# 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 _mpfc
def _swig_setattr(self,class_type,name,value):
    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)
    self.__dict__[name] = value

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


WS_DATA_SOURCE_NONE = _mpfc.WS_DATA_SOURCE_NONE
WS_DATA_SOURCE_INSTANCE = _mpfc.WS_DATA_SOURCE_INSTANCE
WS_DATA_SOURCE_FILE = _mpfc.WS_DATA_SOURCE_FILE
WS_TEXT = _mpfc.WS_TEXT
WS_BINARY = _mpfc.WS_BINARY
WS_NORMAL = _mpfc.WS_NORMAL
WS_TREE = _mpfc.WS_TREE
WS_VERBOSE = _mpfc.WS_VERBOSE
WS_HAVE_CHILD = _mpfc.WS_HAVE_CHILD
WS_HAVE_BROS = _mpfc.WS_HAVE_BROS
WS_OPEN = _mpfc.WS_OPEN
WS_INDENT_LEVEL = _mpfc.WS_INDENT_LEVEL
WS_ABSOLUTE_OPEN = _mpfc.WS_ABSOLUTE_OPEN
WS_ICON = _mpfc.WS_ICON
WS_SFORM_FIXED = _mpfc.WS_SFORM_FIXED
WS_SFORM_UNDER_RESIZING = _mpfc.WS_SFORM_UNDER_RESIZING
WS_EXEC_NONE = _mpfc.WS_EXEC_NONE
WS_EXEC_RD = _mpfc.WS_EXEC_RD
WS_EXEC_RDWR = _mpfc.WS_EXEC_RDWR
WS_EXEC_WR = _mpfc.WS_EXEC_WR
WS_DOUBLE_CLICK_TIME = _mpfc.WS_DOUBLE_CLICK_TIME
WS_POLICY_ORIGINAL = _mpfc.WS_POLICY_ORIGINAL
WS_POLICY_WINDOWS = _mpfc.WS_POLICY_WINDOWS
WS_POLICY_GRADATION = _mpfc.WS_POLICY_GRADATION
WS_POLICY_AQUA = _mpfc.WS_POLICY_AQUA
class WSCpoint(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCpoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSCpoint, name)
    __swig_setmethods__["x"] = _mpfc.WSCpoint_x_set
    __swig_getmethods__["x"] = _mpfc.WSCpoint_x_get
    if _newclass:x = property(_mpfc.WSCpoint_x_get,_mpfc.WSCpoint_x_set)
    __swig_setmethods__["y"] = _mpfc.WSCpoint_y_set
    __swig_getmethods__["y"] = _mpfc.WSCpoint_y_get
    if _newclass:y = property(_mpfc.WSCpoint_y_get,_mpfc.WSCpoint_y_set)
    def setPoint(*args): return apply(_mpfc.WSCpoint_setPoint,args)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCpoint,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCpoint):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCpoint instance at %s>" % (self.this,)

class WSCpointPtr(WSCpoint):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCpoint
_mpfc.WSCpoint_swigregister(WSCpointPtr)

class WSCrect(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCrect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSCrect, name)
    __swig_setmethods__["x"] = _mpfc.WSCrect_x_set
    __swig_getmethods__["x"] = _mpfc.WSCrect_x_get
    if _newclass:x = property(_mpfc.WSCrect_x_get,_mpfc.WSCrect_x_set)
    __swig_setmethods__["y"] = _mpfc.WSCrect_y_set
    __swig_getmethods__["y"] = _mpfc.WSCrect_y_get
    if _newclass:y = property(_mpfc.WSCrect_y_get,_mpfc.WSCrect_y_set)
    __swig_setmethods__["width"] = _mpfc.WSCrect_width_set
    __swig_getmethods__["width"] = _mpfc.WSCrect_width_get
    if _newclass:width = property(_mpfc.WSCrect_width_get,_mpfc.WSCrect_width_set)
    __swig_setmethods__["height"] = _mpfc.WSCrect_height_set
    __swig_getmethods__["height"] = _mpfc.WSCrect_height_get
    if _newclass:height = property(_mpfc.WSCrect_height_get,_mpfc.WSCrect_height_set)
    def setRect(*args): return apply(_mpfc.WSCrect_setRect,args)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCrect,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCrect):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCrect instance at %s>" % (self.this,)

class WSCrectPtr(WSCrect):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCrect
_mpfc.WSCrect_swigregister(WSCrectPtr)

WS_EN_DEFAULT = _mpfc.WS_EN_DEFAULT
WS_EN_LOCALE = _mpfc.WS_EN_LOCALE
WS_EN_NONE = _mpfc.WS_EN_NONE
WS_EN_ISO8859_1 = _mpfc.WS_EN_ISO8859_1
WS_EN_ISO8859_2 = _mpfc.WS_EN_ISO8859_2
WS_EN_ISO8859_3 = _mpfc.WS_EN_ISO8859_3
WS_EN_ISO8859_4 = _mpfc.WS_EN_ISO8859_4
WS_EN_ISO8859_5 = _mpfc.WS_EN_ISO8859_5
WS_EN_ISO8859_6 = _mpfc.WS_EN_ISO8859_6
WS_EN_ISO8859_7 = _mpfc.WS_EN_ISO8859_7
WS_EN_ISO8859_8 = _mpfc.WS_EN_ISO8859_8
WS_EN_ISO8859_9 = _mpfc.WS_EN_ISO8859_9
WS_EN_ISO8859_10 = _mpfc.WS_EN_ISO8859_10
WS_EN_ISO8859_11 = _mpfc.WS_EN_ISO8859_11
WS_EN_ISO8859_12 = _mpfc.WS_EN_ISO8859_12
WS_EN_ISO8859_13 = _mpfc.WS_EN_ISO8859_13
WS_EN_ISO8859_14 = _mpfc.WS_EN_ISO8859_14
WS_EN_ISO8859_15 = _mpfc.WS_EN_ISO8859_15
WS_EN_UTF8 = _mpfc.WS_EN_UTF8
WS_EN_KOI8R = _mpfc.WS_EN_KOI8R
WS_EN_EUCJP = _mpfc.WS_EN_EUCJP
WS_EN_SJIS = _mpfc.WS_EN_SJIS
WS_EN_EUCKR = _mpfc.WS_EN_EUCKR
WS_EN_EUCCN = _mpfc.WS_EN_EUCCN
WS_EN_BIG5 = _mpfc.WS_EN_BIG5
WS_DIALOG_CANCEL = _mpfc.WS_DIALOG_CANCEL
WS_DIALOG_OK = _mpfc.WS_DIALOG_OK
WS_DIALOG_NO = _mpfc.WS_DIALOG_NO
WS_DIALOG_DONE = _mpfc.WS_DIALOG_DONE
class WSCstring(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCstring, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSCstring, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCstring,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCstring):
        try:
            if self.thisown: destroy(self)
        except: pass
    def setString(*args): return apply(_mpfc.WSCstring_setString,args)
    def getString(*args): return apply(_mpfc.WSCstring_getString,args)
    def __repr__(self):
        return "<C WSCstring instance at %s>" % (self.this,)

class WSCstringPtr(WSCstring):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCstring
_mpfc.WSCstring_swigregister(WSCstringPtr)

class WSCvariant(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvariant, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvariant, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvariant,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvariant):
        try:
            if self.thisown: destroy(self)
        except: pass
    def getChar(*args): return apply(_mpfc.WSCvariant_getChar,args)
    def getUnsignedChar(*args): return apply(_mpfc.WSCvariant_getUnsignedChar,args)
    def getShort(*args): return apply(_mpfc.WSCvariant_getShort,args)
    def getUnsignedShort(*args): return apply(_mpfc.WSCvariant_getUnsignedShort,args)
    def getLong(*args): return apply(_mpfc.WSCvariant_getLong,args)
    def getUnsignedLong(*args): return apply(_mpfc.WSCvariant_getUnsignedLong,args)
    def getInt(*args): return apply(_mpfc.WSCvariant_getInt,args)
    def getUnsignedInt(*args): return apply(_mpfc.WSCvariant_getUnsignedInt,args)
    def getFloat(*args): return apply(_mpfc.WSCvariant_getFloat,args)
    def getDouble(*args): return apply(_mpfc.WSCvariant_getDouble,args)
    def getCharPtr(*args): return apply(_mpfc.WSCvariant_getCharPtr,args)
    def getInstancePtr(*args): return apply(_mpfc.WSCvariant_getInstancePtr,args)
    def setValue(*args): return apply(_mpfc.WSCvariant_setValue,args)
    def getType(*args): return apply(_mpfc.WSCvariant_getType,args)
    def getTypeName(*args): return apply(_mpfc.WSCvariant_getTypeName,args)
    def clear(*args): return apply(_mpfc.WSCvariant_clear,args)
    def __repr__(self):
        return "<C WSCvariant instance at %s>" % (self.this,)

class WSCvariantPtr(WSCvariant):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvariant
_mpfc.WSCvariant_swigregister(WSCvariantPtr)

class WSDappDev(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSDappDev, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSDappDev, name)
    def handleEvents(*args): return apply(_mpfc.WSDappDev_handleEvents,args)
    def getInstanceName(*args): return apply(_mpfc.WSDappDev_getInstanceName,args)
    def getWidth(*args): return apply(_mpfc.WSDappDev_getWidth,args)
    def getHeight(*args): return apply(_mpfc.WSDappDev_getHeight,args)
    def update(*args): return apply(_mpfc.WSDappDev_update,args)
    def exit(*args): return apply(_mpfc.WSDappDev_exit,args)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSDappDev,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSDappDev):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSDappDev instance at %s>" % (self.this,)

class WSDappDevPtr(WSDappDev):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSDappDev
_mpfc.WSDappDev_swigregister(WSDappDevPtr)

WSGIappDev = _mpfc.WSGIappDev

WSGFwsInitialize = _mpfc.WSGFwsInitialize

WSGFdestroyWindow = _mpfc.WSGFdestroyWindow

WSGFdeviceInitialize = _mpfc.WSGFdeviceInitialize

WSGFfunctionRegister = _mpfc.WSGFfunctionRegister

