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

import _kahakai

def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "this"):
        if isinstance(value, class_type):
            self.__dict__[name] = value.this
            if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown
            del value.thisown
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name) or (name == "thisown"):
        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):
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError,name

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 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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowObject, 'this', _kahakai.new_WindowObject(*args))
        _swig_setattr(self, WindowObject, 'thisown', 1)
    __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)
    def __del__(self, destroy=_kahakai.delete_WindowObject):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowObjectPtr(WindowObject):
    def __init__(self, this):
        _swig_setattr(self, WindowObject, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowObject, 'thisown', 0)
        _swig_setattr(self, WindowObject,self.__class__,WindowObject)
_kahakai.WindowObject_swigregister(WindowObjectPtr)

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 RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C++ Kahakai instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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)
    def __del__(self, destroy=_kahakai.delete_Kahakai):
        try:
            if self.thisown: destroy(self)
        except: pass


class KahakaiPtr(Kahakai):
    def __init__(self, this):
        _swig_setattr(self, Kahakai, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Kahakai, 'thisown', 0)
        _swig_setattr(self, Kahakai,self.__class__,Kahakai)
_kahakai.Kahakai_swigregister(KahakaiPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ std::vector<KaScreen * > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    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 pop_back(*args): return _kahakai.Vector_KaScreen_pop_back(*args)
    def __init__(self, *args):
        _swig_setattr(self, Vector_KaScreen, 'this', _kahakai.new_Vector_KaScreen(*args))
        _swig_setattr(self, Vector_KaScreen, 'thisown', 1)
    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 reserve(*args): return _kahakai.Vector_KaScreen_reserve(*args)
    def capacity(*args): return _kahakai.Vector_KaScreen_capacity(*args)
    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 __del__(self, destroy=_kahakai.delete_Vector_KaScreen):
        try:
            if self.thisown: destroy(self)
        except: pass


class Vector_KaScreenPtr(Vector_KaScreen):
    def __init__(self, this):
        _swig_setattr(self, Vector_KaScreen, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Vector_KaScreen, 'thisown', 0)
        _swig_setattr(self, Vector_KaScreen,self.__class__,Vector_KaScreen)
_kahakai.Vector_KaScreen_swigregister(Vector_KaScreenPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ std::vector<KaWindow * > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    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 pop_back(*args): return _kahakai.Vector_KaWindow_pop_back(*args)
    def __init__(self, *args):
        _swig_setattr(self, Vector_KaWindow, 'this', _kahakai.new_Vector_KaWindow(*args))
        _swig_setattr(self, Vector_KaWindow, 'thisown', 1)
    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 reserve(*args): return _kahakai.Vector_KaWindow_reserve(*args)
    def capacity(*args): return _kahakai.Vector_KaWindow_capacity(*args)
    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 __del__(self, destroy=_kahakai.delete_Vector_KaWindow):
        try:
            if self.thisown: destroy(self)
        except: pass


class Vector_KaWindowPtr(Vector_KaWindow):
    def __init__(self, this):
        _swig_setattr(self, Vector_KaWindow, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Vector_KaWindow, 'thisown', 0)
        _swig_setattr(self, Vector_KaWindow,self.__class__,Vector_KaWindow)
_kahakai.Vector_KaWindow_swigregister(Vector_KaWindowPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ std::vector<Desktop * > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    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 pop_back(*args): return _kahakai.Vector_Desktop_pop_back(*args)
    def __init__(self, *args):
        _swig_setattr(self, Vector_Desktop, 'this', _kahakai.new_Vector_Desktop(*args))
        _swig_setattr(self, Vector_Desktop, 'thisown', 1)
    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 reserve(*args): return _kahakai.Vector_Desktop_reserve(*args)
    def capacity(*args): return _kahakai.Vector_Desktop_capacity(*args)
    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 __del__(self, destroy=_kahakai.delete_Vector_Desktop):
        try:
            if self.thisown: destroy(self)
        except: pass


class Vector_DesktopPtr(Vector_Desktop):
    def __init__(self, this):
        _swig_setattr(self, Vector_Desktop, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Vector_Desktop, 'thisown', 0)
        _swig_setattr(self, Vector_Desktop,self.__class__,Vector_Desktop)
_kahakai.Vector_Desktop_swigregister(Vector_DesktopPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ std::vector<KaAction * > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    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 pop_back(*args): return _kahakai.Vector_KaAction_pop_back(*args)
    def __init__(self, *args):
        _swig_setattr(self, Vector_KaAction, 'this', _kahakai.new_Vector_KaAction(*args))
        _swig_setattr(self, Vector_KaAction, 'thisown', 1)
    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 reserve(*args): return _kahakai.Vector_KaAction_reserve(*args)
    def capacity(*args): return _kahakai.Vector_KaAction_capacity(*args)
    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 __del__(self, destroy=_kahakai.delete_Vector_KaAction):
        try:
            if self.thisown: destroy(self)
        except: pass


class Vector_KaActionPtr(Vector_KaAction):
    def __init__(self, this):
        _swig_setattr(self, Vector_KaAction, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Vector_KaAction, 'thisown', 0)
        _swig_setattr(self, Vector_KaAction,self.__class__,Vector_KaAction)
_kahakai.Vector_KaAction_swigregister(Vector_KaActionPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ std::vector<KaMenu * > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    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 pop_back(*args): return _kahakai.Vector_KaMenu_pop_back(*args)
    def __init__(self, *args):
        _swig_setattr(self, Vector_KaMenu, 'this', _kahakai.new_Vector_KaMenu(*args))
        _swig_setattr(self, Vector_KaMenu, 'thisown', 1)
    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 reserve(*args): return _kahakai.Vector_KaMenu_reserve(*args)
    def capacity(*args): return _kahakai.Vector_KaMenu_capacity(*args)
    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 __del__(self, destroy=_kahakai.delete_Vector_KaMenu):
        try:
            if self.thisown: destroy(self)
        except: pass


class Vector_KaMenuPtr(Vector_KaMenu):
    def __init__(self, this):
        _swig_setattr(self, Vector_KaMenu, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Vector_KaMenu, 'thisown', 0)
        _swig_setattr(self, Vector_KaMenu,self.__class__,Vector_KaMenu)
_kahakai.Vector_KaMenu_swigregister(Vector_KaMenuPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ std::pair<char *,int > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, Pair_ci, 'this', _kahakai.new_Pair_ci(*args))
        _swig_setattr(self, Pair_ci, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_Pair_ci):
        try:
            if self.thisown: destroy(self)
        except: pass


class Pair_ciPtr(Pair_ci):
    def __init__(self, this):
        _swig_setattr(self, Pair_ci, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Pair_ci, 'thisown', 0)
        _swig_setattr(self, Pair_ci,self.__class__,Pair_ci)
_kahakai.Pair_ci_swigregister(Pair_ciPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ std::vector<std::pair<char *,int > > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    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 pop_back(*args): return _kahakai.Vector_pair_ci_pop_back(*args)
    def __init__(self, *args):
        _swig_setattr(self, Vector_pair_ci, 'this', _kahakai.new_Vector_pair_ci(*args))
        _swig_setattr(self, Vector_pair_ci, 'thisown', 1)
    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 reserve(*args): return _kahakai.Vector_pair_ci_reserve(*args)
    def capacity(*args): return _kahakai.Vector_pair_ci_capacity(*args)
    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 __del__(self, destroy=_kahakai.delete_Vector_pair_ci):
        try:
            if self.thisown: destroy(self)
        except: pass


class Vector_pair_ciPtr(Vector_pair_ci):
    def __init__(self, this):
        _swig_setattr(self, Vector_pair_ci, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Vector_pair_ci, 'thisown', 0)
        _swig_setattr(self, Vector_pair_ci,self.__class__,Vector_pair_ci)
_kahakai.Vector_pair_ci_swigregister(Vector_pair_ciPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ std::vector<int > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    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 pop_back(*args): return _kahakai.Vector_int_pop_back(*args)
    def __init__(self, *args):
        _swig_setattr(self, Vector_int, 'this', _kahakai.new_Vector_int(*args))
        _swig_setattr(self, Vector_int, 'thisown', 1)
    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 reserve(*args): return _kahakai.Vector_int_reserve(*args)
    def capacity(*args): return _kahakai.Vector_int_capacity(*args)
    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 __del__(self, destroy=_kahakai.delete_Vector_int):
        try:
            if self.thisown: destroy(self)
        except: pass


class Vector_intPtr(Vector_int):
    def __init__(self, this):
        _swig_setattr(self, Vector_int, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Vector_int, 'thisown', 0)
        _swig_setattr(self, Vector_int,self.__class__,Vector_int)
_kahakai.Vector_int_swigregister(Vector_intPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ std::vector<std::vector<KaAction * > > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    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 pop_back(*args): return _kahakai.Vector_Vector_KaAction_pop_back(*args)
    def __init__(self, *args):
        _swig_setattr(self, Vector_Vector_KaAction, 'this', _kahakai.new_Vector_Vector_KaAction(*args))
        _swig_setattr(self, Vector_Vector_KaAction, 'thisown', 1)
    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 reserve(*args): return _kahakai.Vector_Vector_KaAction_reserve(*args)
    def capacity(*args): return _kahakai.Vector_Vector_KaAction_capacity(*args)
    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 __del__(self, destroy=_kahakai.delete_Vector_Vector_KaAction):
        try:
            if self.thisown: destroy(self)
        except: pass


class Vector_Vector_KaActionPtr(Vector_Vector_KaAction):
    def __init__(self, this):
        _swig_setattr(self, Vector_Vector_KaAction, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Vector_Vector_KaAction, 'thisown', 0)
        _swig_setattr(self, Vector_Vector_KaAction,self.__class__,Vector_Vector_KaAction)
_kahakai.Vector_Vector_KaAction_swigregister(Vector_Vector_KaActionPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ std::map<std::string,std::vector<KaAction * > > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    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):
        _swig_setattr(self, Map_Vector_KaAction, 'this', _kahakai.new_Map_Vector_KaAction(*args))
        _swig_setattr(self, Map_Vector_KaAction, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_Map_Vector_KaAction):
        try:
            if self.thisown: destroy(self)
        except: pass


class Map_Vector_KaActionPtr(Map_Vector_KaAction):
    def __init__(self, this):
        _swig_setattr(self, Map_Vector_KaAction, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Map_Vector_KaAction, 'thisown', 0)
        _swig_setattr(self, Map_Vector_KaAction,self.__class__,Map_Vector_KaAction)
_kahakai.Map_Vector_KaAction_swigregister(Map_Vector_KaActionPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ std::map<char const *,WindowFunction * > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    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):
        _swig_setattr(self, Map_CStr_WindowFunction, 'this', _kahakai.new_Map_CStr_WindowFunction(*args))
        _swig_setattr(self, Map_CStr_WindowFunction, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_Map_CStr_WindowFunction):
        try:
            if self.thisown: destroy(self)
        except: pass


class Map_CStr_WindowFunctionPtr(Map_CStr_WindowFunction):
    def __init__(self, this):
        _swig_setattr(self, Map_CStr_WindowFunction, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Map_CStr_WindowFunction, 'thisown', 0)
        _swig_setattr(self, Map_CStr_WindowFunction,self.__class__,Map_CStr_WindowFunction)
_kahakai.Map_CStr_WindowFunction_swigregister(Map_CStr_WindowFunctionPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ std::map<char const *,ScreenFunction * > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    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):
        _swig_setattr(self, Map_CStr_ScreenFunction, 'this', _kahakai.new_Map_CStr_ScreenFunction(*args))
        _swig_setattr(self, Map_CStr_ScreenFunction, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_Map_CStr_ScreenFunction):
        try:
            if self.thisown: destroy(self)
        except: pass


class Map_CStr_ScreenFunctionPtr(Map_CStr_ScreenFunction):
    def __init__(self, this):
        _swig_setattr(self, Map_CStr_ScreenFunction, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Map_CStr_ScreenFunction, 'thisown', 0)
        _swig_setattr(self, Map_CStr_ScreenFunction,self.__class__,Map_CStr_ScreenFunction)
_kahakai.Map_CStr_ScreenFunction_swigregister(Map_CStr_ScreenFunctionPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ std::map<char const *,MenuFunction * > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    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):
        _swig_setattr(self, Map_CStr_MenuFunction, 'this', _kahakai.new_Map_CStr_MenuFunction(*args))
        _swig_setattr(self, Map_CStr_MenuFunction, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_Map_CStr_MenuFunction):
        try:
            if self.thisown: destroy(self)
        except: pass


class Map_CStr_MenuFunctionPtr(Map_CStr_MenuFunction):
    def __init__(self, this):
        _swig_setattr(self, Map_CStr_MenuFunction, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Map_CStr_MenuFunction, 'thisown', 0)
        _swig_setattr(self, Map_CStr_MenuFunction,self.__class__,Map_CStr_MenuFunction)
_kahakai.Map_CStr_MenuFunction_swigregister(Map_CStr_MenuFunctionPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ KaFont instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, KaFont, 'this', _kahakai.new_KaFont(*args))
        _swig_setattr(self, KaFont, 'thisown', 1)
    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)
    def __del__(self, destroy=_kahakai.delete_KaFont):
        try:
            if self.thisown: destroy(self)
        except: pass


class KaFontPtr(KaFont):
    def __init__(self, this):
        _swig_setattr(self, KaFont, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, KaFont, 'thisown', 0)
        _swig_setattr(self, KaFont,self.__class__,KaFont)
_kahakai.KaFont_swigregister(KaFontPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ EventDetail instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, EventDetail, 'this', _kahakai.new_EventDetail(*args))
        _swig_setattr(self, EventDetail, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_EventDetail):
        try:
            if self.thisown: destroy(self)
        except: pass


class EventDetailPtr(EventDetail):
    def __init__(self, this):
        _swig_setattr(self, EventDetail, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, EventDetail, 'thisown', 0)
        _swig_setattr(self, EventDetail,self.__class__,EventDetail)
_kahakai.EventDetail_swigregister(EventDetailPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Function instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, Function, 'this', _kahakai.new_Function(*args))
        _swig_setattr(self, Function, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_Function):
        try:
            if self.thisown: destroy(self)
        except: pass


class FunctionPtr(Function):
    def __init__(self, this):
        _swig_setattr(self, Function, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Function, 'thisown', 0)
        _swig_setattr(self, Function,self.__class__,Function)
_kahakai.Function_swigregister(FunctionPtr)

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 RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowFunction instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __call__(*args): return _kahakai.WindowFunction___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowFunction):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowFunctionPtr(WindowFunction):
    def __init__(self, this):
        _swig_setattr(self, WindowFunction, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowFunction, 'thisown', 0)
        _swig_setattr(self, WindowFunction,self.__class__,WindowFunction)
_kahakai.WindowFunction_swigregister(WindowFunctionPtr)

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 RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuFunction instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __call__(*args): return _kahakai.MenuFunction___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuFunction):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuFunctionPtr(MenuFunction):
    def __init__(self, this):
        _swig_setattr(self, MenuFunction, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuFunction, 'thisown', 0)
        _swig_setattr(self, MenuFunction,self.__class__,MenuFunction)
_kahakai.MenuFunction_swigregister(MenuFunctionPtr)

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 RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenFunction instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __call__(*args): return _kahakai.ScreenFunction___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenFunction):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenFunctionPtr(ScreenFunction):
    def __init__(self, this):
        _swig_setattr(self, ScreenFunction, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenFunction, 'thisown', 0)
        _swig_setattr(self, ScreenFunction,self.__class__,ScreenFunction)
_kahakai.ScreenFunction_swigregister(ScreenFunctionPtr)

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 RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C++ SimpleFunction instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __call__(*args): return _kahakai.SimpleFunction___call__(*args)
    def __del__(self, destroy=_kahakai.delete_SimpleFunction):
        try:
            if self.thisown: destroy(self)
        except: pass


class SimpleFunctionPtr(SimpleFunction):
    def __init__(self, this):
        _swig_setattr(self, SimpleFunction, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, SimpleFunction, 'thisown', 0)
        _swig_setattr(self, SimpleFunction,self.__class__,SimpleFunction)
_kahakai.SimpleFunction_swigregister(SimpleFunctionPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ SizeStruct instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, SizeStruct, 'this', _kahakai.new_SizeStruct(*args))
        _swig_setattr(self, SizeStruct, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_SizeStruct):
        try:
            if self.thisown: destroy(self)
        except: pass


class SizeStructPtr(SizeStruct):
    def __init__(self, this):
        _swig_setattr(self, SizeStruct, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, SizeStruct, 'thisown', 0)
        _swig_setattr(self, SizeStruct,self.__class__,SizeStruct)
_kahakai.SizeStruct_swigregister(SizeStructPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ KaWindowFlags instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, KaWindowFlags, 'this', _kahakai.new_KaWindowFlags(*args))
        _swig_setattr(self, KaWindowFlags, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_KaWindowFlags):
        try:
            if self.thisown: destroy(self)
        except: pass


class KaWindowFlagsPtr(KaWindowFlags):
    def __init__(self, this):
        _swig_setattr(self, KaWindowFlags, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, KaWindowFlags, 'thisown', 0)
        _swig_setattr(self, KaWindowFlags,self.__class__,KaWindowFlags)
_kahakai.KaWindowFlags_swigregister(KaWindowFlagsPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ KaWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, KaWindow, 'this', _kahakai.new_KaWindow(*args))
        _swig_setattr(self, KaWindow, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_KaWindow):
        try:
            if self.thisown: destroy(self)
        except: pass

    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)

class KaWindowPtr(KaWindow):
    def __init__(self, this):
        _swig_setattr(self, KaWindow, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, KaWindow, 'thisown', 0)
        _swig_setattr(self, KaWindow,self.__class__,KaWindow)
_kahakai.KaWindow_swigregister(KaWindowPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvFocus instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvFocus, 'this', _kahakai.new_WindowEvFocus(*args))
        _swig_setattr(self, WindowEvFocus, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvFocus___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvFocus):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvFocusPtr(WindowEvFocus):
    def __init__(self, this):
        _swig_setattr(self, WindowEvFocus, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvFocus, 'thisown', 0)
        _swig_setattr(self, WindowEvFocus,self.__class__,WindowEvFocus)
_kahakai.WindowEvFocus_swigregister(WindowEvFocusPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvFocusVis instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvFocusVis, 'this', _kahakai.new_WindowEvFocusVis(*args))
        _swig_setattr(self, WindowEvFocusVis, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvFocusVis___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvFocusVis):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvFocusVisPtr(WindowEvFocusVis):
    def __init__(self, this):
        _swig_setattr(self, WindowEvFocusVis, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvFocusVis, 'thisown', 0)
        _swig_setattr(self, WindowEvFocusVis,self.__class__,WindowEvFocusVis)
_kahakai.WindowEvFocusVis_swigregister(WindowEvFocusVisPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvUnFocus instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvUnFocus, 'this', _kahakai.new_WindowEvUnFocus(*args))
        _swig_setattr(self, WindowEvUnFocus, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvUnFocus___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvUnFocus):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvUnFocusPtr(WindowEvUnFocus):
    def __init__(self, this):
        _swig_setattr(self, WindowEvUnFocus, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvUnFocus, 'thisown', 0)
        _swig_setattr(self, WindowEvUnFocus,self.__class__,WindowEvUnFocus)
_kahakai.WindowEvUnFocus_swigregister(WindowEvUnFocusPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvClose instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvClose, 'this', _kahakai.new_WindowEvClose(*args))
        _swig_setattr(self, WindowEvClose, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvClose___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvClose):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvClosePtr(WindowEvClose):
    def __init__(self, this):
        _swig_setattr(self, WindowEvClose, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvClose, 'thisown', 0)
        _swig_setattr(self, WindowEvClose,self.__class__,WindowEvClose)
_kahakai.WindowEvClose_swigregister(WindowEvClosePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvRaise instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvRaise, 'this', _kahakai.new_WindowEvRaise(*args))
        _swig_setattr(self, WindowEvRaise, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvRaise___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvRaise):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvRaisePtr(WindowEvRaise):
    def __init__(self, this):
        _swig_setattr(self, WindowEvRaise, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvRaise, 'thisown', 0)
        _swig_setattr(self, WindowEvRaise,self.__class__,WindowEvRaise)
_kahakai.WindowEvRaise_swigregister(WindowEvRaisePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvLower instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvLower, 'this', _kahakai.new_WindowEvLower(*args))
        _swig_setattr(self, WindowEvLower, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvLower___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvLower):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvLowerPtr(WindowEvLower):
    def __init__(self, this):
        _swig_setattr(self, WindowEvLower, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvLower, 'thisown', 0)
        _swig_setattr(self, WindowEvLower,self.__class__,WindowEvLower)
_kahakai.WindowEvLower_swigregister(WindowEvLowerPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMoveResize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMoveResize, 'this', _kahakai.new_WindowEvMoveResize(*args))
        _swig_setattr(self, WindowEvMoveResize, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMoveResize___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMoveResize):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMoveResizePtr(WindowEvMoveResize):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMoveResize, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMoveResize, 'thisown', 0)
        _swig_setattr(self, WindowEvMoveResize,self.__class__,WindowEvMoveResize)
_kahakai.WindowEvMoveResize_swigregister(WindowEvMoveResizePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMoveResizeVirtual instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMoveResizeVirtual, 'this', _kahakai.new_WindowEvMoveResizeVirtual(*args))
        _swig_setattr(self, WindowEvMoveResizeVirtual, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMoveResizeVirtual___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMoveResizeVirtual):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMoveResizeVirtualPtr(WindowEvMoveResizeVirtual):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMoveResizeVirtual, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMoveResizeVirtual, 'thisown', 0)
        _swig_setattr(self, WindowEvMoveResizeVirtual,self.__class__,WindowEvMoveResizeVirtual)
_kahakai.WindowEvMoveResizeVirtual_swigregister(WindowEvMoveResizeVirtualPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMoveWindowToPointer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMoveWindowToPointer, 'this', _kahakai.new_WindowEvMoveWindowToPointer(*args))
        _swig_setattr(self, WindowEvMoveWindowToPointer, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMoveWindowToPointer___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMoveWindowToPointer):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMoveWindowToPointerPtr(WindowEvMoveWindowToPointer):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMoveWindowToPointer, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMoveWindowToPointer, 'thisown', 0)
        _swig_setattr(self, WindowEvMoveWindowToPointer,self.__class__,WindowEvMoveWindowToPointer)
