# This file was created automatically by SWIG 1.3.29.
# Don't modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.

import _kahakai
import new
new_instancemethod = new.instancemethod
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__ == 'PySwigObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

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

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

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


_GLIBCXX_LIST = _kahakai._GLIBCXX_LIST
_GLIBCXX_MAP = _kahakai._GLIBCXX_MAP
_GLIBCXX_SET = _kahakai._GLIBCXX_SET
class PySwigIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PySwigIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PySwigIterator, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _kahakai.delete_PySwigIterator
    __del__ = lambda self : None;
    def value(*args): return _kahakai.PySwigIterator_value(*args)
    def incr(*args): return _kahakai.PySwigIterator_incr(*args)
    def decr(*args): return _kahakai.PySwigIterator_decr(*args)
    def distance(*args): return _kahakai.PySwigIterator_distance(*args)
    def equal(*args): return _kahakai.PySwigIterator_equal(*args)
    def copy(*args): return _kahakai.PySwigIterator_copy(*args)
    def next(*args): return _kahakai.PySwigIterator_next(*args)
    def previous(*args): return _kahakai.PySwigIterator_previous(*args)
    def advance(*args): return _kahakai.PySwigIterator_advance(*args)
    def __eq__(*args): return _kahakai.PySwigIterator___eq__(*args)
    def __ne__(*args): return _kahakai.PySwigIterator___ne__(*args)
    def __iadd__(*args): return _kahakai.PySwigIterator___iadd__(*args)
    def __isub__(*args): return _kahakai.PySwigIterator___isub__(*args)
    def __add__(*args): return _kahakai.PySwigIterator___add__(*args)
    def __sub__(*args): return _kahakai.PySwigIterator___sub__(*args)
    def __iter__(self): return self
PySwigIterator_swigregister = _kahakai.PySwigIterator_swigregister
PySwigIterator_swigregister(PySwigIterator)