class WSCbase(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCbase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSCbase, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCbase,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCbase):
        try:
            if self.thisown: destroy(self)
        except: pass
    def initialize(*args): return apply(_mpfc.WSCbase_initialize,args)
    def getInitialized(*args): return apply(_mpfc.WSCbase_getInitialized,args)
    def onMouseIn(*args): return apply(_mpfc.WSCbase_onMouseIn,args)
    def onMouseOut(*args): return apply(_mpfc.WSCbase_onMouseOut,args)
    def onMouseMove(*args): return apply(_mpfc.WSCbase_onMouseMove,args)
    def onMousePress(*args): return apply(_mpfc.WSCbase_onMousePress,args)
    def onMouseRelease(*args): return apply(_mpfc.WSCbase_onMouseRelease,args)
    def onExpose(*args): return apply(_mpfc.WSCbase_onExpose,args)
    def onResize(*args): return apply(_mpfc.WSCbase_onResize,args)
    def onVisibleChange(*args): return apply(_mpfc.WSCbase_onVisibleChange,args)
    def onSensitiveChange(*args): return apply(_mpfc.WSCbase_onSensitiveChange,args)
    def onParentVisibleChange(*args): return apply(_mpfc.WSCbase_onParentVisibleChange,args)
    def onParentSensitiveChange(*args): return apply(_mpfc.WSCbase_onParentSensitiveChange,args)
    def onEditModeChange(*args): return apply(_mpfc.WSCbase_onEditModeChange,args)
    def onFocusChange(*args): return apply(_mpfc.WSCbase_onFocusChange,args)
    def onSpecialFocusChange(*args): return apply(_mpfc.WSCbase_onSpecialFocusChange,args)
    def onChildAdded(*args): return apply(_mpfc.WSCbase_onChildAdded,args)
    def onSelectionChange(*args): return apply(_mpfc.WSCbase_onSelectionChange,args)
    def onGuiPolicyChange(*args): return apply(_mpfc.WSCbase_onGuiPolicyChange,args)
    def onDefaultColorChange(*args): return apply(_mpfc.WSCbase_onDefaultColorChange,args)
    def getInstanceName(*args): return apply(_mpfc.WSCbase_getInstanceName,args)
    def setVisible(*args): return apply(_mpfc.WSCbase_setVisible,args)
    def getVisible(*args): return apply(_mpfc.WSCbase_getVisible,args)
    def getProperty(*args): return apply(_mpfc.WSCbase_getProperty,args)
    def setProperty(*args): return apply(_mpfc.WSCbase_setProperty,args)
    def addProcedure(*args): return apply(_mpfc.WSCbase_addProcedure,args)
    def setParent(*args): return apply(_mpfc.WSCbase_setParent,args)
    def getParent(*args): return apply(_mpfc.WSCbase_getParent,args)
    def getParentWindow(*args): return apply(_mpfc.WSCbase_getParentWindow,args)
    def getChildInstance(*args): return apply(_mpfc.WSCbase_getChildInstance,args)
    def setInternalObject(*args): return apply(_mpfc.WSCbase_setInternalObject,args)
    def getInternalObject(*args): return apply(_mpfc.WSCbase_getInternalObject,args)
    def setDefaultValue(*args): return apply(_mpfc.WSCbase_setDefaultValue,args)
    def existProperty(*args): return apply(_mpfc.WSCbase_existProperty,args)
    def getDefaultProperty(*args): return apply(_mpfc.WSCbase_getDefaultProperty,args)
    def setFocus(*args): return apply(_mpfc.WSCbase_setFocus,args)
    def setSpecialFocus(*args): return apply(_mpfc.WSCbase_setSpecialFocus,args)
    def setParentVisible(*args): return apply(_mpfc.WSCbase_setParentVisible,args)
    def setSensitive(*args): return apply(_mpfc.WSCbase_setSensitive,args)
    def setParentSensitive(*args): return apply(_mpfc.WSCbase_setParentSensitive,args)
    def getParentVisible(*args): return apply(_mpfc.WSCbase_getParentVisible,args)
    def getSensitive(*args): return apply(_mpfc.WSCbase_getSensitive,args)
    def getParentSensitive(*args): return apply(_mpfc.WSCbase_getParentSensitive,args)
    def getFocus(*args): return apply(_mpfc.WSCbase_getFocus,args)
    def getSpecialFocus(*args): return apply(_mpfc.WSCbase_getSpecialFocus,args)
    def setAbsoluteDraw(*args): return apply(_mpfc.WSCbase_setAbsoluteDraw,args)
    def getAbsoluteDraw(*args): return apply(_mpfc.WSCbase_getAbsoluteDraw,args)
    def setUserData(*args): return apply(_mpfc.WSCbase_setUserData,args)
    def getUserData(*args): return apply(_mpfc.WSCbase_getUserData,args)
    def setVariantData(*args): return apply(_mpfc.WSCbase_setVariantData,args)
    def getVariantData(*args): return apply(_mpfc.WSCbase_getVariantData,args)
    def execProcedure(*args): return apply(_mpfc.WSCbase_execProcedure,args)
    def draw(*args): return apply(_mpfc.WSCbase_draw,args)
    def clear(*args): return apply(_mpfc.WSCbase_clear,args)
    def redraw(*args): return apply(_mpfc.WSCbase_redraw,args)
    def cdraw(*args): return apply(_mpfc.WSCbase_cdraw,args)
    __swig_getmethods__["getNewInstance"] = lambda x: _mpfc.WSCbase_getNewInstance
    if _newclass:getNewInstance = staticmethod(_mpfc.WSCbase_getNewInstance)
    __swig_getmethods__["getFocusInstance"] = lambda x: _mpfc.WSCbase_getFocusInstance
    if _newclass:getFocusInstance = staticmethod(_mpfc.WSCbase_getFocusInstance)
    __swig_getmethods__["getSpecialFocusInstance"] = lambda x: _mpfc.WSCbase_getSpecialFocusInstance
    if _newclass:getSpecialFocusInstance = staticmethod(_mpfc.WSCbase_getSpecialFocusInstance)
    def __repr__(self):
        return "<C WSCbase instance at %s>" % (self.this,)

class WSCbasePtr(WSCbase):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCbase
_mpfc.WSCbase_swigregister(WSCbasePtr)
WSCbase_getNewInstance = _mpfc.WSCbase_getNewInstance

WSCbase_getFocusInstance = _mpfc.WSCbase_getFocusInstance

WSCbase_getSpecialFocusInstance = _mpfc.WSCbase_getSpecialFocusInstance


class WSDmouse(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSDmouse, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSDmouse, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSDmouse,args)
        self.thisown = 1
    def getMousePosition(*args): return apply(_mpfc.WSDmouse_getMousePosition,args)
    def getMouseStatus(*args): return apply(_mpfc.WSDmouse_getMouseStatus,args)
    def setMousePosition(*args): return apply(_mpfc.WSDmouse_setMousePosition,args)
    def setMouseCursor(*args): return apply(_mpfc.WSDmouse_setMouseCursor,args)
    def addMouseCursor(*args): return apply(_mpfc.WSDmouse_addMouseCursor,args)
    def getMouseCursorName(*args): return apply(_mpfc.WSDmouse_getMouseCursorName,args)
    def getMouseCursorId(*args): return apply(_mpfc.WSDmouse_getMouseCursorId,args)
    def getMouseCursor(*args): return apply(_mpfc.WSDmouse_getMouseCursor,args)
    def getStatus(*args): return apply(_mpfc.WSDmouse_getStatus,args)
    def setStatus(*args): return apply(_mpfc.WSDmouse_setStatus,args)
    def getTargetBtn(*args): return apply(_mpfc.WSDmouse_getTargetBtn,args)
    def setTargetBtn(*args): return apply(_mpfc.WSDmouse_setTargetBtn,args)
    def setMouseFocusClient(*args): return apply(_mpfc.WSDmouse_setMouseFocusClient,args)
    def getMouseFocusClient(*args): return apply(_mpfc.WSDmouse_getMouseFocusClient,args)
    def __del__(self, destroy= _mpfc.delete_WSDmouse):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSDmouse instance at %s>" % (self.this,)

class WSDmousePtr(WSDmouse):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSDmouse
_mpfc.WSDmouse_swigregister(WSDmousePtr)

WSGIappMouse = _mpfc.WSGIappMouse

class WSCform(WSCbase):
    __swig_setmethods__ = {}
    for _s in [WSCbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCform, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCform, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCform,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCform):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCform instance at %s>" % (self.this,)

class WSCformPtr(WSCform):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCform
_mpfc.WSCform_swigregister(WSCformPtr)

class WSCnwbase(WSCbase):
    __swig_setmethods__ = {}
    for _s in [WSCbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCnwbase, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCnwbase, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCnwbase,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCnwbase):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCnwbase instance at %s>" % (self.this,)

class WSCnwbasePtr(WSCnwbase):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCnwbase
_mpfc.WSCnwbase_swigregister(WSCnwbasePtr)

class WSCngbase(WSCbase):
    __swig_setmethods__ = {}
    for _s in [WSCbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCngbase, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCngbase, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCngbase,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCngbase):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCngbase instance at %s>" % (self.this,)

class WSCngbasePtr(WSCngbase):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCngbase
_mpfc.WSCngbase_swigregister(WSCngbasePtr)

class WSCvlabel(WSCnwbase):
    __swig_setmethods__ = {}
    for _s in [WSCnwbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvlabel, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCnwbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvlabel, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvlabel,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvlabel):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvlabel instance at %s>" % (self.this,)

class WSCvlabelPtr(WSCvlabel):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvlabel
_mpfc.WSCvlabel_swigregister(WSCvlabelPtr)

class WSCvbtn(WSCvlabel):
    __swig_setmethods__ = {}
    for _s in [WSCvlabel]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvbtn, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvlabel]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvbtn, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvbtn,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvbtn):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onKey(*args): return apply(_mpfc.WSCvbtn_onKey,args)
    def onActivate(*args): return apply(_mpfc.WSCvbtn_onActivate,args)
    def setDrawFocusBorder(*args): return apply(_mpfc.WSCvbtn_setDrawFocusBorder,args)
    def __repr__(self):
        return "<C WSCvbtn instance at %s>" % (self.this,)

class WSCvbtnPtr(WSCvbtn):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvbtn
_mpfc.WSCvbtn_swigregister(WSCvbtnPtr)

class WSCvfbtn(WSCvbtn):
    __swig_setmethods__ = {}
    for _s in [WSCvbtn]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvfbtn, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvbtn]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvfbtn, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvfbtn,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvfbtn):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvfbtn instance at %s>" % (self.this,)

class WSCvfbtnPtr(WSCvfbtn):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvfbtn
_mpfc.WSCvfbtn_swigregister(WSCvfbtnPtr)

class WSCvklabel(WSCvlabel):
    __swig_setmethods__ = {}
    for _s in [WSCvlabel]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvklabel, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvlabel]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvklabel, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvklabel,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvklabel):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvklabel instance at %s>" % (self.this,)

class WSCvklabelPtr(WSCvklabel):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvklabel
_mpfc.WSCvklabel_swigregister(WSCvklabelPtr)

class WSCvkflabel(WSCvklabel):
    __swig_setmethods__ = {}
    for _s in [WSCvklabel]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvkflabel, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvklabel]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvkflabel, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvkflabel,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvkflabel):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvkflabel instance at %s>" % (self.this,)

class WSCvkflabelPtr(WSCvkflabel):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvkflabel
_mpfc.WSCvkflabel_swigregister(WSCvkflabelPtr)

class WSDkeyboard(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSDkeyboard, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSDkeyboard, name)
    def setKey(*args): return apply(_mpfc.WSDkeyboard_setKey,args)
    def getKey(*args): return apply(_mpfc.WSDkeyboard_getKey,args)
    def withShift(*args): return apply(_mpfc.WSDkeyboard_withShift,args)
    def withLock(*args): return apply(_mpfc.WSDkeyboard_withLock,args)
    def withCntl(*args): return apply(_mpfc.WSDkeyboard_withCntl,args)
    def withAlt(*args): return apply(_mpfc.WSDkeyboard_withAlt,args)
    def isCursorKey(*args): return apply(_mpfc.WSDkeyboard_isCursorKey,args)
    def isFuncKey(*args): return apply(_mpfc.WSDkeyboard_isFuncKey,args)
    def isTtyFunction(*args): return apply(_mpfc.WSDkeyboard_isTtyFunction,args)
    def getFepStatus(*args): return apply(_mpfc.WSDkeyboard_getFepStatus,args)
    def getEnableFep(*args): return apply(_mpfc.WSDkeyboard_getEnableFep,args)
    def isPressed(*args): return apply(_mpfc.WSDkeyboard_isPressed,args)
    def setWithShift(*args): return apply(_mpfc.WSDkeyboard_setWithShift,args)
    def setWithLock(*args): return apply(_mpfc.WSDkeyboard_setWithLock,args)
    def setWithCntl(*args): return apply(_mpfc.WSDkeyboard_setWithCntl,args)
    def setWithAlt(*args): return apply(_mpfc.WSDkeyboard_setWithAlt,args)
    def setIsCursorKey(*args): return apply(_mpfc.WSDkeyboard_setIsCursorKey,args)
    def setIsFuncKey(*args): return apply(_mpfc.WSDkeyboard_setIsFuncKey,args)
    def setIsTtyFunction(*args): return apply(_mpfc.WSDkeyboard_setIsTtyFunction,args)
    def setIsPressed(*args): return apply(_mpfc.WSDkeyboard_setIsPressed,args)
    def getTextString(*args): return apply(_mpfc.WSDkeyboard_getTextString,args)
    def getText(*args): return apply(_mpfc.WSDkeyboard_getText,args)
    def setSelectedString(*args): return apply(_mpfc.WSDkeyboard_setSelectedString,args)
    def getSelectedString(*args): return apply(_mpfc.WSDkeyboard_getSelectedString,args)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSDkeyboard,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSDkeyboard):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSDkeyboard instance at %s>" % (self.this,)