_kahakai.WindowEvMoveWindowToPointer_swigregister(WindowEvMoveWindowToPointerPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMoveWindowBy instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMoveWindowBy, 'this', _kahakai.new_WindowEvMoveWindowBy(*args))
        _swig_setattr(self, WindowEvMoveWindowBy, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMoveWindowBy___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMoveWindowBy):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMoveWindowByPtr(WindowEvMoveWindowBy):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMoveWindowBy, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMoveWindowBy, 'thisown', 0)
        _swig_setattr(self, WindowEvMoveWindowBy,self.__class__,WindowEvMoveWindowBy)
_kahakai.WindowEvMoveWindowBy_swigregister(WindowEvMoveWindowByPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMoveWindowToSmartPlace instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMoveWindowToSmartPlace, 'this', _kahakai.new_WindowEvMoveWindowToSmartPlace(*args))
        _swig_setattr(self, WindowEvMoveWindowToSmartPlace, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMoveWindowToSmartPlace___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMoveWindowToSmartPlace):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMoveWindowToSmartPlacePtr(WindowEvMoveWindowToSmartPlace):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMoveWindowToSmartPlace, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMoveWindowToSmartPlace, 'thisown', 0)
        _swig_setattr(self, WindowEvMoveWindowToSmartPlace,self.__class__,WindowEvMoveWindowToSmartPlace)
_kahakai.WindowEvMoveWindowToSmartPlace_swigregister(WindowEvMoveWindowToSmartPlacePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMoveWindowToViewport instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMoveWindowToViewport, 'this', _kahakai.new_WindowEvMoveWindowToViewport(*args))
        _swig_setattr(self, WindowEvMoveWindowToViewport, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMoveWindowToViewport___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMoveWindowToViewport):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMoveWindowToViewportPtr(WindowEvMoveWindowToViewport):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMoveWindowToViewport, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMoveWindowToViewport, 'thisown', 0)
        _swig_setattr(self, WindowEvMoveWindowToViewport,self.__class__,WindowEvMoveWindowToViewport)
_kahakai.WindowEvMoveWindowToViewport_swigregister(WindowEvMoveWindowToViewportPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMoveWindowToCurrentViewport instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMoveWindowToCurrentViewport, 'this', _kahakai.new_WindowEvMoveWindowToCurrentViewport(*args))
        _swig_setattr(self, WindowEvMoveWindowToCurrentViewport, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMoveWindowToCurrentViewport___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMoveWindowToCurrentViewport):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMoveWindowToCurrentViewportPtr(WindowEvMoveWindowToCurrentViewport):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMoveWindowToCurrentViewport, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMoveWindowToCurrentViewport, 'thisown', 0)
        _swig_setattr(self, WindowEvMoveWindowToCurrentViewport,self.__class__,WindowEvMoveWindowToCurrentViewport)
_kahakai.WindowEvMoveWindowToCurrentViewport_swigregister(WindowEvMoveWindowToCurrentViewportPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvDesktopMask instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvDesktopMask, 'this', _kahakai.new_WindowEvDesktopMask(*args))
        _swig_setattr(self, WindowEvDesktopMask, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvDesktopMask___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvDesktopMask):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvDesktopMaskPtr(WindowEvDesktopMask):
    def __init__(self, this):
        _swig_setattr(self, WindowEvDesktopMask, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvDesktopMask, 'thisown', 0)
        _swig_setattr(self, WindowEvDesktopMask,self.__class__,WindowEvDesktopMask)
_kahakai.WindowEvDesktopMask_swigregister(WindowEvDesktopMaskPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvJoinDesktop instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvJoinDesktop, 'this', _kahakai.new_WindowEvJoinDesktop(*args))
        _swig_setattr(self, WindowEvJoinDesktop, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvJoinDesktop___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvJoinDesktop):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvJoinDesktopPtr(WindowEvJoinDesktop):
    def __init__(self, this):
        _swig_setattr(self, WindowEvJoinDesktop, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvJoinDesktop, 'thisown', 0)
        _swig_setattr(self, WindowEvJoinDesktop,self.__class__,WindowEvJoinDesktop)
_kahakai.WindowEvJoinDesktop_swigregister(WindowEvJoinDesktopPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvPartDesktop instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvPartDesktop, 'this', _kahakai.new_WindowEvPartDesktop(*args))
        _swig_setattr(self, WindowEvPartDesktop, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvPartDesktop___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvPartDesktop):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvPartDesktopPtr(WindowEvPartDesktop):
    def __init__(self, this):
        _swig_setattr(self, WindowEvPartDesktop, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvPartDesktop, 'thisown', 0)
        _swig_setattr(self, WindowEvPartDesktop,self.__class__,WindowEvPartDesktop)
_kahakai.WindowEvPartDesktop_swigregister(WindowEvPartDesktopPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvPartCurrentJoinDesktop instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvPartCurrentJoinDesktop, 'this', _kahakai.new_WindowEvPartCurrentJoinDesktop(*args))
        _swig_setattr(self, WindowEvPartCurrentJoinDesktop, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvPartCurrentJoinDesktop___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvPartCurrentJoinDesktop):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvPartCurrentJoinDesktopPtr(WindowEvPartCurrentJoinDesktop):
    def __init__(self, this):
        _swig_setattr(self, WindowEvPartCurrentJoinDesktop, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvPartCurrentJoinDesktop, 'thisown', 0)
        _swig_setattr(self, WindowEvPartCurrentJoinDesktop,self.__class__,WindowEvPartCurrentJoinDesktop)
_kahakai.WindowEvPartCurrentJoinDesktop_swigregister(WindowEvPartCurrentJoinDesktopPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvPartCurrentDesktop instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvPartCurrentDesktop, 'this', _kahakai.new_WindowEvPartCurrentDesktop(*args))
        _swig_setattr(self, WindowEvPartCurrentDesktop, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvPartCurrentDesktop___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvPartCurrentDesktop):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvPartCurrentDesktopPtr(WindowEvPartCurrentDesktop):
    def __init__(self, this):
        _swig_setattr(self, WindowEvPartCurrentDesktop, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvPartCurrentDesktop, 'thisown', 0)
        _swig_setattr(self, WindowEvPartCurrentDesktop,self.__class__,WindowEvPartCurrentDesktop)
_kahakai.WindowEvPartCurrentDesktop_swigregister(WindowEvPartCurrentDesktopPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvJoinAllDesktops instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvJoinAllDesktops, 'this', _kahakai.new_WindowEvJoinAllDesktops(*args))
        _swig_setattr(self, WindowEvJoinAllDesktops, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvJoinAllDesktops___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvJoinAllDesktops):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvJoinAllDesktopsPtr(WindowEvJoinAllDesktops):
    def __init__(self, this):
        _swig_setattr(self, WindowEvJoinAllDesktops, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvJoinAllDesktops, 'thisown', 0)
        _swig_setattr(self, WindowEvJoinAllDesktops,self.__class__,WindowEvJoinAllDesktops)
_kahakai.WindowEvJoinAllDesktops_swigregister(WindowEvJoinAllDesktopsPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvPartAllDesktopsExceptCurrent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvPartAllDesktopsExceptCurrent, 'this', _kahakai.new_WindowEvPartAllDesktopsExceptCurrent(*args))
        _swig_setattr(self, WindowEvPartAllDesktopsExceptCurrent, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvPartAllDesktopsExceptCurrent___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvPartAllDesktopsExceptCurrent):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvPartAllDesktopsExceptCurrentPtr(WindowEvPartAllDesktopsExceptCurrent):
    def __init__(self, this):
        _swig_setattr(self, WindowEvPartAllDesktopsExceptCurrent, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvPartAllDesktopsExceptCurrent, 'thisown', 0)
        _swig_setattr(self, WindowEvPartAllDesktopsExceptCurrent,self.__class__,WindowEvPartAllDesktopsExceptCurrent)
