# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.0
#
# 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
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _fife
else:
    import _fife

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _fife.SWIG_PyInstanceMethod_New
_swig_new_static_method = _fife.SWIG_PyStaticMethod_New

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_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import weakref

class SwigPyIterator(object):
    thisown = 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
    value = _swig_new_instance_method(_fife.SwigPyIterator_value)
    incr = _swig_new_instance_method(_fife.SwigPyIterator_incr)
    decr = _swig_new_instance_method(_fife.SwigPyIterator_decr)
    distance = _swig_new_instance_method(_fife.SwigPyIterator_distance)
    equal = _swig_new_instance_method(_fife.SwigPyIterator_equal)
    copy = _swig_new_instance_method(_fife.SwigPyIterator_copy)
    next = _swig_new_instance_method(_fife.SwigPyIterator_next)
    __next__ = _swig_new_instance_method(_fife.SwigPyIterator___next__)
    previous = _swig_new_instance_method(_fife.SwigPyIterator_previous)
    advance = _swig_new_instance_method(_fife.SwigPyIterator_advance)
    __eq__ = _swig_new_instance_method(_fife.SwigPyIterator___eq__)
    __ne__ = _swig_new_instance_method(_fife.SwigPyIterator___ne__)
    __iadd__ = _swig_new_instance_method(_fife.SwigPyIterator___iadd__)
    __isub__ = _swig_new_instance_method(_fife.SwigPyIterator___isub__)
    __add__ = _swig_new_instance_method(_fife.SwigPyIterator___add__)
    __sub__ = _swig_new_instance_method(_fife.SwigPyIterator___sub__)
    def __iter__(self):
        return self

# Register SwigPyIterator in _fife:
_fife.SwigPyIterator_swigregister(SwigPyIterator)
import fife.fifechan
class StringVector(object):
    r"""Proxy of C++ std::vector< std::string > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.StringVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.StringVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.StringVector___bool__)
    __len__ = _swig_new_instance_method(_fife.StringVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.StringVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.StringVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.StringVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.StringVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.StringVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.StringVector___setitem__)
    pop = _swig_new_instance_method(_fife.StringVector_pop)
    append = _swig_new_instance_method(_fife.StringVector_append)
    empty = _swig_new_instance_method(_fife.StringVector_empty)
    size = _swig_new_instance_method(_fife.StringVector_size)
    swap = _swig_new_instance_method(_fife.StringVector_swap)
    begin = _swig_new_instance_method(_fife.StringVector_begin)
    end = _swig_new_instance_method(_fife.StringVector_end)
    rbegin = _swig_new_instance_method(_fife.StringVector_rbegin)
    rend = _swig_new_instance_method(_fife.StringVector_rend)
    clear = _swig_new_instance_method(_fife.StringVector_clear)
    get_allocator = _swig_new_instance_method(_fife.StringVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.StringVector_pop_back)
    erase = _swig_new_instance_method(_fife.StringVector_erase)

    def __init__(self, *args):
        r"""
        __init__(StringVector self) -> StringVector
        __init__(StringVector self, StringVector other) -> StringVector
        __init__(StringVector self, std::vector< std::string >::size_type size) -> StringVector
        __init__(StringVector self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> StringVector
        """
        _fife.StringVector_swiginit(self, _fife.new_StringVector(*args))
    push_back = _swig_new_instance_method(_fife.StringVector_push_back)
    front = _swig_new_instance_method(_fife.StringVector_front)
    back = _swig_new_instance_method(_fife.StringVector_back)
    assign = _swig_new_instance_method(_fife.StringVector_assign)
    resize = _swig_new_instance_method(_fife.StringVector_resize)
    insert = _swig_new_instance_method(_fife.StringVector_insert)
    reserve = _swig_new_instance_method(_fife.StringVector_reserve)
    capacity = _swig_new_instance_method(_fife.StringVector_capacity)
    __swig_destroy__ = _fife.delete_StringVector

# Register StringVector in _fife:
_fife.StringVector_swigregister(StringVector)
class UintVector(object):
    r"""Proxy of C++ std::vector< uint32_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.UintVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.UintVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.UintVector___bool__)
    __len__ = _swig_new_instance_method(_fife.UintVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.UintVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.UintVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.UintVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.UintVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.UintVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.UintVector___setitem__)
    pop = _swig_new_instance_method(_fife.UintVector_pop)
    append = _swig_new_instance_method(_fife.UintVector_append)
    empty = _swig_new_instance_method(_fife.UintVector_empty)
    size = _swig_new_instance_method(_fife.UintVector_size)
    swap = _swig_new_instance_method(_fife.UintVector_swap)
    begin = _swig_new_instance_method(_fife.UintVector_begin)
    end = _swig_new_instance_method(_fife.UintVector_end)
    rbegin = _swig_new_instance_method(_fife.UintVector_rbegin)
    rend = _swig_new_instance_method(_fife.UintVector_rend)
    clear = _swig_new_instance_method(_fife.UintVector_clear)
    get_allocator = _swig_new_instance_method(_fife.UintVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.UintVector_pop_back)
    erase = _swig_new_instance_method(_fife.UintVector_erase)

    def __init__(self, *args):
        r"""
        __init__(UintVector self) -> UintVector
        __init__(UintVector self, UintVector other) -> UintVector
        __init__(UintVector self, std::vector< unsigned int >::size_type size) -> UintVector
        __init__(UintVector self, std::vector< unsigned int >::size_type size, std::vector< unsigned int >::value_type const & value) -> UintVector
        """
        _fife.UintVector_swiginit(self, _fife.new_UintVector(*args))
    push_back = _swig_new_instance_method(_fife.UintVector_push_back)
    front = _swig_new_instance_method(_fife.UintVector_front)
    back = _swig_new_instance_method(_fife.UintVector_back)
    assign = _swig_new_instance_method(_fife.UintVector_assign)
    resize = _swig_new_instance_method(_fife.UintVector_resize)
    insert = _swig_new_instance_method(_fife.UintVector_insert)
    reserve = _swig_new_instance_method(_fife.UintVector_reserve)
    capacity = _swig_new_instance_method(_fife.UintVector_capacity)
    __swig_destroy__ = _fife.delete_UintVector

# Register UintVector in _fife:
_fife.UintVector_swigregister(UintVector)
class IntVector(object):
    r"""Proxy of C++ std::vector< int32_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.IntVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.IntVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.IntVector___bool__)
    __len__ = _swig_new_instance_method(_fife.IntVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.IntVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.IntVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.IntVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.IntVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.IntVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.IntVector___setitem__)
    pop = _swig_new_instance_method(_fife.IntVector_pop)
    append = _swig_new_instance_method(_fife.IntVector_append)
    empty = _swig_new_instance_method(_fife.IntVector_empty)
    size = _swig_new_instance_method(_fife.IntVector_size)
    swap = _swig_new_instance_method(_fife.IntVector_swap)
    begin = _swig_new_instance_method(_fife.IntVector_begin)
    end = _swig_new_instance_method(_fife.IntVector_end)
    rbegin = _swig_new_instance_method(_fife.IntVector_rbegin)
    rend = _swig_new_instance_method(_fife.IntVector_rend)
    clear = _swig_new_instance_method(_fife.IntVector_clear)
    get_allocator = _swig_new_instance_method(_fife.IntVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.IntVector_pop_back)
    erase = _swig_new_instance_method(_fife.IntVector_erase)

    def __init__(self, *args):
        r"""
        __init__(IntVector self) -> IntVector
        __init__(IntVector self, IntVector other) -> IntVector
        __init__(IntVector self, std::vector< int >::size_type size) -> IntVector
        __init__(IntVector self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> IntVector
        """
        _fife.IntVector_swiginit(self, _fife.new_IntVector(*args))
    push_back = _swig_new_instance_method(_fife.IntVector_push_back)
    front = _swig_new_instance_method(_fife.IntVector_front)
    back = _swig_new_instance_method(_fife.IntVector_back)
    assign = _swig_new_instance_method(_fife.IntVector_assign)
    resize = _swig_new_instance_method(_fife.IntVector_resize)
    insert = _swig_new_instance_method(_fife.IntVector_insert)
    reserve = _swig_new_instance_method(_fife.IntVector_reserve)
    capacity = _swig_new_instance_method(_fife.IntVector_capacity)
    __swig_destroy__ = _fife.delete_IntVector

# Register IntVector in _fife:
_fife.IntVector_swigregister(IntVector)
class FloatVector(object):
    r"""Proxy of C++ std::vector< float > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.FloatVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.FloatVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.FloatVector___bool__)
    __len__ = _swig_new_instance_method(_fife.FloatVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.FloatVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.FloatVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.FloatVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.FloatVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.FloatVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.FloatVector___setitem__)
    pop = _swig_new_instance_method(_fife.FloatVector_pop)
    append = _swig_new_instance_method(_fife.FloatVector_append)
    empty = _swig_new_instance_method(_fife.FloatVector_empty)
    size = _swig_new_instance_method(_fife.FloatVector_size)
    swap = _swig_new_instance_method(_fife.FloatVector_swap)
    begin = _swig_new_instance_method(_fife.FloatVector_begin)
    end = _swig_new_instance_method(_fife.FloatVector_end)
    rbegin = _swig_new_instance_method(_fife.FloatVector_rbegin)
    rend = _swig_new_instance_method(_fife.FloatVector_rend)
    clear = _swig_new_instance_method(_fife.FloatVector_clear)
    get_allocator = _swig_new_instance_method(_fife.FloatVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.FloatVector_pop_back)
    erase = _swig_new_instance_method(_fife.FloatVector_erase)

    def __init__(self, *args):
        r"""
        __init__(FloatVector self) -> FloatVector
        __init__(FloatVector self, FloatVector other) -> FloatVector
        __init__(FloatVector self, std::vector< float >::size_type size) -> FloatVector
        __init__(FloatVector self, std::vector< float >::size_type size, std::vector< float >::value_type const & value) -> FloatVector
        """
        _fife.FloatVector_swiginit(self, _fife.new_FloatVector(*args))
    push_back = _swig_new_instance_method(_fife.FloatVector_push_back)
    front = _swig_new_instance_method(_fife.FloatVector_front)
    back = _swig_new_instance_method(_fife.FloatVector_back)
    assign = _swig_new_instance_method(_fife.FloatVector_assign)
    resize = _swig_new_instance_method(_fife.FloatVector_resize)
    insert = _swig_new_instance_method(_fife.FloatVector_insert)
    reserve = _swig_new_instance_method(_fife.FloatVector_reserve)
    capacity = _swig_new_instance_method(_fife.FloatVector_capacity)
    __swig_destroy__ = _fife.delete_FloatVector

# Register FloatVector in _fife:
_fife.FloatVector_swigregister(FloatVector)
class DoubleVector(object):
    r"""Proxy of C++ std::vector< double > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.DoubleVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.DoubleVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.DoubleVector___bool__)
    __len__ = _swig_new_instance_method(_fife.DoubleVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.DoubleVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.DoubleVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.DoubleVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.DoubleVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.DoubleVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.DoubleVector___setitem__)
    pop = _swig_new_instance_method(_fife.DoubleVector_pop)
    append = _swig_new_instance_method(_fife.DoubleVector_append)
    empty = _swig_new_instance_method(_fife.DoubleVector_empty)
    size = _swig_new_instance_method(_fife.DoubleVector_size)
    swap = _swig_new_instance_method(_fife.DoubleVector_swap)
    begin = _swig_new_instance_method(_fife.DoubleVector_begin)
    end = _swig_new_instance_method(_fife.DoubleVector_end)
    rbegin = _swig_new_instance_method(_fife.DoubleVector_rbegin)
    rend = _swig_new_instance_method(_fife.DoubleVector_rend)
    clear = _swig_new_instance_method(_fife.DoubleVector_clear)
    get_allocator = _swig_new_instance_method(_fife.DoubleVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.DoubleVector_pop_back)
    erase = _swig_new_instance_method(_fife.DoubleVector_erase)

    def __init__(self, *args):
        r"""
        __init__(DoubleVector self) -> DoubleVector
        __init__(DoubleVector self, DoubleVector other) -> DoubleVector
        __init__(DoubleVector self, std::vector< double >::size_type size) -> DoubleVector
        __init__(DoubleVector self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> DoubleVector
        """
        _fife.DoubleVector_swiginit(self, _fife.new_DoubleVector(*args))
    push_back = _swig_new_instance_method(_fife.DoubleVector_push_back)
    front = _swig_new_instance_method(_fife.DoubleVector_front)
    back = _swig_new_instance_method(_fife.DoubleVector_back)
    assign = _swig_new_instance_method(_fife.DoubleVector_assign)
    resize = _swig_new_instance_method(_fife.DoubleVector_resize)
    insert = _swig_new_instance_method(_fife.DoubleVector_insert)
    reserve = _swig_new_instance_method(_fife.DoubleVector_reserve)
    capacity = _swig_new_instance_method(_fife.DoubleVector_capacity)
    __swig_destroy__ = _fife.delete_DoubleVector

# Register DoubleVector in _fife:
_fife.DoubleVector_swigregister(DoubleVector)
class BoolVector(object):
    r"""Proxy of C++ std::vector< bool > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.BoolVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.BoolVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.BoolVector___bool__)
    __len__ = _swig_new_instance_method(_fife.BoolVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.BoolVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.BoolVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.BoolVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.BoolVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.BoolVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.BoolVector___setitem__)
    pop = _swig_new_instance_method(_fife.BoolVector_pop)
    append = _swig_new_instance_method(_fife.BoolVector_append)
    empty = _swig_new_instance_method(_fife.BoolVector_empty)
    size = _swig_new_instance_method(_fife.BoolVector_size)
    swap = _swig_new_instance_method(_fife.BoolVector_swap)
    begin = _swig_new_instance_method(_fife.BoolVector_begin)
    end = _swig_new_instance_method(_fife.BoolVector_end)
    rbegin = _swig_new_instance_method(_fife.BoolVector_rbegin)
    rend = _swig_new_instance_method(_fife.BoolVector_rend)
    clear = _swig_new_instance_method(_fife.BoolVector_clear)
    get_allocator = _swig_new_instance_method(_fife.BoolVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.BoolVector_pop_back)
    erase = _swig_new_instance_method(_fife.BoolVector_erase)

    def __init__(self, *args):
        r"""
        __init__(BoolVector self) -> BoolVector
        __init__(BoolVector self, BoolVector other) -> BoolVector
        __init__(BoolVector self, std::vector< bool >::size_type size) -> BoolVector
        __init__(BoolVector self, std::vector< bool >::size_type size, std::vector< bool >::value_type value) -> BoolVector
        """
        _fife.BoolVector_swiginit(self, _fife.new_BoolVector(*args))
    push_back = _swig_new_instance_method(_fife.BoolVector_push_back)
    front = _swig_new_instance_method(_fife.BoolVector_front)
    back = _swig_new_instance_method(_fife.BoolVector_back)
    assign = _swig_new_instance_method(_fife.BoolVector_assign)
    resize = _swig_new_instance_method(_fife.BoolVector_resize)
    insert = _swig_new_instance_method(_fife.BoolVector_insert)
    reserve = _swig_new_instance_method(_fife.BoolVector_reserve)
    capacity = _swig_new_instance_method(_fife.BoolVector_capacity)
    __swig_destroy__ = _fife.delete_BoolVector

# Register BoolVector in _fife:
_fife.BoolVector_swigregister(BoolVector)
class Uint16Uint16Pair(object):
    r"""Proxy of C++ std::pair< uint16_t,uint16_t > class."""

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

    def __init__(self, *args):
        r"""
        __init__(Uint16Uint16Pair self) -> Uint16Uint16Pair
        __init__(Uint16Uint16Pair self, unsigned short first, unsigned short second) -> Uint16Uint16Pair
        __init__(Uint16Uint16Pair self, Uint16Uint16Pair other) -> Uint16Uint16Pair
        """
        _fife.Uint16Uint16Pair_swiginit(self, _fife.new_Uint16Uint16Pair(*args))
    first = property(_fife.Uint16Uint16Pair_first_get, _fife.Uint16Uint16Pair_first_set, doc=r"""first : unsigned short""")
    second = property(_fife.Uint16Uint16Pair_second_get, _fife.Uint16Uint16Pair_second_set, doc=r"""second : unsigned short""")
    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

# Register Uint16Uint16Pair in _fife:
_fife.Uint16Uint16Pair_swigregister(Uint16Uint16Pair)
class Uint16Uint16PairVector(object):
    r"""Proxy of C++ std::vector< std::pair< uint16_t,uint16_t > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.Uint16Uint16PairVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.Uint16Uint16PairVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.Uint16Uint16PairVector___bool__)
    __len__ = _swig_new_instance_method(_fife.Uint16Uint16PairVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.Uint16Uint16PairVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.Uint16Uint16PairVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.Uint16Uint16PairVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.Uint16Uint16PairVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.Uint16Uint16PairVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.Uint16Uint16PairVector___setitem__)
    pop = _swig_new_instance_method(_fife.Uint16Uint16PairVector_pop)
    append = _swig_new_instance_method(_fife.Uint16Uint16PairVector_append)
    empty = _swig_new_instance_method(_fife.Uint16Uint16PairVector_empty)
    size = _swig_new_instance_method(_fife.Uint16Uint16PairVector_size)
    swap = _swig_new_instance_method(_fife.Uint16Uint16PairVector_swap)
    begin = _swig_new_instance_method(_fife.Uint16Uint16PairVector_begin)
    end = _swig_new_instance_method(_fife.Uint16Uint16PairVector_end)
    rbegin = _swig_new_instance_method(_fife.Uint16Uint16PairVector_rbegin)
    rend = _swig_new_instance_method(_fife.Uint16Uint16PairVector_rend)
    clear = _swig_new_instance_method(_fife.Uint16Uint16PairVector_clear)
    get_allocator = _swig_new_instance_method(_fife.Uint16Uint16PairVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.Uint16Uint16PairVector_pop_back)
    erase = _swig_new_instance_method(_fife.Uint16Uint16PairVector_erase)

    def __init__(self, *args):
        r"""
        __init__(Uint16Uint16PairVector self) -> Uint16Uint16PairVector
        __init__(Uint16Uint16PairVector self, Uint16Uint16PairVector other) -> Uint16Uint16PairVector
        __init__(Uint16Uint16PairVector self, std::vector< std::pair< unsigned short,unsigned short > >::size_type size) -> Uint16Uint16PairVector
        __init__(Uint16Uint16PairVector self, std::vector< std::pair< unsigned short,unsigned short > >::size_type size, Uint16Uint16Pair value) -> Uint16Uint16PairVector
        """
        _fife.Uint16Uint16PairVector_swiginit(self, _fife.new_Uint16Uint16PairVector(*args))
    push_back = _swig_new_instance_method(_fife.Uint16Uint16PairVector_push_back)
    front = _swig_new_instance_method(_fife.Uint16Uint16PairVector_front)
    back = _swig_new_instance_method(_fife.Uint16Uint16PairVector_back)
    assign = _swig_new_instance_method(_fife.Uint16Uint16PairVector_assign)
    resize = _swig_new_instance_method(_fife.Uint16Uint16PairVector_resize)
    insert = _swig_new_instance_method(_fife.Uint16Uint16PairVector_insert)
    reserve = _swig_new_instance_method(_fife.Uint16Uint16PairVector_reserve)
    capacity = _swig_new_instance_method(_fife.Uint16Uint16PairVector_capacity)
    __swig_destroy__ = _fife.delete_Uint16Uint16PairVector

# Register Uint16Uint16PairVector in _fife:
_fife.Uint16Uint16PairVector_swigregister(Uint16Uint16PairVector)
getVersion = _fife.getVersion
getVersionShort = _fife.getVersionShort
getMajor = _fife.getMajor
getMinor = _fife.getMinor
getPatch = _fife.getPatch
getHash = _fife.getHash
getVersionId = _fife.getVersionId
class Point(object):
    r"""Proxy of C++ FIFE::PointType2D< int32_t > class."""

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

    def __init__(self, *args):
        r"""
        __init__(Point self, int _x=0, int _y=0) -> Point
        __init__(Point self, Point rhs) -> Point
        """
        _fife.Point_swiginit(self, _fife.new_Point(*args))
    __add__ = _swig_new_instance_method(_fife.Point___add__)
    __sub__ = _swig_new_instance_method(_fife.Point___sub__)
    __iadd__ = _swig_new_instance_method(_fife.Point___iadd__)
    __isub__ = _swig_new_instance_method(_fife.Point___isub__)
    __mul__ = _swig_new_instance_method(_fife.Point___mul__)

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


    __eq__ = _swig_new_instance_method(_fife.Point___eq__)
    __ne__ = _swig_new_instance_method(_fife.Point___ne__)
    length = _swig_new_instance_method(_fife.Point_length)
    normalize = _swig_new_instance_method(_fife.Point_normalize)
    rotate = _swig_new_instance_method(_fife.Point_rotate)
    set = _swig_new_instance_method(_fife.Point_set)
    getX = _swig_new_instance_method(_fife.Point_getX)
    getY = _swig_new_instance_method(_fife.Point_getY)
    setX = _swig_new_instance_method(_fife.Point_setX)
    setY = _swig_new_instance_method(_fife.Point_setY)
    __str__ = _swig_new_instance_method(_fife.Point___str__)
    __swig_destroy__ = _fife.delete_Point

# Register Point in _fife:
_fife.Point_swigregister(Point)
class DoublePoint(object):
    r"""Proxy of C++ FIFE::PointType2D< double > class."""

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

    def __init__(self, *args):
        r"""
        __init__(DoublePoint self, double _x=0, double _y=0) -> DoublePoint
        __init__(DoublePoint self, DoublePoint rhs) -> DoublePoint
        """
        _fife.DoublePoint_swiginit(self, _fife.new_DoublePoint(*args))
    __add__ = _swig_new_instance_method(_fife.DoublePoint___add__)
    __sub__ = _swig_new_instance_method(_fife.DoublePoint___sub__)
    __iadd__ = _swig_new_instance_method(_fife.DoublePoint___iadd__)
    __isub__ = _swig_new_instance_method(_fife.DoublePoint___isub__)
    __mul__ = _swig_new_instance_method(_fife.DoublePoint___mul__)

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


    __eq__ = _swig_new_instance_method(_fife.DoublePoint___eq__)
    __ne__ = _swig_new_instance_method(_fife.DoublePoint___ne__)
    length = _swig_new_instance_method(_fife.DoublePoint_length)
    normalize = _swig_new_instance_method(_fife.DoublePoint_normalize)
    rotate = _swig_new_instance_method(_fife.DoublePoint_rotate)
    set = _swig_new_instance_method(_fife.DoublePoint_set)
    getX = _swig_new_instance_method(_fife.DoublePoint_getX)
    getY = _swig_new_instance_method(_fife.DoublePoint_getY)
    setX = _swig_new_instance_method(_fife.DoublePoint_setX)
    setY = _swig_new_instance_method(_fife.DoublePoint_setY)
    __str__ = _swig_new_instance_method(_fife.DoublePoint___str__)
    __swig_destroy__ = _fife.delete_DoublePoint

# Register DoublePoint in _fife:
_fife.DoublePoint_swigregister(DoublePoint)
class Point3D(object):
    r"""Proxy of C++ FIFE::PointType3D< int32_t > class."""

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

    def __init__(self, *args):
        r"""
        __init__(Point3D self, int _x=0, int _y=0, int _z=0) -> Point3D
        __init__(Point3D self, Point3D rhs) -> Point3D
        """
        _fife.Point3D_swiginit(self, _fife.new_Point3D(*args))
    __add__ = _swig_new_instance_method(_fife.Point3D___add__)
    __sub__ = _swig_new_instance_method(_fife.Point3D___sub__)
    __iadd__ = _swig_new_instance_method(_fife.Point3D___iadd__)
    __isub__ = _swig_new_instance_method(_fife.Point3D___isub__)
    __mul__ = _swig_new_instance_method(_fife.Point3D___mul__)

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


    __eq__ = _swig_new_instance_method(_fife.Point3D___eq__)
    __ne__ = _swig_new_instance_method(_fife.Point3D___ne__)
    length = _swig_new_instance_method(_fife.Point3D_length)
    normalize = _swig_new_instance_method(_fife.Point3D_normalize)
    set = _swig_new_instance_method(_fife.Point3D_set)
    __swig_destroy__ = _fife.delete_Point3D

# Register Point3D in _fife:
_fife.Point3D_swigregister(Point3D)
class DoublePoint3D(object):
    r"""Proxy of C++ FIFE::PointType3D< double > class."""

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

    def __init__(self, *args):
        r"""
        __init__(DoublePoint3D self, double _x=0, double _y=0, double _z=0) -> DoublePoint3D
        __init__(DoublePoint3D self, DoublePoint3D rhs) -> DoublePoint3D
        """
        _fife.DoublePoint3D_swiginit(self, _fife.new_DoublePoint3D(*args))
    __add__ = _swig_new_instance_method(_fife.DoublePoint3D___add__)
    __sub__ = _swig_new_instance_method(_fife.DoublePoint3D___sub__)
    __iadd__ = _swig_new_instance_method(_fife.DoublePoint3D___iadd__)
    __isub__ = _swig_new_instance_method(_fife.DoublePoint3D___isub__)
    __mul__ = _swig_new_instance_method(_fife.DoublePoint3D___mul__)

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


    __eq__ = _swig_new_instance_method(_fife.DoublePoint3D___eq__)
    __ne__ = _swig_new_instance_method(_fife.DoublePoint3D___ne__)
    length = _swig_new_instance_method(_fife.DoublePoint3D_length)
    normalize = _swig_new_instance_method(_fife.DoublePoint3D_normalize)
    set = _swig_new_instance_method(_fife.DoublePoint3D_set)
    __swig_destroy__ = _fife.delete_DoublePoint3D

# Register DoublePoint3D in _fife:
_fife.DoublePoint3D_swigregister(DoublePoint3D)
class Rect(object):
    r"""Proxy of C++ FIFE::RectType< int32_t > class."""

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

    def __init__(self, x=0, y=0, width=0, height=0):
        r"""__init__(Rect self, int x=0, int y=0, int width=0, int height=0) -> Rect"""
        _fife.Rect_swiginit(self, _fife.new_Rect(x, y, width, height))
    right = _swig_new_instance_method(_fife.Rect_right)
    bottom = _swig_new_instance_method(_fife.Rect_bottom)
    __eq__ = _swig_new_instance_method(_fife.Rect___eq__)
    contains = _swig_new_instance_method(_fife.Rect_contains)
    intersects = _swig_new_instance_method(_fife.Rect_intersects)
    intersectInplace = _swig_new_instance_method(_fife.Rect_intersectInplace)
    getX = _swig_new_instance_method(_fife.Rect_getX)
    getY = _swig_new_instance_method(_fife.Rect_getY)
    setX = _swig_new_instance_method(_fife.Rect_setX)
    setY = _swig_new_instance_method(_fife.Rect_setY)
    getW = _swig_new_instance_method(_fife.Rect_getW)
    getH = _swig_new_instance_method(_fife.Rect_getH)
    setW = _swig_new_instance_method(_fife.Rect_setW)
    setH = _swig_new_instance_method(_fife.Rect_setH)
    __str__ = _swig_new_instance_method(_fife.Rect___str__)
    __swig_destroy__ = _fife.delete_Rect

# Register Rect in _fife:
_fife.Rect_swigregister(Rect)
class FloatRect(object):
    r"""Proxy of C++ FIFE::RectType< float > class."""

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

    def __init__(self, x=0, y=0, width=0, height=0):
        r"""__init__(FloatRect self, float x=0, float y=0, float width=0, float height=0) -> FloatRect"""
        _fife.FloatRect_swiginit(self, _fife.new_FloatRect(x, y, width, height))
    right = _swig_new_instance_method(_fife.FloatRect_right)
    bottom = _swig_new_instance_method(_fife.FloatRect_bottom)
    __eq__ = _swig_new_instance_method(_fife.FloatRect___eq__)
    contains = _swig_new_instance_method(_fife.FloatRect_contains)
    intersects = _swig_new_instance_method(_fife.FloatRect_intersects)
    intersectInplace = _swig_new_instance_method(_fife.FloatRect_intersectInplace)
    getX = _swig_new_instance_method(_fife.FloatRect_getX)
    getY = _swig_new_instance_method(_fife.FloatRect_getY)
    setX = _swig_new_instance_method(_fife.FloatRect_setX)
    setY = _swig_new_instance_method(_fife.FloatRect_setY)
    getW = _swig_new_instance_method(_fife.FloatRect_getW)
    getH = _swig_new_instance_method(_fife.FloatRect_getH)
    setW = _swig_new_instance_method(_fife.FloatRect_setW)
    setH = _swig_new_instance_method(_fife.FloatRect_setH)
    __str__ = _swig_new_instance_method(_fife.FloatRect___str__)
    __swig_destroy__ = _fife.delete_FloatRect

# Register FloatRect in _fife:
_fife.FloatRect_swigregister(FloatRect)
class DoubleRect(object):
    r"""Proxy of C++ FIFE::RectType< double > class."""

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

    def __init__(self, x=0, y=0, width=0, height=0):
        r"""__init__(DoubleRect self, double x=0, double y=0, double width=0, double height=0) -> DoubleRect"""
        _fife.DoubleRect_swiginit(self, _fife.new_DoubleRect(x, y, width, height))
    right = _swig_new_instance_method(_fife.DoubleRect_right)
    bottom = _swig_new_instance_method(_fife.DoubleRect_bottom)
    __eq__ = _swig_new_instance_method(_fife.DoubleRect___eq__)
    contains = _swig_new_instance_method(_fife.DoubleRect_contains)
    intersects = _swig_new_instance_method(_fife.DoubleRect_intersects)
    intersectInplace = _swig_new_instance_method(_fife.DoubleRect_intersectInplace)
    getX = _swig_new_instance_method(_fife.DoubleRect_getX)
    getY = _swig_new_instance_method(_fife.DoubleRect_getY)
    setX = _swig_new_instance_method(_fife.DoubleRect_setX)
    setY = _swig_new_instance_method(_fife.DoubleRect_setY)
    getW = _swig_new_instance_method(_fife.DoubleRect_getW)
    getH = _swig_new_instance_method(_fife.DoubleRect_getH)
    setW = _swig_new_instance_method(_fife.DoubleRect_setW)
    setH = _swig_new_instance_method(_fife.DoubleRect_setH)
    __str__ = _swig_new_instance_method(_fife.DoubleRect___str__)
    __swig_destroy__ = _fife.delete_DoubleRect

# Register DoubleRect in _fife:
_fife.DoubleRect_swigregister(DoubleRect)
class FifePointVector(object):
    r"""Proxy of C++ std::vector< FIFE::Point > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.FifePointVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.FifePointVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.FifePointVector___bool__)
    __len__ = _swig_new_instance_method(_fife.FifePointVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.FifePointVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.FifePointVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.FifePointVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.FifePointVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.FifePointVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.FifePointVector___setitem__)
    pop = _swig_new_instance_method(_fife.FifePointVector_pop)
    append = _swig_new_instance_method(_fife.FifePointVector_append)
    empty = _swig_new_instance_method(_fife.FifePointVector_empty)
    size = _swig_new_instance_method(_fife.FifePointVector_size)
    swap = _swig_new_instance_method(_fife.FifePointVector_swap)
    begin = _swig_new_instance_method(_fife.FifePointVector_begin)
    end = _swig_new_instance_method(_fife.FifePointVector_end)
    rbegin = _swig_new_instance_method(_fife.FifePointVector_rbegin)
    rend = _swig_new_instance_method(_fife.FifePointVector_rend)
    clear = _swig_new_instance_method(_fife.FifePointVector_clear)
    get_allocator = _swig_new_instance_method(_fife.FifePointVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.FifePointVector_pop_back)
    erase = _swig_new_instance_method(_fife.FifePointVector_erase)

    def __init__(self, *args):
        r"""
        __init__(FifePointVector self) -> FifePointVector
        __init__(FifePointVector self, FifePointVector other) -> FifePointVector
        __init__(FifePointVector self, std::vector< FIFE::PointType2D< int > >::size_type size) -> FifePointVector
        __init__(FifePointVector self, std::vector< FIFE::PointType2D< int > >::size_type size, Point value) -> FifePointVector
        """
        _fife.FifePointVector_swiginit(self, _fife.new_FifePointVector(*args))
    push_back = _swig_new_instance_method(_fife.FifePointVector_push_back)
    front = _swig_new_instance_method(_fife.FifePointVector_front)
    back = _swig_new_instance_method(_fife.FifePointVector_back)
    assign = _swig_new_instance_method(_fife.FifePointVector_assign)
    resize = _swig_new_instance_method(_fife.FifePointVector_resize)
    insert = _swig_new_instance_method(_fife.FifePointVector_insert)
    reserve = _swig_new_instance_method(_fife.FifePointVector_reserve)
    capacity = _swig_new_instance_method(_fife.FifePointVector_capacity)
    __swig_destroy__ = _fife.delete_FifePointVector

# Register FifePointVector in _fife:
_fife.FifePointVector_swigregister(FifePointVector)
class AudioSpaceCoordinate(object):
    r"""Proxy of C++ FIFE::PointType3D< double > class."""

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

    def __init__(self, *args):
        r"""
        __init__(AudioSpaceCoordinate self, double _x=0, double _y=0, double _z=0) -> AudioSpaceCoordinate
        __init__(AudioSpaceCoordinate self, DoublePoint3D rhs) -> AudioSpaceCoordinate
        """
        _fife.AudioSpaceCoordinate_swiginit(self, _fife.new_AudioSpaceCoordinate(*args))
    __add__ = _swig_new_instance_method(_fife.AudioSpaceCoordinate___add__)
    __sub__ = _swig_new_instance_method(_fife.AudioSpaceCoordinate___sub__)
    __iadd__ = _swig_new_instance_method(_fife.AudioSpaceCoordinate___iadd__)
    __isub__ = _swig_new_instance_method(_fife.AudioSpaceCoordinate___isub__)
    __mul__ = _swig_new_instance_method(_fife.AudioSpaceCoordinate___mul__)

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


    __eq__ = _swig_new_instance_method(_fife.AudioSpaceCoordinate___eq__)
    __ne__ = _swig_new_instance_method(_fife.AudioSpaceCoordinate___ne__)
    length = _swig_new_instance_method(_fife.AudioSpaceCoordinate_length)
    normalize = _swig_new_instance_method(_fife.AudioSpaceCoordinate_normalize)
    set = _swig_new_instance_method(_fife.AudioSpaceCoordinate_set)
    __swig_destroy__ = _fife.delete_AudioSpaceCoordinate

# Register AudioSpaceCoordinate in _fife:
_fife.AudioSpaceCoordinate_swigregister(AudioSpaceCoordinate)
class ModelCoordinate(object):
    r"""Proxy of C++ FIFE::PointType3D< int32_t > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ModelCoordinate self, int _x=0, int _y=0, int _z=0) -> ModelCoordinate
        __init__(ModelCoordinate self, Point3D rhs) -> ModelCoordinate
        """
        _fife.ModelCoordinate_swiginit(self, _fife.new_ModelCoordinate(*args))
    __add__ = _swig_new_instance_method(_fife.ModelCoordinate___add__)
    __sub__ = _swig_new_instance_method(_fife.ModelCoordinate___sub__)
    __iadd__ = _swig_new_instance_method(_fife.ModelCoordinate___iadd__)
    __isub__ = _swig_new_instance_method(_fife.ModelCoordinate___isub__)
    __mul__ = _swig_new_instance_method(_fife.ModelCoordinate___mul__)

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


    __eq__ = _swig_new_instance_method(_fife.ModelCoordinate___eq__)
    __ne__ = _swig_new_instance_method(_fife.ModelCoordinate___ne__)
    length = _swig_new_instance_method(_fife.ModelCoordinate_length)
    normalize = _swig_new_instance_method(_fife.ModelCoordinate_normalize)
    set = _swig_new_instance_method(_fife.ModelCoordinate_set)
    __swig_destroy__ = _fife.delete_ModelCoordinate

# Register ModelCoordinate in _fife:
_fife.ModelCoordinate_swigregister(ModelCoordinate)
class ExactModelCoordinate(object):
    r"""Proxy of C++ FIFE::PointType3D< double > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ExactModelCoordinate self, double _x=0, double _y=0, double _z=0) -> ExactModelCoordinate
        __init__(ExactModelCoordinate self, DoublePoint3D rhs) -> ExactModelCoordinate
        """
        _fife.ExactModelCoordinate_swiginit(self, _fife.new_ExactModelCoordinate(*args))
    __add__ = _swig_new_instance_method(_fife.ExactModelCoordinate___add__)
    __sub__ = _swig_new_instance_method(_fife.ExactModelCoordinate___sub__)
    __iadd__ = _swig_new_instance_method(_fife.ExactModelCoordinate___iadd__)
    __isub__ = _swig_new_instance_method(_fife.ExactModelCoordinate___isub__)
    __mul__ = _swig_new_instance_method(_fife.ExactModelCoordinate___mul__)

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


    __eq__ = _swig_new_instance_method(_fife.ExactModelCoordinate___eq__)
    __ne__ = _swig_new_instance_method(_fife.ExactModelCoordinate___ne__)
    length = _swig_new_instance_method(_fife.ExactModelCoordinate_length)
    normalize = _swig_new_instance_method(_fife.ExactModelCoordinate_normalize)
    set = _swig_new_instance_method(_fife.ExactModelCoordinate_set)
    __str__ = _swig_new_instance_method(_fife.ExactModelCoordinate___str__)
    __swig_destroy__ = _fife.delete_ExactModelCoordinate

# Register ExactModelCoordinate in _fife:
_fife.ExactModelCoordinate_swigregister(ExactModelCoordinate)
SE_EFFECT_NULL = _fife.SE_EFFECT_NULL

SE_EFFECT_REVERB = _fife.SE_EFFECT_REVERB

SE_EFFECT_CHORUS = _fife.SE_EFFECT_CHORUS

SE_EFFECT_DISTORTION = _fife.SE_EFFECT_DISTORTION

SE_EFFECT_ECHO = _fife.SE_EFFECT_ECHO

SE_EFFECT_FLANGER = _fife.SE_EFFECT_FLANGER

SE_EFFECT_FREQUENCY_SHIFTER = _fife.SE_EFFECT_FREQUENCY_SHIFTER

SE_EFFECT_VOCAL_MORPHER = _fife.SE_EFFECT_VOCAL_MORPHER

SE_EFFECT_PITCH_SHIFTER = _fife.SE_EFFECT_PITCH_SHIFTER

SE_EFFECT_RING_MODULATOR = _fife.SE_EFFECT_RING_MODULATOR

SE_EFFECT_AUTOWAH = _fife.SE_EFFECT_AUTOWAH

SE_EFFECT_COMPRESSOR = _fife.SE_EFFECT_COMPRESSOR

SE_EFFECT_EQUALIZER = _fife.SE_EFFECT_EQUALIZER

SE_EFFECT_EAXREVERB = _fife.SE_EFFECT_EAXREVERB

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

    thisown = 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
    getEffectType = _swig_new_instance_method(_fife.SoundEffect_getEffectType)
    isEnabled = _swig_new_instance_method(_fife.SoundEffect_isEnabled)
    __swig_destroy__ = _fife.delete_SoundEffect

# Register SoundEffect in _fife:
_fife.SoundEffect_swigregister(SoundEffect)
class Reverb(SoundEffect):
    r"""Proxy of C++ FIFE::Reverb class."""

    thisown = 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
    setDensity = _swig_new_instance_method(_fife.Reverb_setDensity)
    getDensity = _swig_new_instance_method(_fife.Reverb_getDensity)
    setDiffusion = _swig_new_instance_method(_fife.Reverb_setDiffusion)
    getDiffusion = _swig_new_instance_method(_fife.Reverb_getDiffusion)
    setGain = _swig_new_instance_method(_fife.Reverb_setGain)
    getGain = _swig_new_instance_method(_fife.Reverb_getGain)
    setGainHf = _swig_new_instance_method(_fife.Reverb_setGainHf)
    getGainHf = _swig_new_instance_method(_fife.Reverb_getGainHf)
    setDecayTime = _swig_new_instance_method(_fife.Reverb_setDecayTime)
    getDecayTime = _swig_new_instance_method(_fife.Reverb_getDecayTime)
    setDecayHfRatio = _swig_new_instance_method(_fife.Reverb_setDecayHfRatio)
    getDecayHfRatio = _swig_new_instance_method(_fife.Reverb_getDecayHfRatio)
    setReflectionsGain = _swig_new_instance_method(_fife.Reverb_setReflectionsGain)
    getReflectionsGain = _swig_new_instance_method(_fife.Reverb_getReflectionsGain)
    setReflectionsDelay = _swig_new_instance_method(_fife.Reverb_setReflectionsDelay)
    getReflectionsDelay = _swig_new_instance_method(_fife.Reverb_getReflectionsDelay)
    setLateReverbGain = _swig_new_instance_method(_fife.Reverb_setLateReverbGain)
    getLateReverbGain = _swig_new_instance_method(_fife.Reverb_getLateReverbGain)
    setLateReverbDelay = _swig_new_instance_method(_fife.Reverb_setLateReverbDelay)
    getLateReverbDelay = _swig_new_instance_method(_fife.Reverb_getLateReverbDelay)
    setAirAbsorptionGainHf = _swig_new_instance_method(_fife.Reverb_setAirAbsorptionGainHf)
    getAirAbsorptionGainHf = _swig_new_instance_method(_fife.Reverb_getAirAbsorptionGainHf)
    setRoomRolloffFactor = _swig_new_instance_method(_fife.Reverb_setRoomRolloffFactor)
    getRoomRolloffFactor = _swig_new_instance_method(_fife.Reverb_getRoomRolloffFactor)
    setDecayHfLimit = _swig_new_instance_method(_fife.Reverb_setDecayHfLimit)
    isDecayHfLimit = _swig_new_instance_method(_fife.Reverb_isDecayHfLimit)
    __swig_destroy__ = _fife.delete_Reverb

# Register Reverb in _fife:
_fife.Reverb_swigregister(Reverb)
class Chorus(SoundEffect):
    r"""Proxy of C++ FIFE::Chorus class."""

    thisown = 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
    setWaveformTriangle = _swig_new_instance_method(_fife.Chorus_setWaveformTriangle)
    isWaveformTriangle = _swig_new_instance_method(_fife.Chorus_isWaveformTriangle)
    setPhase = _swig_new_instance_method(_fife.Chorus_setPhase)
    getPhase = _swig_new_instance_method(_fife.Chorus_getPhase)
    setRate = _swig_new_instance_method(_fife.Chorus_setRate)
    getRate = _swig_new_instance_method(_fife.Chorus_getRate)
    setDepth = _swig_new_instance_method(_fife.Chorus_setDepth)
    getDepth = _swig_new_instance_method(_fife.Chorus_getDepth)
    setFeedback = _swig_new_instance_method(_fife.Chorus_setFeedback)
    getFeedback = _swig_new_instance_method(_fife.Chorus_getFeedback)
    setDelay = _swig_new_instance_method(_fife.Chorus_setDelay)
    getDelay = _swig_new_instance_method(_fife.Chorus_getDelay)
    __swig_destroy__ = _fife.delete_Chorus

# Register Chorus in _fife:
_fife.Chorus_swigregister(Chorus)
class Distortion(SoundEffect):
    r"""Proxy of C++ FIFE::Distortion class."""

    thisown = 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
    setEdge = _swig_new_instance_method(_fife.Distortion_setEdge)
    getEdge = _swig_new_instance_method(_fife.Distortion_getEdge)
    setGain = _swig_new_instance_method(_fife.Distortion_setGain)
    getGain = _swig_new_instance_method(_fife.Distortion_getGain)
    setLowpassCutoff = _swig_new_instance_method(_fife.Distortion_setLowpassCutoff)
    getLowpassCutoff = _swig_new_instance_method(_fife.Distortion_getLowpassCutoff)
    setEqCenter = _swig_new_instance_method(_fife.Distortion_setEqCenter)
    getEqCenter = _swig_new_instance_method(_fife.Distortion_getEqCenter)
    setEqBandwidth = _swig_new_instance_method(_fife.Distortion_setEqBandwidth)
    getEqBandwidth = _swig_new_instance_method(_fife.Distortion_getEqBandwidth)
    __swig_destroy__ = _fife.delete_Distortion

# Register Distortion in _fife:
_fife.Distortion_swigregister(Distortion)
class Echo(SoundEffect):
    r"""Proxy of C++ FIFE::Echo class."""

    thisown = 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
    setDelay = _swig_new_instance_method(_fife.Echo_setDelay)
    getDelay = _swig_new_instance_method(_fife.Echo_getDelay)
    setLrDelay = _swig_new_instance_method(_fife.Echo_setLrDelay)
    getLrDelay = _swig_new_instance_method(_fife.Echo_getLrDelay)
    setDamping = _swig_new_instance_method(_fife.Echo_setDamping)
    getDamping = _swig_new_instance_method(_fife.Echo_getDamping)
    setFeedback = _swig_new_instance_method(_fife.Echo_setFeedback)
    getFeedback = _swig_new_instance_method(_fife.Echo_getFeedback)
    setSpread = _swig_new_instance_method(_fife.Echo_setSpread)
    getSpread = _swig_new_instance_method(_fife.Echo_getSpread)
    __swig_destroy__ = _fife.delete_Echo

# Register Echo in _fife:
_fife.Echo_swigregister(Echo)
class Flanger(SoundEffect):
    r"""Proxy of C++ FIFE::Flanger class."""

    thisown = 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
    setWaveformTriangle = _swig_new_instance_method(_fife.Flanger_setWaveformTriangle)
    isWaveformTriangle = _swig_new_instance_method(_fife.Flanger_isWaveformTriangle)
    setPhase = _swig_new_instance_method(_fife.Flanger_setPhase)
    getPhase = _swig_new_instance_method(_fife.Flanger_getPhase)
    setRate = _swig_new_instance_method(_fife.Flanger_setRate)
    getRate = _swig_new_instance_method(_fife.Flanger_getRate)
    setDepth = _swig_new_instance_method(_fife.Flanger_setDepth)
    getDepth = _swig_new_instance_method(_fife.Flanger_getDepth)
    setFeedback = _swig_new_instance_method(_fife.Flanger_setFeedback)
    getFeedback = _swig_new_instance_method(_fife.Flanger_getFeedback)
    setDelay = _swig_new_instance_method(_fife.Flanger_setDelay)
    getDelay = _swig_new_instance_method(_fife.Flanger_getDelay)
    __swig_destroy__ = _fife.delete_Flanger

# Register Flanger in _fife:
_fife.Flanger_swigregister(Flanger)
class FrequencyShifter(SoundEffect):
    r"""Proxy of C++ FIFE::FrequencyShifter class."""

    thisown = 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
    setFrequency = _swig_new_instance_method(_fife.FrequencyShifter_setFrequency)
    getFrequency = _swig_new_instance_method(_fife.FrequencyShifter_getFrequency)
    setLeftDirection = _swig_new_instance_method(_fife.FrequencyShifter_setLeftDirection)
    getLeftDirection = _swig_new_instance_method(_fife.FrequencyShifter_getLeftDirection)
    setRightDirection = _swig_new_instance_method(_fife.FrequencyShifter_setRightDirection)
    getRightDirection = _swig_new_instance_method(_fife.FrequencyShifter_getRightDirection)
    __swig_destroy__ = _fife.delete_FrequencyShifter

# Register FrequencyShifter in _fife:
_fife.FrequencyShifter_swigregister(FrequencyShifter)
class VocalMorpher(SoundEffect):
    r"""Proxy of C++ FIFE::VocalMorpher class."""

    thisown = 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
    setPhonemeA = _swig_new_instance_method(_fife.VocalMorpher_setPhonemeA)
    getPhonemeA = _swig_new_instance_method(_fife.VocalMorpher_getPhonemeA)
    setPhonemeB = _swig_new_instance_method(_fife.VocalMorpher_setPhonemeB)
    getPhonemeB = _swig_new_instance_method(_fife.VocalMorpher_getPhonemeB)
    setPhonemeCoarseA = _swig_new_instance_method(_fife.VocalMorpher_setPhonemeCoarseA)
    getPhonemeCoarseA = _swig_new_instance_method(_fife.VocalMorpher_getPhonemeCoarseA)
    setPhonemeCoarseB = _swig_new_instance_method(_fife.VocalMorpher_setPhonemeCoarseB)
    getPhonemeCoarseB = _swig_new_instance_method(_fife.VocalMorpher_getPhonemeCoarseB)
    setWaveform = _swig_new_instance_method(_fife.VocalMorpher_setWaveform)
    getWaveform = _swig_new_instance_method(_fife.VocalMorpher_getWaveform)
    setRate = _swig_new_instance_method(_fife.VocalMorpher_setRate)
    getRate = _swig_new_instance_method(_fife.VocalMorpher_getRate)
    __swig_destroy__ = _fife.delete_VocalMorpher

# Register VocalMorpher in _fife:
_fife.VocalMorpher_swigregister(VocalMorpher)
class PitchShifter(SoundEffect):
    r"""Proxy of C++ FIFE::PitchShifter class."""

    thisown = 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
    setCoarseTune = _swig_new_instance_method(_fife.PitchShifter_setCoarseTune)
    getCoarseTune = _swig_new_instance_method(_fife.PitchShifter_getCoarseTune)
    setFineTune = _swig_new_instance_method(_fife.PitchShifter_setFineTune)
    getFineTune = _swig_new_instance_method(_fife.PitchShifter_getFineTune)
    __swig_destroy__ = _fife.delete_PitchShifter

# Register PitchShifter in _fife:
_fife.PitchShifter_swigregister(PitchShifter)
class RingModulator(SoundEffect):
    r"""Proxy of C++ FIFE::RingModulator class."""

    thisown = 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
    setFrequency = _swig_new_instance_method(_fife.RingModulator_setFrequency)
    getFrequency = _swig_new_instance_method(_fife.RingModulator_getFrequency)
    setHighpassCutoff = _swig_new_instance_method(_fife.RingModulator_setHighpassCutoff)
    getHighpassCutoff = _swig_new_instance_method(_fife.RingModulator_getHighpassCutoff)
    setWaveform = _swig_new_instance_method(_fife.RingModulator_setWaveform)
    getWaveform = _swig_new_instance_method(_fife.RingModulator_getWaveform)
    __swig_destroy__ = _fife.delete_RingModulator

# Register RingModulator in _fife:
_fife.RingModulator_swigregister(RingModulator)
class Autowah(SoundEffect):
    r"""Proxy of C++ FIFE::Autowah class."""

    thisown = 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
    setAttackTime = _swig_new_instance_method(_fife.Autowah_setAttackTime)
    getAttackTime = _swig_new_instance_method(_fife.Autowah_getAttackTime)
    setReleaseTime = _swig_new_instance_method(_fife.Autowah_setReleaseTime)
    getReleaseTime = _swig_new_instance_method(_fife.Autowah_getReleaseTime)
    setResonance = _swig_new_instance_method(_fife.Autowah_setResonance)
    getResonance = _swig_new_instance_method(_fife.Autowah_getResonance)
    setPeakGain = _swig_new_instance_method(_fife.Autowah_setPeakGain)
    getPeakGain = _swig_new_instance_method(_fife.Autowah_getPeakGain)
    __swig_destroy__ = _fife.delete_Autowah

# Register Autowah in _fife:
_fife.Autowah_swigregister(Autowah)
class Compressor(SoundEffect):
    r"""Proxy of C++ FIFE::Compressor class."""

    thisown = 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
    setCompressor = _swig_new_instance_method(_fife.Compressor_setCompressor)
    isCompressor = _swig_new_instance_method(_fife.Compressor_isCompressor)
    __swig_destroy__ = _fife.delete_Compressor

# Register Compressor in _fife:
_fife.Compressor_swigregister(Compressor)
class Equalizer(SoundEffect):
    r"""Proxy of C++ FIFE::Equalizer class."""

    thisown = 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
    setLowGain = _swig_new_instance_method(_fife.Equalizer_setLowGain)
    getLowGain = _swig_new_instance_method(_fife.Equalizer_getLowGain)
    setLowCutoff = _swig_new_instance_method(_fife.Equalizer_setLowCutoff)
    getLowCutoff = _swig_new_instance_method(_fife.Equalizer_getLowCutoff)
    setMid1Gain = _swig_new_instance_method(_fife.Equalizer_setMid1Gain)
    getMid1Gain = _swig_new_instance_method(_fife.Equalizer_getMid1Gain)
    setMid1Center = _swig_new_instance_method(_fife.Equalizer_setMid1Center)
    getMid1Center = _swig_new_instance_method(_fife.Equalizer_getMid1Center)
    setMid1Width = _swig_new_instance_method(_fife.Equalizer_setMid1Width)
    getMid1Width = _swig_new_instance_method(_fife.Equalizer_getMid1Width)
    setMid2Gain = _swig_new_instance_method(_fife.Equalizer_setMid2Gain)
    getMid2Gain = _swig_new_instance_method(_fife.Equalizer_getMid2Gain)
    setMid2Center = _swig_new_instance_method(_fife.Equalizer_setMid2Center)
    getMid2Center = _swig_new_instance_method(_fife.Equalizer_getMid2Center)
    setMid2Width = _swig_new_instance_method(_fife.Equalizer_setMid2Width)
    getMid2Width = _swig_new_instance_method(_fife.Equalizer_getMid2Width)
    setHighGain = _swig_new_instance_method(_fife.Equalizer_setHighGain)
    getHighGain = _swig_new_instance_method(_fife.Equalizer_getHighGain)
    setHighCutoff = _swig_new_instance_method(_fife.Equalizer_setHighCutoff)
    getHighCutoff = _swig_new_instance_method(_fife.Equalizer_getHighCutoff)
    __swig_destroy__ = _fife.delete_Equalizer

# Register Equalizer in _fife:
_fife.Equalizer_swigregister(Equalizer)
class EaxReverb(SoundEffect):
    r"""Proxy of C++ FIFE::EaxReverb class."""

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

# Register EaxReverb in _fife:
_fife.EaxReverb_swigregister(EaxReverb)
SF_FILTER_NULL = _fife.SF_FILTER_NULL

SF_FILTER_LOWPASS = _fife.SF_FILTER_LOWPASS

SF_FILTER_HIGHPASS = _fife.SF_FILTER_HIGHPASS

SF_FILTER_BANDPASS = _fife.SF_FILTER_BANDPASS

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

    thisown = 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
    getFilterType = _swig_new_instance_method(_fife.SoundFilter_getFilterType)
    isEnabled = _swig_new_instance_method(_fife.SoundFilter_isEnabled)
    setGain = _swig_new_instance_method(_fife.SoundFilter_setGain)
    getGain = _swig_new_instance_method(_fife.SoundFilter_getGain)
    setGainHf = _swig_new_instance_method(_fife.SoundFilter_setGainHf)
    getGainHf = _swig_new_instance_method(_fife.SoundFilter_getGainHf)
    setGainLf = _swig_new_instance_method(_fife.SoundFilter_setGainLf)
    getGainLf = _swig_new_instance_method(_fife.SoundFilter_getGainLf)
    __swig_destroy__ = _fife.delete_SoundFilter

# Register SoundFilter in _fife:
_fife.SoundFilter_swigregister(SoundFilter)
class IResourceLoader(object):
    r"""Proxy of C++ FIFE::IResourceLoader class."""

    thisown = 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
    load = _swig_new_instance_method(_fife.IResourceLoader_load)

# Register IResourceLoader in _fife:
_fife.IResourceLoader_swigregister(IResourceLoader)
class IResource(object):
    r"""Proxy of C++ FIFE::IResource class."""

    thisown = 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
    getName = _swig_new_instance_method(_fife.IResource_getName)
    getHandle = _swig_new_instance_method(_fife.IResource_getHandle)
    getState = _swig_new_instance_method(_fife.IResource_getState)
    setState = _swig_new_instance_method(_fife.IResource_setState)
    getSize = _swig_new_instance_method(_fife.IResource_getSize)
    load = _swig_new_instance_method(_fife.IResource_load)
    free = _swig_new_instance_method(_fife.IResource_free)

# Register IResource in _fife:
_fife.IResource_swigregister(IResource)
class SharedResourcePointer(object):
    r"""Proxy of C++ FIFE::SharedPtr< FIFE::IResource > class."""

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

    def __init__(self, *args):
        r"""
        __init__(SharedResourcePointer self) -> SharedResourcePointer
        __init__(SharedResourcePointer self, SharedResourcePointer rhs) -> SharedResourcePointer
        """
        _fife.SharedResourcePointer_swiginit(self, _fife.new_SharedResourcePointer(*args))
    __swig_destroy__ = _fife.delete_SharedResourcePointer
    __ref__ = _swig_new_instance_method(_fife.SharedResourcePointer___ref__)
    __deref__ = _swig_new_instance_method(_fife.SharedResourcePointer___deref__)
    get = _swig_new_instance_method(_fife.SharedResourcePointer_get)
    reset = _swig_new_instance_method(_fife.SharedResourcePointer_reset)
    useCount = _swig_new_instance_method(_fife.SharedResourcePointer_useCount)
    useCountPtr = _swig_new_instance_method(_fife.SharedResourcePointer_useCountPtr)
    unique = _swig_new_instance_method(_fife.SharedResourcePointer_unique)

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


    getName = _swig_new_instance_method(_fife.SharedResourcePointer_getName)
    getHandle = _swig_new_instance_method(_fife.SharedResourcePointer_getHandle)
    getState = _swig_new_instance_method(_fife.SharedResourcePointer_getState)
    setState = _swig_new_instance_method(_fife.SharedResourcePointer_setState)
    getSize = _swig_new_instance_method(_fife.SharedResourcePointer_getSize)
    load = _swig_new_instance_method(_fife.SharedResourcePointer_load)
    free = _swig_new_instance_method(_fife.SharedResourcePointer_free)

# Register SharedResourcePointer in _fife:
_fife.SharedResourcePointer_swigregister(SharedResourcePointer)
class IResourceManager(object):
    r"""Proxy of C++ FIFE::IResourceManager class."""

    thisown = 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
    getMemoryUsed = _swig_new_instance_method(_fife.IResourceManager_getMemoryUsed)
    getTotalResourcesCreated = _swig_new_instance_method(_fife.IResourceManager_getTotalResourcesCreated)
    getTotalResourcesLoaded = _swig_new_instance_method(_fife.IResourceManager_getTotalResourcesLoaded)
    getTotalResources = _swig_new_instance_method(_fife.IResourceManager_getTotalResources)
    __swig_destroy__ = _fife.delete_IResourceManager

# Register IResourceManager in _fife:
_fife.IResourceManager_swigregister(IResourceManager)
class SoundClip(IResource):
    r"""Proxy of C++ FIFE::SoundClip class."""

    thisown = 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
    isStream = _swig_new_instance_method(_fife.SoundClip_isStream)

# Register SoundClip in _fife:
_fife.SoundClip_swigregister(SoundClip)
class SharedSoundClipPointer(object):
    r"""Proxy of C++ FIFE::SharedPtr< FIFE::SoundClip > class."""

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

    def __init__(self, *args):
        r"""
        __init__(SharedSoundClipPointer self) -> SharedSoundClipPointer
        __init__(SharedSoundClipPointer self, SharedSoundClipPointer rhs) -> SharedSoundClipPointer
        """
        _fife.SharedSoundClipPointer_swiginit(self, _fife.new_SharedSoundClipPointer(*args))
    __swig_destroy__ = _fife.delete_SharedSoundClipPointer
    __ref__ = _swig_new_instance_method(_fife.SharedSoundClipPointer___ref__)
    __deref__ = _swig_new_instance_method(_fife.SharedSoundClipPointer___deref__)
    get = _swig_new_instance_method(_fife.SharedSoundClipPointer_get)
    reset = _swig_new_instance_method(_fife.SharedSoundClipPointer_reset)
    useCount = _swig_new_instance_method(_fife.SharedSoundClipPointer_useCount)
    useCountPtr = _swig_new_instance_method(_fife.SharedSoundClipPointer_useCountPtr)
    unique = _swig_new_instance_method(_fife.SharedSoundClipPointer_unique)

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


    isStream = _swig_new_instance_method(_fife.SharedSoundClipPointer_isStream)
    getName = _swig_new_instance_method(_fife.SharedSoundClipPointer_getName)
    getHandle = _swig_new_instance_method(_fife.SharedSoundClipPointer_getHandle)
    getState = _swig_new_instance_method(_fife.SharedSoundClipPointer_getState)
    setState = _swig_new_instance_method(_fife.SharedSoundClipPointer_setState)
    getSize = _swig_new_instance_method(_fife.SharedSoundClipPointer_getSize)
    load = _swig_new_instance_method(_fife.SharedSoundClipPointer_load)
    free = _swig_new_instance_method(_fife.SharedSoundClipPointer_free)

# Register SharedSoundClipPointer in _fife:
_fife.SharedSoundClipPointer_swigregister(SharedSoundClipPointer)
class SoundClipManager(IResourceManager):
    r"""Proxy of C++ FIFE::SoundClipManager class."""

    thisown = 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
    getMemoryUsed = _swig_new_instance_method(_fife.SoundClipManager_getMemoryUsed)
    getTotalResourcesCreated = _swig_new_instance_method(_fife.SoundClipManager_getTotalResourcesCreated)
    getTotalResourcesLoaded = _swig_new_instance_method(_fife.SoundClipManager_getTotalResourcesLoaded)
    getTotalResources = _swig_new_instance_method(_fife.SoundClipManager_getTotalResources)
    create = _swig_new_instance_method(_fife.SoundClipManager_create)
    load = _swig_new_instance_method(_fife.SoundClipManager_load)
    add = _swig_new_instance_method(_fife.SoundClipManager_add)
    exists = _swig_new_instance_method(_fife.SoundClipManager_exists)
    reload = _swig_new_instance_method(_fife.SoundClipManager_reload)
    reloadAll = _swig_new_instance_method(_fife.SoundClipManager_reloadAll)
    loadUnreferenced = _swig_new_instance_method(_fife.SoundClipManager_loadUnreferenced)
    free = _swig_new_instance_method(_fife.SoundClipManager_free)
    freeAll = _swig_new_instance_method(_fife.SoundClipManager_freeAll)
    freeUnreferenced = _swig_new_instance_method(_fife.SoundClipManager_freeUnreferenced)
    remove = _swig_new_instance_method(_fife.SoundClipManager_remove)
    removeAll = _swig_new_instance_method(_fife.SoundClipManager_removeAll)
    removeUnreferenced = _swig_new_instance_method(_fife.SoundClipManager_removeUnreferenced)
    get = _swig_new_instance_method(_fife.SoundClipManager_get)
    getResourceHandle = _swig_new_instance_method(_fife.SoundClipManager_getResourceHandle)

    def __init__(self):
        r"""__init__(SoundClipManager self) -> SoundClipManager"""
        _fife.SoundClipManager_swiginit(self, _fife.new_SoundClipManager())

# Register SoundClipManager in _fife:
_fife.SoundClipManager_swigregister(SoundClipManager)
class SoundEmitterListener(object):
    r"""Proxy of C++ FIFE::SoundEmitterListener class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_SoundEmitterListener
    onSoundFinished = _swig_new_instance_method(_fife.SoundEmitterListener_onSoundFinished)

    def __init__(self):
        r"""__init__(SoundEmitterListener self) -> SoundEmitterListener"""
        if self.__class__ == SoundEmitterListener:
            _self = None
        else:
            _self = self
        _fife.SoundEmitterListener_swiginit(self, _fife.new_SoundEmitterListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_SoundEmitterListener(self)
        return weakref.proxy(self)

# Register SoundEmitterListener in _fife:
_fife.SoundEmitterListener_swigregister(SoundEmitterListener)
SD_SAMPLE_POS = _fife.SD_SAMPLE_POS

SD_TIME_POS = _fife.SD_TIME_POS

SD_BYTE_POS = _fife.SD_BYTE_POS

SD_UNKNOWN_STATE = _fife.SD_UNKNOWN_STATE

SD_INITIAL_STATE = _fife.SD_INITIAL_STATE

SD_PLAYING_STATE = _fife.SD_PLAYING_STATE

SD_PAUSED_STATE = _fife.SD_PAUSED_STATE

SD_STOPPED_STATE = _fife.SD_STOPPED_STATE

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

    thisown = 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
    getId = _swig_new_instance_method(_fife.SoundEmitter_getId)
    isActive = _swig_new_instance_method(_fife.SoundEmitter_isActive)
    getEffectCount = _swig_new_instance_method(_fife.SoundEmitter_getEffectCount)
    setSoundClip = _swig_new_instance_method(_fife.SoundEmitter_setSoundClip)
    getSoundClip = _swig_new_instance_method(_fife.SoundEmitter_getSoundClip)
    reset = _swig_new_instance_method(_fife.SoundEmitter_reset)
    release = _swig_new_instance_method(_fife.SoundEmitter_release)
    play = _swig_new_instance_method(_fife.SoundEmitter_play)
    pause = _swig_new_instance_method(_fife.SoundEmitter_pause)
    stop = _swig_new_instance_method(_fife.SoundEmitter_stop)
    rewind = _swig_new_instance_method(_fife.SoundEmitter_rewind)
    setGain = _swig_new_instance_method(_fife.SoundEmitter_setGain)
    getGain = _swig_new_instance_method(_fife.SoundEmitter_getGain)
    setMaxGain = _swig_new_instance_method(_fife.SoundEmitter_setMaxGain)
    getMaxGain = _swig_new_instance_method(_fife.SoundEmitter_getMaxGain)
    setMinGain = _swig_new_instance_method(_fife.SoundEmitter_setMinGain)
    getMinGain = _swig_new_instance_method(_fife.SoundEmitter_getMinGain)
    setLooping = _swig_new_instance_method(_fife.SoundEmitter_setLooping)
    isLooping = _swig_new_instance_method(_fife.SoundEmitter_isLooping)
    setRolloff = _swig_new_instance_method(_fife.SoundEmitter_setRolloff)
    getRolloff = _swig_new_instance_method(_fife.SoundEmitter_getRolloff)
    setRelativePositioning = _swig_new_instance_method(_fife.SoundEmitter_setRelativePositioning)
    isRelativePositioning = _swig_new_instance_method(_fife.SoundEmitter_isRelativePositioning)
    setPosition = _swig_new_instance_method(_fife.SoundEmitter_setPosition)
    getPosition = _swig_new_instance_method(_fife.SoundEmitter_getPosition)
    setReferenceDistance = _swig_new_instance_method(_fife.SoundEmitter_setReferenceDistance)
    getReferenceDistance = _swig_new_instance_method(_fife.SoundEmitter_getReferenceDistance)
    setMaxDistance = _swig_new_instance_method(_fife.SoundEmitter_setMaxDistance)
    getMaxDistance = _swig_new_instance_method(_fife.SoundEmitter_getMaxDistance)
    setDirection = _swig_new_instance_method(_fife.SoundEmitter_setDirection)
    getDirection = _swig_new_instance_method(_fife.SoundEmitter_getDirection)
    setVelocity = _swig_new_instance_method(_fife.SoundEmitter_setVelocity)
    getVelocity = _swig_new_instance_method(_fife.SoundEmitter_getVelocity)
    setPitch = _swig_new_instance_method(_fife.SoundEmitter_setPitch)
    getPitch = _swig_new_instance_method(_fife.SoundEmitter_getPitch)
    setConeInnerAngle = _swig_new_instance_method(_fife.SoundEmitter_setConeInnerAngle)
    getConeInnerAngle = _swig_new_instance_method(_fife.SoundEmitter_getConeInnerAngle)
    setConeOuterAngle = _swig_new_instance_method(_fife.SoundEmitter_setConeOuterAngle)
    getConeOuterAngle = _swig_new_instance_method(_fife.SoundEmitter_getConeOuterAngle)
    setConeOuterGain = _swig_new_instance_method(_fife.SoundEmitter_setConeOuterGain)
    getConeOuterGain = _swig_new_instance_method(_fife.SoundEmitter_getConeOuterGain)
    isStereo = _swig_new_instance_method(_fife.SoundEmitter_isStereo)
    getBitResolution = _swig_new_instance_method(_fife.SoundEmitter_getBitResolution)
    getSampleRate = _swig_new_instance_method(_fife.SoundEmitter_getSampleRate)
    getDecodedLength = _swig_new_instance_method(_fife.SoundEmitter_getDecodedLength)
    getDuration = _swig_new_instance_method(_fife.SoundEmitter_getDuration)
    setCursor = _swig_new_instance_method(_fife.SoundEmitter_setCursor)
    getCursor = _swig_new_instance_method(_fife.SoundEmitter_getCursor)
    getState = _swig_new_instance_method(_fife.SoundEmitter_getState)
    setGroup = _swig_new_instance_method(_fife.SoundEmitter_setGroup)
    getGroup = _swig_new_instance_method(_fife.SoundEmitter_getGroup)
    addListener = _swig_new_instance_method(_fife.SoundEmitter_addListener)
    removeListener = _swig_new_instance_method(_fife.SoundEmitter_removeListener)
    __swig_destroy__ = _fife.delete_SoundEmitter

# Register SoundEmitter in _fife:
_fife.SoundEmitter_swigregister(SoundEmitter)
SD_DISTANCE_NONE = _fife.SD_DISTANCE_NONE

SD_DISTANCE_INVERSE = _fife.SD_DISTANCE_INVERSE

SD_DISTANCE_INVERSE_CLAMPED = _fife.SD_DISTANCE_INVERSE_CLAMPED

SD_DISTANCE_LINEAR = _fife.SD_DISTANCE_LINEAR

SD_DISTANCE_LINEAR_CLAMPED = _fife.SD_DISTANCE_LINEAR_CLAMPED

SD_DISTANCE_EXPONENT = _fife.SD_DISTANCE_EXPONENT

SD_DISTANCE_EXPONENT_CLAMPED = _fife.SD_DISTANCE_EXPONENT_CLAMPED

SE_PRESET_GENERIC = _fife.SE_PRESET_GENERIC

SE_PRESET_PADDEDCELL = _fife.SE_PRESET_PADDEDCELL

SE_PRESET_ROOM = _fife.SE_PRESET_ROOM

SE_PRESET_BATHROOM = _fife.SE_PRESET_BATHROOM

SE_PRESET_LIVINGROOM = _fife.SE_PRESET_LIVINGROOM

SE_PRESET_STONEROOM = _fife.SE_PRESET_STONEROOM

SE_PRESET_AUDITORIUM = _fife.SE_PRESET_AUDITORIUM

SE_PRESET_CONCERTHALL = _fife.SE_PRESET_CONCERTHALL

SE_PRESET_CAVE = _fife.SE_PRESET_CAVE

SE_PRESET_ARENA = _fife.SE_PRESET_ARENA

SE_PRESET_HANGAR = _fife.SE_PRESET_HANGAR

SE_PRESET_CARPETEDHALLWAY = _fife.SE_PRESET_CARPETEDHALLWAY

SE_PRESET_HALLWAY = _fife.SE_PRESET_HALLWAY

SE_PRESET_STONECORRIDOR = _fife.SE_PRESET_STONECORRIDOR

SE_PRESET_ALLEY = _fife.SE_PRESET_ALLEY

SE_PRESET_FOREST = _fife.SE_PRESET_FOREST

SE_PRESET_CITY = _fife.SE_PRESET_CITY

SE_PRESET_MOUNTAINS = _fife.SE_PRESET_MOUNTAINS

SE_PRESET_QUARRY = _fife.SE_PRESET_QUARRY

SE_PRESET_PLAIN = _fife.SE_PRESET_PLAIN

SE_PRESET_PARKINGLOT = _fife.SE_PRESET_PARKINGLOT

SE_PRESET_SEWERPIPE = _fife.SE_PRESET_SEWERPIPE

SE_PRESET_UNDERWATER = _fife.SE_PRESET_UNDERWATER

SE_PRESET_DRUGGED = _fife.SE_PRESET_DRUGGED

SE_PRESET_DIZZY = _fife.SE_PRESET_DIZZY

SE_PRESET_PSYCHOTIC = _fife.SE_PRESET_PSYCHOTIC

SE_PRESET_CASTLE_SMALLROOM = _fife.SE_PRESET_CASTLE_SMALLROOM

SE_PRESET_CASTLE_SHORTPASSAGE = _fife.SE_PRESET_CASTLE_SHORTPASSAGE

SE_PRESET_CASTLE_MEDIUMROOM = _fife.SE_PRESET_CASTLE_MEDIUMROOM

SE_PRESET_CASTLE_LARGEROOM = _fife.SE_PRESET_CASTLE_LARGEROOM

SE_PRESET_CASTLE_LONGPASSAGE = _fife.SE_PRESET_CASTLE_LONGPASSAGE

SE_PRESET_CASTLE_HALL = _fife.SE_PRESET_CASTLE_HALL

SE_PRESET_CASTLE_CUPBOARD = _fife.SE_PRESET_CASTLE_CUPBOARD

SE_PRESET_CASTLE_COURTYARD = _fife.SE_PRESET_CASTLE_COURTYARD

SE_PRESET_CASTLE_ALCOVE = _fife.SE_PRESET_CASTLE_ALCOVE

SE_PRESET_FACTORY_SMALLROOM = _fife.SE_PRESET_FACTORY_SMALLROOM

SE_PRESET_FACTORY_SHORTPASSAGE = _fife.SE_PRESET_FACTORY_SHORTPASSAGE

SE_PRESET_FACTORY_MEDIUMROOM = _fife.SE_PRESET_FACTORY_MEDIUMROOM

SE_PRESET_FACTORY_LARGEROOM = _fife.SE_PRESET_FACTORY_LARGEROOM

SE_PRESET_FACTORY_LONGPASSAGE = _fife.SE_PRESET_FACTORY_LONGPASSAGE

SE_PRESET_FACTORY_HALL = _fife.SE_PRESET_FACTORY_HALL

SE_PRESET_FACTORY_CUPBOARD = _fife.SE_PRESET_FACTORY_CUPBOARD

SE_PRESET_FACTORY_COURTYARD = _fife.SE_PRESET_FACTORY_COURTYARD

SE_PRESET_FACTORY_ALCOVE = _fife.SE_PRESET_FACTORY_ALCOVE

SE_PRESET_ICEPALACE_SMALLROOM = _fife.SE_PRESET_ICEPALACE_SMALLROOM

SE_PRESET_ICEPALACE_SHORTPASSAGE = _fife.SE_PRESET_ICEPALACE_SHORTPASSAGE

SE_PRESET_ICEPALACE_MEDIUMROOM = _fife.SE_PRESET_ICEPALACE_MEDIUMROOM

SE_PRESET_ICEPALACE_LARGEROOM = _fife.SE_PRESET_ICEPALACE_LARGEROOM

SE_PRESET_ICEPALACE_LONGPASSAGE = _fife.SE_PRESET_ICEPALACE_LONGPASSAGE

SE_PRESET_ICEPALACE_HALL = _fife.SE_PRESET_ICEPALACE_HALL

SE_PRESET_ICEPALACE_CUPBOARD = _fife.SE_PRESET_ICEPALACE_CUPBOARD

SE_PRESET_ICEPALACE_COURTYARD = _fife.SE_PRESET_ICEPALACE_COURTYARD

SE_PRESET_ICEPALACE_ALCOVE = _fife.SE_PRESET_ICEPALACE_ALCOVE

SE_PRESET_SPACESTATION_SMALLROOM = _fife.SE_PRESET_SPACESTATION_SMALLROOM

SE_PRESET_SPACESTATION_SHORTPASSAGE = _fife.SE_PRESET_SPACESTATION_SHORTPASSAGE

SE_PRESET_SPACESTATION_MEDIUMROOM = _fife.SE_PRESET_SPACESTATION_MEDIUMROOM

SE_PRESET_SPACESTATION_LARGEROOM = _fife.SE_PRESET_SPACESTATION_LARGEROOM

SE_PRESET_SPACESTATION_LONGPASSAGE = _fife.SE_PRESET_SPACESTATION_LONGPASSAGE

SE_PRESET_SPACESTATION_HALL = _fife.SE_PRESET_SPACESTATION_HALL

SE_PRESET_SPACESTATION_CUPBOARD = _fife.SE_PRESET_SPACESTATION_CUPBOARD

SE_PRESET_SPACESTATION_ALCOVE = _fife.SE_PRESET_SPACESTATION_ALCOVE

SE_PRESET_WOODEN_SMALLROOM = _fife.SE_PRESET_WOODEN_SMALLROOM

SE_PRESET_WOODEN_SHORTPASSAGE = _fife.SE_PRESET_WOODEN_SHORTPASSAGE

SE_PRESET_WOODEN_MEDIUMROOM = _fife.SE_PRESET_WOODEN_MEDIUMROOM

SE_PRESET_WOODEN_LARGEROOM = _fife.SE_PRESET_WOODEN_LARGEROOM

SE_PRESET_WOODEN_LONGPASSAGE = _fife.SE_PRESET_WOODEN_LONGPASSAGE

SE_PRESET_WOODEN_HALL = _fife.SE_PRESET_WOODEN_HALL

SE_PRESET_WOODEN_CUPBOARD = _fife.SE_PRESET_WOODEN_CUPBOARD

SE_PRESET_WOODEN_COURTYARD = _fife.SE_PRESET_WOODEN_COURTYARD

SE_PRESET_WOODEN_ALCOVE = _fife.SE_PRESET_WOODEN_ALCOVE

SE_PRESET_SPORT_EMPTYSTADIUM = _fife.SE_PRESET_SPORT_EMPTYSTADIUM

SE_PRESET_SPORT_SQUASHCOURT = _fife.SE_PRESET_SPORT_SQUASHCOURT

SE_PRESET_SPORT_SMALLSWIMMINGPOOL = _fife.SE_PRESET_SPORT_SMALLSWIMMINGPOOL

SE_PRESET_SPORT_LARGESWIMMINGPOOL = _fife.SE_PRESET_SPORT_LARGESWIMMINGPOOL

SE_PRESET_SPORT_GYMNASIUM = _fife.SE_PRESET_SPORT_GYMNASIUM

SE_PRESET_SPORT_FULLSTADIUM = _fife.SE_PRESET_SPORT_FULLSTADIUM

SE_PRESET_SPORT_STADIUMTANNOY = _fife.SE_PRESET_SPORT_STADIUMTANNOY

SE_PRESET_PREFAB_WORKSHOP = _fife.SE_PRESET_PREFAB_WORKSHOP

SE_PRESET_PREFAB_SCHOOLROOM = _fife.SE_PRESET_PREFAB_SCHOOLROOM

SE_PRESET_PREFAB_PRACTISEROOM = _fife.SE_PRESET_PREFAB_PRACTISEROOM

SE_PRESET_PREFAB_OUTHOUSE = _fife.SE_PRESET_PREFAB_OUTHOUSE

SE_PRESET_PREFAB_CARAVAN = _fife.SE_PRESET_PREFAB_CARAVAN

SE_PRESET_DOME_TOMB = _fife.SE_PRESET_DOME_TOMB

SE_PRESET_PIPE_SMALL = _fife.SE_PRESET_PIPE_SMALL

SE_PRESET_DOME_SAINTPAULS = _fife.SE_PRESET_DOME_SAINTPAULS

SE_PRESET_PIPE_LONGTHIN = _fife.SE_PRESET_PIPE_LONGTHIN

SE_PRESET_PIPE_LARGE = _fife.SE_PRESET_PIPE_LARGE

SE_PRESET_PIPE_RESONANT = _fife.SE_PRESET_PIPE_RESONANT

SE_PRESET_OUTDOORS_BACKYARD = _fife.SE_PRESET_OUTDOORS_BACKYARD

SE_PRESET_OUTDOORS_ROLLINGPLAINS = _fife.SE_PRESET_OUTDOORS_ROLLINGPLAINS

SE_PRESET_OUTDOORS_DEEPCANYON = _fife.SE_PRESET_OUTDOORS_DEEPCANYON

SE_PRESET_OUTDOORS_CREEK = _fife.SE_PRESET_OUTDOORS_CREEK

SE_PRESET_OUTDOORS_VALLEY = _fife.SE_PRESET_OUTDOORS_VALLEY

SE_PRESET_MOOD_HEAVEN = _fife.SE_PRESET_MOOD_HEAVEN

SE_PRESET_MOOD_HELL = _fife.SE_PRESET_MOOD_HELL

SE_PRESET_MOOD_MEMORY = _fife.SE_PRESET_MOOD_MEMORY

SE_PRESET_DRIVING_COMMENTATOR = _fife.SE_PRESET_DRIVING_COMMENTATOR

SE_PRESET_DRIVING_PITGARAGE = _fife.SE_PRESET_DRIVING_PITGARAGE

SE_PRESET_DRIVING_INCAR_RACER = _fife.SE_PRESET_DRIVING_INCAR_RACER

SE_PRESET_DRIVING_INCAR_SPORTS = _fife.SE_PRESET_DRIVING_INCAR_SPORTS

SE_PRESET_DRIVING_INCAR_LUXURY = _fife.SE_PRESET_DRIVING_INCAR_LUXURY

SE_PRESET_DRIVING_FULLGRANDSTAND = _fife.SE_PRESET_DRIVING_FULLGRANDSTAND

SE_PRESET_DRIVING_EMPTYGRANDSTAND = _fife.SE_PRESET_DRIVING_EMPTYGRANDSTAND

SE_PRESET_DRIVING_TUNNEL = _fife.SE_PRESET_DRIVING_TUNNEL

SE_PRESET_CITY_STREETS = _fife.SE_PRESET_CITY_STREETS

SE_PRESET_CITY_SUBWAY = _fife.SE_PRESET_CITY_SUBWAY

SE_PRESET_CITY_MUSEUM = _fife.SE_PRESET_CITY_MUSEUM

SE_PRESET_CITY_LIBRARY = _fife.SE_PRESET_CITY_LIBRARY

SE_PRESET_CITY_UNDERPASS = _fife.SE_PRESET_CITY_UNDERPASS

SE_PRESET_CITY_ABANDONED = _fife.SE_PRESET_CITY_ABANDONED

SE_PRESET_DUSTYROOM = _fife.SE_PRESET_DUSTYROOM

SE_PRESET_CHAPEL = _fife.SE_PRESET_CHAPEL

SE_PRESET_SMALLWATERROOM = _fife.SE_PRESET_SMALLWATERROOM

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    init = _swig_new_instance_method(_fife.SoundManager_init)
    isActive = _swig_new_instance_method(_fife.SoundManager_isActive)
    createEmitter = _swig_new_instance_method(_fife.SoundManager_createEmitter)
    deleteEmitter = _swig_new_instance_method(_fife.SoundManager_deleteEmitter)
    getEmitter = _swig_new_instance_method(_fife.SoundManager_getEmitter)
    releaseEmitter = _swig_new_instance_method(_fife.SoundManager_releaseEmitter)
    getContext = _swig_new_instance_method(_fife.SoundManager_getContext)
    setVolume = _swig_new_instance_method(_fife.SoundManager_setVolume)
    getVolume = _swig_new_instance_method(_fife.SoundManager_getVolume)
    mute = _swig_new_instance_method(_fife.SoundManager_mute)
    unmute = _swig_new_instance_method(_fife.SoundManager_unmute)
    setDistanceModel = _swig_new_instance_method(_fife.SoundManager_setDistanceModel)
    getDistanceModel = _swig_new_instance_method(_fife.SoundManager_getDistanceModel)
    setListenerPosition = _swig_new_instance_method(_fife.SoundManager_setListenerPosition)
    getListenerPosition = _swig_new_instance_method(_fife.SoundManager_getListenerPosition)
    setListenerOrientation = _swig_new_instance_method(_fife.SoundManager_setListenerOrientation)
    getListenerOrientation = _swig_new_instance_method(_fife.SoundManager_getListenerOrientation)
    setListenerVelocity = _swig_new_instance_method(_fife.SoundManager_setListenerVelocity)
    getListenerVelocity = _swig_new_instance_method(_fife.SoundManager_getListenerVelocity)
    setDopplerFactor = _swig_new_instance_method(_fife.SoundManager_setDopplerFactor)
    getDopplerFactor = _swig_new_instance_method(_fife.SoundManager_getDopplerFactor)
    setListenerMaxDistance = _swig_new_instance_method(_fife.SoundManager_setListenerMaxDistance)
    getListenerMaxDistance = _swig_new_instance_method(_fife.SoundManager_getListenerMaxDistance)
    createSoundEffect = _swig_new_instance_method(_fife.SoundManager_createSoundEffect)
    createSoundEffectPreset = _swig_new_instance_method(_fife.SoundManager_createSoundEffectPreset)
    deleteSoundEffect = _swig_new_instance_method(_fife.SoundManager_deleteSoundEffect)
    enableSoundEffect = _swig_new_instance_method(_fife.SoundManager_enableSoundEffect)
    disableSoundEffect = _swig_new_instance_method(_fife.SoundManager_disableSoundEffect)
    addEmitterToSoundEffect = _swig_new_instance_method(_fife.SoundManager_addEmitterToSoundEffect)
    removeEmitterFromSoundEffect = _swig_new_instance_method(_fife.SoundManager_removeEmitterFromSoundEffect)
    addSoundFilterToSoundEffect = _swig_new_instance_method(_fife.SoundManager_addSoundFilterToSoundEffect)
    removeSoundFilterFromSoundEffect = _swig_new_instance_method(_fife.SoundManager_removeSoundFilterFromSoundEffect)
    createSoundFilter = _swig_new_instance_method(_fife.SoundManager_createSoundFilter)
    deleteSoundFilter = _swig_new_instance_method(_fife.SoundManager_deleteSoundFilter)
    enableDirectSoundFilter = _swig_new_instance_method(_fife.SoundManager_enableDirectSoundFilter)
    disableDirectSoundFilter = _swig_new_instance_method(_fife.SoundManager_disableDirectSoundFilter)
    addEmitterToDirectSoundFilter = _swig_new_instance_method(_fife.SoundManager_addEmitterToDirectSoundFilter)
    removeEmitterFromDirectSoundFilter = _swig_new_instance_method(_fife.SoundManager_removeEmitterFromDirectSoundFilter)
    removeGroup = _swig_new_instance_method(_fife.SoundManager_removeGroup)
    removeAllGroups = _swig_new_instance_method(_fife.SoundManager_removeAllGroups)
    play = _swig_new_instance_method(_fife.SoundManager_play)
    pause = _swig_new_instance_method(_fife.SoundManager_pause)
    stop = _swig_new_instance_method(_fife.SoundManager_stop)
    rewind = _swig_new_instance_method(_fife.SoundManager_rewind)
    setGain = _swig_new_instance_method(_fife.SoundManager_setGain)
    setMaxGain = _swig_new_instance_method(_fife.SoundManager_setMaxGain)
    setMinGain = _swig_new_instance_method(_fife.SoundManager_setMinGain)

    def __init__(self):
        r"""__init__(SoundManager self) -> SoundManager"""
        _fife.SoundManager_swiginit(self, _fife.new_SoundManager())
    __swig_destroy__ = _fife.delete_SoundManager

# Register SoundManager in _fife:
_fife.SoundManager_swigregister(SoundManager)
class EngineSettings(object):
    r"""Proxy of C++ FIFE::EngineSettings class."""

    thisown = 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
    setBitsPerPixel = _swig_new_instance_method(_fife.EngineSettings_setBitsPerPixel)
    getBitsPerPixel = _swig_new_instance_method(_fife.EngineSettings_getBitsPerPixel)
    getPossibleBitsPerPixel = _swig_new_instance_method(_fife.EngineSettings_getPossibleBitsPerPixel)
    setFullScreen = _swig_new_instance_method(_fife.EngineSettings_setFullScreen)
    isFullScreen = _swig_new_instance_method(_fife.EngineSettings_isFullScreen)
    setRefreshRate = _swig_new_instance_method(_fife.EngineSettings_setRefreshRate)
    getRefreshRate = _swig_new_instance_method(_fife.EngineSettings_getRefreshRate)
    setDisplay = _swig_new_instance_method(_fife.EngineSettings_setDisplay)
    getDisplay = _swig_new_instance_method(_fife.EngineSettings_getDisplay)
    setVSync = _swig_new_instance_method(_fife.EngineSettings_setVSync)
    isVSync = _swig_new_instance_method(_fife.EngineSettings_isVSync)
    setSDLDriver = _swig_new_instance_method(_fife.EngineSettings_setSDLDriver)
    getSDLDriver = _swig_new_instance_method(_fife.EngineSettings_getSDLDriver)
    setInitialVolume = _swig_new_instance_method(_fife.EngineSettings_setInitialVolume)
    getInitialVolume = _swig_new_instance_method(_fife.EngineSettings_getInitialVolume)
    getMaxVolume = _swig_new_instance_method(_fife.EngineSettings_getMaxVolume)
    setRenderBackend = _swig_new_instance_method(_fife.EngineSettings_setRenderBackend)
    getRenderBackend = _swig_new_instance_method(_fife.EngineSettings_getRenderBackend)
    getPossibleRenderBackends = _swig_new_instance_method(_fife.EngineSettings_getPossibleRenderBackends)
    setSDLRemoveFakeAlpha = _swig_new_instance_method(_fife.EngineSettings_setSDLRemoveFakeAlpha)
    isSDLRemoveFakeAlpha = _swig_new_instance_method(_fife.EngineSettings_isSDLRemoveFakeAlpha)
    setGLCompressImages = _swig_new_instance_method(_fife.EngineSettings_setGLCompressImages)
    isGLCompressImages = _swig_new_instance_method(_fife.EngineSettings_isGLCompressImages)
    setGLUseFramebuffer = _swig_new_instance_method(_fife.EngineSettings_setGLUseFramebuffer)
    isGLUseFramebuffer = _swig_new_instance_method(_fife.EngineSettings_isGLUseFramebuffer)
    setGLUseNPOT = _swig_new_instance_method(_fife.EngineSettings_setGLUseNPOT)
    isGLUseNPOT = _swig_new_instance_method(_fife.EngineSettings_isGLUseNPOT)
    setGLTextureFiltering = _swig_new_instance_method(_fife.EngineSettings_setGLTextureFiltering)
    getGLTextureFiltering = _swig_new_instance_method(_fife.EngineSettings_getGLTextureFiltering)
    setGLUseMipmapping = _swig_new_instance_method(_fife.EngineSettings_setGLUseMipmapping)
    isGLUseMipmapping = _swig_new_instance_method(_fife.EngineSettings_isGLUseMipmapping)
    setGLUseMonochrome = _swig_new_instance_method(_fife.EngineSettings_setGLUseMonochrome)
    isGLUseMonochrome = _swig_new_instance_method(_fife.EngineSettings_isGLUseMonochrome)
    setGLUseDepthBuffer = _swig_new_instance_method(_fife.EngineSettings_setGLUseDepthBuffer)
    isGLUseDepthBuffer = _swig_new_instance_method(_fife.EngineSettings_isGLUseDepthBuffer)
    setGLAlphaTestValue = _swig_new_instance_method(_fife.EngineSettings_setGLAlphaTestValue)
    getGLAlphaTestValue = _swig_new_instance_method(_fife.EngineSettings_getGLAlphaTestValue)
    setScreenWidth = _swig_new_instance_method(_fife.EngineSettings_setScreenWidth)
    getScreenWidth = _swig_new_instance_method(_fife.EngineSettings_getScreenWidth)
    setScreenHeight = _swig_new_instance_method(_fife.EngineSettings_setScreenHeight)
    getScreenHeight = _swig_new_instance_method(_fife.EngineSettings_getScreenHeight)
    setDefaultFontPath = _swig_new_instance_method(_fife.EngineSettings_setDefaultFontPath)
    getDefaultFontPath = _swig_new_instance_method(_fife.EngineSettings_getDefaultFontPath)
    setDefaultFontSize = _swig_new_instance_method(_fife.EngineSettings_setDefaultFontSize)
    getDefaultFontSize = _swig_new_instance_method(_fife.EngineSettings_getDefaultFontSize)
    setDefaultFontGlyphs = _swig_new_instance_method(_fife.EngineSettings_setDefaultFontGlyphs)
    getDefaultFontGlyphs = _swig_new_instance_method(_fife.EngineSettings_getDefaultFontGlyphs)
    setWindowTitle = _swig_new_instance_method(_fife.EngineSettings_setWindowTitle)
    getWindowTitle = _swig_new_instance_method(_fife.EngineSettings_getWindowTitle)
    setWindowIcon = _swig_new_instance_method(_fife.EngineSettings_setWindowIcon)
    getWindowIcon = _swig_new_instance_method(_fife.EngineSettings_getWindowIcon)
    setColorKeyEnabled = _swig_new_instance_method(_fife.EngineSettings_setColorKeyEnabled)
    isColorKeyEnabled = _swig_new_instance_method(_fife.EngineSettings_isColorKeyEnabled)
    setColorKey = _swig_new_instance_method(_fife.EngineSettings_setColorKey)
    getColorKey = _swig_new_instance_method(_fife.EngineSettings_getColorKey)
    setVideoDriver = _swig_new_instance_method(_fife.EngineSettings_setVideoDriver)
    getVideoDriver = _swig_new_instance_method(_fife.EngineSettings_getVideoDriver)
    setLightingModel = _swig_new_instance_method(_fife.EngineSettings_setLightingModel)
    getLightingModel = _swig_new_instance_method(_fife.EngineSettings_getLightingModel)
    setFrameLimitEnabled = _swig_new_instance_method(_fife.EngineSettings_setFrameLimitEnabled)
    isFrameLimitEnabled = _swig_new_instance_method(_fife.EngineSettings_isFrameLimitEnabled)
    setFrameLimit = _swig_new_instance_method(_fife.EngineSettings_setFrameLimit)
    getFrameLimit = _swig_new_instance_method(_fife.EngineSettings_getFrameLimit)
    setMouseSensitivity = _swig_new_instance_method(_fife.EngineSettings_setMouseSensitivity)
    getMouseSensitivity = _swig_new_instance_method(_fife.EngineSettings_getMouseSensitivity)
    setMouseAccelerationEnabled = _swig_new_instance_method(_fife.EngineSettings_setMouseAccelerationEnabled)
    isMouseAccelerationEnabled = _swig_new_instance_method(_fife.EngineSettings_isMouseAccelerationEnabled)
    setNativeImageCursorEnabled = _swig_new_instance_method(_fife.EngineSettings_setNativeImageCursorEnabled)
    isNativeImageCursorEnabled = _swig_new_instance_method(_fife.EngineSettings_isNativeImageCursorEnabled)
    setJoystickSupport = _swig_new_instance_method(_fife.EngineSettings_setJoystickSupport)
    isJoystickSupport = _swig_new_instance_method(_fife.EngineSettings_isJoystickSupport)

# Register EngineSettings in _fife:
_fife.EngineSettings_swigregister(EngineSettings)
class IEngineChangeListener(object):
    r"""Proxy of C++ FIFE::IEngineChangeListener class."""

    thisown = 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
    onScreenModeChanged = _swig_new_instance_method(_fife.IEngineChangeListener_onScreenModeChanged)

    def __init__(self):
        r"""__init__(IEngineChangeListener self) -> IEngineChangeListener"""
        if self.__class__ == IEngineChangeListener:
            _self = None
        else:
            _self = self
        _fife.IEngineChangeListener_swiginit(self, _fife.new_IEngineChangeListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IEngineChangeListener(self)
        return weakref.proxy(self)

# Register IEngineChangeListener in _fife:
_fife.IEngineChangeListener_swigregister(IEngineChangeListener)
class Engine(object):
    r"""Proxy of C++ FIFE::Engine class."""

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

    def __init__(self):
        r"""__init__(Engine self) -> Engine"""
        _fife.Engine_swiginit(self, _fife.new_Engine())
    __swig_destroy__ = _fife.delete_Engine
    initializePumping = _swig_new_instance_method(_fife.Engine_initializePumping)
    finalizePumping = _swig_new_instance_method(_fife.Engine_finalizePumping)
    pump = _swig_new_instance_method(_fife.Engine_pump)
    getSettings = _swig_new_instance_method(_fife.Engine_getSettings)
    getDeviceCaps = _swig_new_instance_method(_fife.Engine_getDeviceCaps)
    changeScreenMode = _swig_new_instance_method(_fife.Engine_changeScreenMode)
    init = _swig_new_instance_method(_fife.Engine_init)
    destroy = _swig_new_instance_method(_fife.Engine_destroy)
    getSoundManager = _swig_new_instance_method(_fife.Engine_getSoundManager)
    getEventManager = _swig_new_instance_method(_fife.Engine_getEventManager)
    getTimeManager = _swig_new_instance_method(_fife.Engine_getTimeManager)
    setGuiManager = _swig_new_instance_method(_fife.Engine_setGuiManager)
    getGuiManager = _swig_new_instance_method(_fife.Engine_getGuiManager)
    getImageManager = _swig_new_instance_method(_fife.Engine_getImageManager)
    getAnimationManager = _swig_new_instance_method(_fife.Engine_getAnimationManager)
    getSoundClipManager = _swig_new_instance_method(_fife.Engine_getSoundClipManager)
    getRenderBackend = _swig_new_instance_method(_fife.Engine_getRenderBackend)
    getModel = _swig_new_instance_method(_fife.Engine_getModel)
    getLogManager = _swig_new_instance_method(_fife.Engine_getLogManager)
    getVFS = _swig_new_instance_method(_fife.Engine_getVFS)
    getCursor = _swig_new_instance_method(_fife.Engine_getCursor)
    getOffRenderer = _swig_new_instance_method(_fife.Engine_getOffRenderer)
    getTargetRenderer = _swig_new_instance_method(_fife.Engine_getTargetRenderer)
    addChangeListener = _swig_new_instance_method(_fife.Engine_addChangeListener)
    removeChangeListener = _swig_new_instance_method(_fife.Engine_removeChangeListener)

# Register Engine in _fife:
_fife.Engine_swigregister(Engine)
class Key(object):
    r"""Proxy of C++ FIFE::Key class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    INVALID_KEY = _fife.Key_INVALID_KEY
    
    ENTER = _fife.Key_ENTER
    
    ESCAPE = _fife.Key_ESCAPE
    
    BACKSPACE = _fife.Key_BACKSPACE
    
    TAB = _fife.Key_TAB
    
    SPACE = _fife.Key_SPACE
    
    EXCLAIM = _fife.Key_EXCLAIM
    
    QUOTEDBL = _fife.Key_QUOTEDBL
    
    HASH = _fife.Key_HASH
    
    PERCENT = _fife.Key_PERCENT
    
    DOLLAR = _fife.Key_DOLLAR
    
    AMPERSAND = _fife.Key_AMPERSAND
    
    QUOTE = _fife.Key_QUOTE
    
    LEFTPAREN = _fife.Key_LEFTPAREN
    
    RIGHTPAREN = _fife.Key_RIGHTPAREN
    
    ASTERISK = _fife.Key_ASTERISK
    
    PLUS = _fife.Key_PLUS
    
    COMMA = _fife.Key_COMMA
    
    MINUS = _fife.Key_MINUS
    
    PERIOD = _fife.Key_PERIOD
    
    SLASH = _fife.Key_SLASH
    
    NUM_0 = _fife.Key_NUM_0
    
    NUM_1 = _fife.Key_NUM_1
    
    NUM_2 = _fife.Key_NUM_2
    
    NUM_3 = _fife.Key_NUM_3
    
    NUM_4 = _fife.Key_NUM_4
    
    NUM_5 = _fife.Key_NUM_5
    
    NUM_6 = _fife.Key_NUM_6
    
    NUM_7 = _fife.Key_NUM_7
    
    NUM_8 = _fife.Key_NUM_8
    
    NUM_9 = _fife.Key_NUM_9
    
    COLON = _fife.Key_COLON
    
    SEMICOLON = _fife.Key_SEMICOLON
    
    LESS = _fife.Key_LESS
    
    EQUALS = _fife.Key_EQUALS
    
    GREATER = _fife.Key_GREATER
    
    QUESTION = _fife.Key_QUESTION
    
    AT = _fife.Key_AT
    
    LEFTBRACKET = _fife.Key_LEFTBRACKET
    
    BACKSLASH = _fife.Key_BACKSLASH
    
    RIGHTBRACKET = _fife.Key_RIGHTBRACKET
    
    CARET = _fife.Key_CARET
    
    UNDERSCORE = _fife.Key_UNDERSCORE
    
    BACKQUOTE = _fife.Key_BACKQUOTE
    
    A = _fife.Key_A
    
    B = _fife.Key_B
    
    C = _fife.Key_C
    
    D = _fife.Key_D
    
    E = _fife.Key_E
    
    F = _fife.Key_F
    
    G = _fife.Key_G
    
    H = _fife.Key_H
    
    I = _fife.Key_I
    
    J = _fife.Key_J
    
    K = _fife.Key_K
    
    L = _fife.Key_L
    
    M = _fife.Key_M
    
    N = _fife.Key_N
    
    O = _fife.Key_O
    
    P = _fife.Key_P
    
    Q = _fife.Key_Q
    
    R = _fife.Key_R
    
    S = _fife.Key_S
    
    T = _fife.Key_T
    
    U = _fife.Key_U
    
    V = _fife.Key_V
    
    W = _fife.Key_W
    
    X = _fife.Key_X
    
    Y = _fife.Key_Y
    
    Z = _fife.Key_Z
    
    CAPS_LOCK = _fife.Key_CAPS_LOCK
    
    F1 = _fife.Key_F1
    
    F2 = _fife.Key_F2
    
    F3 = _fife.Key_F3
    
    F4 = _fife.Key_F4
    
    F5 = _fife.Key_F5
    
    F6 = _fife.Key_F6
    
    F7 = _fife.Key_F7
    
    F8 = _fife.Key_F8
    
    F9 = _fife.Key_F9
    
    F10 = _fife.Key_F10
    
    F11 = _fife.Key_F11
    
    F12 = _fife.Key_F12
    
    PRINT_SCREEN = _fife.Key_PRINT_SCREEN
    
    SCROLL_LOCK = _fife.Key_SCROLL_LOCK
    
    PAUSE = _fife.Key_PAUSE
    
    INSERT = _fife.Key_INSERT
    
    HOME = _fife.Key_HOME
    
    PAGE_UP = _fife.Key_PAGE_UP
    
    DELETE = _fife.Key_DELETE
    
    END = _fife.Key_END
    
    PAGE_DOWN = _fife.Key_PAGE_DOWN
    
    RIGHT = _fife.Key_RIGHT
    
    LEFT = _fife.Key_LEFT
    
    DOWN = _fife.Key_DOWN
    
    UP = _fife.Key_UP
    
    NUM_LOCK = _fife.Key_NUM_LOCK
    
    KP_DIVIDE = _fife.Key_KP_DIVIDE
    
    KP_MULTIPLY = _fife.Key_KP_MULTIPLY
    
    KP_MINUS = _fife.Key_KP_MINUS
    
    KP_PLUS = _fife.Key_KP_PLUS
    
    KP_ENTER = _fife.Key_KP_ENTER
    
    KP_0 = _fife.Key_KP_0
    
    KP_1 = _fife.Key_KP_1
    
    KP_2 = _fife.Key_KP_2
    
    KP_3 = _fife.Key_KP_3
    
    KP_4 = _fife.Key_KP_4
    
    KP_5 = _fife.Key_KP_5
    
    KP_6 = _fife.Key_KP_6
    
    KP_7 = _fife.Key_KP_7
    
    KP_8 = _fife.Key_KP_8
    
    KP_9 = _fife.Key_KP_9
    
    KP_PERIOD = _fife.Key_KP_PERIOD
    
    APPLICATION = _fife.Key_APPLICATION
    
    POWER = _fife.Key_POWER
    
    KP_EQUALS = _fife.Key_KP_EQUALS
    
    F13 = _fife.Key_F13
    
    F14 = _fife.Key_F14
    
    F15 = _fife.Key_F15
    
    F16 = _fife.Key_F16
    
    F17 = _fife.Key_F17
    
    F18 = _fife.Key_F18
    
    F19 = _fife.Key_F19
    
    F20 = _fife.Key_F20
    
    F21 = _fife.Key_F21
    
    F22 = _fife.Key_F22
    
    F23 = _fife.Key_F23
    
    F24 = _fife.Key_F24
    
    EXECUTE = _fife.Key_EXECUTE
    
    HELP = _fife.Key_HELP
    
    MENU = _fife.Key_MENU
    
    SELECT = _fife.Key_SELECT
    
    STOP = _fife.Key_STOP
    
    AGAIN = _fife.Key_AGAIN
    
    UNDO = _fife.Key_UNDO
    
    CUT = _fife.Key_CUT
    
    COPY = _fife.Key_COPY
    
    PASTE = _fife.Key_PASTE
    
    FIND = _fife.Key_FIND
    
    MUTE = _fife.Key_MUTE
    
    VOLUME_UP = _fife.Key_VOLUME_UP
    
    VOLUME_DOWN = _fife.Key_VOLUME_DOWN
    
    KP_COMMA = _fife.Key_KP_COMMA
    
    KP_EQUALSAS400 = _fife.Key_KP_EQUALSAS400
    
    ERASE = _fife.Key_ERASE
    
    SYS_REQ = _fife.Key_SYS_REQ
    
    CANCEL = _fife.Key_CANCEL
    
    CLEAR = _fife.Key_CLEAR
    
    PRIOR = _fife.Key_PRIOR
    
    RETURN = _fife.Key_RETURN
    
    SEPARATOR = _fife.Key_SEPARATOR
    
    FORTH = _fife.Key_FORTH
    
    OPER = _fife.Key_OPER
    
    CLEAR_AGAIN = _fife.Key_CLEAR_AGAIN
    
    CR_SEL = _fife.Key_CR_SEL
    
    EX_SEL = _fife.Key_EX_SEL
    
    KP_00 = _fife.Key_KP_00
    
    KP_000 = _fife.Key_KP_000
    
    THOUSANDS_SEPARATOR = _fife.Key_THOUSANDS_SEPARATOR
    
    DECIMAL_SEPARATOR = _fife.Key_DECIMAL_SEPARATOR
    
    CURRENCY_UNIT = _fife.Key_CURRENCY_UNIT
    
    CURRENCY_SUBUNIT = _fife.Key_CURRENCY_SUBUNIT
    
    KP_LEFTPAREN = _fife.Key_KP_LEFTPAREN
    
    KP_RIGHTPAREN = _fife.Key_KP_RIGHTPAREN
    
    KP_LEFTBRACE = _fife.Key_KP_LEFTBRACE
    
    KP_RIGHTBRACE = _fife.Key_KP_RIGHTBRACE
    
    KP_TAB = _fife.Key_KP_TAB
    
    KP_BACKSPACE = _fife.Key_KP_BACKSPACE
    
    KP_A = _fife.Key_KP_A
    
    KP_B = _fife.Key_KP_B
    
    KP_C = _fife.Key_KP_C
    
    KP_D = _fife.Key_KP_D
    
    KP_E = _fife.Key_KP_E
    
    KP_F = _fife.Key_KP_F
    
    KP_XOR = _fife.Key_KP_XOR
    
    KP_POWER = _fife.Key_KP_POWER
    
    KP_PERCENT = _fife.Key_KP_PERCENT
    
    KP_LESS = _fife.Key_KP_LESS
    
    KP_GREATER = _fife.Key_KP_GREATER
    
    KP_AMPERSAND = _fife.Key_KP_AMPERSAND
    
    KP_DBLAMPERSAND = _fife.Key_KP_DBLAMPERSAND
    
    KP_VERTICALBAR = _fife.Key_KP_VERTICALBAR
    
    KP_DBLVERTICALBAR = _fife.Key_KP_DBLVERTICALBAR
    
    KP_COLON = _fife.Key_KP_COLON
    
    KP_HASH = _fife.Key_KP_HASH
    
    KP_SPACE = _fife.Key_KP_SPACE
    
    KP_AT = _fife.Key_KP_AT
    
    KP_EXCLAM = _fife.Key_KP_EXCLAM
    
    KP_MEMSTORE = _fife.Key_KP_MEMSTORE
    
    KP_MEMRECALL = _fife.Key_KP_MEMRECALL
    
    KP_MEMCLEAR = _fife.Key_KP_MEMCLEAR
    
    KP_MEMADD = _fife.Key_KP_MEMADD
    
    KP_MEMSUBSTRACT = _fife.Key_KP_MEMSUBSTRACT
    
    KP_MEMMULTIPLY = _fife.Key_KP_MEMMULTIPLY
    
    KP_MEMDIVIDE = _fife.Key_KP_MEMDIVIDE
    
    KP_PLUSMINUS = _fife.Key_KP_PLUSMINUS
    
    KP_CLEAR = _fife.Key_KP_CLEAR
    
    KP_CLEARENTRY = _fife.Key_KP_CLEARENTRY
    
    KP_BINARY = _fife.Key_KP_BINARY
    
    KP_OCTAL = _fife.Key_KP_OCTAL
    
    KP_DECIMAL = _fife.Key_KP_DECIMAL
    
    KP_HEXADECIMAL = _fife.Key_KP_HEXADECIMAL
    
    LEFT_CONTROL = _fife.Key_LEFT_CONTROL
    
    LEFT_SHIFT = _fife.Key_LEFT_SHIFT
    
    LEFT_ALT = _fife.Key_LEFT_ALT
    
    LEFT_SUPER = _fife.Key_LEFT_SUPER
    
    RIGHT_CONTROL = _fife.Key_RIGHT_CONTROL
    
    RIGHT_SHIFT = _fife.Key_RIGHT_SHIFT
    
    RIGHT_ALT = _fife.Key_RIGHT_ALT
    
    RIGHT_SUPER = _fife.Key_RIGHT_SUPER
    
    ALT_GR = _fife.Key_ALT_GR
    
    AUDIO_NEXT = _fife.Key_AUDIO_NEXT
    
    AUDIO_PREV = _fife.Key_AUDIO_PREV
    
    AUDIO_STOP = _fife.Key_AUDIO_STOP
    
    AUDIO_PLAY = _fife.Key_AUDIO_PLAY
    
    AUDIO_MUTE = _fife.Key_AUDIO_MUTE
    
    MEDIASELECT = _fife.Key_MEDIASELECT
    
    WWW = _fife.Key_WWW
    
    MAIL = _fife.Key_MAIL
    
    CALCULATOR = _fife.Key_CALCULATOR
    
    COMPUTER = _fife.Key_COMPUTER
    
    AC_SEARCH = _fife.Key_AC_SEARCH
    
    AC_HOME = _fife.Key_AC_HOME
    
    AC_BACK = _fife.Key_AC_BACK
    
    AC_FORWARD = _fife.Key_AC_FORWARD
    
    AC_STOP = _fife.Key_AC_STOP
    
    AC_REFRESH = _fife.Key_AC_REFRESH
    
    AC_BOOKMARKS = _fife.Key_AC_BOOKMARKS
    
    BRIGHTNESS_DOWN = _fife.Key_BRIGHTNESS_DOWN
    
    BRIGHTNESS_UP = _fife.Key_BRIGHTNESS_UP
    
    DISPLAY_SWITCH = _fife.Key_DISPLAY_SWITCH
    
    ILLUM_TOGGLE = _fife.Key_ILLUM_TOGGLE
    
    ILLUM_DOWN = _fife.Key_ILLUM_DOWN
    
    ILLUM_UP = _fife.Key_ILLUM_UP
    
    EJECT = _fife.Key_EJECT
    
    SLEEP = _fife.Key_SLEEP
    

    def __init__(self, *args, **kwargs):
        r"""__init__(Key self, FIFE::Key::KeyType key=INVALID_KEY) -> Key"""
        _fife.Key_swiginit(self, _fife.new_Key(*args, **kwargs))
    __swig_destroy__ = _fife.delete_Key
    isPrintable = _swig_new_instance_method(_fife.Key_isPrintable)
    isFunctionKey = _swig_new_instance_method(_fife.Key_isFunctionKey)
    getValue = _swig_new_instance_method(_fife.Key_getValue)
    getAsString = _swig_new_instance_method(_fife.Key_getAsString)

# Register Key in _fife:
_fife.Key_swigregister(Key)
class Text(object):
    r"""Proxy of C++ FIFE::Text class."""

    thisown = 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):
        r"""__init__(Text self, char const * text=None, int32_t start=0, int32_t length=0) -> Text"""
        _fife.Text_swiginit(self, _fife.new_Text(text, start, length))
    __swig_destroy__ = _fife.delete_Text
    isPrintable = _swig_new_instance_method(_fife.Text_isPrintable)
    getAsString = _swig_new_instance_method(_fife.Text_getAsString)
    getStart = _swig_new_instance_method(_fife.Text_getStart)
    getLength = _swig_new_instance_method(_fife.Text_getLength)

# Register Text in _fife:
_fife.Text_swigregister(Text)
ES_ENGINE = _fife.ES_ENGINE

ES_FIFECHAN_WIDGET = _fife.ES_FIFECHAN_WIDGET

ES_CEGUI_WIDGET = _fife.ES_CEGUI_WIDGET

ES_LIBROCKET_WIDGET = _fife.ES_LIBROCKET_WIDGET

CMD_UNKNOWN = _fife.CMD_UNKNOWN

CMD_QUIT_GAME = _fife.CMD_QUIT_GAME

CMD_MOUSE_FOCUS_GAINED = _fife.CMD_MOUSE_FOCUS_GAINED

CMD_MOUSE_FOCUS_LOST = _fife.CMD_MOUSE_FOCUS_LOST

CMD_INPUT_FOCUS_GAINED = _fife.CMD_INPUT_FOCUS_GAINED

CMD_INPUT_FOCUS_LOST = _fife.CMD_INPUT_FOCUS_LOST

CMD_APP_RESTORED = _fife.CMD_APP_RESTORED

CMD_APP_ICONIFIED = _fife.CMD_APP_ICONIFIED

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    getEventSourceType = _swig_new_instance_method(_fife.IEventSource_getEventSourceType)
    __swig_destroy__ = _fife.delete_IEventSource

    def __init__(self):
        r"""__init__(IEventSource self) -> IEventSource"""
        if self.__class__ == IEventSource:
            _self = None
        else:
            _self = self
        _fife.IEventSource_swiginit(self, _fife.new_IEventSource(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IEventSource(self)
        return weakref.proxy(self)

# Register IEventSource in _fife:
_fife.IEventSource_swigregister(IEventSource)
class Event(object):
    r"""Proxy of C++ FIFE::Event class."""

    thisown = 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
    consume = _swig_new_instance_method(_fife.Event_consume)
    isConsumed = _swig_new_instance_method(_fife.Event_isConsumed)
    getSource = _swig_new_instance_method(_fife.Event_getSource)
    getTimeStamp = _swig_new_instance_method(_fife.Event_getTimeStamp)
    getDebugString = _swig_new_instance_method(_fife.Event_getDebugString)
    getName = _swig_new_instance_method(_fife.Event_getName)
    __swig_destroy__ = _fife.delete_Event

# Register Event in _fife:
_fife.Event_swigregister(Event)
class InputEvent(Event):
    r"""Proxy of C++ FIFE::InputEvent class."""

    thisown = 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
    isConsumedByWidgets = _swig_new_instance_method(_fife.InputEvent_isConsumedByWidgets)
    isAltPressed = _swig_new_instance_method(_fife.InputEvent_isAltPressed)
    isControlPressed = _swig_new_instance_method(_fife.InputEvent_isControlPressed)
    isMetaPressed = _swig_new_instance_method(_fife.InputEvent_isMetaPressed)
    isShiftPressed = _swig_new_instance_method(_fife.InputEvent_isShiftPressed)
    __swig_destroy__ = _fife.delete_InputEvent

# Register InputEvent in _fife:
_fife.InputEvent_swigregister(InputEvent)
class Command(Event):
    r"""Proxy of C++ FIFE::Command class."""

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

    def __init__(self):
        r"""__init__(Command self) -> Command"""
        _fife.Command_swiginit(self, _fife.new_Command())
    __swig_destroy__ = _fife.delete_Command
    getCommandType = _swig_new_instance_method(_fife.Command_getCommandType)
    setCommandType = _swig_new_instance_method(_fife.Command_setCommandType)
    getCode = _swig_new_instance_method(_fife.Command_getCode)
    setCode = _swig_new_instance_method(_fife.Command_setCode)
    setSource = _swig_new_instance_method(_fife.Command_setSource)
    setTimeStamp = _swig_new_instance_method(_fife.Command_setTimeStamp)

# Register Command in _fife:
_fife.Command_swigregister(Command)
class ICommandListener(object):
    r"""Proxy of C++ FIFE::ICommandListener class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    onCommand = _swig_new_instance_method(_fife.ICommandListener_onCommand)
    __swig_destroy__ = _fife.delete_ICommandListener

    def __init__(self):
        r"""__init__(ICommandListener self) -> ICommandListener"""
        if self.__class__ == ICommandListener:
            _self = None
        else:
            _self = self
        _fife.ICommandListener_swiginit(self, _fife.new_ICommandListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_ICommandListener(self)
        return weakref.proxy(self)

# Register ICommandListener in _fife:
_fife.ICommandListener_swigregister(ICommandListener)
class KeyEvent(InputEvent):
    r"""Proxy of C++ FIFE::KeyEvent class."""

    thisown = 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
    
    getType = _swig_new_instance_method(_fife.KeyEvent_getType)
    isNumericPad = _swig_new_instance_method(_fife.KeyEvent_isNumericPad)
    getKey = _swig_new_instance_method(_fife.KeyEvent_getKey)
    __swig_destroy__ = _fife.delete_KeyEvent

# Register KeyEvent in _fife:
_fife.KeyEvent_swigregister(KeyEvent)
class IKeyListener(object):
    r"""Proxy of C++ FIFE::IKeyListener class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    keyPressed = _swig_new_instance_method(_fife.IKeyListener_keyPressed)
    keyReleased = _swig_new_instance_method(_fife.IKeyListener_keyReleased)
    isGlobalListener = _swig_new_instance_method(_fife.IKeyListener_isGlobalListener)
    setGlobalListener = _swig_new_instance_method(_fife.IKeyListener_setGlobalListener)
    __swig_destroy__ = _fife.delete_IKeyListener

    def __init__(self):
        r"""__init__(IKeyListener self) -> IKeyListener"""
        if self.__class__ == IKeyListener:
            _self = None
        else:
            _self = self
        _fife.IKeyListener_swiginit(self, _fife.new_IKeyListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IKeyListener(self)
        return weakref.proxy(self)

# Register IKeyListener in _fife:
_fife.IKeyListener_swigregister(IKeyListener)
class TextEvent(InputEvent):
    r"""Proxy of C++ FIFE::TextEvent class."""

    thisown = 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
    
    getType = _swig_new_instance_method(_fife.TextEvent_getType)
    getText = _swig_new_instance_method(_fife.TextEvent_getText)
    __swig_destroy__ = _fife.delete_TextEvent

# Register TextEvent in _fife:
_fife.TextEvent_swigregister(TextEvent)
class ITextListener(object):
    r"""Proxy of C++ FIFE::ITextListener class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    textInput = _swig_new_instance_method(_fife.ITextListener_textInput)
    textEdit = _swig_new_instance_method(_fife.ITextListener_textEdit)
    __swig_destroy__ = _fife.delete_ITextListener

    def __init__(self):
        r"""__init__(ITextListener self) -> ITextListener"""
        if self.__class__ == ITextListener:
            _self = None
        else:
            _self = self
        _fife.ITextListener_swiginit(self, _fife.new_ITextListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_ITextListener(self)
        return weakref.proxy(self)

# Register ITextListener in _fife:
_fife.ITextListener_swigregister(ITextListener)
class ISdlEventListener(object):
    r"""Proxy of C++ FIFE::ISdlEventListener class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    onSdlEvent = _swig_new_instance_method(_fife.ISdlEventListener_onSdlEvent)
    __swig_destroy__ = _fife.delete_ISdlEventListener

    def __init__(self):
        r"""__init__(ISdlEventListener self) -> ISdlEventListener"""
        if self.__class__ == ISdlEventListener:
            _self = None
        else:
            _self = self
        _fife.ISdlEventListener_swiginit(self, _fife.new_ISdlEventListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_ISdlEventListener(self)
        return weakref.proxy(self)

# Register ISdlEventListener in _fife:
_fife.ISdlEventListener_swigregister(ISdlEventListener)
class MouseEvent(InputEvent):
    r"""Proxy of C++ FIFE::MouseEvent class."""

    thisown = 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
    
    getX = _swig_new_instance_method(_fife.MouseEvent_getX)
    getY = _swig_new_instance_method(_fife.MouseEvent_getY)
    getType = _swig_new_instance_method(_fife.MouseEvent_getType)
    getButton = _swig_new_instance_method(_fife.MouseEvent_getButton)
    __swig_destroy__ = _fife.delete_MouseEvent

# Register MouseEvent in _fife:
_fife.MouseEvent_swigregister(MouseEvent)
class IMouseListener(object):
    r"""Proxy of C++ FIFE::IMouseListener class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    mouseEntered = _swig_new_instance_method(_fife.IMouseListener_mouseEntered)
    mouseExited = _swig_new_instance_method(_fife.IMouseListener_mouseExited)
    mousePressed = _swig_new_instance_method(_fife.IMouseListener_mousePressed)
    mouseReleased = _swig_new_instance_method(_fife.IMouseListener_mouseReleased)
    mouseClicked = _swig_new_instance_method(_fife.IMouseListener_mouseClicked)
    mouseWheelMovedUp = _swig_new_instance_method(_fife.IMouseListener_mouseWheelMovedUp)
    mouseWheelMovedDown = _swig_new_instance_method(_fife.IMouseListener_mouseWheelMovedDown)
    mouseWheelMovedRight = _swig_new_instance_method(_fife.IMouseListener_mouseWheelMovedRight)
    mouseWheelMovedLeft = _swig_new_instance_method(_fife.IMouseListener_mouseWheelMovedLeft)
    mouseMoved = _swig_new_instance_method(_fife.IMouseListener_mouseMoved)
    mouseDragged = _swig_new_instance_method(_fife.IMouseListener_mouseDragged)
    isGlobalListener = _swig_new_instance_method(_fife.IMouseListener_isGlobalListener)
    setGlobalListener = _swig_new_instance_method(_fife.IMouseListener_setGlobalListener)
    __swig_destroy__ = _fife.delete_IMouseListener

    def __init__(self):
        r"""__init__(IMouseListener self) -> IMouseListener"""
        if self.__class__ == IMouseListener:
            _self = None
        else:
            _self = self
        _fife.IMouseListener_swiginit(self, _fife.new_IMouseListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IMouseListener(self)
        return weakref.proxy(self)

# Register IMouseListener in _fife:
_fife.IMouseListener_swigregister(IMouseListener)
class IKeyFilter(object):
    r"""Proxy of C++ FIFE::IKeyFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    isFiltered = _swig_new_instance_method(_fife.IKeyFilter_isFiltered)
    __swig_destroy__ = _fife.delete_IKeyFilter

    def __init__(self):
        r"""__init__(IKeyFilter self) -> IKeyFilter"""
        if self.__class__ == IKeyFilter:
            _self = None
        else:
            _self = self
        _fife.IKeyFilter_swiginit(self, _fife.new_IKeyFilter(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IKeyFilter(self)
        return weakref.proxy(self)

# Register IKeyFilter in _fife:
_fife.IKeyFilter_swigregister(IKeyFilter)
class DropEvent(InputEvent):
    r"""Proxy of C++ FIFE::DropEvent class."""

    thisown = 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
    getPath = _swig_new_instance_method(_fife.DropEvent_getPath)
    __swig_destroy__ = _fife.delete_DropEvent

# Register DropEvent in _fife:
_fife.DropEvent_swigregister(DropEvent)
class IDropListener(object):
    r"""Proxy of C++ FIFE::IDropListener class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    fileDropped = _swig_new_instance_method(_fife.IDropListener_fileDropped)
    __swig_destroy__ = _fife.delete_IDropListener

    def __init__(self):
        r"""__init__(IDropListener self) -> IDropListener"""
        if self.__class__ == IDropListener:
            _self = None
        else:
            _self = self
        _fife.IDropListener_swiginit(self, _fife.new_IDropListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IDropListener(self)
        return weakref.proxy(self)

# Register IDropListener in _fife:
_fife.IDropListener_swigregister(IDropListener)
class Joystick(object):
    r"""Proxy of C++ FIFE::Joystick class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    HAT_INVALID = _fife.Joystick_HAT_INVALID
    
    HAT_CENTERED = _fife.Joystick_HAT_CENTERED
    
    HAT_UP = _fife.Joystick_HAT_UP
    
    HAT_RIGHT = _fife.Joystick_HAT_RIGHT
    
    HAT_DOWN = _fife.Joystick_HAT_DOWN
    
    HAT_LEFT = _fife.Joystick_HAT_LEFT
    
    HAT_RIGHTUP = _fife.Joystick_HAT_RIGHTUP
    
    HAT_RIGHTDOWN = _fife.Joystick_HAT_RIGHTDOWN
    
    HAT_LEFTUP = _fife.Joystick_HAT_LEFTUP
    
    HAT_LEFTDOWN = _fife.Joystick_HAT_LEFTDOWN
    
    CONTOLLER_AXIS_INVALID = _fife.Joystick_CONTOLLER_AXIS_INVALID
    
    CONTOLLER_AXIS_LEFTX = _fife.Joystick_CONTOLLER_AXIS_LEFTX
    
    CONTOLLER_AXIS_LEFTY = _fife.Joystick_CONTOLLER_AXIS_LEFTY
    
    CONTOLLER_AXIS_RIGHTX = _fife.Joystick_CONTOLLER_AXIS_RIGHTX
    
    CONTOLLER_AXIS_RIGHTY = _fife.Joystick_CONTOLLER_AXIS_RIGHTY
    
    CONTOLLER_AXIS_TRIGGERLEFT = _fife.Joystick_CONTOLLER_AXIS_TRIGGERLEFT
    
    CONTOLLER_AXIS_TRIGGERRIGHT = _fife.Joystick_CONTOLLER_AXIS_TRIGGERRIGHT
    
    CONTOLLER_AXIS_MAX = _fife.Joystick_CONTOLLER_AXIS_MAX
    
    CONTOLLER_BUTTON_INVALID = _fife.Joystick_CONTOLLER_BUTTON_INVALID
    
    CONTOLLER_BUTTON_A = _fife.Joystick_CONTOLLER_BUTTON_A
    
    CONTOLLER_BUTTON_B = _fife.Joystick_CONTOLLER_BUTTON_B
    
    CONTOLLER_BUTTON_X = _fife.Joystick_CONTOLLER_BUTTON_X
    
    CONTOLLER_BUTTON_Y = _fife.Joystick_CONTOLLER_BUTTON_Y
    
    CONTOLLER_BUTTON_BACK = _fife.Joystick_CONTOLLER_BUTTON_BACK
    
    CONTOLLER_BUTTON_GUIDE = _fife.Joystick_CONTOLLER_BUTTON_GUIDE
    
    CONTOLLER_BUTTON_START = _fife.Joystick_CONTOLLER_BUTTON_START
    
    CONTOLLER_BUTTON_LEFTSTICK = _fife.Joystick_CONTOLLER_BUTTON_LEFTSTICK
    
    CONTOLLER_BUTTON_RIGHTSTICK = _fife.Joystick_CONTOLLER_BUTTON_RIGHTSTICK
    
    CONTOLLER_BUTTON_LEFTSHOULDER = _fife.Joystick_CONTOLLER_BUTTON_LEFTSHOULDER
    
    CONTOLLER_BUTTON_RIGHTSHOULDER = _fife.Joystick_CONTOLLER_BUTTON_RIGHTSHOULDER
    
    CONTOLLER_BUTTON_DPAD_UP = _fife.Joystick_CONTOLLER_BUTTON_DPAD_UP
    
    CONTOLLER_BUTTON_DPAD_DOWN = _fife.Joystick_CONTOLLER_BUTTON_DPAD_DOWN
    
    CONTOLLER_BUTTON_DPAD_LEFT = _fife.Joystick_CONTOLLER_BUTTON_DPAD_LEFT
    
    CONTOLLER_BUTTON_DPAD_RIGHT = _fife.Joystick_CONTOLLER_BUTTON_DPAD_RIGHT
    
    CONTOLLER_BUTTON_MAX = _fife.Joystick_CONTOLLER_BUTTON_MAX
    
    __swig_destroy__ = _fife.delete_Joystick
    getDeviceIndex = _swig_new_instance_method(_fife.Joystick_getDeviceIndex)
    getInstanceId = _swig_new_instance_method(_fife.Joystick_getInstanceId)
    getGuid = _swig_new_instance_method(_fife.Joystick_getGuid)
    getName = _swig_new_instance_method(_fife.Joystick_getName)
    isConnected = _swig_new_instance_method(_fife.Joystick_isConnected)
    isController = _swig_new_instance_method(_fife.Joystick_isController)
    getNumberOfAxes = _swig_new_instance_method(_fife.Joystick_getNumberOfAxes)
    getNumberOfButtons = _swig_new_instance_method(_fife.Joystick_getNumberOfButtons)
    getNumberOfHats = _swig_new_instance_method(_fife.Joystick_getNumberOfHats)
    getAxisValue = _swig_new_instance_method(_fife.Joystick_getAxisValue)
    getHatValue = _swig_new_instance_method(_fife.Joystick_getHatValue)
    isButtonPressed = _swig_new_instance_method(_fife.Joystick_isButtonPressed)

# Register Joystick in _fife:
_fife.Joystick_swigregister(Joystick)
class JoystickEvent(InputEvent):
    r"""Proxy of C++ FIFE::JoystickEvent class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    UNKNOWN_EVENT = _fife.JoystickEvent_UNKNOWN_EVENT
    
    AXIS_MOTION = _fife.JoystickEvent_AXIS_MOTION
    
    HAT_MOTION = _fife.JoystickEvent_HAT_MOTION
    
    BUTTON_PRESSED = _fife.JoystickEvent_BUTTON_PRESSED
    
    BUTTON_RELEASED = _fife.JoystickEvent_BUTTON_RELEASED
    
    DEVICE_ADDED = _fife.JoystickEvent_DEVICE_ADDED
    
    DEVICE_REMOVED = _fife.JoystickEvent_DEVICE_REMOVED
    
    getType = _swig_new_instance_method(_fife.JoystickEvent_getType)
    getInstanceId = _swig_new_instance_method(_fife.JoystickEvent_getInstanceId)
    getAxis = _swig_new_instance_method(_fife.JoystickEvent_getAxis)
    getAxisValue = _swig_new_instance_method(_fife.JoystickEvent_getAxisValue)
    getHat = _swig_new_instance_method(_fife.JoystickEvent_getHat)
    getHatValue = _swig_new_instance_method(_fife.JoystickEvent_getHatValue)
    getButton = _swig_new_instance_method(_fife.JoystickEvent_getButton)
    isController = _swig_new_instance_method(_fife.JoystickEvent_isController)
    __swig_destroy__ = _fife.delete_JoystickEvent

# Register JoystickEvent in _fife:
_fife.JoystickEvent_swigregister(JoystickEvent)
class IJoystickListener(object):
    r"""Proxy of C++ FIFE::IJoystickListener class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    axisMotion = _swig_new_instance_method(_fife.IJoystickListener_axisMotion)
    hatMotion = _swig_new_instance_method(_fife.IJoystickListener_hatMotion)
    buttonPressed = _swig_new_instance_method(_fife.IJoystickListener_buttonPressed)
    buttonReleased = _swig_new_instance_method(_fife.IJoystickListener_buttonReleased)
    deviceAdded = _swig_new_instance_method(_fife.IJoystickListener_deviceAdded)
    deviceRemoved = _swig_new_instance_method(_fife.IJoystickListener_deviceRemoved)
    __swig_destroy__ = _fife.delete_IJoystickListener

    def __init__(self):
        r"""__init__(IJoystickListener self) -> IJoystickListener"""
        if self.__class__ == IJoystickListener:
            _self = None
        else:
            _self = self
        _fife.IJoystickListener_swiginit(self, _fife.new_IJoystickListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IJoystickListener(self)
        return weakref.proxy(self)

# Register IJoystickListener in _fife:
_fife.IJoystickListener_swigregister(IJoystickListener)
class EventManager(object):
    r"""Proxy of C++ FIFE::EventManager class."""

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

    def __init__(self):
        r"""__init__(EventManager self) -> EventManager"""
        _fife.EventManager_swiginit(self, _fife.new_EventManager())
    __swig_destroy__ = _fife.delete_EventManager
    addCommandListener = _swig_new_instance_method(_fife.EventManager_addCommandListener)
    addCommandListenerFront = _swig_new_instance_method(_fife.EventManager_addCommandListenerFront)
    removeCommandListener = _swig_new_instance_method(_fife.EventManager_removeCommandListener)
    addKeyListener = _swig_new_instance_method(_fife.EventManager_addKeyListener)
    addKeyListenerFront = _swig_new_instance_method(_fife.EventManager_addKeyListenerFront)
    removeKeyListener = _swig_new_instance_method(_fife.EventManager_removeKeyListener)
    addTextListener = _swig_new_instance_method(_fife.EventManager_addTextListener)
    addTextListenerFront = _swig_new_instance_method(_fife.EventManager_addTextListenerFront)
    removeTextListener = _swig_new_instance_method(_fife.EventManager_removeTextListener)
    addMouseListener = _swig_new_instance_method(_fife.EventManager_addMouseListener)
    addMouseListenerFront = _swig_new_instance_method(_fife.EventManager_addMouseListenerFront)
    removeMouseListener = _swig_new_instance_method(_fife.EventManager_removeMouseListener)
    addDropListener = _swig_new_instance_method(_fife.EventManager_addDropListener)
    addDropListenerFront = _swig_new_instance_method(_fife.EventManager_addDropListenerFront)
    removeDropListener = _swig_new_instance_method(_fife.EventManager_removeDropListener)
    addJoystickListener = _swig_new_instance_method(_fife.EventManager_addJoystickListener)
    addJoystickListenerFront = _swig_new_instance_method(_fife.EventManager_addJoystickListenerFront)
    removeJoystickListener = _swig_new_instance_method(_fife.EventManager_removeJoystickListener)
    addSdlEventListener = _swig_new_instance_method(_fife.EventManager_addSdlEventListener)
    addSdlEventListenerFront = _swig_new_instance_method(_fife.EventManager_addSdlEventListenerFront)
    removeSdlEventListener = _swig_new_instance_method(_fife.EventManager_removeSdlEventListener)
    getEventSourceType = _swig_new_instance_method(_fife.EventManager_getEventSourceType)
    dispatchCommand = _swig_new_instance_method(_fife.EventManager_dispatchCommand)
    setKeyFilter = _swig_new_instance_method(_fife.EventManager_setKeyFilter)
    setMouseSensitivity = _swig_new_instance_method(_fife.EventManager_setMouseSensitivity)
    getMouseSensitivity = _swig_new_instance_method(_fife.EventManager_getMouseSensitivity)
    setMouseAccelerationEnabled = _swig_new_instance_method(_fife.EventManager_setMouseAccelerationEnabled)
    isMouseAccelerationEnabled = _swig_new_instance_method(_fife.EventManager_isMouseAccelerationEnabled)
    isClipboardText = _swig_new_instance_method(_fife.EventManager_isClipboardText)
    getClipboardText = _swig_new_instance_method(_fife.EventManager_getClipboardText)
    setClipboardText = _swig_new_instance_method(_fife.EventManager_setClipboardText)
    getJoystick = _swig_new_instance_method(_fife.EventManager_getJoystick)
    getJoystickCount = _swig_new_instance_method(_fife.EventManager_getJoystickCount)
    loadGamepadMapping = _swig_new_instance_method(_fife.EventManager_loadGamepadMapping)
    saveGamepadMapping = _swig_new_instance_method(_fife.EventManager_saveGamepadMapping)
    saveGamepadMappings = _swig_new_instance_method(_fife.EventManager_saveGamepadMappings)
    getGamepadStringMapping = _swig_new_instance_method(_fife.EventManager_getGamepadStringMapping)
    setGamepadStringMapping = _swig_new_instance_method(_fife.EventManager_setGamepadStringMapping)

# Register EventManager in _fife:
_fife.EventManager_swigregister(EventManager)
class Exception(Exception):
    r"""Proxy of C++ FIFE::Exception class."""

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

    def __init__(self, msg):
        r"""__init__(Exception self, std::string const & msg) -> Exception"""
        _fife.Exception_swiginit(self, _fife.new_Exception(msg))
    __swig_destroy__ = _fife.delete_Exception
    what = _swig_new_instance_method(_fife.Exception_what)
    getTypeStr = _swig_new_instance_method(_fife.Exception_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.Exception_getDescription)
    update = _swig_new_instance_method(_fife.Exception_update)
    __str__ = _swig_new_instance_method(_fife.Exception___str__)

# Register Exception in _fife:
_fife.Exception_swigregister(Exception)
class SDLException(Exception):
    r"""Proxy of C++ FIFE::SDLException class."""

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

    def __init__(self, msg):
        r"""__init__(SDLException self, std::string const & msg) -> SDLException"""
        _fife.SDLException_swiginit(self, _fife.new_SDLException(msg))
    getTypeStr = _swig_new_instance_method(_fife.SDLException_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.SDLException_getDescription)
    __swig_destroy__ = _fife.delete_SDLException

# Register SDLException in _fife:
_fife.SDLException_swigregister(SDLException)
class NotFound(Exception):
    r"""Proxy of C++ FIFE::NotFound class."""

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

    def __init__(self, msg):
        r"""__init__(NotFound self, std::string const & msg) -> NotFound"""
        _fife.NotFound_swiginit(self, _fife.new_NotFound(msg))
    getTypeStr = _swig_new_instance_method(_fife.NotFound_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.NotFound_getDescription)
    __swig_destroy__ = _fife.delete_NotFound

# Register NotFound in _fife:
_fife.NotFound_swigregister(NotFound)
class NotSet(Exception):
    r"""Proxy of C++ FIFE::NotSet class."""

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

    def __init__(self, msg):
        r"""__init__(NotSet self, std::string const & msg) -> NotSet"""
        _fife.NotSet_swiginit(self, _fife.new_NotSet(msg))
    getTypeStr = _swig_new_instance_method(_fife.NotSet_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.NotSet_getDescription)
    __swig_destroy__ = _fife.delete_NotSet

# Register NotSet in _fife:
_fife.NotSet_swigregister(NotSet)
class IndexOverflow(Exception):
    r"""Proxy of C++ FIFE::IndexOverflow class."""

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

    def __init__(self, msg):
        r"""__init__(IndexOverflow self, std::string const & msg) -> IndexOverflow"""
        _fife.IndexOverflow_swiginit(self, _fife.new_IndexOverflow(msg))
    getTypeStr = _swig_new_instance_method(_fife.IndexOverflow_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.IndexOverflow_getDescription)
    __swig_destroy__ = _fife.delete_IndexOverflow

# Register IndexOverflow in _fife:
_fife.IndexOverflow_swigregister(IndexOverflow)
class InvalidFormat(Exception):
    r"""Proxy of C++ FIFE::InvalidFormat class."""

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

    def __init__(self, msg):
        r"""__init__(InvalidFormat self, std::string const & msg) -> InvalidFormat"""
        _fife.InvalidFormat_swiginit(self, _fife.new_InvalidFormat(msg))
    getTypeStr = _swig_new_instance_method(_fife.InvalidFormat_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.InvalidFormat_getDescription)
    __swig_destroy__ = _fife.delete_InvalidFormat

# Register InvalidFormat in _fife:
_fife.InvalidFormat_swigregister(InvalidFormat)
class CannotOpenFile(Exception):
    r"""Proxy of C++ FIFE::CannotOpenFile class."""

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

    def __init__(self, msg):
        r"""__init__(CannotOpenFile self, std::string const & msg) -> CannotOpenFile"""
        _fife.CannotOpenFile_swiginit(self, _fife.new_CannotOpenFile(msg))
    getTypeStr = _swig_new_instance_method(_fife.CannotOpenFile_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.CannotOpenFile_getDescription)
    __swig_destroy__ = _fife.delete_CannotOpenFile

# Register CannotOpenFile in _fife:
_fife.CannotOpenFile_swigregister(CannotOpenFile)
class InvalidConversion(Exception):
    r"""Proxy of C++ FIFE::InvalidConversion class."""

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

    def __init__(self, msg):
        r"""__init__(InvalidConversion self, std::string const & msg) -> InvalidConversion"""
        _fife.InvalidConversion_swiginit(self, _fife.new_InvalidConversion(msg))
    getTypeStr = _swig_new_instance_method(_fife.InvalidConversion_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.InvalidConversion_getDescription)
    __swig_destroy__ = _fife.delete_InvalidConversion

# Register InvalidConversion in _fife:
_fife.InvalidConversion_swigregister(InvalidConversion)
class NotSupported(Exception):
    r"""Proxy of C++ FIFE::NotSupported class."""

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

    def __init__(self, msg):
        r"""__init__(NotSupported self, std::string const & msg) -> NotSupported"""
        _fife.NotSupported_swiginit(self, _fife.new_NotSupported(msg))
    getTypeStr = _swig_new_instance_method(_fife.NotSupported_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.NotSupported_getDescription)
    __swig_destroy__ = _fife.delete_NotSupported

# Register NotSupported in _fife:
_fife.NotSupported_swigregister(NotSupported)
class NameClash(Exception):
    r"""Proxy of C++ FIFE::NameClash class."""

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

    def __init__(self, msg):
        r"""__init__(NameClash self, std::string const & msg) -> NameClash"""
        _fife.NameClash_swiginit(self, _fife.new_NameClash(msg))
    getTypeStr = _swig_new_instance_method(_fife.NameClash_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.NameClash_getDescription)
    __swig_destroy__ = _fife.delete_NameClash

# Register NameClash in _fife:
_fife.NameClash_swigregister(NameClash)
class Duplicate(Exception):
    r"""Proxy of C++ FIFE::Duplicate class."""

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

    def __init__(self, msg):
        r"""__init__(Duplicate self, std::string const & msg) -> Duplicate"""
        _fife.Duplicate_swiginit(self, _fife.new_Duplicate(msg))
    getTypeStr = _swig_new_instance_method(_fife.Duplicate_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.Duplicate_getDescription)
    __swig_destroy__ = _fife.delete_Duplicate

# Register Duplicate in _fife:
_fife.Duplicate_swigregister(Duplicate)
class ScriptException(Exception):
    r"""Proxy of C++ FIFE::ScriptException class."""

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

    def __init__(self, msg):
        r"""__init__(ScriptException self, std::string const & msg) -> ScriptException"""
        _fife.ScriptException_swiginit(self, _fife.new_ScriptException(msg))
    getTypeStr = _swig_new_instance_method(_fife.ScriptException_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.ScriptException_getDescription)
    __swig_destroy__ = _fife.delete_ScriptException

# Register ScriptException in _fife:
_fife.ScriptException_swigregister(ScriptException)
class EventException(Exception):
    r"""Proxy of C++ FIFE::EventException class."""

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

    def __init__(self, msg):
        r"""__init__(EventException self, std::string const & msg) -> EventException"""
        _fife.EventException_swiginit(self, _fife.new_EventException(msg))
    getTypeStr = _swig_new_instance_method(_fife.EventException_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.EventException_getDescription)
    __swig_destroy__ = _fife.delete_EventException

# Register EventException in _fife:
_fife.EventException_swigregister(EventException)
class GuiException(Exception):
    r"""Proxy of C++ FIFE::GuiException class."""

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

    def __init__(self, msg):
        r"""__init__(GuiException self, std::string const & msg) -> GuiException"""
        _fife.GuiException_swiginit(self, _fife.new_GuiException(msg))
    getTypeStr = _swig_new_instance_method(_fife.GuiException_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.GuiException_getDescription)
    __swig_destroy__ = _fife.delete_GuiException

# Register GuiException in _fife:
_fife.GuiException_swigregister(GuiException)
class InconsistencyDetected(Exception):
    r"""Proxy of C++ FIFE::InconsistencyDetected class."""

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

    def __init__(self, msg):
        r"""__init__(InconsistencyDetected self, std::string const & msg) -> InconsistencyDetected"""
        _fife.InconsistencyDetected_swiginit(self, _fife.new_InconsistencyDetected(msg))
    getTypeStr = _swig_new_instance_method(_fife.InconsistencyDetected_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.InconsistencyDetected_getDescription)
    __swig_destroy__ = _fife.delete_InconsistencyDetected

# Register InconsistencyDetected in _fife:
_fife.InconsistencyDetected_swigregister(InconsistencyDetected)
class OutOfMemory(Exception):
    r"""Proxy of C++ FIFE::OutOfMemory class."""

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

    def __init__(self, msg):
        r"""__init__(OutOfMemory self, std::string const & msg) -> OutOfMemory"""
        _fife.OutOfMemory_swiginit(self, _fife.new_OutOfMemory(msg))
    getTypeStr = _swig_new_instance_method(_fife.OutOfMemory_getTypeStr)
    getDescription = _swig_new_instance_method(_fife.OutOfMemory_getDescription)
    __swig_destroy__ = _fife.delete_OutOfMemory

# Register OutOfMemory in _fife:
_fife.OutOfMemory_swigregister(OutOfMemory)
class FifeClass(object):
    r"""Proxy of C++ FIFE::FifeClass class."""

    thisown = 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
    getFifeId = _swig_new_instance_method(_fife.FifeClass_getFifeId)
    __eq__ = _swig_new_instance_method(_fife.FifeClass___eq__)
    __ne__ = _swig_new_instance_method(_fife.FifeClass___ne__)
    __hash__ = _swig_new_instance_method(_fife.FifeClass___hash__)

    def __init__(self):
        r"""__init__(FifeClass self) -> FifeClass"""
        _fife.FifeClass_swiginit(self, _fife.new_FifeClass())

# Register FifeClass in _fife:
_fife.FifeClass_swigregister(FifeClass)
class ScreenModeVector(object):
    r"""Proxy of C++ std::vector< FIFE::ScreenMode > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.ScreenModeVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.ScreenModeVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.ScreenModeVector___bool__)
    __len__ = _swig_new_instance_method(_fife.ScreenModeVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.ScreenModeVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.ScreenModeVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.ScreenModeVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.ScreenModeVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.ScreenModeVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.ScreenModeVector___setitem__)
    pop = _swig_new_instance_method(_fife.ScreenModeVector_pop)
    append = _swig_new_instance_method(_fife.ScreenModeVector_append)
    empty = _swig_new_instance_method(_fife.ScreenModeVector_empty)
    size = _swig_new_instance_method(_fife.ScreenModeVector_size)
    swap = _swig_new_instance_method(_fife.ScreenModeVector_swap)
    begin = _swig_new_instance_method(_fife.ScreenModeVector_begin)
    end = _swig_new_instance_method(_fife.ScreenModeVector_end)
    rbegin = _swig_new_instance_method(_fife.ScreenModeVector_rbegin)
    rend = _swig_new_instance_method(_fife.ScreenModeVector_rend)
    clear = _swig_new_instance_method(_fife.ScreenModeVector_clear)
    get_allocator = _swig_new_instance_method(_fife.ScreenModeVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.ScreenModeVector_pop_back)
    erase = _swig_new_instance_method(_fife.ScreenModeVector_erase)

    def __init__(self, *args):
        r"""
        __init__(ScreenModeVector self) -> ScreenModeVector
        __init__(ScreenModeVector self, ScreenModeVector other) -> ScreenModeVector
        __init__(ScreenModeVector self, std::vector< FIFE::ScreenMode >::size_type size) -> ScreenModeVector
        __init__(ScreenModeVector self, std::vector< FIFE::ScreenMode >::size_type size, ScreenMode value) -> ScreenModeVector
        """
        _fife.ScreenModeVector_swiginit(self, _fife.new_ScreenModeVector(*args))
    push_back = _swig_new_instance_method(_fife.ScreenModeVector_push_back)
    front = _swig_new_instance_method(_fife.ScreenModeVector_front)
    back = _swig_new_instance_method(_fife.ScreenModeVector_back)
    assign = _swig_new_instance_method(_fife.ScreenModeVector_assign)
    resize = _swig_new_instance_method(_fife.ScreenModeVector_resize)
    insert = _swig_new_instance_method(_fife.ScreenModeVector_insert)
    reserve = _swig_new_instance_method(_fife.ScreenModeVector_reserve)
    capacity = _swig_new_instance_method(_fife.ScreenModeVector_capacity)
    __swig_destroy__ = _fife.delete_ScreenModeVector

# Register ScreenModeVector in _fife:
_fife.ScreenModeVector_swigregister(ScreenModeVector)
class Image(IResource):
    r"""Proxy of C++ FIFE::Image class."""

    thisown = 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
    getSurface = _swig_new_instance_method(_fife.Image_getSurface)
    getWidth = _swig_new_instance_method(_fife.Image_getWidth)
    getHeight = _swig_new_instance_method(_fife.Image_getHeight)
    getArea = _swig_new_instance_method(_fife.Image_getArea)
    setXShift = _swig_new_instance_method(_fife.Image_setXShift)
    getXShift = _swig_new_instance_method(_fife.Image_getXShift)
    setYShift = _swig_new_instance_method(_fife.Image_setYShift)
    getYShift = _swig_new_instance_method(_fife.Image_getYShift)
    getPixelRGBA = _swig_new_instance_method(_fife.Image_getPixelRGBA)
    saveImage = _swig_new_instance_method(_fife.Image_saveImage)
    useSharedImage = _swig_new_instance_method(_fife.Image_useSharedImage)
    forceLoadInternal = _swig_new_instance_method(_fife.Image_forceLoadInternal)
    isSharedImage = _swig_new_instance_method(_fife.Image_isSharedImage)
    getSubImageRect = _swig_new_instance_method(_fife.Image_getSubImageRect)
    copySubimage = _swig_new_instance_method(_fife.Image_copySubimage)

# Register Image in _fife:
_fife.Image_swigregister(Image)
class SharedImagePointer(object):
    r"""Proxy of C++ FIFE::SharedPtr< FIFE::Image > class."""

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

    def __init__(self, *args):
        r"""
        __init__(SharedImagePointer self) -> SharedImagePointer
        __init__(SharedImagePointer self, SharedImagePointer rhs) -> SharedImagePointer
        """
        _fife.SharedImagePointer_swiginit(self, _fife.new_SharedImagePointer(*args))
    __swig_destroy__ = _fife.delete_SharedImagePointer
    __ref__ = _swig_new_instance_method(_fife.SharedImagePointer___ref__)
    __deref__ = _swig_new_instance_method(_fife.SharedImagePointer___deref__)
    get = _swig_new_instance_method(_fife.SharedImagePointer_get)
    reset = _swig_new_instance_method(_fife.SharedImagePointer_reset)
    useCount = _swig_new_instance_method(_fife.SharedImagePointer_useCount)
    useCountPtr = _swig_new_instance_method(_fife.SharedImagePointer_useCountPtr)
    unique = _swig_new_instance_method(_fife.SharedImagePointer_unique)

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


    getSurface = _swig_new_instance_method(_fife.SharedImagePointer_getSurface)
    getWidth = _swig_new_instance_method(_fife.SharedImagePointer_getWidth)
    getHeight = _swig_new_instance_method(_fife.SharedImagePointer_getHeight)
    getArea = _swig_new_instance_method(_fife.SharedImagePointer_getArea)
    setXShift = _swig_new_instance_method(_fife.SharedImagePointer_setXShift)
    getXShift = _swig_new_instance_method(_fife.SharedImagePointer_getXShift)
    setYShift = _swig_new_instance_method(_fife.SharedImagePointer_setYShift)
    getYShift = _swig_new_instance_method(_fife.SharedImagePointer_getYShift)
    getPixelRGBA = _swig_new_instance_method(_fife.SharedImagePointer_getPixelRGBA)
    saveImage = _swig_new_instance_method(_fife.SharedImagePointer_saveImage)
    useSharedImage = _swig_new_instance_method(_fife.SharedImagePointer_useSharedImage)
    forceLoadInternal = _swig_new_instance_method(_fife.SharedImagePointer_forceLoadInternal)
    isSharedImage = _swig_new_instance_method(_fife.SharedImagePointer_isSharedImage)
    getSubImageRect = _swig_new_instance_method(_fife.SharedImagePointer_getSubImageRect)
    copySubimage = _swig_new_instance_method(_fife.SharedImagePointer_copySubimage)
    getName = _swig_new_instance_method(_fife.SharedImagePointer_getName)
    getHandle = _swig_new_instance_method(_fife.SharedImagePointer_getHandle)
    getState = _swig_new_instance_method(_fife.SharedImagePointer_getState)
    setState = _swig_new_instance_method(_fife.SharedImagePointer_setState)
    getSize = _swig_new_instance_method(_fife.SharedImagePointer_getSize)
    load = _swig_new_instance_method(_fife.SharedImagePointer_load)
    free = _swig_new_instance_method(_fife.SharedImagePointer_free)

# Register SharedImagePointer in _fife:
_fife.SharedImagePointer_swigregister(SharedImagePointer)
class ImageManager(IResourceManager):
    r"""Proxy of C++ FIFE::ImageManager class."""

    thisown = 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
    getMemoryUsed = _swig_new_instance_method(_fife.ImageManager_getMemoryUsed)
    getTotalResourcesCreated = _swig_new_instance_method(_fife.ImageManager_getTotalResourcesCreated)
    getTotalResourcesLoaded = _swig_new_instance_method(_fife.ImageManager_getTotalResourcesLoaded)
    getTotalResources = _swig_new_instance_method(_fife.ImageManager_getTotalResources)
    create = _swig_new_instance_method(_fife.ImageManager_create)
    load = _swig_new_instance_method(_fife.ImageManager_load)
    loadBlank = _swig_new_instance_method(_fife.ImageManager_loadBlank)
    add = _swig_new_instance_method(_fife.ImageManager_add)
    exists = _swig_new_instance_method(_fife.ImageManager_exists)
    reload = _swig_new_instance_method(_fife.ImageManager_reload)
    reloadAll = _swig_new_instance_method(_fife.ImageManager_reloadAll)
    loadUnreferenced = _swig_new_instance_method(_fife.ImageManager_loadUnreferenced)
    free = _swig_new_instance_method(_fife.ImageManager_free)
    freeAll = _swig_new_instance_method(_fife.ImageManager_freeAll)
    freeUnreferenced = _swig_new_instance_method(_fife.ImageManager_freeUnreferenced)
    remove = _swig_new_instance_method(_fife.ImageManager_remove)
    removeAll = _swig_new_instance_method(_fife.ImageManager_removeAll)
    removeUnreferenced = _swig_new_instance_method(_fife.ImageManager_removeUnreferenced)
    get = _swig_new_instance_method(_fife.ImageManager_get)
    getResourceHandle = _swig_new_instance_method(_fife.ImageManager_getResourceHandle)
    invalidate = _swig_new_instance_method(_fife.ImageManager_invalidate)
    invalidateAll = _swig_new_instance_method(_fife.ImageManager_invalidateAll)

    def __init__(self):
        r"""__init__(ImageManager self) -> ImageManager"""
        _fife.ImageManager_swiginit(self, _fife.new_ImageManager())

# Register ImageManager in _fife:
_fife.ImageManager_swigregister(ImageManager)
class Animation(IResource):
    r"""Proxy of C++ FIFE::Animation class."""

    thisown = 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
    addFrame = _swig_new_instance_method(_fife.Animation_addFrame)
    getFrameIndex = _swig_new_instance_method(_fife.Animation_getFrameIndex)
    getFrame = _swig_new_instance_method(_fife.Animation_getFrame)
    getFrameByTimestamp = _swig_new_instance_method(_fife.Animation_getFrameByTimestamp)
    getFrameDuration = _swig_new_instance_method(_fife.Animation_getFrameDuration)
    getFrameCount = _swig_new_instance_method(_fife.Animation_getFrameCount)
    setActionFrame = _swig_new_instance_method(_fife.Animation_setActionFrame)
    getActionFrame = _swig_new_instance_method(_fife.Animation_getActionFrame)
    setDirection = _swig_new_instance_method(_fife.Animation_setDirection)
    getDirection = _swig_new_instance_method(_fife.Animation_getDirection)
    getDuration = _swig_new_instance_method(_fife.Animation_getDuration)

# Register Animation in _fife:
_fife.Animation_swigregister(Animation)
class SharedAnimationPointer(object):
    r"""Proxy of C++ FIFE::SharedPtr< FIFE::Animation > class."""

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

    def __init__(self, *args):
        r"""
        __init__(SharedAnimationPointer self) -> SharedAnimationPointer
        __init__(SharedAnimationPointer self, SharedAnimationPointer rhs) -> SharedAnimationPointer
        """
        _fife.SharedAnimationPointer_swiginit(self, _fife.new_SharedAnimationPointer(*args))
    __swig_destroy__ = _fife.delete_SharedAnimationPointer
    __ref__ = _swig_new_instance_method(_fife.SharedAnimationPointer___ref__)
    __deref__ = _swig_new_instance_method(_fife.SharedAnimationPointer___deref__)
    get = _swig_new_instance_method(_fife.SharedAnimationPointer_get)
    reset = _swig_new_instance_method(_fife.SharedAnimationPointer_reset)
    useCount = _swig_new_instance_method(_fife.SharedAnimationPointer_useCount)
    useCountPtr = _swig_new_instance_method(_fife.SharedAnimationPointer_useCountPtr)
    unique = _swig_new_instance_method(_fife.SharedAnimationPointer_unique)

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


    addFrame = _swig_new_instance_method(_fife.SharedAnimationPointer_addFrame)
    getFrameIndex = _swig_new_instance_method(_fife.SharedAnimationPointer_getFrameIndex)
    getFrame = _swig_new_instance_method(_fife.SharedAnimationPointer_getFrame)
    getFrameByTimestamp = _swig_new_instance_method(_fife.SharedAnimationPointer_getFrameByTimestamp)
    getFrameDuration = _swig_new_instance_method(_fife.SharedAnimationPointer_getFrameDuration)
    getFrameCount = _swig_new_instance_method(_fife.SharedAnimationPointer_getFrameCount)
    setActionFrame = _swig_new_instance_method(_fife.SharedAnimationPointer_setActionFrame)
    getActionFrame = _swig_new_instance_method(_fife.SharedAnimationPointer_getActionFrame)
    setDirection = _swig_new_instance_method(_fife.SharedAnimationPointer_setDirection)
    getDirection = _swig_new_instance_method(_fife.SharedAnimationPointer_getDirection)
    getDuration = _swig_new_instance_method(_fife.SharedAnimationPointer_getDuration)
    getName = _swig_new_instance_method(_fife.SharedAnimationPointer_getName)
    getHandle = _swig_new_instance_method(_fife.SharedAnimationPointer_getHandle)
    getState = _swig_new_instance_method(_fife.SharedAnimationPointer_getState)
    setState = _swig_new_instance_method(_fife.SharedAnimationPointer_setState)
    getSize = _swig_new_instance_method(_fife.SharedAnimationPointer_getSize)
    load = _swig_new_instance_method(_fife.SharedAnimationPointer_load)
    free = _swig_new_instance_method(_fife.SharedAnimationPointer_free)

# Register SharedAnimationPointer in _fife:
_fife.SharedAnimationPointer_swigregister(SharedAnimationPointer)
class AnimationManager(IResourceManager):
    r"""Proxy of C++ FIFE::AnimationManager class."""

    thisown = 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
    getMemoryUsed = _swig_new_instance_method(_fife.AnimationManager_getMemoryUsed)
    getTotalResourcesCreated = _swig_new_instance_method(_fife.AnimationManager_getTotalResourcesCreated)
    getTotalResourcesLoaded = _swig_new_instance_method(_fife.AnimationManager_getTotalResourcesLoaded)
    getTotalResources = _swig_new_instance_method(_fife.AnimationManager_getTotalResources)
    create = _swig_new_instance_method(_fife.AnimationManager_create)
    add = _swig_new_instance_method(_fife.AnimationManager_add)
    exists = _swig_new_instance_method(_fife.AnimationManager_exists)
    reload = _swig_new_instance_method(_fife.AnimationManager_reload)
    reloadAll = _swig_new_instance_method(_fife.AnimationManager_reloadAll)
    loadUnreferenced = _swig_new_instance_method(_fife.AnimationManager_loadUnreferenced)
    free = _swig_new_instance_method(_fife.AnimationManager_free)
    freeAll = _swig_new_instance_method(_fife.AnimationManager_freeAll)
    freeUnreferenced = _swig_new_instance_method(_fife.AnimationManager_freeUnreferenced)
    remove = _swig_new_instance_method(_fife.AnimationManager_remove)
    removeAll = _swig_new_instance_method(_fife.AnimationManager_removeAll)
    removeUnreferenced = _swig_new_instance_method(_fife.AnimationManager_removeUnreferenced)
    get = _swig_new_instance_method(_fife.AnimationManager_get)
    getPtr = _swig_new_instance_method(_fife.AnimationManager_getPtr)
    getResourceHandle = _swig_new_instance_method(_fife.AnimationManager_getResourceHandle)
    invalidate = _swig_new_instance_method(_fife.AnimationManager_invalidate)
    invalidateAll = _swig_new_instance_method(_fife.AnimationManager_invalidateAll)

    def __init__(self):
        r"""__init__(AnimationManager self) -> AnimationManager"""
        _fife.AnimationManager_swiginit(self, _fife.new_AnimationManager())

# Register AnimationManager in _fife:
_fife.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):
    r"""Proxy of C++ FIFE::RenderBackend class."""

    thisown = 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
    getName = _swig_new_instance_method(_fife.RenderBackend_getName)
    captureScreen = _swig_new_instance_method(_fife.RenderBackend_captureScreen)
    getCurrentScreenMode = _swig_new_instance_method(_fife.RenderBackend_getCurrentScreenMode)
    getWidth = _swig_new_instance_method(_fife.RenderBackend_getWidth)
    getHeight = _swig_new_instance_method(_fife.RenderBackend_getHeight)
    getScreenWidth = _swig_new_instance_method(_fife.RenderBackend_getScreenWidth)
    getScreenHeight = _swig_new_instance_method(_fife.RenderBackend_getScreenHeight)
    getArea = _swig_new_instance_method(_fife.RenderBackend_getArea)
    getClipArea = _swig_new_instance_method(_fife.RenderBackend_getClipArea)
    setAlphaOptimizerEnabled = _swig_new_instance_method(_fife.RenderBackend_setAlphaOptimizerEnabled)
    isAlphaOptimizerEnabled = _swig_new_instance_method(_fife.RenderBackend_isAlphaOptimizerEnabled)
    setImageCompressingEnabled = _swig_new_instance_method(_fife.RenderBackend_setImageCompressingEnabled)
    isImageCompressingEnabled = _swig_new_instance_method(_fife.RenderBackend_isImageCompressingEnabled)
    setFramebufferEnabled = _swig_new_instance_method(_fife.RenderBackend_setFramebufferEnabled)
    isFramebufferEnabled = _swig_new_instance_method(_fife.RenderBackend_isFramebufferEnabled)
    setNPOTEnabled = _swig_new_instance_method(_fife.RenderBackend_setNPOTEnabled)
    isNPOTEnabled = _swig_new_instance_method(_fife.RenderBackend_isNPOTEnabled)
    setTextureFiltering = _swig_new_instance_method(_fife.RenderBackend_setTextureFiltering)
    getTextureFiltering = _swig_new_instance_method(_fife.RenderBackend_getTextureFiltering)
    setMipmappingEnabled = _swig_new_instance_method(_fife.RenderBackend_setMipmappingEnabled)
    isMipmappingEnabled = _swig_new_instance_method(_fife.RenderBackend_isMipmappingEnabled)
    setMonochromeEnabled = _swig_new_instance_method(_fife.RenderBackend_setMonochromeEnabled)
    isMonochromeEnabled = _swig_new_instance_method(_fife.RenderBackend_isMonochromeEnabled)
    setColorKeyEnabled = _swig_new_instance_method(_fife.RenderBackend_setColorKeyEnabled)
    isColorKeyEnabled = _swig_new_instance_method(_fife.RenderBackend_isColorKeyEnabled)
    setColorKey = _swig_new_instance_method(_fife.RenderBackend_setColorKey)
    getColorKey = _swig_new_instance_method(_fife.RenderBackend_getColorKey)
    getPixelFormat = _swig_new_instance_method(_fife.RenderBackend_getPixelFormat)
    setBackgroundColor = _swig_new_instance_method(_fife.RenderBackend_setBackgroundColor)
    resetBackgroundColor = _swig_new_instance_method(_fife.RenderBackend_resetBackgroundColor)
    setVSyncEnabled = _swig_new_instance_method(_fife.RenderBackend_setVSyncEnabled)
    isVSyncEnabled = _swig_new_instance_method(_fife.RenderBackend_isVSyncEnabled)
    setFrameLimitEnabled = _swig_new_instance_method(_fife.RenderBackend_setFrameLimitEnabled)
    isFrameLimitEnabled = _swig_new_instance_method(_fife.RenderBackend_isFrameLimitEnabled)
    setFrameLimit = _swig_new_instance_method(_fife.RenderBackend_setFrameLimit)
    getFrameLimit = _swig_new_instance_method(_fife.RenderBackend_getFrameLimit)

# Register RenderBackend in _fife:
_fife.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):
    r"""Proxy of C++ FIFE::Cursor class."""

    thisown = 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
    draw = _swig_new_instance_method(_fife.Cursor_draw)
    set = _swig_new_instance_method(_fife.Cursor_set)
    setDrag = _swig_new_instance_method(_fife.Cursor_setDrag)
    resetDrag = _swig_new_instance_method(_fife.Cursor_resetDrag)
    getType = _swig_new_instance_method(_fife.Cursor_getType)
    getId = _swig_new_instance_method(_fife.Cursor_getId)
    getImage = _swig_new_instance_method(_fife.Cursor_getImage)
    getAnimation = _swig_new_instance_method(_fife.Cursor_getAnimation)
    getDragType = _swig_new_instance_method(_fife.Cursor_getDragType)
    getDragImage = _swig_new_instance_method(_fife.Cursor_getDragImage)
    getDragAnimation = _swig_new_instance_method(_fife.Cursor_getDragAnimation)
    getX = _swig_new_instance_method(_fife.Cursor_getX)
    getY = _swig_new_instance_method(_fife.Cursor_getY)
    setPosition = _swig_new_instance_method(_fife.Cursor_setPosition)
    getPosition = _swig_new_instance_method(_fife.Cursor_getPosition)
    setNativeImageCursorEnabled = _swig_new_instance_method(_fife.Cursor_setNativeImageCursorEnabled)
    isNativeImageCursorEnabled = _swig_new_instance_method(_fife.Cursor_isNativeImageCursorEnabled)

# Register Cursor in _fife:
_fife.Cursor_swigregister(Cursor)
class ScreenMode(object):
    r"""Proxy of C++ FIFE::ScreenMode class."""

    thisown = 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
    getWidth = _swig_new_instance_method(_fife.ScreenMode_getWidth)
    getHeight = _swig_new_instance_method(_fife.ScreenMode_getHeight)
    getBPP = _swig_new_instance_method(_fife.ScreenMode_getBPP)
    getRefreshRate = _swig_new_instance_method(_fife.ScreenMode_getRefreshRate)
    getSDLFlags = _swig_new_instance_method(_fife.ScreenMode_getSDLFlags)
    isFullScreen = _swig_new_instance_method(_fife.ScreenMode_isFullScreen)
    isOpenGL = _swig_new_instance_method(_fife.ScreenMode_isOpenGL)
    isSDL = _swig_new_instance_method(_fife.ScreenMode_isSDL)
    getDisplay = _swig_new_instance_method(_fife.ScreenMode_getDisplay)
    getRenderDriverName = _swig_new_instance_method(_fife.ScreenMode_getRenderDriverName)

    def __init__(self):
        r"""__init__(ScreenMode self) -> ScreenMode"""
        _fife.ScreenMode_swiginit(self, _fife.new_ScreenMode())

# Register ScreenMode in _fife:
_fife.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):
    r"""Proxy of C++ FIFE::DeviceCaps class."""

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

    def __init__(self):
        r"""__init__(DeviceCaps self) -> DeviceCaps"""
        _fife.DeviceCaps_swiginit(self, _fife.new_DeviceCaps())
    __swig_destroy__ = _fife.delete_DeviceCaps
    fillDeviceCaps = _swig_new_instance_method(_fife.DeviceCaps_fillDeviceCaps)
    getSupportedScreenModes = _swig_new_instance_method(_fife.DeviceCaps_getSupportedScreenModes)
    getNearestScreenMode = _swig_new_instance_method(_fife.DeviceCaps_getNearestScreenMode)
    getVideoDriverName = _swig_new_instance_method(_fife.DeviceCaps_getVideoDriverName)
    getAvailableVideoDrivers = _swig_new_instance_method(_fife.DeviceCaps_getAvailableVideoDrivers)
    getRenderDriverName = _swig_new_instance_method(_fife.DeviceCaps_getRenderDriverName)
    setRenderDriverName = _swig_new_instance_method(_fife.DeviceCaps_setRenderDriverName)
    getAvailableRenderDrivers = _swig_new_instance_method(_fife.DeviceCaps_getAvailableRenderDrivers)
    getDisplayCount = _swig_new_instance_method(_fife.DeviceCaps_getDisplayCount)
    getDisplayName = _swig_new_instance_method(_fife.DeviceCaps_getDisplayName)
    getDesktopFormat = _swig_new_instance_method(_fife.DeviceCaps_getDesktopFormat)
    getDesktopRefreshRate = _swig_new_instance_method(_fife.DeviceCaps_getDesktopRefreshRate)
    getDesktopWidth = _swig_new_instance_method(_fife.DeviceCaps_getDesktopWidth)
    getDesktopHeight = _swig_new_instance_method(_fife.DeviceCaps_getDesktopHeight)
    getDisplayBounds = _swig_new_instance_method(_fife.DeviceCaps_getDisplayBounds)

# Register DeviceCaps in _fife:
_fife.DeviceCaps_swigregister(DeviceCaps)
class AtlasBlock(object):
    r"""Proxy of C++ FIFE::AtlasBlock class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    page = property(_fife.AtlasBlock_page_get, _fife.AtlasBlock_page_set, doc=r"""page : uint32_t""")
    left = property(_fife.AtlasBlock_left_get, _fife.AtlasBlock_left_set, doc=r"""left : uint32_t""")
    right = property(_fife.AtlasBlock_right_get, _fife.AtlasBlock_right_set, doc=r"""right : uint32_t""")
    top = property(_fife.AtlasBlock_top_get, _fife.AtlasBlock_top_set, doc=r"""top : uint32_t""")
    bottom = property(_fife.AtlasBlock_bottom_get, _fife.AtlasBlock_bottom_set, doc=r"""bottom : uint32_t""")

    def __init__(self, *args):
        r"""
        __init__(AtlasBlock self, Rect rect, uint32_t page) -> AtlasBlock
        __init__(AtlasBlock self) -> AtlasBlock
        """
        _fife.AtlasBlock_swiginit(self, _fife.new_AtlasBlock(*args))
    setTrivial = _swig_new_instance_method(_fife.AtlasBlock_setTrivial)
    isTrivial = _swig_new_instance_method(_fife.AtlasBlock_isTrivial)
    getWidth = _swig_new_instance_method(_fife.AtlasBlock_getWidth)
    getHeight = _swig_new_instance_method(_fife.AtlasBlock_getHeight)
    intersects = _swig_new_instance_method(_fife.AtlasBlock_intersects)
    merge = _swig_new_instance_method(_fife.AtlasBlock_merge)
    __swig_destroy__ = _fife.delete_AtlasBlock

# Register AtlasBlock in _fife:
_fife.AtlasBlock_swigregister(AtlasBlock)
class AtlasBook(object):
    r"""Proxy of C++ FIFE::AtlasBook class."""

    thisown = 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):
        r"""__init__(AtlasBook self, uint32_t pageWidth, uint32_t pageHeight, uint32_t pixelSize=4) -> AtlasBook"""
        _fife.AtlasBook_swiginit(self, _fife.new_AtlasBook(pageWidth, pageHeight, pixelSize))
    getBlock = _swig_new_instance_method(_fife.AtlasBook_getBlock)
    shrink = _swig_new_instance_method(_fife.AtlasBook_shrink)
    getPageWidth = _swig_new_instance_method(_fife.AtlasBook_getPageWidth)
    getPageHeight = _swig_new_instance_method(_fife.AtlasBook_getPageHeight)
    __swig_destroy__ = _fife.delete_AtlasBook

# Register AtlasBook in _fife:
_fife.AtlasBook_swigregister(AtlasBook)
class Color(object):
    r"""Proxy of C++ FIFE::Color class."""

    thisown = 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):
        r"""__init__(Color self, uint8_t r=0, uint8_t g=0, uint8_t b=0, uint8_t alpha=255) -> Color"""
        _fife.Color_swiginit(self, _fife.new_Color(r, g, b, alpha))
    __swig_destroy__ = _fife.delete_Color
    set = _swig_new_instance_method(_fife.Color_set)
    r = property(_fife.Color_r_get, _fife.Color_r_set, doc=r"""r : uint8_t""")
    g = property(_fife.Color_g_get, _fife.Color_g_set, doc=r"""g : uint8_t""")
    b = property(_fife.Color_b_get, _fife.Color_b_set, doc=r"""b : uint8_t""")
    a = property(_fife.Color_a_get, _fife.Color_a_set, doc=r"""a : uint8_t""")

# Register Color in _fife:
_fife.Color_swigregister(Color)
class IAnimationLoader(object):
    r"""Proxy of C++ FIFE::IAnimationLoader class."""

    thisown = 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
    isLoadable = _swig_new_instance_method(_fife.IAnimationLoader_isLoadable)
    load = _swig_new_instance_method(_fife.IAnimationLoader_load)
    loadMultiple = _swig_new_instance_method(_fife.IAnimationLoader_loadMultiple)

    def __init__(self):
        r"""__init__(IAnimationLoader self) -> IAnimationLoader"""
        if self.__class__ == IAnimationLoader:
            _self = None
        else:
            _self = self
        _fife.IAnimationLoader_swiginit(self, _fife.new_IAnimationLoader(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAnimationLoader(self)
        return weakref.proxy(self)

# Register IAnimationLoader in _fife:
_fife.IAnimationLoader_swigregister(IAnimationLoader)
class AnimationLoader(IAnimationLoader):
    r"""Proxy of C++ FIFE::AnimationLoader class."""

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

    def __init__(self, vfs, imageManager, animationManager):
        r"""__init__(AnimationLoader self, VFS vfs, ImageManager imageManager, AnimationManager animationManager) -> AnimationLoader"""
        _fife.AnimationLoader_swiginit(self, _fife.new_AnimationLoader(vfs, imageManager, animationManager))
    isLoadable = _swig_new_instance_method(_fife.AnimationLoader_isLoadable)
    load = _swig_new_instance_method(_fife.AnimationLoader_load)
    loadMultiple = _swig_new_instance_method(_fife.AnimationLoader_loadMultiple)
    __swig_destroy__ = _fife.delete_AnimationLoader

# Register AnimationLoader in _fife:
_fife.AnimationLoader_swigregister(AnimationLoader)
class IAtlasLoader(object):
    r"""Proxy of C++ FIFE::IAtlasLoader class."""

    thisown = 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
    isLoadable = _swig_new_instance_method(_fife.IAtlasLoader_isLoadable)
    load = _swig_new_instance_method(_fife.IAtlasLoader_load)
    loadMultiple = _swig_new_instance_method(_fife.IAtlasLoader_loadMultiple)

    def __init__(self):
        r"""__init__(IAtlasLoader self) -> IAtlasLoader"""
        if self.__class__ == IAtlasLoader:
            _self = None
        else:
            _self = self
        _fife.IAtlasLoader_swiginit(self, _fife.new_IAtlasLoader(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAtlasLoader(self)
        return weakref.proxy(self)

# Register IAtlasLoader in _fife:
_fife.IAtlasLoader_swigregister(IAtlasLoader)
class AtlasData(object):
    r"""Proxy of C++ FIFE::AtlasData class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    rect = property(_fife.AtlasData_rect_get, _fife.AtlasData_rect_set, doc=r"""rect : FIFE::Rect""")
    image = property(_fife.AtlasData_image_get, _fife.AtlasData_image_set, doc=r"""image : FIFE::ImagePtr""")

    def __init__(self):
        r"""__init__(AtlasData self) -> AtlasData"""
        _fife.AtlasData_swiginit(self, _fife.new_AtlasData())
    __swig_destroy__ = _fife.delete_AtlasData

# Register AtlasData in _fife:
_fife.AtlasData_swigregister(AtlasData)
class Atlas(object):
    r"""Proxy of C++ FIFE::Atlas class."""

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

    def __init__(self, name):
        r"""__init__(Atlas self, std::string const & name) -> Atlas"""
        _fife.Atlas_swiginit(self, _fife.new_Atlas(name))
    __swig_destroy__ = _fife.delete_Atlas
    getImageCount = _swig_new_instance_method(_fife.Atlas_getImageCount)
    getPackedImage = _swig_new_instance_method(_fife.Atlas_getPackedImage)
    getImage = _swig_new_instance_method(_fife.Atlas_getImage)
    addImage = _swig_new_instance_method(_fife.Atlas_addImage)
    setPackedImage = _swig_new_instance_method(_fife.Atlas_setPackedImage)
    getName = _swig_new_instance_method(_fife.Atlas_getName)

# Register Atlas in _fife:
_fife.Atlas_swigregister(Atlas)
class AtlasLoader(IAtlasLoader):
    r"""Proxy of C++ FIFE::AtlasLoader class."""

    thisown = 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):
        r"""__init__(AtlasLoader self, Model model, VFS vfs, ImageManager imageManager, AnimationManager animationManager) -> AtlasLoader"""
        _fife.AtlasLoader_swiginit(self, _fife.new_AtlasLoader(model, vfs, imageManager, animationManager))
    __swig_destroy__ = _fife.delete_AtlasLoader
    isLoadable = _swig_new_instance_method(_fife.AtlasLoader_isLoadable)
    load = _swig_new_instance_method(_fife.AtlasLoader_load)
    loadMultiple = _swig_new_instance_method(_fife.AtlasLoader_loadMultiple)

# Register AtlasLoader in _fife:
_fife.AtlasLoader_swigregister(AtlasLoader)
createDefaultAtlasLoader = _fife.createDefaultAtlasLoader
class IMapLoader(object):
    r"""Proxy of C++ FIFE::IMapLoader class."""

    thisown = 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
    setObjectLoader = _swig_new_instance_method(_fife.IMapLoader_setObjectLoader)
    setAnimationLoader = _swig_new_instance_method(_fife.IMapLoader_setAnimationLoader)
    setAtlasLoader = _swig_new_instance_method(_fife.IMapLoader_setAtlasLoader)
    isLoadable = _swig_new_instance_method(_fife.IMapLoader_isLoadable)
    load = _swig_new_instance_method(_fife.IMapLoader_load)

    def __init__(self):
        r"""__init__(IMapLoader self) -> IMapLoader"""
        if self.__class__ == IMapLoader:
            _self = None
        else:
            _self = self
        _fife.IMapLoader_swiginit(self, _fife.new_IMapLoader(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IMapLoader(self)
        return weakref.proxy(self)

# Register IMapLoader in _fife:
_fife.IMapLoader_swigregister(IMapLoader)
class IObjectLoader(object):
    r"""Proxy of C++ FIFE::IObjectLoader class."""

    thisown = 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
    setAnimationLoader = _swig_new_instance_method(_fife.IObjectLoader_setAnimationLoader)
    getAnimationLoader = _swig_new_instance_method(_fife.IObjectLoader_getAnimationLoader)
    setAtlasLoader = _swig_new_instance_method(_fife.IObjectLoader_setAtlasLoader)
    getAtlasLoader = _swig_new_instance_method(_fife.IObjectLoader_getAtlasLoader)
    isLoadable = _swig_new_instance_method(_fife.IObjectLoader_isLoadable)
    load = _swig_new_instance_method(_fife.IObjectLoader_load)

    def __init__(self):
        r"""__init__(IObjectLoader self) -> IObjectLoader"""
        if self.__class__ == IObjectLoader:
            _self = None
        else:
            _self = self
        _fife.IObjectLoader_swiginit(self, _fife.new_IObjectLoader(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IObjectLoader(self)
        return weakref.proxy(self)

# Register IObjectLoader in _fife:
_fife.IObjectLoader_swigregister(IObjectLoader)
class ObjectLoader(IObjectLoader):
    r"""Proxy of C++ FIFE::ObjectLoader class."""

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

    def __init__(self, *args, **kwargs):
        r"""__init__(ObjectLoader self, Model model, VFS vfs, ImageManager imageManager, AnimationManager animationManager, FIFE::AnimationLoaderPtr const & animationLoader=FIFE::AnimationLoaderPtr(), FIFE::AtlasLoaderPtr const & atlasLoader=FIFE::AtlasLoaderPtr()) -> ObjectLoader"""
        _fife.ObjectLoader_swiginit(self, _fife.new_ObjectLoader(*args, **kwargs))
    __swig_destroy__ = _fife.delete_ObjectLoader
    setAnimationLoader = _swig_new_instance_method(_fife.ObjectLoader_setAnimationLoader)
    getAnimationLoader = _swig_new_instance_method(_fife.ObjectLoader_getAnimationLoader)
    setAtlasLoader = _swig_new_instance_method(_fife.ObjectLoader_setAtlasLoader)
    getAtlasLoader = _swig_new_instance_method(_fife.ObjectLoader_getAtlasLoader)
    isLoadable = _swig_new_instance_method(_fife.ObjectLoader_isLoadable)
    load = _swig_new_instance_method(_fife.ObjectLoader_load)
    loadImportFile = _swig_new_instance_method(_fife.ObjectLoader_loadImportFile)
    loadImportDirectory = _swig_new_instance_method(_fife.ObjectLoader_loadImportDirectory)

# Register ObjectLoader in _fife:
_fife.ObjectLoader_swigregister(ObjectLoader)
class MapLoader(IMapLoader):
    r"""Proxy of C++ FIFE::MapLoader class."""

    thisown = 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):
        r"""__init__(MapLoader self, Model model, VFS vfs, ImageManager imageManager, RenderBackend renderBackend) -> MapLoader"""
        _fife.MapLoader_swiginit(self, _fife.new_MapLoader(model, vfs, imageManager, renderBackend))
    __swig_destroy__ = _fife.delete_MapLoader
    setObjectLoader = _swig_new_instance_method(_fife.MapLoader_setObjectLoader)
    getObjectLoader = _swig_new_instance_method(_fife.MapLoader_getObjectLoader)
    setAnimationLoader = _swig_new_instance_method(_fife.MapLoader_setAnimationLoader)
    getAnimationLoader = _swig_new_instance_method(_fife.MapLoader_getAnimationLoader)
    setAtlasLoader = _swig_new_instance_method(_fife.MapLoader_setAtlasLoader)
    getAtlasLoader = _swig_new_instance_method(_fife.MapLoader_getAtlasLoader)
    isLoadable = _swig_new_instance_method(_fife.MapLoader_isLoadable)
    load = _swig_new_instance_method(_fife.MapLoader_load)
    loadImportFile = _swig_new_instance_method(_fife.MapLoader_loadImportFile)
    loadImportDirectory = _swig_new_instance_method(_fife.MapLoader_loadImportDirectory)
    addPercentDoneListener = _swig_new_instance_method(_fife.MapLoader_addPercentDoneListener)
    getLoaderName = _swig_new_instance_method(_fife.MapLoader_getLoaderName)

# Register MapLoader in _fife:
_fife.MapLoader_swigregister(MapLoader)
createDefaultMapLoader = _fife.createDefaultMapLoader
class PercentDoneListener(object):
    r"""Proxy of C++ FIFE::PercentDoneListener class."""

    thisown = 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
    OnEvent = _swig_new_instance_method(_fife.PercentDoneListener_OnEvent)

    def __init__(self):
        r"""__init__(PercentDoneListener self) -> PercentDoneListener"""
        if self.__class__ == PercentDoneListener:
            _self = None
        else:
            _self = self
        _fife.PercentDoneListener_swiginit(self, _fife.new_PercentDoneListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_PercentDoneListener(self)
        return weakref.proxy(self)

# Register PercentDoneListener in _fife:
_fife.PercentDoneListener_swigregister(PercentDoneListener)
class IVisual(object):
    r"""Proxy of C++ FIFE::IVisual class."""

    thisown = 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

# Register IVisual in _fife:
_fife.IVisual_swigregister(IVisual)
class Action(FifeClass):
    r"""Proxy of C++ FIFE::Action class."""

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

    def __init__(self, identifier):
        r"""__init__(Action self, std::string const & identifier) -> Action"""
        _fife.Action_swiginit(self, _fife.new_Action(identifier))
    __swig_destroy__ = _fife.delete_Action
    getId = _swig_new_instance_method(_fife.Action_getId)
    adoptVisual = _swig_new_instance_method(_fife.Action_adoptVisual)
    setDuration = _swig_new_instance_method(_fife.Action_setDuration)
    getDuration = _swig_new_instance_method(_fife.Action_getDuration)
    get2dGfxVisual = _swig_new_instance_method(_fife.Action_get2dGfxVisual)

# Register Action in _fife:
_fife.Action_swigregister(Action)
class Location(object):
    r"""Proxy of C++ FIFE::Location class."""

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

    def __init__(self, *args):
        r"""
        __init__(Location self) -> Location
        __init__(Location self, Location loc) -> Location
        __init__(Location self, Layer layer) -> Location
        """
        _fife.Location_swiginit(self, _fife.new_Location(*args))
    __swig_destroy__ = _fife.delete_Location
    reset = _swig_new_instance_method(_fife.Location_reset)
    __eq__ = _swig_new_instance_method(_fife.Location___eq__)
    getMap = _swig_new_instance_method(_fife.Location_getMap)
    setLayer = _swig_new_instance_method(_fife.Location_setLayer)
    getLayer = _swig_new_instance_method(_fife.Location_getLayer)
    setExactLayerCoordinates = _swig_new_instance_method(_fife.Location_setExactLayerCoordinates)
    setLayerCoordinates = _swig_new_instance_method(_fife.Location_setLayerCoordinates)
    setMapCoordinates = _swig_new_instance_method(_fife.Location_setMapCoordinates)
    getExactLayerCoordinatesRef = _swig_new_instance_method(_fife.Location_getExactLayerCoordinatesRef)
    getExactLayerCoordinates = _swig_new_instance_method(_fife.Location_getExactLayerCoordinates)
    getLayerCoordinates = _swig_new_instance_method(_fife.Location_getLayerCoordinates)
    getMapCoordinates = _swig_new_instance_method(_fife.Location_getMapCoordinates)
    isValid = _swig_new_instance_method(_fife.Location_isValid)
    getCellOffsetDistance = _swig_new_instance_method(_fife.Location_getCellOffsetDistance)
    getMapDistanceTo = _swig_new_instance_method(_fife.Location_getMapDistanceTo)
    getLayerDistanceTo = _swig_new_instance_method(_fife.Location_getLayerDistanceTo)

# Register Location in _fife:
_fife.Location_swigregister(Location)
__lshift__ = _fife.__lshift__
class LocationVector(object):
    r"""Proxy of C++ std::vector< FIFE::Location > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.LocationVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.LocationVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.LocationVector___bool__)
    __len__ = _swig_new_instance_method(_fife.LocationVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.LocationVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.LocationVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.LocationVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.LocationVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.LocationVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.LocationVector___setitem__)
    pop = _swig_new_instance_method(_fife.LocationVector_pop)
    append = _swig_new_instance_method(_fife.LocationVector_append)
    empty = _swig_new_instance_method(_fife.LocationVector_empty)
    size = _swig_new_instance_method(_fife.LocationVector_size)
    swap = _swig_new_instance_method(_fife.LocationVector_swap)
    begin = _swig_new_instance_method(_fife.LocationVector_begin)
    end = _swig_new_instance_method(_fife.LocationVector_end)
    rbegin = _swig_new_instance_method(_fife.LocationVector_rbegin)
    rend = _swig_new_instance_method(_fife.LocationVector_rend)
    clear = _swig_new_instance_method(_fife.LocationVector_clear)
    get_allocator = _swig_new_instance_method(_fife.LocationVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.LocationVector_pop_back)
    erase = _swig_new_instance_method(_fife.LocationVector_erase)

    def __init__(self, *args):
        r"""
        __init__(LocationVector self) -> LocationVector
        __init__(LocationVector self, LocationVector other) -> LocationVector
        __init__(LocationVector self, std::vector< FIFE::Location >::size_type size) -> LocationVector
        __init__(LocationVector self, std::vector< FIFE::Location >::size_type size, Location value) -> LocationVector
        """
        _fife.LocationVector_swiginit(self, _fife.new_LocationVector(*args))
    push_back = _swig_new_instance_method(_fife.LocationVector_push_back)
    front = _swig_new_instance_method(_fife.LocationVector_front)
    back = _swig_new_instance_method(_fife.LocationVector_back)
    assign = _swig_new_instance_method(_fife.LocationVector_assign)
    resize = _swig_new_instance_method(_fife.LocationVector_resize)
    insert = _swig_new_instance_method(_fife.LocationVector_insert)
    reserve = _swig_new_instance_method(_fife.LocationVector_reserve)
    capacity = _swig_new_instance_method(_fife.LocationVector_capacity)
    __swig_destroy__ = _fife.delete_LocationVector

# Register LocationVector in _fife:
_fife.LocationVector_swigregister(LocationVector)
class InstanceActionListener(object):
    r"""Proxy of C++ FIFE::InstanceActionListener class."""

    thisown = 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
    onInstanceActionFinished = _swig_new_instance_method(_fife.InstanceActionListener_onInstanceActionFinished)
    onInstanceActionCancelled = _swig_new_instance_method(_fife.InstanceActionListener_onInstanceActionCancelled)
    onInstanceActionFrame = _swig_new_instance_method(_fife.InstanceActionListener_onInstanceActionFrame)

    def __init__(self):
        r"""__init__(InstanceActionListener self) -> InstanceActionListener"""
        if self.__class__ == InstanceActionListener:
            _self = None
        else:
            _self = self
        _fife.InstanceActionListener_swiginit(self, _fife.new_InstanceActionListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_InstanceActionListener(self)
        return weakref.proxy(self)

# Register InstanceActionListener in _fife:
_fife.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):
    r"""Proxy of C++ FIFE::InstanceChangeListener class."""

    thisown = 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
    onInstanceChanged = _swig_new_instance_method(_fife.InstanceChangeListener_onInstanceChanged)

    def __init__(self):
        r"""__init__(InstanceChangeListener self) -> InstanceChangeListener"""
        if self.__class__ == InstanceChangeListener:
            _self = None
        else:
            _self = self
        _fife.InstanceChangeListener_swiginit(self, _fife.new_InstanceChangeListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_InstanceChangeListener(self)
        return weakref.proxy(self)

# Register InstanceChangeListener in _fife:
_fife.InstanceChangeListener_swigregister(InstanceChangeListener)
class InstanceDeleteListener(object):
    r"""Proxy of C++ FIFE::InstanceDeleteListener class."""

    thisown = 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
    onInstanceDeleted = _swig_new_instance_method(_fife.InstanceDeleteListener_onInstanceDeleted)

    def __init__(self):
        r"""__init__(InstanceDeleteListener self) -> InstanceDeleteListener"""
        if self.__class__ == InstanceDeleteListener:
            _self = None
        else:
            _self = self
        _fife.InstanceDeleteListener_swiginit(self, _fife.new_InstanceDeleteListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_InstanceDeleteListener(self)
        return weakref.proxy(self)

# Register InstanceDeleteListener in _fife:
_fife.InstanceDeleteListener_swigregister(InstanceDeleteListener)
class Instance(FifeClass):
    r"""Proxy of C++ FIFE::Instance class."""

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

    def __init__(self, *args, **kwargs):
        r"""__init__(Instance self, Object object, Location location, std::string const & identifier="") -> Instance"""
        _fife.Instance_swiginit(self, _fife.new_Instance(*args, **kwargs))
    __swig_destroy__ = _fife.delete_Instance
    getId = _swig_new_instance_method(_fife.Instance_getId)
    setId = _swig_new_instance_method(_fife.Instance_setId)
    getObject = _swig_new_instance_method(_fife.Instance_getObject)
    setLocation = _swig_new_instance_method(_fife.Instance_setLocation)
    getLocation = _swig_new_instance_method(_fife.Instance_getLocation)
    getLocationRef = _swig_new_instance_method(_fife.Instance_getLocationRef)
    getTargetLocation = _swig_new_instance_method(_fife.Instance_getTargetLocation)
    setRotation = _swig_new_instance_method(_fife.Instance_setRotation)
    getRotation = _swig_new_instance_method(_fife.Instance_getRotation)
    getOldRotation = _swig_new_instance_method(_fife.Instance_getOldRotation)
    setBlocking = _swig_new_instance_method(_fife.Instance_setBlocking)
    isBlocking = _swig_new_instance_method(_fife.Instance_isBlocking)
    setOverrideBlocking = _swig_new_instance_method(_fife.Instance_setOverrideBlocking)
    isOverrideBlocking = _swig_new_instance_method(_fife.Instance_isOverrideBlocking)
    addActionListener = _swig_new_instance_method(_fife.Instance_addActionListener)
    removeActionListener = _swig_new_instance_method(_fife.Instance_removeActionListener)
    addChangeListener = _swig_new_instance_method(_fife.Instance_addChangeListener)
    removeChangeListener = _swig_new_instance_method(_fife.Instance_removeChangeListener)
    addDeleteListener = _swig_new_instance_method(_fife.Instance_addDeleteListener)
    removeDeleteListener = _swig_new_instance_method(_fife.Instance_removeDeleteListener)
    getCurrentAction = _swig_new_instance_method(_fife.Instance_getCurrentAction)
    getMovementSpeed = _swig_new_instance_method(_fife.Instance_getMovementSpeed)
    setFacingLocation = _swig_new_instance_method(_fife.Instance_setFacingLocation)
    getFacingLocation = _swig_new_instance_method(_fife.Instance_getFacingLocation)
    getActionRuntime = _swig_new_instance_method(_fife.Instance_getActionRuntime)
    setActionRuntime = _swig_new_instance_method(_fife.Instance_setActionRuntime)
    move = _swig_new_instance_method(_fife.Instance_move)
    actOnce = _swig_new_instance_method(_fife.Instance_actOnce)
    actRepeat = _swig_new_instance_method(_fife.Instance_actRepeat)
    follow = _swig_new_instance_method(_fife.Instance_follow)
    cancelMovement = _swig_new_instance_method(_fife.Instance_cancelMovement)
    say = _swig_new_instance_method(_fife.Instance_say)
    setTimeMultiplier = _swig_new_instance_method(_fife.Instance_setTimeMultiplier)
    getTimeMultiplier = _swig_new_instance_method(_fife.Instance_getTimeMultiplier)
    getRuntime = _swig_new_instance_method(_fife.Instance_getRuntime)
    refresh = _swig_new_instance_method(_fife.Instance_refresh)
    getChangeInfo = _swig_new_instance_method(_fife.Instance_getChangeInfo)
    setVisual = _swig_new_instance_method(_fife.Instance_setVisual)
    getRoute = _swig_new_instance_method(_fife.Instance_getRoute)
    setCellStackPosition = _swig_new_instance_method(_fife.Instance_setCellStackPosition)
    getCellStackPosition = _swig_new_instance_method(_fife.Instance_getCellStackPosition)
    isSpecialCost = _swig_new_instance_method(_fife.Instance_isSpecialCost)
    setCost = _swig_new_instance_method(_fife.Instance_setCost)
    resetCost = _swig_new_instance_method(_fife.Instance_resetCost)
    getCost = _swig_new_instance_method(_fife.Instance_getCost)
    getCostId = _swig_new_instance_method(_fife.Instance_getCostId)
    getSpeed = _swig_new_instance_method(_fife.Instance_getSpeed)
    isSpecialSpeed = _swig_new_instance_method(_fife.Instance_isSpecialSpeed)
    isMultiCell = _swig_new_instance_method(_fife.Instance_isMultiCell)
    isMultiObject = _swig_new_instance_method(_fife.Instance_isMultiObject)
    getMultiInstances = _swig_new_instance_method(_fife.Instance_getMultiInstances)
    getMainMultiInstance = _swig_new_instance_method(_fife.Instance_getMainMultiInstance)
    addStaticColorOverlay = _swig_new_instance_method(_fife.Instance_addStaticColorOverlay)
    getStaticColorOverlay = _swig_new_instance_method(_fife.Instance_getStaticColorOverlay)
    removeStaticColorOverlay = _swig_new_instance_method(_fife.Instance_removeStaticColorOverlay)
    isStaticColorOverlay = _swig_new_instance_method(_fife.Instance_isStaticColorOverlay)
    addAnimationOverlay = _swig_new_instance_method(_fife.Instance_addAnimationOverlay)
    getAnimationOverlay = _swig_new_instance_method(_fife.Instance_getAnimationOverlay)
    removeAnimationOverlay = _swig_new_instance_method(_fife.Instance_removeAnimationOverlay)
    addColorOverlay = _swig_new_instance_method(_fife.Instance_addColorOverlay)
    getColorOverlay = _swig_new_instance_method(_fife.Instance_getColorOverlay)
    removeColorOverlay = _swig_new_instance_method(_fife.Instance_removeColorOverlay)
    convertToOverlays = _swig_new_instance_method(_fife.Instance_convertToOverlays)
    isAnimationOverlay = _swig_new_instance_method(_fife.Instance_isAnimationOverlay)
    isColorOverlay = _swig_new_instance_method(_fife.Instance_isColorOverlay)
    get2dGfxVisual = _swig_new_instance_method(_fife.Instance_get2dGfxVisual)

# Register Instance in _fife:
_fife.Instance_swigregister(Instance)
class InstanceVector(object):
    r"""Proxy of C++ std::vector< FIFE::Instance * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.InstanceVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.InstanceVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.InstanceVector___bool__)
    __len__ = _swig_new_instance_method(_fife.InstanceVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.InstanceVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.InstanceVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.InstanceVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.InstanceVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.InstanceVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.InstanceVector___setitem__)
    pop = _swig_new_instance_method(_fife.InstanceVector_pop)
    append = _swig_new_instance_method(_fife.InstanceVector_append)
    empty = _swig_new_instance_method(_fife.InstanceVector_empty)
    size = _swig_new_instance_method(_fife.InstanceVector_size)
    swap = _swig_new_instance_method(_fife.InstanceVector_swap)
    begin = _swig_new_instance_method(_fife.InstanceVector_begin)
    end = _swig_new_instance_method(_fife.InstanceVector_end)
    rbegin = _swig_new_instance_method(_fife.InstanceVector_rbegin)
    rend = _swig_new_instance_method(_fife.InstanceVector_rend)
    clear = _swig_new_instance_method(_fife.InstanceVector_clear)
    get_allocator = _swig_new_instance_method(_fife.InstanceVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.InstanceVector_pop_back)
    erase = _swig_new_instance_method(_fife.InstanceVector_erase)

    def __init__(self, *args):
        r"""
        __init__(InstanceVector self) -> InstanceVector
        __init__(InstanceVector self, InstanceVector other) -> InstanceVector
        __init__(InstanceVector self, std::vector< FIFE::Instance * >::size_type size) -> InstanceVector
        __init__(InstanceVector self, std::vector< FIFE::Instance * >::size_type size, Instance value) -> InstanceVector
        """
        _fife.InstanceVector_swiginit(self, _fife.new_InstanceVector(*args))
    push_back = _swig_new_instance_method(_fife.InstanceVector_push_back)
    front = _swig_new_instance_method(_fife.InstanceVector_front)
    back = _swig_new_instance_method(_fife.InstanceVector_back)
    assign = _swig_new_instance_method(_fife.InstanceVector_assign)
    resize = _swig_new_instance_method(_fife.InstanceVector_resize)
    insert = _swig_new_instance_method(_fife.InstanceVector_insert)
    reserve = _swig_new_instance_method(_fife.InstanceVector_reserve)
    capacity = _swig_new_instance_method(_fife.InstanceVector_capacity)
    __swig_destroy__ = _fife.delete_InstanceVector

# Register InstanceVector in _fife:
_fife.InstanceVector_swigregister(InstanceVector)
class InstanceList(object):
    r"""Proxy of C++ std::list< FIFE::Instance * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.InstanceList_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.InstanceList___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.InstanceList___bool__)
    __len__ = _swig_new_instance_method(_fife.InstanceList___len__)
    __getslice__ = _swig_new_instance_method(_fife.InstanceList___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.InstanceList___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.InstanceList___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.InstanceList___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.InstanceList___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.InstanceList___setitem__)
    pop = _swig_new_instance_method(_fife.InstanceList_pop)
    append = _swig_new_instance_method(_fife.InstanceList_append)
    empty = _swig_new_instance_method(_fife.InstanceList_empty)
    size = _swig_new_instance_method(_fife.InstanceList_size)
    swap = _swig_new_instance_method(_fife.InstanceList_swap)
    begin = _swig_new_instance_method(_fife.InstanceList_begin)
    end = _swig_new_instance_method(_fife.InstanceList_end)
    rbegin = _swig_new_instance_method(_fife.InstanceList_rbegin)
    rend = _swig_new_instance_method(_fife.InstanceList_rend)
    clear = _swig_new_instance_method(_fife.InstanceList_clear)
    get_allocator = _swig_new_instance_method(_fife.InstanceList_get_allocator)
    pop_back = _swig_new_instance_method(_fife.InstanceList_pop_back)
    erase = _swig_new_instance_method(_fife.InstanceList_erase)

    def __init__(self, *args):
        r"""
        __init__(InstanceList self) -> InstanceList
        __init__(InstanceList self, InstanceList other) -> InstanceList
        __init__(InstanceList self, std::list< FIFE::Instance * >::size_type size) -> InstanceList
        __init__(InstanceList self, std::list< FIFE::Instance * >::size_type size, Instance value) -> InstanceList
        """
        _fife.InstanceList_swiginit(self, _fife.new_InstanceList(*args))
    push_back = _swig_new_instance_method(_fife.InstanceList_push_back)
    front = _swig_new_instance_method(_fife.InstanceList_front)
    back = _swig_new_instance_method(_fife.InstanceList_back)
    assign = _swig_new_instance_method(_fife.InstanceList_assign)
    resize = _swig_new_instance_method(_fife.InstanceList_resize)
    insert = _swig_new_instance_method(_fife.InstanceList_insert)
    pop_front = _swig_new_instance_method(_fife.InstanceList_pop_front)
    push_front = _swig_new_instance_method(_fife.InstanceList_push_front)
    remove = _swig_new_instance_method(_fife.InstanceList_remove)
    unique = _swig_new_instance_method(_fife.InstanceList_unique)
    reverse = _swig_new_instance_method(_fife.InstanceList_reverse)
    sort = _swig_new_instance_method(_fife.InstanceList_sort)
    merge = _swig_new_instance_method(_fife.InstanceList_merge)
    __swig_destroy__ = _fife.delete_InstanceList

# Register InstanceList in _fife:
_fife.InstanceList_swigregister(InstanceList)
class AnimationOverlayMap(object):
    r"""Proxy of C++ std::map< int32_t,FIFE::AnimationPtr > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.AnimationOverlayMap_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.AnimationOverlayMap___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.AnimationOverlayMap___bool__)
    __len__ = _swig_new_instance_method(_fife.AnimationOverlayMap___len__)
    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()
    __getitem__ = _swig_new_instance_method(_fife.AnimationOverlayMap___getitem__)
    __delitem__ = _swig_new_instance_method(_fife.AnimationOverlayMap___delitem__)
    has_key = _swig_new_instance_method(_fife.AnimationOverlayMap_has_key)
    keys = _swig_new_instance_method(_fife.AnimationOverlayMap_keys)
    values = _swig_new_instance_method(_fife.AnimationOverlayMap_values)
    items = _swig_new_instance_method(_fife.AnimationOverlayMap_items)
    __contains__ = _swig_new_instance_method(_fife.AnimationOverlayMap___contains__)
    key_iterator = _swig_new_instance_method(_fife.AnimationOverlayMap_key_iterator)
    value_iterator = _swig_new_instance_method(_fife.AnimationOverlayMap_value_iterator)
    __setitem__ = _swig_new_instance_method(_fife.AnimationOverlayMap___setitem__)
    asdict = _swig_new_instance_method(_fife.AnimationOverlayMap_asdict)

    def __init__(self, *args):
        r"""
        __init__(AnimationOverlayMap self, std::less< int > const & other) -> AnimationOverlayMap
        __init__(AnimationOverlayMap self) -> AnimationOverlayMap
        __init__(AnimationOverlayMap self, AnimationOverlayMap other) -> AnimationOverlayMap
        """
        _fife.AnimationOverlayMap_swiginit(self, _fife.new_AnimationOverlayMap(*args))
    empty = _swig_new_instance_method(_fife.AnimationOverlayMap_empty)
    size = _swig_new_instance_method(_fife.AnimationOverlayMap_size)
    swap = _swig_new_instance_method(_fife.AnimationOverlayMap_swap)
    begin = _swig_new_instance_method(_fife.AnimationOverlayMap_begin)
    end = _swig_new_instance_method(_fife.AnimationOverlayMap_end)
    rbegin = _swig_new_instance_method(_fife.AnimationOverlayMap_rbegin)
    rend = _swig_new_instance_method(_fife.AnimationOverlayMap_rend)
    clear = _swig_new_instance_method(_fife.AnimationOverlayMap_clear)
    get_allocator = _swig_new_instance_method(_fife.AnimationOverlayMap_get_allocator)
    count = _swig_new_instance_method(_fife.AnimationOverlayMap_count)
    erase = _swig_new_instance_method(_fife.AnimationOverlayMap_erase)
    find = _swig_new_instance_method(_fife.AnimationOverlayMap_find)
    lower_bound = _swig_new_instance_method(_fife.AnimationOverlayMap_lower_bound)
    upper_bound = _swig_new_instance_method(_fife.AnimationOverlayMap_upper_bound)
    __swig_destroy__ = _fife.delete_AnimationOverlayMap

# Register AnimationOverlayMap in _fife:
_fife.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):
    r"""Proxy of C++ FIFE::Route class."""

    thisown = 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):
        r"""__init__(Route self, Location start, Location end) -> Route"""
        _fife.Route_swiginit(self, _fife.new_Route(start, end))
    __swig_destroy__ = _fife.delete_Route
    setRouteStatus = _swig_new_instance_method(_fife.Route_setRouteStatus)
    getRouteStatus = _swig_new_instance_method(_fife.Route_getRouteStatus)
    setStartNode = _swig_new_instance_method(_fife.Route_setStartNode)
    getStartNode = _swig_new_instance_method(_fife.Route_getStartNode)
    setEndNode = _swig_new_instance_method(_fife.Route_setEndNode)
    getEndNode = _swig_new_instance_method(_fife.Route_getEndNode)
    getCurrentNode = _swig_new_instance_method(_fife.Route_getCurrentNode)
    getPreviousNode = _swig_new_instance_method(_fife.Route_getPreviousNode)
    getNextNode = _swig_new_instance_method(_fife.Route_getNextNode)
    walkToNextNode = _swig_new_instance_method(_fife.Route_walkToNextNode)
    reachedEnd = _swig_new_instance_method(_fife.Route_reachedEnd)
    setPath = _swig_new_instance_method(_fife.Route_setPath)
    getPath = _swig_new_instance_method(_fife.Route_getPath)
    cutPath = _swig_new_instance_method(_fife.Route_cutPath)
    setReplanned = _swig_new_instance_method(_fife.Route_setReplanned)
    isReplanned = _swig_new_instance_method(_fife.Route_isReplanned)
    getPathLength = _swig_new_instance_method(_fife.Route_getPathLength)
    getWalkedLength = _swig_new_instance_method(_fife.Route_getWalkedLength)
    setSessionId = _swig_new_instance_method(_fife.Route_setSessionId)
    getSessionId = _swig_new_instance_method(_fife.Route_getSessionId)
    setRotation = _swig_new_instance_method(_fife.Route_setRotation)
    getRotation = _swig_new_instance_method(_fife.Route_getRotation)
    setCostId = _swig_new_instance_method(_fife.Route_setCostId)
    getCostId = _swig_new_instance_method(_fife.Route_getCostId)
    isMultiCell = _swig_new_instance_method(_fife.Route_isMultiCell)
    setOccupiedArea = _swig_new_instance_method(_fife.Route_setOccupiedArea)
    getOccupiedArea = _swig_new_instance_method(_fife.Route_getOccupiedArea)
    getOccupiedCells = _swig_new_instance_method(_fife.Route_getOccupiedCells)
    getZStepRange = _swig_new_instance_method(_fife.Route_getZStepRange)
    isAreaLimited = _swig_new_instance_method(_fife.Route_isAreaLimited)
    getLimitedAreas = _swig_new_instance_method(_fife.Route_getLimitedAreas)
    setDynamicBlockerIgnored = _swig_new_instance_method(_fife.Route_setDynamicBlockerIgnored)
    isDynamicBlockerIgnored = _swig_new_instance_method(_fife.Route_isDynamicBlockerIgnored)
    getBlockingPathLocations = _swig_new_instance_method(_fife.Route_getBlockingPathLocations)
    setObject = _swig_new_instance_method(_fife.Route_setObject)
    getObject = _swig_new_instance_method(_fife.Route_getObject)

# Register Route in _fife:
_fife.Route_swigregister(Route)
HIGH_PRIORITY = _fife.HIGH_PRIORITY

MEDIUM_PRIORITY = _fife.MEDIUM_PRIORITY

LOW_PRIORITY = _fife.LOW_PRIORITY

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

    thisown = 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
    createRoute = _swig_new_instance_method(_fife.IPather_createRoute)
    solveRoute = _swig_new_instance_method(_fife.IPather_solveRoute)
    followRoute = _swig_new_instance_method(_fife.IPather_followRoute)
    update = _swig_new_instance_method(_fife.IPather_update)
    cancelSession = _swig_new_instance_method(_fife.IPather_cancelSession)
    setMaxTicks = _swig_new_instance_method(_fife.IPather_setMaxTicks)
    getMaxTicks = _swig_new_instance_method(_fife.IPather_getMaxTicks)
    getName = _swig_new_instance_method(_fife.IPather_getName)

    def __init__(self):
        r"""__init__(IPather self) -> IPather"""
        if self.__class__ == IPather:
            _self = None
        else:
            _self = self
        _fife.IPather_swiginit(self, _fife.new_IPather(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IPather(self)
        return weakref.proxy(self)

# Register IPather in _fife:
_fife.IPather_swigregister(IPather)
class Object(object):
    r"""Proxy of C++ FIFE::Object class."""

    thisown = 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):
        r"""__init__(Object self, std::string const & identifier, std::string const & name_space, Object inherited=None) -> Object"""
        _fife.Object_swiginit(self, _fife.new_Object(identifier, name_space, inherited))
    __swig_destroy__ = _fife.delete_Object
    getId = _swig_new_instance_method(_fife.Object_getId)
    getNamespace = _swig_new_instance_method(_fife.Object_getNamespace)
    setId = _swig_new_instance_method(_fife.Object_setId)
    createAction = _swig_new_instance_method(_fife.Object_createAction)
    getAction = _swig_new_instance_method(_fife.Object_getAction)
    getActionIds = _swig_new_instance_method(_fife.Object_getActionIds)
    setDefaultAction = _swig_new_instance_method(_fife.Object_setDefaultAction)
    getDefaultAction = _swig_new_instance_method(_fife.Object_getDefaultAction)
    setPather = _swig_new_instance_method(_fife.Object_setPather)
    getPather = _swig_new_instance_method(_fife.Object_getPather)
    getInherited = _swig_new_instance_method(_fife.Object_getInherited)
    adoptVisual = _swig_new_instance_method(_fife.Object_adoptVisual)
    setBlocking = _swig_new_instance_method(_fife.Object_setBlocking)
    isBlocking = _swig_new_instance_method(_fife.Object_isBlocking)
    setStatic = _swig_new_instance_method(_fife.Object_setStatic)
    isStatic = _swig_new_instance_method(_fife.Object_isStatic)
    setFilename = _swig_new_instance_method(_fife.Object_setFilename)
    getFilename = _swig_new_instance_method(_fife.Object_getFilename)
    setCellStackPosition = _swig_new_instance_method(_fife.Object_setCellStackPosition)
    getCellStackPosition = _swig_new_instance_method(_fife.Object_getCellStackPosition)
    isSpecialCost = _swig_new_instance_method(_fife.Object_isSpecialCost)
    setCostId = _swig_new_instance_method(_fife.Object_setCostId)
    getCostId = _swig_new_instance_method(_fife.Object_getCostId)
    setCost = _swig_new_instance_method(_fife.Object_setCost)
    getCost = _swig_new_instance_method(_fife.Object_getCost)
    isSpecialSpeed = _swig_new_instance_method(_fife.Object_isSpecialSpeed)
    setSpeed = _swig_new_instance_method(_fife.Object_setSpeed)
    getSpeed = _swig_new_instance_method(_fife.Object_getSpeed)
    isMultiObject = _swig_new_instance_method(_fife.Object_isMultiObject)
    addMultiPartId = _swig_new_instance_method(_fife.Object_addMultiPartId)
    getMultiPartIds = _swig_new_instance_method(_fife.Object_getMultiPartIds)
    removeMultiPartId = _swig_new_instance_method(_fife.Object_removeMultiPartId)
    removeAllMultiPartIds = _swig_new_instance_method(_fife.Object_removeAllMultiPartIds)
    isMultiPart = _swig_new_instance_method(_fife.Object_isMultiPart)
    setMultiPart = _swig_new_instance_method(_fife.Object_setMultiPart)
    addMultiPart = _swig_new_instance_method(_fife.Object_addMultiPart)
    getMultiParts = _swig_new_instance_method(_fife.Object_getMultiParts)
    removeMultiPart = _swig_new_instance_method(_fife.Object_removeMultiPart)
    removeMultiParts = _swig_new_instance_method(_fife.Object_removeMultiParts)
    addMultiPartCoordinate = _swig_new_instance_method(_fife.Object_addMultiPartCoordinate)
    getMultiPartCoordinates = _swig_new_instance_method(_fife.Object_getMultiPartCoordinates)
    getMultiObjectCoordinates = _swig_new_instance_method(_fife.Object_getMultiObjectCoordinates)
    setRotationAnchor = _swig_new_instance_method(_fife.Object_setRotationAnchor)
    getRotationAnchor = _swig_new_instance_method(_fife.Object_getRotationAnchor)
    setRestrictedRotation = _swig_new_instance_method(_fife.Object_setRestrictedRotation)
    isRestrictedRotation = _swig_new_instance_method(_fife.Object_isRestrictedRotation)
    getRestrictedRotation = _swig_new_instance_method(_fife.Object_getRestrictedRotation)
    setZStepRange = _swig_new_instance_method(_fife.Object_setZStepRange)
    getZStepRange = _swig_new_instance_method(_fife.Object_getZStepRange)
    setArea = _swig_new_instance_method(_fife.Object_setArea)
    getArea = _swig_new_instance_method(_fife.Object_getArea)
    addWalkableArea = _swig_new_instance_method(_fife.Object_addWalkableArea)
    removeWalkableArea = _swig_new_instance_method(_fife.Object_removeWalkableArea)
    getWalkableAreas = _swig_new_instance_method(_fife.Object_getWalkableAreas)
    __eq__ = _swig_new_instance_method(_fife.Object___eq__)
    __ne__ = _swig_new_instance_method(_fife.Object___ne__)
    get2dGfxVisual = _swig_new_instance_method(_fife.Object_get2dGfxVisual)

# Register Object in _fife:
_fife.Object_swigregister(Object)
class TimeProvider(object):
    r"""Proxy of C++ FIFE::TimeProvider class."""

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

    def __init__(self, master):
        r"""__init__(TimeProvider self, TimeProvider master) -> TimeProvider"""
        _fife.TimeProvider_swiginit(self, _fife.new_TimeProvider(master))
    __swig_destroy__ = _fife.delete_TimeProvider
    setMultiplier = _swig_new_instance_method(_fife.TimeProvider_setMultiplier)
    getMultiplier = _swig_new_instance_method(_fife.TimeProvider_getMultiplier)
    getTotalMultiplier = _swig_new_instance_method(_fife.TimeProvider_getTotalMultiplier)
    getGameTime = _swig_new_instance_method(_fife.TimeProvider_getGameTime)

# Register TimeProvider in _fife:
_fife.TimeProvider_swigregister(TimeProvider)
class ModelCoordinateVector(object):
    r"""Proxy of C++ std::vector< FIFE::ModelCoordinate > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.ModelCoordinateVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.ModelCoordinateVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.ModelCoordinateVector___bool__)
    __len__ = _swig_new_instance_method(_fife.ModelCoordinateVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.ModelCoordinateVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.ModelCoordinateVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.ModelCoordinateVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.ModelCoordinateVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.ModelCoordinateVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.ModelCoordinateVector___setitem__)
    pop = _swig_new_instance_method(_fife.ModelCoordinateVector_pop)
    append = _swig_new_instance_method(_fife.ModelCoordinateVector_append)
    empty = _swig_new_instance_method(_fife.ModelCoordinateVector_empty)
    size = _swig_new_instance_method(_fife.ModelCoordinateVector_size)
    swap = _swig_new_instance_method(_fife.ModelCoordinateVector_swap)
    begin = _swig_new_instance_method(_fife.ModelCoordinateVector_begin)
    end = _swig_new_instance_method(_fife.ModelCoordinateVector_end)
    rbegin = _swig_new_instance_method(_fife.ModelCoordinateVector_rbegin)
    rend = _swig_new_instance_method(_fife.ModelCoordinateVector_rend)
    clear = _swig_new_instance_method(_fife.ModelCoordinateVector_clear)
    get_allocator = _swig_new_instance_method(_fife.ModelCoordinateVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.ModelCoordinateVector_pop_back)
    erase = _swig_new_instance_method(_fife.ModelCoordinateVector_erase)

    def __init__(self, *args):
        r"""
        __init__(ModelCoordinateVector self) -> ModelCoordinateVector
        __init__(ModelCoordinateVector self, ModelCoordinateVector other) -> ModelCoordinateVector
        __init__(ModelCoordinateVector self, std::vector< FIFE::PointType3D< int > >::size_type size) -> ModelCoordinateVector
        __init__(ModelCoordinateVector self, std::vector< FIFE::PointType3D< int > >::size_type size, Point3D value) -> ModelCoordinateVector
        """
        _fife.ModelCoordinateVector_swiginit(self, _fife.new_ModelCoordinateVector(*args))
    push_back = _swig_new_instance_method(_fife.ModelCoordinateVector_push_back)
    front = _swig_new_instance_method(_fife.ModelCoordinateVector_front)
    back = _swig_new_instance_method(_fife.ModelCoordinateVector_back)
    assign = _swig_new_instance_method(_fife.ModelCoordinateVector_assign)
    resize = _swig_new_instance_method(_fife.ModelCoordinateVector_resize)
    insert = _swig_new_instance_method(_fife.ModelCoordinateVector_insert)
    reserve = _swig_new_instance_method(_fife.ModelCoordinateVector_reserve)
    capacity = _swig_new_instance_method(_fife.ModelCoordinateVector_capacity)
    __swig_destroy__ = _fife.delete_ModelCoordinateVector

# Register ModelCoordinateVector in _fife:
_fife.ModelCoordinateVector_swigregister(ModelCoordinateVector)
class ExactModelCoordinateVector(object):
    r"""Proxy of C++ std::vector< FIFE::ExactModelCoordinate > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.ExactModelCoordinateVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.ExactModelCoordinateVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.ExactModelCoordinateVector___bool__)
    __len__ = _swig_new_instance_method(_fife.ExactModelCoordinateVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.ExactModelCoordinateVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.ExactModelCoordinateVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.ExactModelCoordinateVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.ExactModelCoordinateVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.ExactModelCoordinateVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.ExactModelCoordinateVector___setitem__)
    pop = _swig_new_instance_method(_fife.ExactModelCoordinateVector_pop)
    append = _swig_new_instance_method(_fife.ExactModelCoordinateVector_append)
    empty = _swig_new_instance_method(_fife.ExactModelCoordinateVector_empty)
    size = _swig_new_instance_method(_fife.ExactModelCoordinateVector_size)
    swap = _swig_new_instance_method(_fife.ExactModelCoordinateVector_swap)
    begin = _swig_new_instance_method(_fife.ExactModelCoordinateVector_begin)
    end = _swig_new_instance_method(_fife.ExactModelCoordinateVector_end)
    rbegin = _swig_new_instance_method(_fife.ExactModelCoordinateVector_rbegin)
    rend = _swig_new_instance_method(_fife.ExactModelCoordinateVector_rend)
    clear = _swig_new_instance_method(_fife.ExactModelCoordinateVector_clear)
    get_allocator = _swig_new_instance_method(_fife.ExactModelCoordinateVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.ExactModelCoordinateVector_pop_back)
    erase = _swig_new_instance_method(_fife.ExactModelCoordinateVector_erase)

    def __init__(self, *args):
        r"""
        __init__(ExactModelCoordinateVector self) -> ExactModelCoordinateVector
        __init__(ExactModelCoordinateVector self, ExactModelCoordinateVector other) -> ExactModelCoordinateVector
        __init__(ExactModelCoordinateVector self, std::vector< FIFE::PointType3D< double > >::size_type size) -> ExactModelCoordinateVector
        __init__(ExactModelCoordinateVector self, std::vector< FIFE::PointType3D< double > >::size_type size, DoublePoint3D value) -> ExactModelCoordinateVector
        """
        _fife.ExactModelCoordinateVector_swiginit(self, _fife.new_ExactModelCoordinateVector(*args))
    push_back = _swig_new_instance_method(_fife.ExactModelCoordinateVector_push_back)
    front = _swig_new_instance_method(_fife.ExactModelCoordinateVector_front)
    back = _swig_new_instance_method(_fife.ExactModelCoordinateVector_back)
    assign = _swig_new_instance_method(_fife.ExactModelCoordinateVector_assign)
    resize = _swig_new_instance_method(_fife.ExactModelCoordinateVector_resize)
    insert = _swig_new_instance_method(_fife.ExactModelCoordinateVector_insert)
    reserve = _swig_new_instance_method(_fife.ExactModelCoordinateVector_reserve)
    capacity = _swig_new_instance_method(_fife.ExactModelCoordinateVector_capacity)
    __swig_destroy__ = _fife.delete_ExactModelCoordinateVector

# Register ExactModelCoordinateVector in _fife:
_fife.ExactModelCoordinateVector_swigregister(ExactModelCoordinateVector)
class CellGrid(object):
    r"""Proxy of C++ FIFE::CellGrid class."""

    thisown = 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
    getAccessibleCoordinates = _swig_new_instance_method(_fife.CellGrid_getAccessibleCoordinates)
    getType = _swig_new_instance_method(_fife.CellGrid_getType)
    getName = _swig_new_instance_method(_fife.CellGrid_getName)
    isAccessible = _swig_new_instance_method(_fife.CellGrid_isAccessible)
    getAdjacentCost = _swig_new_instance_method(_fife.CellGrid_getAdjacentCost)
    getHeuristicCost = _swig_new_instance_method(_fife.CellGrid_getHeuristicCost)
    getCellSideCount = _swig_new_instance_method(_fife.CellGrid_getCellSideCount)
    toMapCoordinates = _swig_new_instance_method(_fife.CellGrid_toMapCoordinates)
    toLayerCoordinates = _swig_new_instance_method(_fife.CellGrid_toLayerCoordinates)
    toExactLayerCoordinates = _swig_new_instance_method(_fife.CellGrid_toExactLayerCoordinates)
    toLayerCoordinatesFromExactLayerCoordinates = _swig_new_instance_method(_fife.CellGrid_toLayerCoordinatesFromExactLayerCoordinates)
    getVertices = _swig_new_instance_method(_fife.CellGrid_getVertices)
    getCoordinatesInLine = _swig_new_instance_method(_fife.CellGrid_getCoordinatesInLine)
    setXShift = _swig_new_instance_method(_fife.CellGrid_setXShift)
    getXShift = _swig_new_instance_method(_fife.CellGrid_getXShift)
    setYShift = _swig_new_instance_method(_fife.CellGrid_setYShift)
    getYShift = _swig_new_instance_method(_fife.CellGrid_getYShift)
    setZShift = _swig_new_instance_method(_fife.CellGrid_setZShift)
    getZShift = _swig_new_instance_method(_fife.CellGrid_getZShift)
    setXScale = _swig_new_instance_method(_fife.CellGrid_setXScale)
    setYScale = _swig_new_instance_method(_fife.CellGrid_setYScale)
    setZScale = _swig_new_instance_method(_fife.CellGrid_setZScale)
    getXScale = _swig_new_instance_method(_fife.CellGrid_getXScale)
    getYScale = _swig_new_instance_method(_fife.CellGrid_getYScale)
    getZScale = _swig_new_instance_method(_fife.CellGrid_getZScale)
    setRotation = _swig_new_instance_method(_fife.CellGrid_setRotation)
    getRotation = _swig_new_instance_method(_fife.CellGrid_getRotation)
    setAllowDiagonals = _swig_new_instance_method(_fife.CellGrid_setAllowDiagonals)
    getAllowDiagonals = _swig_new_instance_method(_fife.CellGrid_getAllowDiagonals)

# Register CellGrid in _fife:
_fife.CellGrid_swigregister(CellGrid)
class HexGrid(CellGrid):
    r"""Proxy of C++ FIFE::HexGrid class."""

    thisown = 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
    isAccessible = _swig_new_instance_method(_fife.HexGrid_isAccessible)
    getType = _swig_new_instance_method(_fife.HexGrid_getType)
    getName = _swig_new_instance_method(_fife.HexGrid_getName)
    getAdjacentCost = _swig_new_instance_method(_fife.HexGrid_getAdjacentCost)
    getCellSideCount = _swig_new_instance_method(_fife.HexGrid_getCellSideCount)
    toMapCoordinates = _swig_new_instance_method(_fife.HexGrid_toMapCoordinates)
    toLayerCoordinates = _swig_new_instance_method(_fife.HexGrid_toLayerCoordinates)
    toExactLayerCoordinates = _swig_new_instance_method(_fife.HexGrid_toExactLayerCoordinates)
    toLayerCoordinatesFromExactLayerCoordinates = _swig_new_instance_method(_fife.HexGrid_toLayerCoordinatesFromExactLayerCoordinates)
    getVertices = _swig_new_instance_method(_fife.HexGrid_getVertices)
    getCoordinatesInLine = _swig_new_instance_method(_fife.HexGrid_getCoordinatesInLine)

# Register HexGrid in _fife:
_fife.HexGrid_swigregister(HexGrid)
class SquareGrid(CellGrid):
    r"""Proxy of C++ FIFE::SquareGrid class."""

    thisown = 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
    getType = _swig_new_instance_method(_fife.SquareGrid_getType)
    getName = _swig_new_instance_method(_fife.SquareGrid_getName)
    isAccessible = _swig_new_instance_method(_fife.SquareGrid_isAccessible)
    getAdjacentCost = _swig_new_instance_method(_fife.SquareGrid_getAdjacentCost)
    getCellSideCount = _swig_new_instance_method(_fife.SquareGrid_getCellSideCount)
    toMapCoordinates = _swig_new_instance_method(_fife.SquareGrid_toMapCoordinates)
    toLayerCoordinates = _swig_new_instance_method(_fife.SquareGrid_toLayerCoordinates)
    toExactLayerCoordinates = _swig_new_instance_method(_fife.SquareGrid_toExactLayerCoordinates)
    toLayerCoordinatesFromExactLayerCoordinates = _swig_new_instance_method(_fife.SquareGrid_toLayerCoordinatesFromExactLayerCoordinates)
    getVertices = _swig_new_instance_method(_fife.SquareGrid_getVertices)
    getCoordinatesInLine = _swig_new_instance_method(_fife.SquareGrid_getCoordinatesInLine)

# Register SquareGrid in _fife:
_fife.SquareGrid_swigregister(SquareGrid)
CTYPE_NO_BLOCKER = _fife.CTYPE_NO_BLOCKER

CTYPE_STATIC_BLOCKER = _fife.CTYPE_STATIC_BLOCKER

CTYPE_DYNAMIC_BLOCKER = _fife.CTYPE_DYNAMIC_BLOCKER

CTYPE_CELL_NO_BLOCKER = _fife.CTYPE_CELL_NO_BLOCKER

CTYPE_CELL_BLOCKER = _fife.CTYPE_CELL_BLOCKER

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

    thisown = 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
    onInstanceEnteredCell = _swig_new_instance_method(_fife.CellChangeListener_onInstanceEnteredCell)
    onInstanceExitedCell = _swig_new_instance_method(_fife.CellChangeListener_onInstanceExitedCell)
    onBlockingChangedCell = _swig_new_instance_method(_fife.CellChangeListener_onBlockingChangedCell)

    def __init__(self):
        r"""__init__(CellChangeListener self) -> CellChangeListener"""
        if self.__class__ == CellChangeListener:
            _self = None
        else:
            _self = self
        _fife.CellChangeListener_swiginit(self, _fife.new_CellChangeListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_CellChangeListener(self)
        return weakref.proxy(self)

# Register CellChangeListener in _fife:
_fife.CellChangeListener_swigregister(CellChangeListener)
class CellDeleteListener(object):
    r"""Proxy of C++ FIFE::CellDeleteListener class."""

    thisown = 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
    onCellDeleted = _swig_new_instance_method(_fife.CellDeleteListener_onCellDeleted)

    def __init__(self):
        r"""__init__(CellDeleteListener self) -> CellDeleteListener"""
        if self.__class__ == CellDeleteListener:
            _self = None
        else:
            _self = self
        _fife.CellDeleteListener_swiginit(self, _fife.new_CellDeleteListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_CellDeleteListener(self)
        return weakref.proxy(self)

# Register CellDeleteListener in _fife:
_fife.CellDeleteListener_swigregister(CellDeleteListener)
class Cell(FifeClass):
    r"""Proxy of C++ FIFE::Cell class."""

    thisown = 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):
        r"""__init__(Cell self, int32_t coordint, Point3D coordinate, Layer layer) -> Cell"""
        _fife.Cell_swiginit(self, _fife.new_Cell(coordint, coordinate, layer))
    __swig_destroy__ = _fife.delete_Cell
    addInstances = _swig_new_instance_method(_fife.Cell_addInstances)
    addInstance = _swig_new_instance_method(_fife.Cell_addInstance)
    changeInstance = _swig_new_instance_method(_fife.Cell_changeInstance)
    removeInstance = _swig_new_instance_method(_fife.Cell_removeInstance)
    isNeighbor = _swig_new_instance_method(_fife.Cell_isNeighbor)
    getNeighbors = _swig_new_instance_method(_fife.Cell_getNeighbors)
    updateCellInfo = _swig_new_instance_method(_fife.Cell_updateCellInfo)
    getCellId = _swig_new_instance_method(_fife.Cell_getCellId)
    getLayerCoordinates = _swig_new_instance_method(_fife.Cell_getLayerCoordinates)
    defaultCost = _swig_new_instance_method(_fife.Cell_defaultCost)
    setCostMultiplier = _swig_new_instance_method(_fife.Cell_setCostMultiplier)
    getCostMultiplier = _swig_new_instance_method(_fife.Cell_getCostMultiplier)
    resetCostMultiplier = _swig_new_instance_method(_fife.Cell_resetCostMultiplier)
    defaultSpeed = _swig_new_instance_method(_fife.Cell_defaultSpeed)
    setSpeedMultiplier = _swig_new_instance_method(_fife.Cell_setSpeedMultiplier)
    getSpeedMultiplier = _swig_new_instance_method(_fife.Cell_getSpeedMultiplier)
    resetSpeedMultiplier = _swig_new_instance_method(_fife.Cell_resetSpeedMultiplier)
    getInstances = _swig_new_instance_method(_fife.Cell_getInstances)
    setCellType = _swig_new_instance_method(_fife.Cell_setCellType)
    getCellType = _swig_new_instance_method(_fife.Cell_getCellType)
    getLayer = _swig_new_instance_method(_fife.Cell_getLayer)
    createTransition = _swig_new_instance_method(_fife.Cell_createTransition)
    deleteTransition = _swig_new_instance_method(_fife.Cell_deleteTransition)
    addChangeListener = _swig_new_instance_method(_fife.Cell_addChangeListener)
    removeChangeListener = _swig_new_instance_method(_fife.Cell_removeChangeListener)
    addDeleteListener = _swig_new_instance_method(_fife.Cell_addDeleteListener)
    removeDeleteListener = _swig_new_instance_method(_fife.Cell_removeDeleteListener)

# Register Cell in _fife:
_fife.Cell_swigregister(Cell)
class InstanceSet(object):
    r"""Proxy of C++ std::set< FIFE::Instance * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.InstanceSet_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.InstanceSet___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.InstanceSet___bool__)
    __len__ = _swig_new_instance_method(_fife.InstanceSet___len__)
    append = _swig_new_instance_method(_fife.InstanceSet_append)
    __contains__ = _swig_new_instance_method(_fife.InstanceSet___contains__)
    __getitem__ = _swig_new_instance_method(_fife.InstanceSet___getitem__)
    add = _swig_new_instance_method(_fife.InstanceSet_add)
    discard = _swig_new_instance_method(_fife.InstanceSet_discard)

    def __init__(self, *args):
        r"""
        __init__(InstanceSet self, std::less< FIFE::Instance * > const & other) -> InstanceSet
        __init__(InstanceSet self) -> InstanceSet
        __init__(InstanceSet self, InstanceSet other) -> InstanceSet
        """
        _fife.InstanceSet_swiginit(self, _fife.new_InstanceSet(*args))
    empty = _swig_new_instance_method(_fife.InstanceSet_empty)
    size = _swig_new_instance_method(_fife.InstanceSet_size)
    clear = _swig_new_instance_method(_fife.InstanceSet_clear)
    swap = _swig_new_instance_method(_fife.InstanceSet_swap)
    count = _swig_new_instance_method(_fife.InstanceSet_count)
    begin = _swig_new_instance_method(_fife.InstanceSet_begin)
    end = _swig_new_instance_method(_fife.InstanceSet_end)
    rbegin = _swig_new_instance_method(_fife.InstanceSet_rbegin)
    rend = _swig_new_instance_method(_fife.InstanceSet_rend)
    erase = _swig_new_instance_method(_fife.InstanceSet_erase)
    find = _swig_new_instance_method(_fife.InstanceSet_find)
    lower_bound = _swig_new_instance_method(_fife.InstanceSet_lower_bound)
    upper_bound = _swig_new_instance_method(_fife.InstanceSet_upper_bound)
    equal_range = _swig_new_instance_method(_fife.InstanceSet_equal_range)
    insert = _swig_new_instance_method(_fife.InstanceSet_insert)
    __swig_destroy__ = _fife.delete_InstanceSet

# Register InstanceSet in _fife:
_fife.InstanceSet_swigregister(InstanceSet)
class CellSet(object):
    r"""Proxy of C++ std::set< FIFE::Cell * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.CellSet_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.CellSet___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.CellSet___bool__)
    __len__ = _swig_new_instance_method(_fife.CellSet___len__)
    append = _swig_new_instance_method(_fife.CellSet_append)
    __contains__ = _swig_new_instance_method(_fife.CellSet___contains__)
    __getitem__ = _swig_new_instance_method(_fife.CellSet___getitem__)
    add = _swig_new_instance_method(_fife.CellSet_add)
    discard = _swig_new_instance_method(_fife.CellSet_discard)

    def __init__(self, *args):
        r"""
        __init__(CellSet self, std::less< FIFE::Cell * > const & other) -> CellSet
        __init__(CellSet self) -> CellSet
        __init__(CellSet self, CellSet other) -> CellSet
        """
        _fife.CellSet_swiginit(self, _fife.new_CellSet(*args))
    empty = _swig_new_instance_method(_fife.CellSet_empty)
    size = _swig_new_instance_method(_fife.CellSet_size)
    clear = _swig_new_instance_method(_fife.CellSet_clear)
    swap = _swig_new_instance_method(_fife.CellSet_swap)
    count = _swig_new_instance_method(_fife.CellSet_count)
    begin = _swig_new_instance_method(_fife.CellSet_begin)
    end = _swig_new_instance_method(_fife.CellSet_end)
    rbegin = _swig_new_instance_method(_fife.CellSet_rbegin)
    rend = _swig_new_instance_method(_fife.CellSet_rend)
    erase = _swig_new_instance_method(_fife.CellSet_erase)
    find = _swig_new_instance_method(_fife.CellSet_find)
    lower_bound = _swig_new_instance_method(_fife.CellSet_lower_bound)
    upper_bound = _swig_new_instance_method(_fife.CellSet_upper_bound)
    equal_range = _swig_new_instance_method(_fife.CellSet_equal_range)
    insert = _swig_new_instance_method(_fife.CellSet_insert)
    __swig_destroy__ = _fife.delete_CellSet

# Register CellSet in _fife:
_fife.CellSet_swigregister(CellSet)
class CellVector(object):
    r"""Proxy of C++ std::vector< FIFE::Cell * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.CellVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.CellVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.CellVector___bool__)
    __len__ = _swig_new_instance_method(_fife.CellVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.CellVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.CellVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.CellVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.CellVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.CellVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.CellVector___setitem__)
    pop = _swig_new_instance_method(_fife.CellVector_pop)
    append = _swig_new_instance_method(_fife.CellVector_append)
    empty = _swig_new_instance_method(_fife.CellVector_empty)
    size = _swig_new_instance_method(_fife.CellVector_size)
    swap = _swig_new_instance_method(_fife.CellVector_swap)
    begin = _swig_new_instance_method(_fife.CellVector_begin)
    end = _swig_new_instance_method(_fife.CellVector_end)
    rbegin = _swig_new_instance_method(_fife.CellVector_rbegin)
    rend = _swig_new_instance_method(_fife.CellVector_rend)
    clear = _swig_new_instance_method(_fife.CellVector_clear)
    get_allocator = _swig_new_instance_method(_fife.CellVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.CellVector_pop_back)
    erase = _swig_new_instance_method(_fife.CellVector_erase)

    def __init__(self, *args):
        r"""
        __init__(CellVector self) -> CellVector
        __init__(CellVector self, CellVector other) -> CellVector
        __init__(CellVector self, std::vector< FIFE::Cell * >::size_type size) -> CellVector
        __init__(CellVector self, std::vector< FIFE::Cell * >::size_type size, Cell value) -> CellVector
        """
        _fife.CellVector_swiginit(self, _fife.new_CellVector(*args))
    push_back = _swig_new_instance_method(_fife.CellVector_push_back)
    front = _swig_new_instance_method(_fife.CellVector_front)
    back = _swig_new_instance_method(_fife.CellVector_back)
    assign = _swig_new_instance_method(_fife.CellVector_assign)
    resize = _swig_new_instance_method(_fife.CellVector_resize)
    insert = _swig_new_instance_method(_fife.CellVector_insert)
    reserve = _swig_new_instance_method(_fife.CellVector_reserve)
    capacity = _swig_new_instance_method(_fife.CellVector_capacity)
    __swig_destroy__ = _fife.delete_CellVector

# Register CellVector in _fife:
_fife.CellVector_swigregister(CellVector)
class CellCache(FifeClass):
    r"""Proxy of C++ FIFE::CellCache class."""

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

    def __init__(self, layer):
        r"""__init__(CellCache self, Layer layer) -> CellCache"""
        _fife.CellCache_swiginit(self, _fife.new_CellCache(layer))
    __swig_destroy__ = _fife.delete_CellCache
    createCells = _swig_new_instance_method(_fife.CellCache_createCells)
    forceUpdate = _swig_new_instance_method(_fife.CellCache_forceUpdate)
    addCell = _swig_new_instance_method(_fife.CellCache_addCell)
    createCell = _swig_new_instance_method(_fife.CellCache_createCell)
    getCell = _swig_new_instance_method(_fife.CellCache_getCell)
    addInteractOnRuntime = _swig_new_instance_method(_fife.CellCache_addInteractOnRuntime)
    removeInteractOnRuntime = _swig_new_instance_method(_fife.CellCache_removeInteractOnRuntime)
    getSize = _swig_new_instance_method(_fife.CellCache_getSize)
    setSize = _swig_new_instance_method(_fife.CellCache_setSize)
    getWidth = _swig_new_instance_method(_fife.CellCache_getWidth)
    getHeight = _swig_new_instance_method(_fife.CellCache_getHeight)
    getMaxIndex = _swig_new_instance_method(_fife.CellCache_getMaxIndex)
    setMaxNeighborZ = _swig_new_instance_method(_fife.CellCache_setMaxNeighborZ)
    getMaxNeighborZ = _swig_new_instance_method(_fife.CellCache_getMaxNeighborZ)
    isInCellCache = _swig_new_instance_method(_fife.CellCache_isInCellCache)
    getCellsInLine = _swig_new_instance_method(_fife.CellCache_getCellsInLine)
    getCellsInRect = _swig_new_instance_method(_fife.CellCache_getCellsInRect)
    getCellsInCircle = _swig_new_instance_method(_fife.CellCache_getCellsInCircle)
    getCellsInCircleSegment = _swig_new_instance_method(_fife.CellCache_getCellsInCircleSegment)
    registerCost = _swig_new_instance_method(_fife.CellCache_registerCost)
    unregisterCost = _swig_new_instance_method(_fife.CellCache_unregisterCost)
    getCost = _swig_new_instance_method(_fife.CellCache_getCost)
    existsCost = _swig_new_instance_method(_fife.CellCache_existsCost)
    getCosts = _swig_new_instance_method(_fife.CellCache_getCosts)
    unregisterAllCosts = _swig_new_instance_method(_fife.CellCache_unregisterAllCosts)
    addCellToCost = _swig_new_instance_method(_fife.CellCache_addCellToCost)
    addCellsToCost = _swig_new_instance_method(_fife.CellCache_addCellsToCost)
    removeCellFromCost = _swig_new_instance_method(_fife.CellCache_removeCellFromCost)
    removeCellsFromCost = _swig_new_instance_method(_fife.CellCache_removeCellsFromCost)
    getCostCells = _swig_new_instance_method(_fife.CellCache_getCostCells)
    getCellCosts = _swig_new_instance_method(_fife.CellCache_getCellCosts)
    existsCostForCell = _swig_new_instance_method(_fife.CellCache_existsCostForCell)
    setDefaultCostMultiplier = _swig_new_instance_method(_fife.CellCache_setDefaultCostMultiplier)
    getDefaultCostMultiplier = _swig_new_instance_method(_fife.CellCache_getDefaultCostMultiplier)
    setDefaultSpeedMultiplier = _swig_new_instance_method(_fife.CellCache_setDefaultSpeedMultiplier)
    getDefaultSpeedMultiplier = _swig_new_instance_method(_fife.CellCache_getDefaultSpeedMultiplier)
    addCellToArea = _swig_new_instance_method(_fife.CellCache_addCellToArea)
    addCellsToArea = _swig_new_instance_method(_fife.CellCache_addCellsToArea)
    removeCellFromArea = _swig_new_instance_method(_fife.CellCache_removeCellFromArea)
    removeCellsFromArea = _swig_new_instance_method(_fife.CellCache_removeCellsFromArea)
    removeArea = _swig_new_instance_method(_fife.CellCache_removeArea)
    existsArea = _swig_new_instance_method(_fife.CellCache_existsArea)
    getAreas = _swig_new_instance_method(_fife.CellCache_getAreas)
    getCellAreas = _swig_new_instance_method(_fife.CellCache_getCellAreas)
    getAreaCells = _swig_new_instance_method(_fife.CellCache_getAreaCells)
    isCellInArea = _swig_new_instance_method(_fife.CellCache_isCellInArea)
    setStaticSize = _swig_new_instance_method(_fife.CellCache_setStaticSize)
    isStaticSize = _swig_new_instance_method(_fife.CellCache_isStaticSize)

# Register CellCache in _fife:
_fife.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):
    r"""Proxy of C++ FIFE::LayerChangeListener class."""

    thisown = 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
    onLayerChanged = _swig_new_instance_method(_fife.LayerChangeListener_onLayerChanged)
    onInstanceCreate = _swig_new_instance_method(_fife.LayerChangeListener_onInstanceCreate)
    onInstanceDelete = _swig_new_instance_method(_fife.LayerChangeListener_onInstanceDelete)

    def __init__(self):
        r"""__init__(LayerChangeListener self) -> LayerChangeListener"""
        if self.__class__ == LayerChangeListener:
            _self = None
        else:
            _self = self
        _fife.LayerChangeListener_swiginit(self, _fife.new_LayerChangeListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_LayerChangeListener(self)
        return weakref.proxy(self)

# Register LayerChangeListener in _fife:
_fife.LayerChangeListener_swigregister(LayerChangeListener)
class Layer(FifeClass):
    r"""Proxy of C++ FIFE::Layer class."""

    thisown = 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):
        r"""__init__(Layer self, std::string const & identifier, Map map, CellGrid geometry) -> Layer"""
        _fife.Layer_swiginit(self, _fife.new_Layer(identifier, map, geometry))
    __swig_destroy__ = _fife.delete_Layer
    getId = _swig_new_instance_method(_fife.Layer_getId)
    setId = _swig_new_instance_method(_fife.Layer_setId)
    getCellGrid = _swig_new_instance_method(_fife.Layer_getCellGrid)
    setCellGrid = _swig_new_instance_method(_fife.Layer_setCellGrid)
    getMap = _swig_new_instance_method(_fife.Layer_getMap)
    hasInstances = _swig_new_instance_method(_fife.Layer_hasInstances)
    createInstance = _swig_new_instance_method(_fife.Layer_createInstance)
    addInstance = _swig_new_instance_method(_fife.Layer_addInstance)
    deleteInstance = _swig_new_instance_method(_fife.Layer_deleteInstance)
    removeInstance = _swig_new_instance_method(_fife.Layer_removeInstance)
    getInstances = _swig_new_instance_method(_fife.Layer_getInstances)
    getInstancesAt = _swig_new_instance_method(_fife.Layer_getInstancesAt)
    getInstancesIn = _swig_new_instance_method(_fife.Layer_getInstancesIn)
    getInstancesInLine = _swig_new_instance_method(_fife.Layer_getInstancesInLine)
    getInstancesInCircle = _swig_new_instance_method(_fife.Layer_getInstancesInCircle)
    getInstancesInCircleSegment = _swig_new_instance_method(_fife.Layer_getInstancesInCircleSegment)
    getInstance = _swig_new_instance_method(_fife.Layer_getInstance)
    setInstancesVisible = _swig_new_instance_method(_fife.Layer_setInstancesVisible)
    setLayerTransparency = _swig_new_instance_method(_fife.Layer_setLayerTransparency)
    getLayerTransparency = _swig_new_instance_method(_fife.Layer_getLayerTransparency)
    getMinMaxCoordinates = _swig_new_instance_method(_fife.Layer_getMinMaxCoordinates)
    cellContainsBlockingInstance = _swig_new_instance_method(_fife.Layer_cellContainsBlockingInstance)
    getBlockingInstances = _swig_new_instance_method(_fife.Layer_getBlockingInstances)
    toggleInstancesVisible = _swig_new_instance_method(_fife.Layer_toggleInstancesVisible)
    areInstancesVisible = _swig_new_instance_method(_fife.Layer_areInstancesVisible)
    setPathingStrategy = _swig_new_instance_method(_fife.Layer_setPathingStrategy)
    getPathingStrategy = _swig_new_instance_method(_fife.Layer_getPathingStrategy)
    setSortingStrategy = _swig_new_instance_method(_fife.Layer_setSortingStrategy)
    getSortingStrategy = _swig_new_instance_method(_fife.Layer_getSortingStrategy)
    setWalkable = _swig_new_instance_method(_fife.Layer_setWalkable)
    isWalkable = _swig_new_instance_method(_fife.Layer_isWalkable)
    setInteract = _swig_new_instance_method(_fife.Layer_setInteract)
    isInteract = _swig_new_instance_method(_fife.Layer_isInteract)
    getWalkableId = _swig_new_instance_method(_fife.Layer_getWalkableId)
    addInteractLayer = _swig_new_instance_method(_fife.Layer_addInteractLayer)
    getInteractLayers = _swig_new_instance_method(_fife.Layer_getInteractLayers)
    removeInteractLayer = _swig_new_instance_method(_fife.Layer_removeInteractLayer)
    createCellCache = _swig_new_instance_method(_fife.Layer_createCellCache)
    getCellCache = _swig_new_instance_method(_fife.Layer_getCellCache)
    destroyCellCache = _swig_new_instance_method(_fife.Layer_destroyCellCache)
    addChangeListener = _swig_new_instance_method(_fife.Layer_addChangeListener)
    removeChangeListener = _swig_new_instance_method(_fife.Layer_removeChangeListener)
    isChanged = _swig_new_instance_method(_fife.Layer_isChanged)
    getChangedInstances = _swig_new_instance_method(_fife.Layer_getChangedInstances)
    setStatic = _swig_new_instance_method(_fife.Layer_setStatic)
    isStatic = _swig_new_instance_method(_fife.Layer_isStatic)

# Register Layer in _fife:
_fife.Layer_swigregister(Layer)
class LayerList(object):
    r"""Proxy of C++ std::list< FIFE::Layer * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.LayerList_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.LayerList___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.LayerList___bool__)
    __len__ = _swig_new_instance_method(_fife.LayerList___len__)
    __getslice__ = _swig_new_instance_method(_fife.LayerList___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.LayerList___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.LayerList___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.LayerList___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.LayerList___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.LayerList___setitem__)
    pop = _swig_new_instance_method(_fife.LayerList_pop)
    append = _swig_new_instance_method(_fife.LayerList_append)
    empty = _swig_new_instance_method(_fife.LayerList_empty)
    size = _swig_new_instance_method(_fife.LayerList_size)
    swap = _swig_new_instance_method(_fife.LayerList_swap)
    begin = _swig_new_instance_method(_fife.LayerList_begin)
    end = _swig_new_instance_method(_fife.LayerList_end)
    rbegin = _swig_new_instance_method(_fife.LayerList_rbegin)
    rend = _swig_new_instance_method(_fife.LayerList_rend)
    clear = _swig_new_instance_method(_fife.LayerList_clear)
    get_allocator = _swig_new_instance_method(_fife.LayerList_get_allocator)
    pop_back = _swig_new_instance_method(_fife.LayerList_pop_back)
    erase = _swig_new_instance_method(_fife.LayerList_erase)

    def __init__(self, *args):
        r"""
        __init__(LayerList self) -> LayerList
        __init__(LayerList self, LayerList other) -> LayerList
        __init__(LayerList self, std::list< FIFE::Layer * >::size_type size) -> LayerList
        __init__(LayerList self, std::list< FIFE::Layer * >::size_type size, Layer value) -> LayerList
        """
        _fife.LayerList_swiginit(self, _fife.new_LayerList(*args))
    push_back = _swig_new_instance_method(_fife.LayerList_push_back)
    front = _swig_new_instance_method(_fife.LayerList_front)
    back = _swig_new_instance_method(_fife.LayerList_back)
    assign = _swig_new_instance_method(_fife.LayerList_assign)
    resize = _swig_new_instance_method(_fife.LayerList_resize)
    insert = _swig_new_instance_method(_fife.LayerList_insert)
    pop_front = _swig_new_instance_method(_fife.LayerList_pop_front)
    push_front = _swig_new_instance_method(_fife.LayerList_push_front)
    remove = _swig_new_instance_method(_fife.LayerList_remove)
    unique = _swig_new_instance_method(_fife.LayerList_unique)
    reverse = _swig_new_instance_method(_fife.LayerList_reverse)
    sort = _swig_new_instance_method(_fife.LayerList_sort)
    merge = _swig_new_instance_method(_fife.LayerList_merge)
    __swig_destroy__ = _fife.delete_LayerList

# Register LayerList in _fife:
_fife.LayerList_swigregister(LayerList)
class LayerVector(object):
    r"""Proxy of C++ std::vector< FIFE::Layer * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.LayerVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.LayerVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.LayerVector___bool__)
    __len__ = _swig_new_instance_method(_fife.LayerVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.LayerVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.LayerVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.LayerVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.LayerVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.LayerVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.LayerVector___setitem__)
    pop = _swig_new_instance_method(_fife.LayerVector_pop)
    append = _swig_new_instance_method(_fife.LayerVector_append)
    empty = _swig_new_instance_method(_fife.LayerVector_empty)
    size = _swig_new_instance_method(_fife.LayerVector_size)
    swap = _swig_new_instance_method(_fife.LayerVector_swap)
    begin = _swig_new_instance_method(_fife.LayerVector_begin)
    end = _swig_new_instance_method(_fife.LayerVector_end)
    rbegin = _swig_new_instance_method(_fife.LayerVector_rbegin)
    rend = _swig_new_instance_method(_fife.LayerVector_rend)
    clear = _swig_new_instance_method(_fife.LayerVector_clear)
    get_allocator = _swig_new_instance_method(_fife.LayerVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.LayerVector_pop_back)
    erase = _swig_new_instance_method(_fife.LayerVector_erase)

    def __init__(self, *args):
        r"""
        __init__(LayerVector self) -> LayerVector
        __init__(LayerVector self, LayerVector other) -> LayerVector
        __init__(LayerVector self, std::vector< FIFE::Layer * >::size_type size) -> LayerVector
        __init__(LayerVector self, std::vector< FIFE::Layer * >::size_type size, Layer value) -> LayerVector
        """
        _fife.LayerVector_swiginit(self, _fife.new_LayerVector(*args))
    push_back = _swig_new_instance_method(_fife.LayerVector_push_back)
    front = _swig_new_instance_method(_fife.LayerVector_front)
    back = _swig_new_instance_method(_fife.LayerVector_back)
    assign = _swig_new_instance_method(_fife.LayerVector_assign)
    resize = _swig_new_instance_method(_fife.LayerVector_resize)
    insert = _swig_new_instance_method(_fife.LayerVector_insert)
    reserve = _swig_new_instance_method(_fife.LayerVector_reserve)
    capacity = _swig_new_instance_method(_fife.LayerVector_capacity)
    __swig_destroy__ = _fife.delete_LayerVector

# Register LayerVector in _fife:
_fife.LayerVector_swigregister(LayerVector)
class CameraVector(object):
    r"""Proxy of C++ std::vector< FIFE::Camera * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.CameraVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.CameraVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.CameraVector___bool__)
    __len__ = _swig_new_instance_method(_fife.CameraVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.CameraVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.CameraVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.CameraVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.CameraVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.CameraVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.CameraVector___setitem__)
    pop = _swig_new_instance_method(_fife.CameraVector_pop)
    append = _swig_new_instance_method(_fife.CameraVector_append)
    empty = _swig_new_instance_method(_fife.CameraVector_empty)
    size = _swig_new_instance_method(_fife.CameraVector_size)
    swap = _swig_new_instance_method(_fife.CameraVector_swap)
    begin = _swig_new_instance_method(_fife.CameraVector_begin)
    end = _swig_new_instance_method(_fife.CameraVector_end)
    rbegin = _swig_new_instance_method(_fife.CameraVector_rbegin)
    rend = _swig_new_instance_method(_fife.CameraVector_rend)
    clear = _swig_new_instance_method(_fife.CameraVector_clear)
    get_allocator = _swig_new_instance_method(_fife.CameraVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.CameraVector_pop_back)
    erase = _swig_new_instance_method(_fife.CameraVector_erase)

    def __init__(self, *args):
        r"""
        __init__(CameraVector self) -> CameraVector
        __init__(CameraVector self, CameraVector other) -> CameraVector
        __init__(CameraVector self, std::vector< FIFE::Camera * >::size_type size) -> CameraVector
        __init__(CameraVector self, std::vector< FIFE::Camera * >::size_type size, Camera value) -> CameraVector
        """
        _fife.CameraVector_swiginit(self, _fife.new_CameraVector(*args))
    push_back = _swig_new_instance_method(_fife.CameraVector_push_back)
    front = _swig_new_instance_method(_fife.CameraVector_front)
    back = _swig_new_instance_method(_fife.CameraVector_back)
    assign = _swig_new_instance_method(_fife.CameraVector_assign)
    resize = _swig_new_instance_method(_fife.CameraVector_resize)
    insert = _swig_new_instance_method(_fife.CameraVector_insert)
    reserve = _swig_new_instance_method(_fife.CameraVector_reserve)
    capacity = _swig_new_instance_method(_fife.CameraVector_capacity)
    __swig_destroy__ = _fife.delete_CameraVector

# Register CameraVector in _fife:
_fife.CameraVector_swigregister(CameraVector)
class MapChangeListener(object):
    r"""Proxy of C++ FIFE::MapChangeListener class."""

    thisown = 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
    onMapChanged = _swig_new_instance_method(_fife.MapChangeListener_onMapChanged)
    onLayerCreate = _swig_new_instance_method(_fife.MapChangeListener_onLayerCreate)
    onLayerDelete = _swig_new_instance_method(_fife.MapChangeListener_onLayerDelete)

    def __init__(self):
        r"""__init__(MapChangeListener self) -> MapChangeListener"""
        if self.__class__ == MapChangeListener:
            _self = None
        else:
            _self = self
        _fife.MapChangeListener_swiginit(self, _fife.new_MapChangeListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_MapChangeListener(self)
        return weakref.proxy(self)

# Register MapChangeListener in _fife:
_fife.MapChangeListener_swigregister(MapChangeListener)
class Map(FifeClass):
    r"""Proxy of C++ FIFE::Map class."""

    thisown = 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):
        r"""__init__(Map self, std::string const & identifier, RenderBackend renderbackend, std::vector< FIFE::RendererBase *,std::allocator< FIFE::RendererBase * > > const & renderers, TimeProvider tp_master=None) -> Map"""
        _fife.Map_swiginit(self, _fife.new_Map(identifier, renderbackend, renderers, tp_master))
    __swig_destroy__ = _fife.delete_Map
    getId = _swig_new_instance_method(_fife.Map_getId)
    setId = _swig_new_instance_method(_fife.Map_setId)
    createLayer = _swig_new_instance_method(_fife.Map_createLayer)
    deleteLayer = _swig_new_instance_method(_fife.Map_deleteLayer)
    getLayers = _swig_new_instance_method(_fife.Map_getLayers)
    getLayer = _swig_new_instance_method(_fife.Map_getLayer)
    getLayerCount = _swig_new_instance_method(_fife.Map_getLayerCount)
    deleteLayers = _swig_new_instance_method(_fife.Map_deleteLayers)
    getMinMaxCoordinates = _swig_new_instance_method(_fife.Map_getMinMaxCoordinates)
    setTimeMultiplier = _swig_new_instance_method(_fife.Map_setTimeMultiplier)
    getTimeMultiplier = _swig_new_instance_method(_fife.Map_getTimeMultiplier)
    addChangeListener = _swig_new_instance_method(_fife.Map_addChangeListener)
    removeChangeListener = _swig_new_instance_method(_fife.Map_removeChangeListener)
    isChanged = _swig_new_instance_method(_fife.Map_isChanged)
    getChangedLayers = _swig_new_instance_method(_fife.Map_getChangedLayers)
    addCamera = _swig_new_instance_method(_fife.Map_addCamera)
    removeCamera = _swig_new_instance_method(_fife.Map_removeCamera)
    getCamera = _swig_new_instance_method(_fife.Map_getCamera)
    getCameras = _swig_new_instance_method(_fife.Map_getCameras)
    setFilename = _swig_new_instance_method(_fife.Map_setFilename)
    getFilename = _swig_new_instance_method(_fife.Map_getFilename)
    initializeCellCaches = _swig_new_instance_method(_fife.Map_initializeCellCaches)
    finalizeCellCaches = _swig_new_instance_method(_fife.Map_finalizeCellCaches)
    getTriggerController = _swig_new_instance_method(_fife.Map_getTriggerController)

# Register Map in _fife:
_fife.Map_swigregister(Map)
class RendererNode(object):
    r"""Proxy of C++ FIFE::RendererNode class."""

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

    def __init__(self, *args):
        r"""
        __init__(RendererNode self, Instance attached_instance, Location relative_location, Layer relative_layer, Point relative_point=FIFE::Point(0,0)) -> RendererNode
        __init__(RendererNode self, Instance attached_instance, Location relative_location, Point relative_point=FIFE::Point(0,0)) -> RendererNode
        __init__(RendererNode self, Instance attached_instance, Layer relative_layer, Point relative_point=FIFE::Point(0,0)) -> RendererNode
        __init__(RendererNode self, Instance attached_instance, Point relative_point=FIFE::Point(0,0)) -> RendererNode
        __init__(RendererNode self, Location attached_location, Layer relative_layer, Point relative_point=FIFE::Point(0,0)) -> RendererNode
        __init__(RendererNode self, Location attached_location, Point relative_point=FIFE::Point(0,0)) -> RendererNode
        __init__(RendererNode self, Layer attached_layer, Point relative_point=FIFE::Point(0,0)) -> RendererNode
        __init__(RendererNode self, Point attached_point) -> RendererNode
        __init__(RendererNode self, RendererNode old) -> RendererNode
        """
        _fife.RendererNode_swiginit(self, _fife.new_RendererNode(*args))
    __swig_destroy__ = _fife.delete_RendererNode
    setAttached = _swig_new_instance_method(_fife.RendererNode_setAttached)
    setRelative = _swig_new_instance_method(_fife.RendererNode_setRelative)
    getAttachedInstance = _swig_new_instance_method(_fife.RendererNode_getAttachedInstance)
    getAttachedLocation = _swig_new_instance_method(_fife.RendererNode_getAttachedLocation)
    getAttachedLayer = _swig_new_instance_method(_fife.RendererNode_getAttachedLayer)
    getAttachedPoint = _swig_new_instance_method(_fife.RendererNode_getAttachedPoint)
    getOffsetLocation = _swig_new_instance_method(_fife.RendererNode_getOffsetLocation)
    getOffsetPoint = _swig_new_instance_method(_fife.RendererNode_getOffsetPoint)
    getInstance = _swig_new_instance_method(_fife.RendererNode_getInstance)
    getLocation = _swig_new_instance_method(_fife.RendererNode_getLocation)
    getLocationRef = _swig_new_instance_method(_fife.RendererNode_getLocationRef)
    getLayer = _swig_new_instance_method(_fife.RendererNode_getLayer)
    getPoint = _swig_new_instance_method(_fife.RendererNode_getPoint)
    getPointRef = _swig_new_instance_method(_fife.RendererNode_getPointRef)
    getCalculatedPoint = _swig_new_instance_method(_fife.RendererNode_getCalculatedPoint)

# Register RendererNode in _fife:
_fife.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):
    r"""Proxy of C++ FIFE::ITriggerListener class."""

    thisown = 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
    onTriggered = _swig_new_instance_method(_fife.ITriggerListener_onTriggered)

    def __init__(self):
        r"""__init__(ITriggerListener self) -> ITriggerListener"""
        if self.__class__ == ITriggerListener:
            _self = None
        else:
            _self = self
        _fife.ITriggerListener_swiginit(self, _fife.new_ITriggerListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_ITriggerListener(self)
        return weakref.proxy(self)

# Register ITriggerListener in _fife:
_fife.ITriggerListener_swigregister(ITriggerListener)
class Trigger(FifeClass):
    r"""Proxy of C++ FIFE::Trigger class."""

    thisown = 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
    addTriggerListener = _swig_new_instance_method(_fife.Trigger_addTriggerListener)
    removeTriggerListener = _swig_new_instance_method(_fife.Trigger_removeTriggerListener)
    reset = _swig_new_instance_method(_fife.Trigger_reset)
    getName = _swig_new_instance_method(_fife.Trigger_getName)
    isTriggered = _swig_new_instance_method(_fife.Trigger_isTriggered)
    setTriggered = _swig_new_instance_method(_fife.Trigger_setTriggered)
    addTriggerCondition = _swig_new_instance_method(_fife.Trigger_addTriggerCondition)
    getTriggerConditions = _swig_new_instance_method(_fife.Trigger_getTriggerConditions)
    removeTriggerCondition = _swig_new_instance_method(_fife.Trigger_removeTriggerCondition)
    enableForInstance = _swig_new_instance_method(_fife.Trigger_enableForInstance)
    getEnabledInstances = _swig_new_instance_method(_fife.Trigger_getEnabledInstances)
    disableForInstance = _swig_new_instance_method(_fife.Trigger_disableForInstance)
    enableForAllInstances = _swig_new_instance_method(_fife.Trigger_enableForAllInstances)
    isEnabledForAllInstances = _swig_new_instance_method(_fife.Trigger_isEnabledForAllInstances)
    disableForAllInstances = _swig_new_instance_method(_fife.Trigger_disableForAllInstances)
    assign = _swig_new_instance_method(_fife.Trigger_assign)
    remove = _swig_new_instance_method(_fife.Trigger_remove)
    attach = _swig_new_instance_method(_fife.Trigger_attach)
    detach = _swig_new_instance_method(_fife.Trigger_detach)
    getAttached = _swig_new_instance_method(_fife.Trigger_getAttached)
    moveTo = _swig_new_instance_method(_fife.Trigger_moveTo)
    getAssignedCells = _swig_new_instance_method(_fife.Trigger_getAssignedCells)

# Register Trigger in _fife:
_fife.Trigger_swigregister(Trigger)
class TriggerController(FifeClass):
    r"""Proxy of C++ FIFE::TriggerController class."""

    thisown = 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
    createTrigger = _swig_new_instance_method(_fife.TriggerController_createTrigger)
    createTriggerOnCoordinate = _swig_new_instance_method(_fife.TriggerController_createTriggerOnCoordinate)
    createTriggerOnCoordinates = _swig_new_instance_method(_fife.TriggerController_createTriggerOnCoordinates)
    createTriggerOnRect = _swig_new_instance_method(_fife.TriggerController_createTriggerOnRect)
    createTriggerOnLocation = _swig_new_instance_method(_fife.TriggerController_createTriggerOnLocation)
    createTriggerOnLocations = _swig_new_instance_method(_fife.TriggerController_createTriggerOnLocations)
    createTriggerOnCell = _swig_new_instance_method(_fife.TriggerController_createTriggerOnCell)
    createTriggerOnCells = _swig_new_instance_method(_fife.TriggerController_createTriggerOnCells)
    createTriggerOnInstance = _swig_new_instance_method(_fife.TriggerController_createTriggerOnInstance)
    getTrigger = _swig_new_instance_method(_fife.TriggerController_getTrigger)
    deleteTrigger = _swig_new_instance_method(_fife.TriggerController_deleteTrigger)
    removeTriggerFromCoordinate = _swig_new_instance_method(_fife.TriggerController_removeTriggerFromCoordinate)
    removeTriggerFromCoordinates = _swig_new_instance_method(_fife.TriggerController_removeTriggerFromCoordinates)
    removeTriggerFromRect = _swig_new_instance_method(_fife.TriggerController_removeTriggerFromRect)
    removeTriggerFromLocation = _swig_new_instance_method(_fife.TriggerController_removeTriggerFromLocation)
    removeTriggerFromLocations = _swig_new_instance_method(_fife.TriggerController_removeTriggerFromLocations)
    removeTriggerFromCell = _swig_new_instance_method(_fife.TriggerController_removeTriggerFromCell)
    removeTriggerFromCells = _swig_new_instance_method(_fife.TriggerController_removeTriggerFromCells)
    removeTriggerFromInstance = _swig_new_instance_method(_fife.TriggerController_removeTriggerFromInstance)
    getAllTriggers = _swig_new_instance_method(_fife.TriggerController_getAllTriggers)
    getAllTriggerNames = _swig_new_instance_method(_fife.TriggerController_getAllTriggerNames)

# Register TriggerController in _fife:
_fife.TriggerController_swigregister(TriggerController)
class TriggerConditionVector(object):
    r"""Proxy of C++ std::vector< FIFE::TriggerCondition > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.TriggerConditionVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.TriggerConditionVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.TriggerConditionVector___bool__)
    __len__ = _swig_new_instance_method(_fife.TriggerConditionVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.TriggerConditionVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.TriggerConditionVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.TriggerConditionVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.TriggerConditionVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.TriggerConditionVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.TriggerConditionVector___setitem__)
    pop = _swig_new_instance_method(_fife.TriggerConditionVector_pop)
    append = _swig_new_instance_method(_fife.TriggerConditionVector_append)
    empty = _swig_new_instance_method(_fife.TriggerConditionVector_empty)
    size = _swig_new_instance_method(_fife.TriggerConditionVector_size)
    swap = _swig_new_instance_method(_fife.TriggerConditionVector_swap)
    begin = _swig_new_instance_method(_fife.TriggerConditionVector_begin)
    end = _swig_new_instance_method(_fife.TriggerConditionVector_end)
    rbegin = _swig_new_instance_method(_fife.TriggerConditionVector_rbegin)
    rend = _swig_new_instance_method(_fife.TriggerConditionVector_rend)
    clear = _swig_new_instance_method(_fife.TriggerConditionVector_clear)
    get_allocator = _swig_new_instance_method(_fife.TriggerConditionVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.TriggerConditionVector_pop_back)
    erase = _swig_new_instance_method(_fife.TriggerConditionVector_erase)

    def __init__(self, *args):
        r"""
        __init__(TriggerConditionVector self) -> TriggerConditionVector
        __init__(TriggerConditionVector self, TriggerConditionVector other) -> TriggerConditionVector
        __init__(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::size_type size) -> TriggerConditionVector
        __init__(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::size_type size, std::vector< enum FIFE::TriggerCondition >::value_type const & value) -> TriggerConditionVector
        """
        _fife.TriggerConditionVector_swiginit(self, _fife.new_TriggerConditionVector(*args))
    push_back = _swig_new_instance_method(_fife.TriggerConditionVector_push_back)
    front = _swig_new_instance_method(_fife.TriggerConditionVector_front)
    back = _swig_new_instance_method(_fife.TriggerConditionVector_back)
    assign = _swig_new_instance_method(_fife.TriggerConditionVector_assign)
    resize = _swig_new_instance_method(_fife.TriggerConditionVector_resize)
    insert = _swig_new_instance_method(_fife.TriggerConditionVector_insert)
    reserve = _swig_new_instance_method(_fife.TriggerConditionVector_reserve)
    capacity = _swig_new_instance_method(_fife.TriggerConditionVector_capacity)
    __swig_destroy__ = _fife.delete_TriggerConditionVector

# Register TriggerConditionVector in _fife:
_fife.TriggerConditionVector_swigregister(TriggerConditionVector)
class TriggerVector(object):
    r"""Proxy of C++ std::vector< FIFE::Trigger * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.TriggerVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.TriggerVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.TriggerVector___bool__)
    __len__ = _swig_new_instance_method(_fife.TriggerVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.TriggerVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.TriggerVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.TriggerVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.TriggerVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.TriggerVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.TriggerVector___setitem__)
    pop = _swig_new_instance_method(_fife.TriggerVector_pop)
    append = _swig_new_instance_method(_fife.TriggerVector_append)
    empty = _swig_new_instance_method(_fife.TriggerVector_empty)
    size = _swig_new_instance_method(_fife.TriggerVector_size)
    swap = _swig_new_instance_method(_fife.TriggerVector_swap)
    begin = _swig_new_instance_method(_fife.TriggerVector_begin)
    end = _swig_new_instance_method(_fife.TriggerVector_end)
    rbegin = _swig_new_instance_method(_fife.TriggerVector_rbegin)
    rend = _swig_new_instance_method(_fife.TriggerVector_rend)
    clear = _swig_new_instance_method(_fife.TriggerVector_clear)
    get_allocator = _swig_new_instance_method(_fife.TriggerVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.TriggerVector_pop_back)
    erase = _swig_new_instance_method(_fife.TriggerVector_erase)

    def __init__(self, *args):
        r"""
        __init__(TriggerVector self) -> TriggerVector
        __init__(TriggerVector self, TriggerVector other) -> TriggerVector
        __init__(TriggerVector self, std::vector< FIFE::Trigger * >::size_type size) -> TriggerVector
        __init__(TriggerVector self, std::vector< FIFE::Trigger * >::size_type size, Trigger value) -> TriggerVector
        """
        _fife.TriggerVector_swiginit(self, _fife.new_TriggerVector(*args))
    push_back = _swig_new_instance_method(_fife.TriggerVector_push_back)
    front = _swig_new_instance_method(_fife.TriggerVector_front)
    back = _swig_new_instance_method(_fife.TriggerVector_back)
    assign = _swig_new_instance_method(_fife.TriggerVector_assign)
    resize = _swig_new_instance_method(_fife.TriggerVector_resize)
    insert = _swig_new_instance_method(_fife.TriggerVector_insert)
    reserve = _swig_new_instance_method(_fife.TriggerVector_reserve)
    capacity = _swig_new_instance_method(_fife.TriggerVector_capacity)
    __swig_destroy__ = _fife.delete_TriggerVector

# Register TriggerVector in _fife:
_fife.TriggerVector_swigregister(TriggerVector)
class StringList(object):
    r"""Proxy of C++ std::list< std::string > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.StringList_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.StringList___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.StringList___bool__)
    __len__ = _swig_new_instance_method(_fife.StringList___len__)
    __getslice__ = _swig_new_instance_method(_fife.StringList___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.StringList___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.StringList___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.StringList___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.StringList___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.StringList___setitem__)
    pop = _swig_new_instance_method(_fife.StringList_pop)
    append = _swig_new_instance_method(_fife.StringList_append)
    empty = _swig_new_instance_method(_fife.StringList_empty)
    size = _swig_new_instance_method(_fife.StringList_size)
    swap = _swig_new_instance_method(_fife.StringList_swap)
    begin = _swig_new_instance_method(_fife.StringList_begin)
    end = _swig_new_instance_method(_fife.StringList_end)
    rbegin = _swig_new_instance_method(_fife.StringList_rbegin)
    rend = _swig_new_instance_method(_fife.StringList_rend)
    clear = _swig_new_instance_method(_fife.StringList_clear)
    get_allocator = _swig_new_instance_method(_fife.StringList_get_allocator)
    pop_back = _swig_new_instance_method(_fife.StringList_pop_back)
    erase = _swig_new_instance_method(_fife.StringList_erase)

    def __init__(self, *args):
        r"""
        __init__(StringList self) -> StringList
        __init__(StringList self, StringList other) -> StringList
        __init__(StringList self, std::list< std::string >::size_type size) -> StringList
        __init__(StringList self, std::list< std::string >::size_type size, std::list< std::string >::value_type const & value) -> StringList
        """
        _fife.StringList_swiginit(self, _fife.new_StringList(*args))
    push_back = _swig_new_instance_method(_fife.StringList_push_back)
    front = _swig_new_instance_method(_fife.StringList_front)
    back = _swig_new_instance_method(_fife.StringList_back)
    assign = _swig_new_instance_method(_fife.StringList_assign)
    resize = _swig_new_instance_method(_fife.StringList_resize)
    insert = _swig_new_instance_method(_fife.StringList_insert)
    pop_front = _swig_new_instance_method(_fife.StringList_pop_front)
    push_front = _swig_new_instance_method(_fife.StringList_push_front)
    reverse = _swig_new_instance_method(_fife.StringList_reverse)
    __swig_destroy__ = _fife.delete_StringList

# Register StringList in _fife:
_fife.StringList_swigregister(StringList)
class ObjectList(object):
    r"""Proxy of C++ std::list< FIFE::Object * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.ObjectList_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.ObjectList___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.ObjectList___bool__)
    __len__ = _swig_new_instance_method(_fife.ObjectList___len__)
    __getslice__ = _swig_new_instance_method(_fife.ObjectList___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.ObjectList___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.ObjectList___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.ObjectList___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.ObjectList___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.ObjectList___setitem__)
    pop = _swig_new_instance_method(_fife.ObjectList_pop)
    append = _swig_new_instance_method(_fife.ObjectList_append)
    empty = _swig_new_instance_method(_fife.ObjectList_empty)
    size = _swig_new_instance_method(_fife.ObjectList_size)
    swap = _swig_new_instance_method(_fife.ObjectList_swap)
    begin = _swig_new_instance_method(_fife.ObjectList_begin)
    end = _swig_new_instance_method(_fife.ObjectList_end)
    rbegin = _swig_new_instance_method(_fife.ObjectList_rbegin)
    rend = _swig_new_instance_method(_fife.ObjectList_rend)
    clear = _swig_new_instance_method(_fife.ObjectList_clear)
    get_allocator = _swig_new_instance_method(_fife.ObjectList_get_allocator)
    pop_back = _swig_new_instance_method(_fife.ObjectList_pop_back)
    erase = _swig_new_instance_method(_fife.ObjectList_erase)

    def __init__(self, *args):
        r"""
        __init__(ObjectList self) -> ObjectList
        __init__(ObjectList self, ObjectList other) -> ObjectList
        __init__(ObjectList self, std::list< FIFE::Object * >::size_type size) -> ObjectList
        __init__(ObjectList self, std::list< FIFE::Object * >::size_type size, Object value) -> ObjectList
        """
        _fife.ObjectList_swiginit(self, _fife.new_ObjectList(*args))
    push_back = _swig_new_instance_method(_fife.ObjectList_push_back)
    front = _swig_new_instance_method(_fife.ObjectList_front)
    back = _swig_new_instance_method(_fife.ObjectList_back)
    assign = _swig_new_instance_method(_fife.ObjectList_assign)
    resize = _swig_new_instance_method(_fife.ObjectList_resize)
    insert = _swig_new_instance_method(_fife.ObjectList_insert)
    pop_front = _swig_new_instance_method(_fife.ObjectList_pop_front)
    push_front = _swig_new_instance_method(_fife.ObjectList_push_front)
    remove = _swig_new_instance_method(_fife.ObjectList_remove)
    unique = _swig_new_instance_method(_fife.ObjectList_unique)
    reverse = _swig_new_instance_method(_fife.ObjectList_reverse)
    sort = _swig_new_instance_method(_fife.ObjectList_sort)
    merge = _swig_new_instance_method(_fife.ObjectList_merge)
    __swig_destroy__ = _fife.delete_ObjectList

# Register ObjectList in _fife:
_fife.ObjectList_swigregister(ObjectList)
class MapList(object):
    r"""Proxy of C++ std::list< FIFE::Map * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.MapList_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.MapList___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.MapList___bool__)
    __len__ = _swig_new_instance_method(_fife.MapList___len__)
    __getslice__ = _swig_new_instance_method(_fife.MapList___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.MapList___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.MapList___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.MapList___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.MapList___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.MapList___setitem__)
    pop = _swig_new_instance_method(_fife.MapList_pop)
    append = _swig_new_instance_method(_fife.MapList_append)
    empty = _swig_new_instance_method(_fife.MapList_empty)
    size = _swig_new_instance_method(_fife.MapList_size)
    swap = _swig_new_instance_method(_fife.MapList_swap)
    begin = _swig_new_instance_method(_fife.MapList_begin)
    end = _swig_new_instance_method(_fife.MapList_end)
    rbegin = _swig_new_instance_method(_fife.MapList_rbegin)
    rend = _swig_new_instance_method(_fife.MapList_rend)
    clear = _swig_new_instance_method(_fife.MapList_clear)
    get_allocator = _swig_new_instance_method(_fife.MapList_get_allocator)
    pop_back = _swig_new_instance_method(_fife.MapList_pop_back)
    erase = _swig_new_instance_method(_fife.MapList_erase)

    def __init__(self, *args):
        r"""
        __init__(MapList self) -> MapList
        __init__(MapList self, MapList other) -> MapList
        __init__(MapList self, std::list< FIFE::Map * >::size_type size) -> MapList
        __init__(MapList self, std::list< FIFE::Map * >::size_type size, Map value) -> MapList
        """
        _fife.MapList_swiginit(self, _fife.new_MapList(*args))
    push_back = _swig_new_instance_method(_fife.MapList_push_back)
    front = _swig_new_instance_method(_fife.MapList_front)
    back = _swig_new_instance_method(_fife.MapList_back)
    assign = _swig_new_instance_method(_fife.MapList_assign)
    resize = _swig_new_instance_method(_fife.MapList_resize)
    insert = _swig_new_instance_method(_fife.MapList_insert)
    pop_front = _swig_new_instance_method(_fife.MapList_pop_front)
    push_front = _swig_new_instance_method(_fife.MapList_push_front)
    remove = _swig_new_instance_method(_fife.MapList_remove)
    unique = _swig_new_instance_method(_fife.MapList_unique)
    reverse = _swig_new_instance_method(_fife.MapList_reverse)
    sort = _swig_new_instance_method(_fife.MapList_sort)
    merge = _swig_new_instance_method(_fife.MapList_merge)
    __swig_destroy__ = _fife.delete_MapList

# Register MapList in _fife:
_fife.MapList_swigregister(MapList)
class Model(FifeClass):
    r"""Proxy of C++ FIFE::Model class."""

    thisown = 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):
        r"""__init__(Model self, RenderBackend renderbackend, std::vector< FIFE::RendererBase *,std::allocator< FIFE::RendererBase * > > const & renderers) -> Model"""
        _fife.Model_swiginit(self, _fife.new_Model(renderbackend, renderers))
    __swig_destroy__ = _fife.delete_Model
    createMap = _swig_new_instance_method(_fife.Model_createMap)
    deleteMap = _swig_new_instance_method(_fife.Model_deleteMap)
    getMaps = _swig_new_instance_method(_fife.Model_getMaps)
    getMap = _swig_new_instance_method(_fife.Model_getMap)
    getNamespaces = _swig_new_instance_method(_fife.Model_getNamespaces)
    createObject = _swig_new_instance_method(_fife.Model_createObject)
    deleteObject = _swig_new_instance_method(_fife.Model_deleteObject)
    deleteObjects = _swig_new_instance_method(_fife.Model_deleteObjects)
    getObject = _swig_new_instance_method(_fife.Model_getObject)
    getObjects = _swig_new_instance_method(_fife.Model_getObjects)
    getMapCount = _swig_new_instance_method(_fife.Model_getMapCount)
    deleteMaps = _swig_new_instance_method(_fife.Model_deleteMaps)
    adoptPather = _swig_new_instance_method(_fife.Model_adoptPather)
    getPather = _swig_new_instance_method(_fife.Model_getPather)
    getCellGrid = _swig_new_instance_method(_fife.Model_getCellGrid)
    setTimeMultiplier = _swig_new_instance_method(_fife.Model_setTimeMultiplier)
    getTimeMultiplier = _swig_new_instance_method(_fife.Model_getTimeMultiplier)

# Register Model in _fife:
_fife.Model_swigregister(Model)
class LocationList(object):
    r"""Proxy of C++ std::list< FIFE::Location > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.LocationList_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.LocationList___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.LocationList___bool__)
    __len__ = _swig_new_instance_method(_fife.LocationList___len__)
    __getslice__ = _swig_new_instance_method(_fife.LocationList___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.LocationList___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.LocationList___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.LocationList___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.LocationList___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.LocationList___setitem__)
    pop = _swig_new_instance_method(_fife.LocationList_pop)
    append = _swig_new_instance_method(_fife.LocationList_append)
    empty = _swig_new_instance_method(_fife.LocationList_empty)
    size = _swig_new_instance_method(_fife.LocationList_size)
    swap = _swig_new_instance_method(_fife.LocationList_swap)
    begin = _swig_new_instance_method(_fife.LocationList_begin)
    end = _swig_new_instance_method(_fife.LocationList_end)
    rbegin = _swig_new_instance_method(_fife.LocationList_rbegin)
    rend = _swig_new_instance_method(_fife.LocationList_rend)
    clear = _swig_new_instance_method(_fife.LocationList_clear)
    get_allocator = _swig_new_instance_method(_fife.LocationList_get_allocator)
    pop_back = _swig_new_instance_method(_fife.LocationList_pop_back)
    erase = _swig_new_instance_method(_fife.LocationList_erase)

    def __init__(self, *args):
        r"""
        __init__(LocationList self) -> LocationList
        __init__(LocationList self, LocationList other) -> LocationList
        __init__(LocationList self, std::list< FIFE::Location >::size_type size) -> LocationList
        __init__(LocationList self, std::list< FIFE::Location >::size_type size, Location value) -> LocationList
        """
        _fife.LocationList_swiginit(self, _fife.new_LocationList(*args))
    push_back = _swig_new_instance_method(_fife.LocationList_push_back)
    front = _swig_new_instance_method(_fife.LocationList_front)
    back = _swig_new_instance_method(_fife.LocationList_back)
    assign = _swig_new_instance_method(_fife.LocationList_assign)
    resize = _swig_new_instance_method(_fife.LocationList_resize)
    insert = _swig_new_instance_method(_fife.LocationList_insert)
    pop_front = _swig_new_instance_method(_fife.LocationList_pop_front)
    push_front = _swig_new_instance_method(_fife.LocationList_push_front)
    reverse = _swig_new_instance_method(_fife.LocationList_reverse)
    __swig_destroy__ = _fife.delete_LocationList

# Register LocationList in _fife:
_fife.LocationList_swigregister(LocationList)
class RoutePather(IPather):
    r"""Proxy of C++ FIFE::RoutePather class."""

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

    def __init__(self):
        r"""__init__(RoutePather self) -> RoutePather"""
        _fife.RoutePather_swiginit(self, _fife.new_RoutePather())
    __swig_destroy__ = _fife.delete_RoutePather
    getName = _swig_new_instance_method(_fife.RoutePather_getName)

# Register RoutePather in _fife:
_fife.RoutePather_swigregister(RoutePather)
class IAnimationSaver(object):
    r"""Proxy of C++ FIFE::IAnimationSaver class."""

    thisown = 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
    save = _swig_new_instance_method(_fife.IAnimationSaver_save)

    def __init__(self):
        r"""__init__(IAnimationSaver self) -> IAnimationSaver"""
        if self.__class__ == IAnimationSaver:
            _self = None
        else:
            _self = self
        _fife.IAnimationSaver_swiginit(self, _fife.new_IAnimationSaver(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAnimationSaver(self)
        return weakref.proxy(self)

# Register IAnimationSaver in _fife:
_fife.IAnimationSaver_swigregister(IAnimationSaver)
class IAtlasSaver(object):
    r"""Proxy of C++ FIFE::IAtlasSaver class."""

    thisown = 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
    save = _swig_new_instance_method(_fife.IAtlasSaver_save)

    def __init__(self):
        r"""__init__(IAtlasSaver self) -> IAtlasSaver"""
        if self.__class__ == IAtlasSaver:
            _self = None
        else:
            _self = self
        _fife.IAtlasSaver_swiginit(self, _fife.new_IAtlasSaver(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAtlasSaver(self)
        return weakref.proxy(self)

# Register IAtlasSaver in _fife:
_fife.IAtlasSaver_swigregister(IAtlasSaver)
class IMapSaver(object):
    r"""Proxy of C++ FIFE::IMapSaver class."""

    thisown = 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
    setObjectSaver = _swig_new_instance_method(_fife.IMapSaver_setObjectSaver)
    setAnimationSaver = _swig_new_instance_method(_fife.IMapSaver_setAnimationSaver)
    setAtlasSaver = _swig_new_instance_method(_fife.IMapSaver_setAtlasSaver)
    save = _swig_new_instance_method(_fife.IMapSaver_save)

    def __init__(self):
        r"""__init__(IMapSaver self) -> IMapSaver"""
        if self.__class__ == IMapSaver:
            _self = None
        else:
            _self = self
        _fife.IMapSaver_swiginit(self, _fife.new_IMapSaver(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IMapSaver(self)
        return weakref.proxy(self)

# Register IMapSaver in _fife:
_fife.IMapSaver_swigregister(IMapSaver)
class IObjectSaver(object):
    r"""Proxy of C++ FIFE::IObjectSaver class."""

    thisown = 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
    setAnimationSaver = _swig_new_instance_method(_fife.IObjectSaver_setAnimationSaver)
    save = _swig_new_instance_method(_fife.IObjectSaver_save)

    def __init__(self):
        r"""__init__(IObjectSaver self) -> IObjectSaver"""
        if self.__class__ == IObjectSaver:
            _self = None
        else:
            _self = self
        _fife.IObjectSaver_swiginit(self, _fife.new_IObjectSaver(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IObjectSaver(self)
        return weakref.proxy(self)

# Register IObjectSaver in _fife:
_fife.IObjectSaver_swigregister(IObjectSaver)
class MapSaver(IMapSaver):
    r"""Proxy of C++ FIFE::MapSaver class."""

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

    def __init__(self):
        r"""__init__(MapSaver self) -> MapSaver"""
        _fife.MapSaver_swiginit(self, _fife.new_MapSaver())
    __swig_destroy__ = _fife.delete_MapSaver
    setObjectSaver = _swig_new_instance_method(_fife.MapSaver_setObjectSaver)
    setAnimationSaver = _swig_new_instance_method(_fife.MapSaver_setAnimationSaver)
    setAtlasSaver = _swig_new_instance_method(_fife.MapSaver_setAtlasSaver)
    save = _swig_new_instance_method(_fife.MapSaver_save)

# Register MapSaver in _fife:
_fife.MapSaver_swigregister(MapSaver)
LM_CORE = _fife.LM_CORE

LM_AUDIO = _fife.LM_AUDIO

LM_CONTROLLER = _fife.LM_CONTROLLER

LM_EVTCHANNEL = _fife.LM_EVTCHANNEL

LM_GUI = _fife.LM_GUI

LM_CONSOLE = _fife.LM_CONSOLE

LM_LOADERS = _fife.LM_LOADERS

LM_NATIVE_LOADERS = _fife.LM_NATIVE_LOADERS

LM_FO_LOADERS = _fife.LM_FO_LOADERS

LM_SAVERS = _fife.LM_SAVERS

LM_NATIVE_SAVERS = _fife.LM_NATIVE_SAVERS

LM_MODEL = _fife.LM_MODEL

LM_STRUCTURES = _fife.LM_STRUCTURES

LM_INSTANCE = _fife.LM_INSTANCE

LM_LOCATION = _fife.LM_LOCATION

LM_METAMODEL = _fife.LM_METAMODEL

LM_CELLGRID = _fife.LM_CELLGRID

LM_SQUAREGRID = _fife.LM_SQUAREGRID

LM_HEXGRID = _fife.LM_HEXGRID

LM_PATHFINDER = _fife.LM_PATHFINDER

LM_UTIL = _fife.LM_UTIL

LM_RESMGR = _fife.LM_RESMGR

LM_VFS = _fife.LM_VFS

LM_VIDEO = _fife.LM_VIDEO

LM_VIEW = _fife.LM_VIEW

LM_CAMERA = _fife.LM_CAMERA

LM_VIEWVIEW = _fife.LM_VIEWVIEW

LM_XML = _fife.LM_XML

LM_EXCEPTION = _fife.LM_EXCEPTION

LM_SCRIPT = _fife.LM_SCRIPT

LM_CURSOR = _fife.LM_CURSOR

LM_MODULE_MAX = _fife.LM_MODULE_MAX

class moduleVector(object):
    r"""Proxy of C++ std::vector< logmodule_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.moduleVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.moduleVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.moduleVector___bool__)
    __len__ = _swig_new_instance_method(_fife.moduleVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.moduleVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.moduleVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.moduleVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.moduleVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.moduleVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.moduleVector___setitem__)
    pop = _swig_new_instance_method(_fife.moduleVector_pop)
    append = _swig_new_instance_method(_fife.moduleVector_append)
    empty = _swig_new_instance_method(_fife.moduleVector_empty)
    size = _swig_new_instance_method(_fife.moduleVector_size)
    swap = _swig_new_instance_method(_fife.moduleVector_swap)
    begin = _swig_new_instance_method(_fife.moduleVector_begin)
    end = _swig_new_instance_method(_fife.moduleVector_end)
    rbegin = _swig_new_instance_method(_fife.moduleVector_rbegin)
    rend = _swig_new_instance_method(_fife.moduleVector_rend)
    clear = _swig_new_instance_method(_fife.moduleVector_clear)
    get_allocator = _swig_new_instance_method(_fife.moduleVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.moduleVector_pop_back)
    erase = _swig_new_instance_method(_fife.moduleVector_erase)

    def __init__(self, *args):
        r"""
        __init__(moduleVector self) -> moduleVector
        __init__(moduleVector self, moduleVector other) -> moduleVector
        __init__(moduleVector self, std::vector< enum logmodule_t >::size_type size) -> moduleVector
        __init__(moduleVector self, std::vector< enum logmodule_t >::size_type size, std::vector< enum logmodule_t >::value_type const & value) -> moduleVector
        """
        _fife.moduleVector_swiginit(self, _fife.new_moduleVector(*args))
    push_back = _swig_new_instance_method(_fife.moduleVector_push_back)
    front = _swig_new_instance_method(_fife.moduleVector_front)
    back = _swig_new_instance_method(_fife.moduleVector_back)
    assign = _swig_new_instance_method(_fife.moduleVector_assign)
    resize = _swig_new_instance_method(_fife.moduleVector_resize)
    insert = _swig_new_instance_method(_fife.moduleVector_insert)
    reserve = _swig_new_instance_method(_fife.moduleVector_reserve)
    capacity = _swig_new_instance_method(_fife.moduleVector_capacity)
    __swig_destroy__ = _fife.delete_moduleVector

# Register moduleVector in _fife:
_fife.moduleVector_swigregister(moduleVector)
class LogManager(object):
    r"""Proxy of C++ FIFE::LogManager class."""

    thisown = 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
    log = _swig_new_instance_method(_fife.LogManager_log)
    setLevelFilter = _swig_new_instance_method(_fife.LogManager_setLevelFilter)
    getLevelFilter = _swig_new_instance_method(_fife.LogManager_getLevelFilter)
    addVisibleModule = _swig_new_instance_method(_fife.LogManager_addVisibleModule)
    removeVisibleModule = _swig_new_instance_method(_fife.LogManager_removeVisibleModule)
    clearVisibleModules = _swig_new_instance_method(_fife.LogManager_clearVisibleModules)
    isVisible = _swig_new_instance_method(_fife.LogManager_isVisible)
    setLogToPrompt = _swig_new_instance_method(_fife.LogManager_setLogToPrompt)
    isLogToPrompt = _swig_new_instance_method(_fife.LogManager_isLogToPrompt)
    setLogToFile = _swig_new_instance_method(_fife.LogManager_setLogToFile)
    isLogToFile = _swig_new_instance_method(_fife.LogManager_isLogToFile)
    getModuleName = _swig_new_instance_method(_fife.LogManager_getModuleName)

# Register LogManager in _fife:
_fife.LogManager_swigregister(LogManager)
class Logger(object):
    r"""Proxy of C++ FIFE::Logger class."""

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

    def __init__(self, module):
        r"""__init__(Logger self, logmodule_t module) -> Logger"""
        _fife.Logger_swiginit(self, _fife.new_Logger(module))
    __swig_destroy__ = _fife.delete_Logger
    log = _swig_new_instance_method(_fife.Logger_log)

# Register Logger in _fife:
_fife.Logger_swigregister(Logger)
getAngleBetween = _fife.getAngleBetween
getFacing = _fife.getFacing
class Mathf(object):
    r"""Proxy of C++ FIFE::Math< float > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    epsilon = _swig_new_static_method(_fife.Mathf_epsilon)
    zeroTolerance = _swig_new_static_method(_fife.Mathf_zeroTolerance)
    max = _swig_new_static_method(_fife.Mathf_max)
    pi = _swig_new_static_method(_fife.Mathf_pi)
    twoPi = _swig_new_static_method(_fife.Mathf_twoPi)
    halfPi = _swig_new_static_method(_fife.Mathf_halfPi)
    inversePi = _swig_new_static_method(_fife.Mathf_inversePi)
    inverseTwoPi = _swig_new_static_method(_fife.Mathf_inverseTwoPi)
    degToRad = _swig_new_static_method(_fife.Mathf_degToRad)
    radToDeg = _swig_new_static_method(_fife.Mathf_radToDeg)
    log2 = _swig_new_static_method(_fife.Mathf_log2)
    log10 = _swig_new_static_method(_fife.Mathf_log10)
    invLog2 = _swig_new_static_method(_fife.Mathf_invLog2)
    invLog10 = _swig_new_static_method(_fife.Mathf_invLog10)
    ACos = _swig_new_static_method(_fife.Mathf_ACos)
    ASin = _swig_new_static_method(_fife.Mathf_ASin)
    ATan = _swig_new_static_method(_fife.Mathf_ATan)
    ATan2 = _swig_new_static_method(_fife.Mathf_ATan2)
    Ceil = _swig_new_static_method(_fife.Mathf_Ceil)
    Cos = _swig_new_static_method(_fife.Mathf_Cos)
    Exp = _swig_new_static_method(_fife.Mathf_Exp)
    FAbs = _swig_new_static_method(_fife.Mathf_FAbs)
    Floor = _swig_new_static_method(_fife.Mathf_Floor)
    FMod = _swig_new_static_method(_fife.Mathf_FMod)
    InvSqrt = _swig_new_static_method(_fife.Mathf_InvSqrt)
    Log = _swig_new_static_method(_fife.Mathf_Log)
    Log2 = _swig_new_static_method(_fife.Mathf_Log2)
    Log10 = _swig_new_static_method(_fife.Mathf_Log10)
    Pow = _swig_new_static_method(_fife.Mathf_Pow)
    Sin = _swig_new_static_method(_fife.Mathf_Sin)
    Sqr = _swig_new_static_method(_fife.Mathf_Sqr)
    Sqrt = _swig_new_static_method(_fife.Mathf_Sqrt)
    Tan = _swig_new_static_method(_fife.Mathf_Tan)

    def __init__(self):
        r"""__init__(Mathf self) -> Mathf"""
        _fife.Mathf_swiginit(self, _fife.new_Mathf())
    __swig_destroy__ = _fife.delete_Mathf

# Register Mathf in _fife:
_fife.Mathf_swigregister(Mathf)
class Mathd(object):
    r"""Proxy of C++ FIFE::Math< double > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    epsilon = _swig_new_static_method(_fife.Mathd_epsilon)
    zeroTolerance = _swig_new_static_method(_fife.Mathd_zeroTolerance)
    max = _swig_new_static_method(_fife.Mathd_max)
    pi = _swig_new_static_method(_fife.Mathd_pi)
    twoPi = _swig_new_static_method(_fife.Mathd_twoPi)
    halfPi = _swig_new_static_method(_fife.Mathd_halfPi)
    inversePi = _swig_new_static_method(_fife.Mathd_inversePi)
    inverseTwoPi = _swig_new_static_method(_fife.Mathd_inverseTwoPi)
    degToRad = _swig_new_static_method(_fife.Mathd_degToRad)
    radToDeg = _swig_new_static_method(_fife.Mathd_radToDeg)
    log2 = _swig_new_static_method(_fife.Mathd_log2)
    log10 = _swig_new_static_method(_fife.Mathd_log10)
    invLog2 = _swig_new_static_method(_fife.Mathd_invLog2)
    invLog10 = _swig_new_static_method(_fife.Mathd_invLog10)
    ACos = _swig_new_static_method(_fife.Mathd_ACos)
    ASin = _swig_new_static_method(_fife.Mathd_ASin)
    ATan = _swig_new_static_method(_fife.Mathd_ATan)
    ATan2 = _swig_new_static_method(_fife.Mathd_ATan2)
    Ceil = _swig_new_static_method(_fife.Mathd_Ceil)
    Cos = _swig_new_static_method(_fife.Mathd_Cos)
    Exp = _swig_new_static_method(_fife.Mathd_Exp)
    FAbs = _swig_new_static_method(_fife.Mathd_FAbs)
    Floor = _swig_new_static_method(_fife.Mathd_Floor)
    FMod = _swig_new_static_method(_fife.Mathd_FMod)
    InvSqrt = _swig_new_static_method(_fife.Mathd_InvSqrt)
    Log = _swig_new_static_method(_fife.Mathd_Log)
    Log2 = _swig_new_static_method(_fife.Mathd_Log2)
    Log10 = _swig_new_static_method(_fife.Mathd_Log10)
    Pow = _swig_new_static_method(_fife.Mathd_Pow)
    Sin = _swig_new_static_method(_fife.Mathd_Sin)
    Sqr = _swig_new_static_method(_fife.Mathd_Sqr)
    Sqrt = _swig_new_static_method(_fife.Mathd_Sqrt)
    Tan = _swig_new_static_method(_fife.Mathd_Tan)

    def __init__(self):
        r"""__init__(Mathd self) -> Mathd"""
        _fife.Mathd_swiginit(self, _fife.new_Mathd())
    __swig_destroy__ = _fife.delete_Mathd

# Register Mathd in _fife:
_fife.Mathd_swigregister(Mathd)
class TimeEvent(object):
    r"""Proxy of C++ FIFE::TimeEvent class."""

    thisown = 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):
        r"""__init__(TimeEvent self, int32_t period=-1) -> TimeEvent"""
        if self.__class__ == TimeEvent:
            _self = None
        else:
            _self = self
        _fife.TimeEvent_swiginit(self, _fife.new_TimeEvent(_self, period))
    __swig_destroy__ = _fife.delete_TimeEvent
    updateEvent = _swig_new_instance_method(_fife.TimeEvent_updateEvent)
    setPeriod = _swig_new_instance_method(_fife.TimeEvent_setPeriod)
    getPeriod = _swig_new_instance_method(_fife.TimeEvent_getPeriod)
    getLastUpdateTime = _swig_new_instance_method(_fife.TimeEvent_getLastUpdateTime)
    setLastUpdateTime = _swig_new_instance_method(_fife.TimeEvent_setLastUpdateTime)
    def __disown__(self):
        self.this.disown()
        _fife.disown_TimeEvent(self)
        return weakref.proxy(self)

# Register TimeEvent in _fife:
_fife.TimeEvent_swigregister(TimeEvent)
class TimeManager(object):
    r"""Proxy of C++ FIFE::TimeManager class."""

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

    def __init__(self):
        r"""__init__(TimeManager self) -> TimeManager"""
        _fife.TimeManager_swiginit(self, _fife.new_TimeManager())
    __swig_destroy__ = _fife.delete_TimeManager
    update = _swig_new_instance_method(_fife.TimeManager_update)
    getTime = _swig_new_instance_method(_fife.TimeManager_getTime)
    getTimeDelta = _swig_new_instance_method(_fife.TimeManager_getTimeDelta)
    getAverageFrameTime = _swig_new_instance_method(_fife.TimeManager_getAverageFrameTime)
    printStatistics = _swig_new_instance_method(_fife.TimeManager_printStatistics)
    registerEvent = _swig_new_instance_method(_fife.TimeManager_registerEvent)
    unregisterEvent = _swig_new_instance_method(_fife.TimeManager_unregisterEvent)

# Register TimeManager in _fife:
_fife.TimeManager_swigregister(TimeManager)
class RawDataSource(object):
    r"""Proxy of C++ FIFE::RawDataSource class."""

    thisown = 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
    getSize = _swig_new_instance_method(_fife.RawDataSource_getSize)
    readInto = _swig_new_instance_method(_fife.RawDataSource_readInto)

# Register RawDataSource in _fife:
_fife.RawDataSource_swigregister(RawDataSource)
class RawData(object):
    r"""Proxy of C++ FIFE::RawData class."""

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

    def __init__(self, datasource):
        r"""__init__(RawData self, RawDataSource datasource) -> RawData"""
        _fife.RawData_swiginit(self, _fife.new_RawData(datasource))
    __swig_destroy__ = _fife.delete_RawData
    getDataInBytes = _swig_new_instance_method(_fife.RawData_getDataInBytes)
    getDataInLines = _swig_new_instance_method(_fife.RawData_getDataInLines)
    getDataLength = _swig_new_instance_method(_fife.RawData_getDataLength)
    getCurrentIndex = _swig_new_instance_method(_fife.RawData_getCurrentIndex)
    setIndex = _swig_new_instance_method(_fife.RawData_setIndex)
    moveIndex = _swig_new_instance_method(_fife.RawData_moveIndex)
    readInto = _swig_new_instance_method(_fife.RawData_readInto)
    read8 = _swig_new_instance_method(_fife.RawData_read8)
    read16Little = _swig_new_instance_method(_fife.RawData_read16Little)
    read32Little = _swig_new_instance_method(_fife.RawData_read32Little)
    read16Big = _swig_new_instance_method(_fife.RawData_read16Big)
    read32Big = _swig_new_instance_method(_fife.RawData_read32Big)
    read = _swig_new_instance_method(_fife.RawData_read)
    readString = _swig_new_instance_method(_fife.RawData_readString)
    getLine = _swig_new_instance_method(_fife.RawData_getLine)

# Register RawData in _fife:
_fife.RawData_swigregister(RawData)
class StringSet(object):
    r"""Proxy of C++ std::set< std::string > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.StringSet_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.StringSet___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.StringSet___bool__)
    __len__ = _swig_new_instance_method(_fife.StringSet___len__)
    append = _swig_new_instance_method(_fife.StringSet_append)
    __contains__ = _swig_new_instance_method(_fife.StringSet___contains__)
    __getitem__ = _swig_new_instance_method(_fife.StringSet___getitem__)
    add = _swig_new_instance_method(_fife.StringSet_add)
    discard = _swig_new_instance_method(_fife.StringSet_discard)

    def __init__(self, *args):
        r"""
        __init__(StringSet self, std::less< std::string > const & other) -> StringSet
        __init__(StringSet self) -> StringSet
        __init__(StringSet self, StringSet other) -> StringSet
        """
        _fife.StringSet_swiginit(self, _fife.new_StringSet(*args))
    empty = _swig_new_instance_method(_fife.StringSet_empty)
    size = _swig_new_instance_method(_fife.StringSet_size)
    clear = _swig_new_instance_method(_fife.StringSet_clear)
    swap = _swig_new_instance_method(_fife.StringSet_swap)
    count = _swig_new_instance_method(_fife.StringSet_count)
    begin = _swig_new_instance_method(_fife.StringSet_begin)
    end = _swig_new_instance_method(_fife.StringSet_end)
    rbegin = _swig_new_instance_method(_fife.StringSet_rbegin)
    rend = _swig_new_instance_method(_fife.StringSet_rend)
    erase = _swig_new_instance_method(_fife.StringSet_erase)
    find = _swig_new_instance_method(_fife.StringSet_find)
    lower_bound = _swig_new_instance_method(_fife.StringSet_lower_bound)
    upper_bound = _swig_new_instance_method(_fife.StringSet_upper_bound)
    equal_range = _swig_new_instance_method(_fife.StringSet_equal_range)
    insert = _swig_new_instance_method(_fife.StringSet_insert)
    __swig_destroy__ = _fife.delete_StringSet

# Register StringSet in _fife:
_fife.StringSet_swigregister(StringSet)
class vectoru(object):
    r"""Proxy of C++ std::vector< uint8_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.vectoru_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.vectoru___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.vectoru___bool__)
    __len__ = _swig_new_instance_method(_fife.vectoru___len__)
    __getslice__ = _swig_new_instance_method(_fife.vectoru___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.vectoru___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.vectoru___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.vectoru___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.vectoru___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.vectoru___setitem__)
    pop = _swig_new_instance_method(_fife.vectoru_pop)
    append = _swig_new_instance_method(_fife.vectoru_append)
    empty = _swig_new_instance_method(_fife.vectoru_empty)
    size = _swig_new_instance_method(_fife.vectoru_size)
    swap = _swig_new_instance_method(_fife.vectoru_swap)
    begin = _swig_new_instance_method(_fife.vectoru_begin)
    end = _swig_new_instance_method(_fife.vectoru_end)
    rbegin = _swig_new_instance_method(_fife.vectoru_rbegin)
    rend = _swig_new_instance_method(_fife.vectoru_rend)
    clear = _swig_new_instance_method(_fife.vectoru_clear)
    get_allocator = _swig_new_instance_method(_fife.vectoru_get_allocator)
    pop_back = _swig_new_instance_method(_fife.vectoru_pop_back)
    erase = _swig_new_instance_method(_fife.vectoru_erase)

    def __init__(self, *args):
        r"""
        __init__(vectoru self) -> vectoru
        __init__(vectoru self, vectoru other) -> vectoru
        __init__(vectoru self, std::vector< unsigned char >::size_type size) -> vectoru
        __init__(vectoru self, std::vector< unsigned char >::size_type size, std::vector< unsigned char >::value_type const & value) -> vectoru
        """
        _fife.vectoru_swiginit(self, _fife.new_vectoru(*args))
    push_back = _swig_new_instance_method(_fife.vectoru_push_back)
    front = _swig_new_instance_method(_fife.vectoru_front)
    back = _swig_new_instance_method(_fife.vectoru_back)
    assign = _swig_new_instance_method(_fife.vectoru_assign)
    resize = _swig_new_instance_method(_fife.vectoru_resize)
    insert = _swig_new_instance_method(_fife.vectoru_insert)
    reserve = _swig_new_instance_method(_fife.vectoru_reserve)
    capacity = _swig_new_instance_method(_fife.vectoru_capacity)
    __swig_destroy__ = _fife.delete_vectoru

# Register vectoru in _fife:
_fife.vectoru_swigregister(vectoru)
class VFS(object):
    r"""Proxy of C++ FIFE::VFS class."""

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

    def __init__(self):
        r"""__init__(VFS self) -> VFS"""
        _fife.VFS_swiginit(self, _fife.new_VFS())
    __swig_destroy__ = _fife.delete_VFS
    cleanup = _swig_new_instance_method(_fife.VFS_cleanup)
    addNewSource = _swig_new_instance_method(_fife.VFS_addNewSource)
    removeSource = _swig_new_instance_method(_fife.VFS_removeSource)
    exists = _swig_new_instance_method(_fife.VFS_exists)
    open = _swig_new_instance_method(_fife.VFS_open)
    listFiles = _swig_new_instance_method(_fife.VFS_listFiles)
    listDirectories = _swig_new_instance_method(_fife.VFS_listDirectories)

# Register VFS in _fife:
_fife.VFS_swigregister(VFS)
class IFont(object):
    r"""Proxy of C++ FIFE::IFont class."""

    thisown = 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
    setRowSpacing = _swig_new_instance_method(_fife.IFont_setRowSpacing)
    getRowSpacing = _swig_new_instance_method(_fife.IFont_getRowSpacing)
    setGlyphSpacing = _swig_new_instance_method(_fife.IFont_setGlyphSpacing)
    getGlyphSpacing = _swig_new_instance_method(_fife.IFont_getGlyphSpacing)
    setAntiAlias = _swig_new_instance_method(_fife.IFont_setAntiAlias)
    isAntiAlias = _swig_new_instance_method(_fife.IFont_isAntiAlias)
    setColor = _swig_new_instance_method(_fife.IFont_setColor)
    getColor = _swig_new_instance_method(_fife.IFont_getColor)
    getWidth = _swig_new_instance_method(_fife.IFont_getWidth)
    getHeight = _swig_new_instance_method(_fife.IFont_getHeight)

# Register IFont in _fife:
_fife.IFont_swigregister(IFont)
class FontBase(IFont):
    r"""Proxy of C++ FIFE::FontBase class."""

    thisown = 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

# Register FontBase in _fife:
_fife.FontBase_swigregister(FontBase)
class TTFont(FontBase):
    r"""Proxy of C++ FIFE::TrueTypeFont class."""

    thisown = 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):
        r"""__init__(TTFont self, std::string const & filename, int32_t size) -> TTFont"""
        _fife.TTFont_swiginit(self, _fife.new_TTFont(filename, size))
    __swig_destroy__ = _fife.delete_TTFont
    setColor = _swig_new_instance_method(_fife.TTFont_setColor)
    getWidth = _swig_new_instance_method(_fife.TTFont_getWidth)
    getHeight = _swig_new_instance_method(_fife.TTFont_getHeight)

# Register TTFont in _fife:
_fife.TTFont_swigregister(TTFont)
class SubImageFont(FontBase):
    r"""Proxy of C++ FIFE::SubImageFont class."""

    thisown = 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):
        r"""__init__(SubImageFont self, std::string const & filename, std::string const & glyphs) -> SubImageFont"""
        _fife.SubImageFont_swiginit(self, _fife.new_SubImageFont(filename, glyphs))
    __swig_destroy__ = _fife.delete_SubImageFont
    setColor = _swig_new_instance_method(_fife.SubImageFont_setColor)
    getWidth = _swig_new_instance_method(_fife.SubImageFont_getWidth)
    getHeight = _swig_new_instance_method(_fife.SubImageFont_getHeight)

# Register SubImageFont in _fife:
_fife.SubImageFont_swigregister(SubImageFont)
class RendererBase(object):
    r"""Proxy of C++ FIFE::RendererBase class."""

    thisown = 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
    getName = _swig_new_instance_method(_fife.RendererBase_getName)
    getPipelinePosition = _swig_new_instance_method(_fife.RendererBase_getPipelinePosition)
    setPipelinePosition = _swig_new_instance_method(_fife.RendererBase_setPipelinePosition)
    setEnabled = _swig_new_instance_method(_fife.RendererBase_setEnabled)
    isEnabled = _swig_new_instance_method(_fife.RendererBase_isEnabled)
    addActiveLayer = _swig_new_instance_method(_fife.RendererBase_addActiveLayer)
    removeActiveLayer = _swig_new_instance_method(_fife.RendererBase_removeActiveLayer)
    clearActiveLayers = _swig_new_instance_method(_fife.RendererBase_clearActiveLayers)
    activateAllLayers = _swig_new_instance_method(_fife.RendererBase_activateAllLayers)
    getActiveLayers = _swig_new_instance_method(_fife.RendererBase_getActiveLayers)

# Register RendererBase in _fife:
_fife.RendererBase_swigregister(RendererBase)
class IRendererContainer(object):
    r"""Proxy of C++ FIFE::IRendererContainer class."""

    thisown = 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
    getRenderer = _swig_new_instance_method(_fife.IRendererContainer_getRenderer)

# Register IRendererContainer in _fife:
_fife.IRendererContainer_swigregister(IRendererContainer)
class ScreenPoint(object):
    r"""Proxy of C++ FIFE::PointType3D< int32_t > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_fife.ScreenPoint_x_get, _fife.ScreenPoint_x_set, doc=r"""x : int""")
    y = property(_fife.ScreenPoint_y_get, _fife.ScreenPoint_y_set, doc=r"""y : int""")
    z = property(_fife.ScreenPoint_z_get, _fife.ScreenPoint_z_set, doc=r"""z : int""")

    def __init__(self, *args):
        r"""
        __init__(ScreenPoint self, int _x=0, int _y=0, int _z=0) -> ScreenPoint
        __init__(ScreenPoint self, Point3D rhs) -> ScreenPoint
        """
        _fife.ScreenPoint_swiginit(self, _fife.new_ScreenPoint(*args))
    __add__ = _swig_new_instance_method(_fife.ScreenPoint___add__)
    __sub__ = _swig_new_instance_method(_fife.ScreenPoint___sub__)
    __iadd__ = _swig_new_instance_method(_fife.ScreenPoint___iadd__)
    __isub__ = _swig_new_instance_method(_fife.ScreenPoint___isub__)
    __mul__ = _swig_new_instance_method(_fife.ScreenPoint___mul__)

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


    __eq__ = _swig_new_instance_method(_fife.ScreenPoint___eq__)
    __ne__ = _swig_new_instance_method(_fife.ScreenPoint___ne__)
    length = _swig_new_instance_method(_fife.ScreenPoint_length)
    normalize = _swig_new_instance_method(_fife.ScreenPoint_normalize)
    set = _swig_new_instance_method(_fife.ScreenPoint_set)
    __str__ = _swig_new_instance_method(_fife.ScreenPoint___str__)
    __swig_destroy__ = _fife.delete_ScreenPoint

# Register ScreenPoint in _fife:
_fife.ScreenPoint_swigregister(ScreenPoint)
class Camera(IRendererContainer):
    r"""Proxy of C++ FIFE::Camera class."""

    thisown = 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
    getId = _swig_new_instance_method(_fife.Camera_getId)
    setId = _swig_new_instance_method(_fife.Camera_setId)
    setTilt = _swig_new_instance_method(_fife.Camera_setTilt)
    getTilt = _swig_new_instance_method(_fife.Camera_getTilt)
    setRotation = _swig_new_instance_method(_fife.Camera_setRotation)
    getRotation = _swig_new_instance_method(_fife.Camera_getRotation)
    setZoom = _swig_new_instance_method(_fife.Camera_setZoom)
    getZoom = _swig_new_instance_method(_fife.Camera_getZoom)
    getOriginalZToY = _swig_new_instance_method(_fife.Camera_getOriginalZToY)
    setZToY = _swig_new_instance_method(_fife.Camera_setZToY)
    getZToY = _swig_new_instance_method(_fife.Camera_getZToY)
    setZToYEnabled = _swig_new_instance_method(_fife.Camera_setZToYEnabled)
    isZToYEnabled = _swig_new_instance_method(_fife.Camera_isZToYEnabled)
    setLocation = _swig_new_instance_method(_fife.Camera_setLocation)
    getLocation = _swig_new_instance_method(_fife.Camera_getLocation)
    setPosition = _swig_new_instance_method(_fife.Camera_setPosition)
    getPosition = _swig_new_instance_method(_fife.Camera_getPosition)
    getOrigin = _swig_new_instance_method(_fife.Camera_getOrigin)
    attach = _swig_new_instance_method(_fife.Camera_attach)
    detach = _swig_new_instance_method(_fife.Camera_detach)
    getAttached = _swig_new_instance_method(_fife.Camera_getAttached)
    setViewPort = _swig_new_instance_method(_fife.Camera_setViewPort)
    getViewPort = _swig_new_instance_method(_fife.Camera_getViewPort)
    getMapViewPort = _swig_new_instance_method(_fife.Camera_getMapViewPort)
    getLayerViewPort = _swig_new_instance_method(_fife.Camera_getLayerViewPort)
    setCellImageDimensions = _swig_new_instance_method(_fife.Camera_setCellImageDimensions)
    getCellImageDimensions = _swig_new_instance_method(_fife.Camera_getCellImageDimensions)
    toScreenCoordinates = _swig_new_instance_method(_fife.Camera_toScreenCoordinates)
    toMapCoordinates = _swig_new_instance_method(_fife.Camera_toMapCoordinates)
    setEnabled = _swig_new_instance_method(_fife.Camera_setEnabled)
    isEnabled = _swig_new_instance_method(_fife.Camera_isEnabled)
    getMatchingInstances = _swig_new_instance_method(_fife.Camera_getMatchingInstances)
    getRenderer = _swig_new_instance_method(_fife.Camera_getRenderer)
    resetRenderers = _swig_new_instance_method(_fife.Camera_resetRenderers)
    setLightingColor = _swig_new_instance_method(_fife.Camera_setLightingColor)
    resetLightingColor = _swig_new_instance_method(_fife.Camera_resetLightingColor)
    getLightingColor = _swig_new_instance_method(_fife.Camera_getLightingColor)
    setOverlayColor = _swig_new_instance_method(_fife.Camera_setOverlayColor)
    getOverlayColor = _swig_new_instance_method(_fife.Camera_getOverlayColor)
    resetOverlayColor = _swig_new_instance_method(_fife.Camera_resetOverlayColor)
    setOverlayImage = _swig_new_instance_method(_fife.Camera_setOverlayImage)
    getOverlayImage = _swig_new_instance_method(_fife.Camera_getOverlayImage)
    resetOverlayImage = _swig_new_instance_method(_fife.Camera_resetOverlayImage)
    setOverlayAnimation = _swig_new_instance_method(_fife.Camera_setOverlayAnimation)
    getOverlayAnimation = _swig_new_instance_method(_fife.Camera_getOverlayAnimation)
    resetOverlayAnimation = _swig_new_instance_method(_fife.Camera_resetOverlayAnimation)
    refresh = _swig_new_instance_method(_fife.Camera_refresh)

# Register Camera in _fife:
_fife.Camera_swigregister(Camera)
class OverlayColors(object):
    r"""Proxy of C++ FIFE::OverlayColors class."""

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

    def __init__(self, *args):
        r"""
        __init__(OverlayColors self) -> OverlayColors
        __init__(OverlayColors self, SharedImagePointer image) -> OverlayColors
        __init__(OverlayColors self, SharedAnimationPointer animation) -> OverlayColors
        """
        _fife.OverlayColors_swiginit(self, _fife.new_OverlayColors(*args))
    __swig_destroy__ = _fife.delete_OverlayColors
    setColorOverlayImage = _swig_new_instance_method(_fife.OverlayColors_setColorOverlayImage)
    getColorOverlayImage = _swig_new_instance_method(_fife.OverlayColors_getColorOverlayImage)
    setColorOverlayAnimation = _swig_new_instance_method(_fife.OverlayColors_setColorOverlayAnimation)
    getColorOverlayAnimation = _swig_new_instance_method(_fife.OverlayColors_getColorOverlayAnimation)
    changeColor = _swig_new_instance_method(_fife.OverlayColors_changeColor)
    getColors = _swig_new_instance_method(_fife.OverlayColors_getColors)
    resetColors = _swig_new_instance_method(_fife.OverlayColors_resetColors)

# Register OverlayColors in _fife:
_fife.OverlayColors_swigregister(OverlayColors)
class Visual2DGfx(object):
    r"""Proxy of C++ FIFE::Visual2DGfx class."""

    thisown = 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

# Register Visual2DGfx in _fife:
_fife.Visual2DGfx_swigregister(Visual2DGfx)
class ObjectVisual(Visual2DGfx):
    r"""Proxy of C++ FIFE::ObjectVisual class."""

    thisown = 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
    create = _swig_new_static_method(_fife.ObjectVisual_create)
    __swig_destroy__ = _fife.delete_ObjectVisual
    addStaticImage = _swig_new_instance_method(_fife.ObjectVisual_addStaticImage)
    getStaticImageIndexByAngle = _swig_new_instance_method(_fife.ObjectVisual_getStaticImageIndexByAngle)
    addStaticColorOverlay = _swig_new_instance_method(_fife.ObjectVisual_addStaticColorOverlay)
    getStaticColorOverlay = _swig_new_instance_method(_fife.ObjectVisual_getStaticColorOverlay)
    removeStaticColorOverlay = _swig_new_instance_method(_fife.ObjectVisual_removeStaticColorOverlay)
    getClosestMatchingAngle = _swig_new_instance_method(_fife.ObjectVisual_getClosestMatchingAngle)
    getStaticImageAngles = _swig_new_instance_method(_fife.ObjectVisual_getStaticImageAngles)

# Register ObjectVisual in _fife:
_fife.ObjectVisual_swigregister(ObjectVisual)
class InstanceVisual(Visual2DGfx):
    r"""Proxy of C++ FIFE::InstanceVisual class."""

    thisown = 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
    create = _swig_new_static_method(_fife.InstanceVisual_create)
    __swig_destroy__ = _fife.delete_InstanceVisual
    setTransparency = _swig_new_instance_method(_fife.InstanceVisual_setTransparency)
    getTransparency = _swig_new_instance_method(_fife.InstanceVisual_getTransparency)
    setVisible = _swig_new_instance_method(_fife.InstanceVisual_setVisible)
    isVisible = _swig_new_instance_method(_fife.InstanceVisual_isVisible)
    setStackPosition = _swig_new_instance_method(_fife.InstanceVisual_setStackPosition)
    getStackPosition = _swig_new_instance_method(_fife.InstanceVisual_getStackPosition)

# Register InstanceVisual in _fife:
_fife.InstanceVisual_swigregister(InstanceVisual)
class ActionVisual(Visual2DGfx):
    r"""Proxy of C++ FIFE::ActionVisual class."""

    thisown = 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
    create = _swig_new_static_method(_fife.ActionVisual_create)
    __swig_destroy__ = _fife.delete_ActionVisual
    addAnimation = _swig_new_instance_method(_fife.ActionVisual_addAnimation)
    getAnimationByAngle = _swig_new_instance_method(_fife.ActionVisual_getAnimationByAngle)
    addAnimationOverlay = _swig_new_instance_method(_fife.ActionVisual_addAnimationOverlay)
    removeAnimationOverlay = _swig_new_instance_method(_fife.ActionVisual_removeAnimationOverlay)
    getAnimationOverlay = _swig_new_instance_method(_fife.ActionVisual_getAnimationOverlay)
    addColorOverlay = _swig_new_instance_method(_fife.ActionVisual_addColorOverlay)
    getColorOverlay = _swig_new_instance_method(_fife.ActionVisual_getColorOverlay)
    removeColorOverlay = _swig_new_instance_method(_fife.ActionVisual_removeColorOverlay)
    getActionImageAngles = _swig_new_instance_method(_fife.ActionVisual_getActionImageAngles)
    convertToOverlays = _swig_new_instance_method(_fife.ActionVisual_convertToOverlays)
    isAnimationOverlay = _swig_new_instance_method(_fife.ActionVisual_isAnimationOverlay)
    isColorOverlay = _swig_new_instance_method(_fife.ActionVisual_isColorOverlay)

# Register ActionVisual in _fife:
_fife.ActionVisual_swigregister(ActionVisual)
class BlockingInfoRenderer(RendererBase):
    r"""Proxy of C++ FIFE::BlockingInfoRenderer class."""

    thisown = 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
    getName = _swig_new_instance_method(_fife.BlockingInfoRenderer_getName)
    setColor = _swig_new_instance_method(_fife.BlockingInfoRenderer_setColor)
    getInstance = _swig_new_static_method(_fife.BlockingInfoRenderer_getInstance)

# Register BlockingInfoRenderer in _fife:
_fife.BlockingInfoRenderer_swigregister(BlockingInfoRenderer)
class CellRenderer(RendererBase):
    r"""Proxy of C++ FIFE::CellRenderer class."""

    thisown = 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
    getName = _swig_new_instance_method(_fife.CellRenderer_getName)
    setBlockerColor = _swig_new_instance_method(_fife.CellRenderer_setBlockerColor)
    setPathColor = _swig_new_instance_method(_fife.CellRenderer_setPathColor)
    setEnabledBlocking = _swig_new_instance_method(_fife.CellRenderer_setEnabledBlocking)
    isEnabledBlocking = _swig_new_instance_method(_fife.CellRenderer_isEnabledBlocking)
    setEnabledPathVisual = _swig_new_instance_method(_fife.CellRenderer_setEnabledPathVisual)
    isEnabledPathVisual = _swig_new_instance_method(_fife.CellRenderer_isEnabledPathVisual)
    addPathVisual = _swig_new_instance_method(_fife.CellRenderer_addPathVisual)
    removePathVisual = _swig_new_instance_method(_fife.CellRenderer_removePathVisual)
    setEnabledCost = _swig_new_instance_method(_fife.CellRenderer_setEnabledCost)
    isEnabledCost = _swig_new_instance_method(_fife.CellRenderer_isEnabledCost)
    setFont = _swig_new_instance_method(_fife.CellRenderer_setFont)
    getFont = _swig_new_instance_method(_fife.CellRenderer_getFont)
    getInstance = _swig_new_static_method(_fife.CellRenderer_getInstance)

# Register CellRenderer in _fife:
_fife.CellRenderer_swigregister(CellRenderer)
class CellSelectionRenderer(RendererBase):
    r"""Proxy of C++ FIFE::CellSelectionRenderer class."""

    thisown = 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
    getName = _swig_new_instance_method(_fife.CellSelectionRenderer_getName)
    getInstance = _swig_new_static_method(_fife.CellSelectionRenderer_getInstance)
    reset = _swig_new_instance_method(_fife.CellSelectionRenderer_reset)
    selectLocation = _swig_new_instance_method(_fife.CellSelectionRenderer_selectLocation)
    deselectLocation = _swig_new_instance_method(_fife.CellSelectionRenderer_deselectLocation)
    getLocations = _swig_new_instance_method(_fife.CellSelectionRenderer_getLocations)
    setColor = _swig_new_instance_method(_fife.CellSelectionRenderer_setColor)

# Register CellSelectionRenderer in _fife:
_fife.CellSelectionRenderer_swigregister(CellSelectionRenderer)
class CoordinateRenderer(RendererBase):
    r"""Proxy of C++ FIFE::CoordinateRenderer class."""

    thisown = 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
    getName = _swig_new_instance_method(_fife.CoordinateRenderer_getName)
    setFont = _swig_new_instance_method(_fife.CoordinateRenderer_setFont)
    setColor = _swig_new_instance_method(_fife.CoordinateRenderer_setColor)
    setZoom = _swig_new_instance_method(_fife.CoordinateRenderer_setZoom)
    getInstance = _swig_new_static_method(_fife.CoordinateRenderer_getInstance)

# Register CoordinateRenderer in _fife:
_fife.CoordinateRenderer_swigregister(CoordinateRenderer)
class FloatingTextRenderer(RendererBase):
    r"""Proxy of C++ FIFE::FloatingTextRenderer class."""

    thisown = 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
    setFont = _swig_new_instance_method(_fife.FloatingTextRenderer_setFont)
    setColor = _swig_new_instance_method(_fife.FloatingTextRenderer_setColor)
    setBackground = _swig_new_instance_method(_fife.FloatingTextRenderer_setBackground)
    setBorder = _swig_new_instance_method(_fife.FloatingTextRenderer_setBorder)
    resetBackground = _swig_new_instance_method(_fife.FloatingTextRenderer_resetBackground)
    resetBorder = _swig_new_instance_method(_fife.FloatingTextRenderer_resetBorder)
    getInstance = _swig_new_static_method(_fife.FloatingTextRenderer_getInstance)

# Register FloatingTextRenderer in _fife:
_fife.FloatingTextRenderer_swigregister(FloatingTextRenderer)
class GenericRendererElementInfo(object):
    r"""Proxy of C++ FIFE::GenericRendererElementInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_GenericRendererElementInfo

    def __init__(self):
        r"""__init__(GenericRendererElementInfo self) -> GenericRendererElementInfo"""
        _fife.GenericRendererElementInfo_swiginit(self, _fife.new_GenericRendererElementInfo())

# Register GenericRendererElementInfo in _fife:
_fife.GenericRendererElementInfo_swigregister(GenericRendererElementInfo)
class GenericRendererLineInfo(GenericRendererElementInfo):
    r"""Proxy of C++ FIFE::GenericRendererLineInfo class."""

    thisown = 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):
        r"""__init__(GenericRendererLineInfo self, RendererNode n1, RendererNode n2, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> GenericRendererLineInfo"""
        _fife.GenericRendererLineInfo_swiginit(self, _fife.new_GenericRendererLineInfo(n1, n2, r, g, b, a))
    __swig_destroy__ = _fife.delete_GenericRendererLineInfo

# Register GenericRendererLineInfo in _fife:
_fife.GenericRendererLineInfo_swigregister(GenericRendererLineInfo)
class GenericRendererPointInfo(GenericRendererElementInfo):
    r"""Proxy of C++ FIFE::GenericRendererPointInfo class."""

    thisown = 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):
        r"""__init__(GenericRendererPointInfo self, RendererNode n, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> GenericRendererPointInfo"""
        _fife.GenericRendererPointInfo_swiginit(self, _fife.new_GenericRendererPointInfo(n, r, g, b, a))
    __swig_destroy__ = _fife.delete_GenericRendererPointInfo

# Register GenericRendererPointInfo in _fife:
_fife.GenericRendererPointInfo_swigregister(GenericRendererPointInfo)
class GenericRendererTriangleInfo(GenericRendererElementInfo):
    r"""Proxy of C++ FIFE::GenericRendererTriangleInfo class."""

    thisown = 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):
        r"""__init__(GenericRendererTriangleInfo self, RendererNode n1, RendererNode n2, RendererNode n3, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> GenericRendererTriangleInfo"""
        _fife.GenericRendererTriangleInfo_swiginit(self, _fife.new_GenericRendererTriangleInfo(n1, n2, n3, r, g, b, a))
    __swig_destroy__ = _fife.delete_GenericRendererTriangleInfo

# Register GenericRendererTriangleInfo in _fife:
_fife.GenericRendererTriangleInfo_swigregister(GenericRendererTriangleInfo)
class GenericRendererQuadInfo(GenericRendererElementInfo):
    r"""Proxy of C++ FIFE::GenericRendererQuadInfo class."""

    thisown = 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):
        r"""__init__(GenericRendererQuadInfo self, RendererNode n1, RendererNode n2, RendererNode n3, RendererNode n4, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> GenericRendererQuadInfo"""
        _fife.GenericRendererQuadInfo_swiginit(self, _fife.new_GenericRendererQuadInfo(n1, n2, n3, n4, r, g, b, a))
    __swig_destroy__ = _fife.delete_GenericRendererQuadInfo

# Register GenericRendererQuadInfo in _fife:
_fife.GenericRendererQuadInfo_swigregister(GenericRendererQuadInfo)
class GenericRendererVertexInfo(GenericRendererElementInfo):
    r"""Proxy of C++ FIFE::GenericRendererVertexInfo class."""

    thisown = 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):
        r"""__init__(GenericRendererVertexInfo self, RendererNode center, int32_t size, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> GenericRendererVertexInfo"""
        _fife.GenericRendererVertexInfo_swiginit(self, _fife.new_GenericRendererVertexInfo(center, size, r, g, b, a))
    __swig_destroy__ = _fife.delete_GenericRendererVertexInfo

# Register GenericRendererVertexInfo in _fife:
_fife.GenericRendererVertexInfo_swigregister(GenericRendererVertexInfo)
class GenericRendererImageInfo(GenericRendererElementInfo):
    r"""Proxy of C++ FIFE::GenericRendererImageInfo class."""

    thisown = 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):
        r"""__init__(GenericRendererImageInfo self, RendererNode n, SharedImagePointer image, bool zoomed=True) -> GenericRendererImageInfo"""
        _fife.GenericRendererImageInfo_swiginit(self, _fife.new_GenericRendererImageInfo(n, image, zoomed))
    __swig_destroy__ = _fife.delete_GenericRendererImageInfo

# Register GenericRendererImageInfo in _fife:
_fife.GenericRendererImageInfo_swigregister(GenericRendererImageInfo)
class GenericRendererAnimationInfo(GenericRendererElementInfo):
    r"""Proxy of C++ FIFE::GenericRendererAnimationInfo class."""

    thisown = 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):
        r"""__init__(GenericRendererAnimationInfo self, RendererNode n, SharedAnimationPointer animation, bool zoomed=True) -> GenericRendererAnimationInfo"""
        _fife.GenericRendererAnimationInfo_swiginit(self, _fife.new_GenericRendererAnimationInfo(n, animation, zoomed))
    __swig_destroy__ = _fife.delete_GenericRendererAnimationInfo

# Register GenericRendererAnimationInfo in _fife:
_fife.GenericRendererAnimationInfo_swigregister(GenericRendererAnimationInfo)
class GenericRendererTextInfo(GenericRendererElementInfo):
    r"""Proxy of C++ FIFE::GenericRendererTextInfo class."""

    thisown = 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):
        r"""__init__(GenericRendererTextInfo self, RendererNode n, IFont font, std::string text, bool zoomed=True) -> GenericRendererTextInfo"""
        _fife.GenericRendererTextInfo_swiginit(self, _fife.new_GenericRendererTextInfo(n, font, text, zoomed))
    __swig_destroy__ = _fife.delete_GenericRendererTextInfo

# Register GenericRendererTextInfo in _fife:
_fife.GenericRendererTextInfo_swigregister(GenericRendererTextInfo)
class GenericRendererResizeInfo(GenericRendererElementInfo):
    r"""Proxy of C++ FIFE::GenericRendererResizeInfo class."""

    thisown = 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):
        r"""__init__(GenericRendererResizeInfo self, RendererNode n, SharedImagePointer image, int32_t width, int32_t height, bool zoomed=True) -> GenericRendererResizeInfo"""
        _fife.GenericRendererResizeInfo_swiginit(self, _fife.new_GenericRendererResizeInfo(n, image, width, height, zoomed))
    __swig_destroy__ = _fife.delete_GenericRendererResizeInfo

# Register GenericRendererResizeInfo in _fife:
_fife.GenericRendererResizeInfo_swigregister(GenericRendererResizeInfo)
class GenericRenderer(RendererBase):
    r"""Proxy of C++ FIFE::GenericRenderer class."""

    thisown = 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):
        r"""__init__(GenericRenderer self, RenderBackend renderbackend, int32_t position) -> GenericRenderer"""
        _fife.GenericRenderer_swiginit(self, _fife.new_GenericRenderer(renderbackend, position))
    __swig_destroy__ = _fife.delete_GenericRenderer
    getName = _swig_new_instance_method(_fife.GenericRenderer_getName)
    getInstance = _swig_new_static_method(_fife.GenericRenderer_getInstance)
    addLine = _swig_new_instance_method(_fife.GenericRenderer_addLine)
    addPoint = _swig_new_instance_method(_fife.GenericRenderer_addPoint)
    addTriangle = _swig_new_instance_method(_fife.GenericRenderer_addTriangle)
    addQuad = _swig_new_instance_method(_fife.GenericRenderer_addQuad)
    addVertex = _swig_new_instance_method(_fife.GenericRenderer_addVertex)
    addText = _swig_new_instance_method(_fife.GenericRenderer_addText)
    addImage = _swig_new_instance_method(_fife.GenericRenderer_addImage)
    addAnimation = _swig_new_instance_method(_fife.GenericRenderer_addAnimation)
    resizeImage = _swig_new_instance_method(_fife.GenericRenderer_resizeImage)
    removeAll = _swig_new_instance_method(_fife.GenericRenderer_removeAll)

# Register GenericRenderer in _fife:
_fife.GenericRenderer_swigregister(GenericRenderer)
class GridRenderer(RendererBase):
    r"""Proxy of C++ FIFE::GridRenderer class."""

    thisown = 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
    getName = _swig_new_instance_method(_fife.GridRenderer_getName)
    setColor = _swig_new_instance_method(_fife.GridRenderer_setColor)
    getInstance = _swig_new_static_method(_fife.GridRenderer_getInstance)

# Register GridRenderer in _fife:
_fife.GridRenderer_swigregister(GridRenderer)
class InstanceRenderer(RendererBase):
    r"""Proxy of C++ FIFE::InstanceRenderer class."""

    thisown = 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
    getName = _swig_new_instance_method(_fife.InstanceRenderer_getName)
    addOutlined = _swig_new_instance_method(_fife.InstanceRenderer_addOutlined)
    removeOutlined = _swig_new_instance_method(_fife.InstanceRenderer_removeOutlined)
    removeAllOutlines = _swig_new_instance_method(_fife.InstanceRenderer_removeAllOutlines)
    addColored = _swig_new_instance_method(_fife.InstanceRenderer_addColored)
    removeColored = _swig_new_instance_method(_fife.InstanceRenderer_removeColored)
    removeAllColored = _swig_new_instance_method(_fife.InstanceRenderer_removeAllColored)
    addTransparentArea = _swig_new_instance_method(_fife.InstanceRenderer_addTransparentArea)
    removeTransparentArea = _swig_new_instance_method(_fife.InstanceRenderer_removeTransparentArea)
    removeAllTransparentAreas = _swig_new_instance_method(_fife.InstanceRenderer_removeAllTransparentAreas)
    addIgnoreLight = _swig_new_instance_method(_fife.InstanceRenderer_addIgnoreLight)
    removeIgnoreLight = _swig_new_instance_method(_fife.InstanceRenderer_removeIgnoreLight)
    removeAllIgnoreLight = _swig_new_instance_method(_fife.InstanceRenderer_removeAllIgnoreLight)
    getInstance = _swig_new_static_method(_fife.InstanceRenderer_getInstance)
    setRemoveInterval = _swig_new_instance_method(_fife.InstanceRenderer_setRemoveInterval)
    getRemoveInterval = _swig_new_instance_method(_fife.InstanceRenderer_getRemoveInterval)

# Register InstanceRenderer in _fife:
_fife.InstanceRenderer_swigregister(InstanceRenderer)
class LightRendererElementInfo(object):
    r"""Proxy of C++ FIFE::LightRendererElementInfo class."""

    thisown = 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
    getName = _swig_new_instance_method(_fife.LightRendererElementInfo_getName)
    getNode = _swig_new_instance_method(_fife.LightRendererElementInfo_getNode)
    getSrcBlend = _swig_new_instance_method(_fife.LightRendererElementInfo_getSrcBlend)
    getDstBlend = _swig_new_instance_method(_fife.LightRendererElementInfo_getDstBlend)
    setStencil = _swig_new_instance_method(_fife.LightRendererElementInfo_setStencil)
    getStencil = _swig_new_instance_method(_fife.LightRendererElementInfo_getStencil)
    removeStencil = _swig_new_instance_method(_fife.LightRendererElementInfo_removeStencil)
    getColor = _swig_new_instance_method(_fife.LightRendererElementInfo_getColor)
    getRadius = _swig_new_instance_method(_fife.LightRendererElementInfo_getRadius)
    getSubdivisions = _swig_new_instance_method(_fife.LightRendererElementInfo_getSubdivisions)
    getXStretch = _swig_new_instance_method(_fife.LightRendererElementInfo_getXStretch)
    getYStretch = _swig_new_instance_method(_fife.LightRendererElementInfo_getYStretch)

# Register LightRendererElementInfo in _fife:
_fife.LightRendererElementInfo_swigregister(LightRendererElementInfo)
class LightRendererImageInfo(LightRendererElementInfo):
    r"""Proxy of C++ FIFE::LightRendererImageInfo class."""

    thisown = 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
    getImage = _swig_new_instance_method(_fife.LightRendererImageInfo_getImage)

# Register LightRendererImageInfo in _fife:
_fife.LightRendererImageInfo_swigregister(LightRendererImageInfo)
class LightRendererAnimationInfo(LightRendererElementInfo):
    r"""Proxy of C++ FIFE::LightRendererAnimationInfo class."""

    thisown = 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
    getAnimation = _swig_new_instance_method(_fife.LightRendererAnimationInfo_getAnimation)

# Register LightRendererAnimationInfo in _fife:
_fife.LightRendererAnimationInfo_swigregister(LightRendererAnimationInfo)
class LightRendererSimpleLightInfo(LightRendererElementInfo):
    r"""Proxy of C++ FIFE::LightRendererSimpleLightInfo class."""

    thisown = 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
    getColor = _swig_new_instance_method(_fife.LightRendererSimpleLightInfo_getColor)
    getRadius = _swig_new_instance_method(_fife.LightRendererSimpleLightInfo_getRadius)
    getSubdivisions = _swig_new_instance_method(_fife.LightRendererSimpleLightInfo_getSubdivisions)
    getXStretch = _swig_new_instance_method(_fife.LightRendererSimpleLightInfo_getXStretch)
    getYStretch = _swig_new_instance_method(_fife.LightRendererSimpleLightInfo_getYStretch)

# Register LightRendererSimpleLightInfo in _fife:
_fife.LightRendererSimpleLightInfo_swigregister(LightRendererSimpleLightInfo)
class LightRendererResizeInfo(LightRendererElementInfo):
    r"""Proxy of C++ FIFE::LightRendererResizeInfo class."""

    thisown = 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
    getImage = _swig_new_instance_method(_fife.LightRendererResizeInfo_getImage)

# Register LightRendererResizeInfo in _fife:
_fife.LightRendererResizeInfo_swigregister(LightRendererResizeInfo)
class LightRenderer(RendererBase):
    r"""Proxy of C++ FIFE::LightRenderer class."""

    thisown = 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):
        r"""__init__(LightRenderer self, RenderBackend renderbackend, int32_t position) -> LightRenderer"""
        _fife.LightRenderer_swiginit(self, _fife.new_LightRenderer(renderbackend, position))
    __swig_destroy__ = _fife.delete_LightRenderer
    getName = _swig_new_instance_method(_fife.LightRenderer_getName)
    getInstance = _swig_new_static_method(_fife.LightRenderer_getInstance)
    addImage = _swig_new_instance_method(_fife.LightRenderer_addImage)
    addAnimation = _swig_new_instance_method(_fife.LightRenderer_addAnimation)
    addSimpleLight = _swig_new_instance_method(_fife.LightRenderer_addSimpleLight)
    resizeImage = _swig_new_instance_method(_fife.LightRenderer_resizeImage)
    addStencilTest = _swig_new_instance_method(_fife.LightRenderer_addStencilTest)
    removeStencilTest = _swig_new_instance_method(_fife.LightRenderer_removeStencilTest)
    getGroups = _swig_new_instance_method(_fife.LightRenderer_getGroups)
    getLightInfo = _swig_new_instance_method(_fife.LightRenderer_getLightInfo)
    removeAll = _swig_new_instance_method(_fife.LightRenderer_removeAll)

# Register LightRenderer in _fife:
_fife.LightRenderer_swigregister(LightRenderer)
class LightRendererElementInfoVector(object):
    r"""Proxy of C++ std::vector< FIFE::LightRendererElementInfo * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_fife.LightRendererElementInfoVector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_fife.LightRendererElementInfoVector___nonzero__)
    __bool__ = _swig_new_instance_method(_fife.LightRendererElementInfoVector___bool__)
    __len__ = _swig_new_instance_method(_fife.LightRendererElementInfoVector___len__)
    __getslice__ = _swig_new_instance_method(_fife.LightRendererElementInfoVector___getslice__)
    __setslice__ = _swig_new_instance_method(_fife.LightRendererElementInfoVector___setslice__)
    __delslice__ = _swig_new_instance_method(_fife.LightRendererElementInfoVector___delslice__)
    __delitem__ = _swig_new_instance_method(_fife.LightRendererElementInfoVector___delitem__)
    __getitem__ = _swig_new_instance_method(_fife.LightRendererElementInfoVector___getitem__)
    __setitem__ = _swig_new_instance_method(_fife.LightRendererElementInfoVector___setitem__)
    pop = _swig_new_instance_method(_fife.LightRendererElementInfoVector_pop)
    append = _swig_new_instance_method(_fife.LightRendererElementInfoVector_append)
    empty = _swig_new_instance_method(_fife.LightRendererElementInfoVector_empty)
    size = _swig_new_instance_method(_fife.LightRendererElementInfoVector_size)
    swap = _swig_new_instance_method(_fife.LightRendererElementInfoVector_swap)
    begin = _swig_new_instance_method(_fife.LightRendererElementInfoVector_begin)
    end = _swig_new_instance_method(_fife.LightRendererElementInfoVector_end)
    rbegin = _swig_new_instance_method(_fife.LightRendererElementInfoVector_rbegin)
    rend = _swig_new_instance_method(_fife.LightRendererElementInfoVector_rend)
    clear = _swig_new_instance_method(_fife.LightRendererElementInfoVector_clear)
    get_allocator = _swig_new_instance_method(_fife.LightRendererElementInfoVector_get_allocator)
    pop_back = _swig_new_instance_method(_fife.LightRendererElementInfoVector_pop_back)
    erase = _swig_new_instance_method(_fife.LightRendererElementInfoVector_erase)

    def __init__(self, *args):
        r"""
        __init__(LightRendererElementInfoVector self) -> LightRendererElementInfoVector
        __init__(LightRendererElementInfoVector self, LightRendererElementInfoVector other) -> LightRendererElementInfoVector
        __init__(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::size_type size) -> LightRendererElementInfoVector
        __init__(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::size_type size, LightRendererElementInfo value) -> LightRendererElementInfoVector
        """
        _fife.LightRendererElementInfoVector_swiginit(self, _fife.new_LightRendererElementInfoVector(*args))
    push_back = _swig_new_instance_method(_fife.LightRendererElementInfoVector_push_back)
    front = _swig_new_instance_method(_fife.LightRendererElementInfoVector_front)
    back = _swig_new_instance_method(_fife.LightRendererElementInfoVector_back)
    assign = _swig_new_instance_method(_fife.LightRendererElementInfoVector_assign)
    resize = _swig_new_instance_method(_fife.LightRendererElementInfoVector_resize)
    insert = _swig_new_instance_method(_fife.LightRendererElementInfoVector_insert)
    reserve = _swig_new_instance_method(_fife.LightRendererElementInfoVector_reserve)
    capacity = _swig_new_instance_method(_fife.LightRendererElementInfoVector_capacity)
    __swig_destroy__ = _fife.delete_LightRendererElementInfoVector

# Register LightRendererElementInfoVector in _fife:
_fife.LightRendererElementInfoVector_swigregister(LightRendererElementInfoVector)
class OffRendererElementInfo(object):
    r"""Proxy of C++ FIFE::OffRendererElementInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_OffRendererElementInfo

    def __init__(self):
        r"""__init__(OffRendererElementInfo self) -> OffRendererElementInfo"""
        _fife.OffRendererElementInfo_swiginit(self, _fife.new_OffRendererElementInfo())

# Register OffRendererElementInfo in _fife:
_fife.OffRendererElementInfo_swigregister(OffRendererElementInfo)
class OffRendererLineInfo(OffRendererElementInfo):
    r"""Proxy of C++ FIFE::OffRendererLineInfo class."""

    thisown = 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):
        r"""__init__(OffRendererLineInfo self, Point n1, Point n2, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> OffRendererLineInfo"""
        _fife.OffRendererLineInfo_swiginit(self, _fife.new_OffRendererLineInfo(n1, n2, r, g, b, a))
    __swig_destroy__ = _fife.delete_OffRendererLineInfo

# Register OffRendererLineInfo in _fife:
_fife.OffRendererLineInfo_swigregister(OffRendererLineInfo)
class OffRendererPointInfo(OffRendererElementInfo):
    r"""Proxy of C++ FIFE::OffRendererPointInfo class."""

    thisown = 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):
        r"""__init__(OffRendererPointInfo self, Point n, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> OffRendererPointInfo"""
        _fife.OffRendererPointInfo_swiginit(self, _fife.new_OffRendererPointInfo(n, r, g, b, a))
    __swig_destroy__ = _fife.delete_OffRendererPointInfo

# Register OffRendererPointInfo in _fife:
_fife.OffRendererPointInfo_swigregister(OffRendererPointInfo)
class OffRendererTriangleInfo(OffRendererElementInfo):
    r"""Proxy of C++ FIFE::OffRendererTriangleInfo class."""

    thisown = 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):
        r"""__init__(OffRendererTriangleInfo self, Point n1, Point n2, Point n3, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> OffRendererTriangleInfo"""
        _fife.OffRendererTriangleInfo_swiginit(self, _fife.new_OffRendererTriangleInfo(n1, n2, n3, r, g, b, a))
    __swig_destroy__ = _fife.delete_OffRendererTriangleInfo

# Register OffRendererTriangleInfo in _fife:
_fife.OffRendererTriangleInfo_swigregister(OffRendererTriangleInfo)
class OffRendererQuadInfo(OffRendererElementInfo):
    r"""Proxy of C++ FIFE::OffRendererQuadInfo class."""

    thisown = 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):
        r"""__init__(OffRendererQuadInfo self, Point n1, Point n2, Point n3, Point n4, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> OffRendererQuadInfo"""
        _fife.OffRendererQuadInfo_swiginit(self, _fife.new_OffRendererQuadInfo(n1, n2, n3, n4, r, g, b, a))
    __swig_destroy__ = _fife.delete_OffRendererQuadInfo

# Register OffRendererQuadInfo in _fife:
_fife.OffRendererQuadInfo_swigregister(OffRendererQuadInfo)
class OffRendererVertexInfo(OffRendererElementInfo):
    r"""Proxy of C++ FIFE::OffRendererVertexInfo class."""

    thisown = 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):
        r"""__init__(OffRendererVertexInfo self, Point center, int32_t size, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> OffRendererVertexInfo"""
        _fife.OffRendererVertexInfo_swiginit(self, _fife.new_OffRendererVertexInfo(center, size, r, g, b, a))
    __swig_destroy__ = _fife.delete_OffRendererVertexInfo

# Register OffRendererVertexInfo in _fife:
_fife.OffRendererVertexInfo_swigregister(OffRendererVertexInfo)
class OffRendererImageInfo(OffRendererElementInfo):
    r"""Proxy of C++ FIFE::OffRendererImageInfo class."""

    thisown = 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):
        r"""__init__(OffRendererImageInfo self, Point n, SharedImagePointer image) -> OffRendererImageInfo"""
        _fife.OffRendererImageInfo_swiginit(self, _fife.new_OffRendererImageInfo(n, image))
    __swig_destroy__ = _fife.delete_OffRendererImageInfo

# Register OffRendererImageInfo in _fife:
_fife.OffRendererImageInfo_swigregister(OffRendererImageInfo)
class OffRendererAnimationInfo(OffRendererElementInfo):
    r"""Proxy of C++ FIFE::OffRendererAnimationInfo class."""

    thisown = 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):
        r"""__init__(OffRendererAnimationInfo self, Point n, SharedAnimationPointer animation) -> OffRendererAnimationInfo"""
        _fife.OffRendererAnimationInfo_swiginit(self, _fife.new_OffRendererAnimationInfo(n, animation))
    __swig_destroy__ = _fife.delete_OffRendererAnimationInfo

# Register OffRendererAnimationInfo in _fife:
_fife.OffRendererAnimationInfo_swigregister(OffRendererAnimationInfo)
class OffRendererTextInfo(OffRendererElementInfo):
    r"""Proxy of C++ FIFE::OffRendererTextInfo class."""

    thisown = 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):
        r"""__init__(OffRendererTextInfo self, Point n, IFont font, std::string text) -> OffRendererTextInfo"""
        _fife.OffRendererTextInfo_swiginit(self, _fife.new_OffRendererTextInfo(n, font, text))
    __swig_destroy__ = _fife.delete_OffRendererTextInfo

# Register OffRendererTextInfo in _fife:
_fife.OffRendererTextInfo_swigregister(OffRendererTextInfo)
class OffRendererResizeInfo(OffRendererElementInfo):
    r"""Proxy of C++ FIFE::OffRendererResizeInfo class."""

    thisown = 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):
        r"""__init__(OffRendererResizeInfo self, Point n, SharedImagePointer image, int32_t width, int32_t height) -> OffRendererResizeInfo"""
        _fife.OffRendererResizeInfo_swiginit(self, _fife.new_OffRendererResizeInfo(n, image, width, height))
    __swig_destroy__ = _fife.delete_OffRendererResizeInfo

# Register OffRendererResizeInfo in _fife:
_fife.OffRendererResizeInfo_swigregister(OffRendererResizeInfo)
class OffRenderer(object):
    r"""Proxy of C++ FIFE::OffRenderer class."""

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

    def __init__(self, renderbackend):
        r"""__init__(OffRenderer self, RenderBackend renderbackend) -> OffRenderer"""
        _fife.OffRenderer_swiginit(self, _fife.new_OffRenderer(renderbackend))
    __swig_destroy__ = _fife.delete_OffRenderer
    setEnabled = _swig_new_instance_method(_fife.OffRenderer_setEnabled)
    isEnabled = _swig_new_instance_method(_fife.OffRenderer_isEnabled)
    setClipArea = _swig_new_instance_method(_fife.OffRenderer_setClipArea)
    getClipArea = _swig_new_instance_method(_fife.OffRenderer_getClipArea)
    addLine = _swig_new_instance_method(_fife.OffRenderer_addLine)
    addPoint = _swig_new_instance_method(_fife.OffRenderer_addPoint)
    addTriangle = _swig_new_instance_method(_fife.OffRenderer_addTriangle)
    addQuad = _swig_new_instance_method(_fife.OffRenderer_addQuad)
    addVertex = _swig_new_instance_method(_fife.OffRenderer_addVertex)
    addText = _swig_new_instance_method(_fife.OffRenderer_addText)
    addImage = _swig_new_instance_method(_fife.OffRenderer_addImage)
    addAnimation = _swig_new_instance_method(_fife.OffRenderer_addAnimation)
    resizeImage = _swig_new_instance_method(_fife.OffRenderer_resizeImage)
    removeAll = _swig_new_instance_method(_fife.OffRenderer_removeAll)

# Register OffRenderer in _fife:
_fife.OffRenderer_swigregister(OffRenderer)
class RenderTarget(object):
    r"""Proxy of C++ FIFE::RenderTarget class."""

    thisown = 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
    addLine = _swig_new_instance_method(_fife.RenderTarget_addLine)
    addPoint = _swig_new_instance_method(_fife.RenderTarget_addPoint)
    addTriangle = _swig_new_instance_method(_fife.RenderTarget_addTriangle)
    addQuad = _swig_new_instance_method(_fife.RenderTarget_addQuad)
    addVertex = _swig_new_instance_method(_fife.RenderTarget_addVertex)
    addText = _swig_new_instance_method(_fife.RenderTarget_addText)
    addImage = _swig_new_instance_method(_fife.RenderTarget_addImage)
    addAnimation = _swig_new_instance_method(_fife.RenderTarget_addAnimation)
    resizeImage = _swig_new_instance_method(_fife.RenderTarget_resizeImage)
    removeAll = _swig_new_instance_method(_fife.RenderTarget_removeAll)
    render = _swig_new_instance_method(_fife.RenderTarget_render)
    getTarget = _swig_new_instance_method(_fife.RenderTarget_getTarget)

# Register RenderTarget in _fife:
_fife.RenderTarget_swigregister(RenderTarget)
class SharedRenderTargetPointer(object):
    r"""Proxy of C++ FIFE::SharedPtr< FIFE::RenderTarget > class."""

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

    def __init__(self, *args):
        r"""
        __init__(SharedRenderTargetPointer self) -> SharedRenderTargetPointer
        __init__(SharedRenderTargetPointer self, SharedRenderTargetPointer rhs) -> SharedRenderTargetPointer
        """
        _fife.SharedRenderTargetPointer_swiginit(self, _fife.new_SharedRenderTargetPointer(*args))
    __swig_destroy__ = _fife.delete_SharedRenderTargetPointer
    __ref__ = _swig_new_instance_method(_fife.SharedRenderTargetPointer___ref__)
    __deref__ = _swig_new_instance_method(_fife.SharedRenderTargetPointer___deref__)
    get = _swig_new_instance_method(_fife.SharedRenderTargetPointer_get)
    reset = _swig_new_instance_method(_fife.SharedRenderTargetPointer_reset)
    useCount = _swig_new_instance_method(_fife.SharedRenderTargetPointer_useCount)
    useCountPtr = _swig_new_instance_method(_fife.SharedRenderTargetPointer_useCountPtr)
    unique = _swig_new_instance_method(_fife.SharedRenderTargetPointer_unique)

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


    addLine = _swig_new_instance_method(_fife.SharedRenderTargetPointer_addLine)
    addPoint = _swig_new_instance_method(_fife.SharedRenderTargetPointer_addPoint)
    addTriangle = _swig_new_instance_method(_fife.SharedRenderTargetPointer_addTriangle)
    addQuad = _swig_new_instance_method(_fife.SharedRenderTargetPointer_addQuad)
    addVertex = _swig_new_instance_method(_fife.SharedRenderTargetPointer_addVertex)
    addText = _swig_new_instance_method(_fife.SharedRenderTargetPointer_addText)
    addImage = _swig_new_instance_method(_fife.SharedRenderTargetPointer_addImage)
    addAnimation = _swig_new_instance_method(_fife.SharedRenderTargetPointer_addAnimation)
    resizeImage = _swig_new_instance_method(_fife.SharedRenderTargetPointer_resizeImage)
    removeAll = _swig_new_instance_method(_fife.SharedRenderTargetPointer_removeAll)
    render = _swig_new_instance_method(_fife.SharedRenderTargetPointer_render)
    getTarget = _swig_new_instance_method(_fife.SharedRenderTargetPointer_getTarget)

# Register SharedRenderTargetPointer in _fife:
_fife.SharedRenderTargetPointer_swigregister(SharedRenderTargetPointer)
class TargetRenderer(object):
    r"""Proxy of C++ FIFE::TargetRenderer class."""

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

    def __init__(self, renderbackend):
        r"""__init__(TargetRenderer self, RenderBackend renderbackend) -> TargetRenderer"""
        _fife.TargetRenderer_swiginit(self, _fife.new_TargetRenderer(renderbackend))
    __swig_destroy__ = _fife.delete_TargetRenderer
    createRenderTarget = _swig_new_instance_method(_fife.TargetRenderer_createRenderTarget)
    setRenderTarget = _swig_new_instance_method(_fife.TargetRenderer_setRenderTarget)
    render = _swig_new_instance_method(_fife.TargetRenderer_render)

# Register TargetRenderer in _fife:
_fife.TargetRenderer_swigregister(TargetRenderer)
class IGUIManager(ISdlEventListener):
    r"""Proxy of C++ FIFE::IGUIManager class."""

    thisown = 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
    turn = _swig_new_instance_method(_fife.IGUIManager_turn)
    resizeTopContainer = _swig_new_instance_method(_fife.IGUIManager_resizeTopContainer)

# Register IGUIManager in _fife:
_fife.IGUIManager_swigregister(IGUIManager)
class HybridGuiManager(IGUIManager):
    r"""Proxy of C++ FIFE::HybridGuiManager class."""

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

    def __init__(self):
        r"""__init__(HybridGuiManager self) -> HybridGuiManager"""
        _fife.HybridGuiManager_swiginit(self, _fife.new_HybridGuiManager())
    __swig_destroy__ = _fife.delete_HybridGuiManager
    addGuiManager = _swig_new_instance_method(_fife.HybridGuiManager_addGuiManager)
    removeGuiManager = _swig_new_instance_method(_fife.HybridGuiManager_removeGuiManager)

# Register HybridGuiManager in _fife:
_fife.HybridGuiManager_swigregister(HybridGuiManager)
class Font(object):
    r"""Proxy of C++ fcn::Font class."""

    thisown = 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
    getWidth = _swig_new_instance_method(_fife.Font_getWidth)
    getHeight = _swig_new_instance_method(_fife.Font_getHeight)

# Register Font in _fife:
_fife.Font_swigregister(Font)
class GuiFont(Font, IFont):
    r"""Proxy of C++ FIFE::GuiFont class."""

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

    def __init__(self, font):
        r"""__init__(GuiFont self, IFont font) -> GuiFont"""
        _fife.GuiFont_swiginit(self, _fife.new_GuiFont(font))
    __swig_destroy__ = _fife.delete_GuiFont
    getStringIndexAt = _swig_new_instance_method(_fife.GuiFont_getStringIndexAt)
    drawString = _swig_new_instance_method(_fife.GuiFont_drawString)
    setRowSpacing = _swig_new_instance_method(_fife.GuiFont_setRowSpacing)
    getRowSpacing = _swig_new_instance_method(_fife.GuiFont_getRowSpacing)
    setGlyphSpacing = _swig_new_instance_method(_fife.GuiFont_setGlyphSpacing)
    getGlyphSpacing = _swig_new_instance_method(_fife.GuiFont_getGlyphSpacing)
    setAntiAlias = _swig_new_instance_method(_fife.GuiFont_setAntiAlias)
    isAntiAlias = _swig_new_instance_method(_fife.GuiFont_isAntiAlias)
    setBoldStyle = _swig_new_instance_method(_fife.GuiFont_setBoldStyle)
    isBoldStyle = _swig_new_instance_method(_fife.GuiFont_isBoldStyle)
    setItalicStyle = _swig_new_instance_method(_fife.GuiFont_setItalicStyle)
    isItalicStyle = _swig_new_instance_method(_fife.GuiFont_isItalicStyle)
    setUnderlineStyle = _swig_new_instance_method(_fife.GuiFont_setUnderlineStyle)
    isUnderlineStyle = _swig_new_instance_method(_fife.GuiFont_isUnderlineStyle)
    setStrikethroughStyle = _swig_new_instance_method(_fife.GuiFont_setStrikethroughStyle)
    isStrikethroughStyle = _swig_new_instance_method(_fife.GuiFont_isStrikethroughStyle)
    setDynamicColoring = _swig_new_instance_method(_fife.GuiFont_setDynamicColoring)
    isDynamicColoring = _swig_new_instance_method(_fife.GuiFont_isDynamicColoring)
    getAsImage = _swig_new_instance_method(_fife.GuiFont_getAsImage)
    setColor = _swig_new_instance_method(_fife.GuiFont_setColor)
    getColor = _swig_new_instance_method(_fife.GuiFont_getColor)
    getWidth = _swig_new_instance_method(_fife.GuiFont_getWidth)
    getHeight = _swig_new_instance_method(_fife.GuiFont_getHeight)

# Register GuiFont in _fife:
_fife.GuiFont_swigregister(GuiFont)
class GcnImage(object):
    r"""Proxy of C++ fcn::Image class."""

    thisown = 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
    load = _swig_new_static_method(_fife.GcnImage_load)
    getWidth = _swig_new_instance_method(_fife.GcnImage_getWidth)
    getHeight = _swig_new_instance_method(_fife.GcnImage_getHeight)

# Register GcnImage in _fife:
_fife.GcnImage_swigregister(GcnImage)
class GuiImage(GcnImage):
    r"""Proxy of C++ FIFE::GuiImage class."""

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

    def __init__(self, *args):
        r"""
        __init__(GuiImage self) -> GuiImage
        __init__(GuiImage self, SharedImagePointer Image) -> GuiImage
        """
        _fife.GuiImage_swiginit(self, _fife.new_GuiImage(*args))
    getWidth = _swig_new_instance_method(_fife.GuiImage_getWidth)
    getHeight = _swig_new_instance_method(_fife.GuiImage_getHeight)
    __swig_destroy__ = _fife.delete_GuiImage

# Register GuiImage in _fife:
_fife.GuiImage_swigregister(GuiImage)
class ConsoleExecuter(object):
    r"""Proxy of C++ FIFE::ConsoleExecuter class."""

    thisown = 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
    onToolsClick = _swig_new_instance_method(_fife.ConsoleExecuter_onToolsClick)
    onConsoleCommand = _swig_new_instance_method(_fife.ConsoleExecuter_onConsoleCommand)

    def __init__(self):
        r"""__init__(ConsoleExecuter self) -> ConsoleExecuter"""
        if self.__class__ == ConsoleExecuter:
            _self = None
        else:
            _self = self
        _fife.ConsoleExecuter_swiginit(self, _fife.new_ConsoleExecuter(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_ConsoleExecuter(self)
        return weakref.proxy(self)

# Register ConsoleExecuter in _fife:
_fife.ConsoleExecuter_swigregister(ConsoleExecuter)
class Console(object):
    r"""Proxy of C++ FIFE::Console class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    show = _swig_new_instance_method(_fife.Console_show)
    hide = _swig_new_instance_method(_fife.Console_hide)
    clear = _swig_new_instance_method(_fife.Console_clear)
    toggleShowHide = _swig_new_instance_method(_fife.Console_toggleShowHide)
    println = _swig_new_instance_method(_fife.Console_println)
    setConsoleExecuter = _swig_new_instance_method(_fife.Console_setConsoleExecuter)
    removeConsoleExecuter = _swig_new_instance_method(_fife.Console_removeConsoleExecuter)

    def __init__(self):
        r"""__init__(Console self) -> Console"""
        _fife.Console_swiginit(self, _fife.new_Console())
    __swig_destroy__ = _fife.delete_Console

# Register Console in _fife:
_fife.Console_swigregister(Console)
class FifechanManager(IGUIManager):
    r"""Proxy of C++ FIFE::FifechanManager class."""

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

    def __init__(self):
        r"""__init__(FifechanManager self) -> FifechanManager"""
        _fife.FifechanManager_swiginit(self, _fife.new_FifechanManager())
    __swig_destroy__ = _fife.delete_FifechanManager
    init = _swig_new_instance_method(_fife.FifechanManager_init)
    getConsole = _swig_new_instance_method(_fife.FifechanManager_getConsole)
    setConsoleEnabled = _swig_new_instance_method(_fife.FifechanManager_setConsoleEnabled)
    isConsoleEnabled = _swig_new_instance_method(_fife.FifechanManager_isConsoleEnabled)
    setCursor = _swig_new_instance_method(_fife.FifechanManager_setCursor)
    getCursor = _swig_new_instance_method(_fife.FifechanManager_getCursor)
    add = _swig_new_instance_method(_fife.FifechanManager_add)
    remove = _swig_new_instance_method(_fife.FifechanManager_remove)
    createFont = _swig_new_instance_method(_fife.FifechanManager_createFont)
    releaseFont = _swig_new_instance_method(_fife.FifechanManager_releaseFont)
    setDefaultFont = _swig_new_instance_method(_fife.FifechanManager_setDefaultFont)
    getDefaultFont = _swig_new_instance_method(_fife.FifechanManager_getDefaultFont)
    translateKeyEvent = _swig_new_instance_method(_fife.FifechanManager_translateKeyEvent)
    translateMouseEvent = _swig_new_instance_method(_fife.FifechanManager_translateMouseEvent)
    setTabbingEnabled = _swig_new_instance_method(_fife.FifechanManager_setTabbingEnabled)
    isTabbingEnabled = _swig_new_instance_method(_fife.FifechanManager_isTabbingEnabled)

# Register FifechanManager in _fife:
_fife.FifechanManager_swigregister(FifechanManager)
class AnimationIcon(fife.fifechan.Icon):
    r"""Proxy of C++ fcn::AnimationIcon class."""

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

    def __init__(self, *args):
        r"""
        __init__(AnimationIcon self) -> AnimationIcon
        __init__(AnimationIcon self, SharedAnimationPointer animation) -> AnimationIcon
        """
        _fife.AnimationIcon_swiginit(self, _fife.new_AnimationIcon(*args))
    __swig_destroy__ = _fife.delete_AnimationIcon
    setAnimation = _swig_new_instance_method(_fife.AnimationIcon_setAnimation)
    getAnimation = _swig_new_instance_method(_fife.AnimationIcon_getAnimation)
    setRepeating = _swig_new_instance_method(_fife.AnimationIcon_setRepeating)
    isRepeating = _swig_new_instance_method(_fife.AnimationIcon_isRepeating)
    play = _swig_new_instance_method(_fife.AnimationIcon_play)
    isPlaying = _swig_new_instance_method(_fife.AnimationIcon_isPlaying)
    pause = _swig_new_instance_method(_fife.AnimationIcon_pause)
    stop = _swig_new_instance_method(_fife.AnimationIcon_stop)

# Register AnimationIcon in _fife:
_fife.AnimationIcon_swigregister(AnimationIcon)
class Label(fife.fifechan.Widget):
    r"""Proxy of C++ fcn::ClickLabel class."""

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

    def __init__(self, *args):
        r"""
        ClickLabel() -> Label
        __init__(Label self, std::string const & caption) -> Label
        """
        _fife.Label_swiginit(self, _fife.new_Label(*args))
    __swig_destroy__ = _fife.delete_Label
    setCaption = _swig_new_instance_method(_fife.Label_setCaption)
    getCaption = _swig_new_instance_method(_fife.Label_getCaption)
    setAlignment = _swig_new_instance_method(_fife.Label_setAlignment)
    getAlignment = _swig_new_instance_method(_fife.Label_getAlignment)
    setOpaque = _swig_new_instance_method(_fife.Label_setOpaque)
    isOpaque = _swig_new_instance_method(_fife.Label_isOpaque)
    isTextWrapping = _swig_new_instance_method(_fife.Label_isTextWrapping)
    setTextWrapping = _swig_new_instance_method(_fife.Label_setTextWrapping)
    adjustSize = _swig_new_instance_method(_fife.Label_adjustSize)

# Register Label in _fife:
_fife.Label_swigregister(Label)
class PercentageBar(fife.fifechan.Widget):
    r"""Proxy of C++ fcn::PercentageBar class."""

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

    def __init__(self):
        r"""__init__(PercentageBar self) -> PercentageBar"""
        _fife.PercentageBar_swiginit(self, _fife.new_PercentageBar())
    __swig_destroy__ = _fife.delete_PercentageBar
    setForegroundImage = _swig_new_instance_method(_fife.PercentageBar_setForegroundImage)
    setOrientation = _swig_new_instance_method(_fife.PercentageBar_setOrientation)
    getOrientation = _swig_new_instance_method(_fife.PercentageBar_getOrientation)
    getValue = _swig_new_instance_method(_fife.PercentageBar_getValue)
    setValue = _swig_new_instance_method(_fife.PercentageBar_setValue)
    HORIZONTAL = _fife.PercentageBar_HORIZONTAL
    
    VERTICAL = _fife.PercentageBar_VERTICAL
    

# Register PercentageBar in _fife:
_fife.PercentageBar_swigregister(PercentageBar)
class ResizableWindow(fife.fifechan.Window):
    r"""Proxy of C++ fcn::ResizableWindow class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CURSOR_DIRECTION_L = _fife.ResizableWindow_CURSOR_DIRECTION_L
    
    CURSOR_DIRECTION_R = _fife.ResizableWindow_CURSOR_DIRECTION_R
    
    CURSOR_DIRECTION_T = _fife.ResizableWindow_CURSOR_DIRECTION_T
    
    CURSOR_DIRECTION_B = _fife.ResizableWindow_CURSOR_DIRECTION_B
    
    CURSOR_DIRECTION_LT = _fife.ResizableWindow_CURSOR_DIRECTION_LT
    
    CURSOR_DIRECTION_RT = _fife.ResizableWindow_CURSOR_DIRECTION_RT
    
    CURSOR_DIRECTION_LB = _fife.ResizableWindow_CURSOR_DIRECTION_LB
    
    CURSOR_DIRECTION_RB = _fife.ResizableWindow_CURSOR_DIRECTION_RB
    

    def __init__(self, *args):
        r"""
        __init__(ResizableWindow self) -> ResizableWindow
        __init__(ResizableWindow self, bool resizable) -> ResizableWindow
        __init__(ResizableWindow self, std::string const & caption, bool resizable=True) -> ResizableWindow
        """
        _fife.ResizableWindow_swiginit(self, _fife.new_ResizableWindow(*args))
    __swig_destroy__ = _fife.delete_ResizableWindow
    setResizableBorderDistance = _swig_new_instance_method(_fife.ResizableWindow_setResizableBorderDistance)
    getResizableBorderDistance = _swig_new_instance_method(_fife.ResizableWindow_getResizableBorderDistance)
    setResizable = _swig_new_instance_method(_fife.ResizableWindow_setResizable)
    isResizable = _swig_new_instance_method(_fife.ResizableWindow_isResizable)
    setTopResizable = _swig_new_instance_method(_fife.ResizableWindow_setTopResizable)
    isTopResizable = _swig_new_instance_method(_fife.ResizableWindow_isTopResizable)
    setRightResizable = _swig_new_instance_method(_fife.ResizableWindow_setRightResizable)
    isRightResizable = _swig_new_instance_method(_fife.ResizableWindow_isRightResizable)
    setBottomResizable = _swig_new_instance_method(_fife.ResizableWindow_setBottomResizable)
    isBottomResizable = _swig_new_instance_method(_fife.ResizableWindow_isBottomResizable)
    setLeftResizable = _swig_new_instance_method(_fife.ResizableWindow_setLeftResizable)
    isLeftResizable = _swig_new_instance_method(_fife.ResizableWindow_isLeftResizable)
    setShove = _swig_new_instance_method(_fife.ResizableWindow_setShove)
    getShove = _swig_new_instance_method(_fife.ResizableWindow_getShove)
    set = _swig_new_instance_method(_fife.ResizableWindow_set)
    getType = _swig_new_instance_method(_fife.ResizableWindow_getType)
    getId = _swig_new_instance_method(_fife.ResizableWindow_getId)
    getImage = _swig_new_instance_method(_fife.ResizableWindow_getImage)
    getAnimation = _swig_new_instance_method(_fife.ResizableWindow_getAnimation)

# Register ResizableWindow in _fife:
_fife.ResizableWindow_swigregister(ResizableWindow)
class DockArea(ResizableWindow):
    r"""Proxy of C++ fcn::DockArea class."""

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

    def __init__(self, *args):
        r"""
        __init__(DockArea self) -> DockArea
        __init__(DockArea self, bool active) -> DockArea
        """
        _fife.DockArea_swiginit(self, _fife.new_DockArea(*args))
    __swig_destroy__ = _fife.delete_DockArea
    setActiveDockArea = _swig_new_instance_method(_fife.DockArea_setActiveDockArea)
    isActiveDockArea = _swig_new_instance_method(_fife.DockArea_isActiveDockArea)
    setTopSide = _swig_new_instance_method(_fife.DockArea_setTopSide)
    isTopSide = _swig_new_instance_method(_fife.DockArea_isTopSide)
    setRightSide = _swig_new_instance_method(_fife.DockArea_setRightSide)
    isRightSide = _swig_new_instance_method(_fife.DockArea_isRightSide)
    setBottomSide = _swig_new_instance_method(_fife.DockArea_setBottomSide)
    isBottomSide = _swig_new_instance_method(_fife.DockArea_isBottomSide)
    setLeftSide = _swig_new_instance_method(_fife.DockArea_setLeftSide)
    isLeftSide = _swig_new_instance_method(_fife.DockArea_isLeftSide)
    dockWidget = _swig_new_instance_method(_fife.DockArea_dockWidget)
    undockWidget = _swig_new_instance_method(_fife.DockArea_undockWidget)
    setHighlighted = _swig_new_instance_method(_fife.DockArea_setHighlighted)
    isHighlighted = _swig_new_instance_method(_fife.DockArea_isHighlighted)
    setHighlightColor = _swig_new_instance_method(_fife.DockArea_setHighlightColor)
    getHighlightColor = _swig_new_instance_method(_fife.DockArea_getHighlightColor)

# Register DockArea in _fife:
_fife.DockArea_swigregister(DockArea)
class Panel(ResizableWindow):
    r"""Proxy of C++ fcn::Panel class."""

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

    def __init__(self, *args):
        r"""
        __init__(Panel self) -> Panel
        __init__(Panel self, bool dockable) -> Panel
        """
        _fife.Panel_swiginit(self, _fife.new_Panel(*args))
    __swig_destroy__ = _fife.delete_Panel
    setDockable = _swig_new_instance_method(_fife.Panel_setDockable)
    isDockable = _swig_new_instance_method(_fife.Panel_isDockable)
    setDocked = _swig_new_instance_method(_fife.Panel_setDocked)
    isDocked = _swig_new_instance_method(_fife.Panel_isDocked)

# Register Panel in _fife:
_fife.Panel_swigregister(Panel)