class WindowObject(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowObject, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WindowObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowObject(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_setmethods__["id"] = _kahakai.WindowObject_id_set
    __swig_getmethods__["id"] = _kahakai.WindowObject_id_get
    if _newclass:id = property(_kahakai.WindowObject_id_get, _kahakai.WindowObject_id_set)
    __swig_setmethods__["type"] = _kahakai.WindowObject_type_set
    __swig_getmethods__["type"] = _kahakai.WindowObject_type_get
    if _newclass:type = property(_kahakai.WindowObject_type_get, _kahakai.WindowObject_type_set)
    __swig_setmethods__["actionlist"] = _kahakai.WindowObject_actionlist_set
    __swig_getmethods__["actionlist"] = _kahakai.WindowObject_actionlist_get
    if _newclass:actionlist = property(_kahakai.WindowObject_actionlist_get, _kahakai.WindowObject_actionlist_set)
    __swig_destroy__ = _kahakai.delete_WindowObject
    __del__ = lambda self : None;
WindowObject_swigregister = _kahakai.WindowObject_swigregister
WindowObject_swigregister(WindowObject)

class Kahakai(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Kahakai, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Kahakai, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_getmethods__["Instance"] = lambda x: _kahakai.Kahakai_Instance
    if _newclass:Instance = staticmethod(_kahakai.Kahakai_Instance)
    __swig_setmethods__["script_current_screen"] = _kahakai.Kahakai_script_current_screen_set
    __swig_getmethods__["script_current_screen"] = _kahakai.Kahakai_script_current_screen_get
    if _newclass:script_current_screen = property(_kahakai.Kahakai_script_current_screen_get, _kahakai.Kahakai_script_current_screen_set)
    __swig_setmethods__["window_table"] = _kahakai.Kahakai_window_table_set
    __swig_getmethods__["window_table"] = _kahakai.Kahakai_window_table_get
    if _newclass:window_table = property(_kahakai.Kahakai_window_table_get, _kahakai.Kahakai_window_table_set)
    __swig_setmethods__["kascreen_list"] = _kahakai.Kahakai_kascreen_list_set
    __swig_getmethods__["kascreen_list"] = _kahakai.Kahakai_kascreen_list_get
    if _newclass:kascreen_list = property(_kahakai.Kahakai_kascreen_list_get, _kahakai.Kahakai_kascreen_list_set)
    __swig_setmethods__["double_click"] = _kahakai.Kahakai_double_click_set
    __swig_getmethods__["double_click"] = _kahakai.Kahakai_double_click_get
    if _newclass:double_click = property(_kahakai.Kahakai_double_click_get, _kahakai.Kahakai_double_click_set)
    __swig_setmethods__["screenmask"] = _kahakai.Kahakai_screenmask_set
    __swig_getmethods__["screenmask"] = _kahakai.Kahakai_screenmask_get
    if _newclass:screenmask = property(_kahakai.Kahakai_screenmask_get, _kahakai.Kahakai_screenmask_set)
    __swig_setmethods__["pathenv"] = _kahakai.Kahakai_pathenv_set
    __swig_getmethods__["pathenv"] = _kahakai.Kahakai_pathenv_get
    if _newclass:pathenv = property(_kahakai.Kahakai_pathenv_get, _kahakai.Kahakai_pathenv_set)
    def registerWindowFunction(*args): return _kahakai.Kahakai_registerWindowFunction(*args)
    def registerScreenFunction(*args): return _kahakai.Kahakai_registerScreenFunction(*args)
    def registerMenuFunction(*args): return _kahakai.Kahakai_registerMenuFunction(*args)
    __swig_destroy__ = _kahakai.delete_Kahakai
    __del__ = lambda self : None;
Kahakai_swigregister = _kahakai.Kahakai_swigregister
Kahakai_swigregister(Kahakai)
Kahakai_Instance = _kahakai.Kahakai_Instance

class Vector_KaScreen(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Vector_KaScreen, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Vector_KaScreen, name)
    __repr__ = _swig_repr
    def iterator(*args): return _kahakai.Vector_KaScreen_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _kahakai.Vector_KaScreen___nonzero__(*args)
    def __len__(*args): return _kahakai.Vector_KaScreen___len__(*args)
    def pop(*args): return _kahakai.Vector_KaScreen_pop(*args)
    def __getslice__(*args): return _kahakai.Vector_KaScreen___getslice__(*args)
    def __setslice__(*args): return _kahakai.Vector_KaScreen___setslice__(*args)
    def __delslice__(*args): return _kahakai.Vector_KaScreen___delslice__(*args)
    def __delitem__(*args): return _kahakai.Vector_KaScreen___delitem__(*args)
    def __getitem__(*args): return _kahakai.Vector_KaScreen___getitem__(*args)
    def __setitem__(*args): return _kahakai.Vector_KaScreen___setitem__(*args)
    def append(*args): return _kahakai.Vector_KaScreen_append(*args)
    def empty(*args): return _kahakai.Vector_KaScreen_empty(*args)
    def size(*args): return _kahakai.Vector_KaScreen_size(*args)
    def clear(*args): return _kahakai.Vector_KaScreen_clear(*args)
    def swap(*args): return _kahakai.Vector_KaScreen_swap(*args)
    def get_allocator(*args): return _kahakai.Vector_KaScreen_get_allocator(*args)
    def begin(*args): return _kahakai.Vector_KaScreen_begin(*args)
    def end(*args): return _kahakai.Vector_KaScreen_end(*args)
    def rbegin(*args): return _kahakai.Vector_KaScreen_rbegin(*args)
    def rend(*args): return _kahakai.Vector_KaScreen_rend(*args)
    def pop_back(*args): return _kahakai.Vector_KaScreen_pop_back(*args)
    def erase(*args): return _kahakai.Vector_KaScreen_erase(*args)
    def __init__(self, *args): 
        this = _kahakai.new_Vector_KaScreen(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _kahakai.Vector_KaScreen_push_back(*args)
    def front(*args): return _kahakai.Vector_KaScreen_front(*args)
    def back(*args): return _kahakai.Vector_KaScreen_back(*args)
    def assign(*args): return _kahakai.Vector_KaScreen_assign(*args)
    def resize(*args): return _kahakai.Vector_KaScreen_resize(*args)
    def insert(*args): return _kahakai.Vector_KaScreen_insert(*args)
    def reserve(*args): return _kahakai.Vector_KaScreen_reserve(*args)
    def capacity(*args): return _kahakai.Vector_KaScreen_capacity(*args)
    __swig_destroy__ = _kahakai.delete_Vector_KaScreen
    __del__ = lambda self : None;
Vector_KaScreen_swigregister = _kahakai.Vector_KaScreen_swigregister
Vector_KaScreen_swigregister(Vector_KaScreen)

class Vector_KaWindow(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Vector_KaWindow, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Vector_KaWindow, name)
    __repr__ = _swig_repr
    def iterator(*args): return _kahakai.Vector_KaWindow_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _kahakai.Vector_KaWindow___nonzero__(*args)
    def __len__(*args): return _kahakai.Vector_KaWindow___len__(*args)
    def pop(*args): return _kahakai.Vector_KaWindow_pop(*args)
    def __getslice__(*args): return _kahakai.Vector_KaWindow___getslice__(*args)
    def __setslice__(*args): return _kahakai.Vector_KaWindow___setslice__(*args)
    def __delslice__(*args): return _kahakai.Vector_KaWindow___delslice__(*args)
    def __delitem__(*args): return _kahakai.Vector_KaWindow___delitem__(*args)
    def __getitem__(*args): return _kahakai.Vector_KaWindow___getitem__(*args)
    def __setitem__(*args): return _kahakai.Vector_KaWindow___setitem__(*args)
    def append(*args): return _kahakai.Vector_KaWindow_append(*args)
    def empty(*args): return _kahakai.Vector_KaWindow_empty(*args)
    def size(*args): return _kahakai.Vector_KaWindow_size(*args)
    def clear(*args): return _kahakai.Vector_KaWindow_clear(*args)
    def swap(*args): return _kahakai.Vector_KaWindow_swap(*args)
    def get_allocator(*args): return _kahakai.Vector_KaWindow_get_allocator(*args)
    def begin(*args): return _kahakai.Vector_KaWindow_begin(*args)
    def end(*args): return _kahakai.Vector_KaWindow_end(*args)
    def rbegin(*args): return _kahakai.Vector_KaWindow_rbegin(*args)
    def rend(*args): return _kahakai.Vector_KaWindow_rend(*args)
    def pop_back(*args): return _kahakai.Vector_KaWindow_pop_back(*args)
    def erase(*args): return _kahakai.Vector_KaWindow_erase(*args)
    def __init__(self, *args): 
        this = _kahakai.new_Vector_KaWindow(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _kahakai.Vector_KaWindow_push_back(*args)
    def front(*args): return _kahakai.Vector_KaWindow_front(*args)
    def back(*args): return _kahakai.Vector_KaWindow_back(*args)
    def assign(*args): return _kahakai.Vector_KaWindow_assign(*args)
    def resize(*args): return _kahakai.Vector_KaWindow_resize(*args)
    def insert(*args): return _kahakai.Vector_KaWindow_insert(*args)
    def reserve(*args): return _kahakai.Vector_KaWindow_reserve(*args)
    def capacity(*args): return _kahakai.Vector_KaWindow_capacity(*args)
    __swig_destroy__ = _kahakai.delete_Vector_KaWindow
    __del__ = lambda self : None;
Vector_KaWindow_swigregister = _kahakai.Vector_KaWindow_swigregister
Vector_KaWindow_swigregister(Vector_KaWindow)

class Vector_Desktop(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Vector_Desktop, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Vector_Desktop, name)
    __repr__ = _swig_repr
    def iterator(*args): return _kahakai.Vector_Desktop_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _kahakai.Vector_Desktop___nonzero__(*args)
    def __len__(*args): return _kahakai.Vector_Desktop___len__(*args)
    def pop(*args): return _kahakai.Vector_Desktop_pop(*args)
    def __getslice__(*args): return _kahakai.Vector_Desktop___getslice__(*args)
    def __setslice__(*args): return _kahakai.Vector_Desktop___setslice__(*args)
    def __delslice__(*args): return _kahakai.Vector_Desktop___delslice__(*args)
    def __delitem__(*args): return _kahakai.Vector_Desktop___delitem__(*args)
    def __getitem__(*args): return _kahakai.Vector_Desktop___getitem__(*args)
    def __setitem__(*args): return _kahakai.Vector_Desktop___setitem__(*args)
    def append(*args): return _kahakai.Vector_Desktop_append(*args)
    def empty(*args): return _kahakai.Vector_Desktop_empty(*args)
    def size(*args): return _kahakai.Vector_Desktop_size(*args)
    def clear(*args): return _kahakai.Vector_Desktop_clear(*args)
    def swap(*args): return _kahakai.Vector_Desktop_swap(*args)
    def get_allocator(*args): return _kahakai.Vector_Desktop_get_allocator(*args)
    def begin(*args): return _kahakai.Vector_Desktop_begin(*args)
    def end(*args): return _kahakai.Vector_Desktop_end(*args)
    def rbegin(*args): return _kahakai.Vector_Desktop_rbegin(*args)
    def rend(*args): return _kahakai.Vector_Desktop_rend(*args)
    def pop_back(*args): return _kahakai.Vector_Desktop_pop_back(*args)
    def erase(*args): return _kahakai.Vector_Desktop_erase(*args)
    def __init__(self, *args): 
        this = _kahakai.new_Vector_Desktop(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _kahakai.Vector_Desktop_push_back(*args)
    def front(*args): return _kahakai.Vector_Desktop_front(*args)
    def back(*args): return _kahakai.Vector_Desktop_back(*args)
    def assign(*args): return _kahakai.Vector_Desktop_assign(*args)
    def resize(*args): return _kahakai.Vector_Desktop_resize(*args)
    def insert(*args): return _kahakai.Vector_Desktop_insert(*args)
    def reserve(*args): return _kahakai.Vector_Desktop_reserve(*args)
    def capacity(*args): return _kahakai.Vector_Desktop_capacity(*args)
    __swig_destroy__ = _kahakai.delete_Vector_Desktop
    __del__ = lambda self : None;
Vector_Desktop_swigregister = _kahakai.Vector_Desktop_swigregister
Vector_Desktop_swigregister(Vector_Desktop)

class Vector_KaAction(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Vector_KaAction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Vector_KaAction, name)
    __repr__ = _swig_repr
    def iterator(*args): return _kahakai.Vector_KaAction_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _kahakai.Vector_KaAction___nonzero__(*args)
    def __len__(*args): return _kahakai.Vector_KaAction___len__(*args)
    def pop(*args): return _kahakai.Vector_KaAction_pop(*args)
    def __getslice__(*args): return _kahakai.Vector_KaAction___getslice__(*args)
    def __setslice__(*args): return _kahakai.Vector_KaAction___setslice__(*args)
    def __delslice__(*args): return _kahakai.Vector_KaAction___delslice__(*args)
    def __delitem__(*args): return _kahakai.Vector_KaAction___delitem__(*args)
    def __getitem__(*args): return _kahakai.Vector_KaAction___getitem__(*args)
    def __setitem__(*args): return _kahakai.Vector_KaAction___setitem__(*args)
    def append(*args): return _kahakai.Vector_KaAction_append(*args)
    def empty(*args): return _kahakai.Vector_KaAction_empty(*args)
    def size(*args): return _kahakai.Vector_KaAction_size(*args)
    def clear(*args): return _kahakai.Vector_KaAction_clear(*args)
    def swap(*args): return _kahakai.Vector_KaAction_swap(*args)
    def get_allocator(*args): return _kahakai.Vector_KaAction_get_allocator(*args)
    def begin(*args): return _kahakai.Vector_KaAction_begin(*args)
    def end(*args): return _kahakai.Vector_KaAction_end(*args)
    def rbegin(*args): return _kahakai.Vector_KaAction_rbegin(*args)
    def rend(*args): return _kahakai.Vector_KaAction_rend(*args)
    def pop_back(*args): return _kahakai.Vector_KaAction_pop_back(*args)
    def erase(*args): return _kahakai.Vector_KaAction_erase(*args)
    def __init__(self, *args): 
        this = _kahakai.new_Vector_KaAction(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _kahakai.Vector_KaAction_push_back(*args)
    def front(*args): return _kahakai.Vector_KaAction_front(*args)
    def back(*args): return _kahakai.Vector_KaAction_back(*args)
    def assign(*args): return _kahakai.Vector_KaAction_assign(*args)
    def resize(*args): return _kahakai.Vector_KaAction_resize(*args)
    def insert(*args): return _kahakai.Vector_KaAction_insert(*args)
    def reserve(*args): return _kahakai.Vector_KaAction_reserve(*args)
    def capacity(*args): return _kahakai.Vector_KaAction_capacity(*args)
    __swig_destroy__ = _kahakai.delete_Vector_KaAction
    __del__ = lambda self : None;
Vector_KaAction_swigregister = _kahakai.Vector_KaAction_swigregister
Vector_KaAction_swigregister(Vector_KaAction)

class Vector_KaMenu(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Vector_KaMenu, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Vector_KaMenu, name)
    __repr__ = _swig_repr
    def iterator(*args): return _kahakai.Vector_KaMenu_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _kahakai.Vector_KaMenu___nonzero__(*args)
    def __len__(*args): return _kahakai.Vector_KaMenu___len__(*args)
    def pop(*args): return _kahakai.Vector_KaMenu_pop(*args)
    def __getslice__(*args): return _kahakai.Vector_KaMenu___getslice__(*args)
    def __setslice__(*args): return _kahakai.Vector_KaMenu___setslice__(*args)
    def __delslice__(*args): return _kahakai.Vector_KaMenu___delslice__(*args)
    def __delitem__(*args): return _kahakai.Vector_KaMenu___delitem__(*args)
    def __getitem__(*args): return _kahakai.Vector_KaMenu___getitem__(*args)
    def __setitem__(*args): return _kahakai.Vector_KaMenu___setitem__(*args)
    def append(*args): return _kahakai.Vector_KaMenu_append(*args)
    def empty(*args): return _kahakai.Vector_KaMenu_empty(*args)
    def size(*args): return _kahakai.Vector_KaMenu_size(*args)
    def clear(*args): return _kahakai.Vector_KaMenu_clear(*args)
    def swap(*args): return _kahakai.Vector_KaMenu_swap(*args)
    def get_allocator(*args): return _kahakai.Vector_KaMenu_get_allocator(*args)
    def begin(*args): return _kahakai.Vector_KaMenu_begin(*args)
    def end(*args): return _kahakai.Vector_KaMenu_end(*args)
    def rbegin(*args): return _kahakai.Vector_KaMenu_rbegin(*args)
    def rend(*args): return _kahakai.Vector_KaMenu_rend(*args)
    def pop_back(*args): return _kahakai.Vector_KaMenu_pop_back(*args)
    def erase(*args): return _kahakai.Vector_KaMenu_erase(*args)
    def __init__(self, *args): 
        this = _kahakai.new_Vector_KaMenu(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _kahakai.Vector_KaMenu_push_back(*args)
    def front(*args): return _kahakai.Vector_KaMenu_front(*args)
    def back(*args): return _kahakai.Vector_KaMenu_back(*args)
    def assign(*args): return _kahakai.Vector_KaMenu_assign(*args)
    def resize(*args): return _kahakai.Vector_KaMenu_resize(*args)
    def insert(*args): return _kahakai.Vector_KaMenu_insert(*args)
    def reserve(*args): return _kahakai.Vector_KaMenu_reserve(*args)
    def capacity(*args): return _kahakai.Vector_KaMenu_capacity(*args)
    __swig_destroy__ = _kahakai.delete_Vector_KaMenu
    __del__ = lambda self : None;
Vector_KaMenu_swigregister = _kahakai.Vector_KaMenu_swigregister
Vector_KaMenu_swigregister(Vector_KaMenu)

class Pair_ci(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair_ci, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Pair_ci, name)
    __repr__ = _swig_repr
    __swig_setmethods__["first"] = _kahakai.Pair_ci_first_set
    __swig_getmethods__["first"] = _kahakai.Pair_ci_first_get
    if _newclass:first = property(_kahakai.Pair_ci_first_get, _kahakai.Pair_ci_first_set)
    __swig_setmethods__["second"] = _kahakai.Pair_ci_second_set
    __swig_getmethods__["second"] = _kahakai.Pair_ci_second_get
    if _newclass:second = property(_kahakai.Pair_ci_second_get, _kahakai.Pair_ci_second_set)
    def __init__(self, *args): 
        this = _kahakai.new_Pair_ci(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_Pair_ci
    __del__ = lambda self : None;
Pair_ci_swigregister = _kahakai.Pair_ci_swigregister
Pair_ci_swigregister(Pair_ci)

class Vector_pair_ci(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Vector_pair_ci, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Vector_pair_ci, name)
    __repr__ = _swig_repr
    def iterator(*args): return _kahakai.Vector_pair_ci_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _kahakai.Vector_pair_ci___nonzero__(*args)
    def __len__(*args): return _kahakai.Vector_pair_ci___len__(*args)
    def pop(*args): return _kahakai.Vector_pair_ci_pop(*args)
    def __getslice__(*args): return _kahakai.Vector_pair_ci___getslice__(*args)
    def __setslice__(*args): return _kahakai.Vector_pair_ci___setslice__(*args)
    def __delslice__(*args): return _kahakai.Vector_pair_ci___delslice__(*args)
    def __delitem__(*args): return _kahakai.Vector_pair_ci___delitem__(*args)
    def __getitem__(*args): return _kahakai.Vector_pair_ci___getitem__(*args)
    def __setitem__(*args): return _kahakai.Vector_pair_ci___setitem__(*args)
    def append(*args): return _kahakai.Vector_pair_ci_append(*args)
    def empty(*args): return _kahakai.Vector_pair_ci_empty(*args)
    def size(*args): return _kahakai.Vector_pair_ci_size(*args)
    def clear(*args): return _kahakai.Vector_pair_ci_clear(*args)
    def swap(*args): return _kahakai.Vector_pair_ci_swap(*args)
    def get_allocator(*args): return _kahakai.Vector_pair_ci_get_allocator(*args)
    def begin(*args): return _kahakai.Vector_pair_ci_begin(*args)
    def end(*args): return _kahakai.Vector_pair_ci_end(*args)
    def rbegin(*args): return _kahakai.Vector_pair_ci_rbegin(*args)
    def rend(*args): return _kahakai.Vector_pair_ci_rend(*args)
    def pop_back(*args): return _kahakai.Vector_pair_ci_pop_back(*args)
    def erase(*args): return _kahakai.Vector_pair_ci_erase(*args)
    def __init__(self, *args): 
        this = _kahakai.new_Vector_pair_ci(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _kahakai.Vector_pair_ci_push_back(*args)
    def front(*args): return _kahakai.Vector_pair_ci_front(*args)
    def back(*args): return _kahakai.Vector_pair_ci_back(*args)
    def assign(*args): return _kahakai.Vector_pair_ci_assign(*args)
    def resize(*args): return _kahakai.Vector_pair_ci_resize(*args)
    def insert(*args): return _kahakai.Vector_pair_ci_insert(*args)
    def reserve(*args): return _kahakai.Vector_pair_ci_reserve(*args)
    def capacity(*args): return _kahakai.Vector_pair_ci_capacity(*args)
    __swig_destroy__ = _kahakai.delete_Vector_pair_ci
    __del__ = lambda self : None;
Vector_pair_ci_swigregister = _kahakai.Vector_pair_ci_swigregister
Vector_pair_ci_swigregister(Vector_pair_ci)

class Vector_int(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Vector_int, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Vector_int, name)
    __repr__ = _swig_repr
    def iterator(*args): return _kahakai.Vector_int_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _kahakai.Vector_int___nonzero__(*args)
    def __len__(*args): return _kahakai.Vector_int___len__(*args)
    def pop(*args): return _kahakai.Vector_int_pop(*args)
    def __getslice__(*args): return _kahakai.Vector_int___getslice__(*args)
    def __setslice__(*args): return _kahakai.Vector_int___setslice__(*args)
    def __delslice__(*args): return _kahakai.Vector_int___delslice__(*args)
    def __delitem__(*args): return _kahakai.Vector_int___delitem__(*args)
    def __getitem__(*args): return _kahakai.Vector_int___getitem__(*args)
    def __setitem__(*args): return _kahakai.Vector_int___setitem__(*args)
    def append(*args): return _kahakai.Vector_int_append(*args)
    def empty(*args): return _kahakai.Vector_int_empty(*args)
    def size(*args): return _kahakai.Vector_int_size(*args)
    def clear(*args): return _kahakai.Vector_int_clear(*args)
    def swap(*args): return _kahakai.Vector_int_swap(*args)
    def get_allocator(*args): return _kahakai.Vector_int_get_allocator(*args)
    def begin(*args): return _kahakai.Vector_int_begin(*args)
    def end(*args): return _kahakai.Vector_int_end(*args)
    def rbegin(*args): return _kahakai.Vector_int_rbegin(*args)
    def rend(*args): return _kahakai.Vector_int_rend(*args)
    def pop_back(*args): return _kahakai.Vector_int_pop_back(*args)
    def erase(*args): return _kahakai.Vector_int_erase(*args)
    def __init__(self, *args): 
        this = _kahakai.new_Vector_int(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _kahakai.Vector_int_push_back(*args)
    def front(*args): return _kahakai.Vector_int_front(*args)
    def back(*args): return _kahakai.Vector_int_back(*args)
    def assign(*args): return _kahakai.Vector_int_assign(*args)
    def resize(*args): return _kahakai.Vector_int_resize(*args)
    def insert(*args): return _kahakai.Vector_int_insert(*args)
    def reserve(*args): return _kahakai.Vector_int_reserve(*args)
    def capacity(*args): return _kahakai.Vector_int_capacity(*args)
    __swig_destroy__ = _kahakai.delete_Vector_int
    __del__ = lambda self : None;
Vector_int_swigregister = _kahakai.Vector_int_swigregister
Vector_int_swigregister(Vector_int)

class Vector_Vector_KaAction(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Vector_Vector_KaAction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Vector_Vector_KaAction, name)
    __repr__ = _swig_repr
    def iterator(*args): return _kahakai.Vector_Vector_KaAction_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _kahakai.Vector_Vector_KaAction___nonzero__(*args)
    def __len__(*args): return _kahakai.Vector_Vector_KaAction___len__(*args)
    def pop(*args): return _kahakai.Vector_Vector_KaAction_pop(*args)
    def __getslice__(*args): return _kahakai.Vector_Vector_KaAction___getslice__(*args)
    def __setslice__(*args): return _kahakai.Vector_Vector_KaAction___setslice__(*args)
    def __delslice__(*args): return _kahakai.Vector_Vector_KaAction___delslice__(*args)
    def __delitem__(*args): return _kahakai.Vector_Vector_KaAction___delitem__(*args)
    def __getitem__(*args): return _kahakai.Vector_Vector_KaAction___getitem__(*args)
    def __setitem__(*args): return _kahakai.Vector_Vector_KaAction___setitem__(*args)
    def append(*args): return _kahakai.Vector_Vector_KaAction_append(*args)
    def empty(*args): return _kahakai.Vector_Vector_KaAction_empty(*args)
    def size(*args): return _kahakai.Vector_Vector_KaAction_size(*args)
    def clear(*args): return _kahakai.Vector_Vector_KaAction_clear(*args)
    def swap(*args): return _kahakai.Vector_Vector_KaAction_swap(*args)
    def get_allocator(*args): return _kahakai.Vector_Vector_KaAction_get_allocator(*args)
    def begin(*args): return _kahakai.Vector_Vector_KaAction_begin(*args)
    def end(*args): return _kahakai.Vector_Vector_KaAction_end(*args)
    def rbegin(*args): return _kahakai.Vector_Vector_KaAction_rbegin(*args)
    def rend(*args): return _kahakai.Vector_Vector_KaAction_rend(*args)
    def pop_back(*args): return _kahakai.Vector_Vector_KaAction_pop_back(*args)
    def erase(*args): return _kahakai.Vector_Vector_KaAction_erase(*args)
    def __init__(self, *args): 
        this = _kahakai.new_Vector_Vector_KaAction(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _kahakai.Vector_Vector_KaAction_push_back(*args)
    def front(*args): return _kahakai.Vector_Vector_KaAction_front(*args)
    def back(*args): return _kahakai.Vector_Vector_KaAction_back(*args)
    def assign(*args): return _kahakai.Vector_Vector_KaAction_assign(*args)
    def resize(*args): return _kahakai.Vector_Vector_KaAction_resize(*args)
    def insert(*args): return _kahakai.Vector_Vector_KaAction_insert(*args)
    def reserve(*args): return _kahakai.Vector_Vector_KaAction_reserve(*args)
    def capacity(*args): return _kahakai.Vector_Vector_KaAction_capacity(*args)
    __swig_destroy__ = _kahakai.delete_Vector_Vector_KaAction
    __del__ = lambda self : None;
Vector_Vector_KaAction_swigregister = _kahakai.Vector_Vector_KaAction_swigregister
Vector_Vector_KaAction_swigregister(Vector_Vector_KaAction)

class Map_Vector_KaAction(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Map_Vector_KaAction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Map_Vector_KaAction, name)
    __repr__ = _swig_repr
    def __len__(*args): return _kahakai.Map_Vector_KaAction___len__(*args)
    def __getitem__(*args): return _kahakai.Map_Vector_KaAction___getitem__(*args)
    def __setitem__(*args): return _kahakai.Map_Vector_KaAction___setitem__(*args)
    def __delitem__(*args): return _kahakai.Map_Vector_KaAction___delitem__(*args)
    def __init__(self, *args): 
        this = _kahakai.new_Map_Vector_KaAction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_Map_Vector_KaAction
    __del__ = lambda self : None;
Map_Vector_KaAction_swigregister = _kahakai.Map_Vector_KaAction_swigregister
Map_Vector_KaAction_swigregister(Map_Vector_KaAction)

class Map_CStr_WindowFunction(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Map_CStr_WindowFunction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Map_CStr_WindowFunction, name)
    __repr__ = _swig_repr
    def __len__(*args): return _kahakai.Map_CStr_WindowFunction___len__(*args)
    def __getitem__(*args): return _kahakai.Map_CStr_WindowFunction___getitem__(*args)
    def __setitem__(*args): return _kahakai.Map_CStr_WindowFunction___setitem__(*args)
    def __delitem__(*args): return _kahakai.Map_CStr_WindowFunction___delitem__(*args)
    def __init__(self, *args): 
        this = _kahakai.new_Map_CStr_WindowFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_Map_CStr_WindowFunction
    __del__ = lambda self : None;
Map_CStr_WindowFunction_swigregister = _kahakai.Map_CStr_WindowFunction_swigregister
Map_CStr_WindowFunction_swigregister(Map_CStr_WindowFunction)

class Map_CStr_ScreenFunction(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Map_CStr_ScreenFunction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Map_CStr_ScreenFunction, name)
    __repr__ = _swig_repr
    def __len__(*args): return _kahakai.Map_CStr_ScreenFunction___len__(*args)
    def __getitem__(*args): return _kahakai.Map_CStr_ScreenFunction___getitem__(*args)
    def __setitem__(*args): return _kahakai.Map_CStr_ScreenFunction___setitem__(*args)
    def __delitem__(*args): return _kahakai.Map_CStr_ScreenFunction___delitem__(*args)
    def __init__(self, *args): 
        this = _kahakai.new_Map_CStr_ScreenFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_Map_CStr_ScreenFunction
    __del__ = lambda self : None;
Map_CStr_ScreenFunction_swigregister = _kahakai.Map_CStr_ScreenFunction_swigregister
Map_CStr_ScreenFunction_swigregister(Map_CStr_ScreenFunction)

class Map_CStr_MenuFunction(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Map_CStr_MenuFunction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Map_CStr_MenuFunction, name)
    __repr__ = _swig_repr
    def __len__(*args): return _kahakai.Map_CStr_MenuFunction___len__(*args)
    def __getitem__(*args): return _kahakai.Map_CStr_MenuFunction___getitem__(*args)
    def __setitem__(*args): return _kahakai.Map_CStr_MenuFunction___setitem__(*args)
    def __delitem__(*args): return _kahakai.Map_CStr_MenuFunction___delitem__(*args)
    def __init__(self, *args): 
        this = _kahakai.new_Map_CStr_MenuFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_Map_CStr_MenuFunction
    __del__ = lambda self : None;
Map_CStr_MenuFunction_swigregister = _kahakai.Map_CStr_MenuFunction_swigregister
Map_CStr_MenuFunction_swigregister(Map_CStr_MenuFunction)

X_PROTOCOL = _kahakai.X_PROTOCOL
X_PROTOCOL_REVISION = _kahakai.X_PROTOCOL_REVISION
globals()["None"] = _kahakai.None
ParentRelative = _kahakai.ParentRelative
CopyFromParent = _kahakai.CopyFromParent
PointerWindow = _kahakai.PointerWindow
InputFocus = _kahakai.InputFocus
PointerRoot = _kahakai.PointerRoot
AnyPropertyType = _kahakai.AnyPropertyType
AnyKey = _kahakai.AnyKey
AnyButton = _kahakai.AnyButton
AllTemporary = _kahakai.AllTemporary
CurrentTime = _kahakai.CurrentTime
NoSymbol = _kahakai.NoSymbol
NoEventMask = _kahakai.NoEventMask
KeyPressMask = _kahakai.KeyPressMask
KeyReleaseMask = _kahakai.KeyReleaseMask
ButtonPressMask = _kahakai.ButtonPressMask
ButtonReleaseMask = _kahakai.ButtonReleaseMask
EnterWindowMask = _kahakai.EnterWindowMask
LeaveWindowMask = _kahakai.LeaveWindowMask
PointerMotionMask = _kahakai.PointerMotionMask
PointerMotionHintMask = _kahakai.PointerMotionHintMask
Button1MotionMask = _kahakai.Button1MotionMask
Button2MotionMask = _kahakai.Button2MotionMask
Button3MotionMask = _kahakai.Button3MotionMask
Button4MotionMask = _kahakai.Button4MotionMask
Button5MotionMask = _kahakai.Button5MotionMask
ButtonMotionMask = _kahakai.ButtonMotionMask
KeymapStateMask = _kahakai.KeymapStateMask
ExposureMask = _kahakai.ExposureMask
VisibilityChangeMask = _kahakai.VisibilityChangeMask
StructureNotifyMask = _kahakai.StructureNotifyMask
ResizeRedirectMask = _kahakai.ResizeRedirectMask
SubstructureNotifyMask = _kahakai.SubstructureNotifyMask
SubstructureRedirectMask = _kahakai.SubstructureRedirectMask
FocusChangeMask = _kahakai.FocusChangeMask
PropertyChangeMask = _kahakai.PropertyChangeMask
ColormapChangeMask = _kahakai.ColormapChangeMask
OwnerGrabButtonMask = _kahakai.OwnerGrabButtonMask
KeyPress = _kahakai.KeyPress
KeyRelease = _kahakai.KeyRelease
ButtonPress = _kahakai.ButtonPress
ButtonRelease = _kahakai.ButtonRelease
MotionNotify = _kahakai.MotionNotify
EnterNotify = _kahakai.EnterNotify
LeaveNotify = _kahakai.LeaveNotify
FocusIn = _kahakai.FocusIn
FocusOut = _kahakai.FocusOut
KeymapNotify = _kahakai.KeymapNotify
Expose = _kahakai.Expose
GraphicsExpose = _kahakai.GraphicsExpose
NoExpose = _kahakai.NoExpose
VisibilityNotify = _kahakai.VisibilityNotify
CreateNotify = _kahakai.CreateNotify
DestroyNotify = _kahakai.DestroyNotify
UnmapNotify = _kahakai.UnmapNotify
MapNotify = _kahakai.MapNotify
MapRequest = _kahakai.MapRequest
ReparentNotify = _kahakai.ReparentNotify
ConfigureNotify = _kahakai.ConfigureNotify
ConfigureRequest = _kahakai.ConfigureRequest
GravityNotify = _kahakai.GravityNotify
ResizeRequest = _kahakai.ResizeRequest
CirculateNotify = _kahakai.CirculateNotify
CirculateRequest = _kahakai.CirculateRequest
PropertyNotify = _kahakai.PropertyNotify
SelectionClear = _kahakai.SelectionClear
SelectionRequest = _kahakai.SelectionRequest
SelectionNotify = _kahakai.SelectionNotify
ColormapNotify = _kahakai.ColormapNotify
ClientMessage = _kahakai.ClientMessage
MappingNotify = _kahakai.MappingNotify
LASTEvent = _kahakai.LASTEvent
ShiftMask = _kahakai.ShiftMask
LockMask = _kahakai.LockMask
ControlMask = _kahakai.ControlMask
Mod1Mask = _kahakai.Mod1Mask
Mod2Mask = _kahakai.Mod2Mask
Mod3Mask = _kahakai.Mod3Mask
Mod4Mask = _kahakai.Mod4Mask
Mod5Mask = _kahakai.Mod5Mask
ShiftMapIndex = _kahakai.ShiftMapIndex
LockMapIndex = _kahakai.LockMapIndex
ControlMapIndex = _kahakai.ControlMapIndex
Mod1MapIndex = _kahakai.Mod1MapIndex
Mod2MapIndex = _kahakai.Mod2MapIndex
Mod3MapIndex = _kahakai.Mod3MapIndex
Mod4MapIndex = _kahakai.Mod4MapIndex
Mod5MapIndex = _kahakai.Mod5MapIndex
Button1Mask = _kahakai.Button1Mask
Button2Mask = _kahakai.Button2Mask
Button3Mask = _kahakai.Button3Mask
Button4Mask = _kahakai.Button4Mask
Button5Mask = _kahakai.Button5Mask
AnyModifier = _kahakai.AnyModifier
Button1 = _kahakai.Button1
Button2 = _kahakai.Button2
Button3 = _kahakai.Button3
Button4 = _kahakai.Button4
Button5 = _kahakai.Button5
NotifyNormal = _kahakai.NotifyNormal
NotifyGrab = _kahakai.NotifyGrab
NotifyUngrab = _kahakai.NotifyUngrab
NotifyWhileGrabbed = _kahakai.NotifyWhileGrabbed
NotifyHint = _kahakai.NotifyHint
NotifyAncestor = _kahakai.NotifyAncestor
NotifyVirtual = _kahakai.NotifyVirtual
NotifyInferior = _kahakai.NotifyInferior
NotifyNonlinear = _kahakai.NotifyNonlinear
NotifyNonlinearVirtual = _kahakai.NotifyNonlinearVirtual
NotifyPointer = _kahakai.NotifyPointer
NotifyPointerRoot = _kahakai.NotifyPointerRoot
NotifyDetailNone = _kahakai.NotifyDetailNone
VisibilityUnobscured = _kahakai.VisibilityUnobscured
VisibilityPartiallyObscured = _kahakai.VisibilityPartiallyObscured
VisibilityFullyObscured = _kahakai.VisibilityFullyObscured
PlaceOnTop = _kahakai.PlaceOnTop
PlaceOnBottom = _kahakai.PlaceOnBottom
FamilyInternet = _kahakai.FamilyInternet
FamilyDECnet = _kahakai.FamilyDECnet
FamilyChaos = _kahakai.FamilyChaos
FamilyInternet6 = _kahakai.FamilyInternet6
FamilyServerInterpreted = _kahakai.FamilyServerInterpreted
PropertyNewValue = _kahakai.PropertyNewValue
PropertyDelete = _kahakai.PropertyDelete
ColormapUninstalled = _kahakai.ColormapUninstalled
ColormapInstalled = _kahakai.ColormapInstalled
GrabModeSync = _kahakai.GrabModeSync
GrabModeAsync = _kahakai.GrabModeAsync
GrabSuccess = _kahakai.GrabSuccess
AlreadyGrabbed = _kahakai.AlreadyGrabbed
GrabInvalidTime = _kahakai.GrabInvalidTime
GrabNotViewable = _kahakai.GrabNotViewable
GrabFrozen = _kahakai.GrabFrozen
AsyncPointer = _kahakai.AsyncPointer
SyncPointer = _kahakai.SyncPointer
ReplayPointer = _kahakai.ReplayPointer
AsyncKeyboard = _kahakai.AsyncKeyboard
SyncKeyboard = _kahakai.SyncKeyboard
ReplayKeyboard = _kahakai.ReplayKeyboard
AsyncBoth = _kahakai.AsyncBoth
SyncBoth = _kahakai.SyncBoth
RevertToParent = _kahakai.RevertToParent
Success = _kahakai.Success
BadRequest = _kahakai.BadRequest
BadValue = _kahakai.BadValue
BadWindow = _kahakai.BadWindow
BadPixmap = _kahakai.BadPixmap
BadAtom = _kahakai.BadAtom
BadCursor = _kahakai.BadCursor
BadFont = _kahakai.BadFont
BadMatch = _kahakai.BadMatch
BadDrawable = _kahakai.BadDrawable
BadAccess = _kahakai.BadAccess
BadAlloc = _kahakai.BadAlloc
BadColor = _kahakai.BadColor
BadGC = _kahakai.BadGC
BadIDChoice = _kahakai.BadIDChoice
BadName = _kahakai.BadName
BadLength = _kahakai.BadLength
BadImplementation = _kahakai.BadImplementation
FirstExtensionError = _kahakai.FirstExtensionError
LastExtensionError = _kahakai.LastExtensionError
InputOutput = _kahakai.InputOutput
InputOnly = _kahakai.InputOnly
CWBackPixmap = _kahakai.CWBackPixmap
CWBackPixel = _kahakai.CWBackPixel
CWBorderPixmap = _kahakai.CWBorderPixmap
CWBorderPixel = _kahakai.CWBorderPixel
CWBitGravity = _kahakai.CWBitGravity
CWWinGravity = _kahakai.CWWinGravity
CWBackingStore = _kahakai.CWBackingStore
CWBackingPlanes = _kahakai.CWBackingPlanes
CWBackingPixel = _kahakai.CWBackingPixel
CWOverrideRedirect = _kahakai.CWOverrideRedirect
CWSaveUnder = _kahakai.CWSaveUnder
CWEventMask = _kahakai.CWEventMask
CWDontPropagate = _kahakai.CWDontPropagate
CWColormap = _kahakai.CWColormap
CWCursor = _kahakai.CWCursor
CWX = _kahakai.CWX
CWY = _kahakai.CWY
CWWidth = _kahakai.CWWidth
CWHeight = _kahakai.CWHeight
CWBorderWidth = _kahakai.CWBorderWidth
CWSibling = _kahakai.CWSibling
CWStackMode = _kahakai.CWStackMode
ForgetGravity = _kahakai.ForgetGravity
NorthWestGravity = _kahakai.NorthWestGravity
NorthGravity = _kahakai.NorthGravity
NorthEastGravity = _kahakai.NorthEastGravity
WestGravity = _kahakai.WestGravity
CenterGravity = _kahakai.CenterGravity
EastGravity = _kahakai.EastGravity
SouthWestGravity = _kahakai.SouthWestGravity
SouthGravity = _kahakai.SouthGravity
SouthEastGravity = _kahakai.SouthEastGravity
StaticGravity = _kahakai.StaticGravity
UnmapGravity = _kahakai.UnmapGravity
NotUseful = _kahakai.NotUseful
WhenMapped = _kahakai.WhenMapped
Always = _kahakai.Always
IsUnmapped = _kahakai.IsUnmapped
IsUnviewable = _kahakai.IsUnviewable
IsViewable = _kahakai.IsViewable
SetModeInsert = _kahakai.SetModeInsert
SetModeDelete = _kahakai.SetModeDelete
DestroyAll = _kahakai.DestroyAll
RetainPermanent = _kahakai.RetainPermanent
RetainTemporary = _kahakai.RetainTemporary
Above = _kahakai.Above
Below = _kahakai.Below
TopIf = _kahakai.TopIf
BottomIf = _kahakai.BottomIf
Opposite = _kahakai.Opposite
RaiseLowest = _kahakai.RaiseLowest
LowerHighest = _kahakai.LowerHighest
PropModeReplace = _kahakai.PropModeReplace
PropModePrepend = _kahakai.PropModePrepend
PropModeAppend = _kahakai.PropModeAppend
GXclear = _kahakai.GXclear
GXand = _kahakai.GXand
GXandReverse = _kahakai.GXandReverse
GXcopy = _kahakai.GXcopy
GXandInverted = _kahakai.GXandInverted
GXnoop = _kahakai.GXnoop
GXxor = _kahakai.GXxor
GXor = _kahakai.GXor
GXnor = _kahakai.GXnor
GXequiv = _kahakai.GXequiv
GXinvert = _kahakai.GXinvert
GXorReverse = _kahakai.GXorReverse
GXcopyInverted = _kahakai.GXcopyInverted
GXorInverted = _kahakai.GXorInverted
GXnand = _kahakai.GXnand
GXset = _kahakai.GXset
LineSolid = _kahakai.LineSolid
LineOnOffDash = _kahakai.LineOnOffDash
LineDoubleDash = _kahakai.LineDoubleDash
CapNotLast = _kahakai.CapNotLast
CapButt = _kahakai.CapButt
CapRound = _kahakai.CapRound
CapProjecting = _kahakai.CapProjecting
JoinMiter = _kahakai.JoinMiter
JoinRound = _kahakai.JoinRound
JoinBevel = _kahakai.JoinBevel
FillSolid = _kahakai.FillSolid
FillTiled = _kahakai.FillTiled
FillStippled = _kahakai.FillStippled
FillOpaqueStippled = _kahakai.FillOpaqueStippled
EvenOddRule = _kahakai.EvenOddRule
WindingRule = _kahakai.WindingRule
ClipByChildren = _kahakai.ClipByChildren
IncludeInferiors = _kahakai.IncludeInferiors
Unsorted = _kahakai.Unsorted
YSorted = _kahakai.YSorted
YXSorted = _kahakai.YXSorted
YXBanded = _kahakai.YXBanded
CoordModeOrigin = _kahakai.CoordModeOrigin
CoordModePrevious = _kahakai.CoordModePrevious
Complex = _kahakai.Complex
Nonconvex = _kahakai.Nonconvex
Convex = _kahakai.Convex
ArcChord = _kahakai.ArcChord
ArcPieSlice = _kahakai.ArcPieSlice
GCFunction = _kahakai.GCFunction
GCPlaneMask = _kahakai.GCPlaneMask
GCForeground = _kahakai.GCForeground
GCBackground = _kahakai.GCBackground
GCLineWidth = _kahakai.GCLineWidth
GCLineStyle = _kahakai.GCLineStyle
GCCapStyle = _kahakai.GCCapStyle
GCJoinStyle = _kahakai.GCJoinStyle
GCFillStyle = _kahakai.GCFillStyle
GCFillRule = _kahakai.GCFillRule
GCTile = _kahakai.GCTile
GCStipple = _kahakai.GCStipple
GCTileStipXOrigin = _kahakai.GCTileStipXOrigin
GCTileStipYOrigin = _kahakai.GCTileStipYOrigin
GCFont = _kahakai.GCFont
GCSubwindowMode = _kahakai.GCSubwindowMode
GCGraphicsExposures = _kahakai.GCGraphicsExposures
GCClipXOrigin = _kahakai.GCClipXOrigin
GCClipYOrigin = _kahakai.GCClipYOrigin
GCClipMask = _kahakai.GCClipMask
GCDashOffset = _kahakai.GCDashOffset
GCDashList = _kahakai.GCDashList
GCArcMode = _kahakai.GCArcMode
GCLastBit = _kahakai.GCLastBit
FontLeftToRight = _kahakai.FontLeftToRight
FontRightToLeft = _kahakai.FontRightToLeft
FontChange = _kahakai.FontChange
XYBitmap = _kahakai.XYBitmap
XYPixmap = _kahakai.XYPixmap
ZPixmap = _kahakai.ZPixmap
AllocNone = _kahakai.AllocNone
AllocAll = _kahakai.AllocAll
DoRed = _kahakai.DoRed
DoGreen = _kahakai.DoGreen
DoBlue = _kahakai.DoBlue
CursorShape = _kahakai.CursorShape
TileShape = _kahakai.TileShape
StippleShape = _kahakai.StippleShape
AutoRepeatModeOff = _kahakai.AutoRepeatModeOff
AutoRepeatModeOn = _kahakai.AutoRepeatModeOn
AutoRepeatModeDefault = _kahakai.AutoRepeatModeDefault
LedModeOff = _kahakai.LedModeOff
LedModeOn = _kahakai.LedModeOn
KBKeyClickPercent = _kahakai.KBKeyClickPercent
KBBellPercent = _kahakai.KBBellPercent
KBBellPitch = _kahakai.KBBellPitch
KBBellDuration = _kahakai.KBBellDuration
KBLed = _kahakai.KBLed
KBLedMode = _kahakai.KBLedMode
KBKey = _kahakai.KBKey
KBAutoRepeatMode = _kahakai.KBAutoRepeatMode
MappingSuccess = _kahakai.MappingSuccess
MappingBusy = _kahakai.MappingBusy
MappingFailed = _kahakai.MappingFailed
MappingModifier = _kahakai.MappingModifier
MappingKeyboard = _kahakai.MappingKeyboard
MappingPointer = _kahakai.MappingPointer
DontPreferBlanking = _kahakai.DontPreferBlanking
PreferBlanking = _kahakai.PreferBlanking
DefaultBlanking = _kahakai.DefaultBlanking
DisableScreenSaver = _kahakai.DisableScreenSaver
DisableScreenInterval = _kahakai.DisableScreenInterval
DontAllowExposures = _kahakai.DontAllowExposures
AllowExposures = _kahakai.AllowExposures
DefaultExposures = _kahakai.DefaultExposures
ScreenSaverReset = _kahakai.ScreenSaverReset
ScreenSaverActive = _kahakai.ScreenSaverActive
HostInsert = _kahakai.HostInsert
HostDelete = _kahakai.HostDelete
EnableAccess = _kahakai.EnableAccess
DisableAccess = _kahakai.DisableAccess
StaticGray = _kahakai.StaticGray
GrayScale = _kahakai.GrayScale
StaticColor = _kahakai.StaticColor
PseudoColor = _kahakai.PseudoColor
TrueColor = _kahakai.TrueColor
DirectColor = _kahakai.DirectColor
LSBFirst = _kahakai.LSBFirst
MSBFirst = _kahakai.MSBFirst
XStringToKeysym = _kahakai.XStringToKeysym
XKeysymToKeycode = _kahakai.XKeysymToKeycode
class KaFont(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KaFont, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KaFont, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_KaFont(*args)
        try: self.this.append(this)
        except: self.this = this
    def Open(*args): return _kahakai.KaFont_Open(*args)
    def AllocColor(*args): return _kahakai.KaFont_AllocColor(*args)
    def Draw(*args): return _kahakai.KaFont_Draw(*args)
    def Width(*args): return _kahakai.KaFont_Width(*args)
    __swig_setmethods__["xft"] = _kahakai.KaFont_xft_set
    __swig_getmethods__["xft"] = _kahakai.KaFont_xft_get
    if _newclass:xft = property(_kahakai.KaFont_xft_get, _kahakai.KaFont_xft_set)
    __swig_setmethods__["fontNames"] = _kahakai.KaFont_fontNames_set
    __swig_getmethods__["fontNames"] = _kahakai.KaFont_fontNames_get
    if _newclass:fontNames = property(_kahakai.KaFont_fontNames_get, _kahakai.KaFont_fontNames_set)
    __swig_setmethods__["gc"] = _kahakai.KaFont_gc_set
    __swig_getmethods__["gc"] = _kahakai.KaFont_gc_get
    if _newclass:gc = property(_kahakai.KaFont_gc_get, _kahakai.KaFont_gc_set)
    __swig_setmethods__["s_gc"] = _kahakai.KaFont_s_gc_set
    __swig_getmethods__["s_gc"] = _kahakai.KaFont_s_gc_get
    if _newclass:s_gc = property(_kahakai.KaFont_s_gc_get, _kahakai.KaFont_s_gc_set)
    __swig_setmethods__["xfont"] = _kahakai.KaFont_xfont_set
    __swig_getmethods__["xfont"] = _kahakai.KaFont_xfont_get
    if _newclass:xfont = property(_kahakai.KaFont_xfont_get, _kahakai.KaFont_xfont_set)
    __swig_setmethods__["font_ok"] = _kahakai.KaFont_font_ok_set
    __swig_getmethods__["font_ok"] = _kahakai.KaFont_font_ok_get
    if _newclass:font_ok = property(_kahakai.KaFont_font_ok_get, _kahakai.KaFont_font_ok_set)
    __swig_setmethods__["shadow_off_x"] = _kahakai.KaFont_shadow_off_x_set
    __swig_getmethods__["shadow_off_x"] = _kahakai.KaFont_shadow_off_x_get
    if _newclass:shadow_off_x = property(_kahakai.KaFont_shadow_off_x_get, _kahakai.KaFont_shadow_off_x_set)
    __swig_setmethods__["shadow_off_y"] = _kahakai.KaFont_shadow_off_y_set
    __swig_getmethods__["shadow_off_y"] = _kahakai.KaFont_shadow_off_y_get
    if _newclass:shadow_off_y = property(_kahakai.KaFont_shadow_off_y_get, _kahakai.KaFont_shadow_off_y_set)
    __swig_setmethods__["diff"] = _kahakai.KaFont_diff_set
    __swig_getmethods__["diff"] = _kahakai.KaFont_diff_get
    if _newclass:diff = property(_kahakai.KaFont_diff_get, _kahakai.KaFont_diff_set)
    __swig_setmethods__["xftfont"] = _kahakai.KaFont_xftfont_set
    __swig_getmethods__["xftfont"] = _kahakai.KaFont_xftfont_get
    if _newclass:xftfont = property(_kahakai.KaFont_xftfont_get, _kahakai.KaFont_xftfont_set)
    __swig_setmethods__["color"] = _kahakai.KaFont_color_set
    __swig_getmethods__["color"] = _kahakai.KaFont_color_get
    if _newclass:color = property(_kahakai.KaFont_color_get, _kahakai.KaFont_color_set)
    __swig_setmethods__["s_color"] = _kahakai.KaFont_s_color_set
    __swig_getmethods__["s_color"] = _kahakai.KaFont_s_color_get
    if _newclass:s_color = property(_kahakai.KaFont_s_color_get, _kahakai.KaFont_s_color_set)
    __swig_destroy__ = _kahakai.delete_KaFont
    __del__ = lambda self : None;
KaFont_swigregister = _kahakai.KaFont_swigregister
KaFont_swigregister(KaFont)

class EventDetail(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EventDetail, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EventDetail, name)
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _kahakai.EventDetail_type_set
    __swig_getmethods__["type"] = _kahakai.EventDetail_type_get
    if _newclass:type = property(_kahakai.EventDetail_type_get, _kahakai.EventDetail_type_set)
    __swig_setmethods__["mod"] = _kahakai.EventDetail_mod_set
    __swig_getmethods__["mod"] = _kahakai.EventDetail_mod_get
    if _newclass:mod = property(_kahakai.EventDetail_mod_get, _kahakai.EventDetail_mod_set)
    __swig_setmethods__["detail"] = _kahakai.EventDetail_detail_set
    __swig_getmethods__["detail"] = _kahakai.EventDetail_detail_get
    if _newclass:detail = property(_kahakai.EventDetail_detail_get, _kahakai.EventDetail_detail_set)
    def __init__(self, *args): 
        this = _kahakai.new_EventDetail(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_EventDetail
    __del__ = lambda self : None;
EventDetail_swigregister = _kahakai.EventDetail_swigregister
EventDetail_swigregister(EventDetail)

MoveResizeMask = _kahakai.MoveResizeMask
DoubleClick = _kahakai.DoubleClick
class Function(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Function, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Function, name)
    __repr__ = _swig_repr
    __swig_setmethods__["requiresParameter"] = _kahakai.Function_requiresParameter_set
    __swig_getmethods__["requiresParameter"] = _kahakai.Function_requiresParameter_get
    if _newclass:requiresParameter = property(_kahakai.Function_requiresParameter_get, _kahakai.Function_requiresParameter_set)
    def __init__(self, *args): 
        this = _kahakai.new_Function(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_Function
    __del__ = lambda self : None;
Function_swigregister = _kahakai.Function_swigregister
Function_swigregister(Function)
eventmatch = _kahakai.eventmatch

class WindowFunction(Function):
    __swig_setmethods__ = {}
    for _s in [Function]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [Function]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowFunction, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def __call__(*args): return _kahakai.WindowFunction___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowFunction
    __del__ = lambda self : None;
WindowFunction_swigregister = _kahakai.WindowFunction_swigregister
WindowFunction_swigregister(WindowFunction)

class MenuFunction(Function):
    __swig_setmethods__ = {}
    for _s in [Function]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [Function]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuFunction, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def __call__(*args): return _kahakai.MenuFunction___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuFunction
    __del__ = lambda self : None;
MenuFunction_swigregister = _kahakai.MenuFunction_swigregister
MenuFunction_swigregister(MenuFunction)

class ScreenFunction(MenuFunction,WindowFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction,WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction,WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenFunction, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def __call__(*args): return _kahakai.ScreenFunction___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenFunction
    __del__ = lambda self : None;
ScreenFunction_swigregister = _kahakai.ScreenFunction_swigregister
ScreenFunction_swigregister(ScreenFunction)

class SimpleFunction(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimpleFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, SimpleFunction, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def __call__(*args): return _kahakai.SimpleFunction___call__(*args)
    __swig_destroy__ = _kahakai.delete_SimpleFunction
    __del__ = lambda self : None;
SimpleFunction_swigregister = _kahakai.SimpleFunction_swigregister
SimpleFunction_swigregister(SimpleFunction)

ApplyGravity = _kahakai.ApplyGravity
RemoveGravity = _kahakai.RemoveGravity
class SizeStruct(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SizeStruct, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SizeStruct, name)
    __repr__ = _swig_repr
    __swig_setmethods__["max_width"] = _kahakai.SizeStruct_max_width_set
    __swig_getmethods__["max_width"] = _kahakai.SizeStruct_max_width_get
    if _newclass:max_width = property(_kahakai.SizeStruct_max_width_get, _kahakai.SizeStruct_max_width_set)
    __swig_setmethods__["max_height"] = _kahakai.SizeStruct_max_height_set
    __swig_getmethods__["max_height"] = _kahakai.SizeStruct_max_height_get
    if _newclass:max_height = property(_kahakai.SizeStruct_max_height_get, _kahakai.SizeStruct_max_height_set)
    __swig_setmethods__["min_width"] = _kahakai.SizeStruct_min_width_set
    __swig_getmethods__["min_width"] = _kahakai.SizeStruct_min_width_get
    if _newclass:min_width = property(_kahakai.SizeStruct_min_width_get, _kahakai.SizeStruct_min_width_set)
    __swig_setmethods__["min_height"] = _kahakai.SizeStruct_min_height_set
    __swig_getmethods__["min_height"] = _kahakai.SizeStruct_min_height_get
    if _newclass:min_height = property(_kahakai.SizeStruct_min_height_get, _kahakai.SizeStruct_min_height_set)
    __swig_setmethods__["width_inc"] = _kahakai.SizeStruct_width_inc_set
    __swig_getmethods__["width_inc"] = _kahakai.SizeStruct_width_inc_get
    if _newclass:width_inc = property(_kahakai.SizeStruct_width_inc_get, _kahakai.SizeStruct_width_inc_set)
    __swig_setmethods__["height_inc"] = _kahakai.SizeStruct_height_inc_set
    __swig_getmethods__["height_inc"] = _kahakai.SizeStruct_height_inc_get
    if _newclass:height_inc = property(_kahakai.SizeStruct_height_inc_get, _kahakai.SizeStruct_height_inc_set)
    __swig_setmethods__["base_width"] = _kahakai.SizeStruct_base_width_set
    __swig_getmethods__["base_width"] = _kahakai.SizeStruct_base_width_get
    if _newclass:base_width = property(_kahakai.SizeStruct_base_width_get, _kahakai.SizeStruct_base_width_set)
    __swig_setmethods__["base_height"] = _kahakai.SizeStruct_base_height_set
    __swig_getmethods__["base_height"] = _kahakai.SizeStruct_base_height_get
    if _newclass:base_height = property(_kahakai.SizeStruct_base_height_get, _kahakai.SizeStruct_base_height_set)
    __swig_setmethods__["win_gravity"] = _kahakai.SizeStruct_win_gravity_set
    __swig_getmethods__["win_gravity"] = _kahakai.SizeStruct_win_gravity_get
    if _newclass:win_gravity = property(_kahakai.SizeStruct_win_gravity_get, _kahakai.SizeStruct_win_gravity_set)
    def __init__(self, *args): 
        this = _kahakai.new_SizeStruct(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_SizeStruct
    __del__ = lambda self : None;
SizeStruct_swigregister = _kahakai.SizeStruct_swigregister
SizeStruct_swigregister(SizeStruct)

class KaWindowFlags(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KaWindowFlags, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KaWindowFlags, name)
    __repr__ = _swig_repr
    __swig_setmethods__["title"] = _kahakai.KaWindowFlags_title_set
    __swig_getmethods__["title"] = _kahakai.KaWindowFlags_title_get
    if _newclass:title = property(_kahakai.KaWindowFlags_title_get, _kahakai.KaWindowFlags_title_set)
    __swig_setmethods__["border"] = _kahakai.KaWindowFlags_border_set
    __swig_getmethods__["border"] = _kahakai.KaWindowFlags_border_get
    if _newclass:border = property(_kahakai.KaWindowFlags_border_get, _kahakai.KaWindowFlags_border_set)
    __swig_setmethods__["handle"] = _kahakai.KaWindowFlags_handle_set
    __swig_getmethods__["handle"] = _kahakai.KaWindowFlags_handle_get
    if _newclass:handle = property(_kahakai.KaWindowFlags_handle_get, _kahakai.KaWindowFlags_handle_set)
    __swig_setmethods__["sticky"] = _kahakai.KaWindowFlags_sticky_set
    __swig_getmethods__["sticky"] = _kahakai.KaWindowFlags_sticky_get
    if _newclass:sticky = property(_kahakai.KaWindowFlags_sticky_get, _kahakai.KaWindowFlags_sticky_set)
    __swig_setmethods__["shaded"] = _kahakai.KaWindowFlags_shaded_set
    __swig_getmethods__["shaded"] = _kahakai.KaWindowFlags_shaded_get
    if _newclass:shaded = property(_kahakai.KaWindowFlags_shaded_get, _kahakai.KaWindowFlags_shaded_set)
    __swig_setmethods__["wmax"] = _kahakai.KaWindowFlags_wmax_set
    __swig_getmethods__["wmax"] = _kahakai.KaWindowFlags_wmax_get
    if _newclass:wmax = property(_kahakai.KaWindowFlags_wmax_get, _kahakai.KaWindowFlags_wmax_set)
    __swig_setmethods__["hmax"] = _kahakai.KaWindowFlags_hmax_set
    __swig_getmethods__["hmax"] = _kahakai.KaWindowFlags_hmax_get
    if _newclass:hmax = property(_kahakai.KaWindowFlags_hmax_get, _kahakai.KaWindowFlags_hmax_set)
    __swig_setmethods__["vmax"] = _kahakai.KaWindowFlags_vmax_set
    __swig_getmethods__["vmax"] = _kahakai.KaWindowFlags_vmax_get
    if _newclass:vmax = property(_kahakai.KaWindowFlags_vmax_get, _kahakai.KaWindowFlags_vmax_set)
    __swig_setmethods__["all"] = _kahakai.KaWindowFlags_all_set
    __swig_getmethods__["all"] = _kahakai.KaWindowFlags_all_get
    if _newclass:all = property(_kahakai.KaWindowFlags_all_get, _kahakai.KaWindowFlags_all_set)
    __swig_setmethods__["alwaysontop"] = _kahakai.KaWindowFlags_alwaysontop_set
    __swig_getmethods__["alwaysontop"] = _kahakai.KaWindowFlags_alwaysontop_get
    if _newclass:alwaysontop = property(_kahakai.KaWindowFlags_alwaysontop_get, _kahakai.KaWindowFlags_alwaysontop_set)
    __swig_setmethods__["alwaysatbottom"] = _kahakai.KaWindowFlags_alwaysatbottom_set
    __swig_getmethods__["alwaysatbottom"] = _kahakai.KaWindowFlags_alwaysatbottom_get
    if _newclass:alwaysatbottom = property(_kahakai.KaWindowFlags_alwaysatbottom_get, _kahakai.KaWindowFlags_alwaysatbottom_set)
    __swig_setmethods__["focusable"] = _kahakai.KaWindowFlags_focusable_set
    __swig_getmethods__["focusable"] = _kahakai.KaWindowFlags_focusable_get
    if _newclass:focusable = property(_kahakai.KaWindowFlags_focusable_get, _kahakai.KaWindowFlags_focusable_set)
    __swig_setmethods__["tasklist"] = _kahakai.KaWindowFlags_tasklist_set
    __swig_getmethods__["tasklist"] = _kahakai.KaWindowFlags_tasklist_get
    if _newclass:tasklist = property(_kahakai.KaWindowFlags_tasklist_get, _kahakai.KaWindowFlags_tasklist_set)
    __swig_setmethods__["fullscreen"] = _kahakai.KaWindowFlags_fullscreen_set
    __swig_getmethods__["fullscreen"] = _kahakai.KaWindowFlags_fullscreen_get
    if _newclass:fullscreen = property(_kahakai.KaWindowFlags_fullscreen_get, _kahakai.KaWindowFlags_fullscreen_set)
    __swig_setmethods__["hidden"] = _kahakai.KaWindowFlags_hidden_set
    __swig_getmethods__["hidden"] = _kahakai.KaWindowFlags_hidden_get
    if _newclass:hidden = property(_kahakai.KaWindowFlags_hidden_get, _kahakai.KaWindowFlags_hidden_set)
    def __init__(self, *args): 
        this = _kahakai.new_KaWindowFlags(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_KaWindowFlags
    __del__ = lambda self : None;
KaWindowFlags_swigregister = _kahakai.KaWindowFlags_swigregister
KaWindowFlags_swigregister(KaWindowFlags)

DesktopWindowType = _kahakai.DesktopWindowType
ToolbarWindowType = _kahakai.ToolbarWindowType
DockWindowType = _kahakai.DockWindowType
SplashWindowType = _kahakai.SplashWindowType
MenuWindowType = _kahakai.MenuWindowType
OtherWindowType = _kahakai.OtherWindowType
class KaWindow(WindowObject):
    __swig_setmethods__ = {}
    for _s in [WindowObject]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, KaWindow, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowObject]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, KaWindow, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_KaWindow(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_KaWindow
    __del__ = lambda self : None;
    def GetFrameLeft(*args): return _kahakai.KaWindow_GetFrameLeft(*args)
    def GetFrameTop(*args): return _kahakai.KaWindow_GetFrameTop(*args)
    def GetFrameBottom(*args): return _kahakai.KaWindow_GetFrameBottom(*args)
    def GetFrameRight(*args): return _kahakai.KaWindow_GetFrameRight(*args)
    def GetFrameWidth(*args): return _kahakai.KaWindow_GetFrameWidth(*args)
    def GetFrameHeight(*args): return _kahakai.KaWindow_GetFrameHeight(*args)
    def SetFrameLeft(*args): return _kahakai.KaWindow_SetFrameLeft(*args)
    def SetFrameRight(*args): return _kahakai.KaWindow_SetFrameRight(*args)
    def SetFrameTop(*args): return _kahakai.KaWindow_SetFrameTop(*args)
    def SetFrameBottom(*args): return _kahakai.KaWindow_SetFrameBottom(*args)
    def SetFrameWidth(*args): return _kahakai.KaWindow_SetFrameWidth(*args)
    def SetFrameHeight(*args): return _kahakai.KaWindow_SetFrameHeight(*args)
    def OnCurrentDesktop(*args): return _kahakai.KaWindow_OnCurrentDesktop(*args)
    def Show(*args): return _kahakai.KaWindow_Show(*args)
    def Hide(*args): return _kahakai.KaWindow_Hide(*args)
    def RedrawWindow(*args): return _kahakai.KaWindow_RedrawWindow(*args)
    def SendConfig(*args): return _kahakai.KaWindow_SendConfig(*args)
    def Gravitate(*args): return _kahakai.KaWindow_Gravitate(*args)
    def UpdateGrabs(*args): return _kahakai.KaWindow_UpdateGrabs(*args)
    def ButtonPressed(*args): return _kahakai.KaWindow_ButtonPressed(*args)
    def IncSizeCheck(*args): return _kahakai.KaWindow_IncSizeCheck(*args)
    def IncFrameSizeCheck(*args): return _kahakai.KaWindow_IncFrameSizeCheck(*args)
    def IncSizeEnforce(*args): return _kahakai.KaWindow_IncSizeEnforce(*args)
    def IsHorizontallyVisible(*args): return _kahakai.KaWindow_IsHorizontallyVisible(*args)
    def IsVerticallyVisible(*args): return _kahakai.KaWindow_IsVerticallyVisible(*args)
    def DrawTitlebar(*args): return _kahakai.KaWindow_DrawTitlebar(*args)
    def DrawHandlebar(*args): return _kahakai.KaWindow_DrawHandlebar(*args)
    def DrawEdges(*args): return _kahakai.KaWindow_DrawEdges(*args)
    def FocusWin(*args): return _kahakai.KaWindow_FocusWin(*args)
    def UnFocusWin(*args): return _kahakai.KaWindow_UnFocusWin(*args)
    def Focus(*args): return _kahakai.KaWindow_Focus(*args)
    def _Maximize(*args): return _kahakai.KaWindow__Maximize(*args)
    def Shape(*args): return _kahakai.KaWindow_Shape(*args)
    def ShapeEvent(*args): return _kahakai.KaWindow_ShapeEvent(*args)
    def Raise(*args): return _kahakai.KaWindow_Raise(*args)
    def Lower(*args): return _kahakai.KaWindow_Lower(*args)
    def FocusVis(*args): return _kahakai.KaWindow_FocusVis(*args)
    def Move(*args): return _kahakai.KaWindow_Move(*args)
    def MoveOpaque(*args): return _kahakai.KaWindow_MoveOpaque(*args)
    def ResizeRight(*args): return _kahakai.KaWindow_ResizeRight(*args)
    def ResizeLeft(*args): return _kahakai.KaWindow_ResizeLeft(*args)
    def ResizeRightOpaque(*args): return _kahakai.KaWindow_ResizeRightOpaque(*args)
    def ResizeLeftOpaque(*args): return _kahakai.KaWindow_ResizeLeftOpaque(*args)
    def Resize(*args): return _kahakai.KaWindow_Resize(*args)
    def ResizeOpaque(*args): return _kahakai.KaWindow_ResizeOpaque(*args)
    def ResizeNorthWest(*args): return _kahakai.KaWindow_ResizeNorthWest(*args)
    def ResizeNorthEast(*args): return _kahakai.KaWindow_ResizeNorthEast(*args)
    def ResizeSouthWest(*args): return _kahakai.KaWindow_ResizeSouthWest(*args)
    def ResizeSouthEast(*args): return _kahakai.KaWindow_ResizeSouthEast(*args)
    def SmartResize(*args): return _kahakai.KaWindow_SmartResize(*args)
    def SmartResizeOpaque(*args): return _kahakai.KaWindow_SmartResizeOpaque(*args)
    def EndMoveResize(*args): return _kahakai.KaWindow_EndMoveResize(*args)
    def Maximize(*args): return _kahakai.KaWindow_Maximize(*args)
    def MaximizeHorizontally(*args): return _kahakai.KaWindow_MaximizeHorizontally(*args)
    def MaximizeVertically(*args): return _kahakai.KaWindow_MaximizeVertically(*args)
    def UnMaximize(*args): return _kahakai.KaWindow_UnMaximize(*args)
    def ToggleMaximize(*args): return _kahakai.KaWindow_ToggleMaximize(*args)
    def ToggleMaximizeVertically(*args): return _kahakai.KaWindow_ToggleMaximizeVertically(*args)
    def ToggleMaximizeHorizontally(*args): return _kahakai.KaWindow_ToggleMaximizeHorizontally(*args)
    def Close(*args): return _kahakai.KaWindow_Close(*args)
    def Kill(*args): return _kahakai.KaWindow_Kill(*args)
    def CloseKill(*args): return _kahakai.KaWindow_CloseKill(*args)
    def MenuMap(*args): return _kahakai.KaWindow_MenuMap(*args)
    def MenuMapFocused(*args): return _kahakai.KaWindow_MenuMapFocused(*args)
    def MenuRemap(*args): return _kahakai.KaWindow_MenuRemap(*args)
    def MenuRemapFocused(*args): return _kahakai.KaWindow_MenuRemapFocused(*args)
    def MenuUnmap(*args): return _kahakai.KaWindow_MenuUnmap(*args)
    def MenuUnmapFocus(*args): return _kahakai.KaWindow_MenuUnmapFocus(*args)
    def SkipTaskList(*args): return _kahakai.KaWindow_SkipTaskList(*args)
    def Shade(*args): return _kahakai.KaWindow_Shade(*args)
    def UnShade(*args): return _kahakai.KaWindow_UnShade(*args)
    def ToggleShade(*args): return _kahakai.KaWindow_ToggleShade(*args)
    def Sticky(*args): return _kahakai.KaWindow_Sticky(*args)
    def UnSticky(*args): return _kahakai.KaWindow_UnSticky(*args)
    def ToggleSticky(*args): return _kahakai.KaWindow_ToggleSticky(*args)
    def Minimize(*args): return _kahakai.KaWindow_Minimize(*args)
    def UnMinimize(*args): return _kahakai.KaWindow_UnMinimize(*args)
    def ToggleMinimize(*args): return _kahakai.KaWindow_ToggleMinimize(*args)
    def ToggleMinimizeActive(*args): return _kahakai.KaWindow_ToggleMinimizeActive(*args)
    def FullscreenOn(*args): return _kahakai.KaWindow_FullscreenOn(*args)
    def FullscreenOff(*args): return _kahakai.KaWindow_FullscreenOff(*args)
    def FullscreenToggle(*args): return _kahakai.KaWindow_FullscreenToggle(*args)
    def DecorTitleOn(*args): return _kahakai.KaWindow_DecorTitleOn(*args)
    def DecorHandleOn(*args): return _kahakai.KaWindow_DecorHandleOn(*args)
    def DecorBorderOn(*args): return _kahakai.KaWindow_DecorBorderOn(*args)
    def DecorAllOn(*args): return _kahakai.KaWindow_DecorAllOn(*args)
    def DecorTitleOff(*args): return _kahakai.KaWindow_DecorTitleOff(*args)
    def DecorHandleOff(*args): return _kahakai.KaWindow_DecorHandleOff(*args)
    def DecorBorderOff(*args): return _kahakai.KaWindow_DecorBorderOff(*args)
    def DecorAllOff(*args): return _kahakai.KaWindow_DecorAllOff(*args)
    def DecorTitleToggle(*args): return _kahakai.KaWindow_DecorTitleToggle(*args)
    def DecorHandleToggle(*args): return _kahakai.KaWindow_DecorHandleToggle(*args)
    def DecorBorderToggle(*args): return _kahakai.KaWindow_DecorBorderToggle(*args)
    def DecorAllToggle(*args): return _kahakai.KaWindow_DecorAllToggle(*args)
    def AlwaysontopOn(*args): return _kahakai.KaWindow_AlwaysontopOn(*args)
    def AlwaysatbottomOn(*args): return _kahakai.KaWindow_AlwaysatbottomOn(*args)
    def AlwaysontopOff(*args): return _kahakai.KaWindow_AlwaysontopOff(*args)
    def AlwaysatbottomOff(*args): return _kahakai.KaWindow_AlwaysatbottomOff(*args)
    def AlwaysontopToggle(*args): return _kahakai.KaWindow_AlwaysontopToggle(*args)
    def AlwaysatbottomToggle(*args): return _kahakai.KaWindow_AlwaysatbottomToggle(*args)
    def AcceptConfigRequestOn(*args): return _kahakai.KaWindow_AcceptConfigRequestOn(*args)
    def AcceptConfigRequestOff(*args): return _kahakai.KaWindow_AcceptConfigRequestOff(*args)
    def AcceptConfigRequestToggle(*args): return _kahakai.KaWindow_AcceptConfigRequestToggle(*args)
    def RaiseFocus(*args): return _kahakai.KaWindow_RaiseFocus(*args)
    def MoveResize(*args): return _kahakai.KaWindow_MoveResize(*args)
    def MoveResizeVirtual(*args): return _kahakai.KaWindow_MoveResizeVirtual(*args)
    def MoveWindowToPointer(*args): return _kahakai.KaWindow_MoveWindowToPointer(*args)
    def MoveWindowBy(*args): return _kahakai.KaWindow_MoveWindowBy(*args)
    def MoveWindowToSmartPlace(*args): return _kahakai.KaWindow_MoveWindowToSmartPlace(*args)
    def SmartPlaceLeftToRight(*args): return _kahakai.KaWindow_SmartPlaceLeftToRight(*args)
    def MoveWindowToViewport(*args): return _kahakai.KaWindow_MoveWindowToViewport(*args)
    def MoveWindowToCurrentViewport(*args): return _kahakai.KaWindow_MoveWindowToCurrentViewport(*args)
    def CenterOverParent(*args): return _kahakai.KaWindow_CenterOverParent(*args)
    def moveToSmartPlaceIfUninitialized(*args): return _kahakai.KaWindow_moveToSmartPlaceIfUninitialized(*args)
    def UpdateStack(*args): return _kahakai.KaWindow_UpdateStack(*args)
    def DesktopMask(*args): return _kahakai.KaWindow_DesktopMask(*args)
    def JoinDesktop(*args): return _kahakai.KaWindow_JoinDesktop(*args)
    def PartCurrentJoinDesktop(*args): return _kahakai.KaWindow_PartCurrentJoinDesktop(*args)
    def PartDesktop(*args): return _kahakai.KaWindow_PartDesktop(*args)
    def PartCurrentDesktop(*args): return _kahakai.KaWindow_PartCurrentDesktop(*args)
    def JoinCurrentDesktop(*args): return _kahakai.KaWindow_JoinCurrentDesktop(*args)
    def JoinAllDesktops(*args): return _kahakai.KaWindow_JoinAllDesktops(*args)
    def PartAllDesktopsExceptCurrent(*args): return _kahakai.KaWindow_PartAllDesktopsExceptCurrent(*args)
    def Nop(*args): return _kahakai.KaWindow_Nop(*args)
    def UpdateButtons(*args): return _kahakai.KaWindow_UpdateButtons(*args)
    def UpdateTitlebar(*args): return _kahakai.KaWindow_UpdateTitlebar(*args)
    def updateDecorations(*args): return _kahakai.KaWindow_updateDecorations(*args)
    def EvAct(*args): return _kahakai.KaWindow_EvAct(*args)
    __swig_setmethods__["labeltext"] = _kahakai.KaWindow_labeltext_set
    __swig_getmethods__["labeltext"] = _kahakai.KaWindow_labeltext_get
    if _newclass:labeltext = property(_kahakai.KaWindow_labeltext_get, _kahakai.KaWindow_labeltext_set)
    __swig_setmethods__["name"] = _kahakai.KaWindow_name_set
    __swig_getmethods__["name"] = _kahakai.KaWindow_name_get
    if _newclass:name = property(_kahakai.KaWindow_name_get, _kahakai.KaWindow_name_set)
    __swig_setmethods__["realname"] = _kahakai.KaWindow_realname_set
    __swig_getmethods__["realname"] = _kahakai.KaWindow_realname_get
    if _newclass:realname = property(_kahakai.KaWindow_realname_get, _kahakai.KaWindow_realname_set)
    __swig_setmethods__["smartnum"] = _kahakai.KaWindow_smartnum_set
    __swig_getmethods__["smartnum"] = _kahakai.KaWindow_smartnum_get
    if _newclass:smartnum = property(_kahakai.KaWindow_smartnum_get, _kahakai.KaWindow_smartnum_set)
    __swig_setmethods__["host"] = _kahakai.KaWindow_host_set
    __swig_getmethods__["host"] = _kahakai.KaWindow_host_get
    if _newclass:host = property(_kahakai.KaWindow_host_get, _kahakai.KaWindow_host_set)
    __swig_setmethods__["pid"] = _kahakai.KaWindow_pid_set
    __swig_getmethods__["pid"] = _kahakai.KaWindow_pid_get
    if _newclass:pid = property(_kahakai.KaWindow_pid_get, _kahakai.KaWindow_pid_set)
    __swig_setmethods__["realnamelen"] = _kahakai.KaWindow_realnamelen_set
    __swig_getmethods__["realnamelen"] = _kahakai.KaWindow_realnamelen_get
    if _newclass:realnamelen = property(_kahakai.KaWindow_realnamelen_get, _kahakai.KaWindow_realnamelen_set)
    __swig_setmethods__["has_focus"] = _kahakai.KaWindow_has_focus_set
    __swig_getmethods__["has_focus"] = _kahakai.KaWindow_has_focus_get
    if _newclass:has_focus = property(_kahakai.KaWindow_has_focus_get, _kahakai.KaWindow_has_focus_set)
    __swig_setmethods__["want_focus"] = _kahakai.KaWindow_want_focus_set
    __swig_getmethods__["want_focus"] = _kahakai.KaWindow_want_focus_get
    if _newclass:want_focus = property(_kahakai.KaWindow_want_focus_get, _kahakai.KaWindow_want_focus_set)
    __swig_setmethods__["mapped"] = _kahakai.KaWindow_mapped_set
    __swig_getmethods__["mapped"] = _kahakai.KaWindow_mapped_get
    if _newclass:mapped = property(_kahakai.KaWindow_mapped_get, _kahakai.KaWindow_mapped_set)
    __swig_setmethods__["dontsend"] = _kahakai.KaWindow_dontsend_set
    __swig_getmethods__["dontsend"] = _kahakai.KaWindow_dontsend_get
    if _newclass:dontsend = property(_kahakai.KaWindow_dontsend_get, _kahakai.KaWindow_dontsend_set)
    __swig_setmethods__["deleted"] = _kahakai.KaWindow_deleted_set
    __swig_getmethods__["deleted"] = _kahakai.KaWindow_deleted_get
    if _newclass:deleted = property(_kahakai.KaWindow_deleted_get, _kahakai.KaWindow_deleted_set)
    __swig_setmethods__["ign_config_req"] = _kahakai.KaWindow_ign_config_req_set
    __swig_getmethods__["ign_config_req"] = _kahakai.KaWindow_ign_config_req_get
    if _newclass:ign_config_req = property(_kahakai.KaWindow_ign_config_req_get, _kahakai.KaWindow_ign_config_req_set)
    __swig_setmethods__["hidden"] = _kahakai.KaWindow_hidden_set
    __swig_getmethods__["hidden"] = _kahakai.KaWindow_hidden_get
    if _newclass:hidden = property(_kahakai.KaWindow_hidden_get, _kahakai.KaWindow_hidden_set)
    __swig_setmethods__["move_resize"] = _kahakai.KaWindow_move_resize_set
    __swig_getmethods__["move_resize"] = _kahakai.KaWindow_move_resize_get
    if _newclass:move_resize = property(_kahakai.KaWindow_move_resize_get, _kahakai.KaWindow_move_resize_set)
    __swig_setmethods__["display"] = _kahakai.KaWindow_display_set
    __swig_getmethods__["display"] = _kahakai.KaWindow_display_get
    if _newclass:display = property(_kahakai.KaWindow_display_get, _kahakai.KaWindow_display_set)
    __swig_setmethods__["kahakai"] = _kahakai.KaWindow_kahakai_set
    __swig_getmethods__["kahakai"] = _kahakai.KaWindow_kahakai_get
    if _newclass:kahakai = property(_kahakai.KaWindow_kahakai_get, _kahakai.KaWindow_kahakai_set)
    __swig_setmethods__["kascreen"] = _kahakai.KaWindow_kascreen_set
    __swig_getmethods__["kascreen"] = _kahakai.KaWindow_kascreen_get
    if _newclass:kascreen = property(_kahakai.KaWindow_kascreen_get, _kahakai.KaWindow_kascreen_set)
    __swig_setmethods__["border_w"] = _kahakai.KaWindow_border_w_set
    __swig_getmethods__["border_w"] = _kahakai.KaWindow_border_w_get
    if _newclass:border_w = property(_kahakai.KaWindow_border_w_get, _kahakai.KaWindow_border_w_set)
    __swig_setmethods__["title_w"] = _kahakai.KaWindow_title_w_set
    __swig_getmethods__["title_w"] = _kahakai.KaWindow_title_w_get
    if _newclass:title_w = property(_kahakai.KaWindow_title_w_get, _kahakai.KaWindow_title_w_set)
    __swig_setmethods__["handle_w"] = _kahakai.KaWindow_handle_w_set
    __swig_getmethods__["handle_w"] = _kahakai.KaWindow_handle_w_get
    if _newclass:handle_w = property(_kahakai.KaWindow_handle_w_get, _kahakai.KaWindow_handle_w_set)
    __swig_setmethods__["left_w"] = _kahakai.KaWindow_left_w_set
    __swig_getmethods__["left_w"] = _kahakai.KaWindow_left_w_get
    if _newclass:left_w = property(_kahakai.KaWindow_left_w_get, _kahakai.KaWindow_left_w_set)
    __swig_setmethods__["right_w"] = _kahakai.KaWindow_right_w_set
    __swig_getmethods__["right_w"] = _kahakai.KaWindow_right_w_get
    if _newclass:right_w = property(_kahakai.KaWindow_right_w_get, _kahakai.KaWindow_right_w_set)
    __swig_setmethods__["screen_number"] = _kahakai.KaWindow_screen_number_set
    __swig_getmethods__["screen_number"] = _kahakai.KaWindow_screen_number_get
    if _newclass:screen_number = property(_kahakai.KaWindow_screen_number_get, _kahakai.KaWindow_screen_number_set)
    __swig_setmethods__["state"] = _kahakai.KaWindow_state_set
    __swig_getmethods__["state"] = _kahakai.KaWindow_state_get
    if _newclass:state = property(_kahakai.KaWindow_state_get, _kahakai.KaWindow_state_set)
    __swig_setmethods__["frame"] = _kahakai.KaWindow_frame_set
    __swig_getmethods__["frame"] = _kahakai.KaWindow_frame_get
    if _newclass:frame = property(_kahakai.KaWindow_frame_get, _kahakai.KaWindow_frame_set)
    __swig_setmethods__["label"] = _kahakai.KaWindow_label_set
    __swig_getmethods__["label"] = _kahakai.KaWindow_label_get
    if _newclass:label = property(_kahakai.KaWindow_label_get, _kahakai.KaWindow_label_set)
    __swig_setmethods__["title"] = _kahakai.KaWindow_title_set
    __swig_getmethods__["title"] = _kahakai.KaWindow_title_get
    if _newclass:title = property(_kahakai.KaWindow_title_get, _kahakai.KaWindow_title_set)
    __swig_setmethods__["buttons"] = _kahakai.KaWindow_buttons_set
    __swig_getmethods__["buttons"] = _kahakai.KaWindow_buttons_get
    if _newclass:buttons = property(_kahakai.KaWindow_buttons_get, _kahakai.KaWindow_buttons_set)
    __swig_setmethods__["attrib"] = _kahakai.KaWindow_attrib_set
    __swig_getmethods__["attrib"] = _kahakai.KaWindow_attrib_get
    if _newclass:attrib = property(_kahakai.KaWindow_attrib_get, _kahakai.KaWindow_attrib_set)
    __swig_setmethods__["restore_max_attrib"] = _kahakai.KaWindow_restore_max_attrib_set
    __swig_getmethods__["restore_max_attrib"] = _kahakai.KaWindow_restore_max_attrib_get
    if _newclass:restore_max_attrib = property(_kahakai.KaWindow_restore_max_attrib_get, _kahakai.KaWindow_restore_max_attrib_set)
    __swig_setmethods__["flags"] = _kahakai.KaWindow_flags_set
    __swig_getmethods__["flags"] = _kahakai.KaWindow_flags_get
    if _newclass:flags = property(_kahakai.KaWindow_flags_get, _kahakai.KaWindow_flags_set)
    __swig_setmethods__["restore_max_flags"] = _kahakai.KaWindow_restore_max_flags_set
    __swig_getmethods__["restore_max_flags"] = _kahakai.KaWindow_restore_max_flags_get
    if _newclass:restore_max_flags = property(_kahakai.KaWindow_restore_max_flags_get, _kahakai.KaWindow_restore_max_flags_set)
    __swig_setmethods__["size"] = _kahakai.KaWindow_size_set
    __swig_getmethods__["size"] = _kahakai.KaWindow_size_get
    if _newclass:size = property(_kahakai.KaWindow_size_get, _kahakai.KaWindow_size_set)
    __swig_setmethods__["net"] = _kahakai.KaWindow_net_set
    __swig_getmethods__["net"] = _kahakai.KaWindow_net_get
    if _newclass:net = property(_kahakai.KaWindow_net_get, _kahakai.KaWindow_net_set)
    __swig_setmethods__["classhint"] = _kahakai.KaWindow_classhint_set
    __swig_getmethods__["classhint"] = _kahakai.KaWindow_classhint_get
    if _newclass:classhint = property(_kahakai.KaWindow_classhint_get, _kahakai.KaWindow_classhint_set)
    __swig_setmethods__["transients"] = _kahakai.KaWindow_transients_set
    __swig_getmethods__["transients"] = _kahakai.KaWindow_transients_get
    if _newclass:transients = property(_kahakai.KaWindow_transients_get, _kahakai.KaWindow_transients_set)
    __swig_setmethods__["render_if_transparency"] = _kahakai.KaWindow_render_if_transparency_set
    __swig_getmethods__["render_if_transparency"] = _kahakai.KaWindow_render_if_transparency_get
    if _newclass:render_if_transparency = property(_kahakai.KaWindow_render_if_transparency_get, _kahakai.KaWindow_render_if_transparency_set)
    def IsHorizontallyOnScreen(*args): return _kahakai.KaWindow_IsHorizontallyOnScreen(*args)
    def IsVerticallyOnScreen(*args): return _kahakai.KaWindow_IsVerticallyOnScreen(*args)
    def IsOnScreen(*args): return _kahakai.KaWindow_IsOnScreen(*args)
    def IsHorizontallyInWorkarea(*args): return _kahakai.KaWindow_IsHorizontallyInWorkarea(*args)
    def IsVerticallyInWorkarea(*args): return _kahakai.KaWindow_IsVerticallyInWorkarea(*args)
    def IsInWorkarea(*args): return _kahakai.KaWindow_IsInWorkarea(*args)
    def IsVisible(*args): return _kahakai.KaWindow_IsVisible(*args)
    __swig_setmethods__["desktop_mask"] = _kahakai.KaWindow_desktop_mask_set
    __swig_getmethods__["desktop_mask"] = _kahakai.KaWindow_desktop_mask_get
    if _newclass:desktop_mask = property(_kahakai.KaWindow_desktop_mask_get, _kahakai.KaWindow_desktop_mask_set)
KaWindow_swigregister = _kahakai.KaWindow_swigregister
KaWindow_swigregister(KaWindow)

class WindowEvFocus(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvFocus, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvFocus, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvFocus(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvFocus___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvFocus
    __del__ = lambda self : None;
WindowEvFocus_swigregister = _kahakai.WindowEvFocus_swigregister
WindowEvFocus_swigregister(WindowEvFocus)

class WindowEvFocusVis(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvFocusVis, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvFocusVis, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvFocusVis(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvFocusVis___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvFocusVis
    __del__ = lambda self : None;
WindowEvFocusVis_swigregister = _kahakai.WindowEvFocusVis_swigregister
WindowEvFocusVis_swigregister(WindowEvFocusVis)

class WindowEvUnFocus(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvUnFocus, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvUnFocus, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvUnFocus(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvUnFocus___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvUnFocus
    __del__ = lambda self : None;
WindowEvUnFocus_swigregister = _kahakai.WindowEvUnFocus_swigregister
WindowEvUnFocus_swigregister(WindowEvUnFocus)

class WindowEvClose(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvClose, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvClose, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvClose(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvClose___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvClose
    __del__ = lambda self : None;
WindowEvClose_swigregister = _kahakai.WindowEvClose_swigregister
WindowEvClose_swigregister(WindowEvClose)

class WindowEvRaise(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvRaise, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvRaise, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvRaise(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvRaise___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvRaise
    __del__ = lambda self : None;
WindowEvRaise_swigregister = _kahakai.WindowEvRaise_swigregister
WindowEvRaise_swigregister(WindowEvRaise)

class WindowEvLower(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvLower, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvLower, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvLower(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvLower___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvLower
    __del__ = lambda self : None;
WindowEvLower_swigregister = _kahakai.WindowEvLower_swigregister
WindowEvLower_swigregister(WindowEvLower)

class WindowEvMoveResize(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMoveResize, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMoveResize, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMoveResize(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMoveResize___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMoveResize
    __del__ = lambda self : None;
WindowEvMoveResize_swigregister = _kahakai.WindowEvMoveResize_swigregister
WindowEvMoveResize_swigregister(WindowEvMoveResize)

class WindowEvMoveResizeVirtual(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMoveResizeVirtual, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMoveResizeVirtual, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMoveResizeVirtual(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMoveResizeVirtual___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMoveResizeVirtual
    __del__ = lambda self : None;
WindowEvMoveResizeVirtual_swigregister = _kahakai.WindowEvMoveResizeVirtual_swigregister
WindowEvMoveResizeVirtual_swigregister(WindowEvMoveResizeVirtual)

class WindowEvMoveWindowToPointer(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMoveWindowToPointer, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMoveWindowToPointer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMoveWindowToPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMoveWindowToPointer___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMoveWindowToPointer
    __del__ = lambda self : None;
WindowEvMoveWindowToPointer_swigregister = _kahakai.WindowEvMoveWindowToPointer_swigregister
WindowEvMoveWindowToPointer_swigregister(WindowEvMoveWindowToPointer)

class WindowEvMoveWindowBy(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMoveWindowBy, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMoveWindowBy, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMoveWindowBy(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMoveWindowBy___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMoveWindowBy
    __del__ = lambda self : None;
WindowEvMoveWindowBy_swigregister = _kahakai.WindowEvMoveWindowBy_swigregister
WindowEvMoveWindowBy_swigregister(WindowEvMoveWindowBy)

class WindowEvMoveWindowToSmartPlace(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMoveWindowToSmartPlace, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMoveWindowToSmartPlace, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMoveWindowToSmartPlace(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMoveWindowToSmartPlace___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMoveWindowToSmartPlace
    __del__ = lambda self : None;
WindowEvMoveWindowToSmartPlace_swigregister = _kahakai.WindowEvMoveWindowToSmartPlace_swigregister
WindowEvMoveWindowToSmartPlace_swigregister(WindowEvMoveWindowToSmartPlace)

class WindowEvMoveWindowToViewport(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMoveWindowToViewport, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMoveWindowToViewport, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMoveWindowToViewport(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMoveWindowToViewport___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMoveWindowToViewport
    __del__ = lambda self : None;
WindowEvMoveWindowToViewport_swigregister = _kahakai.WindowEvMoveWindowToViewport_swigregister
WindowEvMoveWindowToViewport_swigregister(WindowEvMoveWindowToViewport)

class WindowEvMoveWindowToCurrentViewport(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMoveWindowToCurrentViewport, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMoveWindowToCurrentViewport, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMoveWindowToCurrentViewport(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMoveWindowToCurrentViewport___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMoveWindowToCurrentViewport
    __del__ = lambda self : None;
WindowEvMoveWindowToCurrentViewport_swigregister = _kahakai.WindowEvMoveWindowToCurrentViewport_swigregister
WindowEvMoveWindowToCurrentViewport_swigregister(WindowEvMoveWindowToCurrentViewport)

class WindowEvDesktopMask(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvDesktopMask, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvDesktopMask, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvDesktopMask(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvDesktopMask___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvDesktopMask
    __del__ = lambda self : None;
WindowEvDesktopMask_swigregister = _kahakai.WindowEvDesktopMask_swigregister
WindowEvDesktopMask_swigregister(WindowEvDesktopMask)

class WindowEvJoinDesktop(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvJoinDesktop, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvJoinDesktop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvJoinDesktop(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvJoinDesktop___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvJoinDesktop
    __del__ = lambda self : None;
WindowEvJoinDesktop_swigregister = _kahakai.WindowEvJoinDesktop_swigregister
WindowEvJoinDesktop_swigregister(WindowEvJoinDesktop)

class WindowEvPartDesktop(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvPartDesktop, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvPartDesktop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvPartDesktop(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvPartDesktop___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvPartDesktop
    __del__ = lambda self : None;
WindowEvPartDesktop_swigregister = _kahakai.WindowEvPartDesktop_swigregister
WindowEvPartDesktop_swigregister(WindowEvPartDesktop)

class WindowEvPartCurrentJoinDesktop(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvPartCurrentJoinDesktop, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvPartCurrentJoinDesktop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvPartCurrentJoinDesktop(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvPartCurrentJoinDesktop___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvPartCurrentJoinDesktop
    __del__ = lambda self : None;
WindowEvPartCurrentJoinDesktop_swigregister = _kahakai.WindowEvPartCurrentJoinDesktop_swigregister
WindowEvPartCurrentJoinDesktop_swigregister(WindowEvPartCurrentJoinDesktop)

class WindowEvPartCurrentDesktop(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvPartCurrentDesktop, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvPartCurrentDesktop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvPartCurrentDesktop(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvPartCurrentDesktop___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvPartCurrentDesktop
    __del__ = lambda self : None;
WindowEvPartCurrentDesktop_swigregister = _kahakai.WindowEvPartCurrentDesktop_swigregister
WindowEvPartCurrentDesktop_swigregister(WindowEvPartCurrentDesktop)

class WindowEvJoinAllDesktops(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvJoinAllDesktops, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvJoinAllDesktops, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvJoinAllDesktops(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvJoinAllDesktops___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvJoinAllDesktops
    __del__ = lambda self : None;
WindowEvJoinAllDesktops_swigregister = _kahakai.WindowEvJoinAllDesktops_swigregister
WindowEvJoinAllDesktops_swigregister(WindowEvJoinAllDesktops)

class WindowEvPartAllDesktopsExceptCurrent(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvPartAllDesktopsExceptCurrent, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvPartAllDesktopsExceptCurrent, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvPartAllDesktopsExceptCurrent(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvPartAllDesktopsExceptCurrent___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvPartAllDesktopsExceptCurrent
    __del__ = lambda self : None;
WindowEvPartAllDesktopsExceptCurrent_swigregister = _kahakai.WindowEvPartAllDesktopsExceptCurrent_swigregister
WindowEvPartAllDesktopsExceptCurrent_swigregister(WindowEvPartAllDesktopsExceptCurrent)

class WindowEvMove(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMove, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMove, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMove(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMove___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMove
    __del__ = lambda self : None;
WindowEvMove_swigregister = _kahakai.WindowEvMove_swigregister
WindowEvMove_swigregister(WindowEvMove)

class WindowEvMoveOpaque(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMoveOpaque, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMoveOpaque, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMoveOpaque(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMoveOpaque___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMoveOpaque
    __del__ = lambda self : None;
WindowEvMoveOpaque_swigregister = _kahakai.WindowEvMoveOpaque_swigregister
WindowEvMoveOpaque_swigregister(WindowEvMoveOpaque)

class WindowEvRaiseFocus(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvRaiseFocus, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvRaiseFocus, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvRaiseFocus(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvRaiseFocus___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvRaiseFocus
    __del__ = lambda self : None;
WindowEvRaiseFocus_swigregister = _kahakai.WindowEvRaiseFocus_swigregister
WindowEvRaiseFocus_swigregister(WindowEvRaiseFocus)

class WindowEvShade(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvShade, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvShade, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvShade(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvShade___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvShade
    __del__ = lambda self : None;
WindowEvShade_swigregister = _kahakai.WindowEvShade_swigregister
WindowEvShade_swigregister(WindowEvShade)

class WindowEvUnShade(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvUnShade, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvUnShade, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvUnShade(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvUnShade___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvUnShade
    __del__ = lambda self : None;
WindowEvUnShade_swigregister = _kahakai.WindowEvUnShade_swigregister
WindowEvUnShade_swigregister(WindowEvUnShade)

class WindowEvToggleShade(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvToggleShade, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvToggleShade, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvToggleShade(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvToggleShade___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvToggleShade
    __del__ = lambda self : None;
WindowEvToggleShade_swigregister = _kahakai.WindowEvToggleShade_swigregister
WindowEvToggleShade_swigregister(WindowEvToggleShade)

class WindowEvMenuMap(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMenuMap, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMenuMap, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMenuMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMenuMap___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMenuMap
    __del__ = lambda self : None;
WindowEvMenuMap_swigregister = _kahakai.WindowEvMenuMap_swigregister
WindowEvMenuMap_swigregister(WindowEvMenuMap)

class WindowEvMenuMapFocused(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMenuMapFocused, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMenuMapFocused, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMenuMapFocused(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMenuMapFocused___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMenuMapFocused
    __del__ = lambda self : None;
WindowEvMenuMapFocused_swigregister = _kahakai.WindowEvMenuMapFocused_swigregister
WindowEvMenuMapFocused_swigregister(WindowEvMenuMapFocused)

class WindowEvMenuRemap(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMenuRemap, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMenuRemap, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMenuRemap(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMenuRemap___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMenuRemap
    __del__ = lambda self : None;
WindowEvMenuRemap_swigregister = _kahakai.WindowEvMenuRemap_swigregister
WindowEvMenuRemap_swigregister(WindowEvMenuRemap)

class WindowEvMenuRemapFocused(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMenuRemapFocused, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMenuRemapFocused, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMenuRemapFocused(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMenuRemapFocused___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMenuRemapFocused
    __del__ = lambda self : None;
WindowEvMenuRemapFocused_swigregister = _kahakai.WindowEvMenuRemapFocused_swigregister
WindowEvMenuRemapFocused_swigregister(WindowEvMenuRemapFocused)

class WindowEvMenuUnmap(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMenuUnmap, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMenuUnmap, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMenuUnmap(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMenuUnmap___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMenuUnmap
    __del__ = lambda self : None;
WindowEvMenuUnmap_swigregister = _kahakai.WindowEvMenuUnmap_swigregister
WindowEvMenuUnmap_swigregister(WindowEvMenuUnmap)

class WindowEvMenuUnmapFocus(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMenuUnmapFocus, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMenuUnmapFocus, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMenuUnmapFocus(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMenuUnmapFocus___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMenuUnmapFocus
    __del__ = lambda self : None;
WindowEvMenuUnmapFocus_swigregister = _kahakai.WindowEvMenuUnmapFocus_swigregister
WindowEvMenuUnmapFocus_swigregister(WindowEvMenuUnmapFocus)

class WindowEvResizeLeft(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvResizeLeft, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvResizeLeft, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvResizeLeft(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvResizeLeft___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvResizeLeft
    __del__ = lambda self : None;
WindowEvResizeLeft_swigregister = _kahakai.WindowEvResizeLeft_swigregister
WindowEvResizeLeft_swigregister(WindowEvResizeLeft)

class WindowEvResizeLeftOpaque(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvResizeLeftOpaque, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvResizeLeftOpaque, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvResizeLeftOpaque(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvResizeLeftOpaque___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvResizeLeftOpaque
    __del__ = lambda self : None;
WindowEvResizeLeftOpaque_swigregister = _kahakai.WindowEvResizeLeftOpaque_swigregister
WindowEvResizeLeftOpaque_swigregister(WindowEvResizeLeftOpaque)

class WindowEvResizeRight(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvResizeRight, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvResizeRight, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvResizeRight(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvResizeRight___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvResizeRight
    __del__ = lambda self : None;
WindowEvResizeRight_swigregister = _kahakai.WindowEvResizeRight_swigregister
WindowEvResizeRight_swigregister(WindowEvResizeRight)

class WindowEvResizeRightOpaque(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvResizeRightOpaque, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvResizeRightOpaque, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvResizeRightOpaque(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvResizeRightOpaque___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvResizeRightOpaque
    __del__ = lambda self : None;
WindowEvResizeRightOpaque_swigregister = _kahakai.WindowEvResizeRightOpaque_swigregister
WindowEvResizeRightOpaque_swigregister(WindowEvResizeRightOpaque)

class WindowEvResizeNorthWest(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvResizeNorthWest, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvResizeNorthWest, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvResizeNorthWest(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvResizeNorthWest___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvResizeNorthWest
    __del__ = lambda self : None;
WindowEvResizeNorthWest_swigregister = _kahakai.WindowEvResizeNorthWest_swigregister
WindowEvResizeNorthWest_swigregister(WindowEvResizeNorthWest)

class WindowEvResizeNorthEast(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvResizeNorthEast, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvResizeNorthEast, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvResizeNorthEast(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvResizeNorthEast___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvResizeNorthEast
    __del__ = lambda self : None;
WindowEvResizeNorthEast_swigregister = _kahakai.WindowEvResizeNorthEast_swigregister
WindowEvResizeNorthEast_swigregister(WindowEvResizeNorthEast)

class WindowEvResizeSouthWest(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvResizeSouthWest, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvResizeSouthWest, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvResizeSouthWest(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvResizeSouthWest___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvResizeSouthWest
    __del__ = lambda self : None;
WindowEvResizeSouthWest_swigregister = _kahakai.WindowEvResizeSouthWest_swigregister
WindowEvResizeSouthWest_swigregister(WindowEvResizeSouthWest)

class WindowEvResizeSouthEast(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvResizeSouthEast, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvResizeSouthEast, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvResizeSouthEast(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvResizeSouthEast___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvResizeSouthEast
    __del__ = lambda self : None;
WindowEvResizeSouthEast_swigregister = _kahakai.WindowEvResizeSouthEast_swigregister
WindowEvResizeSouthEast_swigregister(WindowEvResizeSouthEast)

class WindowEvSmartResize(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvSmartResize, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvSmartResize, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvSmartResize(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvSmartResize___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvSmartResize
    __del__ = lambda self : None;
WindowEvSmartResize_swigregister = _kahakai.WindowEvSmartResize_swigregister
WindowEvSmartResize_swigregister(WindowEvSmartResize)

class WindowEvSmartResizeOpaque(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvSmartResizeOpaque, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvSmartResizeOpaque, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvSmartResizeOpaque(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvSmartResizeOpaque___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvSmartResizeOpaque
    __del__ = lambda self : None;
WindowEvSmartResizeOpaque_swigregister = _kahakai.WindowEvSmartResizeOpaque_swigregister
WindowEvSmartResizeOpaque_swigregister(WindowEvSmartResizeOpaque)

class WindowEvEndMoveResize(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvEndMoveResize, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvEndMoveResize, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvEndMoveResize(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvEndMoveResize___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvEndMoveResize
    __del__ = lambda self : None;
WindowEvEndMoveResize_swigregister = _kahakai.WindowEvEndMoveResize_swigregister
WindowEvEndMoveResize_swigregister(WindowEvEndMoveResize)

class WindowEvMaximize(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMaximize, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMaximize, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMaximize(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMaximize___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMaximize
    __del__ = lambda self : None;
WindowEvMaximize_swigregister = _kahakai.WindowEvMaximize_swigregister
WindowEvMaximize_swigregister(WindowEvMaximize)

class WindowEvMaximizeHorizontally(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMaximizeHorizontally, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMaximizeHorizontally, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMaximizeHorizontally(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMaximizeHorizontally___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMaximizeHorizontally
    __del__ = lambda self : None;
WindowEvMaximizeHorizontally_swigregister = _kahakai.WindowEvMaximizeHorizontally_swigregister
WindowEvMaximizeHorizontally_swigregister(WindowEvMaximizeHorizontally)

class WindowEvMaximizeVertically(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMaximizeVertically, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMaximizeVertically, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMaximizeVertically(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMaximizeVertically___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMaximizeVertically
    __del__ = lambda self : None;
WindowEvMaximizeVertically_swigregister = _kahakai.WindowEvMaximizeVertically_swigregister
WindowEvMaximizeVertically_swigregister(WindowEvMaximizeVertically)

class WindowEvUnMaximize(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvUnMaximize, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvUnMaximize, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvUnMaximize(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvUnMaximize___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvUnMaximize
    __del__ = lambda self : None;
WindowEvUnMaximize_swigregister = _kahakai.WindowEvUnMaximize_swigregister
WindowEvUnMaximize_swigregister(WindowEvUnMaximize)

class WindowEvToggleMaximize(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvToggleMaximize, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvToggleMaximize, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvToggleMaximize(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvToggleMaximize___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvToggleMaximize
    __del__ = lambda self : None;
WindowEvToggleMaximize_swigregister = _kahakai.WindowEvToggleMaximize_swigregister
WindowEvToggleMaximize_swigregister(WindowEvToggleMaximize)

class WindowEvToggleMaximizeVertically(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvToggleMaximizeVertically, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvToggleMaximizeVertically, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvToggleMaximizeVertically(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvToggleMaximizeVertically___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvToggleMaximizeVertically
    __del__ = lambda self : None;
WindowEvToggleMaximizeVertically_swigregister = _kahakai.WindowEvToggleMaximizeVertically_swigregister
WindowEvToggleMaximizeVertically_swigregister(WindowEvToggleMaximizeVertically)

class WindowEvToggleMaximizeHorizontally(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvToggleMaximizeHorizontally, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvToggleMaximizeHorizontally, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvToggleMaximizeHorizontally(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvToggleMaximizeHorizontally___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvToggleMaximizeHorizontally
    __del__ = lambda self : None;
WindowEvToggleMaximizeHorizontally_swigregister = _kahakai.WindowEvToggleMaximizeHorizontally_swigregister
WindowEvToggleMaximizeHorizontally_swigregister(WindowEvToggleMaximizeHorizontally)

class WindowEvKill(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvKill, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvKill, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvKill(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvKill___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvKill
    __del__ = lambda self : None;
WindowEvKill_swigregister = _kahakai.WindowEvKill_swigregister
WindowEvKill_swigregister(WindowEvKill)

class WindowEvCloseKill(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvCloseKill, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvCloseKill, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvCloseKill(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvCloseKill___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvCloseKill
    __del__ = lambda self : None;
WindowEvCloseKill_swigregister = _kahakai.WindowEvCloseKill_swigregister
WindowEvCloseKill_swigregister(WindowEvCloseKill)

class WindowEvSticky(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvSticky, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvSticky, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvSticky(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvSticky___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvSticky
    __del__ = lambda self : None;
WindowEvSticky_swigregister = _kahakai.WindowEvSticky_swigregister
WindowEvSticky_swigregister(WindowEvSticky)

class WindowEvUnSticky(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvUnSticky, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvUnSticky, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvUnSticky(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvUnSticky___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvUnSticky
    __del__ = lambda self : None;
WindowEvUnSticky_swigregister = _kahakai.WindowEvUnSticky_swigregister
WindowEvUnSticky_swigregister(WindowEvUnSticky)

class WindowEvToggleSticky(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvToggleSticky, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvToggleSticky, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvToggleSticky(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvToggleSticky___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvToggleSticky
    __del__ = lambda self : None;
WindowEvToggleSticky_swigregister = _kahakai.WindowEvToggleSticky_swigregister
WindowEvToggleSticky_swigregister(WindowEvToggleSticky)

class WindowEvMinimize(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvMinimize, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvMinimize, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvMinimize(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvMinimize___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvMinimize
    __del__ = lambda self : None;
WindowEvMinimize_swigregister = _kahakai.WindowEvMinimize_swigregister
WindowEvMinimize_swigregister(WindowEvMinimize)

class WindowEvUnMinimize(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvUnMinimize, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvUnMinimize, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvUnMinimize(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvUnMinimize___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvUnMinimize
    __del__ = lambda self : None;
WindowEvUnMinimize_swigregister = _kahakai.WindowEvUnMinimize_swigregister
WindowEvUnMinimize_swigregister(WindowEvUnMinimize)

class WindowEvToggleMinimize(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvToggleMinimize, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvToggleMinimize, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvToggleMinimize(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvToggleMinimize___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvToggleMinimize
    __del__ = lambda self : None;
WindowEvToggleMinimize_swigregister = _kahakai.WindowEvToggleMinimize_swigregister
WindowEvToggleMinimize_swigregister(WindowEvToggleMinimize)

class WindowEvToggleMinimizeActive(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvToggleMinimizeActive, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvToggleMinimizeActive, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvToggleMinimizeActive(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvToggleMinimizeActive___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvToggleMinimizeActive
    __del__ = lambda self : None;
WindowEvToggleMinimizeActive_swigregister = _kahakai.WindowEvToggleMinimizeActive_swigregister
WindowEvToggleMinimizeActive_swigregister(WindowEvToggleMinimizeActive)

class WindowEvFullscreenOn(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvFullscreenOn, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvFullscreenOn, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvFullscreenOn(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvFullscreenOn___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvFullscreenOn
    __del__ = lambda self : None;
WindowEvFullscreenOn_swigregister = _kahakai.WindowEvFullscreenOn_swigregister
WindowEvFullscreenOn_swigregister(WindowEvFullscreenOn)

class WindowEvFullscreenOff(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvFullscreenOff, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvFullscreenOff, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvFullscreenOff(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvFullscreenOff___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvFullscreenOff
    __del__ = lambda self : None;
WindowEvFullscreenOff_swigregister = _kahakai.WindowEvFullscreenOff_swigregister
WindowEvFullscreenOff_swigregister(WindowEvFullscreenOff)

class WindowEvFullscreenToggle(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvFullscreenToggle, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvFullscreenToggle, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvFullscreenToggle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvFullscreenToggle___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvFullscreenToggle
    __del__ = lambda self : None;
WindowEvFullscreenToggle_swigregister = _kahakai.WindowEvFullscreenToggle_swigregister
WindowEvFullscreenToggle_swigregister(WindowEvFullscreenToggle)

class WindowEvDecorTitleOn(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvDecorTitleOn, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvDecorTitleOn, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvDecorTitleOn(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvDecorTitleOn___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvDecorTitleOn
    __del__ = lambda self : None;
WindowEvDecorTitleOn_swigregister = _kahakai.WindowEvDecorTitleOn_swigregister
WindowEvDecorTitleOn_swigregister(WindowEvDecorTitleOn)

class WindowEvDecorHandleOn(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvDecorHandleOn, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvDecorHandleOn, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvDecorHandleOn(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvDecorHandleOn___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvDecorHandleOn
    __del__ = lambda self : None;
WindowEvDecorHandleOn_swigregister = _kahakai.WindowEvDecorHandleOn_swigregister
WindowEvDecorHandleOn_swigregister(WindowEvDecorHandleOn)

class WindowEvDecorBorderOn(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvDecorBorderOn, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvDecorBorderOn, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvDecorBorderOn(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvDecorBorderOn___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvDecorBorderOn
    __del__ = lambda self : None;
WindowEvDecorBorderOn_swigregister = _kahakai.WindowEvDecorBorderOn_swigregister
WindowEvDecorBorderOn_swigregister(WindowEvDecorBorderOn)

class WindowEvDecorAllOn(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvDecorAllOn, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvDecorAllOn, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvDecorAllOn(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvDecorAllOn___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvDecorAllOn
    __del__ = lambda self : None;
WindowEvDecorAllOn_swigregister = _kahakai.WindowEvDecorAllOn_swigregister
WindowEvDecorAllOn_swigregister(WindowEvDecorAllOn)

class WindowEvDecorTitleOff(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvDecorTitleOff, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvDecorTitleOff, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvDecorTitleOff(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvDecorTitleOff___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvDecorTitleOff
    __del__ = lambda self : None;
WindowEvDecorTitleOff_swigregister = _kahakai.WindowEvDecorTitleOff_swigregister
WindowEvDecorTitleOff_swigregister(WindowEvDecorTitleOff)

class WindowEvDecorHandleOff(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvDecorHandleOff, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvDecorHandleOff, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvDecorHandleOff(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvDecorHandleOff___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvDecorHandleOff
    __del__ = lambda self : None;
WindowEvDecorHandleOff_swigregister = _kahakai.WindowEvDecorHandleOff_swigregister
WindowEvDecorHandleOff_swigregister(WindowEvDecorHandleOff)

class WindowEvDecorBorderOff(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvDecorBorderOff, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvDecorBorderOff, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvDecorBorderOff(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvDecorBorderOff___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvDecorBorderOff
    __del__ = lambda self : None;
WindowEvDecorBorderOff_swigregister = _kahakai.WindowEvDecorBorderOff_swigregister
WindowEvDecorBorderOff_swigregister(WindowEvDecorBorderOff)

class WindowEvDecorAllOff(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvDecorAllOff, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvDecorAllOff, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvDecorAllOff(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvDecorAllOff___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvDecorAllOff
    __del__ = lambda self : None;
WindowEvDecorAllOff_swigregister = _kahakai.WindowEvDecorAllOff_swigregister
WindowEvDecorAllOff_swigregister(WindowEvDecorAllOff)

class WindowEvDecorTitleToggle(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvDecorTitleToggle, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvDecorTitleToggle, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvDecorTitleToggle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvDecorTitleToggle___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvDecorTitleToggle
    __del__ = lambda self : None;
WindowEvDecorTitleToggle_swigregister = _kahakai.WindowEvDecorTitleToggle_swigregister
WindowEvDecorTitleToggle_swigregister(WindowEvDecorTitleToggle)

class WindowEvDecorHandleToggle(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvDecorHandleToggle, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvDecorHandleToggle, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvDecorHandleToggle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvDecorHandleToggle___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvDecorHandleToggle
    __del__ = lambda self : None;
WindowEvDecorHandleToggle_swigregister = _kahakai.WindowEvDecorHandleToggle_swigregister
WindowEvDecorHandleToggle_swigregister(WindowEvDecorHandleToggle)

class WindowEvDecorBorderToggle(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvDecorBorderToggle, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvDecorBorderToggle, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvDecorBorderToggle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvDecorBorderToggle___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvDecorBorderToggle
    __del__ = lambda self : None;
WindowEvDecorBorderToggle_swigregister = _kahakai.WindowEvDecorBorderToggle_swigregister
WindowEvDecorBorderToggle_swigregister(WindowEvDecorBorderToggle)

class WindowEvDecorAllToggle(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvDecorAllToggle, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvDecorAllToggle, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvDecorAllToggle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvDecorAllToggle___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvDecorAllToggle
    __del__ = lambda self : None;
WindowEvDecorAllToggle_swigregister = _kahakai.WindowEvDecorAllToggle_swigregister
WindowEvDecorAllToggle_swigregister(WindowEvDecorAllToggle)

class WindowEvAlwaysontopOn(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvAlwaysontopOn, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvAlwaysontopOn, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvAlwaysontopOn(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvAlwaysontopOn___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvAlwaysontopOn
    __del__ = lambda self : None;
WindowEvAlwaysontopOn_swigregister = _kahakai.WindowEvAlwaysontopOn_swigregister
WindowEvAlwaysontopOn_swigregister(WindowEvAlwaysontopOn)

class WindowEvAlwaysontopOff(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvAlwaysontopOff, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvAlwaysontopOff, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvAlwaysontopOff(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvAlwaysontopOff___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvAlwaysontopOff
    __del__ = lambda self : None;
WindowEvAlwaysontopOff_swigregister = _kahakai.WindowEvAlwaysontopOff_swigregister
WindowEvAlwaysontopOff_swigregister(WindowEvAlwaysontopOff)

class WindowEvAlwaysontopToggle(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvAlwaysontopToggle, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvAlwaysontopToggle, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvAlwaysontopToggle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvAlwaysontopToggle___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvAlwaysontopToggle
    __del__ = lambda self : None;
WindowEvAlwaysontopToggle_swigregister = _kahakai.WindowEvAlwaysontopToggle_swigregister
WindowEvAlwaysontopToggle_swigregister(WindowEvAlwaysontopToggle)

class WindowEvAlwaysatbottomOn(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvAlwaysatbottomOn, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvAlwaysatbottomOn, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvAlwaysatbottomOn(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvAlwaysatbottomOn___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvAlwaysatbottomOn
    __del__ = lambda self : None;
WindowEvAlwaysatbottomOn_swigregister = _kahakai.WindowEvAlwaysatbottomOn_swigregister
WindowEvAlwaysatbottomOn_swigregister(WindowEvAlwaysatbottomOn)

class WindowEvAlwaysatbottomOff(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvAlwaysatbottomOff, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvAlwaysatbottomOff, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvAlwaysatbottomOff(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvAlwaysatbottomOff___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvAlwaysatbottomOff
    __del__ = lambda self : None;
WindowEvAlwaysatbottomOff_swigregister = _kahakai.WindowEvAlwaysatbottomOff_swigregister
WindowEvAlwaysatbottomOff_swigregister(WindowEvAlwaysatbottomOff)

class WindowEvAlwaysatbottomToggle(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvAlwaysatbottomToggle, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvAlwaysatbottomToggle, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvAlwaysatbottomToggle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvAlwaysatbottomToggle___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvAlwaysatbottomToggle
    __del__ = lambda self : None;
WindowEvAlwaysatbottomToggle_swigregister = _kahakai.WindowEvAlwaysatbottomToggle_swigregister
WindowEvAlwaysatbottomToggle_swigregister(WindowEvAlwaysatbottomToggle)

class WindowEvAcceptConfigRequestOn(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvAcceptConfigRequestOn, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvAcceptConfigRequestOn, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvAcceptConfigRequestOn(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvAcceptConfigRequestOn___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvAcceptConfigRequestOn
    __del__ = lambda self : None;
WindowEvAcceptConfigRequestOn_swigregister = _kahakai.WindowEvAcceptConfigRequestOn_swigregister
WindowEvAcceptConfigRequestOn_swigregister(WindowEvAcceptConfigRequestOn)

class WindowEvAcceptConfigRequestOff(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvAcceptConfigRequestOff, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvAcceptConfigRequestOff, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvAcceptConfigRequestOff(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvAcceptConfigRequestOff___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvAcceptConfigRequestOff
    __del__ = lambda self : None;
WindowEvAcceptConfigRequestOff_swigregister = _kahakai.WindowEvAcceptConfigRequestOff_swigregister
WindowEvAcceptConfigRequestOff_swigregister(WindowEvAcceptConfigRequestOff)

class WindowEvAcceptConfigRequestToggle(WindowFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowEvAcceptConfigRequestToggle, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WindowEvAcceptConfigRequestToggle, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_WindowEvAcceptConfigRequestToggle(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.WindowEvAcceptConfigRequestToggle___call__(*args)
    __swig_destroy__ = _kahakai.delete_WindowEvAcceptConfigRequestToggle
    __del__ = lambda self : None;
WindowEvAcceptConfigRequestToggle_swigregister = _kahakai.WindowEvAcceptConfigRequestToggle_swigregister
WindowEvAcceptConfigRequestToggle_swigregister(WindowEvAcceptConfigRequestToggle)

class WindowAttributes(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowAttributes, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WindowAttributes, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _kahakai.WindowAttributes_x_set
    __swig_getmethods__["x"] = _kahakai.WindowAttributes_x_get
    if _newclass:x = property(_kahakai.WindowAttributes_x_get, _kahakai.WindowAttributes_x_set)
    __swig_setmethods__["y"] = _kahakai.WindowAttributes_y_set
    __swig_getmethods__["y"] = _kahakai.WindowAttributes_y_get
    if _newclass:y = property(_kahakai.WindowAttributes_y_get, _kahakai.WindowAttributes_y_set)
    __swig_setmethods__["width"] = _kahakai.WindowAttributes_width_set
    __swig_getmethods__["width"] = _kahakai.WindowAttributes_width_get
    if _newclass:width = property(_kahakai.WindowAttributes_width_get, _kahakai.WindowAttributes_width_set)
    __swig_setmethods__["height"] = _kahakai.WindowAttributes_height_set
    __swig_getmethods__["height"] = _kahakai.WindowAttributes_height_get
    if _newclass:height = property(_kahakai.WindowAttributes_height_get, _kahakai.WindowAttributes_height_set)
    __swig_setmethods__["misc0"] = _kahakai.WindowAttributes_misc0_set
    __swig_getmethods__["misc0"] = _kahakai.WindowAttributes_misc0_get
    if _newclass:misc0 = property(_kahakai.WindowAttributes_misc0_get, _kahakai.WindowAttributes_misc0_set)
    __swig_setmethods__["misc1"] = _kahakai.WindowAttributes_misc1_set
    __swig_getmethods__["misc1"] = _kahakai.WindowAttributes_misc1_get
    if _newclass:misc1 = property(_kahakai.WindowAttributes_misc1_get, _kahakai.WindowAttributes_misc1_set)
    __swig_setmethods__["colormap"] = _kahakai.WindowAttributes_colormap_set
    __swig_getmethods__["colormap"] = _kahakai.WindowAttributes_colormap_get
    if _newclass:colormap = property(_kahakai.WindowAttributes_colormap_get, _kahakai.WindowAttributes_colormap_set)
    def __init__(self, *args): 
        this = _kahakai.new_WindowAttributes(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_WindowAttributes
    __del__ = lambda self : None;
    def getX(*args): return _kahakai.WindowAttributes_getX(*args)
    def getY(*args): return _kahakai.WindowAttributes_getY(*args)
    def getLeft(*args): return _kahakai.WindowAttributes_getLeft(*args)
    def getTop(*args): return _kahakai.WindowAttributes_getTop(*args)
    def getRight(*args): return _kahakai.WindowAttributes_getRight(*args)
    def getBottom(*args): return _kahakai.WindowAttributes_getBottom(*args)
    def getWidth(*args): return _kahakai.WindowAttributes_getWidth(*args)
    def getHeight(*args): return _kahakai.WindowAttributes_getHeight(*args)
    def getMisc0(*args): return _kahakai.WindowAttributes_getMisc0(*args)
    def getMisc1(*args): return _kahakai.WindowAttributes_getMisc1(*args)
    def getColormap(*args): return _kahakai.WindowAttributes_getColormap(*args)
    def setX(*args): return _kahakai.WindowAttributes_setX(*args)
    def setY(*args): return _kahakai.WindowAttributes_setY(*args)
    def setWidth(*args): return _kahakai.WindowAttributes_setWidth(*args)
    def setHeight(*args): return _kahakai.WindowAttributes_setHeight(*args)
    def setMisc0(*args): return _kahakai.WindowAttributes_setMisc0(*args)
    def setMisc1(*args): return _kahakai.WindowAttributes_setMisc1(*args)
    def setColormap(*args): return _kahakai.WindowAttributes_setColormap(*args)
WindowAttributes_swigregister = _kahakai.WindowAttributes_swigregister
WindowAttributes_swigregister(WindowAttributes)

class Workarea(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Workarea, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Workarea, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _kahakai.Workarea_x_set
    __swig_getmethods__["x"] = _kahakai.Workarea_x_get
    if _newclass:x = property(_kahakai.Workarea_x_get, _kahakai.Workarea_x_set)
    __swig_setmethods__["y"] = _kahakai.Workarea_y_set
    __swig_getmethods__["y"] = _kahakai.Workarea_y_get
    if _newclass:y = property(_kahakai.Workarea_y_get, _kahakai.Workarea_y_set)
    __swig_setmethods__["width"] = _kahakai.Workarea_width_set
    __swig_getmethods__["width"] = _kahakai.Workarea_width_get
    if _newclass:width = property(_kahakai.Workarea_width_get, _kahakai.Workarea_width_set)
    __swig_setmethods__["height"] = _kahakai.Workarea_height_set
    __swig_getmethods__["height"] = _kahakai.Workarea_height_get
    if _newclass:height = property(_kahakai.Workarea_height_get, _kahakai.Workarea_height_set)
    def __init__(self, *args): 
        this = _kahakai.new_Workarea(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_Workarea
    __del__ = lambda self : None;
Workarea_swigregister = _kahakai.Workarea_swigregister
Workarea_swigregister(Workarea)

class Desktop(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Desktop, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Desktop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_Desktop(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_setmethods__["number"] = _kahakai.Desktop_number_set
    __swig_getmethods__["number"] = _kahakai.Desktop_number_get
    if _newclass:number = property(_kahakai.Desktop_number_get, _kahakai.Desktop_number_set)
    __swig_setmethods__["name"] = _kahakai.Desktop_name_set
    __swig_getmethods__["name"] = _kahakai.Desktop_name_get
    if _newclass:name = property(_kahakai.Desktop_name_get, _kahakai.Desktop_name_set)
    __swig_setmethods__["workarea"] = _kahakai.Desktop_workarea_set
    __swig_getmethods__["workarea"] = _kahakai.Desktop_workarea_get
    if _newclass:workarea = property(_kahakai.Desktop_workarea_get, _kahakai.Desktop_workarea_set)
    __swig_setmethods__["oldfocus"] = _kahakai.Desktop_oldfocus_set
    __swig_getmethods__["oldfocus"] = _kahakai.Desktop_oldfocus_get
    if _newclass:oldfocus = property(_kahakai.Desktop_oldfocus_get, _kahakai.Desktop_oldfocus_set)
    __swig_setmethods__["aot_stacking_list"] = _kahakai.Desktop_aot_stacking_list_set
    __swig_getmethods__["aot_stacking_list"] = _kahakai.Desktop_aot_stacking_list_get
    if _newclass:aot_stacking_list = property(_kahakai.Desktop_aot_stacking_list_get, _kahakai.Desktop_aot_stacking_list_set)
    __swig_setmethods__["stacking_list"] = _kahakai.Desktop_stacking_list_set
    __swig_getmethods__["stacking_list"] = _kahakai.Desktop_stacking_list_get
    if _newclass:stacking_list = property(_kahakai.Desktop_stacking_list_get, _kahakai.Desktop_stacking_list_set)
    __swig_setmethods__["aab_stacking_list"] = _kahakai.Desktop_aab_stacking_list_set
    __swig_getmethods__["aab_stacking_list"] = _kahakai.Desktop_aab_stacking_list_get
    if _newclass:aab_stacking_list = property(_kahakai.Desktop_aab_stacking_list_get, _kahakai.Desktop_aab_stacking_list_set)
    __swig_destroy__ = _kahakai.delete_Desktop
    __del__ = lambda self : None;
Desktop_swigregister = _kahakai.Desktop_swigregister
Desktop_swigregister(Desktop)

class ScreenConfig(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenConfig, name)
    __repr__ = _swig_repr
    __swig_setmethods__["style_file"] = _kahakai.ScreenConfig_style_file_set
    __swig_getmethods__["style_file"] = _kahakai.ScreenConfig_style_file_get
    if _newclass:style_file = property(_kahakai.ScreenConfig_style_file_get, _kahakai.ScreenConfig_style_file_set)
    __swig_setmethods__["menu_file"] = _kahakai.ScreenConfig_menu_file_set
    __swig_getmethods__["menu_file"] = _kahakai.ScreenConfig_menu_file_get
    if _newclass:menu_file = property(_kahakai.ScreenConfig_menu_file_get, _kahakai.ScreenConfig_menu_file_set)
    __swig_setmethods__["script_config"] = _kahakai.ScreenConfig_script_config_set
    __swig_getmethods__["script_config"] = _kahakai.ScreenConfig_script_config_get
    if _newclass:script_config = property(_kahakai.ScreenConfig_script_config_get, _kahakai.ScreenConfig_script_config_set)
    __swig_setmethods__["virtual_x"] = _kahakai.ScreenConfig_virtual_x_set
    __swig_getmethods__["virtual_x"] = _kahakai.ScreenConfig_virtual_x_get
    if _newclass:virtual_x = property(_kahakai.ScreenConfig_virtual_x_get, _kahakai.ScreenConfig_virtual_x_set)
    __swig_setmethods__["virtual_y"] = _kahakai.ScreenConfig_virtual_y_set
    __swig_getmethods__["virtual_y"] = _kahakai.ScreenConfig_virtual_y_get
    if _newclass:virtual_y = property(_kahakai.ScreenConfig_virtual_y_get, _kahakai.ScreenConfig_virtual_y_set)
    __swig_setmethods__["desktops"] = _kahakai.ScreenConfig_desktops_set
    __swig_getmethods__["desktops"] = _kahakai.ScreenConfig_desktops_get
    if _newclass:desktops = property(_kahakai.ScreenConfig_desktops_get, _kahakai.ScreenConfig_desktops_set)
    __swig_setmethods__["colors_per_channel"] = _kahakai.ScreenConfig_colors_per_channel_set
    __swig_getmethods__["colors_per_channel"] = _kahakai.ScreenConfig_colors_per_channel_get
    if _newclass:colors_per_channel = property(_kahakai.ScreenConfig_colors_per_channel_get, _kahakai.ScreenConfig_colors_per_channel_set)
    __swig_setmethods__["menu_stacking"] = _kahakai.ScreenConfig_menu_stacking_set
    __swig_getmethods__["menu_stacking"] = _kahakai.ScreenConfig_menu_stacking_get
    if _newclass:menu_stacking = property(_kahakai.ScreenConfig_menu_stacking_get, _kahakai.ScreenConfig_menu_stacking_set)
    __swig_setmethods__["cache_max"] = _kahakai.ScreenConfig_cache_max_set
    __swig_getmethods__["cache_max"] = _kahakai.ScreenConfig_cache_max_get
    if _newclass:cache_max = property(_kahakai.ScreenConfig_cache_max_get, _kahakai.ScreenConfig_cache_max_set)
    __swig_setmethods__["image_dither"] = _kahakai.ScreenConfig_image_dither_set
    __swig_getmethods__["image_dither"] = _kahakai.ScreenConfig_image_dither_get
    if _newclass:image_dither = property(_kahakai.ScreenConfig_image_dither_get, _kahakai.ScreenConfig_image_dither_set)
    __swig_setmethods__["transient_above"] = _kahakai.ScreenConfig_transient_above_set
    __swig_getmethods__["transient_above"] = _kahakai.ScreenConfig_transient_above_get
    if _newclass:transient_above = property(_kahakai.ScreenConfig_transient_above_get, _kahakai.ScreenConfig_transient_above_set)
    __swig_setmethods__["db"] = _kahakai.ScreenConfig_db_set
    __swig_getmethods__["db"] = _kahakai.ScreenConfig_db_get
    if _newclass:db = property(_kahakai.ScreenConfig_db_get, _kahakai.ScreenConfig_db_set)
    __swig_setmethods__["revert_to_window"] = _kahakai.ScreenConfig_revert_to_window_set
    __swig_getmethods__["revert_to_window"] = _kahakai.ScreenConfig_revert_to_window_get
    if _newclass:revert_to_window = property(_kahakai.ScreenConfig_revert_to_window_get, _kahakai.ScreenConfig_revert_to_window_set)
    __swig_setmethods__["moveresize_crosshair"] = _kahakai.ScreenConfig_moveresize_crosshair_set
    __swig_getmethods__["moveresize_crosshair"] = _kahakai.ScreenConfig_moveresize_crosshair_get
    if _newclass:moveresize_crosshair = property(_kahakai.ScreenConfig_moveresize_crosshair_get, _kahakai.ScreenConfig_moveresize_crosshair_set)
    __swig_setmethods__["resist"] = _kahakai.ScreenConfig_resist_set
    __swig_getmethods__["resist"] = _kahakai.ScreenConfig_resist_get
    if _newclass:resist = property(_kahakai.ScreenConfig_resist_get, _kahakai.ScreenConfig_resist_set)
    __swig_setmethods__["snapping"] = _kahakai.ScreenConfig_snapping_set
    __swig_getmethods__["snapping"] = _kahakai.ScreenConfig_snapping_get
    if _newclass:snapping = property(_kahakai.ScreenConfig_snapping_get, _kahakai.ScreenConfig_snapping_set)
    __swig_setmethods__["resistDistance"] = _kahakai.ScreenConfig_resistDistance_set
    __swig_getmethods__["resistDistance"] = _kahakai.ScreenConfig_resistDistance_get
    if _newclass:resistDistance = property(_kahakai.ScreenConfig_resistDistance_get, _kahakai.ScreenConfig_resistDistance_set)
    __swig_setmethods__["snapDistance"] = _kahakai.ScreenConfig_snapDistance_set
    __swig_getmethods__["snapDistance"] = _kahakai.ScreenConfig_snapDistance_get
    if _newclass:snapDistance = property(_kahakai.ScreenConfig_snapDistance_get, _kahakai.ScreenConfig_snapDistance_set)
    __swig_setmethods__["lazy_trans"] = _kahakai.ScreenConfig_lazy_trans_set
    __swig_getmethods__["lazy_trans"] = _kahakai.ScreenConfig_lazy_trans_get
    if _newclass:lazy_trans = property(_kahakai.ScreenConfig_lazy_trans_get, _kahakai.ScreenConfig_lazy_trans_set)
    __swig_setmethods__["frameacts"] = _kahakai.ScreenConfig_frameacts_set
    __swig_getmethods__["frameacts"] = _kahakai.ScreenConfig_frameacts_get
    if _newclass:frameacts = property(_kahakai.ScreenConfig_frameacts_get, _kahakai.ScreenConfig_frameacts_set)
    __swig_setmethods__["awinacts"] = _kahakai.ScreenConfig_awinacts_set
    __swig_getmethods__["awinacts"] = _kahakai.ScreenConfig_awinacts_get
    if _newclass:awinacts = property(_kahakai.ScreenConfig_awinacts_get, _kahakai.ScreenConfig_awinacts_set)
    __swig_setmethods__["pwinacts"] = _kahakai.ScreenConfig_pwinacts_set
    __swig_getmethods__["pwinacts"] = _kahakai.ScreenConfig_pwinacts_get
    if _newclass:pwinacts = property(_kahakai.ScreenConfig_pwinacts_get, _kahakai.ScreenConfig_pwinacts_set)
    __swig_setmethods__["titleacts"] = _kahakai.ScreenConfig_titleacts_set
    __swig_getmethods__["titleacts"] = _kahakai.ScreenConfig_titleacts_get
    if _newclass:titleacts = property(_kahakai.ScreenConfig_titleacts_get, _kahakai.ScreenConfig_titleacts_set)
    __swig_setmethods__["labelacts"] = _kahakai.ScreenConfig_labelacts_set
    __swig_getmethods__["labelacts"] = _kahakai.ScreenConfig_labelacts_get
    if _newclass:labelacts = property(_kahakai.ScreenConfig_labelacts_get, _kahakai.ScreenConfig_labelacts_set)
    __swig_setmethods__["handleacts"] = _kahakai.ScreenConfig_handleacts_set
    __swig_getmethods__["handleacts"] = _kahakai.ScreenConfig_handleacts_get
    if _newclass:handleacts = property(_kahakai.ScreenConfig_handleacts_get, _kahakai.ScreenConfig_handleacts_set)
    __swig_setmethods__["rgacts"] = _kahakai.ScreenConfig_rgacts_set
    __swig_getmethods__["rgacts"] = _kahakai.ScreenConfig_rgacts_get
    if _newclass:rgacts = property(_kahakai.ScreenConfig_rgacts_get, _kahakai.ScreenConfig_rgacts_set)
    __swig_setmethods__["lgacts"] = _kahakai.ScreenConfig_lgacts_set
    __swig_getmethods__["lgacts"] = _kahakai.ScreenConfig_lgacts_get
    if _newclass:lgacts = property(_kahakai.ScreenConfig_lgacts_get, _kahakai.ScreenConfig_lgacts_set)
    __swig_setmethods__["rootacts"] = _kahakai.ScreenConfig_rootacts_set
    __swig_getmethods__["rootacts"] = _kahakai.ScreenConfig_rootacts_get
    if _newclass:rootacts = property(_kahakai.ScreenConfig_rootacts_get, _kahakai.ScreenConfig_rootacts_set)
    __swig_setmethods__["weacts"] = _kahakai.ScreenConfig_weacts_set
    __swig_getmethods__["weacts"] = _kahakai.ScreenConfig_weacts_get
    if _newclass:weacts = property(_kahakai.ScreenConfig_weacts_get, _kahakai.ScreenConfig_weacts_set)
    __swig_setmethods__["eeacts"] = _kahakai.ScreenConfig_eeacts_set
    __swig_getmethods__["eeacts"] = _kahakai.ScreenConfig_eeacts_get
    if _newclass:eeacts = property(_kahakai.ScreenConfig_eeacts_get, _kahakai.ScreenConfig_eeacts_set)
    __swig_setmethods__["neacts"] = _kahakai.ScreenConfig_neacts_set
    __swig_getmethods__["neacts"] = _kahakai.ScreenConfig_neacts_get
    if _newclass:neacts = property(_kahakai.ScreenConfig_neacts_get, _kahakai.ScreenConfig_neacts_set)
    __swig_setmethods__["seacts"] = _kahakai.ScreenConfig_seacts_set
    __swig_getmethods__["seacts"] = _kahakai.ScreenConfig_seacts_get
    if _newclass:seacts = property(_kahakai.ScreenConfig_seacts_get, _kahakai.ScreenConfig_seacts_set)
    __swig_setmethods__["mtacts"] = _kahakai.ScreenConfig_mtacts_set
    __swig_getmethods__["mtacts"] = _kahakai.ScreenConfig_mtacts_get
    if _newclass:mtacts = property(_kahakai.ScreenConfig_mtacts_get, _kahakai.ScreenConfig_mtacts_set)
    __swig_setmethods__["miacts"] = _kahakai.ScreenConfig_miacts_set
    __swig_getmethods__["miacts"] = _kahakai.ScreenConfig_miacts_get
    if _newclass:miacts = property(_kahakai.ScreenConfig_miacts_get, _kahakai.ScreenConfig_miacts_set)
    __swig_setmethods__["msacts"] = _kahakai.ScreenConfig_msacts_set
    __swig_getmethods__["msacts"] = _kahakai.ScreenConfig_msacts_get
    if _newclass:msacts = property(_kahakai.ScreenConfig_msacts_get, _kahakai.ScreenConfig_msacts_set)
    __swig_setmethods__["mcbacts"] = _kahakai.ScreenConfig_mcbacts_set
    __swig_getmethods__["mcbacts"] = _kahakai.ScreenConfig_mcbacts_get
    if _newclass:mcbacts = property(_kahakai.ScreenConfig_mcbacts_get, _kahakai.ScreenConfig_mcbacts_set)
    __swig_setmethods__["lweacts"] = _kahakai.ScreenConfig_lweacts_set
    __swig_getmethods__["lweacts"] = _kahakai.ScreenConfig_lweacts_get
    if _newclass:lweacts = property(_kahakai.ScreenConfig_lweacts_get, _kahakai.ScreenConfig_lweacts_set)
    __swig_setmethods__["rweacts"] = _kahakai.ScreenConfig_rweacts_set
    __swig_getmethods__["rweacts"] = _kahakai.ScreenConfig_rweacts_get
    if _newclass:rweacts = property(_kahakai.ScreenConfig_rweacts_get, _kahakai.ScreenConfig_rweacts_set)
    __swig_setmethods__["bacts"] = _kahakai.ScreenConfig_bacts_set
    __swig_getmethods__["bacts"] = _kahakai.ScreenConfig_bacts_get
    if _newclass:bacts = property(_kahakai.ScreenConfig_bacts_get, _kahakai.ScreenConfig_bacts_set)
    __swig_setmethods__["desktop_names"] = _kahakai.ScreenConfig_desktop_names_set
    __swig_getmethods__["desktop_names"] = _kahakai.ScreenConfig_desktop_names_get
    if _newclass:desktop_names = property(_kahakai.ScreenConfig_desktop_names_get, _kahakai.ScreenConfig_desktop_names_set)
    __swig_setmethods__["rootCommand"] = _kahakai.ScreenConfig_rootCommand_set
    __swig_getmethods__["rootCommand"] = _kahakai.ScreenConfig_rootCommand_get
    if _newclass:rootCommand = property(_kahakai.ScreenConfig_rootCommand_get, _kahakai.ScreenConfig_rootCommand_set)
    __swig_setmethods__["menu_file_mtime"] = _kahakai.ScreenConfig_menu_file_mtime_set
    __swig_getmethods__["menu_file_mtime"] = _kahakai.ScreenConfig_menu_file_mtime_get
    if _newclass:menu_file_mtime = property(_kahakai.ScreenConfig_menu_file_mtime_get, _kahakai.ScreenConfig_menu_file_mtime_set)
    def __init__(self, *args): 
        this = _kahakai.new_ScreenConfig(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_ScreenConfig
    __del__ = lambda self : None;
ScreenConfig_swigregister = _kahakai.ScreenConfig_swigregister
ScreenConfig_swigregister(ScreenConfig)
cvar = _kahakai.cvar
WestDirection = cvar.WestDirection
EastDirection = cvar.EastDirection
NorthDirection = cvar.NorthDirection
SouthDirection = cvar.SouthDirection

class KaScreen(WindowObject):
    __swig_setmethods__ = {}
    for _s in [WindowObject]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, KaScreen, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowObject]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, KaScreen, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_KaScreen(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_KaScreen
    __del__ = lambda self : None;
    def RaiseWindow(*args): return _kahakai.KaScreen_RaiseWindow(*args)
    def RaiseWindowAllDesktops(*args): return _kahakai.KaScreen_RaiseWindowAllDesktops(*args)
    def LowerWindow(*args): return _kahakai.KaScreen_LowerWindow(*args)
    def LowerWindowAllDesktops(*args): return _kahakai.KaScreen_LowerWindowAllDesktops(*args)
    def RestackWindows(*args): return _kahakai.KaScreen_RestackWindows(*args)
    def UpdateCheckboxes(*args): return _kahakai.KaScreen_UpdateCheckboxes(*args)
    def ReloadMenu(*args): return _kahakai.KaScreen_ReloadMenu(*args)
    def CheckMenuMTime(*args): return _kahakai.KaScreen_CheckMenuMTime(*args)
    def GetMenuNamed(*args): return _kahakai.KaScreen_GetMenuNamed(*args)
    def CreateDynamicMenu(*args): return _kahakai.KaScreen_CreateDynamicMenu(*args)
    def MoveViewportTo(*args): return _kahakai.KaScreen_MoveViewportTo(*args)
    def MoveViewport(*args): return _kahakai.KaScreen_MoveViewport(*args)
    def UpdateWorkarea(*args): return _kahakai.KaScreen_UpdateWorkarea(*args)
    def GetWorkareaSize(*args): return _kahakai.KaScreen_GetWorkareaSize(*args)
    def GetWorkarea(*args): return _kahakai.KaScreen_GetWorkarea(*args)
    def AddDockapp(*args): return _kahakai.KaScreen_AddDockapp(*args)
    def SetSmartName(*args): return _kahakai.KaScreen_SetSmartName(*args)
    def SmartName(*args): return _kahakai.KaScreen_SmartName(*args)
    def SmartNameRemove(*args): return _kahakai.KaScreen_SmartNameRemove(*args)
    def ImodAdd(*args): return _kahakai.KaScreen_ImodAdd(*args)
    def QueryPointer(*args): return _kahakai.KaScreen_QueryPointer(*args)
    def MenuMap(*args): return _kahakai.KaScreen_MenuMap(*args)
    def MenuMapFocused(*args): return _kahakai.KaScreen_MenuMapFocused(*args)
    def MenuRemap(*args): return _kahakai.KaScreen_MenuRemap(*args)
    def MenuRemapFocused(*args): return _kahakai.KaScreen_MenuRemapFocused(*args)
    def ViewportMove(*args): return _kahakai.KaScreen_ViewportMove(*args)
    def EndMoveResize(*args): return _kahakai.KaScreen_EndMoveResize(*args)
    def Focus(*args): return _kahakai.KaScreen_Focus(*args)
    def MenuUnmap(*args): return _kahakai.KaScreen_MenuUnmap(*args)
    def MenuUnmapFocus(*args): return _kahakai.KaScreen_MenuUnmapFocus(*args)
    def Restart(*args): return _kahakai.KaScreen_Restart(*args)
    def Exit(*args): return _kahakai.KaScreen_Exit(*args)
    def TaskSwitcher(*args): return _kahakai.KaScreen_TaskSwitcher(*args)
    def PreviousTask(*args): return _kahakai.KaScreen_PreviousTask(*args)
    def NextTask(*args): return _kahakai.KaScreen_NextTask(*args)
    def PointerRelativeWarp(*args): return _kahakai.KaScreen_PointerRelativeWarp(*args)
    def PointerFixedWarp(*args): return _kahakai.KaScreen_PointerFixedWarp(*args)
    def ViewportRelativeMove(*args): return _kahakai.KaScreen_ViewportRelativeMove(*args)
    def ViewportFixedMove(*args): return _kahakai.KaScreen_ViewportFixedMove(*args)
    def GoToDesktop(*args): return _kahakai.KaScreen_GoToDesktop(*args)
    def NextDesktop(*args): return _kahakai.KaScreen_NextDesktop(*args)
    def PreviousDesktop(*args): return _kahakai.KaScreen_PreviousDesktop(*args)
    def CreateFonts(*args): return _kahakai.KaScreen_CreateFonts(*args)
    def MoveViewportLeft(*args): return _kahakai.KaScreen_MoveViewportLeft(*args)
    def MoveViewportRight(*args): return _kahakai.KaScreen_MoveViewportRight(*args)
    def MoveViewportUp(*args): return _kahakai.KaScreen_MoveViewportUp(*args)
    def MoveViewportDown(*args): return _kahakai.KaScreen_MoveViewportDown(*args)
    def MoveViewportWrapLeft(*args): return _kahakai.KaScreen_MoveViewportWrapLeft(*args)
    def MoveViewportWrapRight(*args): return _kahakai.KaScreen_MoveViewportWrapRight(*args)
    def MoveViewportWrapUp(*args): return _kahakai.KaScreen_MoveViewportWrapUp(*args)
    def MoveViewportWrapDown(*args): return _kahakai.KaScreen_MoveViewportWrapDown(*args)
    def FocusFreezeOn(*args): return _kahakai.KaScreen_FocusFreezeOn(*args)
    def FocusFreezeOff(*args): return _kahakai.KaScreen_FocusFreezeOff(*args)
    def FocusFreeze(*args): return _kahakai.KaScreen_FocusFreeze(*args)
    def UserFocusFreezeOn(*args): return _kahakai.KaScreen_UserFocusFreezeOn(*args)
    def UserFocusFreezeOff(*args): return _kahakai.KaScreen_UserFocusFreezeOff(*args)
    def UserFocusFreeze(*args): return _kahakai.KaScreen_UserFocusFreeze(*args)
    def DiscardEnterNotifies(*args): return _kahakai.KaScreen_DiscardEnterNotifies(*args)
    def DiscardEventsOfType(*args): return _kahakai.KaScreen_DiscardEventsOfType(*args)
    __swig_setmethods__["focus_freeze"] = _kahakai.KaScreen_focus_freeze_set
    __swig_getmethods__["focus_freeze"] = _kahakai.KaScreen_focus_freeze_get
    if _newclass:focus_freeze = property(_kahakai.KaScreen_focus_freeze_get, _kahakai.KaScreen_focus_freeze_set)
    __swig_setmethods__["user_focus_freeze"] = _kahakai.KaScreen_user_focus_freeze_set
    __swig_getmethods__["user_focus_freeze"] = _kahakai.KaScreen_user_focus_freeze_get
    if _newclass:user_focus_freeze = property(_kahakai.KaScreen_user_focus_freeze_get, _kahakai.KaScreen_user_focus_freeze_set)
    def Nop(*args): return _kahakai.KaScreen_Nop(*args)
    def EvAct(*args): return _kahakai.KaScreen_EvAct(*args)
    __swig_setmethods__["display"] = _kahakai.KaScreen_display_set
    __swig_getmethods__["display"] = _kahakai.KaScreen_display_get
    if _newclass:display = property(_kahakai.KaScreen_display_get, _kahakai.KaScreen_display_set)
    __swig_setmethods__["screen_number"] = _kahakai.KaScreen_screen_number_set
    __swig_getmethods__["screen_number"] = _kahakai.KaScreen_screen_number_get
    if _newclass:screen_number = property(_kahakai.KaScreen_screen_number_get, _kahakai.KaScreen_screen_number_set)
    __swig_setmethods__["screen_depth"] = _kahakai.KaScreen_screen_depth_set
    __swig_getmethods__["screen_depth"] = _kahakai.KaScreen_screen_depth_get
    if _newclass:screen_depth = property(_kahakai.KaScreen_screen_depth_get, _kahakai.KaScreen_screen_depth_set)
    __swig_setmethods__["width"] = _kahakai.KaScreen_width_set
    __swig_getmethods__["width"] = _kahakai.KaScreen_width_get
    if _newclass:width = property(_kahakai.KaScreen_width_get, _kahakai.KaScreen_width_set)
    __swig_setmethods__["height"] = _kahakai.KaScreen_height_set
    __swig_getmethods__["height"] = _kahakai.KaScreen_height_get
    if _newclass:height = property(_kahakai.KaScreen_height_get, _kahakai.KaScreen_height_set)
    __swig_setmethods__["v_x"] = _kahakai.KaScreen_v_x_set
    __swig_getmethods__["v_x"] = _kahakai.KaScreen_v_x_get
    if _newclass:v_x = property(_kahakai.KaScreen_v_x_get, _kahakai.KaScreen_v_x_set)
    __swig_setmethods__["v_y"] = _kahakai.KaScreen_v_y_set
    __swig_getmethods__["v_y"] = _kahakai.KaScreen_v_y_get
    if _newclass:v_y = property(_kahakai.KaScreen_v_y_get, _kahakai.KaScreen_v_y_set)
    __swig_setmethods__["v_xmax"] = _kahakai.KaScreen_v_xmax_set
    __swig_getmethods__["v_xmax"] = _kahakai.KaScreen_v_xmax_get
    if _newclass:v_xmax = property(_kahakai.KaScreen_v_xmax_get, _kahakai.KaScreen_v_xmax_set)
    __swig_setmethods__["v_ymax"] = _kahakai.KaScreen_v_ymax_set
    __swig_getmethods__["v_ymax"] = _kahakai.KaScreen_v_ymax_get
    if _newclass:v_ymax = property(_kahakai.KaScreen_v_ymax_get, _kahakai.KaScreen_v_ymax_set)
    __swig_setmethods__["colormap"] = _kahakai.KaScreen_colormap_set
    __swig_getmethods__["colormap"] = _kahakai.KaScreen_colormap_get
    if _newclass:colormap = property(_kahakai.KaScreen_colormap_get, _kahakai.KaScreen_colormap_set)
    __swig_setmethods__["visual"] = _kahakai.KaScreen_visual_set
    __swig_getmethods__["visual"] = _kahakai.KaScreen_visual_get
    if _newclass:visual = property(_kahakai.KaScreen_visual_get, _kahakai.KaScreen_visual_set)
    __swig_setmethods__["kahakai"] = _kahakai.KaScreen_kahakai_set
    __swig_getmethods__["kahakai"] = _kahakai.KaScreen_kahakai_get
    if _newclass:kahakai = property(_kahakai.KaScreen_kahakai_get, _kahakai.KaScreen_kahakai_set)
    __swig_setmethods__["net"] = _kahakai.KaScreen_net_set
    __swig_getmethods__["net"] = _kahakai.KaScreen_net_get
    if _newclass:net = property(_kahakai.KaScreen_net_get, _kahakai.KaScreen_net_set)
    __swig_setmethods__["rh"] = _kahakai.KaScreen_rh_set
    __swig_getmethods__["rh"] = _kahakai.KaScreen_rh_get
    if _newclass:rh = property(_kahakai.KaScreen_rh_get, _kahakai.KaScreen_rh_set)
    __swig_setmethods__["ic"] = _kahakai.KaScreen_ic_set
    __swig_getmethods__["ic"] = _kahakai.KaScreen_ic_get
    if _newclass:ic = property(_kahakai.KaScreen_ic_get, _kahakai.KaScreen_ic_set)
    __swig_setmethods__["control"] = _kahakai.KaScreen_control_set
    __swig_getmethods__["control"] = _kahakai.KaScreen_control_get
    if _newclass:control = property(_kahakai.KaScreen_control_get, _kahakai.KaScreen_control_set)
    __swig_setmethods__["style"] = _kahakai.KaScreen_style_set
    __swig_getmethods__["style"] = _kahakai.KaScreen_style_get
    if _newclass:style = property(_kahakai.KaScreen_style_get, _kahakai.KaScreen_style_set)
    __swig_setmethods__["config"] = _kahakai.KaScreen_config_set
    __swig_getmethods__["config"] = _kahakai.KaScreen_config_get
    if _newclass:config = property(_kahakai.KaScreen_config_get, _kahakai.KaScreen_config_set)
    __swig_setmethods__["default_font"] = _kahakai.KaScreen_default_font_set
    __swig_getmethods__["default_font"] = _kahakai.KaScreen_default_font_get
    if _newclass:default_font = property(_kahakai.KaScreen_default_font_get, _kahakai.KaScreen_default_font_set)
    __swig_setmethods__["def_font"] = _kahakai.KaScreen_def_font_set
    __swig_getmethods__["def_font"] = _kahakai.KaScreen_def_font_get
    if _newclass:def_font = property(_kahakai.KaScreen_def_font_get, _kahakai.KaScreen_def_font_set)
    __swig_setmethods__["window_menu"] = _kahakai.KaScreen_window_menu_set
    __swig_getmethods__["window_menu"] = _kahakai.KaScreen_window_menu_get
    if _newclass:window_menu = property(_kahakai.KaScreen_window_menu_get, _kahakai.KaScreen_window_menu_set)
    __swig_setmethods__["edgemgr"] = _kahakai.KaScreen_edgemgr_set
    __swig_getmethods__["edgemgr"] = _kahakai.KaScreen_edgemgr_get
    if _newclass:edgemgr = property(_kahakai.KaScreen_edgemgr_get, _kahakai.KaScreen_edgemgr_set)
    __swig_setmethods__["fgrip"] = _kahakai.KaScreen_fgrip_set
    __swig_getmethods__["fgrip"] = _kahakai.KaScreen_fgrip_get
    if _newclass:fgrip = property(_kahakai.KaScreen_fgrip_get, _kahakai.KaScreen_fgrip_set)
    __swig_setmethods__["ugrip"] = _kahakai.KaScreen_ugrip_set
    __swig_getmethods__["ugrip"] = _kahakai.KaScreen_ugrip_get
    if _newclass:ugrip = property(_kahakai.KaScreen_ugrip_get, _kahakai.KaScreen_ugrip_set)
    __swig_setmethods__["pdisplay"] = _kahakai.KaScreen_pdisplay_set
    __swig_getmethods__["pdisplay"] = _kahakai.KaScreen_pdisplay_get
    if _newclass:pdisplay = property(_kahakai.KaScreen_pdisplay_get, _kahakai.KaScreen_pdisplay_set)
    __swig_setmethods__["render_extension"] = _kahakai.KaScreen_render_extension_set
    __swig_getmethods__["render_extension"] = _kahakai.KaScreen_render_extension_get
    if _newclass:render_extension = property(_kahakai.KaScreen_render_extension_get, _kahakai.KaScreen_render_extension_set)
    __swig_setmethods__["xrootpmap_id"] = _kahakai.KaScreen_xrootpmap_id_set
    __swig_getmethods__["xrootpmap_id"] = _kahakai.KaScreen_xrootpmap_id_get
    if _newclass:xrootpmap_id = property(_kahakai.KaScreen_xrootpmap_id_get, _kahakai.KaScreen_xrootpmap_id_set)
    __swig_setmethods__["fbutton_pixel"] = _kahakai.KaScreen_fbutton_pixel_set
    __swig_getmethods__["fbutton_pixel"] = _kahakai.KaScreen_fbutton_pixel_get
    if _newclass:fbutton_pixel = property(_kahakai.KaScreen_fbutton_pixel_get, _kahakai.KaScreen_fbutton_pixel_set)
    __swig_setmethods__["ubutton_pixel"] = _kahakai.KaScreen_ubutton_pixel_set
    __swig_getmethods__["ubutton_pixel"] = _kahakai.KaScreen_ubutton_pixel_get
    if _newclass:ubutton_pixel = property(_kahakai.KaScreen_ubutton_pixel_get, _kahakai.KaScreen_ubutton_pixel_set)
    __swig_setmethods__["pbutton_pixel"] = _kahakai.KaScreen_pbutton_pixel_set
    __swig_getmethods__["pbutton_pixel"] = _kahakai.KaScreen_pbutton_pixel_get
    if _newclass:pbutton_pixel = property(_kahakai.KaScreen_pbutton_pixel_get, _kahakai.KaScreen_pbutton_pixel_set)
    __swig_setmethods__["fgrip_pixel"] = _kahakai.KaScreen_fgrip_pixel_set
    __swig_getmethods__["fgrip_pixel"] = _kahakai.KaScreen_fgrip_pixel_get
    if _newclass:fgrip_pixel = property(_kahakai.KaScreen_fgrip_pixel_get, _kahakai.KaScreen_fgrip_pixel_set)
    __swig_setmethods__["ugrip_pixel"] = _kahakai.KaScreen_ugrip_pixel_set
    __swig_getmethods__["ugrip_pixel"] = _kahakai.KaScreen_ugrip_pixel_get
    if _newclass:ugrip_pixel = property(_kahakai.KaScreen_ugrip_pixel_get, _kahakai.KaScreen_ugrip_pixel_set)
    __swig_setmethods__["displaystring"] = _kahakai.KaScreen_displaystring_set
    __swig_getmethods__["displaystring"] = _kahakai.KaScreen_displaystring_get
    if _newclass:displaystring = property(_kahakai.KaScreen_displaystring_get, _kahakai.KaScreen_displaystring_set)
    __swig_setmethods__["west"] = _kahakai.KaScreen_west_set
    __swig_getmethods__["west"] = _kahakai.KaScreen_west_get
    if _newclass:west = property(_kahakai.KaScreen_west_get, _kahakai.KaScreen_west_set)
    __swig_setmethods__["east"] = _kahakai.KaScreen_east_set
    __swig_getmethods__["east"] = _kahakai.KaScreen_east_get
    if _newclass:east = property(_kahakai.KaScreen_east_get, _kahakai.KaScreen_east_set)
    __swig_setmethods__["north"] = _kahakai.KaScreen_north_set
    __swig_getmethods__["north"] = _kahakai.KaScreen_north_get
    if _newclass:north = property(_kahakai.KaScreen_north_get, _kahakai.KaScreen_north_set)
    __swig_setmethods__["south"] = _kahakai.KaScreen_south_set
    __swig_getmethods__["south"] = _kahakai.KaScreen_south_get
    if _newclass:south = property(_kahakai.KaScreen_south_get, _kahakai.KaScreen_south_set)
    __swig_setmethods__["wm_check"] = _kahakai.KaScreen_wm_check_set
    __swig_getmethods__["wm_check"] = _kahakai.KaScreen_wm_check_get
    if _newclass:wm_check = property(_kahakai.KaScreen_wm_check_get, _kahakai.KaScreen_wm_check_set)
    __swig_setmethods__["focus"] = _kahakai.KaScreen_focus_set
    __swig_getmethods__["focus"] = _kahakai.KaScreen_focus_get
    if _newclass:focus = property(_kahakai.KaScreen_focus_get, _kahakai.KaScreen_focus_set)
    __swig_setmethods__["shutdown"] = _kahakai.KaScreen_shutdown_set
    __swig_getmethods__["shutdown"] = _kahakai.KaScreen_shutdown_get
    if _newclass:shutdown = property(_kahakai.KaScreen_shutdown_get, _kahakai.KaScreen_shutdown_set)
    __swig_setmethods__["desktop_list"] = _kahakai.KaScreen_desktop_list_set
    __swig_getmethods__["desktop_list"] = _kahakai.KaScreen_desktop_list_get
    if _newclass:desktop_list = property(_kahakai.KaScreen_desktop_list_get, _kahakai.KaScreen_desktop_list_set)
    __swig_setmethods__["current_desktop"] = _kahakai.KaScreen_current_desktop_set
    __swig_getmethods__["current_desktop"] = _kahakai.KaScreen_current_desktop_get
    if _newclass:current_desktop = property(_kahakai.KaScreen_current_desktop_get, _kahakai.KaScreen_current_desktop_set)
    __swig_setmethods__["imod_list"] = _kahakai.KaScreen_imod_list_set
    __swig_getmethods__["imod_list"] = _kahakai.KaScreen_imod_list_get
    if _newclass:imod_list = property(_kahakai.KaScreen_imod_list_get, _kahakai.KaScreen_imod_list_set)
    __swig_setmethods__["imod_mask"] = _kahakai.KaScreen_imod_mask_set
    __swig_getmethods__["imod_mask"] = _kahakai.KaScreen_imod_mask_get
    if _newclass:imod_mask = property(_kahakai.KaScreen_imod_mask_get, _kahakai.KaScreen_imod_mask_set)
    __swig_setmethods__["kawindow_list"] = _kahakai.KaScreen_kawindow_list_set
    __swig_getmethods__["kawindow_list"] = _kahakai.KaScreen_kawindow_list_get
    if _newclass:kawindow_list = property(_kahakai.KaScreen_kawindow_list_get, _kahakai.KaScreen_kawindow_list_set)
    __swig_setmethods__["kawindow_list_map_order"] = _kahakai.KaScreen_kawindow_list_map_order_set
    __swig_getmethods__["kawindow_list_map_order"] = _kahakai.KaScreen_kawindow_list_map_order_get
    if _newclass:kawindow_list_map_order = property(_kahakai.KaScreen_kawindow_list_map_order_get, _kahakai.KaScreen_kawindow_list_map_order_set)
    __swig_setmethods__["kamenu_list"] = _kahakai.KaScreen_kamenu_list_set
    __swig_getmethods__["kamenu_list"] = _kahakai.KaScreen_kamenu_list_get
    if _newclass:kamenu_list = property(_kahakai.KaScreen_kamenu_list_get, _kahakai.KaScreen_kamenu_list_set)
    __swig_setmethods__["strut_list"] = _kahakai.KaScreen_strut_list_set
    __swig_getmethods__["strut_list"] = _kahakai.KaScreen_strut_list_get
    if _newclass:strut_list = property(_kahakai.KaScreen_strut_list_get, _kahakai.KaScreen_strut_list_set)
    __swig_setmethods__["docks"] = _kahakai.KaScreen_docks_set
    __swig_getmethods__["docks"] = _kahakai.KaScreen_docks_get
    if _newclass:docks = property(_kahakai.KaScreen_docks_get, _kahakai.KaScreen_docks_set)
    __swig_setmethods__["systray_window_list"] = _kahakai.KaScreen_systray_window_list_set
    __swig_getmethods__["systray_window_list"] = _kahakai.KaScreen_systray_window_list_get
    if _newclass:systray_window_list = property(_kahakai.KaScreen_systray_window_list_get, _kahakai.KaScreen_systray_window_list_set)
    __swig_setmethods__["mreqs"] = _kahakai.KaScreen_mreqs_set
    __swig_getmethods__["mreqs"] = _kahakai.KaScreen_mreqs_get
    if _newclass:mreqs = property(_kahakai.KaScreen_mreqs_get, _kahakai.KaScreen_mreqs_set)
KaScreen_swigregister = _kahakai.KaScreen_swigregister
KaScreen_swigregister(KaScreen)

class ScreenEdgeManager(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEdgeManager, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEdgeManager, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEdgeManager(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_ScreenEdgeManager
    __del__ = lambda self : None;
    __swig_setmethods__["n"] = _kahakai.ScreenEdgeManager_n_set
    __swig_getmethods__["n"] = _kahakai.ScreenEdgeManager_n_get
    if _newclass:n = property(_kahakai.ScreenEdgeManager_n_get, _kahakai.ScreenEdgeManager_n_set)
    __swig_setmethods__["s"] = _kahakai.ScreenEdgeManager_s_set
    __swig_getmethods__["s"] = _kahakai.ScreenEdgeManager_s_get
    if _newclass:s = property(_kahakai.ScreenEdgeManager_s_get, _kahakai.ScreenEdgeManager_s_set)
    __swig_setmethods__["e"] = _kahakai.ScreenEdgeManager_e_set
    __swig_getmethods__["e"] = _kahakai.ScreenEdgeManager_e_get
    if _newclass:e = property(_kahakai.ScreenEdgeManager_e_get, _kahakai.ScreenEdgeManager_e_set)
    __swig_setmethods__["w"] = _kahakai.ScreenEdgeManager_w_set
    __swig_getmethods__["w"] = _kahakai.ScreenEdgeManager_w_get
    if _newclass:w = property(_kahakai.ScreenEdgeManager_w_get, _kahakai.ScreenEdgeManager_w_set)
ScreenEdgeManager_swigregister = _kahakai.ScreenEdgeManager_swigregister
ScreenEdgeManager_swigregister(ScreenEdgeManager)

class ScreenEvGoToDesktop(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvGoToDesktop, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvGoToDesktop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvGoToDesktop(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvGoToDesktop___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvGoToDesktop
    __del__ = lambda self : None;
ScreenEvGoToDesktop_swigregister = _kahakai.ScreenEvGoToDesktop_swigregister
ScreenEvGoToDesktop_swigregister(ScreenEvGoToDesktop)

class ScreenEvViewportFixedMove(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvViewportFixedMove, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvViewportFixedMove, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvViewportFixedMove(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvViewportFixedMove___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvViewportFixedMove
    __del__ = lambda self : None;
ScreenEvViewportFixedMove_swigregister = _kahakai.ScreenEvViewportFixedMove_swigregister
ScreenEvViewportFixedMove_swigregister(ScreenEvViewportFixedMove)

class ScreenEvMoveViewportLeft(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvMoveViewportLeft, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvMoveViewportLeft, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvMoveViewportLeft(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvMoveViewportLeft___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvMoveViewportLeft
    __del__ = lambda self : None;
ScreenEvMoveViewportLeft_swigregister = _kahakai.ScreenEvMoveViewportLeft_swigregister
ScreenEvMoveViewportLeft_swigregister(ScreenEvMoveViewportLeft)

class ScreenEvMoveViewportRight(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvMoveViewportRight, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvMoveViewportRight, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvMoveViewportRight(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvMoveViewportRight___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvMoveViewportRight
    __del__ = lambda self : None;
ScreenEvMoveViewportRight_swigregister = _kahakai.ScreenEvMoveViewportRight_swigregister
ScreenEvMoveViewportRight_swigregister(ScreenEvMoveViewportRight)

class ScreenEvMoveViewportUp(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvMoveViewportUp, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvMoveViewportUp, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvMoveViewportUp(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvMoveViewportUp___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvMoveViewportUp
    __del__ = lambda self : None;
ScreenEvMoveViewportUp_swigregister = _kahakai.ScreenEvMoveViewportUp_swigregister
ScreenEvMoveViewportUp_swigregister(ScreenEvMoveViewportUp)

class ScreenEvMoveViewportDown(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvMoveViewportDown, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvMoveViewportDown, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvMoveViewportDown(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvMoveViewportDown___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvMoveViewportDown
    __del__ = lambda self : None;
ScreenEvMoveViewportDown_swigregister = _kahakai.ScreenEvMoveViewportDown_swigregister
ScreenEvMoveViewportDown_swigregister(ScreenEvMoveViewportDown)

class ScreenEvMoveViewportWrapLeft(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvMoveViewportWrapLeft, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvMoveViewportWrapLeft, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvMoveViewportWrapLeft(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvMoveViewportWrapLeft___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvMoveViewportWrapLeft
    __del__ = lambda self : None;
ScreenEvMoveViewportWrapLeft_swigregister = _kahakai.ScreenEvMoveViewportWrapLeft_swigregister
ScreenEvMoveViewportWrapLeft_swigregister(ScreenEvMoveViewportWrapLeft)

class ScreenEvMoveViewportWrapRight(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvMoveViewportWrapRight, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvMoveViewportWrapRight, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvMoveViewportWrapRight(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvMoveViewportWrapRight___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvMoveViewportWrapRight
    __del__ = lambda self : None;
ScreenEvMoveViewportWrapRight_swigregister = _kahakai.ScreenEvMoveViewportWrapRight_swigregister
ScreenEvMoveViewportWrapRight_swigregister(ScreenEvMoveViewportWrapRight)

class ScreenEvMoveViewportWrapUp(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvMoveViewportWrapUp, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvMoveViewportWrapUp, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvMoveViewportWrapUp(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvMoveViewportWrapUp___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvMoveViewportWrapUp
    __del__ = lambda self : None;
ScreenEvMoveViewportWrapUp_swigregister = _kahakai.ScreenEvMoveViewportWrapUp_swigregister
ScreenEvMoveViewportWrapUp_swigregister(ScreenEvMoveViewportWrapUp)

class ScreenEvMoveViewportWrapDown(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvMoveViewportWrapDown, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvMoveViewportWrapDown, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvMoveViewportWrapDown(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvMoveViewportWrapDown___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvMoveViewportWrapDown
    __del__ = lambda self : None;
ScreenEvMoveViewportWrapDown_swigregister = _kahakai.ScreenEvMoveViewportWrapDown_swigregister
ScreenEvMoveViewportWrapDown_swigregister(ScreenEvMoveViewportWrapDown)

class ScreenEvReloadMenu(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvReloadMenu, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvReloadMenu, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvReloadMenu(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvReloadMenu___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvReloadMenu
    __del__ = lambda self : None;
ScreenEvReloadMenu_swigregister = _kahakai.ScreenEvReloadMenu_swigregister
ScreenEvReloadMenu_swigregister(ScreenEvReloadMenu)

class ScreenEvMenuMap(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvMenuMap, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvMenuMap, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvMenuMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvMenuMap___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvMenuMap
    __del__ = lambda self : None;
ScreenEvMenuMap_swigregister = _kahakai.ScreenEvMenuMap_swigregister
ScreenEvMenuMap_swigregister(ScreenEvMenuMap)

class ScreenEvMenuMapFocused(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvMenuMapFocused, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvMenuMapFocused, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvMenuMapFocused(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvMenuMapFocused___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvMenuMapFocused
    __del__ = lambda self : None;
ScreenEvMenuMapFocused_swigregister = _kahakai.ScreenEvMenuMapFocused_swigregister
ScreenEvMenuMapFocused_swigregister(ScreenEvMenuMapFocused)

class ScreenEvMenuRemap(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvMenuRemap, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvMenuRemap, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvMenuRemap(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvMenuRemap___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvMenuRemap
    __del__ = lambda self : None;
ScreenEvMenuRemap_swigregister = _kahakai.ScreenEvMenuRemap_swigregister
ScreenEvMenuRemap_swigregister(ScreenEvMenuRemap)

class ScreenEvMenuRemapFocused(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvMenuRemapFocused, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvMenuRemapFocused, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvMenuRemapFocused(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvMenuRemapFocused___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvMenuRemapFocused
    __del__ = lambda self : None;
ScreenEvMenuRemapFocused_swigregister = _kahakai.ScreenEvMenuRemapFocused_swigregister
ScreenEvMenuRemapFocused_swigregister(ScreenEvMenuRemapFocused)

class ScreenEvMenuUnmap(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvMenuUnmap, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvMenuUnmap, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvMenuUnmap(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvMenuUnmap___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvMenuUnmap
    __del__ = lambda self : None;
ScreenEvMenuUnmap_swigregister = _kahakai.ScreenEvMenuUnmap_swigregister
ScreenEvMenuUnmap_swigregister(ScreenEvMenuUnmap)

class ScreenEvMenuUnmapFocus(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvMenuUnmapFocus, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvMenuUnmapFocus, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvMenuUnmapFocus(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvMenuUnmapFocus___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvMenuUnmapFocus
    __del__ = lambda self : None;
ScreenEvMenuUnmapFocus_swigregister = _kahakai.ScreenEvMenuUnmapFocus_swigregister
ScreenEvMenuUnmapFocus_swigregister(ScreenEvMenuUnmapFocus)

class ScreenEvViewportMove(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvViewportMove, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvViewportMove, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvViewportMove(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvViewportMove___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvViewportMove
    __del__ = lambda self : None;
ScreenEvViewportMove_swigregister = _kahakai.ScreenEvViewportMove_swigregister
ScreenEvViewportMove_swigregister(ScreenEvViewportMove)

class ScreenEvViewportRelativeMove(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvViewportRelativeMove, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvViewportRelativeMove, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvViewportRelativeMove(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvViewportRelativeMove___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvViewportRelativeMove
    __del__ = lambda self : None;
ScreenEvViewportRelativeMove_swigregister = _kahakai.ScreenEvViewportRelativeMove_swigregister
ScreenEvViewportRelativeMove_swigregister(ScreenEvViewportRelativeMove)

class ScreenEvEndMoveResize(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvEndMoveResize, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvEndMoveResize, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvEndMoveResize(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvEndMoveResize___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvEndMoveResize
    __del__ = lambda self : None;
ScreenEvEndMoveResize_swigregister = _kahakai.ScreenEvEndMoveResize_swigregister
ScreenEvEndMoveResize_swigregister(ScreenEvEndMoveResize)

class ScreenEvFocus(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvFocus, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvFocus, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvFocus(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvFocus___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvFocus
    __del__ = lambda self : None;
ScreenEvFocus_swigregister = _kahakai.ScreenEvFocus_swigregister
ScreenEvFocus_swigregister(ScreenEvFocus)

class ScreenEvRestart(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvRestart, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvRestart, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvRestart(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvRestart___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvRestart
    __del__ = lambda self : None;
ScreenEvRestart_swigregister = _kahakai.ScreenEvRestart_swigregister
ScreenEvRestart_swigregister(ScreenEvRestart)

class ScreenEvExit(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvExit, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvExit, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvExit(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvExit___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvExit
    __del__ = lambda self : None;
ScreenEvExit_swigregister = _kahakai.ScreenEvExit_swigregister
ScreenEvExit_swigregister(ScreenEvExit)

class ScreenEvTaskSwitcher(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvTaskSwitcher, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvTaskSwitcher, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvTaskSwitcher(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvTaskSwitcher___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvTaskSwitcher
    __del__ = lambda self : None;
ScreenEvTaskSwitcher_swigregister = _kahakai.ScreenEvTaskSwitcher_swigregister
ScreenEvTaskSwitcher_swigregister(ScreenEvTaskSwitcher)

class ScreenEvNextTask(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvNextTask, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvNextTask, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvNextTask(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvNextTask___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvNextTask
    __del__ = lambda self : None;
ScreenEvNextTask_swigregister = _kahakai.ScreenEvNextTask_swigregister
ScreenEvNextTask_swigregister(ScreenEvNextTask)

class ScreenEvPreviousTask(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvPreviousTask, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvPreviousTask, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvPreviousTask(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvPreviousTask___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvPreviousTask
    __del__ = lambda self : None;
ScreenEvPreviousTask_swigregister = _kahakai.ScreenEvPreviousTask_swigregister
ScreenEvPreviousTask_swigregister(ScreenEvPreviousTask)

class ScreenEvPointerFixedWarp(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvPointerFixedWarp, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvPointerFixedWarp, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvPointerFixedWarp(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvPointerFixedWarp___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvPointerFixedWarp
    __del__ = lambda self : None;
ScreenEvPointerFixedWarp_swigregister = _kahakai.ScreenEvPointerFixedWarp_swigregister
ScreenEvPointerFixedWarp_swigregister(ScreenEvPointerFixedWarp)

class ScreenEvPointerRelativeWarp(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvPointerRelativeWarp, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvPointerRelativeWarp, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvPointerRelativeWarp(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvPointerRelativeWarp___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvPointerRelativeWarp
    __del__ = lambda self : None;
ScreenEvPointerRelativeWarp_swigregister = _kahakai.ScreenEvPointerRelativeWarp_swigregister
ScreenEvPointerRelativeWarp_swigregister(ScreenEvPointerRelativeWarp)

class ScreenEvNextDesktop(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvNextDesktop, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvNextDesktop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvNextDesktop(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvNextDesktop___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvNextDesktop
    __del__ = lambda self : None;
ScreenEvNextDesktop_swigregister = _kahakai.ScreenEvNextDesktop_swigregister
ScreenEvNextDesktop_swigregister(ScreenEvNextDesktop)

class ScreenEvPreviousDesktop(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvPreviousDesktop, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvPreviousDesktop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvPreviousDesktop(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvPreviousDesktop___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvPreviousDesktop
    __del__ = lambda self : None;
ScreenEvPreviousDesktop_swigregister = _kahakai.ScreenEvPreviousDesktop_swigregister
ScreenEvPreviousDesktop_swigregister(ScreenEvPreviousDesktop)

class ScreenEvNop(ScreenFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenEvNop, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenEvNop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_ScreenEvNop(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.ScreenEvNop___call__(*args)
    __swig_destroy__ = _kahakai.delete_ScreenEvNop
    __del__ = lambda self : None;
ScreenEvNop_swigregister = _kahakai.ScreenEvNop_swigregister
ScreenEvNop_swigregister(ScreenEvNop)

SCRIPT_DIR_MAX_LENGTH = _kahakai.SCRIPT_DIR_MAX_LENGTH
VerticalDock = _kahakai.VerticalDock
HorizontalDock = _kahakai.HorizontalDock
AlwaysOnTop = _kahakai.AlwaysOnTop
AlwaysAtBottom = _kahakai.AlwaysAtBottom
NormalStacking = _kahakai.NormalStacking
NameMatchType = _kahakai.NameMatchType
ClassMatchType = _kahakai.ClassMatchType
TitleMatchType = _kahakai.TitleMatchType
WindowFuncMask = _kahakai.WindowFuncMask
RootFuncMask = _kahakai.RootFuncMask
MenuFuncMask = _kahakai.MenuFuncMask
strtrim = _kahakai.strtrim
environment_expansion = _kahakai.environment_expansion
MenuExecMask = _kahakai.MenuExecMask
MenuSubMask = _kahakai.MenuSubMask
MenuWFuncMask = _kahakai.MenuWFuncMask
MenuRFuncMask = _kahakai.MenuRFuncMask
MenuMFuncMask = _kahakai.MenuMFuncMask
NoExtMenuType = _kahakai.NoExtMenuType
TaskExtMenuType = _kahakai.TaskExtMenuType
DesktopExtMenuType = _kahakai.DesktopExtMenuType
MinimizedExtMenuType = _kahakai.MinimizedExtMenuType
class KaMenu(WindowObject):
    __swig_setmethods__ = {}
    for _s in [WindowObject]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, KaMenu, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowObject]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, KaMenu, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_KaMenu(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_KaMenu
    __del__ = lambda self : None;
    def AddItem(*args): return _kahakai.KaMenu_AddItem(*args)
    def Build(*args): return _kahakai.KaMenu_Build(*args)
    def Shape(*args): return _kahakai.KaMenu_Shape(*args)
    def Render(*args): return _kahakai.KaMenu_Render(*args)
    def Map(*args): return _kahakai.KaMenu_Map(*args)
    def ReMap(*args): return _kahakai.KaMenu_ReMap(*args)
    def Move(*args): return _kahakai.KaMenu_Move(*args)
    def Unmap(*args): return _kahakai.KaMenu_Unmap(*args)
    def UnmapSubmenus(*args): return _kahakai.KaMenu_UnmapSubmenus(*args)
    def UnmapTree(*args): return _kahakai.KaMenu_UnmapTree(*args)
    def CreateOutline(*args): return _kahakai.KaMenu_CreateOutline(*args)
    def DestroyOutline(*args): return _kahakai.KaMenu_DestroyOutline(*args)
    def DrawOutline(*args): return _kahakai.KaMenu_DrawOutline(*args)
    def Raise(*args): return _kahakai.KaMenu_Raise(*args)
    def Lower(*args): return _kahakai.KaMenu_Lower(*args)
    def FocusItem(*args): return _kahakai.KaMenu_FocusItem(*args)
    def FocusFirst(*args): return _kahakai.KaMenu_FocusFirst(*args)
    def clearCache(*args): return _kahakai.KaMenu_clearCache(*args)
    __swig_setmethods__["kahakai"] = _kahakai.KaMenu_kahakai_set
    __swig_getmethods__["kahakai"] = _kahakai.KaMenu_kahakai_get
    if _newclass:kahakai = property(_kahakai.KaMenu_kahakai_get, _kahakai.KaMenu_kahakai_set)
    __swig_setmethods__["display"] = _kahakai.KaMenu_display_set
    __swig_getmethods__["display"] = _kahakai.KaMenu_display_get
    if _newclass:display = property(_kahakai.KaMenu_display_get, _kahakai.KaMenu_display_set)
    __swig_setmethods__["kascreen"] = _kahakai.KaMenu_kascreen_set
    __swig_getmethods__["kascreen"] = _kahakai.KaMenu_kascreen_get
    if _newclass:kascreen = property(_kahakai.KaMenu_kascreen_get, _kahakai.KaMenu_kascreen_set)
    __swig_setmethods__["ic"] = _kahakai.KaMenu_ic_set
    __swig_getmethods__["ic"] = _kahakai.KaMenu_ic_get
    if _newclass:ic = property(_kahakai.KaMenu_ic_get, _kahakai.KaMenu_ic_set)
    __swig_setmethods__["item_list"] = _kahakai.KaMenu_item_list_set
    __swig_getmethods__["item_list"] = _kahakai.KaMenu_item_list_get
    if _newclass:item_list = property(_kahakai.KaMenu_item_list_get, _kahakai.KaMenu_item_list_set)
    __swig_setmethods__["frame"] = _kahakai.KaMenu_frame_set
    __swig_getmethods__["frame"] = _kahakai.KaMenu_frame_get
    if _newclass:frame = property(_kahakai.KaMenu_frame_get, _kahakai.KaMenu_frame_set)
    __swig_setmethods__["o_west"] = _kahakai.KaMenu_o_west_set
    __swig_getmethods__["o_west"] = _kahakai.KaMenu_o_west_get
    if _newclass:o_west = property(_kahakai.KaMenu_o_west_get, _kahakai.KaMenu_o_west_set)
    __swig_setmethods__["o_north"] = _kahakai.KaMenu_o_north_set
    __swig_getmethods__["o_north"] = _kahakai.KaMenu_o_north_get
    if _newclass:o_north = property(_kahakai.KaMenu_o_north_get, _kahakai.KaMenu_o_north_set)
    __swig_setmethods__["o_south"] = _kahakai.KaMenu_o_south_set
    __swig_getmethods__["o_south"] = _kahakai.KaMenu_o_south_get
    if _newclass:o_south = property(_kahakai.KaMenu_o_south_get, _kahakai.KaMenu_o_south_set)
    __swig_setmethods__["o_east"] = _kahakai.KaMenu_o_east_set
    __swig_getmethods__["o_east"] = _kahakai.KaMenu_o_east_get
    if _newclass:o_east = property(_kahakai.KaMenu_o_east_get, _kahakai.KaMenu_o_east_set)
    __swig_setmethods__["x"] = _kahakai.KaMenu_x_set
    __swig_getmethods__["x"] = _kahakai.KaMenu_x_get
    if _newclass:x = property(_kahakai.KaMenu_x_get, _kahakai.KaMenu_x_set)
    __swig_setmethods__["y"] = _kahakai.KaMenu_y_set
    __swig_getmethods__["y"] = _kahakai.KaMenu_y_get
    if _newclass:y = property(_kahakai.KaMenu_y_get, _kahakai.KaMenu_y_set)
    __swig_setmethods__["width"] = _kahakai.KaMenu_width_set
    __swig_getmethods__["width"] = _kahakai.KaMenu_width_get
    if _newclass:width = property(_kahakai.KaMenu_width_get, _kahakai.KaMenu_width_set)
    __swig_setmethods__["height"] = _kahakai.KaMenu_height_set
    __swig_getmethods__["height"] = _kahakai.KaMenu_height_get
    if _newclass:height = property(_kahakai.KaMenu_height_get, _kahakai.KaMenu_height_set)
    __swig_setmethods__["bullet_width"] = _kahakai.KaMenu_bullet_width_set
    __swig_getmethods__["bullet_width"] = _kahakai.KaMenu_bullet_width_get
    if _newclass:bullet_width = property(_kahakai.KaMenu_bullet_width_get, _kahakai.KaMenu_bullet_width_set)
    __swig_setmethods__["cb_width"] = _kahakai.KaMenu_cb_width_set
    __swig_getmethods__["cb_width"] = _kahakai.KaMenu_cb_width_get
    if _newclass:cb_width = property(_kahakai.KaMenu_cb_width_get, _kahakai.KaMenu_cb_width_set)
    __swig_setmethods__["extra_width"] = _kahakai.KaMenu_extra_width_set
    __swig_getmethods__["extra_width"] = _kahakai.KaMenu_extra_width_get
    if _newclass:extra_width = property(_kahakai.KaMenu_extra_width_get, _kahakai.KaMenu_extra_width_set)
    __swig_setmethods__["mapped"] = _kahakai.KaMenu_mapped_set
    __swig_getmethods__["mapped"] = _kahakai.KaMenu_mapped_get
    if _newclass:mapped = property(_kahakai.KaMenu_mapped_get, _kahakai.KaMenu_mapped_set)
    __swig_setmethods__["built"] = _kahakai.KaMenu_built_set
    __swig_getmethods__["built"] = _kahakai.KaMenu_built_get
    if _newclass:built = property(_kahakai.KaMenu_built_get, _kahakai.KaMenu_built_set)
    __swig_setmethods__["has_focus"] = _kahakai.KaMenu_has_focus_set
    __swig_getmethods__["has_focus"] = _kahakai.KaMenu_has_focus_get
    if _newclass:has_focus = property(_kahakai.KaMenu_has_focus_get, _kahakai.KaMenu_has_focus_set)
    __swig_setmethods__["dynamic"] = _kahakai.KaMenu_dynamic_set
    __swig_getmethods__["dynamic"] = _kahakai.KaMenu_dynamic_get
    if _newclass:dynamic = property(_kahakai.KaMenu_dynamic_get, _kahakai.KaMenu_dynamic_set)
    __swig_setmethods__["dynamic_root"] = _kahakai.KaMenu_dynamic_root_set
    __swig_getmethods__["dynamic_root"] = _kahakai.KaMenu_dynamic_root_get
    if _newclass:dynamic_root = property(_kahakai.KaMenu_dynamic_root_get, _kahakai.KaMenu_dynamic_root_set)
    __swig_setmethods__["ignore"] = _kahakai.KaMenu_ignore_set
    __swig_getmethods__["ignore"] = _kahakai.KaMenu_ignore_get
    if _newclass:ignore = property(_kahakai.KaMenu_ignore_get, _kahakai.KaMenu_ignore_set)
    __swig_setmethods__["db"] = _kahakai.KaMenu_db_set
    __swig_getmethods__["db"] = _kahakai.KaMenu_db_get
    if _newclass:db = property(_kahakai.KaMenu_db_get, _kahakai.KaMenu_db_set)
    __swig_setmethods__["cb_db_upd"] = _kahakai.KaMenu_cb_db_upd_set
    __swig_getmethods__["cb_db_upd"] = _kahakai.KaMenu_cb_db_upd_get
    if _newclass:cb_db_upd = property(_kahakai.KaMenu_cb_db_upd_get, _kahakai.KaMenu_cb_db_upd_set)
    __swig_setmethods__["need_delete"] = _kahakai.KaMenu_need_delete_set
    __swig_getmethods__["need_delete"] = _kahakai.KaMenu_need_delete_get
    if _newclass:need_delete = property(_kahakai.KaMenu_need_delete_get, _kahakai.KaMenu_need_delete_set)
    __swig_setmethods__["name"] = _kahakai.KaMenu_name_set
    __swig_getmethods__["name"] = _kahakai.KaMenu_name_get
    if _newclass:name = property(_kahakai.KaMenu_name_get, _kahakai.KaMenu_name_set)
    __swig_setmethods__["pbackframe"] = _kahakai.KaMenu_pbackframe_set
    __swig_getmethods__["pbackframe"] = _kahakai.KaMenu_pbackframe_get
    if _newclass:pbackframe = property(_kahakai.KaMenu_pbackframe_get, _kahakai.KaMenu_pbackframe_set)
    __swig_setmethods__["ptitle"] = _kahakai.KaMenu_ptitle_set
    __swig_getmethods__["ptitle"] = _kahakai.KaMenu_ptitle_get
    if _newclass:ptitle = property(_kahakai.KaMenu_ptitle_get, _kahakai.KaMenu_ptitle_set)
    __swig_setmethods__["philite"] = _kahakai.KaMenu_philite_set
    __swig_getmethods__["philite"] = _kahakai.KaMenu_philite_get
    if _newclass:philite = property(_kahakai.KaMenu_philite_get, _kahakai.KaMenu_philite_set)
    __swig_setmethods__["psub"] = _kahakai.KaMenu_psub_set
    __swig_getmethods__["psub"] = _kahakai.KaMenu_psub_get
    if _newclass:psub = property(_kahakai.KaMenu_psub_get, _kahakai.KaMenu_psub_set)
    __swig_setmethods__["psubhilite"] = _kahakai.KaMenu_psubhilite_set
    __swig_getmethods__["psubhilite"] = _kahakai.KaMenu_psubhilite_get
    if _newclass:psubhilite = property(_kahakai.KaMenu_psubhilite_get, _kahakai.KaMenu_psubhilite_set)
    __swig_setmethods__["backframe_pixel"] = _kahakai.KaMenu_backframe_pixel_set
    __swig_getmethods__["backframe_pixel"] = _kahakai.KaMenu_backframe_pixel_get
    if _newclass:backframe_pixel = property(_kahakai.KaMenu_backframe_pixel_get, _kahakai.KaMenu_backframe_pixel_set)
    __swig_setmethods__["title_pixel"] = _kahakai.KaMenu_title_pixel_set
    __swig_getmethods__["title_pixel"] = _kahakai.KaMenu_title_pixel_get
    if _newclass:title_pixel = property(_kahakai.KaMenu_title_pixel_get, _kahakai.KaMenu_title_pixel_set)
    __swig_setmethods__["hilite_pixel"] = _kahakai.KaMenu_hilite_pixel_set
    __swig_getmethods__["hilite_pixel"] = _kahakai.KaMenu_hilite_pixel_get
    if _newclass:hilite_pixel = property(_kahakai.KaMenu_hilite_pixel_get, _kahakai.KaMenu_hilite_pixel_set)
    __swig_setmethods__["sub_pixel"] = _kahakai.KaMenu_sub_pixel_set
    __swig_getmethods__["sub_pixel"] = _kahakai.KaMenu_sub_pixel_get
    if _newclass:sub_pixel = property(_kahakai.KaMenu_sub_pixel_get, _kahakai.KaMenu_sub_pixel_set)
    __swig_setmethods__["subhilite_pixel"] = _kahakai.KaMenu_subhilite_pixel_set
    __swig_getmethods__["subhilite_pixel"] = _kahakai.KaMenu_subhilite_pixel_get
    if _newclass:subhilite_pixel = property(_kahakai.KaMenu_subhilite_pixel_get, _kahakai.KaMenu_subhilite_pixel_set)
    __swig_setmethods__["root_menu"] = _kahakai.KaMenu_root_menu_set
    __swig_getmethods__["root_menu"] = _kahakai.KaMenu_root_menu_get
    if _newclass:root_menu = property(_kahakai.KaMenu_root_menu_get, _kahakai.KaMenu_root_menu_set)
    __swig_setmethods__["root_item"] = _kahakai.KaMenu_root_item_set
    __swig_getmethods__["root_item"] = _kahakai.KaMenu_root_item_get
    if _newclass:root_item = property(_kahakai.KaMenu_root_item_get, _kahakai.KaMenu_root_item_set)
    __swig_setmethods__["ext_type"] = _kahakai.KaMenu_ext_type_set
    __swig_getmethods__["ext_type"] = _kahakai.KaMenu_ext_type_get
    if _newclass:ext_type = property(_kahakai.KaMenu_ext_type_get, _kahakai.KaMenu_ext_type_set)
    __swig_setmethods__["ftype"] = _kahakai.KaMenu_ftype_set
    __swig_getmethods__["ftype"] = _kahakai.KaMenu_ftype_get
    if _newclass:ftype = property(_kahakai.KaMenu_ftype_get, _kahakai.KaMenu_ftype_set)
    __swig_setmethods__["wf"] = _kahakai.KaMenu_wf_set
    __swig_getmethods__["wf"] = _kahakai.KaMenu_wf_get
    if _newclass:wf = property(_kahakai.KaMenu_wf_get, _kahakai.KaMenu_wf_set)
    __swig_setmethods__["rf"] = _kahakai.KaMenu_rf_set
    __swig_getmethods__["rf"] = _kahakai.KaMenu_rf_get
    if _newclass:rf = property(_kahakai.KaMenu_rf_get, _kahakai.KaMenu_rf_set)
    __swig_setmethods__["mf"] = _kahakai.KaMenu_mf_set
    __swig_getmethods__["mf"] = _kahakai.KaMenu_mf_get
    if _newclass:mf = property(_kahakai.KaMenu_mf_get, _kahakai.KaMenu_mf_set)
    __swig_setmethods__["pixmap"] = _kahakai.KaMenu_pixmap_set
    __swig_getmethods__["pixmap"] = _kahakai.KaMenu_pixmap_get
    if _newclass:pixmap = property(_kahakai.KaMenu_pixmap_get, _kahakai.KaMenu_pixmap_set)
    __swig_setmethods__["render_if_transparency"] = _kahakai.KaMenu_render_if_transparency_set
    __swig_getmethods__["render_if_transparency"] = _kahakai.KaMenu_render_if_transparency_get
    if _newclass:render_if_transparency = property(_kahakai.KaMenu_render_if_transparency_get, _kahakai.KaMenu_render_if_transparency_set)
    __swig_setmethods__["dirty"] = _kahakai.KaMenu_dirty_set
    __swig_getmethods__["dirty"] = _kahakai.KaMenu_dirty_get
    if _newclass:dirty = property(_kahakai.KaMenu_dirty_get, _kahakai.KaMenu_dirty_set)
    __swig_setmethods__["iconsPresent"] = _kahakai.KaMenu_iconsPresent_set
    __swig_getmethods__["iconsPresent"] = _kahakai.KaMenu_iconsPresent_get
    if _newclass:iconsPresent = property(_kahakai.KaMenu_iconsPresent_get, _kahakai.KaMenu_iconsPresent_set)
    __swig_setmethods__["control"] = _kahakai.KaMenu_control_set
    __swig_getmethods__["control"] = _kahakai.KaMenu_control_get
    if _newclass:control = property(_kahakai.KaMenu_control_get, _kahakai.KaMenu_control_set)
KaMenu_swigregister = _kahakai.KaMenu_swigregister
KaMenu_swigregister(KaMenu)
strwithin = _kahakai.strwithin

class KaMenuItem(WindowObject):
    __swig_setmethods__ = {}
    for _s in [WindowObject]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, KaMenuItem, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowObject]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, KaMenuItem, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_KaMenuItem(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_KaMenuItem
    __del__ = lambda self : None;
    def CreateWindow(*args): return _kahakai.KaMenuItem_CreateWindow(*args)
    def drawForeground(*args): return _kahakai.KaMenuItem_drawForeground(*args)
    def drawBackground(*args): return _kahakai.KaMenuItem_drawBackground(*args)
    def refresh(*args): return _kahakai.KaMenuItem_refresh(*args)
    def Hilite(*args): return _kahakai.KaMenuItem_Hilite(*args)
    def DeHilite(*args): return _kahakai.KaMenuItem_DeHilite(*args)
    def UnLinkMenu(*args): return _kahakai.KaMenuItem_UnLinkMenu(*args)
    def MapSubmenu(*args): return _kahakai.KaMenuItem_MapSubmenu(*args)
    def MapSubmenuOnly(*args): return _kahakai.KaMenuItem_MapSubmenuOnly(*args)
    def MapSubmenuFocused(*args): return _kahakai.KaMenuItem_MapSubmenuFocused(*args)
    def MapSubmenuFocusedOnly(*args): return _kahakai.KaMenuItem_MapSubmenuFocusedOnly(*args)
    def RemapSubmenu(*args): return _kahakai.KaMenuItem_RemapSubmenu(*args)
    def RemapSubmenuFocused(*args): return _kahakai.KaMenuItem_RemapSubmenuFocused(*args)
    def UnmapMenu(*args): return _kahakai.KaMenuItem_UnmapMenu(*args)
    def UnmapMenuFocus(*args): return _kahakai.KaMenuItem_UnmapMenuFocus(*args)
    def Exec(*args): return _kahakai.KaMenuItem_Exec(*args)
    def Func(*args): return _kahakai.KaMenuItem_Func(*args)
    def Move(*args): return _kahakai.KaMenuItem_Move(*args)
    def MoveOpaque(*args): return _kahakai.KaMenuItem_MoveOpaque(*args)
    def EndMoveResize(*args): return _kahakai.KaMenuItem_EndMoveResize(*args)
    def Focus(*args): return _kahakai.KaMenuItem_Focus(*args)
    def UnmapSubmenus(*args): return _kahakai.KaMenuItem_UnmapSubmenus(*args)
    def UnmapTree(*args): return _kahakai.KaMenuItem_UnmapTree(*args)
    def Raise(*args): return _kahakai.KaMenuItem_Raise(*args)
    def Lower(*args): return _kahakai.KaMenuItem_Lower(*args)
    def NextItem(*args): return _kahakai.KaMenuItem_NextItem(*args)
    def PreviousItem(*args): return _kahakai.KaMenuItem_PreviousItem(*args)
    def Nop(*args): return _kahakai.KaMenuItem_Nop(*args)
    def EvAct(*args): return _kahakai.KaMenuItem_EvAct(*args)
    def UpdateCBox(*args): return _kahakai.KaMenuItem_UpdateCBox(*args)
    def ExpandAll(*args): return _kahakai.KaMenuItem_ExpandAll(*args)
    __swig_setmethods__["func_mask"] = _kahakai.KaMenuItem_func_mask_set
    __swig_getmethods__["func_mask"] = _kahakai.KaMenuItem_func_mask_get
    if _newclass:func_mask = property(_kahakai.KaMenuItem_func_mask_get, _kahakai.KaMenuItem_func_mask_set)
    __swig_setmethods__["func_mask1"] = _kahakai.KaMenuItem_func_mask1_set
    __swig_getmethods__["func_mask1"] = _kahakai.KaMenuItem_func_mask1_get
    if _newclass:func_mask1 = property(_kahakai.KaMenuItem_func_mask1_get, _kahakai.KaMenuItem_func_mask1_set)
    __swig_setmethods__["func_mask2"] = _kahakai.KaMenuItem_func_mask2_set
    __swig_getmethods__["func_mask2"] = _kahakai.KaMenuItem_func_mask2_get
    if _newclass:func_mask2 = property(_kahakai.KaMenuItem_func_mask2_get, _kahakai.KaMenuItem_func_mask2_set)
    __swig_setmethods__["height"] = _kahakai.KaMenuItem_height_set
    __swig_getmethods__["height"] = _kahakai.KaMenuItem_height_get
    if _newclass:height = property(_kahakai.KaMenuItem_height_get, _kahakai.KaMenuItem_height_set)
    __swig_setmethods__["width"] = _kahakai.KaMenuItem_width_set
    __swig_getmethods__["width"] = _kahakai.KaMenuItem_width_get
    if _newclass:width = property(_kahakai.KaMenuItem_width_get, _kahakai.KaMenuItem_width_set)
    __swig_setmethods__["dy"] = _kahakai.KaMenuItem_dy_set
    __swig_getmethods__["dy"] = _kahakai.KaMenuItem_dy_get
    if _newclass:dy = property(_kahakai.KaMenuItem_dy_get, _kahakai.KaMenuItem_dy_set)
    __swig_setmethods__["realheight"] = _kahakai.KaMenuItem_realheight_set
    __swig_getmethods__["realheight"] = _kahakai.KaMenuItem_realheight_get
    if _newclass:realheight = property(_kahakai.KaMenuItem_realheight_get, _kahakai.KaMenuItem_realheight_set)
    __swig_setmethods__["cb"] = _kahakai.KaMenuItem_cb_set
    __swig_getmethods__["cb"] = _kahakai.KaMenuItem_cb_get
    if _newclass:cb = property(_kahakai.KaMenuItem_cb_get, _kahakai.KaMenuItem_cb_set)
    __swig_setmethods__["cb_y"] = _kahakai.KaMenuItem_cb_y_set
    __swig_getmethods__["cb_y"] = _kahakai.KaMenuItem_cb_y_get
    if _newclass:cb_y = property(_kahakai.KaMenuItem_cb_y_get, _kahakai.KaMenuItem_cb_y_set)
    __swig_setmethods__["cb_width"] = _kahakai.KaMenuItem_cb_width_set
    __swig_getmethods__["cb_width"] = _kahakai.KaMenuItem_cb_width_get
    if _newclass:cb_width = property(_kahakai.KaMenuItem_cb_width_get, _kahakai.KaMenuItem_cb_width_set)
    __swig_setmethods__["cb_width1"] = _kahakai.KaMenuItem_cb_width1_set
    __swig_getmethods__["cb_width1"] = _kahakai.KaMenuItem_cb_width1_get
    if _newclass:cb_width1 = property(_kahakai.KaMenuItem_cb_width1_get, _kahakai.KaMenuItem_cb_width1_set)
    __swig_setmethods__["cb_width2"] = _kahakai.KaMenuItem_cb_width2_set
    __swig_getmethods__["cb_width2"] = _kahakai.KaMenuItem_cb_width2_get
    if _newclass:cb_width2 = property(_kahakai.KaMenuItem_cb_width2_get, _kahakai.KaMenuItem_cb_width2_set)
    __swig_setmethods__["hilited"] = _kahakai.KaMenuItem_hilited_set
    __swig_getmethods__["hilited"] = _kahakai.KaMenuItem_hilited_get
    if _newclass:hilited = property(_kahakai.KaMenuItem_hilited_get, _kahakai.KaMenuItem_hilited_set)
    __swig_setmethods__["move_resize"] = _kahakai.KaMenuItem_move_resize_set
    __swig_getmethods__["move_resize"] = _kahakai.KaMenuItem_move_resize_get
    if _newclass:move_resize = property(_kahakai.KaMenuItem_move_resize_get, _kahakai.KaMenuItem_move_resize_set)
    __swig_setmethods__["in_window"] = _kahakai.KaMenuItem_in_window_set
    __swig_getmethods__["in_window"] = _kahakai.KaMenuItem_in_window_get
    if _newclass:in_window = property(_kahakai.KaMenuItem_in_window_get, _kahakai.KaMenuItem_in_window_set)
    __swig_setmethods__["sdyn"] = _kahakai.KaMenuItem_sdyn_set
    __swig_getmethods__["sdyn"] = _kahakai.KaMenuItem_sdyn_get
    if _newclass:sdyn = property(_kahakai.KaMenuItem_sdyn_get, _kahakai.KaMenuItem_sdyn_set)
    __swig_setmethods__["sdyn1"] = _kahakai.KaMenuItem_sdyn1_set
    __swig_getmethods__["sdyn1"] = _kahakai.KaMenuItem_sdyn1_get
    if _newclass:sdyn1 = property(_kahakai.KaMenuItem_sdyn1_get, _kahakai.KaMenuItem_sdyn1_set)
    __swig_setmethods__["sdyn2"] = _kahakai.KaMenuItem_sdyn2_set
    __swig_getmethods__["sdyn2"] = _kahakai.KaMenuItem_sdyn2_get
    if _newclass:sdyn2 = property(_kahakai.KaMenuItem_sdyn2_get, _kahakai.KaMenuItem_sdyn2_set)
    __swig_setmethods__["db"] = _kahakai.KaMenuItem_db_set
    __swig_getmethods__["db"] = _kahakai.KaMenuItem_db_get
    if _newclass:db = property(_kahakai.KaMenuItem_db_get, _kahakai.KaMenuItem_db_set)
    __swig_setmethods__["label"] = _kahakai.KaMenuItem_label_set
    __swig_getmethods__["label"] = _kahakai.KaMenuItem_label_get
    if _newclass:label = property(_kahakai.KaMenuItem_label_get, _kahakai.KaMenuItem_label_set)
    __swig_setmethods__["command"] = _kahakai.KaMenuItem_command_set
    __swig_getmethods__["command"] = _kahakai.KaMenuItem_command_get
    if _newclass:command = property(_kahakai.KaMenuItem_command_get, _kahakai.KaMenuItem_command_set)
    __swig_setmethods__["param"] = _kahakai.KaMenuItem_param_set
    __swig_getmethods__["param"] = _kahakai.KaMenuItem_param_get
    if _newclass:param = property(_kahakai.KaMenuItem_param_get, _kahakai.KaMenuItem_param_set)
    __swig_setmethods__["sub"] = _kahakai.KaMenuItem_sub_set
    __swig_getmethods__["sub"] = _kahakai.KaMenuItem_sub_get
    if _newclass:sub = property(_kahakai.KaMenuItem_sub_get, _kahakai.KaMenuItem_sub_set)
    __swig_setmethods__["label1"] = _kahakai.KaMenuItem_label1_set
    __swig_getmethods__["label1"] = _kahakai.KaMenuItem_label1_get
    if _newclass:label1 = property(_kahakai.KaMenuItem_label1_get, _kahakai.KaMenuItem_label1_set)
    __swig_setmethods__["exec1"] = _kahakai.KaMenuItem_exec1_set
    __swig_getmethods__["exec1"] = _kahakai.KaMenuItem_exec1_get
    if _newclass:exec1 = property(_kahakai.KaMenuItem_exec1_get, _kahakai.KaMenuItem_exec1_set)
    __swig_setmethods__["param1"] = _kahakai.KaMenuItem_param1_set
    __swig_getmethods__["param1"] = _kahakai.KaMenuItem_param1_get
    if _newclass:param1 = property(_kahakai.KaMenuItem_param1_get, _kahakai.KaMenuItem_param1_set)
    __swig_setmethods__["sub1"] = _kahakai.KaMenuItem_sub1_set
    __swig_getmethods__["sub1"] = _kahakai.KaMenuItem_sub1_get
    if _newclass:sub1 = property(_kahakai.KaMenuItem_sub1_get, _kahakai.KaMenuItem_sub1_set)
    __swig_setmethods__["label2"] = _kahakai.KaMenuItem_label2_set
    __swig_getmethods__["label2"] = _kahakai.KaMenuItem_label2_get
    if _newclass:label2 = property(_kahakai.KaMenuItem_label2_get, _kahakai.KaMenuItem_label2_set)
    __swig_setmethods__["exec2"] = _kahakai.KaMenuItem_exec2_set
    __swig_getmethods__["exec2"] = _kahakai.KaMenuItem_exec2_get
    if _newclass:exec2 = property(_kahakai.KaMenuItem_exec2_get, _kahakai.KaMenuItem_exec2_set)
    __swig_setmethods__["param2"] = _kahakai.KaMenuItem_param2_set
    __swig_getmethods__["param2"] = _kahakai.KaMenuItem_param2_get
    if _newclass:param2 = property(_kahakai.KaMenuItem_param2_get, _kahakai.KaMenuItem_param2_set)
    __swig_setmethods__["sub2"] = _kahakai.KaMenuItem_sub2_set
    __swig_getmethods__["sub2"] = _kahakai.KaMenuItem_sub2_get
    if _newclass:sub2 = property(_kahakai.KaMenuItem_sub2_get, _kahakai.KaMenuItem_sub2_set)
    __swig_setmethods__["e_label"] = _kahakai.KaMenuItem_e_label_set
    __swig_getmethods__["e_label"] = _kahakai.KaMenuItem_e_label_get
    if _newclass:e_label = property(_kahakai.KaMenuItem_e_label_get, _kahakai.KaMenuItem_e_label_set)
    __swig_setmethods__["e_label1"] = _kahakai.KaMenuItem_e_label1_set
    __swig_getmethods__["e_label1"] = _kahakai.KaMenuItem_e_label1_get
    if _newclass:e_label1 = property(_kahakai.KaMenuItem_e_label1_get, _kahakai.KaMenuItem_e_label1_set)
    __swig_setmethods__["e_label2"] = _kahakai.KaMenuItem_e_label2_set
    __swig_getmethods__["e_label2"] = _kahakai.KaMenuItem_e_label2_get
    if _newclass:e_label2 = property(_kahakai.KaMenuItem_e_label2_get, _kahakai.KaMenuItem_e_label2_set)
    __swig_setmethods__["e_sub"] = _kahakai.KaMenuItem_e_sub_set
    __swig_getmethods__["e_sub"] = _kahakai.KaMenuItem_e_sub_get
    if _newclass:e_sub = property(_kahakai.KaMenuItem_e_sub_get, _kahakai.KaMenuItem_e_sub_set)
    __swig_setmethods__["e_sub1"] = _kahakai.KaMenuItem_e_sub1_set
    __swig_getmethods__["e_sub1"] = _kahakai.KaMenuItem_e_sub1_get
    if _newclass:e_sub1 = property(_kahakai.KaMenuItem_e_sub1_get, _kahakai.KaMenuItem_e_sub1_set)
    __swig_setmethods__["e_sub2"] = _kahakai.KaMenuItem_e_sub2_set
    __swig_getmethods__["e_sub2"] = _kahakai.KaMenuItem_e_sub2_get
    if _newclass:e_sub2 = property(_kahakai.KaMenuItem_e_sub2_get, _kahakai.KaMenuItem_e_sub2_set)
    __swig_setmethods__["cbox"] = _kahakai.KaMenuItem_cbox_set
    __swig_getmethods__["cbox"] = _kahakai.KaMenuItem_cbox_get
    if _newclass:cbox = property(_kahakai.KaMenuItem_cbox_get, _kahakai.KaMenuItem_cbox_set)
    __swig_setmethods__["wfunc"] = _kahakai.KaMenuItem_wfunc_set
    __swig_getmethods__["wfunc"] = _kahakai.KaMenuItem_wfunc_get
    if _newclass:wfunc = property(_kahakai.KaMenuItem_wfunc_get, _kahakai.KaMenuItem_wfunc_set)
    __swig_setmethods__["wfunc1"] = _kahakai.KaMenuItem_wfunc1_set
    __swig_getmethods__["wfunc1"] = _kahakai.KaMenuItem_wfunc1_get
    if _newclass:wfunc1 = property(_kahakai.KaMenuItem_wfunc1_get, _kahakai.KaMenuItem_wfunc1_set)
    __swig_setmethods__["wfunc2"] = _kahakai.KaMenuItem_wfunc2_set
    __swig_getmethods__["wfunc2"] = _kahakai.KaMenuItem_wfunc2_get
    if _newclass:wfunc2 = property(_kahakai.KaMenuItem_wfunc2_get, _kahakai.KaMenuItem_wfunc2_set)
    __swig_setmethods__["mfunc"] = _kahakai.KaMenuItem_mfunc_set
    __swig_getmethods__["mfunc"] = _kahakai.KaMenuItem_mfunc_get
    if _newclass:mfunc = property(_kahakai.KaMenuItem_mfunc_get, _kahakai.KaMenuItem_mfunc_set)
    __swig_setmethods__["mfunc1"] = _kahakai.KaMenuItem_mfunc1_set
    __swig_getmethods__["mfunc1"] = _kahakai.KaMenuItem_mfunc1_get
    if _newclass:mfunc1 = property(_kahakai.KaMenuItem_mfunc1_get, _kahakai.KaMenuItem_mfunc1_set)
    __swig_setmethods__["mfunc2"] = _kahakai.KaMenuItem_mfunc2_set
    __swig_getmethods__["mfunc2"] = _kahakai.KaMenuItem_mfunc2_get
    if _newclass:mfunc2 = property(_kahakai.KaMenuItem_mfunc2_get, _kahakai.KaMenuItem_mfunc2_set)
    __swig_setmethods__["rfunc"] = _kahakai.KaMenuItem_rfunc_set
    __swig_getmethods__["rfunc"] = _kahakai.KaMenuItem_rfunc_get
    if _newclass:rfunc = property(_kahakai.KaMenuItem_rfunc_get, _kahakai.KaMenuItem_rfunc_set)
    __swig_setmethods__["rfunc1"] = _kahakai.KaMenuItem_rfunc1_set
    __swig_getmethods__["rfunc1"] = _kahakai.KaMenuItem_rfunc1_get
    if _newclass:rfunc1 = property(_kahakai.KaMenuItem_rfunc1_get, _kahakai.KaMenuItem_rfunc1_set)
    __swig_setmethods__["rfunc2"] = _kahakai.KaMenuItem_rfunc2_set
    __swig_getmethods__["rfunc2"] = _kahakai.KaMenuItem_rfunc2_get
    if _newclass:rfunc2 = property(_kahakai.KaMenuItem_rfunc2_get, _kahakai.KaMenuItem_rfunc2_set)
    __swig_setmethods__["menu"] = _kahakai.KaMenuItem_menu_set
    __swig_getmethods__["menu"] = _kahakai.KaMenuItem_menu_get
    if _newclass:menu = property(_kahakai.KaMenuItem_menu_get, _kahakai.KaMenuItem_menu_set)
    __swig_setmethods__["submenu"] = _kahakai.KaMenuItem_submenu_set
    __swig_getmethods__["submenu"] = _kahakai.KaMenuItem_submenu_get
    if _newclass:submenu = property(_kahakai.KaMenuItem_submenu_get, _kahakai.KaMenuItem_submenu_set)
    __swig_setmethods__["submenu1"] = _kahakai.KaMenuItem_submenu1_set
    __swig_getmethods__["submenu1"] = _kahakai.KaMenuItem_submenu1_get
    if _newclass:submenu1 = property(_kahakai.KaMenuItem_submenu1_get, _kahakai.KaMenuItem_submenu1_set)
    __swig_setmethods__["submenu2"] = _kahakai.KaMenuItem_submenu2_set
    __swig_getmethods__["submenu2"] = _kahakai.KaMenuItem_submenu2_get
    if _newclass:submenu2 = property(_kahakai.KaMenuItem_submenu2_get, _kahakai.KaMenuItem_submenu2_set)
    __swig_setmethods__["wf"] = _kahakai.KaMenuItem_wf_set
    __swig_getmethods__["wf"] = _kahakai.KaMenuItem_wf_get
    if _newclass:wf = property(_kahakai.KaMenuItem_wf_get, _kahakai.KaMenuItem_wf_set)
    __swig_setmethods__["texture"] = _kahakai.KaMenuItem_texture_set
    __swig_getmethods__["texture"] = _kahakai.KaMenuItem_texture_get
    if _newclass:texture = property(_kahakai.KaMenuItem_texture_get, _kahakai.KaMenuItem_texture_set)
    __swig_setmethods__["kafont_cb"] = _kahakai.KaMenuItem_kafont_cb_set
    __swig_getmethods__["kafont_cb"] = _kahakai.KaMenuItem_kafont_cb_get
    if _newclass:kafont_cb = property(_kahakai.KaMenuItem_kafont_cb_get, _kahakai.KaMenuItem_kafont_cb_set)
    __swig_setmethods__["xftdraw"] = _kahakai.KaMenuItem_xftdraw_set
    __swig_getmethods__["xftdraw"] = _kahakai.KaMenuItem_xftdraw_get
    if _newclass:xftdraw = property(_kahakai.KaMenuItem_xftdraw_get, _kahakai.KaMenuItem_xftdraw_set)
    __swig_setmethods__["pixmap"] = _kahakai.KaMenuItem_pixmap_set
    __swig_getmethods__["pixmap"] = _kahakai.KaMenuItem_pixmap_get
    if _newclass:pixmap = property(_kahakai.KaMenuItem_pixmap_get, _kahakai.KaMenuItem_pixmap_set)
    __swig_setmethods__["icon"] = _kahakai.KaMenuItem_icon_set
    __swig_getmethods__["icon"] = _kahakai.KaMenuItem_icon_get
    if _newclass:icon = property(_kahakai.KaMenuItem_icon_get, _kahakai.KaMenuItem_icon_set)
KaMenuItem_swigregister = _kahakai.KaMenuItem_swigregister
KaMenuItem_swigregister(KaMenuItem)

class MenuEvUnLinkMenu(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvUnLinkMenu, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvUnLinkMenu, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvUnLinkMenu(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvUnLinkMenu___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvUnLinkMenu
    __del__ = lambda self : None;
MenuEvUnLinkMenu_swigregister = _kahakai.MenuEvUnLinkMenu_swigregister
MenuEvUnLinkMenu_swigregister(MenuEvUnLinkMenu)

class MenuEvMapSubmenu(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvMapSubmenu, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvMapSubmenu, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvMapSubmenu(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvMapSubmenu___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvMapSubmenu
    __del__ = lambda self : None;
MenuEvMapSubmenu_swigregister = _kahakai.MenuEvMapSubmenu_swigregister
MenuEvMapSubmenu_swigregister(MenuEvMapSubmenu)

class MenuEvMapSubmenuOnly(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvMapSubmenuOnly, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvMapSubmenuOnly, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvMapSubmenuOnly(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvMapSubmenuOnly___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvMapSubmenuOnly
    __del__ = lambda self : None;
MenuEvMapSubmenuOnly_swigregister = _kahakai.MenuEvMapSubmenuOnly_swigregister
MenuEvMapSubmenuOnly_swigregister(MenuEvMapSubmenuOnly)

class MenuEvMapSubmenuFocused(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvMapSubmenuFocused, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvMapSubmenuFocused, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvMapSubmenuFocused(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvMapSubmenuFocused___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvMapSubmenuFocused
    __del__ = lambda self : None;
MenuEvMapSubmenuFocused_swigregister = _kahakai.MenuEvMapSubmenuFocused_swigregister
MenuEvMapSubmenuFocused_swigregister(MenuEvMapSubmenuFocused)

class MenuEvMapSubmenuFocusedOnly(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvMapSubmenuFocusedOnly, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvMapSubmenuFocusedOnly, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvMapSubmenuFocusedOnly(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvMapSubmenuFocusedOnly___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvMapSubmenuFocusedOnly
    __del__ = lambda self : None;
MenuEvMapSubmenuFocusedOnly_swigregister = _kahakai.MenuEvMapSubmenuFocusedOnly_swigregister
MenuEvMapSubmenuFocusedOnly_swigregister(MenuEvMapSubmenuFocusedOnly)

class MenuEvRemapSubmenu(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvRemapSubmenu, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvRemapSubmenu, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvRemapSubmenu(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvRemapSubmenu___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvRemapSubmenu
    __del__ = lambda self : None;
MenuEvRemapSubmenu_swigregister = _kahakai.MenuEvRemapSubmenu_swigregister
MenuEvRemapSubmenu_swigregister(MenuEvRemapSubmenu)

class MenuEvRemapSubmenuFocused(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvRemapSubmenuFocused, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvRemapSubmenuFocused, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvRemapSubmenuFocused(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvRemapSubmenuFocused___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvRemapSubmenuFocused
    __del__ = lambda self : None;
MenuEvRemapSubmenuFocused_swigregister = _kahakai.MenuEvRemapSubmenuFocused_swigregister
MenuEvRemapSubmenuFocused_swigregister(MenuEvRemapSubmenuFocused)

class MenuEvUnmapMenu(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvUnmapMenu, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvUnmapMenu, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvUnmapMenu(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvUnmapMenu___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvUnmapMenu
    __del__ = lambda self : None;
MenuEvUnmapMenu_swigregister = _kahakai.MenuEvUnmapMenu_swigregister
MenuEvUnmapMenu_swigregister(MenuEvUnmapMenu)

class MenuEvUnmapMenuFocus(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvUnmapMenuFocus, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvUnmapMenuFocus, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvUnmapMenuFocus(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvUnmapMenuFocus___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvUnmapMenuFocus
    __del__ = lambda self : None;
MenuEvUnmapMenuFocus_swigregister = _kahakai.MenuEvUnmapMenuFocus_swigregister
MenuEvUnmapMenuFocus_swigregister(MenuEvUnmapMenuFocus)

class MenuEvExec(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvExec, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvExec, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvExec(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvExec___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvExec
    __del__ = lambda self : None;
MenuEvExec_swigregister = _kahakai.MenuEvExec_swigregister
MenuEvExec_swigregister(MenuEvExec)

class MenuEvFunc(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvFunc, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvFunc, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvFunc(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvFunc___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvFunc
    __del__ = lambda self : None;
MenuEvFunc_swigregister = _kahakai.MenuEvFunc_swigregister
MenuEvFunc_swigregister(MenuEvFunc)

class MenuEvMove(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvMove, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvMove, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvMove(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvMove___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvMove
    __del__ = lambda self : None;
MenuEvMove_swigregister = _kahakai.MenuEvMove_swigregister
MenuEvMove_swigregister(MenuEvMove)

class MenuEvMoveOpaque(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvMoveOpaque, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvMoveOpaque, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvMoveOpaque(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvMoveOpaque___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvMoveOpaque
    __del__ = lambda self : None;
MenuEvMoveOpaque_swigregister = _kahakai.MenuEvMoveOpaque_swigregister
MenuEvMoveOpaque_swigregister(MenuEvMoveOpaque)

class MenuEvEndMoveResize(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvEndMoveResize, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvEndMoveResize, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvEndMoveResize(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvEndMoveResize___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvEndMoveResize
    __del__ = lambda self : None;
MenuEvEndMoveResize_swigregister = _kahakai.MenuEvEndMoveResize_swigregister
MenuEvEndMoveResize_swigregister(MenuEvEndMoveResize)

class MenuEvFocus(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvFocus, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvFocus, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvFocus(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvFocus___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvFocus
    __del__ = lambda self : None;
MenuEvFocus_swigregister = _kahakai.MenuEvFocus_swigregister
MenuEvFocus_swigregister(MenuEvFocus)

class MenuEvUnmapSubmenus(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvUnmapSubmenus, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvUnmapSubmenus, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvUnmapSubmenus(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvUnmapSubmenus___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvUnmapSubmenus
    __del__ = lambda self : None;
MenuEvUnmapSubmenus_swigregister = _kahakai.MenuEvUnmapSubmenus_swigregister
MenuEvUnmapSubmenus_swigregister(MenuEvUnmapSubmenus)

class MenuEvUnmapTree(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvUnmapTree, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvUnmapTree, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvUnmapTree(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvUnmapTree___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvUnmapTree
    __del__ = lambda self : None;
MenuEvUnmapTree_swigregister = _kahakai.MenuEvUnmapTree_swigregister
MenuEvUnmapTree_swigregister(MenuEvUnmapTree)

class MenuEvRaise(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvRaise, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvRaise, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvRaise(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvRaise___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvRaise
    __del__ = lambda self : None;
MenuEvRaise_swigregister = _kahakai.MenuEvRaise_swigregister
MenuEvRaise_swigregister(MenuEvRaise)

class MenuEvLower(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvLower, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvLower, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvLower(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvLower___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvLower
    __del__ = lambda self : None;
MenuEvLower_swigregister = _kahakai.MenuEvLower_swigregister
MenuEvLower_swigregister(MenuEvLower)

class MenuEvNextItem(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvNextItem, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvNextItem, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvNextItem(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvNextItem___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvNextItem
    __del__ = lambda self : None;
MenuEvNextItem_swigregister = _kahakai.MenuEvNextItem_swigregister
MenuEvNextItem_swigregister(MenuEvNextItem)

class MenuEvPreviousItem(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvPreviousItem, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvPreviousItem, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvPreviousItem(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvPreviousItem___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvPreviousItem
    __del__ = lambda self : None;
MenuEvPreviousItem_swigregister = _kahakai.MenuEvPreviousItem_swigregister
MenuEvPreviousItem_swigregister(MenuEvPreviousItem)

class MenuEvNop(MenuFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuEvNop, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuEvNop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_MenuEvNop(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.MenuEvNop___call__(*args)
    __swig_destroy__ = _kahakai.delete_MenuEvNop
    __del__ = lambda self : None;
MenuEvNop_swigregister = _kahakai.MenuEvNop_swigregister
MenuEvNop_swigregister(MenuEvNop)

class Action(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Action, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Action, name)
    __repr__ = _swig_repr
    __swig_setmethods__["winfunc"] = _kahakai.Action_winfunc_set
    __swig_getmethods__["winfunc"] = _kahakai.Action_winfunc_get
    if _newclass:winfunc = property(_kahakai.Action_winfunc_get, _kahakai.Action_winfunc_set)
    __swig_setmethods__["winfunc2"] = _kahakai.Action_winfunc2_set
    __swig_getmethods__["winfunc2"] = _kahakai.Action_winfunc2_get
    if _newclass:winfunc2 = property(_kahakai.Action_winfunc2_get, _kahakai.Action_winfunc2_set)
    __swig_setmethods__["rootfunc"] = _kahakai.Action_rootfunc_set
    __swig_getmethods__["rootfunc"] = _kahakai.Action_rootfunc_get
    if _newclass:rootfunc = property(_kahakai.Action_rootfunc_get, _kahakai.Action_rootfunc_set)
    __swig_setmethods__["menufunc"] = _kahakai.Action_menufunc_set
    __swig_getmethods__["menufunc"] = _kahakai.Action_menufunc_get
    if _newclass:menufunc = property(_kahakai.Action_menufunc_get, _kahakai.Action_menufunc_set)
    __swig_setmethods__["command"] = _kahakai.Action_command_set
    __swig_getmethods__["command"] = _kahakai.Action_command_get
    if _newclass:command = property(_kahakai.Action_command_get, _kahakai.Action_command_set)
    __swig_setmethods__["param"] = _kahakai.Action_param_set
    __swig_getmethods__["param"] = _kahakai.Action_param_get
    if _newclass:param = property(_kahakai.Action_param_get, _kahakai.Action_param_set)
    __swig_setmethods__["type"] = _kahakai.Action_type_set
    __swig_getmethods__["type"] = _kahakai.Action_type_get
    if _newclass:type = property(_kahakai.Action_type_get, _kahakai.Action_type_set)
    __swig_setmethods__["detail"] = _kahakai.Action_detail_set
    __swig_getmethods__["detail"] = _kahakai.Action_detail_get
    if _newclass:detail = property(_kahakai.Action_detail_get, _kahakai.Action_detail_set)
    __swig_setmethods__["mod"] = _kahakai.Action_mod_set
    __swig_getmethods__["mod"] = _kahakai.Action_mod_get
    if _newclass:mod = property(_kahakai.Action_mod_get, _kahakai.Action_mod_set)
    __swig_setmethods__["nmod"] = _kahakai.Action_nmod_set
    __swig_getmethods__["nmod"] = _kahakai.Action_nmod_get
    if _newclass:nmod = property(_kahakai.Action_nmod_get, _kahakai.Action_nmod_set)
    __swig_setmethods__["replay"] = _kahakai.Action_replay_set
    __swig_getmethods__["replay"] = _kahakai.Action_replay_get
    if _newclass:replay = property(_kahakai.Action_replay_get, _kahakai.Action_replay_set)
    __swig_setmethods__["delay"] = _kahakai.Action_delay_set
    __swig_getmethods__["delay"] = _kahakai.Action_delay_get
    if _newclass:delay = property(_kahakai.Action_delay_get, _kahakai.Action_delay_set)
    __swig_setmethods__["delay_breaks"] = _kahakai.Action_delay_breaks_set
    __swig_getmethods__["delay_breaks"] = _kahakai.Action_delay_breaks_get
    if _newclass:delay_breaks = property(_kahakai.Action_delay_breaks_get, _kahakai.Action_delay_breaks_set)
    def __init__(self, *args): 
        this = _kahakai.new_Action(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_Action
    __del__ = lambda self : None;
Action_swigregister = _kahakai.Action_swigregister
Action_swigregister(Action)

MwmHintsDecorations = _kahakai.MwmHintsDecorations
MwmDecorAll = _kahakai.MwmDecorAll
MwmDecorBorder = _kahakai.MwmDecorBorder
MwmDecorHandle = _kahakai.MwmDecorHandle
MwmDecorTitle = _kahakai.MwmDecorTitle
MwmDecorMenu = _kahakai.MwmDecorMenu
MwmDecorMinimize = _kahakai.MwmDecorMinimize
MwmDecorMaximize = _kahakai.MwmDecorMaximize
PropMotifWmHintsElements = _kahakai.PropMotifWmHintsElements
class MwmHints(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MwmHints, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MwmHints, name)
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _kahakai.MwmHints_flags_set
    __swig_getmethods__["flags"] = _kahakai.MwmHints_flags_get
    if _newclass:flags = property(_kahakai.MwmHints_flags_get, _kahakai.MwmHints_flags_set)
    __swig_setmethods__["functions"] = _kahakai.MwmHints_functions_set
    __swig_getmethods__["functions"] = _kahakai.MwmHints_functions_get
    if _newclass:functions = property(_kahakai.MwmHints_functions_get, _kahakai.MwmHints_functions_set)
    __swig_setmethods__["decorations"] = _kahakai.MwmHints_decorations_set
    __swig_getmethods__["decorations"] = _kahakai.MwmHints_decorations_get
    if _newclass:decorations = property(_kahakai.MwmHints_decorations_get, _kahakai.MwmHints_decorations_set)
    def __init__(self, *args): 
        this = _kahakai.new_MwmHints(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_MwmHints
    __del__ = lambda self : None;
MwmHints_swigregister = _kahakai.MwmHints_swigregister
MwmHints_swigregister(MwmHints)

_NET_WM_STATE_REMOVE = _kahakai._NET_WM_STATE_REMOVE
_NET_WM_STATE_ADD = _kahakai._NET_WM_STATE_ADD
_NET_WM_STATE_TOGGLE = _kahakai._NET_WM_STATE_TOGGLE
_NET_WM_MOVERESIZE_SIZE_TOPLEFT = _kahakai._NET_WM_MOVERESIZE_SIZE_TOPLEFT
_NET_WM_MOVERESIZE_SIZE_TOP = _kahakai._NET_WM_MOVERESIZE_SIZE_TOP
_NET_WM_MOVERESIZE_SIZE_TOPRIGHT = _kahakai._NET_WM_MOVERESIZE_SIZE_TOPRIGHT
_NET_WM_MOVERESIZE_SIZE_RIGHT = _kahakai._NET_WM_MOVERESIZE_SIZE_RIGHT
_NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT = _kahakai._NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT
_NET_WM_MOVERESIZE_SIZE_BOTTOM = _kahakai._NET_WM_MOVERESIZE_SIZE_BOTTOM
_NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT = _kahakai._NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT
_NET_WM_MOVERESIZE_SIZE_LEFT = _kahakai._NET_WM_MOVERESIZE_SIZE_LEFT
_NET_WM_MOVERESIZE_MOVE = _kahakai._NET_WM_MOVERESIZE_MOVE
_NET_WM_MOVERESIZE_SIZE_KEYBOARD = _kahakai._NET_WM_MOVERESIZE_SIZE_KEYBOARD
_NET_WM_MOVERESIZE_MOVE_KEYBOARD = _kahakai._NET_WM_MOVERESIZE_MOVE_KEYBOARD
LeftJustify = _kahakai.LeftJustify
RightJustify = _kahakai.RightJustify
CenterJustify = _kahakai.CenterJustify
class Padding(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Padding, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Padding, name)
    __repr__ = _swig_repr
    __swig_setmethods__["left"] = _kahakai.Padding_left_set
    __swig_getmethods__["left"] = _kahakai.Padding_left_get
    if _newclass:left = property(_kahakai.Padding_left_get, _kahakai.Padding_left_set)
    __swig_setmethods__["right"] = _kahakai.Padding_right_set
    __swig_getmethods__["right"] = _kahakai.Padding_right_get
    if _newclass:right = property(_kahakai.Padding_right_get, _kahakai.Padding_right_set)
    __swig_setmethods__["top"] = _kahakai.Padding_top_set
    __swig_getmethods__["top"] = _kahakai.Padding_top_get
    if _newclass:top = property(_kahakai.Padding_top_get, _kahakai.Padding_top_set)
    __swig_setmethods__["bottom"] = _kahakai.Padding_bottom_set
    __swig_getmethods__["bottom"] = _kahakai.Padding_bottom_get
    if _newclass:bottom = property(_kahakai.Padding_bottom_get, _kahakai.Padding_bottom_set)
    def __init__(self, *args): 
        this = _kahakai.new_Padding(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_Padding
    __del__ = lambda self : None;
Padding_swigregister = _kahakai.Padding_swigregister
Padding_swigregister(Padding)

class ButtonStateStyle(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ButtonStateStyle, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ButtonStateStyle, name)
    __repr__ = _swig_repr
    __swig_setmethods__["texture"] = _kahakai.ButtonStateStyle_texture_set
    __swig_getmethods__["texture"] = _kahakai.ButtonStateStyle_texture_get
    if _newclass:texture = property(_kahakai.ButtonStateStyle_texture_get, _kahakai.ButtonStateStyle_texture_set)
    __swig_setmethods__["color"] = _kahakai.ButtonStateStyle_color_set
    __swig_getmethods__["color"] = _kahakai.ButtonStateStyle_color_get
    if _newclass:color = property(_kahakai.ButtonStateStyle_color_get, _kahakai.ButtonStateStyle_color_set)
    __swig_setmethods__["pixmap"] = _kahakai.ButtonStateStyle_pixmap_set
    __swig_getmethods__["pixmap"] = _kahakai.ButtonStateStyle_pixmap_get
    if _newclass:pixmap = property(_kahakai.ButtonStateStyle_pixmap_get, _kahakai.ButtonStateStyle_pixmap_set)
    __swig_setmethods__["gc"] = _kahakai.ButtonStateStyle_gc_set
    __swig_getmethods__["gc"] = _kahakai.ButtonStateStyle_gc_get
    if _newclass:gc = property(_kahakai.ButtonStateStyle_gc_get, _kahakai.ButtonStateStyle_gc_set)
    def __init__(self, *args): 
        this = _kahakai.new_ButtonStateStyle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_ButtonStateStyle
    __del__ = lambda self : None;
ButtonStateStyle_swigregister = _kahakai.ButtonStateStyle_swigregister
ButtonStateStyle_swigregister(ButtonStateStyle)

class ButtonStyle(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ButtonStyle, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ButtonStyle, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _kahakai.ButtonStyle_x_set
    __swig_getmethods__["x"] = _kahakai.ButtonStyle_x_get
    if _newclass:x = property(_kahakai.ButtonStyle_x_get, _kahakai.ButtonStyle_x_set)
    __swig_setmethods__["id"] = _kahakai.ButtonStyle_id_set
    __swig_getmethods__["id"] = _kahakai.ButtonStyle_id_get
    if _newclass:id = property(_kahakai.ButtonStyle_id_get, _kahakai.ButtonStyle_id_set)
    __swig_setmethods__["cb"] = _kahakai.ButtonStyle_cb_set
    __swig_getmethods__["cb"] = _kahakai.ButtonStyle_cb_get
    if _newclass:cb = property(_kahakai.ButtonStyle_cb_get, _kahakai.ButtonStyle_cb_set)
    __swig_setmethods__["autoplace"] = _kahakai.ButtonStyle_autoplace_set
    __swig_getmethods__["autoplace"] = _kahakai.ButtonStyle_autoplace_get
    if _newclass:autoplace = property(_kahakai.ButtonStyle_autoplace_get, _kahakai.ButtonStyle_autoplace_set)
    __swig_setmethods__["fg"] = _kahakai.ButtonStyle_fg_set
    __swig_getmethods__["fg"] = _kahakai.ButtonStyle_fg_get
    if _newclass:fg = property(_kahakai.ButtonStyle_fg_get, _kahakai.ButtonStyle_fg_set)
    __swig_setmethods__["action"] = _kahakai.ButtonStyle_action_set
    __swig_getmethods__["action"] = _kahakai.ButtonStyle_action_get
    if _newclass:action = property(_kahakai.ButtonStyle_action_get, _kahakai.ButtonStyle_action_set)
    __swig_setmethods__["focused"] = _kahakai.ButtonStyle_focused_set
    __swig_getmethods__["focused"] = _kahakai.ButtonStyle_focused_get
    if _newclass:focused = property(_kahakai.ButtonStyle_focused_get, _kahakai.ButtonStyle_focused_set)
    __swig_setmethods__["focusedActive"] = _kahakai.ButtonStyle_focusedActive_set
    __swig_getmethods__["focusedActive"] = _kahakai.ButtonStyle_focusedActive_get
    if _newclass:focusedActive = property(_kahakai.ButtonStyle_focusedActive_get, _kahakai.ButtonStyle_focusedActive_set)
    __swig_setmethods__["unfocused"] = _kahakai.ButtonStyle_unfocused_set
    __swig_getmethods__["unfocused"] = _kahakai.ButtonStyle_unfocused_get
    if _newclass:unfocused = property(_kahakai.ButtonStyle_unfocused_get, _kahakai.ButtonStyle_unfocused_set)
    __swig_setmethods__["unfocusedActive"] = _kahakai.ButtonStyle_unfocusedActive_set
    __swig_getmethods__["unfocusedActive"] = _kahakai.ButtonStyle_unfocusedActive_get
    if _newclass:unfocusedActive = property(_kahakai.ButtonStyle_unfocusedActive_get, _kahakai.ButtonStyle_unfocusedActive_set)
    __swig_setmethods__["pressed"] = _kahakai.ButtonStyle_pressed_set
    __swig_getmethods__["pressed"] = _kahakai.ButtonStyle_pressed_get
    if _newclass:pressed = property(_kahakai.ButtonStyle_pressed_get, _kahakai.ButtonStyle_pressed_set)
    __swig_setmethods__["pressedActive"] = _kahakai.ButtonStyle_pressedActive_set
    __swig_getmethods__["pressedActive"] = _kahakai.ButtonStyle_pressedActive_get
    if _newclass:pressedActive = property(_kahakai.ButtonStyle_pressedActive_get, _kahakai.ButtonStyle_pressedActive_set)
    def __init__(self, *args): 
        this = _kahakai.new_ButtonStyle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_ButtonStyle
    __del__ = lambda self : None;
ButtonStyle_swigregister = _kahakai.ButtonStyle_swigregister
ButtonStyle_swigregister(ButtonStyle)

class WindowStateStyle(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowStateStyle, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WindowStateStyle, name)
    __repr__ = _swig_repr
    __swig_setmethods__["labelColor"] = _kahakai.WindowStateStyle_labelColor_set
    __swig_getmethods__["labelColor"] = _kahakai.WindowStateStyle_labelColor_get
    if _newclass:labelColor = property(_kahakai.WindowStateStyle_labelColor_get, _kahakai.WindowStateStyle_labelColor_set)
    __swig_setmethods__["labelShadowColor"] = _kahakai.WindowStateStyle_labelShadowColor_set
    __swig_getmethods__["labelShadowColor"] = _kahakai.WindowStateStyle_labelShadowColor_get
    if _newclass:labelShadowColor = property(_kahakai.WindowStateStyle_labelShadowColor_get, _kahakai.WindowStateStyle_labelShadowColor_set)
    __swig_setmethods__["handleTexture"] = _kahakai.WindowStateStyle_handleTexture_set
    __swig_getmethods__["handleTexture"] = _kahakai.WindowStateStyle_handleTexture_get
    if _newclass:handleTexture = property(_kahakai.WindowStateStyle_handleTexture_get, _kahakai.WindowStateStyle_handleTexture_set)
    __swig_setmethods__["leftGripTexture"] = _kahakai.WindowStateStyle_leftGripTexture_set
    __swig_getmethods__["leftGripTexture"] = _kahakai.WindowStateStyle_leftGripTexture_get
    if _newclass:leftGripTexture = property(_kahakai.WindowStateStyle_leftGripTexture_get, _kahakai.WindowStateStyle_leftGripTexture_set)
    __swig_setmethods__["rightGripTexture"] = _kahakai.WindowStateStyle_rightGripTexture_set
    __swig_getmethods__["rightGripTexture"] = _kahakai.WindowStateStyle_rightGripTexture_get
    if _newclass:rightGripTexture = property(_kahakai.WindowStateStyle_rightGripTexture_get, _kahakai.WindowStateStyle_rightGripTexture_set)
    __swig_setmethods__["titleTexture"] = _kahakai.WindowStateStyle_titleTexture_set
    __swig_getmethods__["titleTexture"] = _kahakai.WindowStateStyle_titleTexture_get
    if _newclass:titleTexture = property(_kahakai.WindowStateStyle_titleTexture_get, _kahakai.WindowStateStyle_titleTexture_set)
    __swig_setmethods__["labelTexture"] = _kahakai.WindowStateStyle_labelTexture_set
    __swig_getmethods__["labelTexture"] = _kahakai.WindowStateStyle_labelTexture_get
    if _newclass:labelTexture = property(_kahakai.WindowStateStyle_labelTexture_get, _kahakai.WindowStateStyle_labelTexture_set)
    __swig_setmethods__["leftEdgeTexture"] = _kahakai.WindowStateStyle_leftEdgeTexture_set
    __swig_getmethods__["leftEdgeTexture"] = _kahakai.WindowStateStyle_leftEdgeTexture_get
    if _newclass:leftEdgeTexture = property(_kahakai.WindowStateStyle_leftEdgeTexture_get, _kahakai.WindowStateStyle_leftEdgeTexture_set)
    __swig_setmethods__["rightEdgeTexture"] = _kahakai.WindowStateStyle_rightEdgeTexture_set
    __swig_getmethods__["rightEdgeTexture"] = _kahakai.WindowStateStyle_rightEdgeTexture_get
    if _newclass:rightEdgeTexture = property(_kahakai.WindowStateStyle_rightEdgeTexture_get, _kahakai.WindowStateStyle_rightEdgeTexture_set)
    __swig_setmethods__["font"] = _kahakai.WindowStateStyle_font_set
    __swig_getmethods__["font"] = _kahakai.WindowStateStyle_font_get
    if _newclass:font = property(_kahakai.WindowStateStyle_font_get, _kahakai.WindowStateStyle_font_set)
    def __init__(self, *args): 
        this = _kahakai.new_WindowStateStyle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_WindowStateStyle
    __del__ = lambda self : None;
WindowStateStyle_swigregister = _kahakai.WindowStateStyle_swigregister
WindowStateStyle_swigregister(WindowStateStyle)

class WindowStyle(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WindowStyle, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WindowStyle, name)
    __repr__ = _swig_repr
    __swig_setmethods__["buttonStyles"] = _kahakai.WindowStyle_buttonStyles_set
    __swig_getmethods__["buttonStyles"] = _kahakai.WindowStyle_buttonStyles_get
    if _newclass:buttonStyles = property(_kahakai.WindowStyle_buttonStyles_get, _kahakai.WindowStyle_buttonStyles_set)
    __swig_setmethods__["numButtons"] = _kahakai.WindowStyle_numButtons_set
    __swig_getmethods__["numButtons"] = _kahakai.WindowStyle_numButtons_get
    if _newclass:numButtons = property(_kahakai.WindowStyle_numButtons_get, _kahakai.WindowStyle_numButtons_set)
    __swig_setmethods__["handleThickness"] = _kahakai.WindowStyle_handleThickness_set
    __swig_getmethods__["handleThickness"] = _kahakai.WindowStyle_handleThickness_get
    if _newclass:handleThickness = property(_kahakai.WindowStyle_handleThickness_get, _kahakai.WindowStyle_handleThickness_set)
    __swig_setmethods__["borderThickness"] = _kahakai.WindowStyle_borderThickness_set
    __swig_getmethods__["borderThickness"] = _kahakai.WindowStyle_borderThickness_get
    if _newclass:borderThickness = property(_kahakai.WindowStyle_borderThickness_get, _kahakai.WindowStyle_borderThickness_set)
    __swig_setmethods__["titleHeight"] = _kahakai.WindowStyle_titleHeight_set
    __swig_getmethods__["titleHeight"] = _kahakai.WindowStyle_titleHeight_get
    if _newclass:titleHeight = property(_kahakai.WindowStyle_titleHeight_get, _kahakai.WindowStyle_titleHeight_set)
    __swig_setmethods__["roundedTopLeft"] = _kahakai.WindowStyle_roundedTopLeft_set
    __swig_getmethods__["roundedTopLeft"] = _kahakai.WindowStyle_roundedTopLeft_get
    if _newclass:roundedTopLeft = property(_kahakai.WindowStyle_roundedTopLeft_get, _kahakai.WindowStyle_roundedTopLeft_set)
    __swig_setmethods__["roundedTopRight"] = _kahakai.WindowStyle_roundedTopRight_set
    __swig_getmethods__["roundedTopRight"] = _kahakai.WindowStyle_roundedTopRight_get
    if _newclass:roundedTopRight = property(_kahakai.WindowStyle_roundedTopRight_get, _kahakai.WindowStyle_roundedTopRight_set)
    __swig_setmethods__["roundedBottomLeft"] = _kahakai.WindowStyle_roundedBottomLeft_set
    __swig_getmethods__["roundedBottomLeft"] = _kahakai.WindowStyle_roundedBottomLeft_get
    if _newclass:roundedBottomLeft = property(_kahakai.WindowStyle_roundedBottomLeft_get, _kahakai.WindowStyle_roundedBottomLeft_set)
    __swig_setmethods__["roundedBottomRight"] = _kahakai.WindowStyle_roundedBottomRight_set
    __swig_getmethods__["roundedBottomRight"] = _kahakai.WindowStyle_roundedBottomRight_get
    if _newclass:roundedBottomRight = property(_kahakai.WindowStyle_roundedBottomRight_get, _kahakai.WindowStyle_roundedBottomRight_set)
    __swig_setmethods__["outlineColor"] = _kahakai.WindowStyle_outlineColor_set
    __swig_getmethods__["outlineColor"] = _kahakai.WindowStyle_outlineColor_get
    if _newclass:outlineColor = property(_kahakai.WindowStyle_outlineColor_get, _kahakai.WindowStyle_outlineColor_set)
    __swig_setmethods__["borderColor"] = _kahakai.WindowStyle_borderColor_set
    __swig_getmethods__["borderColor"] = _kahakai.WindowStyle_borderColor_get
    if _newclass:borderColor = property(_kahakai.WindowStyle_borderColor_get, _kahakai.WindowStyle_borderColor_set)
    __swig_setmethods__["focused"] = _kahakai.WindowStyle_focused_set
    __swig_getmethods__["focused"] = _kahakai.WindowStyle_focused_get
    if _newclass:focused = property(_kahakai.WindowStyle_focused_get, _kahakai.WindowStyle_focused_set)
    __swig_setmethods__["unfocused"] = _kahakai.WindowStyle_unfocused_set
    __swig_getmethods__["unfocused"] = _kahakai.WindowStyle_unfocused_get
    if _newclass:unfocused = property(_kahakai.WindowStyle_unfocused_get, _kahakai.WindowStyle_unfocused_set)
    __swig_setmethods__["yPosition"] = _kahakai.WindowStyle_yPosition_set
    __swig_getmethods__["yPosition"] = _kahakai.WindowStyle_yPosition_get
    if _newclass:yPosition = property(_kahakai.WindowStyle_yPosition_get, _kahakai.WindowStyle_yPosition_set)
    __swig_setmethods__["justify"] = _kahakai.WindowStyle_justify_set
    __swig_getmethods__["justify"] = _kahakai.WindowStyle_justify_get
    if _newclass:justify = property(_kahakai.WindowStyle_justify_get, _kahakai.WindowStyle_justify_set)
    __swig_setmethods__["titleBarWidth"] = _kahakai.WindowStyle_titleBarWidth_set
    __swig_getmethods__["titleBarWidth"] = _kahakai.WindowStyle_titleBarWidth_get
    if _newclass:titleBarWidth = property(_kahakai.WindowStyle_titleBarWidth_get, _kahakai.WindowStyle_titleBarWidth_set)
    __swig_setmethods__["titleBarWidthPercent"] = _kahakai.WindowStyle_titleBarWidthPercent_set
    __swig_getmethods__["titleBarWidthPercent"] = _kahakai.WindowStyle_titleBarWidthPercent_get
    if _newclass:titleBarWidthPercent = property(_kahakai.WindowStyle_titleBarWidthPercent_get, _kahakai.WindowStyle_titleBarWidthPercent_set)
    __swig_setmethods__["fitText"] = _kahakai.WindowStyle_fitText_set
    __swig_getmethods__["fitText"] = _kahakai.WindowStyle_fitText_get
    if _newclass:fitText = property(_kahakai.WindowStyle_fitText_get, _kahakai.WindowStyle_fitText_set)
    __swig_setmethods__["leftEdgeWidth"] = _kahakai.WindowStyle_leftEdgeWidth_set
    __swig_getmethods__["leftEdgeWidth"] = _kahakai.WindowStyle_leftEdgeWidth_get
    if _newclass:leftEdgeWidth = property(_kahakai.WindowStyle_leftEdgeWidth_get, _kahakai.WindowStyle_leftEdgeWidth_set)
    __swig_setmethods__["rightEdgeWidth"] = _kahakai.WindowStyle_rightEdgeWidth_set
    __swig_getmethods__["rightEdgeWidth"] = _kahakai.WindowStyle_rightEdgeWidth_get
    if _newclass:rightEdgeWidth = property(_kahakai.WindowStyle_rightEdgeWidth_get, _kahakai.WindowStyle_rightEdgeWidth_set)
    __swig_setmethods__["buttonPadding"] = _kahakai.WindowStyle_buttonPadding_set
    __swig_getmethods__["buttonPadding"] = _kahakai.WindowStyle_buttonPadding_get
    if _newclass:buttonPadding = property(_kahakai.WindowStyle_buttonPadding_get, _kahakai.WindowStyle_buttonPadding_set)
    __swig_setmethods__["usesDrawing"] = _kahakai.WindowStyle_usesDrawing_set
    __swig_getmethods__["usesDrawing"] = _kahakai.WindowStyle_usesDrawing_get
    if _newclass:usesDrawing = property(_kahakai.WindowStyle_usesDrawing_get, _kahakai.WindowStyle_usesDrawing_set)
    def __init__(self, *args): 
        this = _kahakai.new_WindowStyle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_WindowStyle
    __del__ = lambda self : None;
WindowStyle_swigregister = _kahakai.WindowStyle_swigregister
WindowStyle_swigregister(WindowStyle)

class MenuItemStyle(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuItemStyle, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MenuItemStyle, name)
    __repr__ = _swig_repr
    __swig_setmethods__["font"] = _kahakai.MenuItemStyle_font_set
    __swig_getmethods__["font"] = _kahakai.MenuItemStyle_font_get
    if _newclass:font = property(_kahakai.MenuItemStyle_font_get, _kahakai.MenuItemStyle_font_set)
    __swig_setmethods__["highlightFont"] = _kahakai.MenuItemStyle_highlightFont_set
    __swig_getmethods__["highlightFont"] = _kahakai.MenuItemStyle_highlightFont_get
    if _newclass:highlightFont = property(_kahakai.MenuItemStyle_highlightFont_get, _kahakai.MenuItemStyle_highlightFont_set)
    __swig_setmethods__["yPosition"] = _kahakai.MenuItemStyle_yPosition_set
    __swig_getmethods__["yPosition"] = _kahakai.MenuItemStyle_yPosition_get
    if _newclass:yPosition = property(_kahakai.MenuItemStyle_yPosition_get, _kahakai.MenuItemStyle_yPosition_set)
    def __init__(self, *args): 
        this = _kahakai.new_MenuItemStyle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_MenuItemStyle
    __del__ = lambda self : None;
MenuItemStyle_swigregister = _kahakai.MenuItemStyle_swigregister
MenuItemStyle_swigregister(MenuItemStyle)

class MenuFrameStyle(MenuItemStyle):
    __swig_setmethods__ = {}
    for _s in [MenuItemStyle]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuFrameStyle, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuItemStyle]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuFrameStyle, name)
    __repr__ = _swig_repr
    __swig_setmethods__["color"] = _kahakai.MenuFrameStyle_color_set
    __swig_getmethods__["color"] = _kahakai.MenuFrameStyle_color_get
    if _newclass:color = property(_kahakai.MenuFrameStyle_color_get, _kahakai.MenuFrameStyle_color_set)
    __swig_setmethods__["shadowColor"] = _kahakai.MenuFrameStyle_shadowColor_set
    __swig_getmethods__["shadowColor"] = _kahakai.MenuFrameStyle_shadowColor_get
    if _newclass:shadowColor = property(_kahakai.MenuFrameStyle_shadowColor_get, _kahakai.MenuFrameStyle_shadowColor_set)
    __swig_setmethods__["highlightColor"] = _kahakai.MenuFrameStyle_highlightColor_set
    __swig_getmethods__["highlightColor"] = _kahakai.MenuFrameStyle_highlightColor_get
    if _newclass:highlightColor = property(_kahakai.MenuFrameStyle_highlightColor_get, _kahakai.MenuFrameStyle_highlightColor_set)
    __swig_setmethods__["highlightShadowColor"] = _kahakai.MenuFrameStyle_highlightShadowColor_set
    __swig_getmethods__["highlightShadowColor"] = _kahakai.MenuFrameStyle_highlightShadowColor_get
    if _newclass:highlightShadowColor = property(_kahakai.MenuFrameStyle_highlightShadowColor_get, _kahakai.MenuFrameStyle_highlightShadowColor_set)
    __swig_setmethods__["texture"] = _kahakai.MenuFrameStyle_texture_set
    __swig_getmethods__["texture"] = _kahakai.MenuFrameStyle_texture_get
    if _newclass:texture = property(_kahakai.MenuFrameStyle_texture_get, _kahakai.MenuFrameStyle_texture_set)
    __swig_setmethods__["highlightTexture"] = _kahakai.MenuFrameStyle_highlightTexture_set
    __swig_getmethods__["highlightTexture"] = _kahakai.MenuFrameStyle_highlightTexture_get
    if _newclass:highlightTexture = property(_kahakai.MenuFrameStyle_highlightTexture_get, _kahakai.MenuFrameStyle_highlightTexture_set)
    __swig_setmethods__["justify"] = _kahakai.MenuFrameStyle_justify_set
    __swig_getmethods__["justify"] = _kahakai.MenuFrameStyle_justify_get
    if _newclass:justify = property(_kahakai.MenuFrameStyle_justify_get, _kahakai.MenuFrameStyle_justify_set)
    def __init__(self, *args): 
        this = _kahakai.new_MenuFrameStyle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_MenuFrameStyle
    __del__ = lambda self : None;
MenuFrameStyle_swigregister = _kahakai.MenuFrameStyle_swigregister
MenuFrameStyle_swigregister(MenuFrameStyle)

class MenuTitleStyle(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuTitleStyle, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MenuTitleStyle, name)
    __repr__ = _swig_repr
    __swig_setmethods__["color"] = _kahakai.MenuTitleStyle_color_set
    __swig_getmethods__["color"] = _kahakai.MenuTitleStyle_color_get
    if _newclass:color = property(_kahakai.MenuTitleStyle_color_get, _kahakai.MenuTitleStyle_color_set)
    __swig_setmethods__["shadowColor"] = _kahakai.MenuTitleStyle_shadowColor_set
    __swig_getmethods__["shadowColor"] = _kahakai.MenuTitleStyle_shadowColor_get
    if _newclass:shadowColor = property(_kahakai.MenuTitleStyle_shadowColor_get, _kahakai.MenuTitleStyle_shadowColor_set)
    __swig_setmethods__["texture"] = _kahakai.MenuTitleStyle_texture_set
    __swig_getmethods__["texture"] = _kahakai.MenuTitleStyle_texture_get
    if _newclass:texture = property(_kahakai.MenuTitleStyle_texture_get, _kahakai.MenuTitleStyle_texture_set)
    __swig_setmethods__["font"] = _kahakai.MenuTitleStyle_font_set
    __swig_getmethods__["font"] = _kahakai.MenuTitleStyle_font_get
    if _newclass:font = property(_kahakai.MenuTitleStyle_font_get, _kahakai.MenuTitleStyle_font_set)
    __swig_setmethods__["justify"] = _kahakai.MenuTitleStyle_justify_set
    __swig_getmethods__["justify"] = _kahakai.MenuTitleStyle_justify_get
    if _newclass:justify = property(_kahakai.MenuTitleStyle_justify_get, _kahakai.MenuTitleStyle_justify_set)
    __swig_setmethods__["yPosition"] = _kahakai.MenuTitleStyle_yPosition_set
    __swig_getmethods__["yPosition"] = _kahakai.MenuTitleStyle_yPosition_get
    if _newclass:yPosition = property(_kahakai.MenuTitleStyle_yPosition_get, _kahakai.MenuTitleStyle_yPosition_set)
    def __init__(self, *args): 
        this = _kahakai.new_MenuTitleStyle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_MenuTitleStyle
    __del__ = lambda self : None;
MenuTitleStyle_swigregister = _kahakai.MenuTitleStyle_swigregister
MenuTitleStyle_swigregister(MenuTitleStyle)

class MenuCheckboxStyle(MenuItemStyle):
    __swig_setmethods__ = {}
    for _s in [MenuItemStyle]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuCheckboxStyle, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuItemStyle]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuCheckboxStyle, name)
    __repr__ = _swig_repr
    __swig_setmethods__["label"] = _kahakai.MenuCheckboxStyle_label_set
    __swig_getmethods__["label"] = _kahakai.MenuCheckboxStyle_label_get
    if _newclass:label = property(_kahakai.MenuCheckboxStyle_label_get, _kahakai.MenuCheckboxStyle_label_set)
    def __init__(self, *args): 
        this = _kahakai.new_MenuCheckboxStyle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_MenuCheckboxStyle
    __del__ = lambda self : None;
MenuCheckboxStyle_swigregister = _kahakai.MenuCheckboxStyle_swigregister
MenuCheckboxStyle_swigregister(MenuCheckboxStyle)

class MenuBulletStyle(MenuItemStyle):
    __swig_setmethods__ = {}
    for _s in [MenuItemStyle]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuBulletStyle, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuItemStyle]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MenuBulletStyle, name)
    __repr__ = _swig_repr
    __swig_setmethods__["label"] = _kahakai.MenuBulletStyle_label_set
    __swig_getmethods__["label"] = _kahakai.MenuBulletStyle_label_get
    if _newclass:label = property(_kahakai.MenuBulletStyle_label_get, _kahakai.MenuBulletStyle_label_set)
    def __init__(self, *args): 
        this = _kahakai.new_MenuBulletStyle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_MenuBulletStyle
    __del__ = lambda self : None;
MenuBulletStyle_swigregister = _kahakai.MenuBulletStyle_swigregister
MenuBulletStyle_swigregister(MenuBulletStyle)

class MenuStyle(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MenuStyle, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MenuStyle, name)
    __repr__ = _swig_repr
    __swig_setmethods__["frame"] = _kahakai.MenuStyle_frame_set
    __swig_getmethods__["frame"] = _kahakai.MenuStyle_frame_get
    if _newclass:frame = property(_kahakai.MenuStyle_frame_get, _kahakai.MenuStyle_frame_set)
    __swig_setmethods__["title"] = _kahakai.MenuStyle_title_set
    __swig_getmethods__["title"] = _kahakai.MenuStyle_title_get
    if _newclass:title = property(_kahakai.MenuStyle_title_get, _kahakai.MenuStyle_title_set)
    __swig_setmethods__["checkboxTrue"] = _kahakai.MenuStyle_checkboxTrue_set
    __swig_getmethods__["checkboxTrue"] = _kahakai.MenuStyle_checkboxTrue_get
    if _newclass:checkboxTrue = property(_kahakai.MenuStyle_checkboxTrue_get, _kahakai.MenuStyle_checkboxTrue_set)
    __swig_setmethods__["checkboxFalse"] = _kahakai.MenuStyle_checkboxFalse_set
    __swig_getmethods__["checkboxFalse"] = _kahakai.MenuStyle_checkboxFalse_get
    if _newclass:checkboxFalse = property(_kahakai.MenuStyle_checkboxFalse_get, _kahakai.MenuStyle_checkboxFalse_set)
    __swig_setmethods__["bullet"] = _kahakai.MenuStyle_bullet_set
    __swig_getmethods__["bullet"] = _kahakai.MenuStyle_bullet_get
    if _newclass:bullet = property(_kahakai.MenuStyle_bullet_get, _kahakai.MenuStyle_bullet_set)
    __swig_setmethods__["roundedTopLeft"] = _kahakai.MenuStyle_roundedTopLeft_set
    __swig_getmethods__["roundedTopLeft"] = _kahakai.MenuStyle_roundedTopLeft_get
    if _newclass:roundedTopLeft = property(_kahakai.MenuStyle_roundedTopLeft_get, _kahakai.MenuStyle_roundedTopLeft_set)
    __swig_setmethods__["roundedTopRight"] = _kahakai.MenuStyle_roundedTopRight_set
    __swig_getmethods__["roundedTopRight"] = _kahakai.MenuStyle_roundedTopRight_get
    if _newclass:roundedTopRight = property(_kahakai.MenuStyle_roundedTopRight_get, _kahakai.MenuStyle_roundedTopRight_set)
    __swig_setmethods__["roundedBottomLeft"] = _kahakai.MenuStyle_roundedBottomLeft_set
    __swig_getmethods__["roundedBottomLeft"] = _kahakai.MenuStyle_roundedBottomLeft_get
    if _newclass:roundedBottomLeft = property(_kahakai.MenuStyle_roundedBottomLeft_get, _kahakai.MenuStyle_roundedBottomLeft_set)
    __swig_setmethods__["roundedBottomRight"] = _kahakai.MenuStyle_roundedBottomRight_set
    __swig_getmethods__["roundedBottomRight"] = _kahakai.MenuStyle_roundedBottomRight_get
    if _newclass:roundedBottomRight = property(_kahakai.MenuStyle_roundedBottomRight_get, _kahakai.MenuStyle_roundedBottomRight_set)
    __swig_setmethods__["borderColor"] = _kahakai.MenuStyle_borderColor_set
    __swig_getmethods__["borderColor"] = _kahakai.MenuStyle_borderColor_get
    if _newclass:borderColor = property(_kahakai.MenuStyle_borderColor_get, _kahakai.MenuStyle_borderColor_set)
    __swig_setmethods__["borderThickness"] = _kahakai.MenuStyle_borderThickness_set
    __swig_getmethods__["borderThickness"] = _kahakai.MenuStyle_borderThickness_get
    if _newclass:borderThickness = property(_kahakai.MenuStyle_borderThickness_get, _kahakai.MenuStyle_borderThickness_set)
    __swig_setmethods__["titleHeight"] = _kahakai.MenuStyle_titleHeight_set
    __swig_getmethods__["titleHeight"] = _kahakai.MenuStyle_titleHeight_get
    if _newclass:titleHeight = property(_kahakai.MenuStyle_titleHeight_get, _kahakai.MenuStyle_titleHeight_set)
    __swig_setmethods__["itemHeight"] = _kahakai.MenuStyle_itemHeight_set
    __swig_getmethods__["itemHeight"] = _kahakai.MenuStyle_itemHeight_get
    if _newclass:itemHeight = property(_kahakai.MenuStyle_itemHeight_get, _kahakai.MenuStyle_itemHeight_set)
    def __init__(self, *args): 
        this = _kahakai.new_MenuStyle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_MenuStyle
    __del__ = lambda self : None;
MenuStyle_swigregister = _kahakai.MenuStyle_swigregister
MenuStyle_swigregister(MenuStyle)

class DockholderStyle(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DockholderStyle, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DockholderStyle, name)
    __repr__ = _swig_repr
    __swig_setmethods__["borderColor"] = _kahakai.DockholderStyle_borderColor_set
    __swig_getmethods__["borderColor"] = _kahakai.DockholderStyle_borderColor_get
    if _newclass:borderColor = property(_kahakai.DockholderStyle_borderColor_get, _kahakai.DockholderStyle_borderColor_set)
    __swig_setmethods__["texture"] = _kahakai.DockholderStyle_texture_set
    __swig_getmethods__["texture"] = _kahakai.DockholderStyle_texture_get
    if _newclass:texture = property(_kahakai.DockholderStyle_texture_get, _kahakai.DockholderStyle_texture_set)
    __swig_setmethods__["borderThickness"] = _kahakai.DockholderStyle_borderThickness_set
    __swig_getmethods__["borderThickness"] = _kahakai.DockholderStyle_borderThickness_get
    if _newclass:borderThickness = property(_kahakai.DockholderStyle_borderThickness_get, _kahakai.DockholderStyle_borderThickness_set)
    def __init__(self, *args): 
        this = _kahakai.new_DockholderStyle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_DockholderStyle
    __del__ = lambda self : None;
DockholderStyle_swigregister = _kahakai.DockholderStyle_swigregister
DockholderStyle_swigregister(DockholderStyle)

class DockStyle(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DockStyle, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DockStyle, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _kahakai.DockStyle_x_set
    __swig_getmethods__["x"] = _kahakai.DockStyle_x_get
    if _newclass:x = property(_kahakai.DockStyle_x_get, _kahakai.DockStyle_x_set)
    __swig_setmethods__["y"] = _kahakai.DockStyle_y_set
    __swig_getmethods__["y"] = _kahakai.DockStyle_y_get
    if _newclass:y = property(_kahakai.DockStyle_y_get, _kahakai.DockStyle_y_set)
    __swig_setmethods__["geometry"] = _kahakai.DockStyle_geometry_set
    __swig_getmethods__["geometry"] = _kahakai.DockStyle_geometry_get
    if _newclass:geometry = property(_kahakai.DockStyle_geometry_get, _kahakai.DockStyle_geometry_set)
    __swig_setmethods__["direction"] = _kahakai.DockStyle_direction_set
    __swig_getmethods__["direction"] = _kahakai.DockStyle_direction_get
    if _newclass:direction = property(_kahakai.DockStyle_direction_get, _kahakai.DockStyle_direction_set)
    __swig_setmethods__["stacking"] = _kahakai.DockStyle_stacking_set
    __swig_getmethods__["stacking"] = _kahakai.DockStyle_stacking_get
    if _newclass:stacking = property(_kahakai.DockStyle_stacking_get, _kahakai.DockStyle_stacking_set)
    __swig_setmethods__["desktop_mask"] = _kahakai.DockStyle_desktop_mask_set
    __swig_getmethods__["desktop_mask"] = _kahakai.DockStyle_desktop_mask_get
    if _newclass:desktop_mask = property(_kahakai.DockStyle_desktop_mask_get, _kahakai.DockStyle_desktop_mask_set)
    __swig_setmethods__["gridspace"] = _kahakai.DockStyle_gridspace_set
    __swig_getmethods__["gridspace"] = _kahakai.DockStyle_gridspace_get
    if _newclass:gridspace = property(_kahakai.DockStyle_gridspace_get, _kahakai.DockStyle_gridspace_set)
    __swig_setmethods__["order_type"] = _kahakai.DockStyle_order_type_set
    __swig_getmethods__["order_type"] = _kahakai.DockStyle_order_type_get
    if _newclass:order_type = property(_kahakai.DockStyle_order_type_get, _kahakai.DockStyle_order_type_set)
    __swig_setmethods__["order"] = _kahakai.DockStyle_order_set
    __swig_getmethods__["order"] = _kahakai.DockStyle_order_get
    if _newclass:order = property(_kahakai.DockStyle_order_get, _kahakai.DockStyle_order_set)
    __swig_setmethods__["centered"] = _kahakai.DockStyle_centered_set
    __swig_getmethods__["centered"] = _kahakai.DockStyle_centered_get
    if _newclass:centered = property(_kahakai.DockStyle_centered_get, _kahakai.DockStyle_centered_set)
    __swig_setmethods__["inworkspace"] = _kahakai.DockStyle_inworkspace_set
    __swig_getmethods__["inworkspace"] = _kahakai.DockStyle_inworkspace_get
    if _newclass:inworkspace = property(_kahakai.DockStyle_inworkspace_get, _kahakai.DockStyle_inworkspace_set)
    __swig_setmethods__["style"] = _kahakai.DockStyle_style_set
    __swig_getmethods__["style"] = _kahakai.DockStyle_style_get
    if _newclass:style = property(_kahakai.DockStyle_style_get, _kahakai.DockStyle_style_set)
    def __init__(self, *args): 
        this = _kahakai.new_DockStyle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_DockStyle
    __del__ = lambda self : None;
DockStyle_swigregister = _kahakai.DockStyle_swigregister
DockStyle_swigregister(DockStyle)

class Style(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Style, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Style, name)
    __repr__ = _swig_repr
    __swig_setmethods__["window"] = _kahakai.Style_window_set
    __swig_getmethods__["window"] = _kahakai.Style_window_get
    if _newclass:window = property(_kahakai.Style_window_get, _kahakai.Style_window_set)
    __swig_setmethods__["menu"] = _kahakai.Style_menu_set
    __swig_getmethods__["menu"] = _kahakai.Style_menu_get
    if _newclass:menu = property(_kahakai.Style_menu_get, _kahakai.Style_menu_set)
    __swig_setmethods__["dockStyles"] = _kahakai.Style_dockStyles_set
    __swig_getmethods__["dockStyles"] = _kahakai.Style_dockStyles_get
    if _newclass:dockStyles = property(_kahakai.Style_dockStyles_get, _kahakai.Style_dockStyles_set)
    def __init__(self, *args): 
        this = _kahakai.new_Style(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_Style
    __del__ = lambda self : None;
Style_swigregister = _kahakai.Style_swigregister
Style_swigregister(Style)

class timeval(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, timeval, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, timeval, name)
    __repr__ = _swig_repr
    __swig_setmethods__["tv_sec"] = _kahakai.timeval_tv_sec_set
    __swig_getmethods__["tv_sec"] = _kahakai.timeval_tv_sec_get
    if _newclass:tv_sec = property(_kahakai.timeval_tv_sec_get, _kahakai.timeval_tv_sec_set)
    __swig_setmethods__["tv_usec"] = _kahakai.timeval_tv_usec_set
    __swig_getmethods__["tv_usec"] = _kahakai.timeval_tv_usec_get
    if _newclass:tv_usec = property(_kahakai.timeval_tv_usec_get, _kahakai.timeval_tv_usec_set)
    def __init__(self, *args): 
        this = _kahakai.new_timeval(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_timeval
    __del__ = lambda self : None;
timeval_swigregister = _kahakai.timeval_swigregister
timeval_swigregister(timeval)

class XClassHint(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XClassHint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XClassHint, name)
    __repr__ = _swig_repr
    __swig_setmethods__["res_name"] = _kahakai.XClassHint_res_name_set
    __swig_getmethods__["res_name"] = _kahakai.XClassHint_res_name_get
    if _newclass:res_name = property(_kahakai.XClassHint_res_name_get, _kahakai.XClassHint_res_name_set)
    __swig_setmethods__["res_class"] = _kahakai.XClassHint_res_class_set
    __swig_getmethods__["res_class"] = _kahakai.XClassHint_res_class_get
    if _newclass:res_class = property(_kahakai.XClassHint_res_class_get, _kahakai.XClassHint_res_class_set)
    def __init__(self, *args): 
        this = _kahakai.new_XClassHint(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_XClassHint
    __del__ = lambda self : None;
XClassHint_swigregister = _kahakai.XClassHint_swigregister
XClassHint_swigregister(XClassHint)

getXModifiers = _kahakai.getXModifiers
class PythonFunction(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PythonFunction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PythonFunction, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_PythonFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kahakai.delete_PythonFunction
    __del__ = lambda self : None;
PythonFunction_swigregister = _kahakai.PythonFunction_swigregister
PythonFunction_swigregister(PythonFunction)

class PythonMenuFunction(MenuFunction,PythonFunction):
    __swig_setmethods__ = {}
    for _s in [MenuFunction,PythonFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, PythonMenuFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [MenuFunction,PythonFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, PythonMenuFunction, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_PythonMenuFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.PythonMenuFunction___call__(*args)
    __swig_destroy__ = _kahakai.delete_PythonMenuFunction
    __del__ = lambda self : None;
PythonMenuFunction_swigregister = _kahakai.PythonMenuFunction_swigregister
PythonMenuFunction_swigregister(PythonMenuFunction)

class PythonScreenFunction(ScreenFunction,PythonFunction):
    __swig_setmethods__ = {}
    for _s in [ScreenFunction,PythonFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, PythonScreenFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [ScreenFunction,PythonFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, PythonScreenFunction, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_PythonScreenFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.PythonScreenFunction___call__(*args)
    __swig_destroy__ = _kahakai.delete_PythonScreenFunction
    __del__ = lambda self : None;
PythonScreenFunction_swigregister = _kahakai.PythonScreenFunction_swigregister
PythonScreenFunction_swigregister(PythonScreenFunction)

class PythonWindowFunction(WindowFunction,PythonFunction):
    __swig_setmethods__ = {}
    for _s in [WindowFunction,PythonFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, PythonWindowFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [WindowFunction,PythonFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, PythonWindowFunction, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_PythonWindowFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.PythonWindowFunction___call__(*args)
    __swig_destroy__ = _kahakai.delete_PythonWindowFunction
    __del__ = lambda self : None;
PythonWindowFunction_swigregister = _kahakai.PythonWindowFunction_swigregister
PythonWindowFunction_swigregister(PythonWindowFunction)

class PythonSimpleFunction(SimpleFunction,PythonFunction):
    __swig_setmethods__ = {}
    for _s in [SimpleFunction,PythonFunction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, PythonSimpleFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [SimpleFunction,PythonFunction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, PythonSimpleFunction, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kahakai.new_PythonSimpleFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(*args): return _kahakai.PythonSimpleFunction___call__(*args)
    __swig_destroy__ = _kahakai.delete_PythonSimpleFunction
    __del__ = lambda self : None;
PythonSimpleFunction_swigregister = _kahakai.PythonSimpleFunction_swigregister
PythonSimpleFunction_swigregister(PythonSimpleFunction)

createMenuFunction = _kahakai.createMenuFunction
createWindowFunction = _kahakai.createWindowFunction
createScreenFunction = _kahakai.createScreenFunction
createSimpleFunction = _kahakai.createSimpleFunction