_kahakai.WindowEvPartAllDesktopsExceptCurrent_swigregister(WindowEvPartAllDesktopsExceptCurrentPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMove instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMove, 'this', _kahakai.new_WindowEvMove(*args))
        _swig_setattr(self, WindowEvMove, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMove___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMove):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMovePtr(WindowEvMove):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMove, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMove, 'thisown', 0)
        _swig_setattr(self, WindowEvMove,self.__class__,WindowEvMove)
_kahakai.WindowEvMove_swigregister(WindowEvMovePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMoveOpaque instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMoveOpaque, 'this', _kahakai.new_WindowEvMoveOpaque(*args))
        _swig_setattr(self, WindowEvMoveOpaque, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMoveOpaque___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMoveOpaque):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMoveOpaquePtr(WindowEvMoveOpaque):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMoveOpaque, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMoveOpaque, 'thisown', 0)
        _swig_setattr(self, WindowEvMoveOpaque,self.__class__,WindowEvMoveOpaque)
_kahakai.WindowEvMoveOpaque_swigregister(WindowEvMoveOpaquePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvRaiseFocus instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvRaiseFocus, 'this', _kahakai.new_WindowEvRaiseFocus(*args))
        _swig_setattr(self, WindowEvRaiseFocus, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvRaiseFocus___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvRaiseFocus):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvRaiseFocusPtr(WindowEvRaiseFocus):
    def __init__(self, this):
        _swig_setattr(self, WindowEvRaiseFocus, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvRaiseFocus, 'thisown', 0)
        _swig_setattr(self, WindowEvRaiseFocus,self.__class__,WindowEvRaiseFocus)
_kahakai.WindowEvRaiseFocus_swigregister(WindowEvRaiseFocusPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvShade instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvShade, 'this', _kahakai.new_WindowEvShade(*args))
        _swig_setattr(self, WindowEvShade, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvShade___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvShade):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvShadePtr(WindowEvShade):
    def __init__(self, this):
        _swig_setattr(self, WindowEvShade, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvShade, 'thisown', 0)
        _swig_setattr(self, WindowEvShade,self.__class__,WindowEvShade)
_kahakai.WindowEvShade_swigregister(WindowEvShadePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvUnShade instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvUnShade, 'this', _kahakai.new_WindowEvUnShade(*args))
        _swig_setattr(self, WindowEvUnShade, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvUnShade___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvUnShade):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvUnShadePtr(WindowEvUnShade):
    def __init__(self, this):
        _swig_setattr(self, WindowEvUnShade, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvUnShade, 'thisown', 0)
        _swig_setattr(self, WindowEvUnShade,self.__class__,WindowEvUnShade)
_kahakai.WindowEvUnShade_swigregister(WindowEvUnShadePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvToggleShade instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvToggleShade, 'this', _kahakai.new_WindowEvToggleShade(*args))
        _swig_setattr(self, WindowEvToggleShade, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvToggleShade___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvToggleShade):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvToggleShadePtr(WindowEvToggleShade):
    def __init__(self, this):
        _swig_setattr(self, WindowEvToggleShade, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvToggleShade, 'thisown', 0)
        _swig_setattr(self, WindowEvToggleShade,self.__class__,WindowEvToggleShade)
_kahakai.WindowEvToggleShade_swigregister(WindowEvToggleShadePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMenuMap instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMenuMap, 'this', _kahakai.new_WindowEvMenuMap(*args))
        _swig_setattr(self, WindowEvMenuMap, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMenuMap___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMenuMap):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMenuMapPtr(WindowEvMenuMap):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMenuMap, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMenuMap, 'thisown', 0)
        _swig_setattr(self, WindowEvMenuMap,self.__class__,WindowEvMenuMap)
_kahakai.WindowEvMenuMap_swigregister(WindowEvMenuMapPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMenuMapFocused instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMenuMapFocused, 'this', _kahakai.new_WindowEvMenuMapFocused(*args))
        _swig_setattr(self, WindowEvMenuMapFocused, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMenuMapFocused___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMenuMapFocused):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMenuMapFocusedPtr(WindowEvMenuMapFocused):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMenuMapFocused, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMenuMapFocused, 'thisown', 0)
        _swig_setattr(self, WindowEvMenuMapFocused,self.__class__,WindowEvMenuMapFocused)
_kahakai.WindowEvMenuMapFocused_swigregister(WindowEvMenuMapFocusedPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMenuRemap instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMenuRemap, 'this', _kahakai.new_WindowEvMenuRemap(*args))
        _swig_setattr(self, WindowEvMenuRemap, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMenuRemap___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMenuRemap):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMenuRemapPtr(WindowEvMenuRemap):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMenuRemap, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMenuRemap, 'thisown', 0)
        _swig_setattr(self, WindowEvMenuRemap,self.__class__,WindowEvMenuRemap)
_kahakai.WindowEvMenuRemap_swigregister(WindowEvMenuRemapPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMenuRemapFocused instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMenuRemapFocused, 'this', _kahakai.new_WindowEvMenuRemapFocused(*args))
        _swig_setattr(self, WindowEvMenuRemapFocused, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMenuRemapFocused___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMenuRemapFocused):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMenuRemapFocusedPtr(WindowEvMenuRemapFocused):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMenuRemapFocused, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMenuRemapFocused, 'thisown', 0)
        _swig_setattr(self, WindowEvMenuRemapFocused,self.__class__,WindowEvMenuRemapFocused)
_kahakai.WindowEvMenuRemapFocused_swigregister(WindowEvMenuRemapFocusedPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMenuUnmap instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMenuUnmap, 'this', _kahakai.new_WindowEvMenuUnmap(*args))
        _swig_setattr(self, WindowEvMenuUnmap, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMenuUnmap___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMenuUnmap):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMenuUnmapPtr(WindowEvMenuUnmap):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMenuUnmap, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMenuUnmap, 'thisown', 0)
        _swig_setattr(self, WindowEvMenuUnmap,self.__class__,WindowEvMenuUnmap)
_kahakai.WindowEvMenuUnmap_swigregister(WindowEvMenuUnmapPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMenuUnmapFocus instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMenuUnmapFocus, 'this', _kahakai.new_WindowEvMenuUnmapFocus(*args))
        _swig_setattr(self, WindowEvMenuUnmapFocus, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMenuUnmapFocus___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMenuUnmapFocus):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMenuUnmapFocusPtr(WindowEvMenuUnmapFocus):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMenuUnmapFocus, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMenuUnmapFocus, 'thisown', 0)
        _swig_setattr(self, WindowEvMenuUnmapFocus,self.__class__,WindowEvMenuUnmapFocus)
_kahakai.WindowEvMenuUnmapFocus_swigregister(WindowEvMenuUnmapFocusPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvResizeLeft instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvResizeLeft, 'this', _kahakai.new_WindowEvResizeLeft(*args))
        _swig_setattr(self, WindowEvResizeLeft, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvResizeLeft___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvResizeLeft):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvResizeLeftPtr(WindowEvResizeLeft):
    def __init__(self, this):
        _swig_setattr(self, WindowEvResizeLeft, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvResizeLeft, 'thisown', 0)
        _swig_setattr(self, WindowEvResizeLeft,self.__class__,WindowEvResizeLeft)
_kahakai.WindowEvResizeLeft_swigregister(WindowEvResizeLeftPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvResizeLeftOpaque instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvResizeLeftOpaque, 'this', _kahakai.new_WindowEvResizeLeftOpaque(*args))
        _swig_setattr(self, WindowEvResizeLeftOpaque, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvResizeLeftOpaque___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvResizeLeftOpaque):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvResizeLeftOpaquePtr(WindowEvResizeLeftOpaque):
    def __init__(self, this):
        _swig_setattr(self, WindowEvResizeLeftOpaque, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvResizeLeftOpaque, 'thisown', 0)
        _swig_setattr(self, WindowEvResizeLeftOpaque,self.__class__,WindowEvResizeLeftOpaque)
_kahakai.WindowEvResizeLeftOpaque_swigregister(WindowEvResizeLeftOpaquePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvResizeRight instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvResizeRight, 'this', _kahakai.new_WindowEvResizeRight(*args))
        _swig_setattr(self, WindowEvResizeRight, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvResizeRight___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvResizeRight):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvResizeRightPtr(WindowEvResizeRight):
    def __init__(self, this):
        _swig_setattr(self, WindowEvResizeRight, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvResizeRight, 'thisown', 0)
        _swig_setattr(self, WindowEvResizeRight,self.__class__,WindowEvResizeRight)
_kahakai.WindowEvResizeRight_swigregister(WindowEvResizeRightPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvResizeRightOpaque instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvResizeRightOpaque, 'this', _kahakai.new_WindowEvResizeRightOpaque(*args))
        _swig_setattr(self, WindowEvResizeRightOpaque, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvResizeRightOpaque___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvResizeRightOpaque):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvResizeRightOpaquePtr(WindowEvResizeRightOpaque):
    def __init__(self, this):
        _swig_setattr(self, WindowEvResizeRightOpaque, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvResizeRightOpaque, 'thisown', 0)
        _swig_setattr(self, WindowEvResizeRightOpaque,self.__class__,WindowEvResizeRightOpaque)
_kahakai.WindowEvResizeRightOpaque_swigregister(WindowEvResizeRightOpaquePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvResizeNorthWest instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvResizeNorthWest, 'this', _kahakai.new_WindowEvResizeNorthWest(*args))
        _swig_setattr(self, WindowEvResizeNorthWest, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvResizeNorthWest___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvResizeNorthWest):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvResizeNorthWestPtr(WindowEvResizeNorthWest):
    def __init__(self, this):
        _swig_setattr(self, WindowEvResizeNorthWest, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvResizeNorthWest, 'thisown', 0)
        _swig_setattr(self, WindowEvResizeNorthWest,self.__class__,WindowEvResizeNorthWest)
_kahakai.WindowEvResizeNorthWest_swigregister(WindowEvResizeNorthWestPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvResizeNorthEast instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvResizeNorthEast, 'this', _kahakai.new_WindowEvResizeNorthEast(*args))
        _swig_setattr(self, WindowEvResizeNorthEast, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvResizeNorthEast___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvResizeNorthEast):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvResizeNorthEastPtr(WindowEvResizeNorthEast):
    def __init__(self, this):
        _swig_setattr(self, WindowEvResizeNorthEast, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvResizeNorthEast, 'thisown', 0)
        _swig_setattr(self, WindowEvResizeNorthEast,self.__class__,WindowEvResizeNorthEast)
_kahakai.WindowEvResizeNorthEast_swigregister(WindowEvResizeNorthEastPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvResizeSouthWest instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvResizeSouthWest, 'this', _kahakai.new_WindowEvResizeSouthWest(*args))
        _swig_setattr(self, WindowEvResizeSouthWest, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvResizeSouthWest___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvResizeSouthWest):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvResizeSouthWestPtr(WindowEvResizeSouthWest):
    def __init__(self, this):
        _swig_setattr(self, WindowEvResizeSouthWest, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvResizeSouthWest, 'thisown', 0)
        _swig_setattr(self, WindowEvResizeSouthWest,self.__class__,WindowEvResizeSouthWest)
_kahakai.WindowEvResizeSouthWest_swigregister(WindowEvResizeSouthWestPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvResizeSouthEast instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvResizeSouthEast, 'this', _kahakai.new_WindowEvResizeSouthEast(*args))
        _swig_setattr(self, WindowEvResizeSouthEast, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvResizeSouthEast___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvResizeSouthEast):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvResizeSouthEastPtr(WindowEvResizeSouthEast):
    def __init__(self, this):
        _swig_setattr(self, WindowEvResizeSouthEast, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvResizeSouthEast, 'thisown', 0)
        _swig_setattr(self, WindowEvResizeSouthEast,self.__class__,WindowEvResizeSouthEast)
_kahakai.WindowEvResizeSouthEast_swigregister(WindowEvResizeSouthEastPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvSmartResize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvSmartResize, 'this', _kahakai.new_WindowEvSmartResize(*args))
        _swig_setattr(self, WindowEvSmartResize, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvSmartResize___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvSmartResize):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvSmartResizePtr(WindowEvSmartResize):
    def __init__(self, this):
        _swig_setattr(self, WindowEvSmartResize, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvSmartResize, 'thisown', 0)
        _swig_setattr(self, WindowEvSmartResize,self.__class__,WindowEvSmartResize)
_kahakai.WindowEvSmartResize_swigregister(WindowEvSmartResizePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvSmartResizeOpaque instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvSmartResizeOpaque, 'this', _kahakai.new_WindowEvSmartResizeOpaque(*args))
        _swig_setattr(self, WindowEvSmartResizeOpaque, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvSmartResizeOpaque___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvSmartResizeOpaque):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvSmartResizeOpaquePtr(WindowEvSmartResizeOpaque):
    def __init__(self, this):
        _swig_setattr(self, WindowEvSmartResizeOpaque, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvSmartResizeOpaque, 'thisown', 0)
        _swig_setattr(self, WindowEvSmartResizeOpaque,self.__class__,WindowEvSmartResizeOpaque)
_kahakai.WindowEvSmartResizeOpaque_swigregister(WindowEvSmartResizeOpaquePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvEndMoveResize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvEndMoveResize, 'this', _kahakai.new_WindowEvEndMoveResize(*args))
        _swig_setattr(self, WindowEvEndMoveResize, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvEndMoveResize___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvEndMoveResize):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvEndMoveResizePtr(WindowEvEndMoveResize):
    def __init__(self, this):
        _swig_setattr(self, WindowEvEndMoveResize, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvEndMoveResize, 'thisown', 0)
        _swig_setattr(self, WindowEvEndMoveResize,self.__class__,WindowEvEndMoveResize)
_kahakai.WindowEvEndMoveResize_swigregister(WindowEvEndMoveResizePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMaximize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMaximize, 'this', _kahakai.new_WindowEvMaximize(*args))
        _swig_setattr(self, WindowEvMaximize, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMaximize___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMaximize):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMaximizePtr(WindowEvMaximize):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMaximize, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMaximize, 'thisown', 0)
        _swig_setattr(self, WindowEvMaximize,self.__class__,WindowEvMaximize)
_kahakai.WindowEvMaximize_swigregister(WindowEvMaximizePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMaximizeHorizontally instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMaximizeHorizontally, 'this', _kahakai.new_WindowEvMaximizeHorizontally(*args))
        _swig_setattr(self, WindowEvMaximizeHorizontally, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMaximizeHorizontally___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMaximizeHorizontally):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMaximizeHorizontallyPtr(WindowEvMaximizeHorizontally):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMaximizeHorizontally, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMaximizeHorizontally, 'thisown', 0)
        _swig_setattr(self, WindowEvMaximizeHorizontally,self.__class__,WindowEvMaximizeHorizontally)