class WSDkeyboardPtr(WSDkeyboard):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSDkeyboard
_mpfc.WSDkeyboard_swigregister(WSDkeyboardPtr)

WSGIappKeyboard = _mpfc.WSGIappKeyboard

class WSCvifield(WSCvlabel):
    __swig_setmethods__ = {}
    for _s in [WSCvlabel]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvifield, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvlabel]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvifield, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvifield,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvifield):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onCursorBlink(*args): return apply(_mpfc.WSCvifield_onCursorBlink,args)
    def onKeyHook(*args): return apply(_mpfc.WSCvifield_onKeyHook,args)
    def onKeyInput(*args): return apply(_mpfc.WSCvifield_onKeyInput,args)
    def onKey(*args): return apply(_mpfc.WSCvifield_onKey,args)
    def onActivate(*args): return apply(_mpfc.WSCvifield_onActivate,args)
    def onValueChange(*args): return apply(_mpfc.WSCvifield_onValueChange,args)
    def onSelectionChange(*args): return apply(_mpfc.WSCvifield_onSelectionChange,args)
    def onVisibleChange(*args): return apply(_mpfc.WSCvifield_onVisibleChange,args)
    def onParentVisibleChange(*args): return apply(_mpfc.WSCvifield_onParentVisibleChange,args)
    def setCursorFore(*args): return apply(_mpfc.WSCvifield_setCursorFore,args)
    def getCursorFore(*args): return apply(_mpfc.WSCvifield_getCursorFore,args)
    def setCurPos(*args): return apply(_mpfc.WSCvifield_setCurPos,args)
    def replaceSelectedString(*args): return apply(_mpfc.WSCvifield_replaceSelectedString,args)
    def getSelectedString(*args): return apply(_mpfc.WSCvifield_getSelectedString,args)
    def deleteSelectedString(*args): return apply(_mpfc.WSCvifield_deleteSelectedString,args)
    def setSelect(*args): return apply(_mpfc.WSCvifield_setSelect,args)
    def getSelectedPos(*args): return apply(_mpfc.WSCvifield_getSelectedPos,args)
    def getString(*args): return apply(_mpfc.WSCvifield_getString,args)
    def addString(*args): return apply(_mpfc.WSCvifield_addString,args)
    def __repr__(self):
        return "<C WSCvifield instance at %s>" % (self.this,)

class WSCvifieldPtr(WSCvifield):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvifield
_mpfc.WSCvifield_swigregister(WSCvifieldPtr)

class WSCvkslabel(WSCvifield):
    __swig_setmethods__ = {}
    for _s in [WSCvifield]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvkslabel, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvifield]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvkslabel, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvkslabel,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvkslabel):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvkslabel instance at %s>" % (self.this,)

class WSCvkslabelPtr(WSCvkslabel):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvkslabel
_mpfc.WSCvkslabel_swigregister(WSCvkslabelPtr)

class WSCvmifield(WSCvifield):
    __swig_setmethods__ = {}
    for _s in [WSCvifield]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvmifield, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvifield]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvmifield, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvmifield,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvmifield):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvmifield instance at %s>" % (self.this,)

class WSCvmifieldPtr(WSCvmifield):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvmifield
_mpfc.WSCvmifield_swigregister(WSCvmifieldPtr)

class WSCvpifield(WSCvifield):
    __swig_setmethods__ = {}
    for _s in [WSCvifield]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvpifield, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvifield]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvpifield, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvpifield,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvpifield):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvpifield instance at %s>" % (self.this,)

class WSCvpifieldPtr(WSCvpifield):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvpifield
_mpfc.WSCvpifield_swigregister(WSCvpifieldPtr)

class WSCtextField(WSCform):
    __swig_setmethods__ = {}
    for _s in [WSCform]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCtextField, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCform]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCtextField, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCtextField,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCtextField):
        try:
            if self.thisown: destroy(self)
        except: pass
    def addString(*args): return apply(_mpfc.WSCtextField_addString,args)
    def replaceSelectedString(*args): return apply(_mpfc.WSCtextField_replaceSelectedString,args)
    def getSelectedString(*args): return apply(_mpfc.WSCtextField_getSelectedString,args)
    def getString(*args): return apply(_mpfc.WSCtextField_getString,args)
    def deleteSelectedString(*args): return apply(_mpfc.WSCtextField_deleteSelectedString,args)
    def setSelect(*args): return apply(_mpfc.WSCtextField_setSelect,args)
    def getSelectedPos(*args): return apply(_mpfc.WSCtextField_getSelectedPos,args)
    def getLines(*args): return apply(_mpfc.WSCtextField_getLines,args)
    def getTopLine(*args): return apply(_mpfc.WSCtextField_getTopLine,args)
    def setTopLine(*args): return apply(_mpfc.WSCtextField_setTopLine,args)
    def getBottomLine(*args): return apply(_mpfc.WSCtextField_getBottomLine,args)
    def setBottomLine(*args): return apply(_mpfc.WSCtextField_setBottomLine,args)
    def getTextFrame(*args): return apply(_mpfc.WSCtextField_getTextFrame,args)
    def __repr__(self):
        return "<C WSCtextField instance at %s>" % (self.this,)

class WSCtextFieldPtr(WSCtextField):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCtextField
_mpfc.WSCtextField_swigregister(WSCtextFieldPtr)

class WSCvarrow(WSCvbtn):
    __swig_setmethods__ = {}
    for _s in [WSCvbtn]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvarrow, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvbtn]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvarrow, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvarrow,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvarrow):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvarrow instance at %s>" % (self.this,)

class WSCvarrowPtr(WSCvarrow):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvarrow
_mpfc.WSCvarrow_swigregister(WSCvarrowPtr)

class WSCvscrBar(WSCnwbase):
    __swig_setmethods__ = {}
    for _s in [WSCnwbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvscrBar, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCnwbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvscrBar, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvscrBar,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvscrBar):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return apply(_mpfc.WSCvscrBar_onActivate,args)
    def onBegin(*args): return apply(_mpfc.WSCvscrBar_onBegin,args)
    def onEnd(*args): return apply(_mpfc.WSCvscrBar_onEnd,args)
    def onIncrement(*args): return apply(_mpfc.WSCvscrBar_onIncrement,args)
    def onDecrement(*args): return apply(_mpfc.WSCvscrBar_onDecrement,args)
    def onPageIncrement(*args): return apply(_mpfc.WSCvscrBar_onPageIncrement,args)
    def onPageDecrement(*args): return apply(_mpfc.WSCvscrBar_onPageDecrement,args)
    def onValueChange(*args): return apply(_mpfc.WSCvscrBar_onValueChange,args)
    def getMaxSlideValue(*args): return apply(_mpfc.WSCvscrBar_getMaxSlideValue,args)
    def __repr__(self):
        return "<C WSCvscrBar instance at %s>" % (self.this,)

class WSCvscrBarPtr(WSCvscrBar):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvscrBar
_mpfc.WSCvscrBar_swigregister(WSCvscrBarPtr)

class WSCvpolyAttr(WSCnwbase):
    __swig_setmethods__ = {}
    for _s in [WSCnwbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvpolyAttr, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCnwbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvpolyAttr, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvpolyAttr,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvpolyAttr):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvpolyAttr instance at %s>" % (self.this,)

class WSCvpolyAttrPtr(WSCvpolyAttr):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvpolyAttr
_mpfc.WSCvpolyAttr_swigregister(WSCvpolyAttrPtr)

class WSCvmeter(WSCvpolyAttr):
    __swig_setmethods__ = {}
    for _s in [WSCvpolyAttr]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvmeter, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvpolyAttr]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvmeter, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvmeter,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvmeter):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvmeter instance at %s>" % (self.this,)

class WSCvmeterPtr(WSCvmeter):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvmeter
_mpfc.WSCvmeter_swigregister(WSCvmeterPtr)

class WSCvclock(WSCvlabel):
    __swig_setmethods__ = {}
    for _s in [WSCvlabel]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvclock, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvlabel]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvclock, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvclock,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvclock):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvclock instance at %s>" % (self.this,)

class WSCvclockPtr(WSCvclock):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvclock
_mpfc.WSCvclock_swigregister(WSCvclockPtr)

class WSCvslider(WSCnwbase):
    __swig_setmethods__ = {}
    for _s in [WSCnwbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvslider, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCnwbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvslider, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvslider,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvslider):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return apply(_mpfc.WSCvslider_onActivate,args)
    def onDragInterval(*args): return apply(_mpfc.WSCvslider_onDragInterval,args)
    def onValueChange(*args): return apply(_mpfc.WSCvslider_onValueChange,args)
    def __repr__(self):
        return "<C WSCvslider instance at %s>" % (self.this,)

class WSCvsliderPtr(WSCvslider):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvslider
_mpfc.WSCvslider_swigregister(WSCvsliderPtr)

class WSCpulldownMenu(WSCvlabel):
    __swig_setmethods__ = {}
    for _s in [WSCvlabel]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCpulldownMenu, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvlabel]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCpulldownMenu, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCpulldownMenu,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCpulldownMenu):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return apply(_mpfc.WSCpulldownMenu_onActivate,args)
    def setItemSensitive(*args): return apply(_mpfc.WSCpulldownMenu_setItemSensitive,args)
    def setValueSensitive(*args): return apply(_mpfc.WSCpulldownMenu_setValueSensitive,args)
    def getItemSensitive(*args): return apply(_mpfc.WSCpulldownMenu_getItemSensitive,args)
    def getValue(*args): return apply(_mpfc.WSCpulldownMenu_getValue,args)
    def getItems(*args): return apply(_mpfc.WSCpulldownMenu_getItems,args)
    def beginCascade(*args): return apply(_mpfc.WSCpulldownMenu_beginCascade,args)
    def addItem(*args): return apply(_mpfc.WSCpulldownMenu_addItem,args)
    def endCascade(*args): return apply(_mpfc.WSCpulldownMenu_endCascade,args)
    def __repr__(self):
        return "<C WSCpulldownMenu instance at %s>" % (self.this,)

class WSCpulldownMenuPtr(WSCpulldownMenu):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCpulldownMenu
_mpfc.WSCpulldownMenu_swigregister(WSCpulldownMenuPtr)

class WSCcomboBox(WSCform):
    __swig_setmethods__ = {}
    for _s in [WSCform]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCcomboBox, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCform]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCcomboBox, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCcomboBox,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCcomboBox):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return apply(_mpfc.WSCcomboBox_onActivate,args)
    def __repr__(self):
        return "<C WSCcomboBox instance at %s>" % (self.this,)

class WSCcomboBoxPtr(WSCcomboBox):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCcomboBox
_mpfc.WSCcomboBox_swigregister(WSCcomboBoxPtr)

class WSCoption(WSCform):
    __swig_setmethods__ = {}
    for _s in [WSCform]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCoption, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCform]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCoption, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCoption,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCoption):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return apply(_mpfc.WSCoption_onActivate,args)
    def onValueChange(*args): return apply(_mpfc.WSCoption_onValueChange,args)
    def setItemSensitive(*args): return apply(_mpfc.WSCoption_setItemSensitive,args)
    def setSelectValue(*args): return apply(_mpfc.WSCoption_setSelectValue,args)
    def getValue(*args): return apply(_mpfc.WSCoption_getValue,args)
    def getItemValue(*args): return apply(_mpfc.WSCoption_getItemValue,args)
    def getSelectStatus(*args): return apply(_mpfc.WSCoption_getSelectStatus,args)
    def getItemNum(*args): return apply(_mpfc.WSCoption_getItemNum,args)
    def getItems(*args): return apply(_mpfc.WSCoption_getItems,args)
    def __repr__(self):
        return "<C WSCoption instance at %s>" % (self.this,)

