# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# 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
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_adonthell', [dirname(__file__)])
        except ImportError:
            import _adonthell
            return _adonthell
        if fp is not None:
            try:
                _mod = imp.load_module('_adonthell', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _adonthell = swig_import_helper()
    del swig_import_helper
else:
    import _adonthell
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


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


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

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



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



_adonthell.Python_swigconstant(_adonthell)
Python = _adonthell.Python

_adonthell.C_swigconstant(_adonthell)
C = _adonthell.C

_adonthell.READ_swigconstant(_adonthell)
READ = _adonthell.READ

_adonthell.WRITE_swigconstant(_adonthell)
WRITE = _adonthell.WRITE
class gz_file(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_gz_file(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_gz_file
    __del__ = lambda self: None

    def open(self, *args):
        return _adonthell.gz_file_open(self, *args)

    def close(self, *args):
        return _adonthell.gz_file_close(self, *args)

    def is_open(self, *args):
        return _adonthell.gz_file_is_open(self, *args)

    def eof(self, *args):
        return _adonthell.gz_file_eof(self, *args)
gz_file_swigregister = _adonthell.gz_file_swigregister
gz_file_swigregister(gz_file)

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

    def __init__(self, *args):
        this = _adonthell.new_igzstream(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_igzstream
    __del__ = lambda self: None

    def open(self, *args):
        return _adonthell.igzstream_open(self, *args)

    def get_block(self, *args):
        return _adonthell.igzstream_get_block(self, *args)

    def get_bool(self, *args):
        return _adonthell.igzstream_get_bool(self, *args)

    def get_uint8(self, *args):
        return _adonthell.igzstream_get_uint8(self, *args)

    def get_sint8(self, *args):
        return _adonthell.igzstream_get_sint8(self, *args)

    def get_uint16(self, *args):
        return _adonthell.igzstream_get_uint16(self, *args)

    def get_sint16(self, *args):
        return _adonthell.igzstream_get_sint16(self, *args)

    def get_uint32(self, *args):
        return _adonthell.igzstream_get_uint32(self, *args)

    def get_sint32(self, *args):
        return _adonthell.igzstream_get_sint32(self, *args)

    def get_string(self, *args):
        return _adonthell.igzstream_get_string(self, *args)

    def get_float(self, *args):
        return _adonthell.igzstream_get_float(self, *args)
igzstream_swigregister = _adonthell.igzstream_swigregister
igzstream_swigregister(igzstream)

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

    def __init__(self, *args):
        this = _adonthell.new_ogzstream(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_ogzstream
    __del__ = lambda self: None

    def open(self, *args):
        return _adonthell.ogzstream_open(self, *args)

    def put_block(self, *args):
        return _adonthell.ogzstream_put_block(self, *args)

    def put_bool(self, *args):
        return _adonthell.ogzstream_put_bool(self, *args)

    def put_uint8(self, *args):
        return _adonthell.ogzstream_put_uint8(self, *args)

    def put_sint8(self, *args):
        return _adonthell.ogzstream_put_sint8(self, *args)

    def put_uint16(self, *args):
        return _adonthell.ogzstream_put_uint16(self, *args)

    def put_sint16(self, *args):
        return _adonthell.ogzstream_put_sint16(self, *args)

    def put_uint32(self, *args):
        return _adonthell.ogzstream_put_uint32(self, *args)

    def put_sint32(self, *args):
        return _adonthell.ogzstream_put_sint32(self, *args)

    def put_string(self, *args):
        return _adonthell.ogzstream_put_string(self, *args)

    def put_float(self, *args):
        return _adonthell.ogzstream_put_float(self, *args)
ogzstream_swigregister = _adonthell.ogzstream_swigregister
ogzstream_swigregister(ogzstream)

class fileops(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    put_version = staticmethod(_adonthell.fileops_put_version)
    get_version = staticmethod(_adonthell.fileops_get_version)

    def __init__(self, *args):
        this = _adonthell.new_fileops(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_fileops
    __del__ = lambda self: None
fileops_swigregister = _adonthell.fileops_swigregister
fileops_swigregister(fileops)

def fileops_put_version(*args):
    return _adonthell.fileops_put_version(*args)
fileops_put_version = _adonthell.fileops_put_version

def fileops_get_version(*args):
    return _adonthell.fileops_get_version(*args)
fileops_get_version = _adonthell.fileops_get_version


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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _adonthell.delete_event
    __del__ = lambda self: None

    def clear(self, *args):
        return _adonthell.event_clear(self, *args)

    def type(self, *args):
        return _adonthell.event_type(self, *args)

    def id(self, *args):
        return _adonthell.event_id(self, *args)

    def set_id(self, *args):
        return _adonthell.event_set_id(self, *args)

    def registered(self, *args):
        return _adonthell.event_registered(self, *args)

    def repeat(self, *args):
        return _adonthell.event_repeat(self, *args)

    def set_repeat(self, *args):
        return _adonthell.event_set_repeat(self, *args)

    def execute(self, *args):
        return _adonthell.event_execute(self, *args)

    def equals(self, *args):
        return _adonthell.event_equals(self, *args)

    def set_script(self, *args):
        return _adonthell.event_set_script(self, *args)

    def set_callback(self, *args):
        return _adonthell.event_set_callback(self, *args)

    def pause(self, *args):
        return _adonthell.event_pause(self, *args)

    def resume(self, *args):
        return _adonthell.event_resume(self, *args)

    def is_paused(self, *args):
        return _adonthell.event_is_paused(self, *args)

    def put_state(self, *args):
        return _adonthell.event_put_state(self, *args)

    def get_state(self, *args):
        return _adonthell.event_get_state(self, *args)
event_swigregister = _adonthell.event_swigregister
event_swigregister(event)

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

    def __init__(self, *args):
        this = _adonthell.new_event_list(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_event_list
    __del__ = lambda self: None

    def clear(self, *args):
        return _adonthell.event_list_clear(self, *args)

    def add_event(self, *args):
        return _adonthell.event_list_add_event(self, *args)

    def remove_event(self, *args):
        return _adonthell.event_list_remove_event(self, *args)

    def get_event(self, *args):
        return _adonthell.event_list_get_event(self, *args)

    def pause(self, *args):
        return _adonthell.event_list_pause(self, *args)

    def resume(self, *args):
        return _adonthell.event_list_resume(self, *args)

    def is_paused(self, *args):
        return _adonthell.event_list_is_paused(self, *args)

    def put_state(self, *args):
        return _adonthell.event_list_put_state(self, *args)

    def get_state(self, *args):
        return _adonthell.event_list_get_state(self, *args)
event_list_swigregister = _adonthell.event_list_swigregister
event_list_swigregister(event_list)

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

    def __init__(self, *args):
        this = _adonthell.new_time_event(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_repeat(self, *args):
        return _adonthell.time_event_set_repeat(self, *args)

    def equals(self, *args):
        return _adonthell.time_event_equals(self, *args)

    def execute(self, *args):
        return _adonthell.time_event_execute(self, *args)

    def put_state(self, *args):
        return _adonthell.time_event_put_state(self, *args)

    def get_state(self, *args):
        return _adonthell.time_event_get_state(self, *args)

    def pause(self, *args):
        return _adonthell.time_event_pause(self, *args)

    def resume(self, *args):
        return _adonthell.time_event_resume(self, *args)

    def time(self, *args):
        return _adonthell.time_event_time(self, *args)
    __swig_destroy__ = _adonthell.delete_time_event
    __del__ = lambda self: None
time_event_swigregister = _adonthell.time_event_swigregister
time_event_swigregister(time_event)

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

    def __init__(self, *args):
        this = _adonthell.new_map_event(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def put_state(self, *args):
        return _adonthell.map_event_put_state(self, *args)

    def get_state(self, *args):
        return _adonthell.map_event_get_state(self, *args)
    submap = _swig_property(_adonthell.map_event_submap_get, _adonthell.map_event_submap_set)
    x = _swig_property(_adonthell.map_event_x_get, _adonthell.map_event_x_set)
    y = _swig_property(_adonthell.map_event_y_get, _adonthell.map_event_y_set)
    dir = _swig_property(_adonthell.map_event_dir_get, _adonthell.map_event_dir_set)
    map = _swig_property(_adonthell.map_event_map_get, _adonthell.map_event_map_set)
    c = _swig_property(_adonthell.map_event_c_get, _adonthell.map_event_c_set)

    def equals(self, *args):
        return _adonthell.map_event_equals(self, *args)

    def execute(self, *args):
        return _adonthell.map_event_execute(self, *args)
    __swig_destroy__ = _adonthell.delete_map_event
    __del__ = lambda self: None
map_event_swigregister = _adonthell.map_event_swigregister
map_event_swigregister(map_event)

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

    def __init__(self, *args):
        this = _adonthell.new_enter_event(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_enter_event
    __del__ = lambda self: None
enter_event_swigregister = _adonthell.enter_event_swigregister
enter_event_swigregister(enter_event)

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

    def __init__(self, *args):
        this = _adonthell.new_leave_event(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_leave_event
    __del__ = lambda self: None
leave_event_swigregister = _adonthell.leave_event_swigregister
leave_event_swigregister(leave_event)

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

    def __init__(self, *args):
        this = _adonthell.new_action_event(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_action_event
    __del__ = lambda self: None
action_event_swigregister = _adonthell.action_event_swigregister
action_event_swigregister(action_event)

class event_handler(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    init = staticmethod(_adonthell.event_handler_init)
    cleanup = staticmethod(_adonthell.event_handler_cleanup)
    remove_event = staticmethod(_adonthell.event_handler_remove_event)
    raise_event = staticmethod(_adonthell.event_handler_raise_event)

    def __init__(self, *args):
        this = _adonthell.new_event_handler(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_event_handler
    __del__ = lambda self: None
event_handler_swigregister = _adonthell.event_handler_swigregister
event_handler_swigregister(event_handler)

def event_handler_init(*args):
    return _adonthell.event_handler_init(*args)
event_handler_init = _adonthell.event_handler_init

def event_handler_cleanup(*args):
    return _adonthell.event_handler_cleanup(*args)
event_handler_cleanup = _adonthell.event_handler_cleanup

def event_handler_remove_event(*args):
    return _adonthell.event_handler_remove_event(*args)
event_handler_remove_event = _adonthell.event_handler_remove_event

def event_handler_raise_event(*args):
    return _adonthell.event_handler_raise_event(*args)
event_handler_raise_event = _adonthell.event_handler_raise_event

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

    def __init__(self, *args):
        this = _adonthell.new_storage(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_storage
    __del__ = lambda self: None

    def set_val(self, *args):
        return _adonthell.storage_set_val(self, *args)

    def get_val(self, *args):
        return _adonthell.storage_get_val(self, *args)

    def next(self, *args):
        return _adonthell.storage_next(self, *args)
storage_swigregister = _adonthell.storage_swigregister
storage_swigregister(storage)

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

    def __init__(self, *args):
        this = _adonthell.new_objects(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_val(self, *args):
        return _adonthell.objects_set_val(self, *args)

    def get_val(self, *args):
        return _adonthell.objects_get_val(self, *args)

    def erase(self, *args):
        return _adonthell.objects_erase(self, *args)

    def next(self, *args):
        return _adonthell.objects_next(self, *args)
    __swig_destroy__ = _adonthell.delete_objects
    __del__ = lambda self: None
objects_swigregister = _adonthell.objects_swigregister
objects_swigregister(objects)


_adonthell.CYCLE_LENGTH_swigconstant(_adonthell)
CYCLE_LENGTH = _adonthell.CYCLE_LENGTH

_adonthell.FRAME_RATE_swigconstant(_adonthell)
FRAME_RATE = _adonthell.FRAME_RATE

_adonthell.FTS_LIMIT_swigconstant(_adonthell)
FTS_LIMIT = _adonthell.FTS_LIMIT
class gametime(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    init = staticmethod(_adonthell.gametime_init)
    minute = staticmethod(_adonthell.gametime_minute)
    start_action = staticmethod(_adonthell.gametime_start_action)
    stop_action = staticmethod(_adonthell.gametime_stop_action)
    frames_to_skip = staticmethod(_adonthell.gametime_frames_to_skip)
    update = staticmethod(_adonthell.gametime_update)

    def __init__(self, *args):
        this = _adonthell.new_gametime(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_gametime
    __del__ = lambda self: None
gametime_swigregister = _adonthell.gametime_swigregister
gametime_swigregister(gametime)

def gametime_init(*args):
    return _adonthell.gametime_init(*args)
gametime_init = _adonthell.gametime_init

def gametime_minute(*args):
    return _adonthell.gametime_minute(*args)
gametime_minute = _adonthell.gametime_minute

def gametime_start_action(*args):
    return _adonthell.gametime_start_action(*args)
gametime_start_action = _adonthell.gametime_start_action

def gametime_stop_action(*args):
    return _adonthell.gametime_stop_action(*args)
gametime_stop_action = _adonthell.gametime_stop_action

def gametime_frames_to_skip(*args):
    return _adonthell.gametime_frames_to_skip(*args)
gametime_frames_to_skip = _adonthell.gametime_frames_to_skip

def gametime_update(*args):
    return _adonthell.gametime_update(*args)
gametime_update = _adonthell.gametime_update

class gamedate(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    update = staticmethod(_adonthell.gamedate_update)
    time = staticmethod(_adonthell.gamedate_time)
    weekday = staticmethod(_adonthell.gamedate_weekday)
    day = staticmethod(_adonthell.gamedate_day)
    hour = staticmethod(_adonthell.gamedate_hour)
    minute = staticmethod(_adonthell.gamedate_minute)
    parse_time = staticmethod(_adonthell.gamedate_parse_time)
    get_state = staticmethod(_adonthell.gamedate_get_state)
    put_state = staticmethod(_adonthell.gamedate_put_state)

    def __init__(self, *args):
        this = _adonthell.new_gamedate(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_gamedate
    __del__ = lambda self: None
gamedate_swigregister = _adonthell.gamedate_swigregister
gamedate_swigregister(gamedate)

def gamedate_update(*args):
    return _adonthell.gamedate_update(*args)
gamedate_update = _adonthell.gamedate_update

def gamedate_time(*args):
    return _adonthell.gamedate_time(*args)
gamedate_time = _adonthell.gamedate_time

def gamedate_weekday(*args):
    return _adonthell.gamedate_weekday(*args)
gamedate_weekday = _adonthell.gamedate_weekday

def gamedate_day(*args):
    return _adonthell.gamedate_day(*args)
gamedate_day = _adonthell.gamedate_day

def gamedate_hour(*args):
    return _adonthell.gamedate_hour(*args)
gamedate_hour = _adonthell.gamedate_hour

def gamedate_minute(*args):
    return _adonthell.gamedate_minute(*args)
gamedate_minute = _adonthell.gamedate_minute

def gamedate_parse_time(*args):
    return _adonthell.gamedate_parse_time(*args)
gamedate_parse_time = _adonthell.gamedate_parse_time

def gamedate_get_state(*args):
    return _adonthell.gamedate_get_state(*args)
gamedate_get_state = _adonthell.gamedate_get_state

def gamedate_put_state(*args):
    return _adonthell.gamedate_put_state(*args)
gamedate_put_state = _adonthell.gamedate_put_state


_adonthell.SDLK_SCANCODE_MASK_swigconstant(_adonthell)
SDLK_SCANCODE_MASK = _adonthell.SDLK_SCANCODE_MASK

_adonthell.SDLK_UNKNOWN_swigconstant(_adonthell)
SDLK_UNKNOWN = _adonthell.SDLK_UNKNOWN

_adonthell.SDLK_RETURN_swigconstant(_adonthell)
SDLK_RETURN = _adonthell.SDLK_RETURN

_adonthell.SDLK_ESCAPE_swigconstant(_adonthell)
SDLK_ESCAPE = _adonthell.SDLK_ESCAPE

_adonthell.SDLK_BACKSPACE_swigconstant(_adonthell)
SDLK_BACKSPACE = _adonthell.SDLK_BACKSPACE

_adonthell.SDLK_TAB_swigconstant(_adonthell)
SDLK_TAB = _adonthell.SDLK_TAB

_adonthell.SDLK_SPACE_swigconstant(_adonthell)
SDLK_SPACE = _adonthell.SDLK_SPACE

_adonthell.SDLK_EXCLAIM_swigconstant(_adonthell)
SDLK_EXCLAIM = _adonthell.SDLK_EXCLAIM

_adonthell.SDLK_QUOTEDBL_swigconstant(_adonthell)
SDLK_QUOTEDBL = _adonthell.SDLK_QUOTEDBL

_adonthell.SDLK_HASH_swigconstant(_adonthell)
SDLK_HASH = _adonthell.SDLK_HASH

_adonthell.SDLK_PERCENT_swigconstant(_adonthell)
SDLK_PERCENT = _adonthell.SDLK_PERCENT

_adonthell.SDLK_DOLLAR_swigconstant(_adonthell)
SDLK_DOLLAR = _adonthell.SDLK_DOLLAR

_adonthell.SDLK_AMPERSAND_swigconstant(_adonthell)
SDLK_AMPERSAND = _adonthell.SDLK_AMPERSAND

_adonthell.SDLK_QUOTE_swigconstant(_adonthell)
SDLK_QUOTE = _adonthell.SDLK_QUOTE

_adonthell.SDLK_LEFTPAREN_swigconstant(_adonthell)
SDLK_LEFTPAREN = _adonthell.SDLK_LEFTPAREN

_adonthell.SDLK_RIGHTPAREN_swigconstant(_adonthell)
SDLK_RIGHTPAREN = _adonthell.SDLK_RIGHTPAREN

_adonthell.SDLK_ASTERISK_swigconstant(_adonthell)
SDLK_ASTERISK = _adonthell.SDLK_ASTERISK

_adonthell.SDLK_PLUS_swigconstant(_adonthell)
SDLK_PLUS = _adonthell.SDLK_PLUS

_adonthell.SDLK_COMMA_swigconstant(_adonthell)
SDLK_COMMA = _adonthell.SDLK_COMMA

_adonthell.SDLK_MINUS_swigconstant(_adonthell)
SDLK_MINUS = _adonthell.SDLK_MINUS

_adonthell.SDLK_PERIOD_swigconstant(_adonthell)
SDLK_PERIOD = _adonthell.SDLK_PERIOD

_adonthell.SDLK_SLASH_swigconstant(_adonthell)
SDLK_SLASH = _adonthell.SDLK_SLASH

_adonthell.SDLK_0_swigconstant(_adonthell)
SDLK_0 = _adonthell.SDLK_0

_adonthell.SDLK_1_swigconstant(_adonthell)
SDLK_1 = _adonthell.SDLK_1

_adonthell.SDLK_2_swigconstant(_adonthell)
SDLK_2 = _adonthell.SDLK_2

_adonthell.SDLK_3_swigconstant(_adonthell)
SDLK_3 = _adonthell.SDLK_3

_adonthell.SDLK_4_swigconstant(_adonthell)
SDLK_4 = _adonthell.SDLK_4

_adonthell.SDLK_5_swigconstant(_adonthell)
SDLK_5 = _adonthell.SDLK_5

_adonthell.SDLK_6_swigconstant(_adonthell)
SDLK_6 = _adonthell.SDLK_6

_adonthell.SDLK_7_swigconstant(_adonthell)
SDLK_7 = _adonthell.SDLK_7

_adonthell.SDLK_8_swigconstant(_adonthell)
SDLK_8 = _adonthell.SDLK_8

_adonthell.SDLK_9_swigconstant(_adonthell)
SDLK_9 = _adonthell.SDLK_9

_adonthell.SDLK_COLON_swigconstant(_adonthell)
SDLK_COLON = _adonthell.SDLK_COLON

_adonthell.SDLK_SEMICOLON_swigconstant(_adonthell)
SDLK_SEMICOLON = _adonthell.SDLK_SEMICOLON

_adonthell.SDLK_LESS_swigconstant(_adonthell)
SDLK_LESS = _adonthell.SDLK_LESS

_adonthell.SDLK_EQUALS_swigconstant(_adonthell)
SDLK_EQUALS = _adonthell.SDLK_EQUALS

_adonthell.SDLK_GREATER_swigconstant(_adonthell)
SDLK_GREATER = _adonthell.SDLK_GREATER

_adonthell.SDLK_QUESTION_swigconstant(_adonthell)
SDLK_QUESTION = _adonthell.SDLK_QUESTION

_adonthell.SDLK_AT_swigconstant(_adonthell)
SDLK_AT = _adonthell.SDLK_AT

_adonthell.SDLK_LEFTBRACKET_swigconstant(_adonthell)
SDLK_LEFTBRACKET = _adonthell.SDLK_LEFTBRACKET

_adonthell.SDLK_BACKSLASH_swigconstant(_adonthell)
SDLK_BACKSLASH = _adonthell.SDLK_BACKSLASH

_adonthell.SDLK_RIGHTBRACKET_swigconstant(_adonthell)
SDLK_RIGHTBRACKET = _adonthell.SDLK_RIGHTBRACKET

_adonthell.SDLK_CARET_swigconstant(_adonthell)
SDLK_CARET = _adonthell.SDLK_CARET

_adonthell.SDLK_UNDERSCORE_swigconstant(_adonthell)
SDLK_UNDERSCORE = _adonthell.SDLK_UNDERSCORE

_adonthell.SDLK_BACKQUOTE_swigconstant(_adonthell)
SDLK_BACKQUOTE = _adonthell.SDLK_BACKQUOTE

_adonthell.SDLK_a_swigconstant(_adonthell)
SDLK_a = _adonthell.SDLK_a

_adonthell.SDLK_b_swigconstant(_adonthell)
SDLK_b = _adonthell.SDLK_b

_adonthell.SDLK_c_swigconstant(_adonthell)
SDLK_c = _adonthell.SDLK_c

_adonthell.SDLK_d_swigconstant(_adonthell)
SDLK_d = _adonthell.SDLK_d

_adonthell.SDLK_e_swigconstant(_adonthell)
SDLK_e = _adonthell.SDLK_e

_adonthell.SDLK_f_swigconstant(_adonthell)
SDLK_f = _adonthell.SDLK_f

_adonthell.SDLK_g_swigconstant(_adonthell)
SDLK_g = _adonthell.SDLK_g

_adonthell.SDLK_h_swigconstant(_adonthell)
SDLK_h = _adonthell.SDLK_h

_adonthell.SDLK_i_swigconstant(_adonthell)
SDLK_i = _adonthell.SDLK_i

_adonthell.SDLK_j_swigconstant(_adonthell)
SDLK_j = _adonthell.SDLK_j

_adonthell.SDLK_k_swigconstant(_adonthell)
SDLK_k = _adonthell.SDLK_k

_adonthell.SDLK_l_swigconstant(_adonthell)
SDLK_l = _adonthell.SDLK_l

_adonthell.SDLK_m_swigconstant(_adonthell)
SDLK_m = _adonthell.SDLK_m

_adonthell.SDLK_n_swigconstant(_adonthell)
SDLK_n = _adonthell.SDLK_n

_adonthell.SDLK_o_swigconstant(_adonthell)
SDLK_o = _adonthell.SDLK_o

_adonthell.SDLK_p_swigconstant(_adonthell)
SDLK_p = _adonthell.SDLK_p

_adonthell.SDLK_q_swigconstant(_adonthell)
SDLK_q = _adonthell.SDLK_q

_adonthell.SDLK_r_swigconstant(_adonthell)
SDLK_r = _adonthell.SDLK_r

_adonthell.SDLK_s_swigconstant(_adonthell)
SDLK_s = _adonthell.SDLK_s

_adonthell.SDLK_t_swigconstant(_adonthell)
SDLK_t = _adonthell.SDLK_t

_adonthell.SDLK_u_swigconstant(_adonthell)
SDLK_u = _adonthell.SDLK_u

_adonthell.SDLK_v_swigconstant(_adonthell)
SDLK_v = _adonthell.SDLK_v

_adonthell.SDLK_w_swigconstant(_adonthell)
SDLK_w = _adonthell.SDLK_w

_adonthell.SDLK_x_swigconstant(_adonthell)
SDLK_x = _adonthell.SDLK_x

_adonthell.SDLK_y_swigconstant(_adonthell)
SDLK_y = _adonthell.SDLK_y

_adonthell.SDLK_z_swigconstant(_adonthell)
SDLK_z = _adonthell.SDLK_z

_adonthell.SDLK_CAPSLOCK_swigconstant(_adonthell)
SDLK_CAPSLOCK = _adonthell.SDLK_CAPSLOCK

_adonthell.SDLK_F1_swigconstant(_adonthell)
SDLK_F1 = _adonthell.SDLK_F1

_adonthell.SDLK_F2_swigconstant(_adonthell)
SDLK_F2 = _adonthell.SDLK_F2

_adonthell.SDLK_F3_swigconstant(_adonthell)
SDLK_F3 = _adonthell.SDLK_F3

_adonthell.SDLK_F4_swigconstant(_adonthell)
SDLK_F4 = _adonthell.SDLK_F4

_adonthell.SDLK_F5_swigconstant(_adonthell)
SDLK_F5 = _adonthell.SDLK_F5

_adonthell.SDLK_F6_swigconstant(_adonthell)
SDLK_F6 = _adonthell.SDLK_F6

_adonthell.SDLK_F7_swigconstant(_adonthell)
SDLK_F7 = _adonthell.SDLK_F7

_adonthell.SDLK_F8_swigconstant(_adonthell)
SDLK_F8 = _adonthell.SDLK_F8

_adonthell.SDLK_F9_swigconstant(_adonthell)
SDLK_F9 = _adonthell.SDLK_F9

_adonthell.SDLK_F10_swigconstant(_adonthell)
SDLK_F10 = _adonthell.SDLK_F10

_adonthell.SDLK_F11_swigconstant(_adonthell)
SDLK_F11 = _adonthell.SDLK_F11

_adonthell.SDLK_F12_swigconstant(_adonthell)
SDLK_F12 = _adonthell.SDLK_F12

_adonthell.SDLK_PRINTSCREEN_swigconstant(_adonthell)
SDLK_PRINTSCREEN = _adonthell.SDLK_PRINTSCREEN

_adonthell.SDLK_SCROLLLOCK_swigconstant(_adonthell)
SDLK_SCROLLLOCK = _adonthell.SDLK_SCROLLLOCK

_adonthell.SDLK_PAUSE_swigconstant(_adonthell)
SDLK_PAUSE = _adonthell.SDLK_PAUSE

_adonthell.SDLK_INSERT_swigconstant(_adonthell)
SDLK_INSERT = _adonthell.SDLK_INSERT

_adonthell.SDLK_HOME_swigconstant(_adonthell)
SDLK_HOME = _adonthell.SDLK_HOME

_adonthell.SDLK_PAGEUP_swigconstant(_adonthell)
SDLK_PAGEUP = _adonthell.SDLK_PAGEUP

_adonthell.SDLK_DELETE_swigconstant(_adonthell)
SDLK_DELETE = _adonthell.SDLK_DELETE

_adonthell.SDLK_END_swigconstant(_adonthell)
SDLK_END = _adonthell.SDLK_END

_adonthell.SDLK_PAGEDOWN_swigconstant(_adonthell)
SDLK_PAGEDOWN = _adonthell.SDLK_PAGEDOWN

_adonthell.SDLK_RIGHT_swigconstant(_adonthell)
SDLK_RIGHT = _adonthell.SDLK_RIGHT

_adonthell.SDLK_LEFT_swigconstant(_adonthell)
SDLK_LEFT = _adonthell.SDLK_LEFT

_adonthell.SDLK_DOWN_swigconstant(_adonthell)
SDLK_DOWN = _adonthell.SDLK_DOWN

_adonthell.SDLK_UP_swigconstant(_adonthell)
SDLK_UP = _adonthell.SDLK_UP

_adonthell.SDLK_NUMLOCKCLEAR_swigconstant(_adonthell)
SDLK_NUMLOCKCLEAR = _adonthell.SDLK_NUMLOCKCLEAR

_adonthell.SDLK_KP_DIVIDE_swigconstant(_adonthell)
SDLK_KP_DIVIDE = _adonthell.SDLK_KP_DIVIDE

_adonthell.SDLK_KP_MULTIPLY_swigconstant(_adonthell)
SDLK_KP_MULTIPLY = _adonthell.SDLK_KP_MULTIPLY

_adonthell.SDLK_KP_MINUS_swigconstant(_adonthell)
SDLK_KP_MINUS = _adonthell.SDLK_KP_MINUS

_adonthell.SDLK_KP_PLUS_swigconstant(_adonthell)
SDLK_KP_PLUS = _adonthell.SDLK_KP_PLUS

_adonthell.SDLK_KP_ENTER_swigconstant(_adonthell)
SDLK_KP_ENTER = _adonthell.SDLK_KP_ENTER

_adonthell.SDLK_KP_1_swigconstant(_adonthell)
SDLK_KP_1 = _adonthell.SDLK_KP_1

_adonthell.SDLK_KP_2_swigconstant(_adonthell)
SDLK_KP_2 = _adonthell.SDLK_KP_2

_adonthell.SDLK_KP_3_swigconstant(_adonthell)
SDLK_KP_3 = _adonthell.SDLK_KP_3

_adonthell.SDLK_KP_4_swigconstant(_adonthell)
SDLK_KP_4 = _adonthell.SDLK_KP_4

_adonthell.SDLK_KP_5_swigconstant(_adonthell)
SDLK_KP_5 = _adonthell.SDLK_KP_5

_adonthell.SDLK_KP_6_swigconstant(_adonthell)
SDLK_KP_6 = _adonthell.SDLK_KP_6

_adonthell.SDLK_KP_7_swigconstant(_adonthell)
SDLK_KP_7 = _adonthell.SDLK_KP_7

_adonthell.SDLK_KP_8_swigconstant(_adonthell)
SDLK_KP_8 = _adonthell.SDLK_KP_8

_adonthell.SDLK_KP_9_swigconstant(_adonthell)
SDLK_KP_9 = _adonthell.SDLK_KP_9

_adonthell.SDLK_KP_0_swigconstant(_adonthell)
SDLK_KP_0 = _adonthell.SDLK_KP_0

_adonthell.SDLK_KP_PERIOD_swigconstant(_adonthell)
SDLK_KP_PERIOD = _adonthell.SDLK_KP_PERIOD

_adonthell.SDLK_APPLICATION_swigconstant(_adonthell)
SDLK_APPLICATION = _adonthell.SDLK_APPLICATION

_adonthell.SDLK_POWER_swigconstant(_adonthell)
SDLK_POWER = _adonthell.SDLK_POWER

_adonthell.SDLK_KP_EQUALS_swigconstant(_adonthell)
SDLK_KP_EQUALS = _adonthell.SDLK_KP_EQUALS

_adonthell.SDLK_F13_swigconstant(_adonthell)
SDLK_F13 = _adonthell.SDLK_F13

_adonthell.SDLK_F14_swigconstant(_adonthell)
SDLK_F14 = _adonthell.SDLK_F14

_adonthell.SDLK_F15_swigconstant(_adonthell)
SDLK_F15 = _adonthell.SDLK_F15

_adonthell.SDLK_F16_swigconstant(_adonthell)
SDLK_F16 = _adonthell.SDLK_F16

_adonthell.SDLK_F17_swigconstant(_adonthell)
SDLK_F17 = _adonthell.SDLK_F17

_adonthell.SDLK_F18_swigconstant(_adonthell)
SDLK_F18 = _adonthell.SDLK_F18

_adonthell.SDLK_F19_swigconstant(_adonthell)
SDLK_F19 = _adonthell.SDLK_F19

_adonthell.SDLK_F20_swigconstant(_adonthell)
SDLK_F20 = _adonthell.SDLK_F20

_adonthell.SDLK_F21_swigconstant(_adonthell)
SDLK_F21 = _adonthell.SDLK_F21

_adonthell.SDLK_F22_swigconstant(_adonthell)
SDLK_F22 = _adonthell.SDLK_F22

_adonthell.SDLK_F23_swigconstant(_adonthell)
SDLK_F23 = _adonthell.SDLK_F23

_adonthell.SDLK_F24_swigconstant(_adonthell)
SDLK_F24 = _adonthell.SDLK_F24

_adonthell.SDLK_EXECUTE_swigconstant(_adonthell)
SDLK_EXECUTE = _adonthell.SDLK_EXECUTE

_adonthell.SDLK_HELP_swigconstant(_adonthell)
SDLK_HELP = _adonthell.SDLK_HELP

_adonthell.SDLK_MENU_swigconstant(_adonthell)
SDLK_MENU = _adonthell.SDLK_MENU

_adonthell.SDLK_SELECT_swigconstant(_adonthell)
SDLK_SELECT = _adonthell.SDLK_SELECT

_adonthell.SDLK_STOP_swigconstant(_adonthell)
SDLK_STOP = _adonthell.SDLK_STOP

_adonthell.SDLK_AGAIN_swigconstant(_adonthell)
SDLK_AGAIN = _adonthell.SDLK_AGAIN

_adonthell.SDLK_UNDO_swigconstant(_adonthell)
SDLK_UNDO = _adonthell.SDLK_UNDO

_adonthell.SDLK_CUT_swigconstant(_adonthell)
SDLK_CUT = _adonthell.SDLK_CUT

_adonthell.SDLK_COPY_swigconstant(_adonthell)
SDLK_COPY = _adonthell.SDLK_COPY

_adonthell.SDLK_PASTE_swigconstant(_adonthell)
SDLK_PASTE = _adonthell.SDLK_PASTE

_adonthell.SDLK_FIND_swigconstant(_adonthell)
SDLK_FIND = _adonthell.SDLK_FIND

_adonthell.SDLK_MUTE_swigconstant(_adonthell)
SDLK_MUTE = _adonthell.SDLK_MUTE

_adonthell.SDLK_VOLUMEUP_swigconstant(_adonthell)
SDLK_VOLUMEUP = _adonthell.SDLK_VOLUMEUP

_adonthell.SDLK_VOLUMEDOWN_swigconstant(_adonthell)
SDLK_VOLUMEDOWN = _adonthell.SDLK_VOLUMEDOWN

_adonthell.SDLK_KP_COMMA_swigconstant(_adonthell)
SDLK_KP_COMMA = _adonthell.SDLK_KP_COMMA

_adonthell.SDLK_KP_EQUALSAS400_swigconstant(_adonthell)
SDLK_KP_EQUALSAS400 = _adonthell.SDLK_KP_EQUALSAS400

_adonthell.SDLK_ALTERASE_swigconstant(_adonthell)
SDLK_ALTERASE = _adonthell.SDLK_ALTERASE

_adonthell.SDLK_SYSREQ_swigconstant(_adonthell)
SDLK_SYSREQ = _adonthell.SDLK_SYSREQ

_adonthell.SDLK_CANCEL_swigconstant(_adonthell)
SDLK_CANCEL = _adonthell.SDLK_CANCEL

_adonthell.SDLK_CLEAR_swigconstant(_adonthell)
SDLK_CLEAR = _adonthell.SDLK_CLEAR

_adonthell.SDLK_PRIOR_swigconstant(_adonthell)
SDLK_PRIOR = _adonthell.SDLK_PRIOR

_adonthell.SDLK_RETURN2_swigconstant(_adonthell)
SDLK_RETURN2 = _adonthell.SDLK_RETURN2

_adonthell.SDLK_SEPARATOR_swigconstant(_adonthell)
SDLK_SEPARATOR = _adonthell.SDLK_SEPARATOR

_adonthell.SDLK_OUT_swigconstant(_adonthell)
SDLK_OUT = _adonthell.SDLK_OUT

_adonthell.SDLK_OPER_swigconstant(_adonthell)
SDLK_OPER = _adonthell.SDLK_OPER

_adonthell.SDLK_CLEARAGAIN_swigconstant(_adonthell)
SDLK_CLEARAGAIN = _adonthell.SDLK_CLEARAGAIN

_adonthell.SDLK_CRSEL_swigconstant(_adonthell)
SDLK_CRSEL = _adonthell.SDLK_CRSEL

_adonthell.SDLK_EXSEL_swigconstant(_adonthell)
SDLK_EXSEL = _adonthell.SDLK_EXSEL

_adonthell.SDLK_KP_00_swigconstant(_adonthell)
SDLK_KP_00 = _adonthell.SDLK_KP_00

_adonthell.SDLK_KP_000_swigconstant(_adonthell)
SDLK_KP_000 = _adonthell.SDLK_KP_000

_adonthell.SDLK_THOUSANDSSEPARATOR_swigconstant(_adonthell)
SDLK_THOUSANDSSEPARATOR = _adonthell.SDLK_THOUSANDSSEPARATOR

_adonthell.SDLK_DECIMALSEPARATOR_swigconstant(_adonthell)
SDLK_DECIMALSEPARATOR = _adonthell.SDLK_DECIMALSEPARATOR

_adonthell.SDLK_CURRENCYUNIT_swigconstant(_adonthell)
SDLK_CURRENCYUNIT = _adonthell.SDLK_CURRENCYUNIT

_adonthell.SDLK_CURRENCYSUBUNIT_swigconstant(_adonthell)
SDLK_CURRENCYSUBUNIT = _adonthell.SDLK_CURRENCYSUBUNIT

_adonthell.SDLK_KP_LEFTPAREN_swigconstant(_adonthell)
SDLK_KP_LEFTPAREN = _adonthell.SDLK_KP_LEFTPAREN

_adonthell.SDLK_KP_RIGHTPAREN_swigconstant(_adonthell)
SDLK_KP_RIGHTPAREN = _adonthell.SDLK_KP_RIGHTPAREN

_adonthell.SDLK_KP_LEFTBRACE_swigconstant(_adonthell)
SDLK_KP_LEFTBRACE = _adonthell.SDLK_KP_LEFTBRACE

_adonthell.SDLK_KP_RIGHTBRACE_swigconstant(_adonthell)
SDLK_KP_RIGHTBRACE = _adonthell.SDLK_KP_RIGHTBRACE

_adonthell.SDLK_KP_TAB_swigconstant(_adonthell)
SDLK_KP_TAB = _adonthell.SDLK_KP_TAB

_adonthell.SDLK_KP_BACKSPACE_swigconstant(_adonthell)
SDLK_KP_BACKSPACE = _adonthell.SDLK_KP_BACKSPACE

_adonthell.SDLK_KP_A_swigconstant(_adonthell)
SDLK_KP_A = _adonthell.SDLK_KP_A

_adonthell.SDLK_KP_B_swigconstant(_adonthell)
SDLK_KP_B = _adonthell.SDLK_KP_B

_adonthell.SDLK_KP_C_swigconstant(_adonthell)
SDLK_KP_C = _adonthell.SDLK_KP_C

_adonthell.SDLK_KP_D_swigconstant(_adonthell)
SDLK_KP_D = _adonthell.SDLK_KP_D

_adonthell.SDLK_KP_E_swigconstant(_adonthell)
SDLK_KP_E = _adonthell.SDLK_KP_E

_adonthell.SDLK_KP_F_swigconstant(_adonthell)
SDLK_KP_F = _adonthell.SDLK_KP_F

_adonthell.SDLK_KP_XOR_swigconstant(_adonthell)
SDLK_KP_XOR = _adonthell.SDLK_KP_XOR

_adonthell.SDLK_KP_POWER_swigconstant(_adonthell)
SDLK_KP_POWER = _adonthell.SDLK_KP_POWER

_adonthell.SDLK_KP_PERCENT_swigconstant(_adonthell)
SDLK_KP_PERCENT = _adonthell.SDLK_KP_PERCENT

_adonthell.SDLK_KP_LESS_swigconstant(_adonthell)
SDLK_KP_LESS = _adonthell.SDLK_KP_LESS

_adonthell.SDLK_KP_GREATER_swigconstant(_adonthell)
SDLK_KP_GREATER = _adonthell.SDLK_KP_GREATER

_adonthell.SDLK_KP_AMPERSAND_swigconstant(_adonthell)
SDLK_KP_AMPERSAND = _adonthell.SDLK_KP_AMPERSAND

_adonthell.SDLK_KP_DBLAMPERSAND_swigconstant(_adonthell)
SDLK_KP_DBLAMPERSAND = _adonthell.SDLK_KP_DBLAMPERSAND

_adonthell.SDLK_KP_VERTICALBAR_swigconstant(_adonthell)
SDLK_KP_VERTICALBAR = _adonthell.SDLK_KP_VERTICALBAR

_adonthell.SDLK_KP_DBLVERTICALBAR_swigconstant(_adonthell)
SDLK_KP_DBLVERTICALBAR = _adonthell.SDLK_KP_DBLVERTICALBAR

_adonthell.SDLK_KP_COLON_swigconstant(_adonthell)
SDLK_KP_COLON = _adonthell.SDLK_KP_COLON

_adonthell.SDLK_KP_HASH_swigconstant(_adonthell)
SDLK_KP_HASH = _adonthell.SDLK_KP_HASH

_adonthell.SDLK_KP_SPACE_swigconstant(_adonthell)
SDLK_KP_SPACE = _adonthell.SDLK_KP_SPACE

_adonthell.SDLK_KP_AT_swigconstant(_adonthell)
SDLK_KP_AT = _adonthell.SDLK_KP_AT

_adonthell.SDLK_KP_EXCLAM_swigconstant(_adonthell)
SDLK_KP_EXCLAM = _adonthell.SDLK_KP_EXCLAM

_adonthell.SDLK_KP_MEMSTORE_swigconstant(_adonthell)
SDLK_KP_MEMSTORE = _adonthell.SDLK_KP_MEMSTORE

_adonthell.SDLK_KP_MEMRECALL_swigconstant(_adonthell)
SDLK_KP_MEMRECALL = _adonthell.SDLK_KP_MEMRECALL

_adonthell.SDLK_KP_MEMCLEAR_swigconstant(_adonthell)
SDLK_KP_MEMCLEAR = _adonthell.SDLK_KP_MEMCLEAR

_adonthell.SDLK_KP_MEMADD_swigconstant(_adonthell)
SDLK_KP_MEMADD = _adonthell.SDLK_KP_MEMADD

_adonthell.SDLK_KP_MEMSUBTRACT_swigconstant(_adonthell)
SDLK_KP_MEMSUBTRACT = _adonthell.SDLK_KP_MEMSUBTRACT

_adonthell.SDLK_KP_MEMMULTIPLY_swigconstant(_adonthell)
SDLK_KP_MEMMULTIPLY = _adonthell.SDLK_KP_MEMMULTIPLY

_adonthell.SDLK_KP_MEMDIVIDE_swigconstant(_adonthell)
SDLK_KP_MEMDIVIDE = _adonthell.SDLK_KP_MEMDIVIDE

_adonthell.SDLK_KP_PLUSMINUS_swigconstant(_adonthell)
SDLK_KP_PLUSMINUS = _adonthell.SDLK_KP_PLUSMINUS

_adonthell.SDLK_KP_CLEAR_swigconstant(_adonthell)
SDLK_KP_CLEAR = _adonthell.SDLK_KP_CLEAR

_adonthell.SDLK_KP_CLEARENTRY_swigconstant(_adonthell)
SDLK_KP_CLEARENTRY = _adonthell.SDLK_KP_CLEARENTRY

_adonthell.SDLK_KP_BINARY_swigconstant(_adonthell)
SDLK_KP_BINARY = _adonthell.SDLK_KP_BINARY

_adonthell.SDLK_KP_OCTAL_swigconstant(_adonthell)
SDLK_KP_OCTAL = _adonthell.SDLK_KP_OCTAL

_adonthell.SDLK_KP_DECIMAL_swigconstant(_adonthell)
SDLK_KP_DECIMAL = _adonthell.SDLK_KP_DECIMAL

_adonthell.SDLK_KP_HEXADECIMAL_swigconstant(_adonthell)
SDLK_KP_HEXADECIMAL = _adonthell.SDLK_KP_HEXADECIMAL

_adonthell.SDLK_LCTRL_swigconstant(_adonthell)
SDLK_LCTRL = _adonthell.SDLK_LCTRL

_adonthell.SDLK_LSHIFT_swigconstant(_adonthell)
SDLK_LSHIFT = _adonthell.SDLK_LSHIFT

_adonthell.SDLK_LALT_swigconstant(_adonthell)
SDLK_LALT = _adonthell.SDLK_LALT

_adonthell.SDLK_LGUI_swigconstant(_adonthell)
SDLK_LGUI = _adonthell.SDLK_LGUI

_adonthell.SDLK_RCTRL_swigconstant(_adonthell)
SDLK_RCTRL = _adonthell.SDLK_RCTRL

_adonthell.SDLK_RSHIFT_swigconstant(_adonthell)
SDLK_RSHIFT = _adonthell.SDLK_RSHIFT

_adonthell.SDLK_RALT_swigconstant(_adonthell)
SDLK_RALT = _adonthell.SDLK_RALT

_adonthell.SDLK_RGUI_swigconstant(_adonthell)
SDLK_RGUI = _adonthell.SDLK_RGUI

_adonthell.SDLK_MODE_swigconstant(_adonthell)
SDLK_MODE = _adonthell.SDLK_MODE

_adonthell.SDLK_AUDIONEXT_swigconstant(_adonthell)
SDLK_AUDIONEXT = _adonthell.SDLK_AUDIONEXT

_adonthell.SDLK_AUDIOPREV_swigconstant(_adonthell)
SDLK_AUDIOPREV = _adonthell.SDLK_AUDIOPREV

_adonthell.SDLK_AUDIOSTOP_swigconstant(_adonthell)
SDLK_AUDIOSTOP = _adonthell.SDLK_AUDIOSTOP

_adonthell.SDLK_AUDIOPLAY_swigconstant(_adonthell)
SDLK_AUDIOPLAY = _adonthell.SDLK_AUDIOPLAY

_adonthell.SDLK_AUDIOMUTE_swigconstant(_adonthell)
SDLK_AUDIOMUTE = _adonthell.SDLK_AUDIOMUTE

_adonthell.SDLK_MEDIASELECT_swigconstant(_adonthell)
SDLK_MEDIASELECT = _adonthell.SDLK_MEDIASELECT

_adonthell.SDLK_WWW_swigconstant(_adonthell)
SDLK_WWW = _adonthell.SDLK_WWW

_adonthell.SDLK_MAIL_swigconstant(_adonthell)
SDLK_MAIL = _adonthell.SDLK_MAIL

_adonthell.SDLK_CALCULATOR_swigconstant(_adonthell)
SDLK_CALCULATOR = _adonthell.SDLK_CALCULATOR

_adonthell.SDLK_COMPUTER_swigconstant(_adonthell)
SDLK_COMPUTER = _adonthell.SDLK_COMPUTER

_adonthell.SDLK_AC_SEARCH_swigconstant(_adonthell)
SDLK_AC_SEARCH = _adonthell.SDLK_AC_SEARCH

_adonthell.SDLK_AC_HOME_swigconstant(_adonthell)
SDLK_AC_HOME = _adonthell.SDLK_AC_HOME

_adonthell.SDLK_AC_BACK_swigconstant(_adonthell)
SDLK_AC_BACK = _adonthell.SDLK_AC_BACK

_adonthell.SDLK_AC_FORWARD_swigconstant(_adonthell)
SDLK_AC_FORWARD = _adonthell.SDLK_AC_FORWARD

_adonthell.SDLK_AC_STOP_swigconstant(_adonthell)
SDLK_AC_STOP = _adonthell.SDLK_AC_STOP

_adonthell.SDLK_AC_REFRESH_swigconstant(_adonthell)
SDLK_AC_REFRESH = _adonthell.SDLK_AC_REFRESH

_adonthell.SDLK_AC_BOOKMARKS_swigconstant(_adonthell)
SDLK_AC_BOOKMARKS = _adonthell.SDLK_AC_BOOKMARKS

_adonthell.SDLK_BRIGHTNESSDOWN_swigconstant(_adonthell)
SDLK_BRIGHTNESSDOWN = _adonthell.SDLK_BRIGHTNESSDOWN

_adonthell.SDLK_BRIGHTNESSUP_swigconstant(_adonthell)
SDLK_BRIGHTNESSUP = _adonthell.SDLK_BRIGHTNESSUP

_adonthell.SDLK_DISPLAYSWITCH_swigconstant(_adonthell)
SDLK_DISPLAYSWITCH = _adonthell.SDLK_DISPLAYSWITCH

_adonthell.SDLK_KBDILLUMTOGGLE_swigconstant(_adonthell)
SDLK_KBDILLUMTOGGLE = _adonthell.SDLK_KBDILLUMTOGGLE

_adonthell.SDLK_KBDILLUMDOWN_swigconstant(_adonthell)
SDLK_KBDILLUMDOWN = _adonthell.SDLK_KBDILLUMDOWN

_adonthell.SDLK_KBDILLUMUP_swigconstant(_adonthell)
SDLK_KBDILLUMUP = _adonthell.SDLK_KBDILLUMUP

_adonthell.SDLK_EJECT_swigconstant(_adonthell)
SDLK_EJECT = _adonthell.SDLK_EJECT

_adonthell.SDLK_SLEEP_swigconstant(_adonthell)
SDLK_SLEEP = _adonthell.SDLK_SLEEP

_adonthell.SDLK_APP1_swigconstant(_adonthell)
SDLK_APP1 = _adonthell.SDLK_APP1

_adonthell.SDLK_APP2_swigconstant(_adonthell)
SDLK_APP2 = _adonthell.SDLK_APP2

_adonthell.SDLK_AUDIOREWIND_swigconstant(_adonthell)
SDLK_AUDIOREWIND = _adonthell.SDLK_AUDIOREWIND

_adonthell.SDLK_AUDIOFASTFORWARD_swigconstant(_adonthell)
SDLK_AUDIOFASTFORWARD = _adonthell.SDLK_AUDIOFASTFORWARD

_adonthell.KMOD_NONE_swigconstant(_adonthell)
KMOD_NONE = _adonthell.KMOD_NONE

_adonthell.KMOD_LSHIFT_swigconstant(_adonthell)
KMOD_LSHIFT = _adonthell.KMOD_LSHIFT

_adonthell.KMOD_RSHIFT_swigconstant(_adonthell)
KMOD_RSHIFT = _adonthell.KMOD_RSHIFT

_adonthell.KMOD_LCTRL_swigconstant(_adonthell)
KMOD_LCTRL = _adonthell.KMOD_LCTRL

_adonthell.KMOD_RCTRL_swigconstant(_adonthell)
KMOD_RCTRL = _adonthell.KMOD_RCTRL

_adonthell.KMOD_LALT_swigconstant(_adonthell)
KMOD_LALT = _adonthell.KMOD_LALT

_adonthell.KMOD_RALT_swigconstant(_adonthell)
KMOD_RALT = _adonthell.KMOD_RALT

_adonthell.KMOD_LGUI_swigconstant(_adonthell)
KMOD_LGUI = _adonthell.KMOD_LGUI

_adonthell.KMOD_RGUI_swigconstant(_adonthell)
KMOD_RGUI = _adonthell.KMOD_RGUI

_adonthell.KMOD_NUM_swigconstant(_adonthell)
KMOD_NUM = _adonthell.KMOD_NUM

_adonthell.KMOD_CAPS_swigconstant(_adonthell)
KMOD_CAPS = _adonthell.KMOD_CAPS

_adonthell.KMOD_MODE_swigconstant(_adonthell)
KMOD_MODE = _adonthell.KMOD_MODE

_adonthell.KMOD_RESERVED_swigconstant(_adonthell)
KMOD_RESERVED = _adonthell.KMOD_RESERVED
class input(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    init = staticmethod(_adonthell.input_init)
    shutdown = staticmethod(_adonthell.input_shutdown)
    update = staticmethod(_adonthell.input_update)
    is_pushed = staticmethod(_adonthell.input_is_pushed)
    has_been_pushed = staticmethod(_adonthell.input_has_been_pushed)
    get_next_key = staticmethod(_adonthell.input_get_next_key)
    get_next_unicode = staticmethod(_adonthell.input_get_next_unicode)
    start_text_input = staticmethod(_adonthell.input_start_text_input)
    stop_text_input = staticmethod(_adonthell.input_stop_text_input)
    is_text_input = staticmethod(_adonthell.input_is_text_input)
    clear_keys_queue = staticmethod(_adonthell.input_clear_keys_queue)

    def __init__(self, *args):
        this = _adonthell.new_input(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_input
    __del__ = lambda self: None
input_swigregister = _adonthell.input_swigregister
input_swigregister(input)

def input_init(*args):
    return _adonthell.input_init(*args)
input_init = _adonthell.input_init

def input_shutdown(*args):
    return _adonthell.input_shutdown(*args)
input_shutdown = _adonthell.input_shutdown

def input_update(*args):
    return _adonthell.input_update(*args)
input_update = _adonthell.input_update

def input_is_pushed(*args):
    return _adonthell.input_is_pushed(*args)
input_is_pushed = _adonthell.input_is_pushed

def input_has_been_pushed(*args):
    return _adonthell.input_has_been_pushed(*args)
input_has_been_pushed = _adonthell.input_has_been_pushed

def input_get_next_key(*args):
    return _adonthell.input_get_next_key(*args)
input_get_next_key = _adonthell.input_get_next_key

def input_get_next_unicode(*args):
    return _adonthell.input_get_next_unicode(*args)
input_get_next_unicode = _adonthell.input_get_next_unicode

def input_start_text_input(*args):
    return _adonthell.input_start_text_input(*args)
input_start_text_input = _adonthell.input_start_text_input

def input_stop_text_input(*args):
    return _adonthell.input_stop_text_input(*args)
input_stop_text_input = _adonthell.input_stop_text_input

def input_is_text_input(*args):
    return _adonthell.input_is_text_input(*args)
input_is_text_input = _adonthell.input_is_text_input

def input_clear_keys_queue(*args):
    return _adonthell.input_clear_keys_queue(*args)
input_clear_keys_queue = _adonthell.input_clear_keys_queue


_adonthell.NUM_WAVES_swigconstant(_adonthell)
NUM_WAVES = _adonthell.NUM_WAVES

_adonthell.NUM_MUSIC_swigconstant(_adonthell)
NUM_MUSIC = _adonthell.NUM_MUSIC

_adonthell.NUM_CHANNELS_swigconstant(_adonthell)
NUM_CHANNELS = _adonthell.NUM_CHANNELS
class audio(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    init = staticmethod(_adonthell.audio_init)
    cleanup = staticmethod(_adonthell.audio_cleanup)
    put_state = staticmethod(_adonthell.audio_put_state)
    get_state = staticmethod(_adonthell.audio_get_state)
    load_background = staticmethod(_adonthell.audio_load_background)
    unload_background = staticmethod(_adonthell.audio_unload_background)
    set_background_volume = staticmethod(_adonthell.audio_set_background_volume)
    pause_music = staticmethod(_adonthell.audio_pause_music)
    unpause_music = staticmethod(_adonthell.audio_unpause_music)
    load_wave = staticmethod(_adonthell.audio_load_wave)
    unload_wave = staticmethod(_adonthell.audio_unload_wave)
    play_wave = staticmethod(_adonthell.audio_play_wave)
    play_background = staticmethod(_adonthell.audio_play_background)
    fade_in_background = staticmethod(_adonthell.audio_fade_in_background)
    fade_out_background = staticmethod(_adonthell.audio_fade_out_background)
    change_background = staticmethod(_adonthell.audio_change_background)
    is_initialized = staticmethod(_adonthell.audio_is_initialized)
    is_schedule_activated = staticmethod(_adonthell.audio_is_schedule_activated)
    is_background_finished = staticmethod(_adonthell.audio_is_background_finished)
    set_schedule_active = staticmethod(_adonthell.audio_set_schedule_active)
    set_schedule = staticmethod(_adonthell.audio_set_schedule)
    run_schedule = staticmethod(_adonthell.audio_run_schedule)

    def __init__(self, *args):
        this = _adonthell.new_audio(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_audio
    __del__ = lambda self: None
audio_swigregister = _adonthell.audio_swigregister
audio_swigregister(audio)

def audio_init(*args):
    return _adonthell.audio_init(*args)
audio_init = _adonthell.audio_init

def audio_cleanup(*args):
    return _adonthell.audio_cleanup(*args)
audio_cleanup = _adonthell.audio_cleanup

def audio_put_state(*args):
    return _adonthell.audio_put_state(*args)
audio_put_state = _adonthell.audio_put_state

def audio_get_state(*args):
    return _adonthell.audio_get_state(*args)
audio_get_state = _adonthell.audio_get_state

def audio_load_background(*args):
    return _adonthell.audio_load_background(*args)
audio_load_background = _adonthell.audio_load_background

def audio_unload_background(*args):
    return _adonthell.audio_unload_background(*args)
audio_unload_background = _adonthell.audio_unload_background

def audio_set_background_volume(*args):
    return _adonthell.audio_set_background_volume(*args)
audio_set_background_volume = _adonthell.audio_set_background_volume

def audio_pause_music(*args):
    return _adonthell.audio_pause_music(*args)
audio_pause_music = _adonthell.audio_pause_music

def audio_unpause_music(*args):
    return _adonthell.audio_unpause_music(*args)
audio_unpause_music = _adonthell.audio_unpause_music

def audio_load_wave(*args):
    return _adonthell.audio_load_wave(*args)
audio_load_wave = _adonthell.audio_load_wave

def audio_unload_wave(*args):
    return _adonthell.audio_unload_wave(*args)
audio_unload_wave = _adonthell.audio_unload_wave

def audio_play_wave(*args):
    return _adonthell.audio_play_wave(*args)
audio_play_wave = _adonthell.audio_play_wave

def audio_play_background(*args):
    return _adonthell.audio_play_background(*args)
audio_play_background = _adonthell.audio_play_background

def audio_fade_in_background(*args):
    return _adonthell.audio_fade_in_background(*args)
audio_fade_in_background = _adonthell.audio_fade_in_background

def audio_fade_out_background(*args):
    return _adonthell.audio_fade_out_background(*args)
audio_fade_out_background = _adonthell.audio_fade_out_background

def audio_change_background(*args):
    return _adonthell.audio_change_background(*args)
audio_change_background = _adonthell.audio_change_background

def audio_is_initialized(*args):
    return _adonthell.audio_is_initialized(*args)
audio_is_initialized = _adonthell.audio_is_initialized

def audio_is_schedule_activated(*args):
    return _adonthell.audio_is_schedule_activated(*args)
audio_is_schedule_activated = _adonthell.audio_is_schedule_activated

def audio_is_background_finished(*args):
    return _adonthell.audio_is_background_finished(*args)
audio_is_background_finished = _adonthell.audio_is_background_finished

def audio_set_schedule_active(*args):
    return _adonthell.audio_set_schedule_active(*args)
audio_set_schedule_active = _adonthell.audio_set_schedule_active

def audio_set_schedule(*args):
    return _adonthell.audio_set_schedule(*args)
audio_set_schedule = _adonthell.audio_set_schedule

def audio_run_schedule(*args):
    return _adonthell.audio_run_schedule(*args)
audio_run_schedule = _adonthell.audio_run_schedule


_adonthell.DIALOG_DIR_swigconstant(_adonthell)
DIALOG_DIR = _adonthell.DIALOG_DIR

_adonthell.DWARF_swigconstant(_adonthell)
DWARF = _adonthell.DWARF

_adonthell.ELF_swigconstant(_adonthell)
ELF = _adonthell.ELF

_adonthell.HALFELF_swigconstant(_adonthell)
HALFELF = _adonthell.HALFELF

_adonthell.HUMAN_swigconstant(_adonthell)
HUMAN = _adonthell.HUMAN

_adonthell.FEMALE_swigconstant(_adonthell)
FEMALE = _adonthell.FEMALE

_adonthell.MALE_swigconstant(_adonthell)
MALE = _adonthell.MALE

_adonthell.NPC_swigconstant(_adonthell)
NPC = _adonthell.NPC

_adonthell.PLAYER_swigconstant(_adonthell)
PLAYER = _adonthell.PLAYER

_adonthell.PARTY_swigconstant(_adonthell)
PARTY = _adonthell.PARTY
class character_base(storage):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_character_base(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_character_base
    __del__ = lambda self: None

    def get_name(self, *args):
        return _adonthell.character_base_get_name(self, *args)

    def get_id(self, *args):
        return _adonthell.character_base_get_id(self, *args)

    def set_name(self, *args):
        return _adonthell.character_base_set_name(self, *args)

    def get_color(self, *args):
        return _adonthell.character_base_get_color(self, *args)

    def set_color(self, *args):
        return _adonthell.character_base_set_color(self, *args)

    def get_portrait(self, *args):
        return _adonthell.character_base_get_portrait(self, *args)

    def set_portrait(self, *args):
        return _adonthell.character_base_set_portrait(self, *args)

    def get_dialogue(self, *args):
        return _adonthell.character_base_get_dialogue(self, *args)

    def set_dialogue(self, *args):
        return _adonthell.character_base_set_dialogue(self, *args)

    def get_state(self, *args):
        return _adonthell.character_base_get_state(self, *args)

    def put_state(self, *args):
        return _adonthell.character_base_put_state(self, *args)
character_base_swigregister = _adonthell.character_base_swigregister
character_base_swigregister(character_base)

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

    def __init__(self, *args):
        this = _adonthell.new_py_object(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_py_object
    __del__ = lambda self: None

    def clear(self, *args):
        return _adonthell.py_object_clear(self, *args)

    def create_instance(self, *args):
        return _adonthell.py_object_create_instance(self, *args)

    def reload_instance(self, *args):
        return _adonthell.py_object_reload_instance(self, *args)

    def call_method_ret(self, *args):
        return _adonthell.py_object_call_method_ret(self, *args)

    def call_method(self, *args):
        return _adonthell.py_object_call_method(self, *args)

    def run(self, *args):
        return _adonthell.py_object_run(self, *args)

    def has_attribute(self, *args):
        return _adonthell.py_object_has_attribute(self, *args)

    def get_attribute(self, *args):
        return _adonthell.py_object_get_attribute(self, *args)

    def get_attribute_int(self, *args):
        return _adonthell.py_object_get_attribute_int(self, *args)

    def get_attribute_string(self, *args):
        return _adonthell.py_object_get_attribute_string(self, *args)

    def set_attribute(self, *args):
        return _adonthell.py_object_set_attribute(self, *args)

    def set_attribute_int(self, *args):
        return _adonthell.py_object_set_attribute_int(self, *args)

    def set_attribute_string(self, *args):
        return _adonthell.py_object_set_attribute_string(self, *args)

    def get_instance(self, *args):
        return _adonthell.py_object_get_instance(self, *args)

    def class_name(self, *args):
        return _adonthell.py_object_class_name(self, *args)

    def file_name(self, *args):
        return _adonthell.py_object_file_name(self, *args)
py_object_swigregister = _adonthell.py_object_swigregister
py_object_swigregister(py_object)

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

    def __init__(self, *args):
        this = _adonthell.new_drawing_area(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def x(self, *args):
        return _adonthell.drawing_area_x(self, *args)

    def y(self, *args):
        return _adonthell.drawing_area_y(self, *args)

    def length(self, *args):
        return _adonthell.drawing_area_length(self, *args)

    def height(self, *args):
        return _adonthell.drawing_area_height(self, *args)

    def move(self, *args):
        return _adonthell.drawing_area_move(self, *args)

    def resize(self, *args):
        return _adonthell.drawing_area_resize(self, *args)

    def assign_drawing_area(self, *args):
        return _adonthell.drawing_area_assign_drawing_area(self, *args)

    def assigned_drawing_area(self, *args):
        return _adonthell.drawing_area_assigned_drawing_area(self, *args)

    def detach_drawing_area(self, *args):
        return _adonthell.drawing_area_detach_drawing_area(self, *args)

    def setup_rects(self, *args):
        return _adonthell.drawing_area_setup_rects(self, *args)
    __swig_destroy__ = _adonthell.delete_drawing_area
    __del__ = lambda self: None
drawing_area_swigregister = _adonthell.drawing_area_swigregister
drawing_area_swigregister(drawing_area)

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

    def __init__(self, *args):
        this = _adonthell.new_quest(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_quest
    __del__ = lambda self: None
quest_swigregister = _adonthell.quest_swigregister
quest_swigregister(quest)

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _adonthell.delete_drawable
    __del__ = lambda self: None

    def length(self, *args):
        return _adonthell.drawable_length(self, *args)

    def height(self, *args):
        return _adonthell.drawable_height(self, *args)

    def update(self, *args):
        return _adonthell.drawable_update(self, *args)

    def input_update(self, *args):
        return _adonthell.drawable_input_update(self, *args)

    def draw(self, *args):
        return _adonthell.drawable_draw(self, *args)
drawable_swigregister = _adonthell.drawable_swigregister
drawable_swigregister(drawable)


_adonthell.R_MASK_swigconstant(_adonthell)
R_MASK = _adonthell.R_MASK

_adonthell.G_MASK_swigconstant(_adonthell)
G_MASK = _adonthell.G_MASK

_adonthell.B_MASK_swigconstant(_adonthell)
B_MASK = _adonthell.B_MASK

_adonthell.A_MASK_swigconstant(_adonthell)
A_MASK = _adonthell.A_MASK

_adonthell.BYTES_PER_PIXEL_swigconstant(_adonthell)
BYTES_PER_PIXEL = _adonthell.BYTES_PER_PIXEL
class pixel_info(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_pixel_info(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    Pixels = _swig_property(_adonthell.pixel_info_Pixels_get, _adonthell.pixel_info_Pixels_set)
    Pitch = _swig_property(_adonthell.pixel_info_Pitch_get, _adonthell.pixel_info_Pitch_set)
    Format = _swig_property(_adonthell.pixel_info_Format_get, _adonthell.pixel_info_Format_set)
    BytesPerPixel = _swig_property(_adonthell.pixel_info_BytesPerPixel_get, _adonthell.pixel_info_BytesPerPixel_set)
    __swig_destroy__ = _adonthell.delete_pixel_info
    __del__ = lambda self: None
pixel_info_swigregister = _adonthell.pixel_info_swigregister
pixel_info_swigregister(pixel_info)

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

    def __init__(self, *args):
        this = _adonthell.new_surface(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_surface
    __del__ = lambda self: None

    def is_masked(self, *args):
        return _adonthell.surface_is_masked(self, *args)

    def set_mask(self, *args):
        return _adonthell.surface_set_mask(self, *args)

    def alpha(self, *args):
        return _adonthell.surface_alpha(self, *args)

    def set_alpha(self, *args):
        return _adonthell.surface_set_alpha(self, *args)

    def has_alpha_channel(self, *args):
        return _adonthell.surface_has_alpha_channel(self, *args)

    def scale(self, *args):
        return _adonthell.surface_scale(self, *args)

    def set_scale(self, *args):
        return _adonthell.surface_set_scale(self, *args)

    def draw(self, *args):
        return _adonthell.surface_draw(self, *args)

    def draw_part(self, *args):
        return _adonthell.surface_draw_part(self, *args)

    def fillrect(self, *args):
        return _adonthell.surface_fillrect(self, *args)

    def map_color(self, *args):
        return _adonthell.surface_map_color(self, *args)

    def unmap_color(self, *args):
        return _adonthell.surface_unmap_color(self, *args)

    def lock(self, *args):
        return _adonthell.surface_lock(self, *args)

    def unlock(self, *args):
        return _adonthell.surface_unlock(self, *args)

    def put_pix(self, *args):
        return _adonthell.surface_put_pix(self, *args)

    def put_pix_rgb(self, *args):
        return _adonthell.surface_put_pix_rgb(self, *args)

    def get_pix(self, *args):
        return _adonthell.surface_get_pix(self, *args)

    def get_pix_rgb(self, *args):
        return _adonthell.surface_get_pix_rgb(self, *args)

    def copy(self, *args):
        return _adonthell.surface_copy(self, *args)
surface_swigregister = _adonthell.surface_swigregister
surface_swigregister(surface)

class screen(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    cleanup = staticmethod(_adonthell.screen_cleanup)
    get_renderer = staticmethod(_adonthell.screen_get_renderer)
    format = staticmethod(_adonthell.screen_format)
    display = _swig_property(_adonthell.screen_display_get, _adonthell.screen_display_set)
    init = staticmethod(_adonthell.screen_init)
    length = staticmethod(_adonthell.screen_length)
    height = staticmethod(_adonthell.screen_height)
    bytes_per_pixel = staticmethod(_adonthell.screen_bytes_per_pixel)
    trans_col = staticmethod(_adonthell.screen_trans_col)
    scale = staticmethod(_adonthell.screen_scale)
    offset_x = staticmethod(_adonthell.screen_offset_x)
    offset_y = staticmethod(_adonthell.screen_offset_y)
    clear = staticmethod(_adonthell.screen_clear)
    show = staticmethod(_adonthell.screen_show)
    mode = staticmethod(_adonthell.screen_mode)
    set_fullscreen = staticmethod(_adonthell.screen_set_fullscreen)
    info = staticmethod(_adonthell.screen_info)
    transition = staticmethod(_adonthell.screen_transition)

    def __init__(self, *args):
        this = _adonthell.new_screen(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_screen
    __del__ = lambda self: None
screen_swigregister = _adonthell.screen_swigregister
screen_swigregister(screen)

def screen_cleanup(*args):
    return _adonthell.screen_cleanup(*args)
screen_cleanup = _adonthell.screen_cleanup

def screen_get_renderer(*args):
    return _adonthell.screen_get_renderer(*args)
screen_get_renderer = _adonthell.screen_get_renderer

def screen_format(*args):
    return _adonthell.screen_format(*args)
screen_format = _adonthell.screen_format
cvar = _adonthell.cvar

def screen_init(*args):
    return _adonthell.screen_init(*args)
screen_init = _adonthell.screen_init

def screen_length(*args):
    return _adonthell.screen_length(*args)
screen_length = _adonthell.screen_length

def screen_height(*args):
    return _adonthell.screen_height(*args)
screen_height = _adonthell.screen_height

def screen_bytes_per_pixel(*args):
    return _adonthell.screen_bytes_per_pixel(*args)
screen_bytes_per_pixel = _adonthell.screen_bytes_per_pixel

def screen_trans_col(*args):
    return _adonthell.screen_trans_col(*args)
screen_trans_col = _adonthell.screen_trans_col

def screen_scale(*args):
    return _adonthell.screen_scale(*args)
screen_scale = _adonthell.screen_scale

def screen_offset_x(*args):
    return _adonthell.screen_offset_x(*args)
screen_offset_x = _adonthell.screen_offset_x

def screen_offset_y(*args):
    return _adonthell.screen_offset_y(*args)
screen_offset_y = _adonthell.screen_offset_y

def screen_clear(*args):
    return _adonthell.screen_clear(*args)
screen_clear = _adonthell.screen_clear

def screen_show(*args):
    return _adonthell.screen_show(*args)
screen_show = _adonthell.screen_show

def screen_mode(*args):
    return _adonthell.screen_mode(*args)
screen_mode = _adonthell.screen_mode

def screen_set_fullscreen(*args):
    return _adonthell.screen_set_fullscreen(*args)
screen_set_fullscreen = _adonthell.screen_set_fullscreen

def screen_info(*args):
    return _adonthell.screen_info(*args)
screen_info = _adonthell.screen_info

def screen_transition(*args):
    return _adonthell.screen_transition(*args)
screen_transition = _adonthell.screen_transition

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

    def __init__(self, *args):
        this = _adonthell.new_image(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_image
    __del__ = lambda self: None

    def resize(self, *args):
        return _adonthell.image_resize(self, *args)

    def clear(self, *args):
        return _adonthell.image_clear(self, *args)

    def get(self, *args):
        return _adonthell.image_get(self, *args)

    def load(self, *args):
        return _adonthell.image_load(self, *args)

    def get_raw(self, *args):
        return _adonthell.image_get_raw(self, *args)

    def load_raw(self, *args):
        return _adonthell.image_load_raw(self, *args)

    def get_pnm(self, *args):
        return _adonthell.image_get_pnm(self, *args)

    def load_pnm(self, *args):
        return _adonthell.image_load_pnm(self, *args)

    def put(self, *args):
        return _adonthell.image_put(self, *args)

    def save(self, *args):
        return _adonthell.image_save(self, *args)

    def put_raw(self, *args):
        return _adonthell.image_put_raw(self, *args)

    def save_raw(self, *args):
        return _adonthell.image_save_raw(self, *args)

    def put_pnm(self, *args):
        return _adonthell.image_put_pnm(self, *args)

    def save_pnm(self, *args):
        return _adonthell.image_save_pnm(self, *args)

    def zoom(self, *args):
        return _adonthell.image_zoom(self, *args)

    def zoom_to(self, *args):
        return _adonthell.image_zoom_to(self, *args)

    def tile(self, *args):
        return _adonthell.image_tile(self, *args)

    def tile_to(self, *args):
        return _adonthell.image_tile_to(self, *args)

    def brightness(self, *args):
        return _adonthell.image_brightness(self, *args)

    def copy(self, *args):
        return _adonthell.image_copy(self, *args)
image_swigregister = _adonthell.image_swigregister
image_swigregister(image)

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

    def __init__(self, *args):
        this = _adonthell.new_animationframe(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_animationframe
    __del__ = lambda self: None

    def clear(self, *args):
        return _adonthell.animationframe_clear(self, *args)

    def is_masked(self, *args):
        return _adonthell.animationframe_is_masked(self, *args)

    def set_mask(self, *args):
        return _adonthell.animationframe_set_mask(self, *args)

    def alpha(self, *args):
        return _adonthell.animationframe_alpha(self, *args)

    def set_alpha(self, *args):
        return _adonthell.animationframe_set_alpha(self, *args)

    def image_nbr(self, *args):
        return _adonthell.animationframe_image_nbr(self, *args)

    def set_image_nbr(self, *args):
        return _adonthell.animationframe_set_image_nbr(self, *args)

    def delay(self, *args):
        return _adonthell.animationframe_delay(self, *args)

    def set_delay(self, *args):
        return _adonthell.animationframe_set_delay(self, *args)

    def nextframe(self, *args):
        return _adonthell.animationframe_nextframe(self, *args)

    def set_nextframe(self, *args):
        return _adonthell.animationframe_set_nextframe(self, *args)

    def offx(self, *args):
        return _adonthell.animationframe_offx(self, *args)

    def offy(self, *args):
        return _adonthell.animationframe_offy(self, *args)

    def set_offset(self, *args):
        return _adonthell.animationframe_set_offset(self, *args)

    def get(self, *args):
        return _adonthell.animationframe_get(self, *args)

    def put(self, *args):
        return _adonthell.animationframe_put(self, *args)
animationframe_swigregister = _adonthell.animationframe_swigregister
animationframe_swigregister(animationframe)


_adonthell.PLAY_swigconstant(_adonthell)
PLAY = _adonthell.PLAY

_adonthell.STOP_swigconstant(_adonthell)
STOP = _adonthell.STOP
class animation(drawable):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_animation(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_animation
    __del__ = lambda self: None

    def clear(self, *args):
        return _adonthell.animation_clear(self, *args)

    def play(self, *args):
        return _adonthell.animation_play(self, *args)

    def stop(self, *args):
        return _adonthell.animation_stop(self, *args)

    def playstate(self, *args):
        return _adonthell.animation_playstate(self, *args)

    def rewind(self, *args):
        return _adonthell.animation_rewind(self, *args)

    def next_frame(self, *args):
        return _adonthell.animation_next_frame(self, *args)

    def update(self, *args):
        return _adonthell.animation_update(self, *args)

    def draw(self, *args):
        return _adonthell.animation_draw(self, *args)

    def get(self, *args):
        return _adonthell.animation_get(self, *args)

    def load(self, *args):
        return _adonthell.animation_load(self, *args)

    def put(self, *args):
        return _adonthell.animation_put(self, *args)

    def save(self, *args):
        return _adonthell.animation_save(self, *args)

    def nbr_of_frames(self, *args):
        return _adonthell.animation_nbr_of_frames(self, *args)

    def nbr_of_images(self, *args):
        return _adonthell.animation_nbr_of_images(self, *args)

    def currentframe(self, *args):
        return _adonthell.animation_currentframe(self, *args)

    def set_currentframe(self, *args):
        return _adonthell.animation_set_currentframe(self, *args)

    def xoffset(self, *args):
        return _adonthell.animation_xoffset(self, *args)

    def yoffset(self, *args):
        return _adonthell.animation_yoffset(self, *args)

    def set_offset(self, *args):
        return _adonthell.animation_set_offset(self, *args)

    def get_frame(self, *args):
        return _adonthell.animation_get_frame(self, *args)

    def get_image(self, *args):
        return _adonthell.animation_get_image(self, *args)

    def insert_image(self, *args):
        return _adonthell.animation_insert_image(self, *args)

    def insert_frame(self, *args):
        return _adonthell.animation_insert_frame(self, *args)

    def delete_image(self, *args):
        return _adonthell.animation_delete_image(self, *args)

    def delete_frame(self, *args):
        return _adonthell.animation_delete_frame(self, *args)

    def zoom(self, *args):
        return _adonthell.animation_zoom(self, *args)

    def copy(self, *args):
        return _adonthell.animation_copy(self, *args)
animation_swigregister = _adonthell.animation_swigregister
animation_swigregister(animation)


_adonthell.ALL_WALKABLE_swigconstant(_adonthell)
ALL_WALKABLE = _adonthell.ALL_WALKABLE

_adonthell.WALKABLE_SOUTH_swigconstant(_adonthell)
WALKABLE_SOUTH = _adonthell.WALKABLE_SOUTH

_adonthell.WALKABLE_NORTH_swigconstant(_adonthell)
WALKABLE_NORTH = _adonthell.WALKABLE_NORTH

_adonthell.WALKABLE_EAST_swigconstant(_adonthell)
WALKABLE_EAST = _adonthell.WALKABLE_EAST

_adonthell.WALKABLE_WEST_swigconstant(_adonthell)
WALKABLE_WEST = _adonthell.WALKABLE_WEST

_adonthell.NONE_WALKABLE_swigconstant(_adonthell)
NONE_WALKABLE = _adonthell.NONE_WALKABLE
class mapsquare_walkable(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_mapsquare_walkable(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get(self, *args):
        return _adonthell.mapsquare_walkable_get(self, *args)

    def put(self, *args):
        return _adonthell.mapsquare_walkable_put(self, *args)

    def is_walkable_west(self, *args):
        return _adonthell.mapsquare_walkable_is_walkable_west(self, *args)

    def is_walkable_east(self, *args):
        return _adonthell.mapsquare_walkable_is_walkable_east(self, *args)

    def is_walkable_north(self, *args):
        return _adonthell.mapsquare_walkable_is_walkable_north(self, *args)

    def is_walkable_south(self, *args):
        return _adonthell.mapsquare_walkable_is_walkable_south(self, *args)

    def set_walkable_west(self, *args):
        return _adonthell.mapsquare_walkable_set_walkable_west(self, *args)

    def set_walkable_east(self, *args):
        return _adonthell.mapsquare_walkable_set_walkable_east(self, *args)

    def set_walkable_north(self, *args):
        return _adonthell.mapsquare_walkable_set_walkable_north(self, *args)

    def set_walkable_south(self, *args):
        return _adonthell.mapsquare_walkable_set_walkable_south(self, *args)

    def get_walkable(self, *args):
        return _adonthell.mapsquare_walkable_get_walkable(self, *args)

    def set_walkable(self, *args):
        return _adonthell.mapsquare_walkable_set_walkable(self, *args)
    __swig_destroy__ = _adonthell.delete_mapsquare_walkable
    __del__ = lambda self: None
mapsquare_walkable_swigregister = _adonthell.mapsquare_walkable_swigregister
mapsquare_walkable_swigregister(mapsquare_walkable)
MAPSQUARE_SIZE = cvar.MAPSQUARE_SIZE

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _adonthell.delete_mapsquare_walkable_area
    __del__ = lambda self: None

    def clear(self, *args):
        return _adonthell.mapsquare_walkable_area_clear(self, *args)

    def draw(self, *args):
        return _adonthell.mapsquare_walkable_area_draw(self, *args)

    def area_length(self, *args):
        return _adonthell.mapsquare_walkable_area_area_length(self, *args)

    def area_height(self, *args):
        return _adonthell.mapsquare_walkable_area_area_height(self, *args)

    def get_square(self, *args):
        return _adonthell.mapsquare_walkable_area_get_square(self, *args)

    def resize_area(self, *args):
        return _adonthell.mapsquare_walkable_area_resize_area(self, *args)

    def base_x(self, *args):
        return _adonthell.mapsquare_walkable_area_base_x(self, *args)

    def base_y(self, *args):
        return _adonthell.mapsquare_walkable_area_base_y(self, *args)

    def set_base(self, *args):
        return _adonthell.mapsquare_walkable_area_set_base(self, *args)

    def get(self, *args):
        return _adonthell.mapsquare_walkable_area_get(self, *args)

    def put(self, *args):
        return _adonthell.mapsquare_walkable_area_put(self, *args)

    def copy(self, *args):
        return _adonthell.mapsquare_walkable_area_copy(self, *args)
mapsquare_walkable_area_swigregister = _adonthell.mapsquare_walkable_area_swigregister
mapsquare_walkable_area_swigregister(mapsquare_walkable_area)

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

    def __init__(self, *args):
        this = _adonthell.new_mapsquare_tile(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_mapsquare_tile
    __del__ = lambda self: None
mapsquare_tile_swigregister = _adonthell.mapsquare_tile_swigregister
mapsquare_tile_swigregister(mapsquare_tile)

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

    def __init__(self, *args):
        this = _adonthell.new_mapsquare_char(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_mapsquare_char
    __del__ = lambda self: None
mapsquare_char_swigregister = _adonthell.mapsquare_char_swigregister
mapsquare_char_swigregister(mapsquare_char)

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

    def __init__(self, *args):
        this = _adonthell.new_mapsquare(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_mapsquare
    __del__ = lambda self: None

    def x(self, *args):
        return _adonthell.mapsquare_x(self, *args)

    def y(self, *args):
        return _adonthell.mapsquare_y(self, *args)

    def is_free(self, *args):
        return _adonthell.mapsquare_is_free(self, *args)

    def whoshere(self, *args):
        return _adonthell.mapsquare_whoshere(self, *args)
    g = _swig_property(_adonthell.mapsquare_g_get, _adonthell.mapsquare_g_set)
    h = _swig_property(_adonthell.mapsquare_h_get, _adonthell.mapsquare_h_set)
    f = _swig_property(_adonthell.mapsquare_f_get, _adonthell.mapsquare_f_set)
    parent = _swig_property(_adonthell.mapsquare_parent_get, _adonthell.mapsquare_parent_set)
    can_use_for_pathfinding = _swig_property(_adonthell.mapsquare_can_use_for_pathfinding_get, _adonthell.mapsquare_can_use_for_pathfinding_set)
mapsquare_swigregister = _adonthell.mapsquare_swigregister
mapsquare_swigregister(mapsquare)

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

    def __init__(self, *args):
        this = _adonthell.new_mapsquare_area(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_mapsquare_area
    __del__ = lambda self: None

    def clear(self, *args):
        return _adonthell.mapsquare_area_clear(self, *args)

    def area_length(self, *args):
        return _adonthell.mapsquare_area_area_length(self, *args)

    def area_height(self, *args):
        return _adonthell.mapsquare_area_area_height(self, *args)

    def get_square(self, *args):
        return _adonthell.mapsquare_area_get_square(self, *args)

    def resize_area(self, *args):
        return _adonthell.mapsquare_area_resize_area(self, *args)
mapsquare_area_swigregister = _adonthell.mapsquare_area_swigregister
mapsquare_area_swigregister(mapsquare_area)


_adonthell.MAPOBJECTS_DIR_swigconstant(_adonthell)
MAPOBJECTS_DIR = _adonthell.MAPOBJECTS_DIR
class mapobject(mapsquare_walkable_area):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_mapobject(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_mapobject
    __del__ = lambda self: None

    def clear(self, *args):
        return _adonthell.mapobject_clear(self, *args)

    def update(self, *args):
        return _adonthell.mapobject_update(self, *args)

    def draw(self, *args):
        return _adonthell.mapobject_draw(self, *args)

    def draw_from_base(self, *args):
        return _adonthell.mapobject_draw_from_base(self, *args)

    def get(self, *args):
        return _adonthell.mapobject_get(self, *args)

    def load(self, *args):
        return _adonthell.mapobject_load(self, *args)

    def put(self, *args):
        return _adonthell.mapobject_put(self, *args)

    def save(self, *args):
        return _adonthell.mapobject_save(self, *args)

    def nbr_of_animations(self, *args):
        return _adonthell.mapobject_nbr_of_animations(self, *args)

    def get_animation(self, *args):
        return _adonthell.mapobject_get_animation(self, *args)

    def insert_animation(self, *args):
        return _adonthell.mapobject_insert_animation(self, *args)

    def delete_animation(self, *args):
        return _adonthell.mapobject_delete_animation(self, *args)

    def copy(self, *args):
        return _adonthell.mapobject_copy(self, *args)
mapobject_swigregister = _adonthell.mapobject_swigregister
mapobject_swigregister(mapobject)


_adonthell.MAPCHAR_DIR_swigconstant(_adonthell)
MAPCHAR_DIR = _adonthell.MAPCHAR_DIR

_adonthell.STAND_NORTH_swigconstant(_adonthell)
STAND_NORTH = _adonthell.STAND_NORTH

_adonthell.STAND_SOUTH_swigconstant(_adonthell)
STAND_SOUTH = _adonthell.STAND_SOUTH

_adonthell.STAND_WEST_swigconstant(_adonthell)
STAND_WEST = _adonthell.STAND_WEST

_adonthell.STAND_EAST_swigconstant(_adonthell)
STAND_EAST = _adonthell.STAND_EAST

_adonthell.WALK_NORTH_swigconstant(_adonthell)
WALK_NORTH = _adonthell.WALK_NORTH

_adonthell.WALK_SOUTH_swigconstant(_adonthell)
WALK_SOUTH = _adonthell.WALK_SOUTH

_adonthell.WALK_WEST_swigconstant(_adonthell)
WALK_WEST = _adonthell.WALK_WEST

_adonthell.WALK_EAST_swigconstant(_adonthell)
WALK_EAST = _adonthell.WALK_EAST

_adonthell.NBR_MOVES_swigconstant(_adonthell)
NBR_MOVES = _adonthell.NBR_MOVES

_adonthell.NO_MOVE_swigconstant(_adonthell)
NO_MOVE = _adonthell.NO_MOVE
class mapcharacter(mapsquare_walkable_area, character_base, event_list):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_mapcharacter(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_mapcharacter
    __del__ = lambda self: None

    def clear(self, *args):
        return _adonthell.mapcharacter_clear(self, *args)

    def filename(self, *args):
        return _adonthell.mapcharacter_filename(self, *args)

    def update(self, *args):
        return _adonthell.mapcharacter_update(self, *args)

    def draw(self, *args):
        return _adonthell.mapcharacter_draw(self, *args)

    def draw_bubble(self, *args):
        return _adonthell.mapcharacter_draw_bubble(self, *args)

    def get(self, *args):
        return _adonthell.mapcharacter_get(self, *args)

    def load(self, *args):
        return _adonthell.mapcharacter_load(self, *args)

    def put(self, *args):
        return _adonthell.mapcharacter_put(self, *args)

    def save(self, *args):
        return _adonthell.mapcharacter_save(self, *args)

    def get_state(self, *args):
        return _adonthell.mapcharacter_get_state(self, *args)

    def put_state(self, *args):
        return _adonthell.mapcharacter_put_state(self, *args)

    def set_map(self, *args):
        return _adonthell.mapcharacter_set_map(self, *args)

    def remove_from_map(self, *args):
        return _adonthell.mapcharacter_remove_from_map(self, *args)

    def mymap(self, *args):
        return _adonthell.mapcharacter_mymap(self, *args)

    def stand_north(self, *args):
        return _adonthell.mapcharacter_stand_north(self, *args)

    def stand_south(self, *args):
        return _adonthell.mapcharacter_stand_south(self, *args)

    def stand_east(self, *args):
        return _adonthell.mapcharacter_stand_east(self, *args)

    def stand_west(self, *args):
        return _adonthell.mapcharacter_stand_west(self, *args)

    def stand(self, *args):
        return _adonthell.mapcharacter_stand(self, *args)

    def go_north(self, *args):
        return _adonthell.mapcharacter_go_north(self, *args)

    def go_south(self, *args):
        return _adonthell.mapcharacter_go_south(self, *args)

    def go_east(self, *args):
        return _adonthell.mapcharacter_go_east(self, *args)

    def go_west(self, *args):
        return _adonthell.mapcharacter_go_west(self, *args)

    def can_go_north(self, *args):
        return _adonthell.mapcharacter_can_go_north(self, *args)

    def can_go_south(self, *args):
        return _adonthell.mapcharacter_can_go_south(self, *args)

    def can_go_east(self, *args):
        return _adonthell.mapcharacter_can_go_east(self, *args)

    def can_go_west(self, *args):
        return _adonthell.mapcharacter_can_go_west(self, *args)

    def look_invert(self, *args):
        return _adonthell.mapcharacter_look_invert(self, *args)

    def whosnext(self, *args):
        return _adonthell.mapcharacter_whosnext(self, *args)

    def speak(self, *args):
        return _adonthell.mapcharacter_speak(self, *args)

    def is_speaking(self, *args):
        return _adonthell.mapcharacter_is_speaking(self, *args)

    def get_bubble(self, *args):
        return _adonthell.mapcharacter_get_bubble(self, *args)

    def set_offset(self, *args):
        return _adonthell.mapcharacter_set_offset(self, *args)

    def remove_from_pos(self, *args):
        return _adonthell.mapcharacter_remove_from_pos(self, *args)

    def jump_to(self, *args):
        return _adonthell.mapcharacter_jump_to(self, *args)

    def submap(self, *args):
        return _adonthell.mapcharacter_submap(self, *args)

    def posx(self, *args):
        return _adonthell.mapcharacter_posx(self, *args)

    def posy(self, *args):
        return _adonthell.mapcharacter_posy(self, *args)

    def offx(self, *args):
        return _adonthell.mapcharacter_offx(self, *args)

    def offy(self, *args):
        return _adonthell.mapcharacter_offy(self, *args)

    def currentmove(self, *args):
        return _adonthell.mapcharacter_currentmove(self, *args)

    def set_goal(self, *args):
        return _adonthell.mapcharacter_set_goal(self, *args)

    def set_callback(self, *args):
        return _adonthell.mapcharacter_set_callback(self, *args)

    def follow_path(self, *args):
        return _adonthell.mapcharacter_follow_path(self, *args)

    def goal_reached(self, *args):
        return _adonthell.mapcharacter_goal_reached(self, *args)

    def stop_moving(self, *args):
        return _adonthell.mapcharacter_stop_moving(self, *args)

    def time_callback(self, *args):
        return _adonthell.mapcharacter_time_callback(self, *args)

    def time_callback_string(self, *args):
        return _adonthell.mapcharacter_time_callback_string(self, *args)

    def set_schedule(self, *args):
        return _adonthell.mapcharacter_set_schedule(self, *args)

    def schedule_file(self, *args):
        return _adonthell.mapcharacter_schedule_file(self, *args)

    def is_schedule_activated(self, *args):
        return _adonthell.mapcharacter_is_schedule_activated(self, *args)

    def set_schedule_active(self, *args):
        return _adonthell.mapcharacter_set_schedule_active(self, *args)

    def do_stuff(self, *args):
        return _adonthell.mapcharacter_do_stuff(self, *args)

    def set_action(self, *args):
        return _adonthell.mapcharacter_set_action(self, *args)

    def action_file(self, *args):
        return _adonthell.mapcharacter_action_file(self, *args)

    def is_action_activated(self, *args):
        return _adonthell.mapcharacter_is_action_activated(self, *args)

    def set_action_active(self, *args):
        return _adonthell.mapcharacter_set_action_active(self, *args)

    def launch_action(self, *args):
        return _adonthell.mapcharacter_launch_action(self, *args)

    def get_animation(self, *args):
        return _adonthell.mapcharacter_get_animation(self, *args)

    def copy(self, *args):
        return _adonthell.mapcharacter_copy(self, *args)
mapcharacter_swigregister = _adonthell.mapcharacter_swigregister
mapcharacter_swigregister(mapcharacter)

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

    def clear(self, *args):
        return _adonthell.path_clear(self, *args)

    def calculate(self, *args):
        return _adonthell.path_calculate(self, *args)

    def nbr_moves(self, *args):
        return _adonthell.path_nbr_moves(self, *args)

    def get_move(self, *args):
        return _adonthell.path_get_move(self, *args)

    def get_state(self, *args):
        return _adonthell.path_get_state(self, *args)

    def put_state(self, *args):
        return _adonthell.path_put_state(self, *args)

    def __init__(self, *args):
        this = _adonthell.new_path(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_path
    __del__ = lambda self: None
path_swigregister = _adonthell.path_swigregister
path_swigregister(path)

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

    def __init__(self, *args):
        this = _adonthell.new_character(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_character
    __del__ = lambda self: None
character_swigregister = _adonthell.character_swigregister
character_swigregister(character)


_adonthell.MAPS_DIR_swigconstant(_adonthell)
MAPS_DIR = _adonthell.MAPS_DIR
class landmap(event_list):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_landmap(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_landmap
    __del__ = lambda self: None

    def clear(self, *args):
        return _adonthell.landmap_clear(self, *args)

    def nbr_of_mapobjects(self, *args):
        return _adonthell.landmap_nbr_of_mapobjects(self, *args)

    def nbr_of_submaps(self, *args):
        return _adonthell.landmap_nbr_of_submaps(self, *args)

    def nbr_of_mapcharacters(self, *args):
        return _adonthell.landmap_nbr_of_mapcharacters(self, *args)

    def filename(self, *args):
        return _adonthell.landmap_filename(self, *args)

    def get_mapcharacter(self, *args):
        return _adonthell.landmap_get_mapcharacter(self, *args)

    def get_mapobject(self, *args):
        return _adonthell.landmap_get_mapobject(self, *args)

    def get_submap(self, *args):
        return _adonthell.landmap_get_submap(self, *args)

    def update(self, *args):
        return _adonthell.landmap_update(self, *args)

    def get(self, *args):
        return _adonthell.landmap_get(self, *args)

    def load(self, *args):
        return _adonthell.landmap_load(self, *args)

    def put(self, *args):
        return _adonthell.landmap_put(self, *args)

    def save(self, *args):
        return _adonthell.landmap_save(self, *args)

    def get_state(self, *args):
        return _adonthell.landmap_get_state(self, *args)

    def put_state(self, *args):
        return _adonthell.landmap_put_state(self, *args)

    def put_mapobject(self, *args):
        return _adonthell.landmap_put_mapobject(self, *args)

    def remove_mapobject(self, *args):
        return _adonthell.landmap_remove_mapobject(self, *args)

    def insert_submap(self, *args):
        return _adonthell.landmap_insert_submap(self, *args)

    def delete_submap(self, *args):
        return _adonthell.landmap_delete_submap(self, *args)

    def insert_mapobject(self, *args):
        return _adonthell.landmap_insert_mapobject(self, *args)

    def delete_mapobject(self, *args):
        return _adonthell.landmap_delete_mapobject(self, *args)
landmap_swigregister = _adonthell.landmap_swigregister
landmap_swigregister(landmap)

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

    def __init__(self, *args):
        this = _adonthell.new_mapview(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_mapview
    __del__ = lambda self: None

    def attach_map(self, *args):
        return _adonthell.mapview_attach_map(self, *args)

    def detach_map(self, *args):
        return _adonthell.mapview_detach_map(self, *args)

    def set_pos(self, *args):
        return _adonthell.mapview_set_pos(self, *args)

    def center_on(self, *args):
        return _adonthell.mapview_center_on(self, *args)

    def currentsubmap(self, *args):
        return _adonthell.mapview_currentsubmap(self, *args)

    def posx(self, *args):
        return _adonthell.mapview_posx(self, *args)

    def posy(self, *args):
        return _adonthell.mapview_posy(self, *args)

    def offx(self, *args):
        return _adonthell.mapview_offx(self, *args)

    def offy(self, *args):
        return _adonthell.mapview_offy(self, *args)

    def can_scroll_right(self, *args):
        return _adonthell.mapview_can_scroll_right(self, *args)

    def can_scroll_left(self, *args):
        return _adonthell.mapview_can_scroll_left(self, *args)

    def can_scroll_up(self, *args):
        return _adonthell.mapview_can_scroll_up(self, *args)

    def can_scroll_down(self, *args):
        return _adonthell.mapview_can_scroll_down(self, *args)

    def scroll_right(self, *args):
        return _adonthell.mapview_scroll_right(self, *args)

    def scroll_left(self, *args):
        return _adonthell.mapview_scroll_left(self, *args)

    def scroll_down(self, *args):
        return _adonthell.mapview_scroll_down(self, *args)

    def scroll_up(self, *args):
        return _adonthell.mapview_scroll_up(self, *args)

    def get_state(self, *args):
        return _adonthell.mapview_get_state(self, *args)

    def put_state(self, *args):
        return _adonthell.mapview_put_state(self, *args)

    def resize(self, *args):
        return _adonthell.mapview_resize(self, *args)

    def set_schedule(self, *args):
        return _adonthell.mapview_set_schedule(self, *args)

    def schedule_file(self, *args):
        return _adonthell.mapview_schedule_file(self, *args)

    def update(self, *args):
        return _adonthell.mapview_update(self, *args)

    def draw(self, *args):
        return _adonthell.mapview_draw(self, *args)
mapview_swigregister = _adonthell.mapview_swigregister
mapview_swigregister(mapview)

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

    def __init__(self, *args):
        this = _adonthell.new_adonthell(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def main(self, *args):
        return _adonthell.adonthell_main(self, *args)

    def main_loop(self, *args):
        return _adonthell.adonthell_main_loop(self, *args)

    def main_quit(self, *args):
        return _adonthell.adonthell_main_quit(self, *args)

    def fade_out(self, *args):
        return _adonthell.adonthell_fade_out(self, *args)

    def fade_in(self, *args):
        return _adonthell.adonthell_fade_in(self, *args)

    def get_state(self, *args):
        return _adonthell.adonthell_get_state(self, *args)

    def put_state(self, *args):
        return _adonthell.adonthell_put_state(self, *args)

    def control_active(self, *args):
        return _adonthell.adonthell_control_active(self, *args)

    def set_control_active(self, *args):
        return _adonthell.adonthell_set_control_active(self, *args)

    def get_landmap(self, *args):
        return _adonthell.adonthell_get_landmap(self, *args)

    def update_map(self, *args):
        return _adonthell.adonthell_update_map(self, *args)

    def set_update_map(self, *args):
        return _adonthell.adonthell_set_update_map(self, *args)

    def get_mapview(self, *args):
        return _adonthell.adonthell_get_mapview(self, *args)

    def draw(self, *args):
        return _adonthell.adonthell_draw(self, *args)

    def set_mapview_schedule(self, *args):
        return _adonthell.adonthell_set_mapview_schedule(self, *args)

    def mapview_start(self, *args):
        return _adonthell.adonthell_mapview_start(self, *args)

    def mapview_stop(self, *args):
        return _adonthell.adonthell_mapview_stop(self, *args)
    __swig_destroy__ = _adonthell.delete_adonthell
    __del__ = lambda self: None
adonthell_swigregister = _adonthell.adonthell_swigregister
adonthell_swigregister(adonthell)


_adonthell.WIN_NB_TABLE_CHAR_swigconstant(_adonthell)
WIN_NB_TABLE_CHAR = _adonthell.WIN_NB_TABLE_CHAR

_adonthell.WIN_TEXT_MAX_LENGTH_swigconstant(_adonthell)
WIN_TEXT_MAX_LENGTH = _adonthell.WIN_TEXT_MAX_LENGTH

_adonthell.WIN_FONT_HEIGHT_swigconstant(_adonthell)
WIN_FONT_HEIGHT = _adonthell.WIN_FONT_HEIGHT

_adonthell.WIN_FONT_LENGHT_swigconstant(_adonthell)
WIN_FONT_LENGHT = _adonthell.WIN_FONT_LENGHT

_adonthell.WIN_SPACE_LENGHT_swigconstant(_adonthell)
WIN_SPACE_LENGHT = _adonthell.WIN_SPACE_LENGHT

_adonthell.WIN_DIRECTORY_swigconstant(_adonthell)
WIN_DIRECTORY = _adonthell.WIN_DIRECTORY

_adonthell.WIN_FONT_DIRECTORY_swigconstant(_adonthell)
WIN_FONT_DIRECTORY = _adonthell.WIN_FONT_DIRECTORY

_adonthell.WIN_BORDER_DIRECTORY_swigconstant(_adonthell)
WIN_BORDER_DIRECTORY = _adonthell.WIN_BORDER_DIRECTORY

_adonthell.WIN_BACKGROUND_DIRECTORY_swigconstant(_adonthell)
WIN_BACKGROUND_DIRECTORY = _adonthell.WIN_BACKGROUND_DIRECTORY

_adonthell.WIN_SCROLLBAR_DIRECTORY_swigconstant(_adonthell)
WIN_SCROLLBAR_DIRECTORY = _adonthell.WIN_SCROLLBAR_DIRECTORY

_adonthell.WIN_CURSOR_DIRECTORY_swigconstant(_adonthell)
WIN_CURSOR_DIRECTORY = _adonthell.WIN_CURSOR_DIRECTORY

_adonthell.WIN_FONT_FILE_IDX_swigconstant(_adonthell)
WIN_FONT_FILE_IDX = _adonthell.WIN_FONT_FILE_IDX

_adonthell.WIN_FONT_FILE_PIC_swigconstant(_adonthell)
WIN_FONT_FILE_PIC = _adonthell.WIN_FONT_FILE_PIC

_adonthell.WIN_FONT_FILE_swigconstant(_adonthell)
WIN_FONT_FILE = _adonthell.WIN_FONT_FILE

_adonthell.WIN_V_BORDER_TEMPLATE_FILE_swigconstant(_adonthell)
WIN_V_BORDER_TEMPLATE_FILE = _adonthell.WIN_V_BORDER_TEMPLATE_FILE

_adonthell.WIN_H_BORDER_TEMPLATE_FILE_swigconstant(_adonthell)
WIN_H_BORDER_TEMPLATE_FILE = _adonthell.WIN_H_BORDER_TEMPLATE_FILE

_adonthell.WIN_CORNER_TOP_LEFT_FILE_swigconstant(_adonthell)
WIN_CORNER_TOP_LEFT_FILE = _adonthell.WIN_CORNER_TOP_LEFT_FILE

_adonthell.WIN_CORNER_TOP_RIGHT_FILE_swigconstant(_adonthell)
WIN_CORNER_TOP_RIGHT_FILE = _adonthell.WIN_CORNER_TOP_RIGHT_FILE

_adonthell.WIN_CORNER_BOTTOM_LEFT_FILE_swigconstant(_adonthell)
WIN_CORNER_BOTTOM_LEFT_FILE = _adonthell.WIN_CORNER_BOTTOM_LEFT_FILE

_adonthell.WIN_CORNER_BOTTOM_RIGHT_FILE_swigconstant(_adonthell)
WIN_CORNER_BOTTOM_RIGHT_FILE = _adonthell.WIN_CORNER_BOTTOM_RIGHT_FILE

_adonthell.WIN_BACKGROUND_FILE_swigconstant(_adonthell)
WIN_BACKGROUND_FILE = _adonthell.WIN_BACKGROUND_FILE

_adonthell.WIN_SCROLLBAR_BAR_TOP_swigconstant(_adonthell)
WIN_SCROLLBAR_BAR_TOP = _adonthell.WIN_SCROLLBAR_BAR_TOP

_adonthell.WIN_SCROLLBAR_BAR_MID_swigconstant(_adonthell)
WIN_SCROLLBAR_BAR_MID = _adonthell.WIN_SCROLLBAR_BAR_MID

_adonthell.WIN_SCROLLBAR_BAR_BOT_swigconstant(_adonthell)
WIN_SCROLLBAR_BAR_BOT = _adonthell.WIN_SCROLLBAR_BAR_BOT

_adonthell.WIN_SCROLLBAR_BAR_FLEX_swigconstant(_adonthell)
WIN_SCROLLBAR_BAR_FLEX = _adonthell.WIN_SCROLLBAR_BAR_FLEX

_adonthell.WIN_SCROLLBAR_BACK_TOP_swigconstant(_adonthell)
WIN_SCROLLBAR_BACK_TOP = _adonthell.WIN_SCROLLBAR_BACK_TOP

_adonthell.WIN_SCROLLBAR_BACK_MID_swigconstant(_adonthell)
WIN_SCROLLBAR_BACK_MID = _adonthell.WIN_SCROLLBAR_BACK_MID

_adonthell.WIN_SCROLLBAR_BACK_BOT_swigconstant(_adonthell)
WIN_SCROLLBAR_BACK_BOT = _adonthell.WIN_SCROLLBAR_BACK_BOT

_adonthell.WIN_CURSOR_FILE_swigconstant(_adonthell)
WIN_CURSOR_FILE = _adonthell.WIN_CURSOR_FILE

_adonthell.WIN_BORDER_NORMAL_SIZE_swigconstant(_adonthell)
WIN_BORDER_NORMAL_SIZE = _adonthell.WIN_BORDER_NORMAL_SIZE

_adonthell.WIN_BORDER_MINI_SIZE_swigconstant(_adonthell)
WIN_BORDER_MINI_SIZE = _adonthell.WIN_BORDER_MINI_SIZE

_adonthell.WIN_BRIGHTNESS_LEVEL_swigconstant(_adonthell)
WIN_BRIGHTNESS_LEVEL = _adonthell.WIN_BRIGHTNESS_LEVEL
class win_manager(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_win_manager(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_win_manager
    __del__ = lambda self: None

    def add(self, *args):
        return _adonthell.win_manager_add(self, *args)

    def remove(self, *args):
        return _adonthell.win_manager_remove(self, *args)

    def update(self, *args):
        return _adonthell.win_manager_update(self, *args)

    def input_update(self, *args):
        return _adonthell.win_manager_input_update(self, *args)

    def draw(self, *args):
        return _adonthell.win_manager_draw(self, *args)

    def set_focus(self, *args):
        return _adonthell.win_manager_set_focus(self, *args)

    def destroy(self, *args):
        return _adonthell.win_manager_destroy(self, *args)
    get_active = staticmethod(_adonthell.win_manager_get_active)
    init = staticmethod(_adonthell.win_manager_init)
    cleanup = staticmethod(_adonthell.win_manager_cleanup)
    add_theme = staticmethod(_adonthell.win_manager_add_theme)
    remove_theme = staticmethod(_adonthell.win_manager_remove_theme)
    get_theme = staticmethod(_adonthell.win_manager_get_theme)
    add_font = staticmethod(_adonthell.win_manager_add_font)
    remove_font = staticmethod(_adonthell.win_manager_remove_font)
    get_font = staticmethod(_adonthell.win_manager_get_font)
win_manager_swigregister = _adonthell.win_manager_swigregister
win_manager_swigregister(win_manager)

def win_manager_get_active(*args):
    return _adonthell.win_manager_get_active(*args)
win_manager_get_active = _adonthell.win_manager_get_active

def win_manager_init(*args):
    return _adonthell.win_manager_init(*args)
win_manager_init = _adonthell.win_manager_init

def win_manager_cleanup(*args):
    return _adonthell.win_manager_cleanup(*args)
win_manager_cleanup = _adonthell.win_manager_cleanup

def win_manager_add_theme(*args):
    return _adonthell.win_manager_add_theme(*args)
win_manager_add_theme = _adonthell.win_manager_add_theme

def win_manager_remove_theme(*args):
    return _adonthell.win_manager_remove_theme(*args)
win_manager_remove_theme = _adonthell.win_manager_remove_theme

def win_manager_get_theme(*args):
    return _adonthell.win_manager_get_theme(*args)
win_manager_get_theme = _adonthell.win_manager_get_theme

def win_manager_add_font(*args):
    return _adonthell.win_manager_add_font(*args)
win_manager_add_font = _adonthell.win_manager_add_font

def win_manager_remove_font(*args):
    return _adonthell.win_manager_remove_font(*args)
win_manager_remove_font = _adonthell.win_manager_remove_font

def win_manager_get_font(*args):
    return _adonthell.win_manager_get_font(*args)
win_manager_get_font = _adonthell.win_manager_get_font

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

    def __init__(self, *args):
        this = _adonthell.new_win_font(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_win_font
    __del__ = lambda self: None

    def load(self, *args):
        return _adonthell.win_font_load(self, *args)

    def in_table(self, *args):
        return _adonthell.win_font_in_table(self, *args)

    def height(self, *args):
        return _adonthell.win_font_height(self, *args)

    def length(self, *args):
        return _adonthell.win_font_length(self, *args)
    cursor = _swig_property(_adonthell.win_font_cursor_get, _adonthell.win_font_cursor_set)
win_font_swigregister = _adonthell.win_font_swigregister
win_font_swigregister(win_font)


_adonthell.win_event_ACTIVATE_swigconstant(_adonthell)
win_event_ACTIVATE = _adonthell.win_event_ACTIVATE

_adonthell.win_event_UNACTIVATE_swigconstant(_adonthell)
win_event_UNACTIVATE = _adonthell.win_event_UNACTIVATE

_adonthell.win_event_UPDATE_swigconstant(_adonthell)
win_event_UPDATE = _adonthell.win_event_UPDATE

_adonthell.win_event_DRAW_swigconstant(_adonthell)
win_event_DRAW = _adonthell.win_event_DRAW

_adonthell.win_event_DRAW_ON_VISIBLE_swigconstant(_adonthell)
win_event_DRAW_ON_VISIBLE = _adonthell.win_event_DRAW_ON_VISIBLE

_adonthell.win_event_ACTIVATE_KEY_swigconstant(_adonthell)
win_event_ACTIVATE_KEY = _adonthell.win_event_ACTIVATE_KEY

_adonthell.win_event_SELECT_swigconstant(_adonthell)
win_event_SELECT = _adonthell.win_event_SELECT

_adonthell.win_event_UNSELECT_swigconstant(_adonthell)
win_event_UNSELECT = _adonthell.win_event_UNSELECT

_adonthell.win_event_KEYBOARD_swigconstant(_adonthell)
win_event_KEYBOARD = _adonthell.win_event_KEYBOARD

_adonthell.win_event_SCROLL_UP_swigconstant(_adonthell)
win_event_SCROLL_UP = _adonthell.win_event_SCROLL_UP

_adonthell.win_event_SCROLL_DOWN_swigconstant(_adonthell)
win_event_SCROLL_DOWN = _adonthell.win_event_SCROLL_DOWN

_adonthell.win_event_NEXT_swigconstant(_adonthell)
win_event_NEXT = _adonthell.win_event_NEXT

_adonthell.win_event_PREVIOUS_swigconstant(_adonthell)
win_event_PREVIOUS = _adonthell.win_event_PREVIOUS

_adonthell.win_event_CLOSE_swigconstant(_adonthell)
win_event_CLOSE = _adonthell.win_event_CLOSE

_adonthell.win_event_DESTROY_swigconstant(_adonthell)
win_event_DESTROY = _adonthell.win_event_DESTROY
class win_event(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_win_event(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_return_code(self, *args):
        return _adonthell.win_event_set_return_code(self, *args)

    def update(self, *args):
        return _adonthell.win_event_update(self, *args)

    def py_signal_connect(self, *args):
        return _adonthell.win_event_py_signal_connect(self, *args)
    __swig_destroy__ = _adonthell.delete_win_event
    __del__ = lambda self: None
win_event_swigregister = _adonthell.win_event_swigregister
win_event_swigregister(win_event)


_adonthell.win_border_MINI_swigconstant(_adonthell)
win_border_MINI = _adonthell.win_border_MINI

_adonthell.win_border_NORMAL_swigconstant(_adonthell)
win_border_NORMAL = _adonthell.win_border_NORMAL
class win_border(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_win_border(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_win_border
    __del__ = lambda self: None

    def load(self, *args):
        return _adonthell.win_border_load(self, *args)

    def update(self, *args):
        return _adonthell.win_border_update(self, *args)

    def destroy(self, *args):
        return _adonthell.win_border_destroy(self, *args)

    def draw(self, *args):
        return _adonthell.win_border_draw(self, *args)

    def set_visible_border(self, *args):
        return _adonthell.win_border_set_visible_border(self, *args)

    def set_brightness_border(self, *args):
        return _adonthell.win_border_set_brightness_border(self, *args)

    def set_border(self, *args):
        return _adonthell.win_border_set_border(self, *args)

    def set_trans_border(self, *args):
        return _adonthell.win_border_set_trans_border(self, *args)

    def length_border(self, *args):
        return _adonthell.win_border_length_border(self, *args)

    def height_border(self, *args):
        return _adonthell.win_border_height_border(self, *args)
win_border_swigregister = _adonthell.win_border_swigregister
win_border_swigregister(win_border)

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

    def __init__(self, *args):
        this = _adonthell.new_win_background(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_win_background
    __del__ = lambda self: None

    def load(self, *args):
        return _adonthell.win_background_load(self, *args)

    def update(self, *args):
        return _adonthell.win_background_update(self, *args)

    def destroy(self, *args):
        return _adonthell.win_background_destroy(self, *args)

    def draw(self, *args):
        return _adonthell.win_background_draw(self, *args)

    def set_visible_background(self, *args):
        return _adonthell.win_background_set_visible_background(self, *args)

    def set_background(self, *args):
        return _adonthell.win_background_set_background(self, *args)

    def set_brightness_background(self, *args):
        return _adonthell.win_background_set_brightness_background(self, *args)

    def set_trans_background(self, *args):
        return _adonthell.win_background_set_trans_background(self, *args)
win_background_swigregister = _adonthell.win_background_swigregister
win_background_swigregister(win_background)


_adonthell.win_base_ALIGN_NONE_swigconstant(_adonthell)
win_base_ALIGN_NONE = _adonthell.win_base_ALIGN_NONE

_adonthell.win_base_ALIGN_LEFT_swigconstant(_adonthell)
win_base_ALIGN_LEFT = _adonthell.win_base_ALIGN_LEFT

_adonthell.win_base_ALIGN_CENTER_swigconstant(_adonthell)
win_base_ALIGN_CENTER = _adonthell.win_base_ALIGN_CENTER

_adonthell.win_base_ALIGN_RIGHT_swigconstant(_adonthell)
win_base_ALIGN_RIGHT = _adonthell.win_base_ALIGN_RIGHT
class win_base(win_event, win_border, drawing_area, win_background):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_win_base(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def x(self, *args):
        return _adonthell.win_base_x(self, *args)

    def y(self, *args):
        return _adonthell.win_base_y(self, *args)

    def pad_x(self, *args):
        return _adonthell.win_base_pad_x(self, *args)

    def pad_y(self, *args):
        return _adonthell.win_base_pad_y(self, *args)

    def real_x(self, *args):
        return _adonthell.win_base_real_x(self, *args)

    def real_y(self, *args):
        return _adonthell.win_base_real_y(self, *args)

    def move(self, *args):
        return _adonthell.win_base_move(self, *args)

    def resize(self, *args):
        return _adonthell.win_base_resize(self, *args)

    def is_visible(self, *args):
        return _adonthell.win_base_is_visible(self, *args)

    def set_visible(self, *args):
        return _adonthell.win_base_set_visible(self, *args)

    def is_activate(self, *args):
        return _adonthell.win_base_is_activate(self, *args)

    def set_activate(self, *args):
        return _adonthell.win_base_set_activate(self, *args)

    def is_focus(self, *args):
        return _adonthell.win_base_is_focus(self, *args)

    def set_focus(self, *args):
        return _adonthell.win_base_set_focus(self, *args)

    def is_trans(self, *args):
        return _adonthell.win_base_is_trans(self, *args)

    def set_trans(self, *args):
        return _adonthell.win_base_set_trans(self, *args)

    def is_brightness(self, *args):
        return _adonthell.win_base_is_brightness(self, *args)

    def set_brightness(self, *args):
        return _adonthell.win_base_set_brightness(self, *args)

    def set_align(self, *args):
        return _adonthell.win_base_set_align(self, *args)

    def align(self, *args):
        return _adonthell.win_base_align(self, *args)

    def is_can_be_selected(self, *args):
        return _adonthell.win_base_is_can_be_selected(self, *args)

    def set_can_be_selected(self, *args):
        return _adonthell.win_base_set_can_be_selected(self, *args)

    def update(self, *args):
        return _adonthell.win_base_update(self, *args)

    def draw(self, *args):
        return _adonthell.win_base_draw(self, *args)

    def input_update(self, *args):
        return _adonthell.win_base_input_update(self, *args)
    __swig_destroy__ = _adonthell.delete_win_base
    __del__ = lambda self: None
win_base_swigregister = _adonthell.win_base_swigregister
win_base_swigregister(win_base)


_adonthell.win_container_SPACE_WITH_BORDER_swigconstant(_adonthell)
win_container_SPACE_WITH_BORDER = _adonthell.win_container_SPACE_WITH_BORDER

_adonthell.win_container_SPACE_WITH_OBJECT_swigconstant(_adonthell)
win_container_SPACE_WITH_OBJECT = _adonthell.win_container_SPACE_WITH_OBJECT

_adonthell.win_container_LIST_LAYOUT_swigconstant(_adonthell)
win_container_LIST_LAYOUT = _adonthell.win_container_LIST_LAYOUT

_adonthell.win_container_NO_LAYOUT_swigconstant(_adonthell)
win_container_NO_LAYOUT = _adonthell.win_container_NO_LAYOUT
class win_container(win_base):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_win_container(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def move(self, *args):
        return _adonthell.win_container_move(self, *args)

    def resize(self, *args):
        return _adonthell.win_container_resize(self, *args)

    def add(self, *args):
        return _adonthell.win_container_add(self, *args)

    def remove(self, *args):
        return _adonthell.win_container_remove(self, *args)

    def remove_all(self, *args):
        return _adonthell.win_container_remove_all(self, *args)

    def destroy(self, *args):
        return _adonthell.win_container_destroy(self, *args)
    __swig_destroy__ = _adonthell.delete_win_container
    __del__ = lambda self: None

    def update(self, *args):
        return _adonthell.win_container_update(self, *args)

    def input_update(self, *args):
        return _adonthell.win_container_input_update(self, *args)

    def draw(self, *args):
        return _adonthell.win_container_draw(self, *args)

    def set_visible_all(self, *args):
        return _adonthell.win_container_set_visible_all(self, *args)

    def set_brightness(self, *args):
        return _adonthell.win_container_set_brightness(self, *args)

    def set_trans(self, *args):
        return _adonthell.win_container_set_trans(self, *args)

    def set_space_with_border(self, *args):
        return _adonthell.win_container_set_space_with_border(self, *args)

    def set_space_with_object(self, *args):
        return _adonthell.win_container_set_space_with_object(self, *args)

    def space_with_border(self, *args):
        return _adonthell.win_container_space_with_border(self, *args)

    def space_with_object(self, *args):
        return _adonthell.win_container_space_with_object(self, *args)

    def set_layout(self, *args):
        return _adonthell.win_container_set_layout(self, *args)

    def set_focus_object(self, *args):
        return _adonthell.win_container_set_focus_object(self, *args)

    def focus_object(self, *args):
        return _adonthell.win_container_focus_object(self, *args)
win_container_swigregister = _adonthell.win_container_swigregister
win_container_swigregister(win_container)

class win_image(image, win_base):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _adonthell.delete_win_image
    __del__ = lambda self: None

    def draw(self, *args):
        return _adonthell.win_image_draw(self, *args)

    def update(self, *args):
        return _adonthell.win_image_update(self, *args)

    def input_update(self, *args):
        return _adonthell.win_image_input_update(self, *args)

    def set_brightness(self, *args):
        return _adonthell.win_image_set_brightness(self, *args)

    def set_trans(self, *args):
        return _adonthell.win_image_set_trans(self, *args)

    def pack(self, *args):
        return _adonthell.win_image_pack(self, *args)

    def set_auto_refresh(self, *args):
        return _adonthell.win_image_set_auto_refresh(self, *args)

    def __init__(self, *args):
        this = _adonthell.new_win_image(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
win_image_swigregister = _adonthell.win_image_swigregister
win_image_swigregister(win_image)


_adonthell.label_NOTHING_swigconstant(_adonthell)
label_NOTHING = _adonthell.label_NOTHING

_adonthell.label_AUTO_HEIGHT_swigconstant(_adonthell)
label_AUTO_HEIGHT = _adonthell.label_AUTO_HEIGHT

_adonthell.label_AUTO_SIZE_swigconstant(_adonthell)
label_AUTO_SIZE = _adonthell.label_AUTO_SIZE
class label(image):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_label(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def text_string(self, *args):
        return _adonthell.label_text_string(self, *args)

    def text_char(self, *args):
        return _adonthell.label_text_char(self, *args)

    def set_text(self, *args):
        return _adonthell.label_set_text(self, *args)

    def add_text(self, *args):
        return _adonthell.label_add_text(self, *args)

    def set_font(self, *args):
        return _adonthell.label_set_font(self, *args)

    def set_form(self, *args):
        return _adonthell.label_set_form(self, *args)

    def set_cursor_visible(self, *args):
        return _adonthell.label_set_cursor_visible(self, *args)

    def set_cursor_moveable(self, *args):
        return _adonthell.label_set_cursor_moveable(self, *args)

    def resize(self, *args):
        return _adonthell.label_resize(self, *args)

    def update(self, *args):
        return _adonthell.label_update(self, *args)

    def input_update(self, *args):
        return _adonthell.label_input_update(self, *args)
    __swig_destroy__ = _adonthell.delete_label
    __del__ = lambda self: None
label_swigregister = _adonthell.label_swigregister
label_swigregister(label)

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

    def __init__(self, *args):
        this = _adonthell.new_win_label(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_win_label
    __del__ = lambda self: None

    def draw(self, *args):
        return _adonthell.win_label_draw(self, *args)

    def update(self, *args):
        return _adonthell.win_label_update(self, *args)

    def input_update(self, *args):
        return _adonthell.win_label_input_update(self, *args)

    def set_brightness(self, *args):
        return _adonthell.win_label_set_brightness(self, *args)

    def set_trans(self, *args):
        return _adonthell.win_label_set_trans(self, *args)

    def pack(self, *args):
        return _adonthell.win_label_pack(self, *args)

    def set_auto_refresh(self, *args):
        return _adonthell.win_label_set_auto_refresh(self, *args)
win_label_swigregister = _adonthell.win_label_swigregister
win_label_swigregister(win_label)

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

    def input_update(self, *args):
        return _adonthell.label_input_input_update(self, *args)

    def __init__(self, *args):
        this = _adonthell.new_label_input(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_label_input
    __del__ = lambda self: None
label_input_swigregister = _adonthell.label_input_swigregister
label_input_swigregister(label_input)

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

    def __init__(self, *args):
        this = _adonthell.new_win_write(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_win_write
    __del__ = lambda self: None

    def draw(self, *args):
        return _adonthell.win_write_draw(self, *args)

    def update(self, *args):
        return _adonthell.win_write_update(self, *args)

    def input_update(self, *args):
        return _adonthell.win_write_input_update(self, *args)

    def set_brightness(self, *args):
        return _adonthell.win_write_set_brightness(self, *args)

    def set_trans(self, *args):
        return _adonthell.win_write_set_trans(self, *args)

    def pack(self, *args):
        return _adonthell.win_write_pack(self, *args)

    def set_auto_refresh(self, *args):
        return _adonthell.win_write_set_auto_refresh(self, *args)
win_write_swigregister = _adonthell.win_write_swigregister
win_write_swigregister(win_write)

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

    def __init__(self, *args):
        this = _adonthell.new_win_mapview(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_win_mapview
    __del__ = lambda self: None

    def draw(self, *args):
        return _adonthell.win_mapview_draw(self, *args)

    def update(self, *args):
        return _adonthell.win_mapview_update(self, *args)

    def input_update(self, *args):
        return _adonthell.win_mapview_input_update(self, *args)

    def set_brightness(self, *args):
        return _adonthell.win_mapview_set_brightness(self, *args)

    def set_trans(self, *args):
        return _adonthell.win_mapview_set_trans(self, *args)

    def pack(self, *args):
        return _adonthell.win_mapview_pack(self, *args)

    def set_auto_refresh(self, *args):
        return _adonthell.win_mapview_set_auto_refresh(self, *args)
win_mapview_swigregister = _adonthell.win_mapview_swigregister
win_mapview_swigregister(win_mapview)

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

    def __init__(self, *args):
        this = _adonthell.new_win_scrollbar(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_win_scrollbar
    __del__ = lambda self: None

    def update_bar(self, *args):
        return _adonthell.win_scrollbar_update_bar(self, *args)

    def load(self, *args):
        return _adonthell.win_scrollbar_load(self, *args)

    def update_back(self, *args):
        return _adonthell.win_scrollbar_update_back(self, *args)

    def destroy(self, *args):
        return _adonthell.win_scrollbar_destroy(self, *args)

    def set_scrollbar(self, *args):
        return _adonthell.win_scrollbar_set_scrollbar(self, *args)

    def set_visible_scrollbar(self, *args):
        return _adonthell.win_scrollbar_set_visible_scrollbar(self, *args)

    def set_trans_scrollbar(self, *args):
        return _adonthell.win_scrollbar_set_trans_scrollbar(self, *args)

    def set_brightness_scrollbar(self, *args):
        return _adonthell.win_scrollbar_set_brightness_scrollbar(self, *args)

    def draw(self, *args):
        return _adonthell.win_scrollbar_draw(self, *args)

    def height_bar(self, *args):
        return _adonthell.win_scrollbar_height_bar(self, *args)
win_scrollbar_swigregister = _adonthell.win_scrollbar_swigregister
win_scrollbar_swigregister(win_scrollbar)


_adonthell.win_scroll_PAD_DEFAULT_swigconstant(_adonthell)
win_scroll_PAD_DEFAULT = _adonthell.win_scroll_PAD_DEFAULT
class win_scroll(win_container, win_scrollbar):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_win_scroll(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def amplitude(self, *args):
        return _adonthell.win_scroll_amplitude(self, *args)

    def add(self, *args):
        return _adonthell.win_scroll_add(self, *args)

    def remove(self, *args):
        return _adonthell.win_scroll_remove(self, *args)

    def remove_all(self, *args):
        return _adonthell.win_scroll_remove_all(self, *args)

    def resize(self, *args):
        return _adonthell.win_scroll_resize(self, *args)

    def destroy(self, *args):
        return _adonthell.win_scroll_destroy(self, *args)

    def draw(self, *args):
        return _adonthell.win_scroll_draw(self, *args)

    def update(self, *args):
        return _adonthell.win_scroll_update(self, *args)

    def input_update(self, *args):
        return _adonthell.win_scroll_input_update(self, *args)

    def set_space_between_border(self, *args):
        return _adonthell.win_scroll_set_space_between_border(self, *args)

    def set_space_between_object(self, *args):
        return _adonthell.win_scroll_set_space_between_object(self, *args)

    def cursor_y(self, *args):
        return _adonthell.win_scroll_cursor_y(self, *args)

    def set_auto_scrollbar(self, *args):
        return _adonthell.win_scroll_set_auto_scrollbar(self, *args)

    def set_auto_refresh(self, *args):
        return _adonthell.win_scroll_set_auto_refresh(self, *args)

    def set_brightness(self, *args):
        return _adonthell.win_scroll_set_brightness(self, *args)

    def set_trans(self, *args):
        return _adonthell.win_scroll_set_trans(self, *args)
    __swig_destroy__ = _adonthell.delete_win_scroll
    __del__ = lambda self: None
win_scroll_swigregister = _adonthell.win_scroll_swigregister
win_scroll_swigregister(win_scroll)


_adonthell.win_select_MODE_BORDER_swigconstant(_adonthell)
win_select_MODE_BORDER = _adonthell.win_select_MODE_BORDER

_adonthell.win_select_MODE_BRIGHTNESS_swigconstant(_adonthell)
win_select_MODE_BRIGHTNESS = _adonthell.win_select_MODE_BRIGHTNESS
class win_select(win_scroll):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_win_select(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def input_update(self, *args):
        return _adonthell.win_select_input_update(self, *args)

    def add(self, *args):
        return _adonthell.win_select_add(self, *args)

    def remove(self, *args):
        return _adonthell.win_select_remove(self, *args)

    def remove_all(self, *args):
        return _adonthell.win_select_remove_all(self, *args)

    def set_mode(self, *args):
        return _adonthell.win_select_set_mode(self, *args)

    def set_border_select(self, *args):
        return _adonthell.win_select_set_border_select(self, *args)

    def set_circle(self, *args):
        return _adonthell.win_select_set_circle(self, *args)

    def is_circle(self, *args):
        return _adonthell.win_select_is_circle(self, *args)

    def set_default(self, *args):
        return _adonthell.win_select_set_default(self, *args)

    def set_default_object(self, *args):
        return _adonthell.win_select_set_default_object(self, *args)

    def set_default_position(self, *args):
        return _adonthell.win_select_set_default_position(self, *args)

    def get_selected_object(self, *args):
        return _adonthell.win_select_get_selected_object(self, *args)

    def get_selected_position(self, *args):
        return _adonthell.win_select_get_selected_position(self, *args)
    __swig_destroy__ = _adonthell.delete_win_select
    __del__ = lambda self: None
win_select_swigregister = _adonthell.win_select_swigregister
win_select_swigregister(win_select)

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

    def __init__(self, *args):
        this = _adonthell.new_win_theme(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_win_theme
    __del__ = lambda self: None

    def destroy(self, *args):
        return _adonthell.win_theme_destroy(self, *args)
win_theme_swigregister = _adonthell.win_theme_swigregister
win_theme_swigregister(win_theme)

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

    def __init__(self, *args):
        this = _adonthell.new_text_bubble(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_text_bubble
    __del__ = lambda self: None

    def update(self, *args):
        return _adonthell.text_bubble_update(self, *args)

    def remaining(self, *args):
        return _adonthell.text_bubble_remaining(self, *args)
text_bubble_swigregister = _adonthell.text_bubble_swigregister
text_bubble_swigregister(text_bubble)


_adonthell.MAX_COLOR_swigconstant(_adonthell)
MAX_COLOR = _adonthell.MAX_COLOR
class dialog_screen(win_container):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_dialog_screen(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_dialog_screen
    __del__ = lambda self: None

    def init(self, *args):
        return _adonthell.dialog_screen_init(self, *args)

    def set_portrait(self, *args):
        return _adonthell.dialog_screen_set_portrait(self, *args)

    def set_name(self, *args):
        return _adonthell.dialog_screen_set_name(self, *args)

    def set_npc(self, *args):
        return _adonthell.dialog_screen_set_npc(self, *args)

    def update(self, *args):
        return _adonthell.dialog_screen_update(self, *args)

    def run(self, *args):
        return _adonthell.dialog_screen_run(self, *args)
dialog_screen_swigregister = _adonthell.dialog_screen_swigregister
dialog_screen_swigregister(dialog_screen)


_adonthell.LOAD_SCREEN_swigconstant(_adonthell)
LOAD_SCREEN = _adonthell.LOAD_SCREEN

_adonthell.SAVE_SCREEN_swigconstant(_adonthell)
SAVE_SCREEN = _adonthell.SAVE_SCREEN
class data_screen(win_container):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _adonthell.new_data_screen(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_data_screen
    __del__ = lambda self: None

    def update(self, *args):
        return _adonthell.data_screen_update(self, *args)

    def get_result(self, *args):
        return _adonthell.data_screen_get_result(self, *args)
data_screen_swigregister = _adonthell.data_screen_swigregister
data_screen_swigregister(data_screen)

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

    def __init__(self, *args):
        this = _adonthell.new_gamedata(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_gamedata
    __del__ = lambda self: None

    def put(self, *args):
        return _adonthell.gamedata_put(self, *args)

    def get(self, *args):
        return _adonthell.gamedata_get(self, *args)

    def directory(self, *args):
        return _adonthell.gamedata_directory(self, *args)

    def description(self, *args):
        return _adonthell.gamedata_description(self, *args)

    def location(self, *args):
        return _adonthell.gamedata_location(self, *args)

    def gametime(self, *args):
        return _adonthell.gamedata_gametime(self, *args)

    def timestamp(self, *args):
        return _adonthell.gamedata_timestamp(self, *args)

    def set_description(self, *args):
        return _adonthell.gamedata_set_description(self, *args)

    def set_directory(self, *args):
        return _adonthell.gamedata_set_directory(self, *args)

    def set_gametime(self, *args):
        return _adonthell.gamedata_set_gametime(self, *args)
    init = staticmethod(_adonthell.gamedata_init)
    cleanup = staticmethod(_adonthell.gamedata_cleanup)
    load_characters = staticmethod(_adonthell.gamedata_load_characters)
    load_quests = staticmethod(_adonthell.gamedata_load_quests)
    load_mapengine = staticmethod(_adonthell.gamedata_load_mapengine)
    load_audio = staticmethod(_adonthell.gamedata_load_audio)
    load_achievements = staticmethod(_adonthell.gamedata_load_achievements)
    load = staticmethod(_adonthell.gamedata_load)
    load_newest = staticmethod(_adonthell.gamedata_load_newest)
    save = staticmethod(_adonthell.gamedata_save)
    unload = staticmethod(_adonthell.gamedata_unload)
    next_save = staticmethod(_adonthell.gamedata_next_save)
    user_data_dir = staticmethod(_adonthell.gamedata_user_data_dir)
    game_data_dir = staticmethod(_adonthell.gamedata_game_data_dir)
    get_saved_game = staticmethod(_adonthell.gamedata_get_saved_game)
    quests = staticmethod(_adonthell.gamedata_quests)
    player = staticmethod(_adonthell.gamedata_player)
    get_character = staticmethod(_adonthell.gamedata_get_character)
    get_quest = staticmethod(_adonthell.gamedata_get_quest)
    characters = staticmethod(_adonthell.gamedata_characters)
    engine = staticmethod(_adonthell.gamedata_engine)
gamedata_swigregister = _adonthell.gamedata_swigregister
gamedata_swigregister(gamedata)

def gamedata_init(*args):
    return _adonthell.gamedata_init(*args)
gamedata_init = _adonthell.gamedata_init

def gamedata_cleanup(*args):
    return _adonthell.gamedata_cleanup(*args)
gamedata_cleanup = _adonthell.gamedata_cleanup

def gamedata_load_characters(*args):
    return _adonthell.gamedata_load_characters(*args)
gamedata_load_characters = _adonthell.gamedata_load_characters

def gamedata_load_quests(*args):
    return _adonthell.gamedata_load_quests(*args)
gamedata_load_quests = _adonthell.gamedata_load_quests

def gamedata_load_mapengine(*args):
    return _adonthell.gamedata_load_mapengine(*args)
gamedata_load_mapengine = _adonthell.gamedata_load_mapengine

def gamedata_load_audio(*args):
    return _adonthell.gamedata_load_audio(*args)
gamedata_load_audio = _adonthell.gamedata_load_audio

def gamedata_load_achievements(*args):
    return _adonthell.gamedata_load_achievements(*args)
gamedata_load_achievements = _adonthell.gamedata_load_achievements

def gamedata_load(*args):
    return _adonthell.gamedata_load(*args)
gamedata_load = _adonthell.gamedata_load

def gamedata_load_newest(*args):
    return _adonthell.gamedata_load_newest(*args)
gamedata_load_newest = _adonthell.gamedata_load_newest

def gamedata_save(*args):
    return _adonthell.gamedata_save(*args)
gamedata_save = _adonthell.gamedata_save

def gamedata_unload(*args):
    return _adonthell.gamedata_unload(*args)
gamedata_unload = _adonthell.gamedata_unload

def gamedata_next_save(*args):
    return _adonthell.gamedata_next_save(*args)
gamedata_next_save = _adonthell.gamedata_next_save

def gamedata_user_data_dir(*args):
    return _adonthell.gamedata_user_data_dir(*args)
gamedata_user_data_dir = _adonthell.gamedata_user_data_dir

def gamedata_game_data_dir(*args):
    return _adonthell.gamedata_game_data_dir(*args)
gamedata_game_data_dir = _adonthell.gamedata_game_data_dir

def gamedata_get_saved_game(*args):
    return _adonthell.gamedata_get_saved_game(*args)
gamedata_get_saved_game = _adonthell.gamedata_get_saved_game

def gamedata_quests(*args):
    return _adonthell.gamedata_quests(*args)
gamedata_quests = _adonthell.gamedata_quests

def gamedata_player(*args):
    return _adonthell.gamedata_player(*args)
gamedata_player = _adonthell.gamedata_player

def gamedata_get_character(*args):
    return _adonthell.gamedata_get_character(*args)
gamedata_get_character = _adonthell.gamedata_get_character

def gamedata_get_quest(*args):
    return _adonthell.gamedata_get_quest(*args)
gamedata_get_quest = _adonthell.gamedata_get_quest

def gamedata_characters(*args):
    return _adonthell.gamedata_characters(*args)
gamedata_characters = _adonthell.gamedata_characters

def gamedata_engine(*args):
    return _adonthell.gamedata_engine(*args)
gamedata_engine = _adonthell.gamedata_engine


_adonthell.CONFIG_swigconstant(_adonthell)
CONFIG = _adonthell.CONFIG

_adonthell.USER_DATA_swigconstant(_adonthell)
USER_DATA = _adonthell.USER_DATA
class game(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    User_data_dir = _swig_property(_adonthell.game_User_data_dir_get, _adonthell.game_User_data_dir_set)
    Global_data_dir = _swig_property(_adonthell.game_Global_data_dir_get, _adonthell.game_Global_data_dir_set)
    Game_data_dir = _swig_property(_adonthell.game_Game_data_dir_get, _adonthell.game_Game_data_dir_set)
    init = staticmethod(_adonthell.game_init)
    set_game_data_dir = staticmethod(_adonthell.game_set_game_data_dir)
    user_data_dir = staticmethod(_adonthell.game_user_data_dir)
    global_data_dir = staticmethod(_adonthell.game_global_data_dir)
    game_data_dir = staticmethod(_adonthell.game_game_data_dir)
    find_file = staticmethod(_adonthell.game_find_file)
    find_directory = staticmethod(_adonthell.game_find_directory)

    def __init__(self, *args):
        this = _adonthell.new_game(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_game
    __del__ = lambda self: None
game_swigregister = _adonthell.game_swigregister
game_swigregister(game)

def game_init(*args):
    return _adonthell.game_init(*args)
game_init = _adonthell.game_init

def game_set_game_data_dir(*args):
    return _adonthell.game_set_game_data_dir(*args)
game_set_game_data_dir = _adonthell.game_set_game_data_dir

def game_user_data_dir(*args):
    return _adonthell.game_user_data_dir(*args)
game_user_data_dir = _adonthell.game_user_data_dir

def game_global_data_dir(*args):
    return _adonthell.game_global_data_dir(*args)
game_global_data_dir = _adonthell.game_global_data_dir

def game_game_data_dir(*args):
    return _adonthell.game_game_data_dir(*args)
game_game_data_dir = _adonthell.game_game_data_dir

def game_find_file(*args):
    return _adonthell.game_find_file(*args)
game_find_file = _adonthell.game_find_file

def game_find_directory(*args):
    return _adonthell.game_find_directory(*args)
game_find_directory = _adonthell.game_find_directory

class nls(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    init = staticmethod(_adonthell.nls_init)
    set_language = staticmethod(_adonthell.nls_set_language)
    translate = staticmethod(_adonthell.nls_translate)

    def __init__(self, *args):
        this = _adonthell.new_nls(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _adonthell.delete_nls
    __del__ = lambda self: None
nls_swigregister = _adonthell.nls_swigregister
nls_swigregister(nls)

def nls_init(*args):
    return _adonthell.nls_init(*args)
nls_init = _adonthell.nls_init

def nls_set_language(*args):
    return _adonthell.nls_set_language(*args)
nls_set_language = _adonthell.nls_set_language

def nls_translate(*args):
    return _adonthell.nls_translate(*args)
nls_translate = _adonthell.nls_translate

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

    def __init__(self, *args):
        this = _adonthell.new_config(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def parse_arguments(self, *args):
        return _adonthell.config_parse_arguments(self, *args)

    def write_adonthellrc(self, *args):
        return _adonthell.config_write_adonthellrc(self, *args)

    def read_adonthellrc(self, *args):
        return _adonthell.config_read_adonthellrc(self, *args)

    def get_adonthellrc(self, *args):
        return _adonthell.config_get_adonthellrc(self, *args)
    language = _swig_property(_adonthell.config_language_get, _adonthell.config_language_set)
    font = _swig_property(_adonthell.config_font_get, _adonthell.config_font_set)
    game_name = _swig_property(_adonthell.config_game_name_get, _adonthell.config_game_name_set)
    gamedir = _swig_property(_adonthell.config_gamedir_get, _adonthell.config_gamedir_set)
    screen_mode = _swig_property(_adonthell.config_screen_mode_get, _adonthell.config_screen_mode_set)
    display = _swig_property(_adonthell.config_display_get, _adonthell.config_display_set)
    quick_load = _swig_property(_adonthell.config_quick_load_get, _adonthell.config_quick_load_set)
    audio_channels = _swig_property(_adonthell.config_audio_channels_get, _adonthell.config_audio_channels_set)
    audio_resolution = _swig_property(_adonthell.config_audio_resolution_get, _adonthell.config_audio_resolution_set)
    audio_sample_rate = _swig_property(_adonthell.config_audio_sample_rate_get, _adonthell.config_audio_sample_rate_set)
    audio_volume = _swig_property(_adonthell.config_audio_volume_get, _adonthell.config_audio_volume_set)
    __swig_destroy__ = _adonthell.delete_config
    __del__ = lambda self: None
config_swigregister = _adonthell.config_swigregister
config_swigregister(config)

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    create = staticmethod(_adonthell.achievements_create)
    update = staticmethod(_adonthell.achievements_update)
    num_achievements = staticmethod(_adonthell.achievements_num_achievements)
    num_unlocked = staticmethod(_adonthell.achievements_num_unlocked)
    is_unlocked = staticmethod(_adonthell.achievements_is_unlocked)
    achievement_id = staticmethod(_adonthell.achievements_achievement_id)
    py_signal_connect = staticmethod(_adonthell.achievements_py_signal_connect)
achievements_swigregister = _adonthell.achievements_swigregister
achievements_swigregister(achievements)

def achievements_create(*args):
    return _adonthell.achievements_create(*args)
achievements_create = _adonthell.achievements_create

def achievements_update(*args):
    return _adonthell.achievements_update(*args)
achievements_update = _adonthell.achievements_update

def achievements_num_achievements(*args):
    return _adonthell.achievements_num_achievements(*args)
achievements_num_achievements = _adonthell.achievements_num_achievements

def achievements_num_unlocked(*args):
    return _adonthell.achievements_num_unlocked(*args)
achievements_num_unlocked = _adonthell.achievements_num_unlocked

def achievements_is_unlocked(*args):
    return _adonthell.achievements_is_unlocked(*args)
achievements_is_unlocked = _adonthell.achievements_is_unlocked

def achievements_achievement_id(*args):
    return _adonthell.achievements_achievement_id(*args)
achievements_achievement_id = _adonthell.achievements_achievement_id

def achievements_py_signal_connect(*args):
    return _adonthell.achievements_py_signal_connect(*args)
achievements_py_signal_connect = _adonthell.achievements_py_signal_connect