_kahakai.WindowEvMaximizeHorizontally_swigregister(WindowEvMaximizeHorizontallyPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMaximizeVertically instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMaximizeVertically, 'this', _kahakai.new_WindowEvMaximizeVertically(*args))
        _swig_setattr(self, WindowEvMaximizeVertically, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMaximizeVertically___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMaximizeVertically):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMaximizeVerticallyPtr(WindowEvMaximizeVertically):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMaximizeVertically, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMaximizeVertically, 'thisown', 0)
        _swig_setattr(self, WindowEvMaximizeVertically,self.__class__,WindowEvMaximizeVertically)
_kahakai.WindowEvMaximizeVertically_swigregister(WindowEvMaximizeVerticallyPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvUnMaximize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvUnMaximize, 'this', _kahakai.new_WindowEvUnMaximize(*args))
        _swig_setattr(self, WindowEvUnMaximize, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvUnMaximize___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvUnMaximize):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvUnMaximizePtr(WindowEvUnMaximize):
    def __init__(self, this):
        _swig_setattr(self, WindowEvUnMaximize, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvUnMaximize, 'thisown', 0)
        _swig_setattr(self, WindowEvUnMaximize,self.__class__,WindowEvUnMaximize)
_kahakai.WindowEvUnMaximize_swigregister(WindowEvUnMaximizePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvToggleMaximize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvToggleMaximize, 'this', _kahakai.new_WindowEvToggleMaximize(*args))
        _swig_setattr(self, WindowEvToggleMaximize, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvToggleMaximize___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvToggleMaximize):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvToggleMaximizePtr(WindowEvToggleMaximize):
    def __init__(self, this):
        _swig_setattr(self, WindowEvToggleMaximize, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvToggleMaximize, 'thisown', 0)
        _swig_setattr(self, WindowEvToggleMaximize,self.__class__,WindowEvToggleMaximize)
_kahakai.WindowEvToggleMaximize_swigregister(WindowEvToggleMaximizePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvToggleMaximizeVertically instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvToggleMaximizeVertically, 'this', _kahakai.new_WindowEvToggleMaximizeVertically(*args))
        _swig_setattr(self, WindowEvToggleMaximizeVertically, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvToggleMaximizeVertically___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvToggleMaximizeVertically):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvToggleMaximizeVerticallyPtr(WindowEvToggleMaximizeVertically):
    def __init__(self, this):
        _swig_setattr(self, WindowEvToggleMaximizeVertically, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvToggleMaximizeVertically, 'thisown', 0)
        _swig_setattr(self, WindowEvToggleMaximizeVertically,self.__class__,WindowEvToggleMaximizeVertically)
_kahakai.WindowEvToggleMaximizeVertically_swigregister(WindowEvToggleMaximizeVerticallyPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvToggleMaximizeHorizontally instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvToggleMaximizeHorizontally, 'this', _kahakai.new_WindowEvToggleMaximizeHorizontally(*args))
        _swig_setattr(self, WindowEvToggleMaximizeHorizontally, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvToggleMaximizeHorizontally___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvToggleMaximizeHorizontally):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvToggleMaximizeHorizontallyPtr(WindowEvToggleMaximizeHorizontally):
    def __init__(self, this):
        _swig_setattr(self, WindowEvToggleMaximizeHorizontally, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvToggleMaximizeHorizontally, 'thisown', 0)
        _swig_setattr(self, WindowEvToggleMaximizeHorizontally,self.__class__,WindowEvToggleMaximizeHorizontally)
_kahakai.WindowEvToggleMaximizeHorizontally_swigregister(WindowEvToggleMaximizeHorizontallyPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvKill instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvKill, 'this', _kahakai.new_WindowEvKill(*args))
        _swig_setattr(self, WindowEvKill, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvKill___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvKill):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvKillPtr(WindowEvKill):
    def __init__(self, this):
        _swig_setattr(self, WindowEvKill, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvKill, 'thisown', 0)
        _swig_setattr(self, WindowEvKill,self.__class__,WindowEvKill)
_kahakai.WindowEvKill_swigregister(WindowEvKillPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvCloseKill instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvCloseKill, 'this', _kahakai.new_WindowEvCloseKill(*args))
        _swig_setattr(self, WindowEvCloseKill, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvCloseKill___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvCloseKill):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvCloseKillPtr(WindowEvCloseKill):
    def __init__(self, this):
        _swig_setattr(self, WindowEvCloseKill, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvCloseKill, 'thisown', 0)
        _swig_setattr(self, WindowEvCloseKill,self.__class__,WindowEvCloseKill)
_kahakai.WindowEvCloseKill_swigregister(WindowEvCloseKillPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvSticky instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvSticky, 'this', _kahakai.new_WindowEvSticky(*args))
        _swig_setattr(self, WindowEvSticky, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvSticky___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvSticky):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvStickyPtr(WindowEvSticky):
    def __init__(self, this):
        _swig_setattr(self, WindowEvSticky, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvSticky, 'thisown', 0)
        _swig_setattr(self, WindowEvSticky,self.__class__,WindowEvSticky)
_kahakai.WindowEvSticky_swigregister(WindowEvStickyPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvUnSticky instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvUnSticky, 'this', _kahakai.new_WindowEvUnSticky(*args))
        _swig_setattr(self, WindowEvUnSticky, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvUnSticky___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvUnSticky):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvUnStickyPtr(WindowEvUnSticky):
    def __init__(self, this):
        _swig_setattr(self, WindowEvUnSticky, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvUnSticky, 'thisown', 0)
        _swig_setattr(self, WindowEvUnSticky,self.__class__,WindowEvUnSticky)
_kahakai.WindowEvUnSticky_swigregister(WindowEvUnStickyPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvToggleSticky instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvToggleSticky, 'this', _kahakai.new_WindowEvToggleSticky(*args))
        _swig_setattr(self, WindowEvToggleSticky, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvToggleSticky___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvToggleSticky):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvToggleStickyPtr(WindowEvToggleSticky):
    def __init__(self, this):
        _swig_setattr(self, WindowEvToggleSticky, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvToggleSticky, 'thisown', 0)
        _swig_setattr(self, WindowEvToggleSticky,self.__class__,WindowEvToggleSticky)
_kahakai.WindowEvToggleSticky_swigregister(WindowEvToggleStickyPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvMinimize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvMinimize, 'this', _kahakai.new_WindowEvMinimize(*args))
        _swig_setattr(self, WindowEvMinimize, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvMinimize___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvMinimize):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvMinimizePtr(WindowEvMinimize):
    def __init__(self, this):
        _swig_setattr(self, WindowEvMinimize, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvMinimize, 'thisown', 0)
        _swig_setattr(self, WindowEvMinimize,self.__class__,WindowEvMinimize)
_kahakai.WindowEvMinimize_swigregister(WindowEvMinimizePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvUnMinimize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvUnMinimize, 'this', _kahakai.new_WindowEvUnMinimize(*args))
        _swig_setattr(self, WindowEvUnMinimize, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvUnMinimize___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvUnMinimize):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvUnMinimizePtr(WindowEvUnMinimize):
    def __init__(self, this):
        _swig_setattr(self, WindowEvUnMinimize, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvUnMinimize, 'thisown', 0)
        _swig_setattr(self, WindowEvUnMinimize,self.__class__,WindowEvUnMinimize)
_kahakai.WindowEvUnMinimize_swigregister(WindowEvUnMinimizePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvToggleMinimize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvToggleMinimize, 'this', _kahakai.new_WindowEvToggleMinimize(*args))
        _swig_setattr(self, WindowEvToggleMinimize, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvToggleMinimize___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvToggleMinimize):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvToggleMinimizePtr(WindowEvToggleMinimize):
    def __init__(self, this):
        _swig_setattr(self, WindowEvToggleMinimize, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvToggleMinimize, 'thisown', 0)
        _swig_setattr(self, WindowEvToggleMinimize,self.__class__,WindowEvToggleMinimize)
_kahakai.WindowEvToggleMinimize_swigregister(WindowEvToggleMinimizePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvToggleMinimizeActive instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvToggleMinimizeActive, 'this', _kahakai.new_WindowEvToggleMinimizeActive(*args))
        _swig_setattr(self, WindowEvToggleMinimizeActive, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvToggleMinimizeActive___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvToggleMinimizeActive):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvToggleMinimizeActivePtr(WindowEvToggleMinimizeActive):
    def __init__(self, this):
        _swig_setattr(self, WindowEvToggleMinimizeActive, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvToggleMinimizeActive, 'thisown', 0)
        _swig_setattr(self, WindowEvToggleMinimizeActive,self.__class__,WindowEvToggleMinimizeActive)
_kahakai.WindowEvToggleMinimizeActive_swigregister(WindowEvToggleMinimizeActivePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvFullscreenOn instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvFullscreenOn, 'this', _kahakai.new_WindowEvFullscreenOn(*args))
        _swig_setattr(self, WindowEvFullscreenOn, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvFullscreenOn___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvFullscreenOn):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvFullscreenOnPtr(WindowEvFullscreenOn):
    def __init__(self, this):
        _swig_setattr(self, WindowEvFullscreenOn, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvFullscreenOn, 'thisown', 0)
        _swig_setattr(self, WindowEvFullscreenOn,self.__class__,WindowEvFullscreenOn)
_kahakai.WindowEvFullscreenOn_swigregister(WindowEvFullscreenOnPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvFullscreenOff instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvFullscreenOff, 'this', _kahakai.new_WindowEvFullscreenOff(*args))
        _swig_setattr(self, WindowEvFullscreenOff, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvFullscreenOff___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvFullscreenOff):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvFullscreenOffPtr(WindowEvFullscreenOff):
    def __init__(self, this):
        _swig_setattr(self, WindowEvFullscreenOff, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvFullscreenOff, 'thisown', 0)
        _swig_setattr(self, WindowEvFullscreenOff,self.__class__,WindowEvFullscreenOff)
_kahakai.WindowEvFullscreenOff_swigregister(WindowEvFullscreenOffPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvFullscreenToggle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvFullscreenToggle, 'this', _kahakai.new_WindowEvFullscreenToggle(*args))
        _swig_setattr(self, WindowEvFullscreenToggle, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvFullscreenToggle___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvFullscreenToggle):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvFullscreenTogglePtr(WindowEvFullscreenToggle):
    def __init__(self, this):
        _swig_setattr(self, WindowEvFullscreenToggle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvFullscreenToggle, 'thisown', 0)
        _swig_setattr(self, WindowEvFullscreenToggle,self.__class__,WindowEvFullscreenToggle)
_kahakai.WindowEvFullscreenToggle_swigregister(WindowEvFullscreenTogglePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvDecorTitleOn instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvDecorTitleOn, 'this', _kahakai.new_WindowEvDecorTitleOn(*args))
        _swig_setattr(self, WindowEvDecorTitleOn, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvDecorTitleOn___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvDecorTitleOn):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvDecorTitleOnPtr(WindowEvDecorTitleOn):
    def __init__(self, this):
        _swig_setattr(self, WindowEvDecorTitleOn, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvDecorTitleOn, 'thisown', 0)
        _swig_setattr(self, WindowEvDecorTitleOn,self.__class__,WindowEvDecorTitleOn)
_kahakai.WindowEvDecorTitleOn_swigregister(WindowEvDecorTitleOnPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvDecorHandleOn instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvDecorHandleOn, 'this', _kahakai.new_WindowEvDecorHandleOn(*args))
        _swig_setattr(self, WindowEvDecorHandleOn, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvDecorHandleOn___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvDecorHandleOn):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvDecorHandleOnPtr(WindowEvDecorHandleOn):
    def __init__(self, this):
        _swig_setattr(self, WindowEvDecorHandleOn, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvDecorHandleOn, 'thisown', 0)
        _swig_setattr(self, WindowEvDecorHandleOn,self.__class__,WindowEvDecorHandleOn)
_kahakai.WindowEvDecorHandleOn_swigregister(WindowEvDecorHandleOnPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvDecorBorderOn instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvDecorBorderOn, 'this', _kahakai.new_WindowEvDecorBorderOn(*args))
        _swig_setattr(self, WindowEvDecorBorderOn, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvDecorBorderOn___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvDecorBorderOn):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvDecorBorderOnPtr(WindowEvDecorBorderOn):
    def __init__(self, this):
        _swig_setattr(self, WindowEvDecorBorderOn, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvDecorBorderOn, 'thisown', 0)
        _swig_setattr(self, WindowEvDecorBorderOn,self.__class__,WindowEvDecorBorderOn)
_kahakai.WindowEvDecorBorderOn_swigregister(WindowEvDecorBorderOnPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvDecorAllOn instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvDecorAllOn, 'this', _kahakai.new_WindowEvDecorAllOn(*args))
        _swig_setattr(self, WindowEvDecorAllOn, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvDecorAllOn___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvDecorAllOn):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvDecorAllOnPtr(WindowEvDecorAllOn):
    def __init__(self, this):
        _swig_setattr(self, WindowEvDecorAllOn, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvDecorAllOn, 'thisown', 0)
        _swig_setattr(self, WindowEvDecorAllOn,self.__class__,WindowEvDecorAllOn)
_kahakai.WindowEvDecorAllOn_swigregister(WindowEvDecorAllOnPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvDecorTitleOff instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvDecorTitleOff, 'this', _kahakai.new_WindowEvDecorTitleOff(*args))
        _swig_setattr(self, WindowEvDecorTitleOff, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvDecorTitleOff___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvDecorTitleOff):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvDecorTitleOffPtr(WindowEvDecorTitleOff):
    def __init__(self, this):
        _swig_setattr(self, WindowEvDecorTitleOff, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvDecorTitleOff, 'thisown', 0)
        _swig_setattr(self, WindowEvDecorTitleOff,self.__class__,WindowEvDecorTitleOff)
_kahakai.WindowEvDecorTitleOff_swigregister(WindowEvDecorTitleOffPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvDecorHandleOff instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvDecorHandleOff, 'this', _kahakai.new_WindowEvDecorHandleOff(*args))
        _swig_setattr(self, WindowEvDecorHandleOff, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvDecorHandleOff___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvDecorHandleOff):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvDecorHandleOffPtr(WindowEvDecorHandleOff):
    def __init__(self, this):
        _swig_setattr(self, WindowEvDecorHandleOff, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvDecorHandleOff, 'thisown', 0)
        _swig_setattr(self, WindowEvDecorHandleOff,self.__class__,WindowEvDecorHandleOff)
_kahakai.WindowEvDecorHandleOff_swigregister(WindowEvDecorHandleOffPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvDecorBorderOff instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvDecorBorderOff, 'this', _kahakai.new_WindowEvDecorBorderOff(*args))
        _swig_setattr(self, WindowEvDecorBorderOff, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvDecorBorderOff___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvDecorBorderOff):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvDecorBorderOffPtr(WindowEvDecorBorderOff):
    def __init__(self, this):
        _swig_setattr(self, WindowEvDecorBorderOff, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvDecorBorderOff, 'thisown', 0)
        _swig_setattr(self, WindowEvDecorBorderOff,self.__class__,WindowEvDecorBorderOff)