class WSCoptionPtr(WSCoption):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCoption
_mpfc.WSCoption_swigregister(WSCoptionPtr)

class WSCgrid(WSCform):
    __swig_setmethods__ = {}
    for _s in [WSCform]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCgrid, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCform]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCgrid, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCgrid,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCgrid):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onInputFixed(*args): return apply(_mpfc.WSCgrid_onInputFixed,args)
    def getCellNo(*args): return apply(_mpfc.WSCgrid_getCellNo,args)
    def getHColumns(*args): return apply(_mpfc.WSCgrid_getHColumns,args)
    def getVColumns(*args): return apply(_mpfc.WSCgrid_getVColumns,args)
    def getItem(*args): return apply(_mpfc.WSCgrid_getItem,args)
    def setItem(*args): return apply(_mpfc.WSCgrid_setItem,args)
    def getItemAlignment(*args): return apply(_mpfc.WSCgrid_getItemAlignment,args)
    def setCellForeColor(*args): return apply(_mpfc.WSCgrid_setCellForeColor,args)
    def setCellBackColor(*args): return apply(_mpfc.WSCgrid_setCellBackColor,args)
    def setCellInputStatus(*args): return apply(_mpfc.WSCgrid_setCellInputStatus,args)
    def getCellInputStatus(*args): return apply(_mpfc.WSCgrid_getCellInputStatus,args)
    def getFocusedCell(*args): return apply(_mpfc.WSCgrid_getFocusedCell,args)
    def setFocusedCell(*args): return apply(_mpfc.WSCgrid_setFocusedCell,args)
    def __repr__(self):
        return "<C WSCgrid instance at %s>" % (self.this,)

class WSCgridPtr(WSCgrid):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCgrid
_mpfc.WSCgrid_swigregister(WSCgridPtr)

class WSCvimage(WSCnwbase):
    __swig_setmethods__ = {}
    for _s in [WSCnwbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvimage, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCnwbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvimage, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvimage,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvimage):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvimage instance at %s>" % (self.this,)

class WSCvimagePtr(WSCvimage):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvimage
_mpfc.WSCvimage_swigregister(WSCvimagePtr)

class WSCvrect(WSCvpolyAttr):
    __swig_setmethods__ = {}
    for _s in [WSCvpolyAttr]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvrect, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvpolyAttr]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvrect, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvrect,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvrect):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvrect instance at %s>" % (self.this,)

class WSCvrectPtr(WSCvrect):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvrect
_mpfc.WSCvrect_swigregister(WSCvrectPtr)

class WSCvarc(WSCvpolyAttr):
    __swig_setmethods__ = {}
    for _s in [WSCvpolyAttr]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvarc, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvpolyAttr]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvarc, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvarc,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvarc):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvarc instance at %s>" % (self.this,)

class WSCvarcPtr(WSCvarc):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvarc
_mpfc.WSCvarc_swigregister(WSCvarcPtr)

class WSCvpoly(WSCvpolyAttr):
    __swig_setmethods__ = {}
    for _s in [WSCvpolyAttr]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvpoly, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvpolyAttr]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvpoly, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvpoly,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvpoly):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvpoly instance at %s>" % (self.this,)

class WSCvpolyPtr(WSCvpoly):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvpoly
_mpfc.WSCvpoly_swigregister(WSCvpolyPtr)

class WSCvline(WSCnwbase):
    __swig_setmethods__ = {}
    for _s in [WSCnwbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvline, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCnwbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvline, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvline,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvline):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvline instance at %s>" % (self.this,)

class WSCvlinePtr(WSCvline):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvline
_mpfc.WSCvline_swigregister(WSCvlinePtr)

class WSDimage(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSDimage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSDimage, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSDimage,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSDimage):
        try:
            if self.thisown: destroy(self)
        except: pass
    def destroyImage(*args): return apply(_mpfc.WSDimage_destroyImage,args)
    def getImageWidth(*args): return apply(_mpfc.WSDimage_getImageWidth,args)
    def getImageHeight(*args): return apply(_mpfc.WSDimage_getImageHeight,args)
    def getReady(*args): return apply(_mpfc.WSDimage_getReady,args)
    def __repr__(self):
        return "<C WSDimage instance at %s>" % (self.this,)

class WSDimagePtr(WSDimage):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSDimage
_mpfc.WSDimage_swigregister(WSDimagePtr)

class WSCvdrawingArea(WSCnwbase):
    __swig_setmethods__ = {}
    for _s in [WSCnwbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvdrawingArea, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCnwbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvdrawingArea, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvdrawingArea,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvdrawingArea):
        try:
            if self.thisown: destroy(self)
        except: pass
    def beginDraw(*args): return apply(_mpfc.WSCvdrawingArea_beginDraw,args)
    def endDraw(*args): return apply(_mpfc.WSCvdrawingArea_endDraw,args)
    def setForeColor(*args): return apply(_mpfc.WSCvdrawingArea_setForeColor,args)
    def setBackColor(*args): return apply(_mpfc.WSCvdrawingArea_setBackColor,args)
    def setLineWidth(*args): return apply(_mpfc.WSCvdrawingArea_setLineWidth,args)
    def setLineDashType(*args): return apply(_mpfc.WSCvdrawingArea_setLineDashType,args)
    def setHatchPattern(*args): return apply(_mpfc.WSCvdrawingArea_setHatchPattern,args)
    def setRegion(*args): return apply(_mpfc.WSCvdrawingArea_setRegion,args)
    def drawArc(*args): return apply(_mpfc.WSCvdrawingArea_drawArc,args)
    def drawFillArc(*args): return apply(_mpfc.WSCvdrawingArea_drawFillArc,args)
    def drawLine(*args): return apply(_mpfc.WSCvdrawingArea_drawLine,args)
    def drawLines(*args): return apply(_mpfc.WSCvdrawingArea_drawLines,args)
    def drawRect(*args): return apply(_mpfc.WSCvdrawingArea_drawRect,args)
    def drawFillRect(*args): return apply(_mpfc.WSCvdrawingArea_drawFillRect,args)
    def drawRects(*args): return apply(_mpfc.WSCvdrawingArea_drawRects,args)
    def drawFillRects(*args): return apply(_mpfc.WSCvdrawingArea_drawFillRects,args)
    def drawPoly(*args): return apply(_mpfc.WSCvdrawingArea_drawPoly,args)
    def drawFillPoly(*args): return apply(_mpfc.WSCvdrawingArea_drawFillPoly,args)
    def drawGradation(*args): return apply(_mpfc.WSCvdrawingArea_drawGradation,args)
    def drawImage(*args): return apply(_mpfc.WSCvdrawingArea_drawImage,args)
    def drawStretchedImage(*args): return apply(_mpfc.WSCvdrawingArea_drawStretchedImage,args)
    def drawString(*args): return apply(_mpfc.WSCvdrawingArea_drawString,args)
    def drawFillString(*args): return apply(_mpfc.WSCvdrawingArea_drawFillString,args)
    def __repr__(self):
        return "<C WSCvdrawingArea instance at %s>" % (self.this,)

class WSCvdrawingAreaPtr(WSCvdrawingArea):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvdrawingArea
_mpfc.WSCvdrawingArea_swigregister(WSCvdrawingAreaPtr)

class WSCvbarGraph(WSCnwbase):
    __swig_setmethods__ = {}
    for _s in [WSCnwbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvbarGraph, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCnwbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvbarGraph, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvbarGraph,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvbarGraph):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvbarGraph instance at %s>" % (self.this,)

class WSCvbarGraphPtr(WSCvbarGraph):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvbarGraph
_mpfc.WSCvbarGraph_swigregister(WSCvbarGraphPtr)

class WSCvlineGraph(WSCnwbase):
    __swig_setmethods__ = {}
    for _s in [WSCnwbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvlineGraph, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCnwbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvlineGraph, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvlineGraph,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvlineGraph):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvlineGraph instance at %s>" % (self.this,)

class WSCvlineGraphPtr(WSCvlineGraph):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvlineGraph
_mpfc.WSCvlineGraph_swigregister(WSCvlineGraphPtr)

class WSCvgraphScale(WSCnwbase):
    __swig_setmethods__ = {}
    for _s in [WSCnwbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvgraphScale, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCnwbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvgraphScale, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvgraphScale,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvgraphScale):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvgraphScale instance at %s>" % (self.this,)

class WSCvgraphScalePtr(WSCvgraphScale):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvgraphScale
_mpfc.WSCvgraphScale_swigregister(WSCvgraphScalePtr)

class WSCvgraphMatrix(WSCnwbase):
    __swig_setmethods__ = {}
    for _s in [WSCnwbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvgraphMatrix, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCnwbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvgraphMatrix, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvgraphMatrix,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvgraphMatrix):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvgraphMatrix instance at %s>" % (self.this,)

class WSCvgraphMatrixPtr(WSCvgraphMatrix):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvgraphMatrix
_mpfc.WSCvgraphMatrix_swigregister(WSCvgraphMatrixPtr)

class WSCvtimer(WSCngbase):
    __swig_setmethods__ = {}
    for _s in [WSCngbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvtimer, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCngbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvtimer, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvtimer,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvtimer):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return apply(_mpfc.WSCvtimer_onActivate,args)
    def __repr__(self):
        return "<C WSCvtimer instance at %s>" % (self.this,)

class WSCvtimerPtr(WSCvtimer):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvtimer
_mpfc.WSCvtimer_swigregister(WSCvtimerPtr)

class WSCvspace(WSCngbase):
    __swig_setmethods__ = {}
    for _s in [WSCngbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvspace, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCngbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvspace, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvspace,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvspace):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvspace instance at %s>" % (self.this,)

class WSCvspacePtr(WSCvspace):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvspace
_mpfc.WSCvspace_swigregister(WSCvspacePtr)

class WSCvballoonHelp(WSCngbase):
    __swig_setmethods__ = {}
    for _s in [WSCngbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvballoonHelp, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCngbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvballoonHelp, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvballoonHelp,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvballoonHelp):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvballoonHelp instance at %s>" % (self.this,)

class WSCvballoonHelpPtr(WSCvballoonHelp):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvballoonHelp
_mpfc.WSCvballoonHelp_swigregister(WSCvballoonHelpPtr)

class WSCvcsocket(WSCngbase):
    __swig_setmethods__ = {}
    for _s in [WSCngbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvcsocket, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCngbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvcsocket, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvcsocket,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvcsocket):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return apply(_mpfc.WSCvcsocket_onActivate,args)
    def read(*args): return apply(_mpfc.WSCvcsocket_read,args)
    def write(*args): return apply(_mpfc.WSCvcsocket_write,args)
    def execX(*args): return apply(_mpfc.WSCvcsocket_execX,args)
    def setBindAddr(*args): return apply(_mpfc.WSCvcsocket_setBindAddr,args)
    def getBindAddr(*args): return apply(_mpfc.WSCvcsocket_getBindAddr,args)
    def getErrorMessage(*args): return apply(_mpfc.WSCvcsocket_getErrorMessage,args)
    def __repr__(self):
        return "<C WSCvcsocket instance at %s>" % (self.this,)

class WSCvcsocketPtr(WSCvcsocket):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvcsocket
_mpfc.WSCvcsocket_swigregister(WSCvcsocketPtr)

class WSCvssocket(WSCngbase):
    __swig_setmethods__ = {}
    for _s in [WSCngbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvssocket, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCngbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvssocket, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvssocket,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvssocket):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return apply(_mpfc.WSCvssocket_onActivate,args)
    def read(*args): return apply(_mpfc.WSCvssocket_read,args)
    def write(*args): return apply(_mpfc.WSCvssocket_write,args)
    def getDestAddr(*args): return apply(_mpfc.WSCvssocket_getDestAddr,args)
    def getErrorMessage(*args): return apply(_mpfc.WSCvssocket_getErrorMessage,args)
    def __repr__(self):
        return "<C WSCvssocket instance at %s>" % (self.this,)