_kahakai.WindowEvDecorBorderOff_swigregister(WindowEvDecorBorderOffPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvDecorAllOff instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvDecorAllOff, 'this', _kahakai.new_WindowEvDecorAllOff(*args))
        _swig_setattr(self, WindowEvDecorAllOff, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvDecorAllOff___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvDecorAllOff):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvDecorAllOffPtr(WindowEvDecorAllOff):
    def __init__(self, this):
        _swig_setattr(self, WindowEvDecorAllOff, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvDecorAllOff, 'thisown', 0)
        _swig_setattr(self, WindowEvDecorAllOff,self.__class__,WindowEvDecorAllOff)
_kahakai.WindowEvDecorAllOff_swigregister(WindowEvDecorAllOffPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvDecorTitleToggle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvDecorTitleToggle, 'this', _kahakai.new_WindowEvDecorTitleToggle(*args))
        _swig_setattr(self, WindowEvDecorTitleToggle, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvDecorTitleToggle___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvDecorTitleToggle):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvDecorTitleTogglePtr(WindowEvDecorTitleToggle):
    def __init__(self, this):
        _swig_setattr(self, WindowEvDecorTitleToggle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvDecorTitleToggle, 'thisown', 0)
        _swig_setattr(self, WindowEvDecorTitleToggle,self.__class__,WindowEvDecorTitleToggle)
_kahakai.WindowEvDecorTitleToggle_swigregister(WindowEvDecorTitleTogglePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvDecorHandleToggle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvDecorHandleToggle, 'this', _kahakai.new_WindowEvDecorHandleToggle(*args))
        _swig_setattr(self, WindowEvDecorHandleToggle, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvDecorHandleToggle___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvDecorHandleToggle):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvDecorHandleTogglePtr(WindowEvDecorHandleToggle):
    def __init__(self, this):
        _swig_setattr(self, WindowEvDecorHandleToggle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvDecorHandleToggle, 'thisown', 0)
        _swig_setattr(self, WindowEvDecorHandleToggle,self.__class__,WindowEvDecorHandleToggle)
_kahakai.WindowEvDecorHandleToggle_swigregister(WindowEvDecorHandleTogglePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvDecorBorderToggle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvDecorBorderToggle, 'this', _kahakai.new_WindowEvDecorBorderToggle(*args))
        _swig_setattr(self, WindowEvDecorBorderToggle, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvDecorBorderToggle___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvDecorBorderToggle):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvDecorBorderTogglePtr(WindowEvDecorBorderToggle):
    def __init__(self, this):
        _swig_setattr(self, WindowEvDecorBorderToggle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvDecorBorderToggle, 'thisown', 0)
        _swig_setattr(self, WindowEvDecorBorderToggle,self.__class__,WindowEvDecorBorderToggle)
_kahakai.WindowEvDecorBorderToggle_swigregister(WindowEvDecorBorderTogglePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvDecorAllToggle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvDecorAllToggle, 'this', _kahakai.new_WindowEvDecorAllToggle(*args))
        _swig_setattr(self, WindowEvDecorAllToggle, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvDecorAllToggle___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvDecorAllToggle):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvDecorAllTogglePtr(WindowEvDecorAllToggle):
    def __init__(self, this):
        _swig_setattr(self, WindowEvDecorAllToggle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvDecorAllToggle, 'thisown', 0)
        _swig_setattr(self, WindowEvDecorAllToggle,self.__class__,WindowEvDecorAllToggle)
_kahakai.WindowEvDecorAllToggle_swigregister(WindowEvDecorAllTogglePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvAlwaysontopOn instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvAlwaysontopOn, 'this', _kahakai.new_WindowEvAlwaysontopOn(*args))
        _swig_setattr(self, WindowEvAlwaysontopOn, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvAlwaysontopOn___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvAlwaysontopOn):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvAlwaysontopOnPtr(WindowEvAlwaysontopOn):
    def __init__(self, this):
        _swig_setattr(self, WindowEvAlwaysontopOn, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvAlwaysontopOn, 'thisown', 0)
        _swig_setattr(self, WindowEvAlwaysontopOn,self.__class__,WindowEvAlwaysontopOn)
_kahakai.WindowEvAlwaysontopOn_swigregister(WindowEvAlwaysontopOnPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvAlwaysontopOff instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvAlwaysontopOff, 'this', _kahakai.new_WindowEvAlwaysontopOff(*args))
        _swig_setattr(self, WindowEvAlwaysontopOff, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvAlwaysontopOff___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvAlwaysontopOff):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvAlwaysontopOffPtr(WindowEvAlwaysontopOff):
    def __init__(self, this):
        _swig_setattr(self, WindowEvAlwaysontopOff, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvAlwaysontopOff, 'thisown', 0)
        _swig_setattr(self, WindowEvAlwaysontopOff,self.__class__,WindowEvAlwaysontopOff)
_kahakai.WindowEvAlwaysontopOff_swigregister(WindowEvAlwaysontopOffPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvAlwaysontopToggle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvAlwaysontopToggle, 'this', _kahakai.new_WindowEvAlwaysontopToggle(*args))
        _swig_setattr(self, WindowEvAlwaysontopToggle, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvAlwaysontopToggle___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvAlwaysontopToggle):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvAlwaysontopTogglePtr(WindowEvAlwaysontopToggle):
    def __init__(self, this):
        _swig_setattr(self, WindowEvAlwaysontopToggle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvAlwaysontopToggle, 'thisown', 0)
        _swig_setattr(self, WindowEvAlwaysontopToggle,self.__class__,WindowEvAlwaysontopToggle)
_kahakai.WindowEvAlwaysontopToggle_swigregister(WindowEvAlwaysontopTogglePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvAlwaysatbottomOn instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvAlwaysatbottomOn, 'this', _kahakai.new_WindowEvAlwaysatbottomOn(*args))
        _swig_setattr(self, WindowEvAlwaysatbottomOn, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvAlwaysatbottomOn___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvAlwaysatbottomOn):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvAlwaysatbottomOnPtr(WindowEvAlwaysatbottomOn):
    def __init__(self, this):
        _swig_setattr(self, WindowEvAlwaysatbottomOn, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvAlwaysatbottomOn, 'thisown', 0)
        _swig_setattr(self, WindowEvAlwaysatbottomOn,self.__class__,WindowEvAlwaysatbottomOn)
_kahakai.WindowEvAlwaysatbottomOn_swigregister(WindowEvAlwaysatbottomOnPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvAlwaysatbottomOff instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvAlwaysatbottomOff, 'this', _kahakai.new_WindowEvAlwaysatbottomOff(*args))
        _swig_setattr(self, WindowEvAlwaysatbottomOff, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvAlwaysatbottomOff___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvAlwaysatbottomOff):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvAlwaysatbottomOffPtr(WindowEvAlwaysatbottomOff):
    def __init__(self, this):
        _swig_setattr(self, WindowEvAlwaysatbottomOff, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvAlwaysatbottomOff, 'thisown', 0)
        _swig_setattr(self, WindowEvAlwaysatbottomOff,self.__class__,WindowEvAlwaysatbottomOff)
_kahakai.WindowEvAlwaysatbottomOff_swigregister(WindowEvAlwaysatbottomOffPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvAlwaysatbottomToggle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvAlwaysatbottomToggle, 'this', _kahakai.new_WindowEvAlwaysatbottomToggle(*args))
        _swig_setattr(self, WindowEvAlwaysatbottomToggle, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvAlwaysatbottomToggle___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvAlwaysatbottomToggle):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvAlwaysatbottomTogglePtr(WindowEvAlwaysatbottomToggle):
    def __init__(self, this):
        _swig_setattr(self, WindowEvAlwaysatbottomToggle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvAlwaysatbottomToggle, 'thisown', 0)
        _swig_setattr(self, WindowEvAlwaysatbottomToggle,self.__class__,WindowEvAlwaysatbottomToggle)
_kahakai.WindowEvAlwaysatbottomToggle_swigregister(WindowEvAlwaysatbottomTogglePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvAcceptConfigRequestOn instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvAcceptConfigRequestOn, 'this', _kahakai.new_WindowEvAcceptConfigRequestOn(*args))
        _swig_setattr(self, WindowEvAcceptConfigRequestOn, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvAcceptConfigRequestOn___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvAcceptConfigRequestOn):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvAcceptConfigRequestOnPtr(WindowEvAcceptConfigRequestOn):
    def __init__(self, this):
        _swig_setattr(self, WindowEvAcceptConfigRequestOn, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvAcceptConfigRequestOn, 'thisown', 0)
        _swig_setattr(self, WindowEvAcceptConfigRequestOn,self.__class__,WindowEvAcceptConfigRequestOn)
_kahakai.WindowEvAcceptConfigRequestOn_swigregister(WindowEvAcceptConfigRequestOnPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvAcceptConfigRequestOff instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvAcceptConfigRequestOff, 'this', _kahakai.new_WindowEvAcceptConfigRequestOff(*args))
        _swig_setattr(self, WindowEvAcceptConfigRequestOff, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvAcceptConfigRequestOff___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvAcceptConfigRequestOff):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvAcceptConfigRequestOffPtr(WindowEvAcceptConfigRequestOff):
    def __init__(self, this):
        _swig_setattr(self, WindowEvAcceptConfigRequestOff, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvAcceptConfigRequestOff, 'thisown', 0)
        _swig_setattr(self, WindowEvAcceptConfigRequestOff,self.__class__,WindowEvAcceptConfigRequestOff)
_kahakai.WindowEvAcceptConfigRequestOff_swigregister(WindowEvAcceptConfigRequestOffPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowEvAcceptConfigRequestToggle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WindowEvAcceptConfigRequestToggle, 'this', _kahakai.new_WindowEvAcceptConfigRequestToggle(*args))
        _swig_setattr(self, WindowEvAcceptConfigRequestToggle, 'thisown', 1)
    def __call__(*args): return _kahakai.WindowEvAcceptConfigRequestToggle___call__(*args)
    def __del__(self, destroy=_kahakai.delete_WindowEvAcceptConfigRequestToggle):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowEvAcceptConfigRequestTogglePtr(WindowEvAcceptConfigRequestToggle):
    def __init__(self, this):
        _swig_setattr(self, WindowEvAcceptConfigRequestToggle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowEvAcceptConfigRequestToggle, 'thisown', 0)
        _swig_setattr(self, WindowEvAcceptConfigRequestToggle,self.__class__,WindowEvAcceptConfigRequestToggle)
_kahakai.WindowEvAcceptConfigRequestToggle_swigregister(WindowEvAcceptConfigRequestTogglePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowAttributes instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, WindowAttributes, 'this', _kahakai.new_WindowAttributes(*args))
        _swig_setattr(self, WindowAttributes, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_WindowAttributes):
        try:
            if self.thisown: destroy(self)
        except: pass

    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)

class WindowAttributesPtr(WindowAttributes):
    def __init__(self, this):
        _swig_setattr(self, WindowAttributes, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowAttributes, 'thisown', 0)
        _swig_setattr(self, WindowAttributes,self.__class__,WindowAttributes)
_kahakai.WindowAttributes_swigregister(WindowAttributesPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Workarea instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, Workarea, 'this', _kahakai.new_Workarea(*args))
        _swig_setattr(self, Workarea, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_Workarea):
        try:
            if self.thisown: destroy(self)
        except: pass


class WorkareaPtr(Workarea):
    def __init__(self, this):
        _swig_setattr(self, Workarea, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Workarea, 'thisown', 0)
        _swig_setattr(self, Workarea,self.__class__,Workarea)
_kahakai.Workarea_swigregister(WorkareaPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Desktop instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Desktop, 'this', _kahakai.new_Desktop(*args))
        _swig_setattr(self, Desktop, 'thisown', 1)
    __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)
    def __del__(self, destroy=_kahakai.delete_Desktop):
        try:
            if self.thisown: destroy(self)
        except: pass


class DesktopPtr(Desktop):
    def __init__(self, this):
        _swig_setattr(self, Desktop, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Desktop, 'thisown', 0)
        _swig_setattr(self, Desktop,self.__class__,Desktop)
_kahakai.Desktop_swigregister(DesktopPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenConfig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, ScreenConfig, 'this', _kahakai.new_ScreenConfig(*args))
        _swig_setattr(self, ScreenConfig, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_ScreenConfig):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenConfigPtr(ScreenConfig):
    def __init__(self, this):
        _swig_setattr(self, ScreenConfig, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenConfig, 'thisown', 0)
        _swig_setattr(self, ScreenConfig,self.__class__,ScreenConfig)
_kahakai.ScreenConfig_swigregister(ScreenConfigPtr)
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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ KaScreen instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, KaScreen, 'this', _kahakai.new_KaScreen(*args))
        _swig_setattr(self, KaScreen, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_KaScreen):
        try:
            if self.thisown: destroy(self)
        except: pass

    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)

class KaScreenPtr(KaScreen):
    def __init__(self, this):
        _swig_setattr(self, KaScreen, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, KaScreen, 'thisown', 0)
        _swig_setattr(self, KaScreen,self.__class__,KaScreen)
_kahakai.KaScreen_swigregister(KaScreenPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEdgeManager instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEdgeManager, 'this', _kahakai.new_ScreenEdgeManager(*args))
        _swig_setattr(self, ScreenEdgeManager, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_ScreenEdgeManager):
        try:
            if self.thisown: destroy(self)
        except: pass

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

class ScreenEdgeManagerPtr(ScreenEdgeManager):
    def __init__(self, this):
        _swig_setattr(self, ScreenEdgeManager, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEdgeManager, 'thisown', 0)
        _swig_setattr(self, ScreenEdgeManager,self.__class__,ScreenEdgeManager)
_kahakai.ScreenEdgeManager_swigregister(ScreenEdgeManagerPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvGoToDesktop instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvGoToDesktop, 'this', _kahakai.new_ScreenEvGoToDesktop(*args))
        _swig_setattr(self, ScreenEvGoToDesktop, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvGoToDesktop___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvGoToDesktop):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvGoToDesktopPtr(ScreenEvGoToDesktop):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvGoToDesktop, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvGoToDesktop, 'thisown', 0)
        _swig_setattr(self, ScreenEvGoToDesktop,self.__class__,ScreenEvGoToDesktop)
_kahakai.ScreenEvGoToDesktop_swigregister(ScreenEvGoToDesktopPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvViewportFixedMove instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvViewportFixedMove, 'this', _kahakai.new_ScreenEvViewportFixedMove(*args))
        _swig_setattr(self, ScreenEvViewportFixedMove, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvViewportFixedMove___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvViewportFixedMove):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvViewportFixedMovePtr(ScreenEvViewportFixedMove):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvViewportFixedMove, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvViewportFixedMove, 'thisown', 0)
        _swig_setattr(self, ScreenEvViewportFixedMove,self.__class__,ScreenEvViewportFixedMove)
_kahakai.ScreenEvViewportFixedMove_swigregister(ScreenEvViewportFixedMovePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvMoveViewportLeft instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvMoveViewportLeft, 'this', _kahakai.new_ScreenEvMoveViewportLeft(*args))
        _swig_setattr(self, ScreenEvMoveViewportLeft, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvMoveViewportLeft___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvMoveViewportLeft):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvMoveViewportLeftPtr(ScreenEvMoveViewportLeft):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvMoveViewportLeft, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvMoveViewportLeft, 'thisown', 0)
        _swig_setattr(self, ScreenEvMoveViewportLeft,self.__class__,ScreenEvMoveViewportLeft)