class WSCvssocketPtr(WSCvssocket):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvssocket
_mpfc.WSCvssocket_swigregister(WSCvssocketPtr)

class WSCvudpsocket(WSCngbase):
    __swig_setmethods__ = {}
    for _s in [WSCngbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvudpsocket, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCngbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvudpsocket, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvudpsocket,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvudpsocket):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return apply(_mpfc.WSCvudpsocket_onActivate,args)
    def read(*args): return apply(_mpfc.WSCvudpsocket_read,args)
    def write(*args): return apply(_mpfc.WSCvudpsocket_write,args)
    def getDestAddr(*args): return apply(_mpfc.WSCvudpsocket_getDestAddr,args)
    def setBindAddr(*args): return apply(_mpfc.WSCvudpsocket_setBindAddr,args)
    def getBindAddr(*args): return apply(_mpfc.WSCvudpsocket_getBindAddr,args)
    def start(*args): return apply(_mpfc.WSCvudpsocket_start,args)
    def stop(*args): return apply(_mpfc.WSCvudpsocket_stop,args)
    def getErrorMessage(*args): return apply(_mpfc.WSCvudpsocket_getErrorMessage,args)
    def __repr__(self):
        return "<C WSCvudpsocket instance at %s>" % (self.this,)

class WSCvudpsocketPtr(WSCvudpsocket):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvudpsocket
_mpfc.WSCvudpsocket_swigregister(WSCvudpsocketPtr)

class WSCvremoteClient(WSCngbase):
    __swig_setmethods__ = {}
    for _s in [WSCngbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvremoteClient, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCngbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvremoteClient, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvremoteClient,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvremoteClient):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvremoteClient instance at %s>" % (self.this,)

class WSCvremoteClientPtr(WSCvremoteClient):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvremoteClient
_mpfc.WSCvremoteClient_swigregister(WSCvremoteClientPtr)

class WSCvremoteServer(WSCngbase):
    __swig_setmethods__ = {}
    for _s in [WSCngbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvremoteServer, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCngbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvremoteServer, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvremoteServer,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvremoteServer):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvremoteServer instance at %s>" % (self.this,)

class WSCvremoteServerPtr(WSCvremoteServer):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvremoteServer
_mpfc.WSCvremoteServer_swigregister(WSCvremoteServerPtr)

class WSCvdb(WSCngbase):
    __swig_setmethods__ = {}
    for _s in [WSCngbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvdb, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCngbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvdb, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvdb,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvdb):
        try:
            if self.thisown: destroy(self)
        except: pass
    def open(*args): return apply(_mpfc.WSCvdb_open,args)
    def close(*args): return apply(_mpfc.WSCvdb_close,args)
    def isOpen(*args): return apply(_mpfc.WSCvdb_isOpen,args)
    def sqlExecute(*args): return apply(_mpfc.WSCvdb_sqlExecute,args)
    def beginTran(*args): return apply(_mpfc.WSCvdb_beginTran,args)
    def commitTran(*args): return apply(_mpfc.WSCvdb_commitTran,args)
    def abortTran(*args): return apply(_mpfc.WSCvdb_abortTran,args)
    def getErrorMessage(*args): return apply(_mpfc.WSCvdb_getErrorMessage,args)
    def __repr__(self):
        return "<C WSCvdb instance at %s>" % (self.this,)

class WSCvdbPtr(WSCvdb):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvdb
_mpfc.WSCvdb_swigregister(WSCvdbPtr)

class WSCwindow(WSCbase):
    __swig_setmethods__ = {}
    for _s in [WSCbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCwindow, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCwindow, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCwindow,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCwindow):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCwindow instance at %s>" % (self.this,)

class WSCwindowPtr(WSCwindow):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCwindow
_mpfc.WSCwindow_swigregister(WSCwindowPtr)

class WSCmainWindow(WSCwindow):
    __swig_setmethods__ = {}
    for _s in [WSCwindow]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCmainWindow, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCwindow]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCmainWindow, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCmainWindow,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCmainWindow):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCmainWindow instance at %s>" % (self.this,)

class WSCmainWindowPtr(WSCmainWindow):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCmainWindow
_mpfc.WSCmainWindow_swigregister(WSCmainWindowPtr)

class WSCbaseDialog(WSCwindow):
    __swig_setmethods__ = {}
    for _s in [WSCwindow]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCbaseDialog, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCwindow]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCbaseDialog, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCbaseDialog,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCbaseDialog):
        try:
            if self.thisown: destroy(self)
        except: pass
    def getStatus(*args): return apply(_mpfc.WSCbaseDialog_getStatus,args)
    def popup(*args): return apply(_mpfc.WSCbaseDialog_popup,args)
    def __repr__(self):
        return "<C WSCbaseDialog instance at %s>" % (self.this,)

class WSCbaseDialogPtr(WSCbaseDialog):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCbaseDialog
_mpfc.WSCbaseDialog_swigregister(WSCbaseDialogPtr)

class WSCdialog(WSCbaseDialog):
    __swig_setmethods__ = {}
    for _s in [WSCbaseDialog]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCdialog, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCbaseDialog]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCdialog, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCdialog,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCdialog):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCdialog instance at %s>" % (self.this,)

class WSCdialogPtr(WSCdialog):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCdialog
_mpfc.WSCdialog_swigregister(WSCdialogPtr)

class WSCmessageDialog(WSCbaseDialog):
    __swig_setmethods__ = {}
    for _s in [WSCbaseDialog]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCmessageDialog, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCbaseDialog]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCmessageDialog, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCmessageDialog,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCmessageDialog):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCmessageDialog instance at %s>" % (self.this,)

class WSCmessageDialogPtr(WSCmessageDialog):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCmessageDialog
_mpfc.WSCmessageDialog_swigregister(WSCmessageDialogPtr)

class WSCinputDialog(WSCbaseDialog):
    __swig_setmethods__ = {}
    for _s in [WSCbaseDialog]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCinputDialog, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCbaseDialog]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCinputDialog, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCinputDialog,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCinputDialog):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCinputDialog instance at %s>" % (self.this,)

class WSCinputDialogPtr(WSCinputDialog):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCinputDialog
_mpfc.WSCinputDialog_swigregister(WSCinputDialogPtr)

class WSCwizardDialog(WSCbaseDialog):
    __swig_setmethods__ = {}
    for _s in [WSCbaseDialog]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCwizardDialog, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCbaseDialog]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCwizardDialog, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCwizardDialog,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCwizardDialog):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCwizardDialog instance at %s>" % (self.this,)

class WSCwizardDialogPtr(WSCwizardDialog):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCwizardDialog
_mpfc.WSCwizardDialog_swigregister(WSCwizardDialogPtr)

class WSCfileSelect(WSCbaseDialog):
    __swig_setmethods__ = {}
    for _s in [WSCbaseDialog]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCfileSelect, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCbaseDialog]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCfileSelect, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCfileSelect,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCfileSelect):
        try:
            if self.thisown: destroy(self)
        except: pass
    def getFileName(*args): return apply(_mpfc.WSCfileSelect_getFileName,args)
    def __repr__(self):
        return "<C WSCfileSelect instance at %s>" % (self.this,)

class WSCfileSelectPtr(WSCfileSelect):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCfileSelect
_mpfc.WSCfileSelect_swigregister(WSCfileSelectPtr)

WSGIappFileSelect = _mpfc.WSGIappFileSelect

class WSCworkingDialog(WSCbaseDialog):
    __swig_setmethods__ = {}
    for _s in [WSCbaseDialog]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCworkingDialog, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCbaseDialog]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCworkingDialog, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCworkingDialog,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCworkingDialog):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCworkingDialog instance at %s>" % (self.this,)

class WSCworkingDialogPtr(WSCworkingDialog):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCworkingDialog
_mpfc.WSCworkingDialog_swigregister(WSCworkingDialogPtr)

class WSCindexForm(WSCform):
    __swig_setmethods__ = {}
    for _s in [WSCform]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCindexForm, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCform]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCindexForm, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCindexForm,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCindexForm):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCindexForm instance at %s>" % (self.this,)

class WSCindexFormPtr(WSCindexForm):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCindexForm
_mpfc.WSCindexForm_swigregister(WSCindexFormPtr)

class WSCsform(WSCform):
    __swig_setmethods__ = {}
    for _s in [WSCform]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCsform, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCform]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCsform, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCsform,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCsform):
        try:
            if self.thisown: destroy(self)
        except: pass
    def getStatus(*args): return apply(_mpfc.WSCsform_getStatus,args)
    def setAdjustChildren(*args): return apply(_mpfc.WSCsform_setAdjustChildren,args)
    def setManaged(*args): return apply(_mpfc.WSCsform_setManaged,args)
    def __repr__(self):
        return "<C WSCsform instance at %s>" % (self.this,)

class WSCsformPtr(WSCsform):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCsform
_mpfc.WSCsform_swigregister(WSCsformPtr)

class WSCvtoggle(WSCvlabel):
    __swig_setmethods__ = {}
    for _s in [WSCvlabel]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvtoggle, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvlabel]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvtoggle, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvtoggle,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvtoggle):
        try:
            if self.thisown: destroy(self)
        except: pass
    def setStatus(*args): return apply(_mpfc.WSCvtoggle_setStatus,args)
    def getStatus(*args): return apply(_mpfc.WSCvtoggle_getStatus,args)
    def getGroupValue(*args): return apply(_mpfc.WSCvtoggle_getGroupValue,args)
    def setGroupValue(*args): return apply(_mpfc.WSCvtoggle_setGroupValue,args)
    def clearGroupValue(*args): return apply(_mpfc.WSCvtoggle_clearGroupValue,args)
    def __repr__(self):
        return "<C WSCvtoggle instance at %s>" % (self.this,)

class WSCvtogglePtr(WSCvtoggle):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvtoggle
_mpfc.WSCvtoggle_swigregister(WSCvtogglePtr)

class WSCvradio(WSCvtoggle):
    __swig_setmethods__ = {}
    for _s in [WSCvtoggle]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvradio, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvtoggle]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvradio, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvradio,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvradio):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvradio instance at %s>" % (self.this,)

class WSCvradioPtr(WSCvradio):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvradio
_mpfc.WSCvradio_swigregister(WSCvradioPtr)

class WSCradioGroup(WSCform):
    __swig_setmethods__ = {}
    for _s in [WSCform]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCradioGroup, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCform]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCradioGroup, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCradioGroup,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCradioGroup):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onValueChange(*args): return apply(_mpfc.WSCradioGroup_onValueChange,args)
    def setItemSensitive(*args): return apply(_mpfc.WSCradioGroup_setItemSensitive,args)
    def getItemSensitive(*args): return apply(_mpfc.WSCradioGroup_getItemSensitive,args)
    def getItem(*args): return apply(_mpfc.WSCradioGroup_getItem,args)
    def __repr__(self):
        return "<C WSCradioGroup instance at %s>" % (self.this,)

class WSCradioGroupPtr(WSCradioGroup):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCradioGroup
_mpfc.WSCradioGroup_swigregister(WSCradioGroupPtr)

class WSCcheckGroup(WSCradioGroup):
    __swig_setmethods__ = {}
    for _s in [WSCradioGroup]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCcheckGroup, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCradioGroup]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCcheckGroup, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCcheckGroup,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCcheckGroup):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCcheckGroup instance at %s>" % (self.this,)

class WSCcheckGroupPtr(WSCcheckGroup):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCcheckGroup
_mpfc.WSCcheckGroup_swigregister(WSCcheckGroupPtr)

class WSCvertForm(WSCform):
    __swig_setmethods__ = {}
    for _s in [WSCform]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCvertForm, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCform]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCvertForm, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCvertForm,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCvertForm):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCvertForm instance at %s>" % (self.this,)

class WSCvertFormPtr(WSCvertForm):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCvertForm
_mpfc.WSCvertForm_swigregister(WSCvertFormPtr)