_kahakai.ScreenEvMoveViewportLeft_swigregister(ScreenEvMoveViewportLeftPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvMoveViewportRight instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvMoveViewportRight, 'this', _kahakai.new_ScreenEvMoveViewportRight(*args))
        _swig_setattr(self, ScreenEvMoveViewportRight, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvMoveViewportRight___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvMoveViewportRight):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvMoveViewportRightPtr(ScreenEvMoveViewportRight):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvMoveViewportRight, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvMoveViewportRight, 'thisown', 0)
        _swig_setattr(self, ScreenEvMoveViewportRight,self.__class__,ScreenEvMoveViewportRight)
_kahakai.ScreenEvMoveViewportRight_swigregister(ScreenEvMoveViewportRightPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvMoveViewportUp instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvMoveViewportUp, 'this', _kahakai.new_ScreenEvMoveViewportUp(*args))
        _swig_setattr(self, ScreenEvMoveViewportUp, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvMoveViewportUp___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvMoveViewportUp):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvMoveViewportUpPtr(ScreenEvMoveViewportUp):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvMoveViewportUp, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvMoveViewportUp, 'thisown', 0)
        _swig_setattr(self, ScreenEvMoveViewportUp,self.__class__,ScreenEvMoveViewportUp)
_kahakai.ScreenEvMoveViewportUp_swigregister(ScreenEvMoveViewportUpPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvMoveViewportDown instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvMoveViewportDown, 'this', _kahakai.new_ScreenEvMoveViewportDown(*args))
        _swig_setattr(self, ScreenEvMoveViewportDown, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvMoveViewportDown___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvMoveViewportDown):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvMoveViewportDownPtr(ScreenEvMoveViewportDown):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvMoveViewportDown, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvMoveViewportDown, 'thisown', 0)
        _swig_setattr(self, ScreenEvMoveViewportDown,self.__class__,ScreenEvMoveViewportDown)
_kahakai.ScreenEvMoveViewportDown_swigregister(ScreenEvMoveViewportDownPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvMoveViewportWrapLeft instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvMoveViewportWrapLeft, 'this', _kahakai.new_ScreenEvMoveViewportWrapLeft(*args))
        _swig_setattr(self, ScreenEvMoveViewportWrapLeft, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvMoveViewportWrapLeft___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvMoveViewportWrapLeft):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvMoveViewportWrapLeftPtr(ScreenEvMoveViewportWrapLeft):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvMoveViewportWrapLeft, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvMoveViewportWrapLeft, 'thisown', 0)
        _swig_setattr(self, ScreenEvMoveViewportWrapLeft,self.__class__,ScreenEvMoveViewportWrapLeft)
_kahakai.ScreenEvMoveViewportWrapLeft_swigregister(ScreenEvMoveViewportWrapLeftPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvMoveViewportWrapRight instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvMoveViewportWrapRight, 'this', _kahakai.new_ScreenEvMoveViewportWrapRight(*args))
        _swig_setattr(self, ScreenEvMoveViewportWrapRight, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvMoveViewportWrapRight___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvMoveViewportWrapRight):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvMoveViewportWrapRightPtr(ScreenEvMoveViewportWrapRight):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvMoveViewportWrapRight, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvMoveViewportWrapRight, 'thisown', 0)
        _swig_setattr(self, ScreenEvMoveViewportWrapRight,self.__class__,ScreenEvMoveViewportWrapRight)
_kahakai.ScreenEvMoveViewportWrapRight_swigregister(ScreenEvMoveViewportWrapRightPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvMoveViewportWrapUp instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvMoveViewportWrapUp, 'this', _kahakai.new_ScreenEvMoveViewportWrapUp(*args))
        _swig_setattr(self, ScreenEvMoveViewportWrapUp, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvMoveViewportWrapUp___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvMoveViewportWrapUp):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvMoveViewportWrapUpPtr(ScreenEvMoveViewportWrapUp):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvMoveViewportWrapUp, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvMoveViewportWrapUp, 'thisown', 0)
        _swig_setattr(self, ScreenEvMoveViewportWrapUp,self.__class__,ScreenEvMoveViewportWrapUp)
_kahakai.ScreenEvMoveViewportWrapUp_swigregister(ScreenEvMoveViewportWrapUpPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvMoveViewportWrapDown instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvMoveViewportWrapDown, 'this', _kahakai.new_ScreenEvMoveViewportWrapDown(*args))
        _swig_setattr(self, ScreenEvMoveViewportWrapDown, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvMoveViewportWrapDown___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvMoveViewportWrapDown):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvMoveViewportWrapDownPtr(ScreenEvMoveViewportWrapDown):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvMoveViewportWrapDown, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvMoveViewportWrapDown, 'thisown', 0)
        _swig_setattr(self, ScreenEvMoveViewportWrapDown,self.__class__,ScreenEvMoveViewportWrapDown)
_kahakai.ScreenEvMoveViewportWrapDown_swigregister(ScreenEvMoveViewportWrapDownPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvReloadMenu instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvReloadMenu, 'this', _kahakai.new_ScreenEvReloadMenu(*args))
        _swig_setattr(self, ScreenEvReloadMenu, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvReloadMenu___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvReloadMenu):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvReloadMenuPtr(ScreenEvReloadMenu):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvReloadMenu, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvReloadMenu, 'thisown', 0)
        _swig_setattr(self, ScreenEvReloadMenu,self.__class__,ScreenEvReloadMenu)
_kahakai.ScreenEvReloadMenu_swigregister(ScreenEvReloadMenuPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvMenuMap instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvMenuMap, 'this', _kahakai.new_ScreenEvMenuMap(*args))
        _swig_setattr(self, ScreenEvMenuMap, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvMenuMap___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvMenuMap):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvMenuMapPtr(ScreenEvMenuMap):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvMenuMap, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvMenuMap, 'thisown', 0)
        _swig_setattr(self, ScreenEvMenuMap,self.__class__,ScreenEvMenuMap)
_kahakai.ScreenEvMenuMap_swigregister(ScreenEvMenuMapPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvMenuMapFocused instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvMenuMapFocused, 'this', _kahakai.new_ScreenEvMenuMapFocused(*args))
        _swig_setattr(self, ScreenEvMenuMapFocused, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvMenuMapFocused___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvMenuMapFocused):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvMenuMapFocusedPtr(ScreenEvMenuMapFocused):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvMenuMapFocused, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvMenuMapFocused, 'thisown', 0)
        _swig_setattr(self, ScreenEvMenuMapFocused,self.__class__,ScreenEvMenuMapFocused)
_kahakai.ScreenEvMenuMapFocused_swigregister(ScreenEvMenuMapFocusedPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvMenuRemap instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvMenuRemap, 'this', _kahakai.new_ScreenEvMenuRemap(*args))
        _swig_setattr(self, ScreenEvMenuRemap, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvMenuRemap___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvMenuRemap):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvMenuRemapPtr(ScreenEvMenuRemap):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvMenuRemap, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvMenuRemap, 'thisown', 0)
        _swig_setattr(self, ScreenEvMenuRemap,self.__class__,ScreenEvMenuRemap)
_kahakai.ScreenEvMenuRemap_swigregister(ScreenEvMenuRemapPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvMenuRemapFocused instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvMenuRemapFocused, 'this', _kahakai.new_ScreenEvMenuRemapFocused(*args))
        _swig_setattr(self, ScreenEvMenuRemapFocused, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvMenuRemapFocused___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvMenuRemapFocused):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvMenuRemapFocusedPtr(ScreenEvMenuRemapFocused):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvMenuRemapFocused, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvMenuRemapFocused, 'thisown', 0)
        _swig_setattr(self, ScreenEvMenuRemapFocused,self.__class__,ScreenEvMenuRemapFocused)
_kahakai.ScreenEvMenuRemapFocused_swigregister(ScreenEvMenuRemapFocusedPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvMenuUnmap instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvMenuUnmap, 'this', _kahakai.new_ScreenEvMenuUnmap(*args))
        _swig_setattr(self, ScreenEvMenuUnmap, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvMenuUnmap___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvMenuUnmap):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvMenuUnmapPtr(ScreenEvMenuUnmap):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvMenuUnmap, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvMenuUnmap, 'thisown', 0)
        _swig_setattr(self, ScreenEvMenuUnmap,self.__class__,ScreenEvMenuUnmap)
_kahakai.ScreenEvMenuUnmap_swigregister(ScreenEvMenuUnmapPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvMenuUnmapFocus instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvMenuUnmapFocus, 'this', _kahakai.new_ScreenEvMenuUnmapFocus(*args))
        _swig_setattr(self, ScreenEvMenuUnmapFocus, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvMenuUnmapFocus___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvMenuUnmapFocus):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvMenuUnmapFocusPtr(ScreenEvMenuUnmapFocus):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvMenuUnmapFocus, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvMenuUnmapFocus, 'thisown', 0)
        _swig_setattr(self, ScreenEvMenuUnmapFocus,self.__class__,ScreenEvMenuUnmapFocus)
_kahakai.ScreenEvMenuUnmapFocus_swigregister(ScreenEvMenuUnmapFocusPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvViewportMove instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvViewportMove, 'this', _kahakai.new_ScreenEvViewportMove(*args))
        _swig_setattr(self, ScreenEvViewportMove, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvViewportMove___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvViewportMove):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvViewportMovePtr(ScreenEvViewportMove):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvViewportMove, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvViewportMove, 'thisown', 0)
        _swig_setattr(self, ScreenEvViewportMove,self.__class__,ScreenEvViewportMove)
_kahakai.ScreenEvViewportMove_swigregister(ScreenEvViewportMovePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvViewportRelativeMove instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvViewportRelativeMove, 'this', _kahakai.new_ScreenEvViewportRelativeMove(*args))
        _swig_setattr(self, ScreenEvViewportRelativeMove, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvViewportRelativeMove___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvViewportRelativeMove):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvViewportRelativeMovePtr(ScreenEvViewportRelativeMove):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvViewportRelativeMove, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvViewportRelativeMove, 'thisown', 0)
        _swig_setattr(self, ScreenEvViewportRelativeMove,self.__class__,ScreenEvViewportRelativeMove)
_kahakai.ScreenEvViewportRelativeMove_swigregister(ScreenEvViewportRelativeMovePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvEndMoveResize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvEndMoveResize, 'this', _kahakai.new_ScreenEvEndMoveResize(*args))
        _swig_setattr(self, ScreenEvEndMoveResize, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvEndMoveResize___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvEndMoveResize):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvEndMoveResizePtr(ScreenEvEndMoveResize):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvEndMoveResize, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvEndMoveResize, 'thisown', 0)
        _swig_setattr(self, ScreenEvEndMoveResize,self.__class__,ScreenEvEndMoveResize)
_kahakai.ScreenEvEndMoveResize_swigregister(ScreenEvEndMoveResizePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvFocus instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvFocus, 'this', _kahakai.new_ScreenEvFocus(*args))
        _swig_setattr(self, ScreenEvFocus, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvFocus___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvFocus):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvFocusPtr(ScreenEvFocus):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvFocus, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvFocus, 'thisown', 0)
        _swig_setattr(self, ScreenEvFocus,self.__class__,ScreenEvFocus)
_kahakai.ScreenEvFocus_swigregister(ScreenEvFocusPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvRestart instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvRestart, 'this', _kahakai.new_ScreenEvRestart(*args))
        _swig_setattr(self, ScreenEvRestart, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvRestart___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvRestart):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvRestartPtr(ScreenEvRestart):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvRestart, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvRestart, 'thisown', 0)
        _swig_setattr(self, ScreenEvRestart,self.__class__,ScreenEvRestart)
_kahakai.ScreenEvRestart_swigregister(ScreenEvRestartPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvExit instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvExit, 'this', _kahakai.new_ScreenEvExit(*args))
        _swig_setattr(self, ScreenEvExit, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvExit___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvExit):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvExitPtr(ScreenEvExit):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvExit, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvExit, 'thisown', 0)
        _swig_setattr(self, ScreenEvExit,self.__class__,ScreenEvExit)
_kahakai.ScreenEvExit_swigregister(ScreenEvExitPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvTaskSwitcher instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvTaskSwitcher, 'this', _kahakai.new_ScreenEvTaskSwitcher(*args))
        _swig_setattr(self, ScreenEvTaskSwitcher, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvTaskSwitcher___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvTaskSwitcher):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvTaskSwitcherPtr(ScreenEvTaskSwitcher):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvTaskSwitcher, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvTaskSwitcher, 'thisown', 0)
        _swig_setattr(self, ScreenEvTaskSwitcher,self.__class__,ScreenEvTaskSwitcher)
_kahakai.ScreenEvTaskSwitcher_swigregister(ScreenEvTaskSwitcherPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvNextTask instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvNextTask, 'this', _kahakai.new_ScreenEvNextTask(*args))
        _swig_setattr(self, ScreenEvNextTask, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvNextTask___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvNextTask):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvNextTaskPtr(ScreenEvNextTask):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvNextTask, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvNextTask, 'thisown', 0)
        _swig_setattr(self, ScreenEvNextTask,self.__class__,ScreenEvNextTask)
_kahakai.ScreenEvNextTask_swigregister(ScreenEvNextTaskPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvPreviousTask instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvPreviousTask, 'this', _kahakai.new_ScreenEvPreviousTask(*args))
        _swig_setattr(self, ScreenEvPreviousTask, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvPreviousTask___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvPreviousTask):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvPreviousTaskPtr(ScreenEvPreviousTask):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvPreviousTask, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvPreviousTask, 'thisown', 0)
        _swig_setattr(self, ScreenEvPreviousTask,self.__class__,ScreenEvPreviousTask)
_kahakai.ScreenEvPreviousTask_swigregister(ScreenEvPreviousTaskPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvPointerFixedWarp instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvPointerFixedWarp, 'this', _kahakai.new_ScreenEvPointerFixedWarp(*args))
        _swig_setattr(self, ScreenEvPointerFixedWarp, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvPointerFixedWarp___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvPointerFixedWarp):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvPointerFixedWarpPtr(ScreenEvPointerFixedWarp):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvPointerFixedWarp, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvPointerFixedWarp, 'thisown', 0)
        _swig_setattr(self, ScreenEvPointerFixedWarp,self.__class__,ScreenEvPointerFixedWarp)
_kahakai.ScreenEvPointerFixedWarp_swigregister(ScreenEvPointerFixedWarpPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvPointerRelativeWarp instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvPointerRelativeWarp, 'this', _kahakai.new_ScreenEvPointerRelativeWarp(*args))
        _swig_setattr(self, ScreenEvPointerRelativeWarp, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvPointerRelativeWarp___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvPointerRelativeWarp):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvPointerRelativeWarpPtr(ScreenEvPointerRelativeWarp):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvPointerRelativeWarp, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvPointerRelativeWarp, 'thisown', 0)
        _swig_setattr(self, ScreenEvPointerRelativeWarp,self.__class__,ScreenEvPointerRelativeWarp)
_kahakai.ScreenEvPointerRelativeWarp_swigregister(ScreenEvPointerRelativeWarpPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvNextDesktop instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvNextDesktop, 'this', _kahakai.new_ScreenEvNextDesktop(*args))
        _swig_setattr(self, ScreenEvNextDesktop, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvNextDesktop___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvNextDesktop):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvNextDesktopPtr(ScreenEvNextDesktop):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvNextDesktop, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvNextDesktop, 'thisown', 0)
        _swig_setattr(self, ScreenEvNextDesktop,self.__class__,ScreenEvNextDesktop)
_kahakai.ScreenEvNextDesktop_swigregister(ScreenEvNextDesktopPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvPreviousDesktop instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvPreviousDesktop, 'this', _kahakai.new_ScreenEvPreviousDesktop(*args))
        _swig_setattr(self, ScreenEvPreviousDesktop, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvPreviousDesktop___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvPreviousDesktop):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvPreviousDesktopPtr(ScreenEvPreviousDesktop):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvPreviousDesktop, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvPreviousDesktop, 'thisown', 0)
        _swig_setattr(self, ScreenEvPreviousDesktop,self.__class__,ScreenEvPreviousDesktop)
_kahakai.ScreenEvPreviousDesktop_swigregister(ScreenEvPreviousDesktopPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ScreenEvNop instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ScreenEvNop, 'this', _kahakai.new_ScreenEvNop(*args))
        _swig_setattr(self, ScreenEvNop, 'thisown', 1)
    def __call__(*args): return _kahakai.ScreenEvNop___call__(*args)
    def __del__(self, destroy=_kahakai.delete_ScreenEvNop):
        try:
            if self.thisown: destroy(self)
        except: pass


class ScreenEvNopPtr(ScreenEvNop):
    def __init__(self, this):
        _swig_setattr(self, ScreenEvNop, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ScreenEvNop, 'thisown', 0)
        _swig_setattr(self, ScreenEvNop,self.__class__,ScreenEvNop)
_kahakai.ScreenEvNop_swigregister(ScreenEvNopPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ KaMenu instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, KaMenu, 'this', _kahakai.new_KaMenu(*args))
        _swig_setattr(self, KaMenu, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_KaMenu):
        try:
            if self.thisown: destroy(self)
        except: pass

    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)

class KaMenuPtr(KaMenu):
    def __init__(self, this):
        _swig_setattr(self, KaMenu, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, KaMenu, 'thisown', 0)
        _swig_setattr(self, KaMenu,self.__class__,KaMenu)
_kahakai.KaMenu_swigregister(KaMenuPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ KaMenuItem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, KaMenuItem, 'this', _kahakai.new_KaMenuItem(*args))
        _swig_setattr(self, KaMenuItem, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_KaMenuItem):
        try:
            if self.thisown: destroy(self)
        except: pass

    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)

class KaMenuItemPtr(KaMenuItem):
    def __init__(self, this):
        _swig_setattr(self, KaMenuItem, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, KaMenuItem, 'thisown', 0)
        _swig_setattr(self, KaMenuItem,self.__class__,KaMenuItem)
_kahakai.KaMenuItem_swigregister(KaMenuItemPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvUnLinkMenu instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvUnLinkMenu, 'this', _kahakai.new_MenuEvUnLinkMenu(*args))
        _swig_setattr(self, MenuEvUnLinkMenu, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvUnLinkMenu___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvUnLinkMenu):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvUnLinkMenuPtr(MenuEvUnLinkMenu):
    def __init__(self, this):
        _swig_setattr(self, MenuEvUnLinkMenu, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvUnLinkMenu, 'thisown', 0)
        _swig_setattr(self, MenuEvUnLinkMenu,self.__class__,MenuEvUnLinkMenu)
_kahakai.MenuEvUnLinkMenu_swigregister(MenuEvUnLinkMenuPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvMapSubmenu instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvMapSubmenu, 'this', _kahakai.new_MenuEvMapSubmenu(*args))
        _swig_setattr(self, MenuEvMapSubmenu, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvMapSubmenu___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvMapSubmenu):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvMapSubmenuPtr(MenuEvMapSubmenu):
    def __init__(self, this):
        _swig_setattr(self, MenuEvMapSubmenu, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvMapSubmenu, 'thisown', 0)
        _swig_setattr(self, MenuEvMapSubmenu,self.__class__,MenuEvMapSubmenu)
_kahakai.MenuEvMapSubmenu_swigregister(MenuEvMapSubmenuPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvMapSubmenuOnly instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvMapSubmenuOnly, 'this', _kahakai.new_MenuEvMapSubmenuOnly(*args))
        _swig_setattr(self, MenuEvMapSubmenuOnly, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvMapSubmenuOnly___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvMapSubmenuOnly):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvMapSubmenuOnlyPtr(MenuEvMapSubmenuOnly):
    def __init__(self, this):
        _swig_setattr(self, MenuEvMapSubmenuOnly, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvMapSubmenuOnly, 'thisown', 0)
        _swig_setattr(self, MenuEvMapSubmenuOnly,self.__class__,MenuEvMapSubmenuOnly)
_kahakai.MenuEvMapSubmenuOnly_swigregister(MenuEvMapSubmenuOnlyPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvMapSubmenuFocused instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvMapSubmenuFocused, 'this', _kahakai.new_MenuEvMapSubmenuFocused(*args))
        _swig_setattr(self, MenuEvMapSubmenuFocused, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvMapSubmenuFocused___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvMapSubmenuFocused):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvMapSubmenuFocusedPtr(MenuEvMapSubmenuFocused):
    def __init__(self, this):
        _swig_setattr(self, MenuEvMapSubmenuFocused, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvMapSubmenuFocused, 'thisown', 0)
        _swig_setattr(self, MenuEvMapSubmenuFocused,self.__class__,MenuEvMapSubmenuFocused)
_kahakai.MenuEvMapSubmenuFocused_swigregister(MenuEvMapSubmenuFocusedPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvMapSubmenuFocusedOnly instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvMapSubmenuFocusedOnly, 'this', _kahakai.new_MenuEvMapSubmenuFocusedOnly(*args))
        _swig_setattr(self, MenuEvMapSubmenuFocusedOnly, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvMapSubmenuFocusedOnly___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvMapSubmenuFocusedOnly):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvMapSubmenuFocusedOnlyPtr(MenuEvMapSubmenuFocusedOnly):
    def __init__(self, this):
        _swig_setattr(self, MenuEvMapSubmenuFocusedOnly, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvMapSubmenuFocusedOnly, 'thisown', 0)
        _swig_setattr(self, MenuEvMapSubmenuFocusedOnly,self.__class__,MenuEvMapSubmenuFocusedOnly)
_kahakai.MenuEvMapSubmenuFocusedOnly_swigregister(MenuEvMapSubmenuFocusedOnlyPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvRemapSubmenu instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvRemapSubmenu, 'this', _kahakai.new_MenuEvRemapSubmenu(*args))
        _swig_setattr(self, MenuEvRemapSubmenu, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvRemapSubmenu___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvRemapSubmenu):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvRemapSubmenuPtr(MenuEvRemapSubmenu):
    def __init__(self, this):
        _swig_setattr(self, MenuEvRemapSubmenu, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvRemapSubmenu, 'thisown', 0)
        _swig_setattr(self, MenuEvRemapSubmenu,self.__class__,MenuEvRemapSubmenu)
_kahakai.MenuEvRemapSubmenu_swigregister(MenuEvRemapSubmenuPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvRemapSubmenuFocused instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvRemapSubmenuFocused, 'this', _kahakai.new_MenuEvRemapSubmenuFocused(*args))
        _swig_setattr(self, MenuEvRemapSubmenuFocused, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvRemapSubmenuFocused___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvRemapSubmenuFocused):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvRemapSubmenuFocusedPtr(MenuEvRemapSubmenuFocused):
    def __init__(self, this):
        _swig_setattr(self, MenuEvRemapSubmenuFocused, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvRemapSubmenuFocused, 'thisown', 0)
        _swig_setattr(self, MenuEvRemapSubmenuFocused,self.__class__,MenuEvRemapSubmenuFocused)
_kahakai.MenuEvRemapSubmenuFocused_swigregister(MenuEvRemapSubmenuFocusedPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvUnmapMenu instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvUnmapMenu, 'this', _kahakai.new_MenuEvUnmapMenu(*args))
        _swig_setattr(self, MenuEvUnmapMenu, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvUnmapMenu___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvUnmapMenu):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvUnmapMenuPtr(MenuEvUnmapMenu):
    def __init__(self, this):
        _swig_setattr(self, MenuEvUnmapMenu, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvUnmapMenu, 'thisown', 0)
        _swig_setattr(self, MenuEvUnmapMenu,self.__class__,MenuEvUnmapMenu)
_kahakai.MenuEvUnmapMenu_swigregister(MenuEvUnmapMenuPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvUnmapMenuFocus instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvUnmapMenuFocus, 'this', _kahakai.new_MenuEvUnmapMenuFocus(*args))
        _swig_setattr(self, MenuEvUnmapMenuFocus, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvUnmapMenuFocus___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvUnmapMenuFocus):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvUnmapMenuFocusPtr(MenuEvUnmapMenuFocus):
    def __init__(self, this):
        _swig_setattr(self, MenuEvUnmapMenuFocus, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvUnmapMenuFocus, 'thisown', 0)
        _swig_setattr(self, MenuEvUnmapMenuFocus,self.__class__,MenuEvUnmapMenuFocus)
_kahakai.MenuEvUnmapMenuFocus_swigregister(MenuEvUnmapMenuFocusPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvExec instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvExec, 'this', _kahakai.new_MenuEvExec(*args))
        _swig_setattr(self, MenuEvExec, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvExec___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvExec):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvExecPtr(MenuEvExec):
    def __init__(self, this):
        _swig_setattr(self, MenuEvExec, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvExec, 'thisown', 0)
        _swig_setattr(self, MenuEvExec,self.__class__,MenuEvExec)
_kahakai.MenuEvExec_swigregister(MenuEvExecPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvFunc instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvFunc, 'this', _kahakai.new_MenuEvFunc(*args))
        _swig_setattr(self, MenuEvFunc, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvFunc___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvFunc):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvFuncPtr(MenuEvFunc):
    def __init__(self, this):
        _swig_setattr(self, MenuEvFunc, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvFunc, 'thisown', 0)
        _swig_setattr(self, MenuEvFunc,self.__class__,MenuEvFunc)
_kahakai.MenuEvFunc_swigregister(MenuEvFuncPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvMove instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvMove, 'this', _kahakai.new_MenuEvMove(*args))
        _swig_setattr(self, MenuEvMove, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvMove___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvMove):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvMovePtr(MenuEvMove):
    def __init__(self, this):
        _swig_setattr(self, MenuEvMove, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvMove, 'thisown', 0)
        _swig_setattr(self, MenuEvMove,self.__class__,MenuEvMove)
_kahakai.MenuEvMove_swigregister(MenuEvMovePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvMoveOpaque instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvMoveOpaque, 'this', _kahakai.new_MenuEvMoveOpaque(*args))
        _swig_setattr(self, MenuEvMoveOpaque, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvMoveOpaque___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvMoveOpaque):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvMoveOpaquePtr(MenuEvMoveOpaque):
    def __init__(self, this):
        _swig_setattr(self, MenuEvMoveOpaque, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvMoveOpaque, 'thisown', 0)
        _swig_setattr(self, MenuEvMoveOpaque,self.__class__,MenuEvMoveOpaque)
_kahakai.MenuEvMoveOpaque_swigregister(MenuEvMoveOpaquePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvEndMoveResize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvEndMoveResize, 'this', _kahakai.new_MenuEvEndMoveResize(*args))
        _swig_setattr(self, MenuEvEndMoveResize, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvEndMoveResize___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvEndMoveResize):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvEndMoveResizePtr(MenuEvEndMoveResize):
    def __init__(self, this):
        _swig_setattr(self, MenuEvEndMoveResize, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvEndMoveResize, 'thisown', 0)
        _swig_setattr(self, MenuEvEndMoveResize,self.__class__,MenuEvEndMoveResize)
_kahakai.MenuEvEndMoveResize_swigregister(MenuEvEndMoveResizePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvFocus instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvFocus, 'this', _kahakai.new_MenuEvFocus(*args))
        _swig_setattr(self, MenuEvFocus, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvFocus___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvFocus):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvFocusPtr(MenuEvFocus):
    def __init__(self, this):
        _swig_setattr(self, MenuEvFocus, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvFocus, 'thisown', 0)
        _swig_setattr(self, MenuEvFocus,self.__class__,MenuEvFocus)
_kahakai.MenuEvFocus_swigregister(MenuEvFocusPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvUnmapSubmenus instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvUnmapSubmenus, 'this', _kahakai.new_MenuEvUnmapSubmenus(*args))
        _swig_setattr(self, MenuEvUnmapSubmenus, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvUnmapSubmenus___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvUnmapSubmenus):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvUnmapSubmenusPtr(MenuEvUnmapSubmenus):
    def __init__(self, this):
        _swig_setattr(self, MenuEvUnmapSubmenus, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvUnmapSubmenus, 'thisown', 0)
        _swig_setattr(self, MenuEvUnmapSubmenus,self.__class__,MenuEvUnmapSubmenus)
_kahakai.MenuEvUnmapSubmenus_swigregister(MenuEvUnmapSubmenusPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvUnmapTree instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvUnmapTree, 'this', _kahakai.new_MenuEvUnmapTree(*args))
        _swig_setattr(self, MenuEvUnmapTree, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvUnmapTree___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvUnmapTree):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvUnmapTreePtr(MenuEvUnmapTree):
    def __init__(self, this):
        _swig_setattr(self, MenuEvUnmapTree, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvUnmapTree, 'thisown', 0)
        _swig_setattr(self, MenuEvUnmapTree,self.__class__,MenuEvUnmapTree)
_kahakai.MenuEvUnmapTree_swigregister(MenuEvUnmapTreePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvRaise instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvRaise, 'this', _kahakai.new_MenuEvRaise(*args))
        _swig_setattr(self, MenuEvRaise, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvRaise___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvRaise):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvRaisePtr(MenuEvRaise):
    def __init__(self, this):
        _swig_setattr(self, MenuEvRaise, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvRaise, 'thisown', 0)
        _swig_setattr(self, MenuEvRaise,self.__class__,MenuEvRaise)
_kahakai.MenuEvRaise_swigregister(MenuEvRaisePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvLower instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvLower, 'this', _kahakai.new_MenuEvLower(*args))
        _swig_setattr(self, MenuEvLower, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvLower___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvLower):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvLowerPtr(MenuEvLower):
    def __init__(self, this):
        _swig_setattr(self, MenuEvLower, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvLower, 'thisown', 0)
        _swig_setattr(self, MenuEvLower,self.__class__,MenuEvLower)