class WSChorzForm(WSCvertForm):
    __swig_setmethods__ = {}
    for _s in [WSCvertForm]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSChorzForm, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCvertForm]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSChorzForm, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSChorzForm,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSChorzForm):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSChorzForm instance at %s>" % (self.this,)

class WSChorzFormPtr(WSChorzForm):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSChorzForm
_mpfc.WSChorzForm_swigregister(WSChorzFormPtr)

class WSCmenuArea(WSCform):
    __swig_setmethods__ = {}
    for _s in [WSCform]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCmenuArea, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCform]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCmenuArea, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCmenuArea,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCmenuArea):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCmenuArea instance at %s>" % (self.this,)

class WSCmenuAreaPtr(WSCmenuArea):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCmenuArea
_mpfc.WSCmenuArea_swigregister(WSCmenuAreaPtr)

class WSCscrForm(WSCform):
    __swig_setmethods__ = {}
    for _s in [WSCform]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCscrForm, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCform]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCscrForm, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCscrForm,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCscrForm):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onScrMousePress(*args): return apply(_mpfc.WSCscrForm_onScrMousePress,args)
    def onScrMouseRelease(*args): return apply(_mpfc.WSCscrForm_onScrMouseRelease,args)
    def onScrMouseMove(*args): return apply(_mpfc.WSCscrForm_onScrMouseMove,args)
    def getVisibleWidth(*args): return apply(_mpfc.WSCscrForm_getVisibleWidth,args)
    def getVisibleHeight(*args): return apply(_mpfc.WSCscrForm_getVisibleHeight,args)
    def getScrFrame(*args): return apply(_mpfc.WSCscrForm_getScrFrame,args)
    def __repr__(self):
        return "<C WSCscrForm instance at %s>" % (self.this,)

class WSCscrFormPtr(WSCscrForm):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCscrForm
_mpfc.WSCscrForm_swigregister(WSCscrFormPtr)

class WSClist(WSCscrForm):
    __swig_setmethods__ = {}
    for _s in [WSCscrForm]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSClist, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCscrForm]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSClist, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSClist,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSClist):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onSort(*args): return apply(_mpfc.WSClist_onSort,args)
    def onItemSelected(*args): return apply(_mpfc.WSClist_onItemSelected,args)
    def onInputFixed(*args): return apply(_mpfc.WSClist_onInputFixed,args)
    def setLabelHeight(*args): return apply(_mpfc.WSClist_setLabelHeight,args)
    def delAll(*args): return apply(_mpfc.WSClist_delAll,args)
    def getLabel(*args): return apply(_mpfc.WSClist_getLabel,args)
    def getNum(*args): return apply(_mpfc.WSClist_getNum,args)
    def getItem(*args): return apply(_mpfc.WSClist_getItem,args)
    def addItem(*args): return apply(_mpfc.WSClist_addItem,args)
    def replaceItem(*args): return apply(_mpfc.WSClist_replaceItem,args)
    def delPos(*args): return apply(_mpfc.WSClist_delPos,args)
    def getPreSelectedPos(*args): return apply(_mpfc.WSClist_getPreSelectedPos,args)
    def setPreSelectPos(*args): return apply(_mpfc.WSClist_setPreSelectPos,args)
    def getSelectedPos(*args): return apply(_mpfc.WSClist_getSelectedPos,args)
    def setSelectPos(*args): return apply(_mpfc.WSClist_setSelectPos,args)
    def getSelectedItem(*args): return apply(_mpfc.WSClist_getSelectedItem,args)
    def setTopPos(*args): return apply(_mpfc.WSClist_setTopPos,args)
    def setBottomPos(*args): return apply(_mpfc.WSClist_setBottomPos,args)
    def getTopPos(*args): return apply(_mpfc.WSClist_getTopPos,args)
    def getBottomPos(*args): return apply(_mpfc.WSClist_getBottomPos,args)
    def updateList(*args): return apply(_mpfc.WSClist_updateList,args)
    def setLabelProperty(*args): return apply(_mpfc.WSClist_setLabelProperty,args)
    def setLabelClass(*args): return apply(_mpfc.WSClist_setLabelClass,args)
    def getSelectItemChanged(*args): return apply(_mpfc.WSClist_getSelectItemChanged,args)
    def setSelectItemChanged(*args): return apply(_mpfc.WSClist_setSelectItemChanged,args)
    def setItemVisible(*args): return apply(_mpfc.WSClist_setItemVisible,args)
    def setItemValue(*args): return apply(_mpfc.WSClist_setItemValue,args)
    def getItemValue(*args): return apply(_mpfc.WSClist_getItemValue,args)
    def getInputString(*args): return apply(_mpfc.WSClist_getInputString,args)
    def cancelInput(*args): return apply(_mpfc.WSClist_cancelInput,args)
    def getSeparator(*args): return apply(_mpfc.WSClist_getSeparator,args)
    def __repr__(self):
        return "<C WSClist instance at %s>" % (self.this,)

class WSClistPtr(WSClist):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSClist
_mpfc.WSClist_swigregister(WSClistPtr)

class WSCverbList(WSClist):
    __swig_setmethods__ = {}
    for _s in [WSClist]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCverbList, name, value)
    __swig_getmethods__ = {}
    for _s in [WSClist]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCverbList, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCverbList,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCverbList):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCverbList instance at %s>" % (self.this,)

class WSCverbListPtr(WSCverbList):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCverbList
_mpfc.WSCverbList_swigregister(WSCverbListPtr)

class WSCtreeList(WSClist):
    __swig_setmethods__ = {}
    for _s in [WSClist]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCtreeList, name, value)
    __swig_getmethods__ = {}
    for _s in [WSClist]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCtreeList, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCtreeList,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCtreeList):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCtreeList instance at %s>" % (self.this,)

class WSCtreeListPtr(WSCtreeList):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCtreeList
_mpfc.WSCtreeList_swigregister(WSCtreeListPtr)

WSGFsetDefaultEncoding = _mpfc.WSGFsetDefaultEncoding

WSGFgettext = _mpfc.WSGFgettext

WSGFimage = _mpfc.WSGFimage

class WSDcolor(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSDcolor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSDcolor, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSDcolor,args)
        self.thisown = 1
    def getColorName(*args): return apply(_mpfc.WSDcolor_getColorName,args)
    def getUsePrivateCell(*args): return apply(_mpfc.WSDcolor_getUsePrivateCell,args)
    def setUsePrivateCell(*args): return apply(_mpfc.WSDcolor_setUsePrivateCell,args)
    def getRGB(*args): return apply(_mpfc.WSDcolor_getRGB,args)
    def setColorName(*args): return apply(_mpfc.WSDcolor_setColorName,args)
    def __del__(self, destroy= _mpfc.delete_WSDcolor):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSDcolor instance at %s>" % (self.this,)

class WSDcolorPtr(WSDcolor):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSDcolor
_mpfc.WSDcolor_swigregister(WSDcolorPtr)

class WSCcolorSet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCcolorSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSCcolorSet, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCcolorSet,args)
        self.thisown = 1
    def getColor(*args): return apply(_mpfc.WSCcolorSet_getColor,args)
    def getColorName(*args): return apply(_mpfc.WSCcolorSet_getColorName,args)
    def __del__(self, destroy= _mpfc.delete_WSCcolorSet):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCcolorSet instance at %s>" % (self.this,)

class WSCcolorSetPtr(WSCcolorSet):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCcolorSet
_mpfc.WSCcolorSet_swigregister(WSCcolorSetPtr)

WSGIappColorSet = _mpfc.WSGIappColorSet

WSGFindexColor = _mpfc.WSGFindexColor

WSGFcolorName = _mpfc.WSGFcolorName

WSGFcolor = _mpfc.WSGFcolor

class WSCimageSet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCimageSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSCimageSet, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCimageSet,args)
        self.thisown = 1
    def getImageNo(*args): return apply(_mpfc.WSCimageSet_getImageNo,args)
    def getImage(*args): return apply(_mpfc.WSCimageSet_getImage,args)
    def getImageName(*args): return apply(_mpfc.WSCimageSet_getImageName,args)
    def destroyImage(*args): return apply(_mpfc.WSCimageSet_destroyImage,args)
    def destroyAllImage(*args): return apply(_mpfc.WSCimageSet_destroyAllImage,args)
    def __del__(self, destroy= _mpfc.delete_WSCimageSet):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCimageSet instance at %s>" % (self.this,)

class WSCimageSetPtr(WSCimageSet):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCimageSet
_mpfc.WSCimageSet_swigregister(WSCimageSetPtr)

WSGIappImageSet = _mpfc.WSGIappImageSet

WSGFimageName = _mpfc.WSGFimageName

class WSDfont(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSDfont, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSDfont, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSDfont,args)
        self.thisown = 1
    def getFontHeight(*args): return apply(_mpfc.WSDfont_getFontHeight,args)
    def setFontName(*args): return apply(_mpfc.WSDfont_setFontName,args)
    def getFontName(*args): return apply(_mpfc.WSDfont_getFontName,args)
    def getStringWidth(*args): return apply(_mpfc.WSDfont_getStringWidth,args)
    def getStringHeight(*args): return apply(_mpfc.WSDfont_getStringHeight,args)
    def __del__(self, destroy= _mpfc.delete_WSDfont):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSDfont instance at %s>" % (self.this,)

class WSDfontPtr(WSDfont):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSDfont
_mpfc.WSDfont_swigregister(WSDfontPtr)

class WSCfontSet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCfontSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSCfontSet, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCfontSet,args)
        self.thisown = 1
    def getFont(*args): return apply(_mpfc.WSCfontSet_getFont,args)
    def getStringWidth(*args): return apply(_mpfc.WSCfontSet_getStringWidth,args)
    def getStringHeight(*args): return apply(_mpfc.WSCfontSet_getStringHeight,args)
    def setDefaultFont(*args): return apply(_mpfc.WSCfontSet_setDefaultFont,args)
    def getDefaultFontNo(*args): return apply(_mpfc.WSCfontSet_getDefaultFontNo,args)
    def getDefaultFont(*args): return apply(_mpfc.WSCfontSet_getDefaultFont,args)
    def __del__(self, destroy= _mpfc.delete_WSCfontSet):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C WSCfontSet instance at %s>" % (self.this,)

class WSCfontSetPtr(WSCfontSet):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCfontSet
_mpfc.WSCfontSet_swigregister(WSCfontSetPtr)

WSGIappFontSet = _mpfc.WSGIappFontSet

WSGIappMessageDialog = _mpfc.WSGIappMessageDialog