_kahakai.MenuEvLower_swigregister(MenuEvLowerPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvNextItem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvNextItem, 'this', _kahakai.new_MenuEvNextItem(*args))
        _swig_setattr(self, MenuEvNextItem, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvNextItem___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvNextItem):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvNextItemPtr(MenuEvNextItem):
    def __init__(self, this):
        _swig_setattr(self, MenuEvNextItem, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvNextItem, 'thisown', 0)
        _swig_setattr(self, MenuEvNextItem,self.__class__,MenuEvNextItem)
_kahakai.MenuEvNextItem_swigregister(MenuEvNextItemPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvPreviousItem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvPreviousItem, 'this', _kahakai.new_MenuEvPreviousItem(*args))
        _swig_setattr(self, MenuEvPreviousItem, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvPreviousItem___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvPreviousItem):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvPreviousItemPtr(MenuEvPreviousItem):
    def __init__(self, this):
        _swig_setattr(self, MenuEvPreviousItem, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvPreviousItem, 'thisown', 0)
        _swig_setattr(self, MenuEvPreviousItem,self.__class__,MenuEvPreviousItem)
_kahakai.MenuEvPreviousItem_swigregister(MenuEvPreviousItemPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuEvNop instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MenuEvNop, 'this', _kahakai.new_MenuEvNop(*args))
        _swig_setattr(self, MenuEvNop, 'thisown', 1)
    def __call__(*args): return _kahakai.MenuEvNop___call__(*args)
    def __del__(self, destroy=_kahakai.delete_MenuEvNop):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuEvNopPtr(MenuEvNop):
    def __init__(self, this):
        _swig_setattr(self, MenuEvNop, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuEvNop, 'thisown', 0)
        _swig_setattr(self, MenuEvNop,self.__class__,MenuEvNop)
_kahakai.MenuEvNop_swigregister(MenuEvNopPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ KaAction instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, Action, 'this', _kahakai.new_Action(*args))
        _swig_setattr(self, Action, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_Action):
        try:
            if self.thisown: destroy(self)
        except: pass


class ActionPtr(Action):
    def __init__(self, this):
        _swig_setattr(self, Action, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Action, 'thisown', 0)
        _swig_setattr(self, Action,self.__class__,Action)
_kahakai.Action_swigregister(ActionPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MwmHints instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, MwmHints, 'this', _kahakai.new_MwmHints(*args))
        _swig_setattr(self, MwmHints, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_MwmHints):
        try:
            if self.thisown: destroy(self)
        except: pass


class MwmHintsPtr(MwmHints):
    def __init__(self, this):
        _swig_setattr(self, MwmHints, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MwmHints, 'thisown', 0)
        _swig_setattr(self, MwmHints,self.__class__,MwmHints)
_kahakai.MwmHints_swigregister(MwmHintsPtr)

_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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Padding instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, Padding, 'this', _kahakai.new_Padding(*args))
        _swig_setattr(self, Padding, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_Padding):
        try:
            if self.thisown: destroy(self)
        except: pass


class PaddingPtr(Padding):
    def __init__(self, this):
        _swig_setattr(self, Padding, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Padding, 'thisown', 0)
        _swig_setattr(self, Padding,self.__class__,Padding)
_kahakai.Padding_swigregister(PaddingPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ButtonStateStyle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, ButtonStateStyle, 'this', _kahakai.new_ButtonStateStyle(*args))
        _swig_setattr(self, ButtonStateStyle, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_ButtonStateStyle):
        try:
            if self.thisown: destroy(self)
        except: pass


class ButtonStateStylePtr(ButtonStateStyle):
    def __init__(self, this):
        _swig_setattr(self, ButtonStateStyle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ButtonStateStyle, 'thisown', 0)
        _swig_setattr(self, ButtonStateStyle,self.__class__,ButtonStateStyle)
_kahakai.ButtonStateStyle_swigregister(ButtonStateStylePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ ButtonStyle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, ButtonStyle, 'this', _kahakai.new_ButtonStyle(*args))
        _swig_setattr(self, ButtonStyle, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_ButtonStyle):
        try:
            if self.thisown: destroy(self)
        except: pass


class ButtonStylePtr(ButtonStyle):
    def __init__(self, this):
        _swig_setattr(self, ButtonStyle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ButtonStyle, 'thisown', 0)
        _swig_setattr(self, ButtonStyle,self.__class__,ButtonStyle)
_kahakai.ButtonStyle_swigregister(ButtonStylePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowStateStyle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, WindowStateStyle, 'this', _kahakai.new_WindowStateStyle(*args))
        _swig_setattr(self, WindowStateStyle, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_WindowStateStyle):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowStateStylePtr(WindowStateStyle):
    def __init__(self, this):
        _swig_setattr(self, WindowStateStyle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowStateStyle, 'thisown', 0)
        _swig_setattr(self, WindowStateStyle,self.__class__,WindowStateStyle)
_kahakai.WindowStateStyle_swigregister(WindowStateStylePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ WindowStyle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, WindowStyle, 'this', _kahakai.new_WindowStyle(*args))
        _swig_setattr(self, WindowStyle, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_WindowStyle):
        try:
            if self.thisown: destroy(self)
        except: pass


class WindowStylePtr(WindowStyle):
    def __init__(self, this):
        _swig_setattr(self, WindowStyle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WindowStyle, 'thisown', 0)
        _swig_setattr(self, WindowStyle,self.__class__,WindowStyle)
_kahakai.WindowStyle_swigregister(WindowStylePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuItemStyle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, MenuItemStyle, 'this', _kahakai.new_MenuItemStyle(*args))
        _swig_setattr(self, MenuItemStyle, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_MenuItemStyle):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuItemStylePtr(MenuItemStyle):
    def __init__(self, this):
        _swig_setattr(self, MenuItemStyle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuItemStyle, 'thisown', 0)
        _swig_setattr(self, MenuItemStyle,self.__class__,MenuItemStyle)
_kahakai.MenuItemStyle_swigregister(MenuItemStylePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuFrameStyle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, MenuFrameStyle, 'this', _kahakai.new_MenuFrameStyle(*args))
        _swig_setattr(self, MenuFrameStyle, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_MenuFrameStyle):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuFrameStylePtr(MenuFrameStyle):
    def __init__(self, this):
        _swig_setattr(self, MenuFrameStyle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuFrameStyle, 'thisown', 0)
        _swig_setattr(self, MenuFrameStyle,self.__class__,MenuFrameStyle)
_kahakai.MenuFrameStyle_swigregister(MenuFrameStylePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuTitleStyle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, MenuTitleStyle, 'this', _kahakai.new_MenuTitleStyle(*args))
        _swig_setattr(self, MenuTitleStyle, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_MenuTitleStyle):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuTitleStylePtr(MenuTitleStyle):
    def __init__(self, this):
        _swig_setattr(self, MenuTitleStyle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuTitleStyle, 'thisown', 0)
        _swig_setattr(self, MenuTitleStyle,self.__class__,MenuTitleStyle)
_kahakai.MenuTitleStyle_swigregister(MenuTitleStylePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuCheckboxStyle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, MenuCheckboxStyle, 'this', _kahakai.new_MenuCheckboxStyle(*args))
        _swig_setattr(self, MenuCheckboxStyle, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_MenuCheckboxStyle):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuCheckboxStylePtr(MenuCheckboxStyle):
    def __init__(self, this):
        _swig_setattr(self, MenuCheckboxStyle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuCheckboxStyle, 'thisown', 0)
        _swig_setattr(self, MenuCheckboxStyle,self.__class__,MenuCheckboxStyle)
_kahakai.MenuCheckboxStyle_swigregister(MenuCheckboxStylePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuBulletStyle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, MenuBulletStyle, 'this', _kahakai.new_MenuBulletStyle(*args))
        _swig_setattr(self, MenuBulletStyle, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_MenuBulletStyle):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuBulletStylePtr(MenuBulletStyle):
    def __init__(self, this):
        _swig_setattr(self, MenuBulletStyle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuBulletStyle, 'thisown', 0)
        _swig_setattr(self, MenuBulletStyle,self.__class__,MenuBulletStyle)
_kahakai.MenuBulletStyle_swigregister(MenuBulletStylePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ MenuStyle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, MenuStyle, 'this', _kahakai.new_MenuStyle(*args))
        _swig_setattr(self, MenuStyle, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_MenuStyle):
        try:
            if self.thisown: destroy(self)
        except: pass


class MenuStylePtr(MenuStyle):
    def __init__(self, this):
        _swig_setattr(self, MenuStyle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MenuStyle, 'thisown', 0)
        _swig_setattr(self, MenuStyle,self.__class__,MenuStyle)
_kahakai.MenuStyle_swigregister(MenuStylePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ DockholderStyle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, DockholderStyle, 'this', _kahakai.new_DockholderStyle(*args))
        _swig_setattr(self, DockholderStyle, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_DockholderStyle):
        try:
            if self.thisown: destroy(self)
        except: pass


class DockholderStylePtr(DockholderStyle):
    def __init__(self, this):
        _swig_setattr(self, DockholderStyle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, DockholderStyle, 'thisown', 0)
        _swig_setattr(self, DockholderStyle,self.__class__,DockholderStyle)
_kahakai.DockholderStyle_swigregister(DockholderStylePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ DockStyle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, DockStyle, 'this', _kahakai.new_DockStyle(*args))
        _swig_setattr(self, DockStyle, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_DockStyle):
        try:
            if self.thisown: destroy(self)
        except: pass


class DockStylePtr(DockStyle):
    def __init__(self, this):
        _swig_setattr(self, DockStyle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, DockStyle, 'thisown', 0)
        _swig_setattr(self, DockStyle,self.__class__,DockStyle)
_kahakai.DockStyle_swigregister(DockStylePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Style instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, Style, 'this', _kahakai.new_Style(*args))
        _swig_setattr(self, Style, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_Style):
        try:
            if self.thisown: destroy(self)
        except: pass


class StylePtr(Style):
    def __init__(self, this):
        _swig_setattr(self, Style, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Style, 'thisown', 0)
        _swig_setattr(self, Style,self.__class__,Style)
_kahakai.Style_swigregister(StylePtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ timeval instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, timeval, 'this', _kahakai.new_timeval(*args))
        _swig_setattr(self, timeval, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_timeval):
        try:
            if self.thisown: destroy(self)
        except: pass


class timevalPtr(timeval):
    def __init__(self, this):
        _swig_setattr(self, timeval, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, timeval, 'thisown', 0)
        _swig_setattr(self, timeval,self.__class__,timeval)
_kahakai.timeval_swigregister(timevalPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ XClassHint instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __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):
        _swig_setattr(self, XClassHint, 'this', _kahakai.new_XClassHint(*args))
        _swig_setattr(self, XClassHint, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_XClassHint):
        try:
            if self.thisown: destroy(self)
        except: pass


class XClassHintPtr(XClassHint):
    def __init__(self, this):
        _swig_setattr(self, XClassHint, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, XClassHint, 'thisown', 0)
        _swig_setattr(self, XClassHint,self.__class__,XClassHint)
_kahakai.XClassHint_swigregister(XClassHintPtr)


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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ PythonFunction instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, PythonFunction, 'this', _kahakai.new_PythonFunction(*args))
        _swig_setattr(self, PythonFunction, 'thisown', 1)
    def __del__(self, destroy=_kahakai.delete_PythonFunction):
        try:
            if self.thisown: destroy(self)
        except: pass


class PythonFunctionPtr(PythonFunction):
    def __init__(self, this):
        _swig_setattr(self, PythonFunction, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, PythonFunction, 'thisown', 0)
        _swig_setattr(self, PythonFunction,self.__class__,PythonFunction)
_kahakai.PythonFunction_swigregister(PythonFunctionPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ PythonMenuFunction instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, PythonMenuFunction, 'this', _kahakai.new_PythonMenuFunction(*args))
        _swig_setattr(self, PythonMenuFunction, 'thisown', 1)
    def __call__(*args): return _kahakai.PythonMenuFunction___call__(*args)
    def __del__(self, destroy=_kahakai.delete_PythonMenuFunction):
        try:
            if self.thisown: destroy(self)
        except: pass


class PythonMenuFunctionPtr(PythonMenuFunction):
    def __init__(self, this):
        _swig_setattr(self, PythonMenuFunction, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, PythonMenuFunction, 'thisown', 0)
        _swig_setattr(self, PythonMenuFunction,self.__class__,PythonMenuFunction)
_kahakai.PythonMenuFunction_swigregister(PythonMenuFunctionPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ PythonScreenFunction instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, PythonScreenFunction, 'this', _kahakai.new_PythonScreenFunction(*args))
        _swig_setattr(self, PythonScreenFunction, 'thisown', 1)
    def __call__(*args): return _kahakai.PythonScreenFunction___call__(*args)
    def __del__(self, destroy=_kahakai.delete_PythonScreenFunction):
        try:
            if self.thisown: destroy(self)
        except: pass


class PythonScreenFunctionPtr(PythonScreenFunction):
    def __init__(self, this):
        _swig_setattr(self, PythonScreenFunction, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, PythonScreenFunction, 'thisown', 0)
        _swig_setattr(self, PythonScreenFunction,self.__class__,PythonScreenFunction)
_kahakai.PythonScreenFunction_swigregister(PythonScreenFunctionPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ PythonWindowFunction instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, PythonWindowFunction, 'this', _kahakai.new_PythonWindowFunction(*args))
        _swig_setattr(self, PythonWindowFunction, 'thisown', 1)
    def __call__(*args): return _kahakai.PythonWindowFunction___call__(*args)
    def __del__(self, destroy=_kahakai.delete_PythonWindowFunction):
        try:
            if self.thisown: destroy(self)
        except: pass


class PythonWindowFunctionPtr(PythonWindowFunction):
    def __init__(self, this):
        _swig_setattr(self, PythonWindowFunction, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, PythonWindowFunction, 'thisown', 0)
        _swig_setattr(self, PythonWindowFunction,self.__class__,PythonWindowFunction)
_kahakai.PythonWindowFunction_swigregister(PythonWindowFunctionPtr)

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)
    def __repr__(self):
        return "<%s.%s; proxy of C++ PythonSimpleFunction instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, PythonSimpleFunction, 'this', _kahakai.new_PythonSimpleFunction(*args))
        _swig_setattr(self, PythonSimpleFunction, 'thisown', 1)
    def __call__(*args): return _kahakai.PythonSimpleFunction___call__(*args)
    def __del__(self, destroy=_kahakai.delete_PythonSimpleFunction):
        try:
            if self.thisown: destroy(self)
        except: pass


class PythonSimpleFunctionPtr(PythonSimpleFunction):
    def __init__(self, this):
        _swig_setattr(self, PythonSimpleFunction, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, PythonSimpleFunction, 'thisown', 0)
        _swig_setattr(self, PythonSimpleFunction,self.__class__,PythonSimpleFunction)
_kahakai.PythonSimpleFunction_swigregister(PythonSimpleFunctionPtr)


createMenuFunction = _kahakai.createMenuFunction

createWindowFunction = _kahakai.createWindowFunction

createScreenFunction = _kahakai.createScreenFunction

createSimpleFunction = _kahakai.createSimpleFunction