class WSCbaseList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCbaseList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSCbaseList, name)
    def __init__(self,*args):
        self.this = apply(_mpfc.new_WSCbaseList,args)
        self.thisown = 1
    def __del__(self, destroy= _mpfc.delete_WSCbaseList):
        try:
            if self.thisown: destroy(self)
        except: pass
    def getInstance(*args): return apply(_mpfc.WSCbaseList_getInstance,args)
    def getClassList(*args): return apply(_mpfc.WSCbaseList_getClassList,args)
    def addClient(*args): return apply(_mpfc.WSCbaseList_addClient,args)
    def delClient(*args): return apply(_mpfc.WSCbaseList_delClient,args)
    def countObject(*args): return apply(_mpfc.WSCbaseList_countObject,args)
    def addNeedUpdate(*args): return apply(_mpfc.WSCbaseList_addNeedUpdate,args)
    def addNeedInitialize(*args): return apply(_mpfc.WSCbaseList_addNeedInitialize,args)
    def execUpdate(*args): return apply(_mpfc.WSCbaseList_execUpdate,args)
    def execInitialize(*args): return apply(_mpfc.WSCbaseList_execInitialize,args)
    def setUserData(*args): return apply(_mpfc.WSCbaseList_setUserData,args)
    def getUserData(*args): return apply(_mpfc.WSCbaseList_getUserData,args)
    def getInstanceList(*args): return apply(_mpfc.WSCbaseList_getInstanceList,args)
    def getRemoteInstance(*args): return apply(_mpfc.WSCbaseList_getRemoteInstance,args)
    def setSearchInstanceHandler(*args): return apply(_mpfc.WSCbaseList_setSearchInstanceHandler,args)
    def searchInstance(*args): return apply(_mpfc.WSCbaseList_searchInstance,args)
    def existInstance(*args): return apply(_mpfc.WSCbaseList_existInstance,args)
    def addEvent(*args): return apply(_mpfc.WSCbaseList_addEvent,args)
    def delEvent(*args): return apply(_mpfc.WSCbaseList_delEvent,args)
    def execEvent(*args): return apply(_mpfc.WSCbaseList_execEvent,args)
    def addRemoteInstanceData(*args): return apply(_mpfc.WSCbaseList_addRemoteInstanceData,args)
    def delRemoteInstanceData(*args): return apply(_mpfc.WSCbaseList_delRemoteInstanceData,args)
    def getRemoteInstanceListUpdated(*args): return apply(_mpfc.WSCbaseList_getRemoteInstanceListUpdated,args)
    def setRemoteInstanceListUpdated(*args): return apply(_mpfc.WSCbaseList_setRemoteInstanceListUpdated,args)
    def addExportInstanceList(*args): return apply(_mpfc.WSCbaseList_addExportInstanceList,args)
    def delExportInstanceList(*args): return apply(_mpfc.WSCbaseList_delExportInstanceList,args)
    def addExportInstanceUpdateList(*args): return apply(_mpfc.WSCbaseList_addExportInstanceUpdateList,args)
    def delExportInstanceUpdateList(*args): return apply(_mpfc.WSCbaseList_delExportInstanceUpdateList,args)
    def addExportInstanceDeleteList(*args): return apply(_mpfc.WSCbaseList_addExportInstanceDeleteList,args)
    def delExportInstanceDeleteList(*args): return apply(_mpfc.WSCbaseList_delExportInstanceDeleteList,args)
    def getExportInstanceDeleteList(*args): return apply(_mpfc.WSCbaseList_getExportInstanceDeleteList,args)
    def getExportInstanceUpdateList(*args): return apply(_mpfc.WSCbaseList_getExportInstanceUpdateList,args)
    def getExportInstanceList(*args): return apply(_mpfc.WSCbaseList_getExportInstanceList,args)
    def getRemoteInstanceData(*args): return apply(_mpfc.WSCbaseList_getRemoteInstanceData,args)
    def getRemoteInstanceList(*args): return apply(_mpfc.WSCbaseList_getRemoteInstanceList,args)
    def __repr__(self):
        return "<C WSCbaseList instance at %s>" % (self.this,)

class WSCbaseListPtr(WSCbaseList):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = WSCbaseList
_mpfc.WSCbaseList_swigregister(WSCbaseListPtr)
WSGFdestroyPixmap = _mpfc.WSGFdestroyPixmap


WSGIappObjectList = _mpfc.WSGIappObjectList

WS_MOUSE_SHIFT = _mpfc.WS_MOUSE_SHIFT
WS_MOUSE_LOCK = _mpfc.WS_MOUSE_LOCK
WS_MOUSE_CONTROL = _mpfc.WS_MOUSE_CONTROL
WS_MOUSE_MOD = _mpfc.WS_MOUSE_MOD
WS_MOUSE_BTN1 = _mpfc.WS_MOUSE_BTN1
WS_MOUSE_BTN2 = _mpfc.WS_MOUSE_BTN2
WS_MOUSE_BTN3 = _mpfc.WS_MOUSE_BTN3
WS_MOUSE_BTN4 = _mpfc.WS_MOUSE_BTN4
WS_MOUSE_BTN5 = _mpfc.WS_MOUSE_BTN5
WS_READ = _mpfc.WS_READ
WS_WRITE = _mpfc.WS_WRITE
WS_RW = _mpfc.WS_RW
WS_SHADOW_OUT = _mpfc.WS_SHADOW_OUT
WS_SHADOW_IN = _mpfc.WS_SHADOW_IN
WS_SHADOW_EOUT = _mpfc.WS_SHADOW_EOUT
WS_SHADOW_EIN = _mpfc.WS_SHADOW_EIN
WS_SHADOW_BORDER = _mpfc.WS_SHADOW_BORDER
WS_LEFT = _mpfc.WS_LEFT
WS_RIGHT = _mpfc.WS_RIGHT
WS_CENTER = _mpfc.WS_CENTER
WS_UP = _mpfc.WS_UP
WS_TOP = _mpfc.WS_TOP
WS_DOWN = _mpfc.WS_DOWN
WS_BOTTOM = _mpfc.WS_BOTTOM
WS_LEFT_TOP = _mpfc.WS_LEFT_TOP
WS_LEFT_BOTTOM = _mpfc.WS_LEFT_BOTTOM
WS_RIGHT_TOP = _mpfc.WS_RIGHT_TOP
WS_RIGHT_BOTTOM = _mpfc.WS_RIGHT_BOTTOM
WS_RET = _mpfc.WS_RET
WS_TAB = _mpfc.WS_TAB
WS_STAB = _mpfc.WS_STAB
WS_NO_ERR = _mpfc.WS_NO_ERR
WS_OK = _mpfc.WS_OK
WS_ERR = _mpfc.WS_ERR
WS_REMOTE_CALL_FAILED = _mpfc.WS_REMOTE_CALL_FAILED
False = _mpfc.False
True = _mpfc.True
WSTlong = _mpfc.WSTlong
WSTulong = _mpfc.WSTulong
WSTshort = _mpfc.WSTshort
WSTushort = _mpfc.WSTushort
WSTchar = _mpfc.WSTchar
WSTuchar = _mpfc.WSTuchar
WSTfloat = _mpfc.WSTfloat
WSTdouble = _mpfc.WSTdouble
WSTvoidptr = _mpfc.WSTvoidptr
WSTcharptr = _mpfc.WSTcharptr
WSTvoid = _mpfc.WSTvoid
WSTbool = _mpfc.WSTbool
WSTint = _mpfc.WSTint
WSTuint = _mpfc.WSTuint
WSEV_HASH_MAX_NUM = _mpfc.WSEV_HASH_MAX_NUM
WSEV_NONE = _mpfc.WSEV_NONE
WSEV_INITIALIZE = _mpfc.WSEV_INITIALIZE
WSEV_DELETE = _mpfc.WSEV_DELETE
WSEV_ACTIVATE = _mpfc.WSEV_ACTIVATE
WSEV_VALUE_CH = _mpfc.WSEV_VALUE_CH
WSEV_FOCUS_CH = _mpfc.WSEV_FOCUS_CH
WSEV_VISIBLE_CH = _mpfc.WSEV_VISIBLE_CH
WSEV_SENSITIVE_CH = _mpfc.WSEV_SENSITIVE_CH
WSEV_PARENT_VISIBLE_CH = _mpfc.WSEV_PARENT_VISIBLE_CH
WSEV_PARENT_SENSITIVE_CH = _mpfc.WSEV_PARENT_SENSITIVE_CH
WSEV_EXPOSE = _mpfc.WSEV_EXPOSE
WSEV_RESIZE = _mpfc.WSEV_RESIZE
WSEV_MOUSE_IN = _mpfc.WSEV_MOUSE_IN
WSEV_MOUSE_OUT = _mpfc.WSEV_MOUSE_OUT
WSEV_MOUSE_PRESS = _mpfc.WSEV_MOUSE_PRESS
WSEV_MOUSE_RELEASE = _mpfc.WSEV_MOUSE_RELEASE
WSEV_MOUSE_MOVE = _mpfc.WSEV_MOUSE_MOVE
WSEV_KEY_PRESS = _mpfc.WSEV_KEY_PRESS
WSEV_KEY_RELEASE = _mpfc.WSEV_KEY_RELEASE
WSEV_KEY_HOOK = _mpfc.WSEV_KEY_HOOK
WSEV_MOUSE_DOUBLE_CLICK = _mpfc.WSEV_MOUSE_DOUBLE_CLICK
WSEV_SORT = _mpfc.WSEV_SORT
WSEV_GUI_POLICY_CH = _mpfc.WSEV_GUI_POLICY_CH
WSEV_ITEM_SELECTED = _mpfc.WSEV_ITEM_SELECTED
WSEV_STATUS_CH = _mpfc.WSEV_STATUS_CH
WSEV_INPUT_FIXED = _mpfc.WSEV_INPUT_FIXED
WSEV_BEGIN = _mpfc.WSEV_BEGIN
WSEV_END = _mpfc.WSEV_END
WSEV_INCREMENT = _mpfc.WSEV_INCREMENT
WSEV_DECREMENT = _mpfc.WSEV_DECREMENT
WSEV_PAGE_INCREMENT = _mpfc.WSEV_PAGE_INCREMENT
WSEV_PAGE_DECREMENT = _mpfc.WSEV_PAGE_DECREMENT
WSEV_SCR_MOUSE_PRESS = _mpfc.WSEV_SCR_MOUSE_PRESS
WSEV_SCR_MOUSE_RELEASE = _mpfc.WSEV_SCR_MOUSE_RELEASE
WSEV_SCR_MOUSE_MOVE = _mpfc.WSEV_SCR_MOUSE_MOVE
WSEV_EDIT_MODE_CH = _mpfc.WSEV_EDIT_MODE_CH
WSEV_SPECIAL_FOCUS_CH = _mpfc.WSEV_SPECIAL_FOCUS_CH
WSEV_CHILD_ADDED = _mpfc.WSEV_CHILD_ADDED
WSEV_SELECTION_CH = _mpfc.WSEV_SELECTION_CH
WSK_BackSpace = _mpfc.WSK_BackSpace
WSK_Tab = _mpfc.WSK_Tab
WSK_Linefeed = _mpfc.WSK_Linefeed
WSK_Clear = _mpfc.WSK_Clear
WSK_Return = _mpfc.WSK_Return
WSK_Pause = _mpfc.WSK_Pause
WSK_Scroll_Lock = _mpfc.WSK_Scroll_Lock
WSK_Sys_Req = _mpfc.WSK_Sys_Req
WSK_Escape = _mpfc.WSK_Escape
WSK_Delete = _mpfc.WSK_Delete
WSK_Kanji = _mpfc.WSK_Kanji
WSK_Muhenkan = _mpfc.WSK_Muhenkan
WSK_Henkan_Mode = _mpfc.WSK_Henkan_Mode
WSK_Henkan = _mpfc.WSK_Henkan
WSK_Romaji = _mpfc.WSK_Romaji
WSK_Hiragana = _mpfc.WSK_Hiragana
WSK_Katakana = _mpfc.WSK_Katakana
WSK_Hiragana_Katakana = _mpfc.WSK_Hiragana_Katakana
WSK_Zenkaku = _mpfc.WSK_Zenkaku
WSK_Hankaku = _mpfc.WSK_Hankaku
WSK_Zenkaku_Hankaku = _mpfc.WSK_Zenkaku_Hankaku
WSK_Touroku = _mpfc.WSK_Touroku
WSK_Massyo = _mpfc.WSK_Massyo
WSK_Kana_Lock = _mpfc.WSK_Kana_Lock
WSK_Kana_Shift = _mpfc.WSK_Kana_Shift
WSK_Eisu_Shift = _mpfc.WSK_Eisu_Shift
WSK_Eisu_toggle = _mpfc.WSK_Eisu_toggle
WSK_Home = _mpfc.WSK_Home
WSK_Left = _mpfc.WSK_Left
WSK_Up = _mpfc.WSK_Up
WSK_Right = _mpfc.WSK_Right
WSK_Down = _mpfc.WSK_Down
WSK_Prior = _mpfc.WSK_Prior
WSK_Page_Up = _mpfc.WSK_Page_Up
WSK_Page_Down = _mpfc.WSK_Page_Down
WSK_End = _mpfc.WSK_End
WSK_Print = _mpfc.WSK_Print
WSK_Execute = _mpfc.WSK_Execute
WSK_Insert = _mpfc.WSK_Insert
WSK_Cancel = _mpfc.WSK_Cancel
WSK_Help = _mpfc.WSK_Help
WSK_Break = _mpfc.WSK_Break
WSK_Num_Lock = _mpfc.WSK_Num_Lock
WSK_KP_Space = _mpfc.WSK_KP_Space
WSK_KP_Tab = _mpfc.WSK_KP_Tab
WSK_KP_Enter = _mpfc.WSK_KP_Enter
WSK_KP_F1 = _mpfc.WSK_KP_F1
WSK_KP_F2 = _mpfc.WSK_KP_F2
WSK_KP_F3 = _mpfc.WSK_KP_F3
WSK_KP_F4 = _mpfc.WSK_KP_F4
WSK_KP_Home = _mpfc.WSK_KP_Home
WSK_KP_Left = _mpfc.WSK_KP_Left
WSK_KP_Up = _mpfc.WSK_KP_Up
WSK_KP_Right = _mpfc.WSK_KP_Right
WSK_KP_Down = _mpfc.WSK_KP_Down
WSK_KP_Prior = _mpfc.WSK_KP_Prior
WSK_KP_Page_Up = _mpfc.WSK_KP_Page_Up
WSK_KP_Next = _mpfc.WSK_KP_Next
WSK_KP_Page_Down = _mpfc.WSK_KP_Page_Down
WSK_KP_End = _mpfc.WSK_KP_End
WSK_KP_Begin = _mpfc.WSK_KP_Begin
WSK_KP_Insert = _mpfc.WSK_KP_Insert
WSK_KP_Delete = _mpfc.WSK_KP_Delete
WSK_KP_Equal = _mpfc.WSK_KP_Equal
WSK_KP_Multiply = _mpfc.WSK_KP_Multiply
WSK_KP_Add = _mpfc.WSK_KP_Add
WSK_KP_Separator = _mpfc.WSK_KP_Separator
WSK_KP_Subtract = _mpfc.WSK_KP_Subtract
WSK_KP_Decimal = _mpfc.WSK_KP_Decimal
WSK_KP_Divide = _mpfc.WSK_KP_Divide
WSK_KP_0 = _mpfc.WSK_KP_0
WSK_KP_1 = _mpfc.WSK_KP_1
WSK_KP_2 = _mpfc.WSK_KP_2
WSK_KP_3 = _mpfc.WSK_KP_3
WSK_KP_4 = _mpfc.WSK_KP_4
WSK_KP_5 = _mpfc.WSK_KP_5
WSK_KP_6 = _mpfc.WSK_KP_6
WSK_KP_7 = _mpfc.WSK_KP_7
WSK_KP_8 = _mpfc.WSK_KP_8
WSK_KP_9 = _mpfc.WSK_KP_9
WSK_F1 = _mpfc.WSK_F1
WSK_F2 = _mpfc.WSK_F2
WSK_F3 = _mpfc.WSK_F3
WSK_F4 = _mpfc.WSK_F4
WSK_F5 = _mpfc.WSK_F5
WSK_F6 = _mpfc.WSK_F6
WSK_F7 = _mpfc.WSK_F7
WSK_F8 = _mpfc.WSK_F8
WSK_F9 = _mpfc.WSK_F9
WSK_F10 = _mpfc.WSK_F10
WSK_F11 = _mpfc.WSK_F11
WSK_L1 = _mpfc.WSK_L1
WSK_F12 = _mpfc.WSK_F12
WSK_L2 = _mpfc.WSK_L2
WSK_F13 = _mpfc.WSK_F13
WSK_L3 = _mpfc.WSK_L3
WSK_F14 = _mpfc.WSK_F14
WSK_L4 = _mpfc.WSK_L4
WSK_F15 = _mpfc.WSK_F15
WSK_L5 = _mpfc.WSK_L5
WSK_F16 = _mpfc.WSK_F16
WSK_L6 = _mpfc.WSK_L6
WSK_F17 = _mpfc.WSK_F17
WSK_L7 = _mpfc.WSK_L7
WSK_F18 = _mpfc.WSK_F18
WSK_L8 = _mpfc.WSK_L8
WSK_F19 = _mpfc.WSK_F19
WSK_L9 = _mpfc.WSK_L9
WSK_F20 = _mpfc.WSK_F20
WSK_L10 = _mpfc.WSK_L10
WSK_F21 = _mpfc.WSK_F21
WSK_R1 = _mpfc.WSK_R1
WSK_F22 = _mpfc.WSK_F22
WSK_R2 = _mpfc.WSK_R2
WSK_F23 = _mpfc.WSK_F23
WSK_R3 = _mpfc.WSK_R3
WSK_F24 = _mpfc.WSK_F24
WSK_R4 = _mpfc.WSK_R4
WSK_F25 = _mpfc.WSK_F25
WSK_R5 = _mpfc.WSK_R5
WSK_F26 = _mpfc.WSK_F26
WSK_R6 = _mpfc.WSK_R6
WSK_F27 = _mpfc.WSK_F27
WSK_R7 = _mpfc.WSK_R7
WSK_F28 = _mpfc.WSK_F28
WSK_R8 = _mpfc.WSK_R8
WSK_F29 = _mpfc.WSK_F29
WSK_R9 = _mpfc.WSK_R9
WSK_F30 = _mpfc.WSK_F30
WSK_R10 = _mpfc.WSK_R10
WSK_F31 = _mpfc.WSK_F31
WSK_R11 = _mpfc.WSK_R11
WSK_F32 = _mpfc.WSK_F32
WSK_R12 = _mpfc.WSK_R12
WSK_F33 = _mpfc.WSK_F33
WSK_R13 = _mpfc.WSK_R13
WSK_F34 = _mpfc.WSK_F34
WSK_R14 = _mpfc.WSK_R14
WSK_F35 = _mpfc.WSK_F35
WSK_R15 = _mpfc.WSK_R15
WSK_Shift_L = _mpfc.WSK_Shift_L
WSK_Shift_R = _mpfc.WSK_Shift_R
WSK_Control_L = _mpfc.WSK_Control_L
WSK_Control_R = _mpfc.WSK_Control_R
WSK_Caps_Lock = _mpfc.WSK_Caps_Lock
WSK_Shift_Lock = _mpfc.WSK_Shift_Lock
WSK_Meta_L = _mpfc.WSK_Meta_L
WSK_Meta_R = _mpfc.WSK_Meta_R
WSK_Alt_L = _mpfc.WSK_Alt_L
WSK_Alt_R = _mpfc.WSK_Alt_R
WSK_Super_L = _mpfc.WSK_Super_L
WSK_Super_R = _mpfc.WSK_Super_R
WSK_Hyper_L = _mpfc.WSK_Hyper_L
WSK_Hyper_R = _mpfc.WSK_Hyper_R
WSK_space = _mpfc.WSK_space
WSK_exclam = _mpfc.WSK_exclam
WSK_quotedbl = _mpfc.WSK_quotedbl
WSK_numbersign = _mpfc.WSK_numbersign
WSK_dollar = _mpfc.WSK_dollar
WSK_percent = _mpfc.WSK_percent
WSK_ampersand = _mpfc.WSK_ampersand
WSK_apostrophe = _mpfc.WSK_apostrophe
WSK_quoteright = _mpfc.WSK_quoteright
WSK_parenleft = _mpfc.WSK_parenleft
WSK_parenright = _mpfc.WSK_parenright
WSK_asterisk = _mpfc.WSK_asterisk
WSK_plus = _mpfc.WSK_plus
WSK_comma = _mpfc.WSK_comma
WSK_minus = _mpfc.WSK_minus
WSK_period = _mpfc.WSK_period
WSK_slash = _mpfc.WSK_slash
WSK_0 = _mpfc.WSK_0
WSK_1 = _mpfc.WSK_1
WSK_2 = _mpfc.WSK_2
WSK_3 = _mpfc.WSK_3
WSK_4 = _mpfc.WSK_4
WSK_5 = _mpfc.WSK_5
WSK_6 = _mpfc.WSK_6
WSK_7 = _mpfc.WSK_7
WSK_8 = _mpfc.WSK_8
WSK_9 = _mpfc.WSK_9
WSK_colon = _mpfc.WSK_colon
WSK_semicolon = _mpfc.WSK_semicolon
WSK_less = _mpfc.WSK_less
WSK_equal = _mpfc.WSK_equal
WSK_greater = _mpfc.WSK_greater
WSK_question = _mpfc.WSK_question
WSK_at = _mpfc.WSK_at
WSK_A = _mpfc.WSK_A
WSK_B = _mpfc.WSK_B
WSK_C = _mpfc.WSK_C
WSK_D = _mpfc.WSK_D
WSK_E = _mpfc.WSK_E
WSK_F = _mpfc.WSK_F
WSK_G = _mpfc.WSK_G
WSK_H = _mpfc.WSK_H
WSK_I = _mpfc.WSK_I
WSK_J = _mpfc.WSK_J
WSK_K = _mpfc.WSK_K
WSK_L = _mpfc.WSK_L
WSK_M = _mpfc.WSK_M
WSK_N = _mpfc.WSK_N
WSK_O = _mpfc.WSK_O
WSK_P = _mpfc.WSK_P
WSK_Q = _mpfc.WSK_Q
WSK_R = _mpfc.WSK_R
WSK_S = _mpfc.WSK_S
WSK_T = _mpfc.WSK_T
WSK_U = _mpfc.WSK_U
WSK_V = _mpfc.WSK_V
WSK_W = _mpfc.WSK_W
WSK_X = _mpfc.WSK_X
WSK_Y = _mpfc.WSK_Y
WSK_Z = _mpfc.WSK_Z
WSK_bracketleft = _mpfc.WSK_bracketleft
WSK_backslash = _mpfc.WSK_backslash
WSK_bracketright = _mpfc.WSK_bracketright
WSK_asciicircum = _mpfc.WSK_asciicircum
WSK_underscore = _mpfc.WSK_underscore
WSK_grave = _mpfc.WSK_grave
WSK_quoteleft = _mpfc.WSK_quoteleft
WSK_a = _mpfc.WSK_a
WSK_b = _mpfc.WSK_b
WSK_c = _mpfc.WSK_c
WSK_d = _mpfc.WSK_d
WSK_e = _mpfc.WSK_e
WSK_f = _mpfc.WSK_f
WSK_g = _mpfc.WSK_g
WSK_h = _mpfc.WSK_h
WSK_i = _mpfc.WSK_i
WSK_j = _mpfc.WSK_j
WSK_k = _mpfc.WSK_k
WSK_l = _mpfc.WSK_l
WSK_m = _mpfc.WSK_m
WSK_n = _mpfc.WSK_n
WSK_o = _mpfc.WSK_o
WSK_p = _mpfc.WSK_p
WSK_q = _mpfc.WSK_q
WSK_r = _mpfc.WSK_r
WSK_s = _mpfc.WSK_s
WSK_t = _mpfc.WSK_t
WSK_u = _mpfc.WSK_u
WSK_v = _mpfc.WSK_v
WSK_w = _mpfc.WSK_w
WSK_x = _mpfc.WSK_x
WSK_y = _mpfc.WSK_y
WSK_z = _mpfc.WSK_z
WSK_braceleft = _mpfc.WSK_braceleft
WSK_bar = _mpfc.WSK_bar
WSK_braceright = _mpfc.WSK_braceright
WSK_asciitilde = _mpfc.WSK_asciitilde
WS_LIST_TREE_OPEN = _mpfc.WS_LIST_TREE_OPEN
WS_LIST_TREE_OPEN_CH = _mpfc.WS_LIST_TREE_OPEN_CH
WS_LIST_INDENT_LEVEL = _mpfc.WS_LIST_INDENT_LEVEL
WS_LIST_INDENT_STATUS = _mpfc.WS_LIST_INDENT_STATUS
WS_LIST_LABEL_LIST = _mpfc.WS_LIST_LABEL_LIST
WS_LIST_TOP = _mpfc.WS_LIST_TOP

