# 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
del types


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)
    def __repr__(self):
        return "<C WSCpoint instance at %s>" % (self.this,)
    __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 _mpfc.WSCpoint_setPoint(*args)
    def __init__(self, *args):
        _swig_setattr(self, WSCpoint, 'this', _mpfc.new_WSCpoint(*args))
        _swig_setattr(self, WSCpoint, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCpoint):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCpointPtr(WSCpoint):
    def __init__(self, this):
        _swig_setattr(self, WSCpoint, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCpoint, 'thisown', 0)
        _swig_setattr(self, WSCpoint,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)
    def __repr__(self):
        return "<C WSCrect instance at %s>" % (self.this,)
    __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 _mpfc.WSCrect_setRect(*args)
    def __init__(self, *args):
        _swig_setattr(self, WSCrect, 'this', _mpfc.new_WSCrect(*args))
        _swig_setattr(self, WSCrect, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCrect):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCrectPtr(WSCrect):
    def __init__(self, this):
        _swig_setattr(self, WSCrect, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCrect, 'thisown', 0)
        _swig_setattr(self, WSCrect,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 __repr__(self):
        return "<C WSCstring instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCstring, 'this', _mpfc.new_WSCstring(*args))
        _swig_setattr(self, WSCstring, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCstring):
        try:
            if self.thisown: destroy(self)
        except: pass
    def setString(*args): return _mpfc.WSCstring_setString(*args)
    def getString(*args): return _mpfc.WSCstring_getString(*args)
    def __str__(*args): return _mpfc.WSCstring___str__(*args)
    def getChars(*args): return _mpfc.WSCstring_getChars(*args)
    def getEncoding(*args): return _mpfc.WSCstring_getEncoding(*args)
    def isExist(*args): return _mpfc.WSCstring_isExist(*args)
    def addString(*args): return _mpfc.WSCstring_addString(*args)
    def cutString(*args): return _mpfc.WSCstring_cutString(*args)
    def insertString(*args): return _mpfc.WSCstring_insertString(*args)
    def deleteChar(*args): return _mpfc.WSCstring_deleteChar(*args)
    def deleteChars(*args): return _mpfc.WSCstring_deleteChars(*args)
    def clear(*args): return _mpfc.WSCstring_clear(*args)
    def delLineFeed(*args): return _mpfc.WSCstring_delLineFeed(*args)
    def delString(*args): return _mpfc.WSCstring_delString(*args)
    def delHeadSpace(*args): return _mpfc.WSCstring_delHeadSpace(*args)
    def delTailSpace(*args): return _mpfc.WSCstring_delTailSpace(*args)
    def to_upper(*args): return _mpfc.WSCstring_to_upper(*args)
    def to_lower(*args): return _mpfc.WSCstring_to_lower(*args)
    def replaceString(*args): return _mpfc.WSCstring_replaceString(*args)
    def getWords(*args): return _mpfc.WSCstring_getWords(*args)
    def getWordCharPos(*args): return _mpfc.WSCstring_getWordCharPos(*args)
    def getWord(*args): return _mpfc.WSCstring_getWord(*args)
    def _seek_next_line(*args): return _mpfc.WSCstring__seek_next_line(*args)
    def tell(*args): return _mpfc.WSCstring_tell(*args)
    def seek(*args): return _mpfc.WSCstring_seek(*args)
    def seekEnd(*args): return _mpfc.WSCstring_seekEnd(*args)
    def eof(*args): return _mpfc.WSCstring_eof(*args)
    def getLines(*args): return _mpfc.WSCstring_getLines(*args)
    def gets(*args): return _mpfc.WSCstring_gets(*args)
    def __add__(*args): return _mpfc.WSCstring___add__(*args)
    def __lshift__(*args): return _mpfc.WSCstring___lshift__(*args)
    def __eq__(*args): return _mpfc.WSCstring___eq__(*args)

class WSCstringPtr(WSCstring):
    def __init__(self, this):
        _swig_setattr(self, WSCstring, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCstring, 'thisown', 0)
        _swig_setattr(self, WSCstring,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 __repr__(self):
        return "<C WSCvariant instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvariant, 'this', _mpfc.new_WSCvariant(*args))
        _swig_setattr(self, WSCvariant, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvariant):
        try:
            if self.thisown: destroy(self)
        except: pass
    def getChar(*args): return _mpfc.WSCvariant_getChar(*args)
    def getUnsignedChar(*args): return _mpfc.WSCvariant_getUnsignedChar(*args)
    def getShort(*args): return _mpfc.WSCvariant_getShort(*args)
    def getUnsignedShort(*args): return _mpfc.WSCvariant_getUnsignedShort(*args)
    def getLong(*args): return _mpfc.WSCvariant_getLong(*args)
    def getUnsignedLong(*args): return _mpfc.WSCvariant_getUnsignedLong(*args)
    def getInt(*args): return _mpfc.WSCvariant_getInt(*args)
    def getUnsignedInt(*args): return _mpfc.WSCvariant_getUnsignedInt(*args)
    def getFloat(*args): return _mpfc.WSCvariant_getFloat(*args)
    def getDouble(*args): return _mpfc.WSCvariant_getDouble(*args)
    def getCharPtr(*args): return _mpfc.WSCvariant_getCharPtr(*args)
    def getInstancePtr(*args): return _mpfc.WSCvariant_getInstancePtr(*args)
    def __int__(*args): return _mpfc.WSCvariant___int__(*args)
    def __float__(*args): return _mpfc.WSCvariant___float__(*args)
    def __str__(*args): return _mpfc.WSCvariant___str__(*args)
    def setValue(*args): return _mpfc.WSCvariant_setValue(*args)
    def getType(*args): return _mpfc.WSCvariant_getType(*args)
    def getTypeName(*args): return _mpfc.WSCvariant_getTypeName(*args)
    def clear(*args): return _mpfc.WSCvariant_clear(*args)

class WSCvariantPtr(WSCvariant):
    def __init__(self, this):
        _swig_setattr(self, WSCvariant, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvariant, 'thisown', 0)
        _swig_setattr(self, WSCvariant,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 __repr__(self):
        return "<C WSDappDev instance at %s>" % (self.this,)
    def execInitHandler(*args): return _mpfc.WSDappDev_execInitHandler(*args)
    def handleEvents(*args): return _mpfc.WSDappDev_handleEvents(*args)
    def getInstanceName(*args): return _mpfc.WSDappDev_getInstanceName(*args)
    def getWidth(*args): return _mpfc.WSDappDev_getWidth(*args)
    def getHeight(*args): return _mpfc.WSDappDev_getHeight(*args)
    def update(*args): return _mpfc.WSDappDev_update(*args)
    def exit(*args): return _mpfc.WSDappDev_exit(*args)
    def __init__(self, *args):
        _swig_setattr(self, WSDappDev, 'this', _mpfc.new_WSDappDev(*args))
        _swig_setattr(self, WSDappDev, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSDappDev):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSDappDevPtr(WSDappDev):
    def __init__(self, this):
        _swig_setattr(self, WSDappDev, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSDappDev, 'thisown', 0)
        _swig_setattr(self, WSDappDev,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 __repr__(self):
        return "<C WSCbase instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCbase, 'this', _mpfc.new_WSCbase(*args))
        _swig_setattr(self, WSCbase, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCbase):
        try:
            if self.thisown: destroy(self)
        except: pass
    def initialize(*args): return _mpfc.WSCbase_initialize(*args)
    def getInitialized(*args): return _mpfc.WSCbase_getInitialized(*args)
    def onMouseIn(*args): return _mpfc.WSCbase_onMouseIn(*args)
    def onMouseOut(*args): return _mpfc.WSCbase_onMouseOut(*args)
    def onMouseMove(*args): return _mpfc.WSCbase_onMouseMove(*args)
    def onMousePress(*args): return _mpfc.WSCbase_onMousePress(*args)
    def onMouseRelease(*args): return _mpfc.WSCbase_onMouseRelease(*args)
    def onExpose(*args): return _mpfc.WSCbase_onExpose(*args)
    def onResize(*args): return _mpfc.WSCbase_onResize(*args)
    def onVisibleChange(*args): return _mpfc.WSCbase_onVisibleChange(*args)
    def onSensitiveChange(*args): return _mpfc.WSCbase_onSensitiveChange(*args)
    def onParentVisibleChange(*args): return _mpfc.WSCbase_onParentVisibleChange(*args)
    def onParentSensitiveChange(*args): return _mpfc.WSCbase_onParentSensitiveChange(*args)
    def onEditModeChange(*args): return _mpfc.WSCbase_onEditModeChange(*args)
    def onFocusChange(*args): return _mpfc.WSCbase_onFocusChange(*args)
    def onSpecialFocusChange(*args): return _mpfc.WSCbase_onSpecialFocusChange(*args)
    def onChildAdded(*args): return _mpfc.WSCbase_onChildAdded(*args)
    def onSelectionChange(*args): return _mpfc.WSCbase_onSelectionChange(*args)
    def onGuiPolicyChange(*args): return _mpfc.WSCbase_onGuiPolicyChange(*args)
    def onDefaultColorChange(*args): return _mpfc.WSCbase_onDefaultColorChange(*args)
    def getInstanceName(*args): return _mpfc.WSCbase_getInstanceName(*args)
    def setVisible(*args): return _mpfc.WSCbase_setVisible(*args)
    def getVisible(*args): return _mpfc.WSCbase_getVisible(*args)
    def getProperty(*args): return _mpfc.WSCbase_getProperty(*args)
    def setProperty(*args): return _mpfc.WSCbase_setProperty(*args)
    def addProcedure(*args): return _mpfc.WSCbase_addProcedure(*args)
    def setParent(*args): return _mpfc.WSCbase_setParent(*args)
    def getParent(*args): return _mpfc.WSCbase_getParent(*args)
    def getParentWindow(*args): return _mpfc.WSCbase_getParentWindow(*args)
    def getChildInstance(*args): return _mpfc.WSCbase_getChildInstance(*args)
    def setInternalObject(*args): return _mpfc.WSCbase_setInternalObject(*args)
    def getInternalObject(*args): return _mpfc.WSCbase_getInternalObject(*args)
    def setDefaultValue(*args): return _mpfc.WSCbase_setDefaultValue(*args)
    def existProperty(*args): return _mpfc.WSCbase_existProperty(*args)
    def getDefaultProperty(*args): return _mpfc.WSCbase_getDefaultProperty(*args)
    def setFocus(*args): return _mpfc.WSCbase_setFocus(*args)
    def setSpecialFocus(*args): return _mpfc.WSCbase_setSpecialFocus(*args)
    def setParentVisible(*args): return _mpfc.WSCbase_setParentVisible(*args)
    def setSensitive(*args): return _mpfc.WSCbase_setSensitive(*args)
    def setParentSensitive(*args): return _mpfc.WSCbase_setParentSensitive(*args)
    def getParentVisible(*args): return _mpfc.WSCbase_getParentVisible(*args)
    def getSensitive(*args): return _mpfc.WSCbase_getSensitive(*args)
    def getParentSensitive(*args): return _mpfc.WSCbase_getParentSensitive(*args)
    def getFocus(*args): return _mpfc.WSCbase_getFocus(*args)
    def getSpecialFocus(*args): return _mpfc.WSCbase_getSpecialFocus(*args)
    def setAbsoluteDraw(*args): return _mpfc.WSCbase_setAbsoluteDraw(*args)
    def getAbsoluteDraw(*args): return _mpfc.WSCbase_getAbsoluteDraw(*args)
    def setUserData(*args): return _mpfc.WSCbase_setUserData(*args)
    def getUserData(*args): return _mpfc.WSCbase_getUserData(*args)
    def setVariantData(*args): return _mpfc.WSCbase_setVariantData(*args)
    def getVariantData(*args): return _mpfc.WSCbase_getVariantData(*args)
    def execProcedure(*args): return _mpfc.WSCbase_execProcedure(*args)
    def draw(*args): return _mpfc.WSCbase_draw(*args)
    def clear(*args): return _mpfc.WSCbase_clear(*args)
    def redraw(*args): return _mpfc.WSCbase_redraw(*args)
    def cdraw(*args): return _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)

class WSCbasePtr(WSCbase):
    def __init__(self, this):
        _swig_setattr(self, WSCbase, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCbase, 'thisown', 0)
        _swig_setattr(self, WSCbase,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 __repr__(self):
        return "<C WSDmouse instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSDmouse, 'this', _mpfc.new_WSDmouse(*args))
        _swig_setattr(self, WSDmouse, 'thisown', 1)
    def getMousePosition(*args): return _mpfc.WSDmouse_getMousePosition(*args)
    def getMouseStatus(*args): return _mpfc.WSDmouse_getMouseStatus(*args)
    def setMousePosition(*args): return _mpfc.WSDmouse_setMousePosition(*args)
    def setMouseCursor(*args): return _mpfc.WSDmouse_setMouseCursor(*args)
    def addMouseCursor(*args): return _mpfc.WSDmouse_addMouseCursor(*args)
    def getMouseCursorName(*args): return _mpfc.WSDmouse_getMouseCursorName(*args)
    def getMouseCursorId(*args): return _mpfc.WSDmouse_getMouseCursorId(*args)
    def getMouseCursor(*args): return _mpfc.WSDmouse_getMouseCursor(*args)
    def getStatus(*args): return _mpfc.WSDmouse_getStatus(*args)
    def setStatus(*args): return _mpfc.WSDmouse_setStatus(*args)
    def getTargetBtn(*args): return _mpfc.WSDmouse_getTargetBtn(*args)
    def setTargetBtn(*args): return _mpfc.WSDmouse_setTargetBtn(*args)
    def setMouseFocusClient(*args): return _mpfc.WSDmouse_setMouseFocusClient(*args)
    def getMouseFocusClient(*args): return _mpfc.WSDmouse_getMouseFocusClient(*args)
    def __del__(self, destroy=_mpfc.delete_WSDmouse):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSDmousePtr(WSDmouse):
    def __init__(self, this):
        _swig_setattr(self, WSDmouse, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSDmouse, 'thisown', 0)
        _swig_setattr(self, WSDmouse,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 __repr__(self):
        return "<C WSCform instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCform, 'this', _mpfc.new_WSCform(*args))
        _swig_setattr(self, WSCform, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCform):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCformPtr(WSCform):
    def __init__(self, this):
        _swig_setattr(self, WSCform, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCform, 'thisown', 0)
        _swig_setattr(self, WSCform,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 __repr__(self):
        return "<C WSCnwbase instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCnwbase, 'this', _mpfc.new_WSCnwbase(*args))
        _swig_setattr(self, WSCnwbase, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCnwbase):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCnwbasePtr(WSCnwbase):
    def __init__(self, this):
        _swig_setattr(self, WSCnwbase, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCnwbase, 'thisown', 0)
        _swig_setattr(self, WSCnwbase,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 __repr__(self):
        return "<C WSCngbase instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCngbase, 'this', _mpfc.new_WSCngbase(*args))
        _swig_setattr(self, WSCngbase, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCngbase):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCngbasePtr(WSCngbase):
    def __init__(self, this):
        _swig_setattr(self, WSCngbase, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCngbase, 'thisown', 0)
        _swig_setattr(self, WSCngbase,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 __repr__(self):
        return "<C WSCvlabel instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvlabel, 'this', _mpfc.new_WSCvlabel(*args))
        _swig_setattr(self, WSCvlabel, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvlabel):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvlabelPtr(WSCvlabel):
    def __init__(self, this):
        _swig_setattr(self, WSCvlabel, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvlabel, 'thisown', 0)
        _swig_setattr(self, WSCvlabel,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 __repr__(self):
        return "<C WSCvbtn instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvbtn, 'this', _mpfc.new_WSCvbtn(*args))
        _swig_setattr(self, WSCvbtn, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvbtn):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onKey(*args): return _mpfc.WSCvbtn_onKey(*args)
    def onActivate(*args): return _mpfc.WSCvbtn_onActivate(*args)
    def setDrawFocusBorder(*args): return _mpfc.WSCvbtn_setDrawFocusBorder(*args)

class WSCvbtnPtr(WSCvbtn):
    def __init__(self, this):
        _swig_setattr(self, WSCvbtn, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvbtn, 'thisown', 0)
        _swig_setattr(self, WSCvbtn,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 __repr__(self):
        return "<C WSCvfbtn instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvfbtn, 'this', _mpfc.new_WSCvfbtn(*args))
        _swig_setattr(self, WSCvfbtn, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvfbtn):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvfbtnPtr(WSCvfbtn):
    def __init__(self, this):
        _swig_setattr(self, WSCvfbtn, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvfbtn, 'thisown', 0)
        _swig_setattr(self, WSCvfbtn,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 __repr__(self):
        return "<C WSCvklabel instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvklabel, 'this', _mpfc.new_WSCvklabel(*args))
        _swig_setattr(self, WSCvklabel, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvklabel):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvklabelPtr(WSCvklabel):
    def __init__(self, this):
        _swig_setattr(self, WSCvklabel, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvklabel, 'thisown', 0)
        _swig_setattr(self, WSCvklabel,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 __repr__(self):
        return "<C WSCvkflabel instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvkflabel, 'this', _mpfc.new_WSCvkflabel(*args))
        _swig_setattr(self, WSCvkflabel, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvkflabel):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvkflabelPtr(WSCvkflabel):
    def __init__(self, this):
        _swig_setattr(self, WSCvkflabel, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvkflabel, 'thisown', 0)
        _swig_setattr(self, WSCvkflabel,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 __repr__(self):
        return "<C WSDkeyboard instance at %s>" % (self.this,)
    def setKey(*args): return _mpfc.WSDkeyboard_setKey(*args)
    def getKey(*args): return _mpfc.WSDkeyboard_getKey(*args)
    def withShift(*args): return _mpfc.WSDkeyboard_withShift(*args)
    def withLock(*args): return _mpfc.WSDkeyboard_withLock(*args)
    def withCntl(*args): return _mpfc.WSDkeyboard_withCntl(*args)
    def withAlt(*args): return _mpfc.WSDkeyboard_withAlt(*args)
    def isCursorKey(*args): return _mpfc.WSDkeyboard_isCursorKey(*args)
    def isFuncKey(*args): return _mpfc.WSDkeyboard_isFuncKey(*args)
    def isTtyFunction(*args): return _mpfc.WSDkeyboard_isTtyFunction(*args)
    def getFepStatus(*args): return _mpfc.WSDkeyboard_getFepStatus(*args)
    def getEnableFep(*args): return _mpfc.WSDkeyboard_getEnableFep(*args)
    def isPressed(*args): return _mpfc.WSDkeyboard_isPressed(*args)
    def setWithShift(*args): return _mpfc.WSDkeyboard_setWithShift(*args)
    def setWithLock(*args): return _mpfc.WSDkeyboard_setWithLock(*args)
    def setWithCntl(*args): return _mpfc.WSDkeyboard_setWithCntl(*args)
    def setWithAlt(*args): return _mpfc.WSDkeyboard_setWithAlt(*args)
    def setIsCursorKey(*args): return _mpfc.WSDkeyboard_setIsCursorKey(*args)
    def setIsFuncKey(*args): return _mpfc.WSDkeyboard_setIsFuncKey(*args)
    def setIsTtyFunction(*args): return _mpfc.WSDkeyboard_setIsTtyFunction(*args)
    def setIsPressed(*args): return _mpfc.WSDkeyboard_setIsPressed(*args)
    def getTextString(*args): return _mpfc.WSDkeyboard_getTextString(*args)
    def getText(*args): return _mpfc.WSDkeyboard_getText(*args)
    def setSelectedString(*args): return _mpfc.WSDkeyboard_setSelectedString(*args)
    def getSelectedString(*args): return _mpfc.WSDkeyboard_getSelectedString(*args)
    def __init__(self, *args):
        _swig_setattr(self, WSDkeyboard, 'this', _mpfc.new_WSDkeyboard(*args))
        _swig_setattr(self, WSDkeyboard, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSDkeyboard):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSDkeyboardPtr(WSDkeyboard):
    def __init__(self, this):
        _swig_setattr(self, WSDkeyboard, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSDkeyboard, 'thisown', 0)
        _swig_setattr(self, WSDkeyboard,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 __repr__(self):
        return "<C WSCvifield instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvifield, 'this', _mpfc.new_WSCvifield(*args))
        _swig_setattr(self, WSCvifield, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvifield):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onCursorBlink(*args): return _mpfc.WSCvifield_onCursorBlink(*args)
    def onKeyHook(*args): return _mpfc.WSCvifield_onKeyHook(*args)
    def onKeyInput(*args): return _mpfc.WSCvifield_onKeyInput(*args)
    def onKey(*args): return _mpfc.WSCvifield_onKey(*args)
    def onActivate(*args): return _mpfc.WSCvifield_onActivate(*args)
    def onValueChange(*args): return _mpfc.WSCvifield_onValueChange(*args)
    def onSelectionChange(*args): return _mpfc.WSCvifield_onSelectionChange(*args)
    def onVisibleChange(*args): return _mpfc.WSCvifield_onVisibleChange(*args)
    def onParentVisibleChange(*args): return _mpfc.WSCvifield_onParentVisibleChange(*args)
    def setCursorFore(*args): return _mpfc.WSCvifield_setCursorFore(*args)
    def getCursorFore(*args): return _mpfc.WSCvifield_getCursorFore(*args)
    def setCurPos(*args): return _mpfc.WSCvifield_setCurPos(*args)
    def replaceSelectedString(*args): return _mpfc.WSCvifield_replaceSelectedString(*args)
    def getSelectedString(*args): return _mpfc.WSCvifield_getSelectedString(*args)
    def deleteSelectedString(*args): return _mpfc.WSCvifield_deleteSelectedString(*args)
    def setSelect(*args): return _mpfc.WSCvifield_setSelect(*args)
    def getSelectedPos(*args): return _mpfc.WSCvifield_getSelectedPos(*args)
    def getString(*args): return _mpfc.WSCvifield_getString(*args)
    def addString(*args): return _mpfc.WSCvifield_addString(*args)

class WSCvifieldPtr(WSCvifield):
    def __init__(self, this):
        _swig_setattr(self, WSCvifield, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvifield, 'thisown', 0)
        _swig_setattr(self, WSCvifield,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 __repr__(self):
        return "<C WSCvkslabel instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvkslabel, 'this', _mpfc.new_WSCvkslabel(*args))
        _swig_setattr(self, WSCvkslabel, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvkslabel):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvkslabelPtr(WSCvkslabel):
    def __init__(self, this):
        _swig_setattr(self, WSCvkslabel, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvkslabel, 'thisown', 0)
        _swig_setattr(self, WSCvkslabel,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 __repr__(self):
        return "<C WSCvmifield instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvmifield, 'this', _mpfc.new_WSCvmifield(*args))
        _swig_setattr(self, WSCvmifield, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvmifield):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvmifieldPtr(WSCvmifield):
    def __init__(self, this):
        _swig_setattr(self, WSCvmifield, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvmifield, 'thisown', 0)
        _swig_setattr(self, WSCvmifield,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 __repr__(self):
        return "<C WSCvpifield instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvpifield, 'this', _mpfc.new_WSCvpifield(*args))
        _swig_setattr(self, WSCvpifield, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvpifield):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvpifieldPtr(WSCvpifield):
    def __init__(self, this):
        _swig_setattr(self, WSCvpifield, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvpifield, 'thisown', 0)
        _swig_setattr(self, WSCvpifield,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 __repr__(self):
        return "<C WSCtextField instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCtextField, 'this', _mpfc.new_WSCtextField(*args))
        _swig_setattr(self, WSCtextField, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCtextField):
        try:
            if self.thisown: destroy(self)
        except: pass
    def addString(*args): return _mpfc.WSCtextField_addString(*args)
    def replaceSelectedString(*args): return _mpfc.WSCtextField_replaceSelectedString(*args)
    def getSelectedString(*args): return _mpfc.WSCtextField_getSelectedString(*args)
    def getString(*args): return _mpfc.WSCtextField_getString(*args)
    def deleteSelectedString(*args): return _mpfc.WSCtextField_deleteSelectedString(*args)
    def setSelect(*args): return _mpfc.WSCtextField_setSelect(*args)
    def getSelectedPos(*args): return _mpfc.WSCtextField_getSelectedPos(*args)
    def getLines(*args): return _mpfc.WSCtextField_getLines(*args)
    def getTopLine(*args): return _mpfc.WSCtextField_getTopLine(*args)
    def setTopLine(*args): return _mpfc.WSCtextField_setTopLine(*args)
    def getBottomLine(*args): return _mpfc.WSCtextField_getBottomLine(*args)
    def setBottomLine(*args): return _mpfc.WSCtextField_setBottomLine(*args)
    def getTextFrame(*args): return _mpfc.WSCtextField_getTextFrame(*args)

class WSCtextFieldPtr(WSCtextField):
    def __init__(self, this):
        _swig_setattr(self, WSCtextField, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCtextField, 'thisown', 0)
        _swig_setattr(self, WSCtextField,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 __repr__(self):
        return "<C WSCvarrow instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvarrow, 'this', _mpfc.new_WSCvarrow(*args))
        _swig_setattr(self, WSCvarrow, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvarrow):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvarrowPtr(WSCvarrow):
    def __init__(self, this):
        _swig_setattr(self, WSCvarrow, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvarrow, 'thisown', 0)
        _swig_setattr(self, WSCvarrow,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 __repr__(self):
        return "<C WSCvscrBar instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvscrBar, 'this', _mpfc.new_WSCvscrBar(*args))
        _swig_setattr(self, WSCvscrBar, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvscrBar):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return _mpfc.WSCvscrBar_onActivate(*args)
    def onBegin(*args): return _mpfc.WSCvscrBar_onBegin(*args)
    def onEnd(*args): return _mpfc.WSCvscrBar_onEnd(*args)
    def onIncrement(*args): return _mpfc.WSCvscrBar_onIncrement(*args)
    def onDecrement(*args): return _mpfc.WSCvscrBar_onDecrement(*args)
    def onPageIncrement(*args): return _mpfc.WSCvscrBar_onPageIncrement(*args)
    def onPageDecrement(*args): return _mpfc.WSCvscrBar_onPageDecrement(*args)
    def onValueChange(*args): return _mpfc.WSCvscrBar_onValueChange(*args)
    def getMaxSlideValue(*args): return _mpfc.WSCvscrBar_getMaxSlideValue(*args)

class WSCvscrBarPtr(WSCvscrBar):
    def __init__(self, this):
        _swig_setattr(self, WSCvscrBar, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvscrBar, 'thisown', 0)
        _swig_setattr(self, WSCvscrBar,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 __repr__(self):
        return "<C WSCvpolyAttr instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvpolyAttr, 'this', _mpfc.new_WSCvpolyAttr(*args))
        _swig_setattr(self, WSCvpolyAttr, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvpolyAttr):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvpolyAttrPtr(WSCvpolyAttr):
    def __init__(self, this):
        _swig_setattr(self, WSCvpolyAttr, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvpolyAttr, 'thisown', 0)
        _swig_setattr(self, WSCvpolyAttr,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 __repr__(self):
        return "<C WSCvmeter instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvmeter, 'this', _mpfc.new_WSCvmeter(*args))
        _swig_setattr(self, WSCvmeter, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvmeter):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvmeterPtr(WSCvmeter):
    def __init__(self, this):
        _swig_setattr(self, WSCvmeter, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvmeter, 'thisown', 0)
        _swig_setattr(self, WSCvmeter,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 __repr__(self):
        return "<C WSCvclock instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvclock, 'this', _mpfc.new_WSCvclock(*args))
        _swig_setattr(self, WSCvclock, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvclock):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvclockPtr(WSCvclock):
    def __init__(self, this):
        _swig_setattr(self, WSCvclock, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvclock, 'thisown', 0)
        _swig_setattr(self, WSCvclock,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 __repr__(self):
        return "<C WSCvslider instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvslider, 'this', _mpfc.new_WSCvslider(*args))
        _swig_setattr(self, WSCvslider, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvslider):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return _mpfc.WSCvslider_onActivate(*args)
    def onDragInterval(*args): return _mpfc.WSCvslider_onDragInterval(*args)
    def onValueChange(*args): return _mpfc.WSCvslider_onValueChange(*args)

class WSCvsliderPtr(WSCvslider):
    def __init__(self, this):
        _swig_setattr(self, WSCvslider, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvslider, 'thisown', 0)
        _swig_setattr(self, WSCvslider,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 __repr__(self):
        return "<C WSCpulldownMenu instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCpulldownMenu, 'this', _mpfc.new_WSCpulldownMenu(*args))
        _swig_setattr(self, WSCpulldownMenu, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCpulldownMenu):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return _mpfc.WSCpulldownMenu_onActivate(*args)
    def setItemSensitive(*args): return _mpfc.WSCpulldownMenu_setItemSensitive(*args)
    def setValueSensitive(*args): return _mpfc.WSCpulldownMenu_setValueSensitive(*args)
    def getItemSensitive(*args): return _mpfc.WSCpulldownMenu_getItemSensitive(*args)
    def getValue(*args): return _mpfc.WSCpulldownMenu_getValue(*args)
    def getItems(*args): return _mpfc.WSCpulldownMenu_getItems(*args)
    def beginCascade(*args): return _mpfc.WSCpulldownMenu_beginCascade(*args)
    def addItem(*args): return _mpfc.WSCpulldownMenu_addItem(*args)
    def endCascade(*args): return _mpfc.WSCpulldownMenu_endCascade(*args)

class WSCpulldownMenuPtr(WSCpulldownMenu):
    def __init__(self, this):
        _swig_setattr(self, WSCpulldownMenu, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCpulldownMenu, 'thisown', 0)
        _swig_setattr(self, WSCpulldownMenu,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 __repr__(self):
        return "<C WSCcomboBox instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCcomboBox, 'this', _mpfc.new_WSCcomboBox(*args))
        _swig_setattr(self, WSCcomboBox, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCcomboBox):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return _mpfc.WSCcomboBox_onActivate(*args)

class WSCcomboBoxPtr(WSCcomboBox):
    def __init__(self, this):
        _swig_setattr(self, WSCcomboBox, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCcomboBox, 'thisown', 0)
        _swig_setattr(self, WSCcomboBox,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 __repr__(self):
        return "<C WSCoption instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCoption, 'this', _mpfc.new_WSCoption(*args))
        _swig_setattr(self, WSCoption, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCoption):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return _mpfc.WSCoption_onActivate(*args)
    def onValueChange(*args): return _mpfc.WSCoption_onValueChange(*args)
    def setItemSensitive(*args): return _mpfc.WSCoption_setItemSensitive(*args)
    def setSelectValue(*args): return _mpfc.WSCoption_setSelectValue(*args)
    def getValue(*args): return _mpfc.WSCoption_getValue(*args)
    def getItemValue(*args): return _mpfc.WSCoption_getItemValue(*args)
    def getSelectStatus(*args): return _mpfc.WSCoption_getSelectStatus(*args)
    def getItemNum(*args): return _mpfc.WSCoption_getItemNum(*args)
    def getItems(*args): return _mpfc.WSCoption_getItems(*args)

class WSCoptionPtr(WSCoption):
    def __init__(self, this):
        _swig_setattr(self, WSCoption, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCoption, 'thisown', 0)
        _swig_setattr(self, WSCoption,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 __repr__(self):
        return "<C WSCgrid instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCgrid, 'this', _mpfc.new_WSCgrid(*args))
        _swig_setattr(self, WSCgrid, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCgrid):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onInputFixed(*args): return _mpfc.WSCgrid_onInputFixed(*args)
    def getCellNo(*args): return _mpfc.WSCgrid_getCellNo(*args)
    def getHColumns(*args): return _mpfc.WSCgrid_getHColumns(*args)
    def getVColumns(*args): return _mpfc.WSCgrid_getVColumns(*args)
    def getItem(*args): return _mpfc.WSCgrid_getItem(*args)
    def setItem(*args): return _mpfc.WSCgrid_setItem(*args)
    def getItemAlignment(*args): return _mpfc.WSCgrid_getItemAlignment(*args)
    def setCellForeColor(*args): return _mpfc.WSCgrid_setCellForeColor(*args)
    def setCellBackColor(*args): return _mpfc.WSCgrid_setCellBackColor(*args)
    def setCellInputStatus(*args): return _mpfc.WSCgrid_setCellInputStatus(*args)
    def getCellInputStatus(*args): return _mpfc.WSCgrid_getCellInputStatus(*args)
    def getFocusedCell(*args): return _mpfc.WSCgrid_getFocusedCell(*args)
    def setFocusedCell(*args): return _mpfc.WSCgrid_setFocusedCell(*args)

class WSCgridPtr(WSCgrid):
    def __init__(self, this):
        _swig_setattr(self, WSCgrid, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCgrid, 'thisown', 0)
        _swig_setattr(self, WSCgrid,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 __repr__(self):
        return "<C WSCvimage instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvimage, 'this', _mpfc.new_WSCvimage(*args))
        _swig_setattr(self, WSCvimage, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvimage):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvimagePtr(WSCvimage):
    def __init__(self, this):
        _swig_setattr(self, WSCvimage, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvimage, 'thisown', 0)
        _swig_setattr(self, WSCvimage,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 __repr__(self):
        return "<C WSCvrect instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvrect, 'this', _mpfc.new_WSCvrect(*args))
        _swig_setattr(self, WSCvrect, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvrect):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvrectPtr(WSCvrect):
    def __init__(self, this):
        _swig_setattr(self, WSCvrect, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvrect, 'thisown', 0)
        _swig_setattr(self, WSCvrect,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 __repr__(self):
        return "<C WSCvarc instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvarc, 'this', _mpfc.new_WSCvarc(*args))
        _swig_setattr(self, WSCvarc, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvarc):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvarcPtr(WSCvarc):
    def __init__(self, this):
        _swig_setattr(self, WSCvarc, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvarc, 'thisown', 0)
        _swig_setattr(self, WSCvarc,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 __repr__(self):
        return "<C WSCvpoly instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvpoly, 'this', _mpfc.new_WSCvpoly(*args))
        _swig_setattr(self, WSCvpoly, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvpoly):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvpolyPtr(WSCvpoly):
    def __init__(self, this):
        _swig_setattr(self, WSCvpoly, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvpoly, 'thisown', 0)
        _swig_setattr(self, WSCvpoly,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 __repr__(self):
        return "<C WSCvline instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvline, 'this', _mpfc.new_WSCvline(*args))
        _swig_setattr(self, WSCvline, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvline):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvlinePtr(WSCvline):
    def __init__(self, this):
        _swig_setattr(self, WSCvline, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvline, 'thisown', 0)
        _swig_setattr(self, WSCvline,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 __repr__(self):
        return "<C WSDimage instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSDimage, 'this', _mpfc.new_WSDimage(*args))
        _swig_setattr(self, WSDimage, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSDimage):
        try:
            if self.thisown: destroy(self)
        except: pass
    def destroyImage(*args): return _mpfc.WSDimage_destroyImage(*args)
    def getImageWidth(*args): return _mpfc.WSDimage_getImageWidth(*args)
    def getImageHeight(*args): return _mpfc.WSDimage_getImageHeight(*args)
    def getReady(*args): return _mpfc.WSDimage_getReady(*args)

class WSDimagePtr(WSDimage):
    def __init__(self, this):
        _swig_setattr(self, WSDimage, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSDimage, 'thisown', 0)
        _swig_setattr(self, WSDimage,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 __repr__(self):
        return "<C WSCvdrawingArea instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvdrawingArea, 'this', _mpfc.new_WSCvdrawingArea(*args))
        _swig_setattr(self, WSCvdrawingArea, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvdrawingArea):
        try:
            if self.thisown: destroy(self)
        except: pass
    def beginDraw(*args): return _mpfc.WSCvdrawingArea_beginDraw(*args)
    def endDraw(*args): return _mpfc.WSCvdrawingArea_endDraw(*args)
    def setForeColor(*args): return _mpfc.WSCvdrawingArea_setForeColor(*args)
    def setBackColor(*args): return _mpfc.WSCvdrawingArea_setBackColor(*args)
    def setLineWidth(*args): return _mpfc.WSCvdrawingArea_setLineWidth(*args)
    def setLineDashType(*args): return _mpfc.WSCvdrawingArea_setLineDashType(*args)
    def setHatchPattern(*args): return _mpfc.WSCvdrawingArea_setHatchPattern(*args)
    def setRegion(*args): return _mpfc.WSCvdrawingArea_setRegion(*args)
    def drawArc(*args): return _mpfc.WSCvdrawingArea_drawArc(*args)
    def drawFillArc(*args): return _mpfc.WSCvdrawingArea_drawFillArc(*args)
    def drawLine(*args): return _mpfc.WSCvdrawingArea_drawLine(*args)
    def drawLines(*args): return _mpfc.WSCvdrawingArea_drawLines(*args)
    def drawRect(*args): return _mpfc.WSCvdrawingArea_drawRect(*args)
    def drawFillRect(*args): return _mpfc.WSCvdrawingArea_drawFillRect(*args)
    def drawRects(*args): return _mpfc.WSCvdrawingArea_drawRects(*args)
    def drawFillRects(*args): return _mpfc.WSCvdrawingArea_drawFillRects(*args)
    def drawPoly(*args): return _mpfc.WSCvdrawingArea_drawPoly(*args)
    def drawFillPoly(*args): return _mpfc.WSCvdrawingArea_drawFillPoly(*args)
    def drawGradation(*args): return _mpfc.WSCvdrawingArea_drawGradation(*args)
    def drawStretchedImage(*args): return _mpfc.WSCvdrawingArea_drawStretchedImage(*args)
    def drawImage(*args): return _mpfc.WSCvdrawingArea_drawImage(*args)
    def drawString(*args): return _mpfc.WSCvdrawingArea_drawString(*args)
    def drawFillString(*args): return _mpfc.WSCvdrawingArea_drawFillString(*args)

class WSCvdrawingAreaPtr(WSCvdrawingArea):
    def __init__(self, this):
        _swig_setattr(self, WSCvdrawingArea, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvdrawingArea, 'thisown', 0)
        _swig_setattr(self, WSCvdrawingArea,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 __repr__(self):
        return "<C WSCvbarGraph instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvbarGraph, 'this', _mpfc.new_WSCvbarGraph(*args))
        _swig_setattr(self, WSCvbarGraph, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvbarGraph):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvbarGraphPtr(WSCvbarGraph):
    def __init__(self, this):
        _swig_setattr(self, WSCvbarGraph, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvbarGraph, 'thisown', 0)
        _swig_setattr(self, WSCvbarGraph,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 __repr__(self):
        return "<C WSCvlineGraph instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvlineGraph, 'this', _mpfc.new_WSCvlineGraph(*args))
        _swig_setattr(self, WSCvlineGraph, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvlineGraph):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvlineGraphPtr(WSCvlineGraph):
    def __init__(self, this):
        _swig_setattr(self, WSCvlineGraph, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvlineGraph, 'thisown', 0)
        _swig_setattr(self, WSCvlineGraph,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 __repr__(self):
        return "<C WSCvgraphScale instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvgraphScale, 'this', _mpfc.new_WSCvgraphScale(*args))
        _swig_setattr(self, WSCvgraphScale, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvgraphScale):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvgraphScalePtr(WSCvgraphScale):
    def __init__(self, this):
        _swig_setattr(self, WSCvgraphScale, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvgraphScale, 'thisown', 0)
        _swig_setattr(self, WSCvgraphScale,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 __repr__(self):
        return "<C WSCvgraphMatrix instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvgraphMatrix, 'this', _mpfc.new_WSCvgraphMatrix(*args))
        _swig_setattr(self, WSCvgraphMatrix, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvgraphMatrix):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvgraphMatrixPtr(WSCvgraphMatrix):
    def __init__(self, this):
        _swig_setattr(self, WSCvgraphMatrix, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvgraphMatrix, 'thisown', 0)
        _swig_setattr(self, WSCvgraphMatrix,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 __repr__(self):
        return "<C WSCvtimer instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvtimer, 'this', _mpfc.new_WSCvtimer(*args))
        _swig_setattr(self, WSCvtimer, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvtimer):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return _mpfc.WSCvtimer_onActivate(*args)

class WSCvtimerPtr(WSCvtimer):
    def __init__(self, this):
        _swig_setattr(self, WSCvtimer, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvtimer, 'thisown', 0)
        _swig_setattr(self, WSCvtimer,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 __repr__(self):
        return "<C WSCvspace instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvspace, 'this', _mpfc.new_WSCvspace(*args))
        _swig_setattr(self, WSCvspace, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvspace):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvspacePtr(WSCvspace):
    def __init__(self, this):
        _swig_setattr(self, WSCvspace, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvspace, 'thisown', 0)
        _swig_setattr(self, WSCvspace,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 __repr__(self):
        return "<C WSCvballoonHelp instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvballoonHelp, 'this', _mpfc.new_WSCvballoonHelp(*args))
        _swig_setattr(self, WSCvballoonHelp, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvballoonHelp):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvballoonHelpPtr(WSCvballoonHelp):
    def __init__(self, this):
        _swig_setattr(self, WSCvballoonHelp, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvballoonHelp, 'thisown', 0)
        _swig_setattr(self, WSCvballoonHelp,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 __repr__(self):
        return "<C WSCvcsocket instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvcsocket, 'this', _mpfc.new_WSCvcsocket(*args))
        _swig_setattr(self, WSCvcsocket, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvcsocket):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return _mpfc.WSCvcsocket_onActivate(*args)
    def read(*args): return _mpfc.WSCvcsocket_read(*args)
    def write(*args): return _mpfc.WSCvcsocket_write(*args)
    def execX(*args): return _mpfc.WSCvcsocket_execX(*args)
    def setBindAddr(*args): return _mpfc.WSCvcsocket_setBindAddr(*args)
    def getBindAddr(*args): return _mpfc.WSCvcsocket_getBindAddr(*args)
    def getErrorMessage(*args): return _mpfc.WSCvcsocket_getErrorMessage(*args)

class WSCvcsocketPtr(WSCvcsocket):
    def __init__(self, this):
        _swig_setattr(self, WSCvcsocket, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvcsocket, 'thisown', 0)
        _swig_setattr(self, WSCvcsocket,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 __repr__(self):
        return "<C WSCvssocket instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvssocket, 'this', _mpfc.new_WSCvssocket(*args))
        _swig_setattr(self, WSCvssocket, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvssocket):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return _mpfc.WSCvssocket_onActivate(*args)
    def read(*args): return _mpfc.WSCvssocket_read(*args)
    def write(*args): return _mpfc.WSCvssocket_write(*args)
    def getDestAddr(*args): return _mpfc.WSCvssocket_getDestAddr(*args)
    def getErrorMessage(*args): return _mpfc.WSCvssocket_getErrorMessage(*args)

class WSCvssocketPtr(WSCvssocket):
    def __init__(self, this):
        _swig_setattr(self, WSCvssocket, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvssocket, 'thisown', 0)
        _swig_setattr(self, WSCvssocket,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 __repr__(self):
        return "<C WSCvudpsocket instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvudpsocket, 'this', _mpfc.new_WSCvudpsocket(*args))
        _swig_setattr(self, WSCvudpsocket, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvudpsocket):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onActivate(*args): return _mpfc.WSCvudpsocket_onActivate(*args)
    def read(*args): return _mpfc.WSCvudpsocket_read(*args)
    def write(*args): return _mpfc.WSCvudpsocket_write(*args)
    def getDestAddr(*args): return _mpfc.WSCvudpsocket_getDestAddr(*args)
    def setBindAddr(*args): return _mpfc.WSCvudpsocket_setBindAddr(*args)
    def getBindAddr(*args): return _mpfc.WSCvudpsocket_getBindAddr(*args)
    def start(*args): return _mpfc.WSCvudpsocket_start(*args)
    def stop(*args): return _mpfc.WSCvudpsocket_stop(*args)
    def getErrorMessage(*args): return _mpfc.WSCvudpsocket_getErrorMessage(*args)

class WSCvudpsocketPtr(WSCvudpsocket):
    def __init__(self, this):
        _swig_setattr(self, WSCvudpsocket, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvudpsocket, 'thisown', 0)
        _swig_setattr(self, WSCvudpsocket,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 __repr__(self):
        return "<C WSCvremoteClient instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvremoteClient, 'this', _mpfc.new_WSCvremoteClient(*args))
        _swig_setattr(self, WSCvremoteClient, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvremoteClient):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvremoteClientPtr(WSCvremoteClient):
    def __init__(self, this):
        _swig_setattr(self, WSCvremoteClient, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvremoteClient, 'thisown', 0)
        _swig_setattr(self, WSCvremoteClient,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 __repr__(self):
        return "<C WSCvremoteServer instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvremoteServer, 'this', _mpfc.new_WSCvremoteServer(*args))
        _swig_setattr(self, WSCvremoteServer, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvremoteServer):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvremoteServerPtr(WSCvremoteServer):
    def __init__(self, this):
        _swig_setattr(self, WSCvremoteServer, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvremoteServer, 'thisown', 0)
        _swig_setattr(self, WSCvremoteServer,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 __repr__(self):
        return "<C WSCvdb instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvdb, 'this', _mpfc.new_WSCvdb(*args))
        _swig_setattr(self, WSCvdb, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvdb):
        try:
            if self.thisown: destroy(self)
        except: pass
    def open(*args): return _mpfc.WSCvdb_open(*args)
    def close(*args): return _mpfc.WSCvdb_close(*args)
    def isOpen(*args): return _mpfc.WSCvdb_isOpen(*args)
    def sqlExecute(*args): return _mpfc.WSCvdb_sqlExecute(*args)
    def beginTran(*args): return _mpfc.WSCvdb_beginTran(*args)
    def commitTran(*args): return _mpfc.WSCvdb_commitTran(*args)
    def abortTran(*args): return _mpfc.WSCvdb_abortTran(*args)
    def getErrorMessage(*args): return _mpfc.WSCvdb_getErrorMessage(*args)

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

WSCDB_SQL_CONCUR_READ_ONLY = _mpfc.WSCDB_SQL_CONCUR_READ_ONLY
WSCDB_SQL_CONCUR_LOCK = _mpfc.WSCDB_SQL_CONCUR_LOCK
WSCDB_SQL_CONCUR_ROWVER = _mpfc.WSCDB_SQL_CONCUR_ROWVER
WSCDB_SQL_CONCUR_VALUES = _mpfc.WSCDB_SQL_CONCUR_VALUES
WSCDB_SQL_CONCUR_DEFAULT = _mpfc.WSCDB_SQL_CONCUR_DEFAULT
WSCDB_SQL_CURSOR_FORWARD_ONLY = _mpfc.WSCDB_SQL_CURSOR_FORWARD_ONLY
WSCDB_SQL_CURSOR_KEYSET_DRIVEN = _mpfc.WSCDB_SQL_CURSOR_KEYSET_DRIVEN
WSCDB_SQL_CURSOR_DYNAMIC = _mpfc.WSCDB_SQL_CURSOR_DYNAMIC
WSCDB_SQL_CURSOR_STATIC = _mpfc.WSCDB_SQL_CURSOR_STATIC
WSCDB_SQL_CURSOR_TYPE_DEFAULT = _mpfc.WSCDB_SQL_CURSOR_TYPE_DEFAULT
WSCDB_FIELD_TYPE_CHAR = _mpfc.WSCDB_FIELD_TYPE_CHAR
WSCDB_FIELD_TYPE_NUMERIC = _mpfc.WSCDB_FIELD_TYPE_NUMERIC
WSCDB_FIELD_TYPE_DECIMAL = _mpfc.WSCDB_FIELD_TYPE_DECIMAL
WSCDB_FIELD_TYPE_INTEGER = _mpfc.WSCDB_FIELD_TYPE_INTEGER
WSCDB_FIELD_TYPE_SMALLINT = _mpfc.WSCDB_FIELD_TYPE_SMALLINT
WSCDB_FIELD_TYPE_FLOAT = _mpfc.WSCDB_FIELD_TYPE_FLOAT
WSCDB_FIELD_TYPE_REAL = _mpfc.WSCDB_FIELD_TYPE_REAL
WSCDB_FIELD_TYPE_DOUBLE = _mpfc.WSCDB_FIELD_TYPE_DOUBLE
WSCDB_FIELD_TYPE_DATE = _mpfc.WSCDB_FIELD_TYPE_DATE
WSCDB_FIELD_TYPE_TIME = _mpfc.WSCDB_FIELD_TYPE_TIME
WSCDB_FIELD_TYPE_TIMESTAMP = _mpfc.WSCDB_FIELD_TYPE_TIMESTAMP
WSCDB_FIELD_TYPE_NONE = _mpfc.WSCDB_FIELD_TYPE_NONE
class WSCdbRecord(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCdbRecord, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WSCdbRecord, name)
    def __repr__(self):
        return "<C WSCdbRecord instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCdbRecord, 'this', _mpfc.new_WSCdbRecord(*args))
        _swig_setattr(self, WSCdbRecord, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCdbRecord):
        try:
            if self.thisown: destroy(self)
        except: pass
    def open(*args): return _mpfc.WSCdbRecord_open(*args)
    def close(*args): return _mpfc.WSCdbRecord_close(*args)
    def isEOF(*args): return _mpfc.WSCdbRecord_isEOF(*args)
    def isOpen(*args): return _mpfc.WSCdbRecord_isOpen(*args)
    def getColValue(*args): return _mpfc.WSCdbRecord_getColValue(*args)
    def setColValue(*args): return _mpfc.WSCdbRecord_setColValue(*args)
    def edit(*args): return _mpfc.WSCdbRecord_edit(*args)
    def update(*args): return _mpfc.WSCdbRecord_update(*args)
    def addnew(*args): return _mpfc.WSCdbRecord_addnew(*args)
    def deleterow(*args): return _mpfc.WSCdbRecord_deleterow(*args)
    def moveNext(*args): return _mpfc.WSCdbRecord_moveNext(*args)
    def movePrevious(*args): return _mpfc.WSCdbRecord_movePrevious(*args)
    def moveFirst(*args): return _mpfc.WSCdbRecord_moveFirst(*args)
    def moveLast(*args): return _mpfc.WSCdbRecord_moveLast(*args)
    def getColIndex(*args): return _mpfc.WSCdbRecord_getColIndex(*args)
    def getColType(*args): return _mpfc.WSCdbRecord_getColType(*args)
    def getColLength(*args): return _mpfc.WSCdbRecord_getColLength(*args)
    def getRowCount(*args): return _mpfc.WSCdbRecord_getRowCount(*args)
    def getColCount(*args): return _mpfc.WSCdbRecord_getColCount(*args)

class WSCdbRecordPtr(WSCdbRecord):
    def __init__(self, this):
        _swig_setattr(self, WSCdbRecord, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCdbRecord, 'thisown', 0)
        _swig_setattr(self, WSCdbRecord,self.__class__,WSCdbRecord)
_mpfc.WSCdbRecord_swigregister(WSCdbRecordPtr)

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 __repr__(self):
        return "<C WSCwindow instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCwindow, 'this', _mpfc.new_WSCwindow(*args))
        _swig_setattr(self, WSCwindow, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCwindow):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCwindowPtr(WSCwindow):
    def __init__(self, this):
        _swig_setattr(self, WSCwindow, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCwindow, 'thisown', 0)
        _swig_setattr(self, WSCwindow,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 __repr__(self):
        return "<C WSCmainWindow instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCmainWindow, 'this', _mpfc.new_WSCmainWindow(*args))
        _swig_setattr(self, WSCmainWindow, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCmainWindow):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCmainWindowPtr(WSCmainWindow):
    def __init__(self, this):
        _swig_setattr(self, WSCmainWindow, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCmainWindow, 'thisown', 0)
        _swig_setattr(self, WSCmainWindow,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 __repr__(self):
        return "<C WSCbaseDialog instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCbaseDialog, 'this', _mpfc.new_WSCbaseDialog(*args))
        _swig_setattr(self, WSCbaseDialog, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCbaseDialog):
        try:
            if self.thisown: destroy(self)
        except: pass
    def getStatus(*args): return _mpfc.WSCbaseDialog_getStatus(*args)
    def popup(*args): return _mpfc.WSCbaseDialog_popup(*args)

class WSCbaseDialogPtr(WSCbaseDialog):
    def __init__(self, this):
        _swig_setattr(self, WSCbaseDialog, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCbaseDialog, 'thisown', 0)
        _swig_setattr(self, WSCbaseDialog,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 __repr__(self):
        return "<C WSCdialog instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCdialog, 'this', _mpfc.new_WSCdialog(*args))
        _swig_setattr(self, WSCdialog, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCdialog):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCdialogPtr(WSCdialog):
    def __init__(self, this):
        _swig_setattr(self, WSCdialog, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCdialog, 'thisown', 0)
        _swig_setattr(self, WSCdialog,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 __repr__(self):
        return "<C WSCmessageDialog instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCmessageDialog, 'this', _mpfc.new_WSCmessageDialog(*args))
        _swig_setattr(self, WSCmessageDialog, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCmessageDialog):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCmessageDialogPtr(WSCmessageDialog):
    def __init__(self, this):
        _swig_setattr(self, WSCmessageDialog, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCmessageDialog, 'thisown', 0)
        _swig_setattr(self, WSCmessageDialog,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 __repr__(self):
        return "<C WSCinputDialog instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCinputDialog, 'this', _mpfc.new_WSCinputDialog(*args))
        _swig_setattr(self, WSCinputDialog, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCinputDialog):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCinputDialogPtr(WSCinputDialog):
    def __init__(self, this):
        _swig_setattr(self, WSCinputDialog, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCinputDialog, 'thisown', 0)
        _swig_setattr(self, WSCinputDialog,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 __repr__(self):
        return "<C WSCwizardDialog instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCwizardDialog, 'this', _mpfc.new_WSCwizardDialog(*args))
        _swig_setattr(self, WSCwizardDialog, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCwizardDialog):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCwizardDialogPtr(WSCwizardDialog):
    def __init__(self, this):
        _swig_setattr(self, WSCwizardDialog, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCwizardDialog, 'thisown', 0)
        _swig_setattr(self, WSCwizardDialog,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 __repr__(self):
        return "<C WSCfileSelect instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCfileSelect, 'this', _mpfc.new_WSCfileSelect(*args))
        _swig_setattr(self, WSCfileSelect, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCfileSelect):
        try:
            if self.thisown: destroy(self)
        except: pass
    def getFileName(*args): return _mpfc.WSCfileSelect_getFileName(*args)

class WSCfileSelectPtr(WSCfileSelect):
    def __init__(self, this):
        _swig_setattr(self, WSCfileSelect, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCfileSelect, 'thisown', 0)
        _swig_setattr(self, WSCfileSelect,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 __repr__(self):
        return "<C WSCworkingDialog instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCworkingDialog, 'this', _mpfc.new_WSCworkingDialog(*args))
        _swig_setattr(self, WSCworkingDialog, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCworkingDialog):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCworkingDialogPtr(WSCworkingDialog):
    def __init__(self, this):
        _swig_setattr(self, WSCworkingDialog, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCworkingDialog, 'thisown', 0)
        _swig_setattr(self, WSCworkingDialog,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 __repr__(self):
        return "<C WSCindexForm instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCindexForm, 'this', _mpfc.new_WSCindexForm(*args))
        _swig_setattr(self, WSCindexForm, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCindexForm):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCindexFormPtr(WSCindexForm):
    def __init__(self, this):
        _swig_setattr(self, WSCindexForm, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCindexForm, 'thisown', 0)
        _swig_setattr(self, WSCindexForm,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 __repr__(self):
        return "<C WSCsform instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCsform, 'this', _mpfc.new_WSCsform(*args))
        _swig_setattr(self, WSCsform, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCsform):
        try:
            if self.thisown: destroy(self)
        except: pass
    def getStatus(*args): return _mpfc.WSCsform_getStatus(*args)
    def setAdjustChildren(*args): return _mpfc.WSCsform_setAdjustChildren(*args)
    def setManaged(*args): return _mpfc.WSCsform_setManaged(*args)

class WSCsformPtr(WSCsform):
    def __init__(self, this):
        _swig_setattr(self, WSCsform, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCsform, 'thisown', 0)
        _swig_setattr(self, WSCsform,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 __repr__(self):
        return "<C WSCvtoggle instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvtoggle, 'this', _mpfc.new_WSCvtoggle(*args))
        _swig_setattr(self, WSCvtoggle, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvtoggle):
        try:
            if self.thisown: destroy(self)
        except: pass
    def setStatus(*args): return _mpfc.WSCvtoggle_setStatus(*args)
    def getStatus(*args): return _mpfc.WSCvtoggle_getStatus(*args)
    def getGroupValue(*args): return _mpfc.WSCvtoggle_getGroupValue(*args)
    def setGroupValue(*args): return _mpfc.WSCvtoggle_setGroupValue(*args)
    def clearGroupValue(*args): return _mpfc.WSCvtoggle_clearGroupValue(*args)

class WSCvtogglePtr(WSCvtoggle):
    def __init__(self, this):
        _swig_setattr(self, WSCvtoggle, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvtoggle, 'thisown', 0)
        _swig_setattr(self, WSCvtoggle,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 __repr__(self):
        return "<C WSCvradio instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvradio, 'this', _mpfc.new_WSCvradio(*args))
        _swig_setattr(self, WSCvradio, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvradio):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvradioPtr(WSCvradio):
    def __init__(self, this):
        _swig_setattr(self, WSCvradio, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvradio, 'thisown', 0)
        _swig_setattr(self, WSCvradio,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 __repr__(self):
        return "<C WSCradioGroup instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCradioGroup, 'this', _mpfc.new_WSCradioGroup(*args))
        _swig_setattr(self, WSCradioGroup, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCradioGroup):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onValueChange(*args): return _mpfc.WSCradioGroup_onValueChange(*args)
    def setItemSensitive(*args): return _mpfc.WSCradioGroup_setItemSensitive(*args)
    def getItemSensitive(*args): return _mpfc.WSCradioGroup_getItemSensitive(*args)
    def getItem(*args): return _mpfc.WSCradioGroup_getItem(*args)

class WSCradioGroupPtr(WSCradioGroup):
    def __init__(self, this):
        _swig_setattr(self, WSCradioGroup, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCradioGroup, 'thisown', 0)
        _swig_setattr(self, WSCradioGroup,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 __repr__(self):
        return "<C WSCcheckGroup instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCcheckGroup, 'this', _mpfc.new_WSCcheckGroup(*args))
        _swig_setattr(self, WSCcheckGroup, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCcheckGroup):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCcheckGroupPtr(WSCcheckGroup):
    def __init__(self, this):
        _swig_setattr(self, WSCcheckGroup, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCcheckGroup, 'thisown', 0)
        _swig_setattr(self, WSCcheckGroup,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 __repr__(self):
        return "<C WSCvertForm instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCvertForm, 'this', _mpfc.new_WSCvertForm(*args))
        _swig_setattr(self, WSCvertForm, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCvertForm):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCvertFormPtr(WSCvertForm):
    def __init__(self, this):
        _swig_setattr(self, WSCvertForm, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCvertForm, 'thisown', 0)
        _swig_setattr(self, WSCvertForm,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 __repr__(self):
        return "<C WSChorzForm instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSChorzForm, 'this', _mpfc.new_WSChorzForm(*args))
        _swig_setattr(self, WSChorzForm, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSChorzForm):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSChorzFormPtr(WSChorzForm):
    def __init__(self, this):
        _swig_setattr(self, WSChorzForm, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSChorzForm, 'thisown', 0)
        _swig_setattr(self, WSChorzForm,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 __repr__(self):
        return "<C WSCmenuArea instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCmenuArea, 'this', _mpfc.new_WSCmenuArea(*args))
        _swig_setattr(self, WSCmenuArea, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCmenuArea):
        try:
            if self.thisown: destroy(self)
        except: pass

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

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

class WSCtformPtr(WSCtform):
    def __init__(self, this):
        _swig_setattr(self, WSCtform, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCtform, 'thisown', 0)
        _swig_setattr(self, WSCtform,self.__class__,WSCtform)
_mpfc.WSCtform_swigregister(WSCtformPtr)

class WSCfform(WSCbase):
    __swig_setmethods__ = {}
    for _s in [WSCbase]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCfform, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCbase]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCfform, name)
    def __repr__(self):
        return "<C WSCfform instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCfform, 'this', _mpfc.new_WSCfform(*args))
        _swig_setattr(self, WSCfform, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCfform):
        try:
            if self.thisown: destroy(self)
        except: pass
    def execResizeEvent(*args): return _mpfc.WSCfform_execResizeEvent(*args)
    def setNoRefresh(*args): return _mpfc.WSCfform_setNoRefresh(*args)
    def getNoRefresh(*args): return _mpfc.WSCfform_getNoRefresh(*args)
    def setFloated(*args): return _mpfc.WSCfform_setFloated(*args)
    def getFloated(*args): return _mpfc.WSCfform_getFloated(*args)
    def getPixmapStyle(*args): return _mpfc.WSCfform_getPixmapStyle(*args)

class WSCfformPtr(WSCfform):
    def __init__(self, this):
        _swig_setattr(self, WSCfform, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCfform, 'thisown', 0)
        _swig_setattr(self, WSCfform,self.__class__,WSCfform)
_mpfc.WSCfform_swigregister(WSCfformPtr)

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

class WSCprformPtr(WSCprform):
    def __init__(self, this):
        _swig_setattr(self, WSCprform, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCprform, 'thisown', 0)
        _swig_setattr(self, WSCprform,self.__class__,WSCprform)
_mpfc.WSCprform_swigregister(WSCprformPtr)

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

class WSCj3wformPtr(WSCj3wform):
    def __init__(self, this):
        _swig_setattr(self, WSCj3wform, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCj3wform, 'thisown', 0)
        _swig_setattr(self, WSCj3wform,self.__class__,WSCj3wform)
_mpfc.WSCj3wform_swigregister(WSCj3wformPtr)

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 __repr__(self):
        return "<C WSCscrForm instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCscrForm, 'this', _mpfc.new_WSCscrForm(*args))
        _swig_setattr(self, WSCscrForm, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCscrForm):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onScrMousePress(*args): return _mpfc.WSCscrForm_onScrMousePress(*args)
    def onScrMouseRelease(*args): return _mpfc.WSCscrForm_onScrMouseRelease(*args)
    def onScrMouseMove(*args): return _mpfc.WSCscrForm_onScrMouseMove(*args)
    def getVisibleWidth(*args): return _mpfc.WSCscrForm_getVisibleWidth(*args)
    def getVisibleHeight(*args): return _mpfc.WSCscrForm_getVisibleHeight(*args)
    def getScrFrame(*args): return _mpfc.WSCscrForm_getScrFrame(*args)

class WSCscrFormPtr(WSCscrForm):
    def __init__(self, this):
        _swig_setattr(self, WSCscrForm, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCscrForm, 'thisown', 0)
        _swig_setattr(self, WSCscrForm,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 __repr__(self):
        return "<C WSClist instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSClist, 'this', _mpfc.new_WSClist(*args))
        _swig_setattr(self, WSClist, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSClist):
        try:
            if self.thisown: destroy(self)
        except: pass
    def onSort(*args): return _mpfc.WSClist_onSort(*args)
    def onItemSelected(*args): return _mpfc.WSClist_onItemSelected(*args)
    def onInputFixed(*args): return _mpfc.WSClist_onInputFixed(*args)
    def setLabelHeight(*args): return _mpfc.WSClist_setLabelHeight(*args)
    def delAll(*args): return _mpfc.WSClist_delAll(*args)
    def getLabel(*args): return _mpfc.WSClist_getLabel(*args)
    def getNum(*args): return _mpfc.WSClist_getNum(*args)
    def getItem(*args): return _mpfc.WSClist_getItem(*args)
    def addItem(*args): return _mpfc.WSClist_addItem(*args)
    def replaceItem(*args): return _mpfc.WSClist_replaceItem(*args)
    def delPos(*args): return _mpfc.WSClist_delPos(*args)
    def getPreSelectedPos(*args): return _mpfc.WSClist_getPreSelectedPos(*args)
    def setPreSelectPos(*args): return _mpfc.WSClist_setPreSelectPos(*args)
    def getSelectedPos(*args): return _mpfc.WSClist_getSelectedPos(*args)
    def setSelectPos(*args): return _mpfc.WSClist_setSelectPos(*args)
    def getSelectedItem(*args): return _mpfc.WSClist_getSelectedItem(*args)
    def setTopPos(*args): return _mpfc.WSClist_setTopPos(*args)
    def setBottomPos(*args): return _mpfc.WSClist_setBottomPos(*args)
    def getTopPos(*args): return _mpfc.WSClist_getTopPos(*args)
    def getBottomPos(*args): return _mpfc.WSClist_getBottomPos(*args)
    def updateList(*args): return _mpfc.WSClist_updateList(*args)
    def setLabelProperty(*args): return _mpfc.WSClist_setLabelProperty(*args)
    def setLabelClass(*args): return _mpfc.WSClist_setLabelClass(*args)
    def getSelectItemChanged(*args): return _mpfc.WSClist_getSelectItemChanged(*args)
    def setSelectItemChanged(*args): return _mpfc.WSClist_setSelectItemChanged(*args)
    def setItemVisible(*args): return _mpfc.WSClist_setItemVisible(*args)
    def setItemValue(*args): return _mpfc.WSClist_setItemValue(*args)
    def getItemValue(*args): return _mpfc.WSClist_getItemValue(*args)
    def getInputString(*args): return _mpfc.WSClist_getInputString(*args)
    def cancelInput(*args): return _mpfc.WSClist_cancelInput(*args)
    def getSeparator(*args): return _mpfc.WSClist_getSeparator(*args)

class WSClistPtr(WSClist):
    def __init__(self, this):
        _swig_setattr(self, WSClist, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSClist, 'thisown', 0)
        _swig_setattr(self, WSClist,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 __repr__(self):
        return "<C WSCverbList instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCverbList, 'this', _mpfc.new_WSCverbList(*args))
        _swig_setattr(self, WSCverbList, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCverbList):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCverbListPtr(WSCverbList):
    def __init__(self, this):
        _swig_setattr(self, WSCverbList, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCverbList, 'thisown', 0)
        _swig_setattr(self, WSCverbList,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 __repr__(self):
        return "<C WSCtreeList instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCtreeList, 'this', _mpfc.new_WSCtreeList(*args))
        _swig_setattr(self, WSCtreeList, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCtreeList):
        try:
            if self.thisown: destroy(self)
        except: pass

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

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

class WSCdirTreePtr(WSCdirTree):
    def __init__(self, this):
        _swig_setattr(self, WSCdirTree, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCdirTree, 'thisown', 0)
        _swig_setattr(self, WSCdirTree,self.__class__,WSCdirTree)
_mpfc.WSCdirTree_swigregister(WSCdirTreePtr)


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 __repr__(self):
        return "<C WSDcolor instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSDcolor, 'this', _mpfc.new_WSDcolor(*args))
        _swig_setattr(self, WSDcolor, 'thisown', 1)
    def getColorName(*args): return _mpfc.WSDcolor_getColorName(*args)
    def getUsePrivateCell(*args): return _mpfc.WSDcolor_getUsePrivateCell(*args)
    def setUsePrivateCell(*args): return _mpfc.WSDcolor_setUsePrivateCell(*args)
    def getRGB(*args): return _mpfc.WSDcolor_getRGB(*args)
    def setColorName(*args): return _mpfc.WSDcolor_setColorName(*args)
    def __del__(self, destroy=_mpfc.delete_WSDcolor):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSDcolorPtr(WSDcolor):
    def __init__(self, this):
        _swig_setattr(self, WSDcolor, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSDcolor, 'thisown', 0)
        _swig_setattr(self, WSDcolor,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 __repr__(self):
        return "<C WSCcolorSet instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCcolorSet, 'this', _mpfc.new_WSCcolorSet(*args))
        _swig_setattr(self, WSCcolorSet, 'thisown', 1)
    def getColor(*args): return _mpfc.WSCcolorSet_getColor(*args)
    def getColorName(*args): return _mpfc.WSCcolorSet_getColorName(*args)
    def __del__(self, destroy=_mpfc.delete_WSCcolorSet):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCcolorSetPtr(WSCcolorSet):
    def __init__(self, this):
        _swig_setattr(self, WSCcolorSet, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCcolorSet, 'thisown', 0)
        _swig_setattr(self, WSCcolorSet,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 __repr__(self):
        return "<C WSCimageSet instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCimageSet, 'this', _mpfc.new_WSCimageSet(*args))
        _swig_setattr(self, WSCimageSet, 'thisown', 1)
    def getImageNo(*args): return _mpfc.WSCimageSet_getImageNo(*args)
    def getImage(*args): return _mpfc.WSCimageSet_getImage(*args)
    def getImageName(*args): return _mpfc.WSCimageSet_getImageName(*args)
    def destroyImage(*args): return _mpfc.WSCimageSet_destroyImage(*args)
    def destroyAllImage(*args): return _mpfc.WSCimageSet_destroyAllImage(*args)
    def __del__(self, destroy=_mpfc.delete_WSCimageSet):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSCimageSetPtr(WSCimageSet):
    def __init__(self, this):
        _swig_setattr(self, WSCimageSet, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCimageSet, 'thisown', 0)
        _swig_setattr(self, WSCimageSet,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 __repr__(self):
        return "<C WSDfont instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSDfont, 'this', _mpfc.new_WSDfont(*args))
        _swig_setattr(self, WSDfont, 'thisown', 1)
    def getFontHeight(*args): return _mpfc.WSDfont_getFontHeight(*args)
    def setFontName(*args): return _mpfc.WSDfont_setFontName(*args)
    def getFontName(*args): return _mpfc.WSDfont_getFontName(*args)
    def getStringWidth(*args): return _mpfc.WSDfont_getStringWidth(*args)
    def getStringHeight(*args): return _mpfc.WSDfont_getStringHeight(*args)
    def __del__(self, destroy=_mpfc.delete_WSDfont):
        try:
            if self.thisown: destroy(self)
        except: pass

class WSDfontPtr(WSDfont):
    def __init__(self, this):
        _swig_setattr(self, WSDfont, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSDfont, 'thisown', 0)
        _swig_setattr(self, WSDfont,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 __repr__(self):
        return "<C WSCfontSet instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCfontSet, 'this', _mpfc.new_WSCfontSet(*args))
        _swig_setattr(self, WSCfontSet, 'thisown', 1)
    def getFont(*args): return _mpfc.WSCfontSet_getFont(*args)
    def getStringWidth(*args): return _mpfc.WSCfontSet_getStringWidth(*args)
    def getStringHeight(*args): return _mpfc.WSCfontSet_getStringHeight(*args)
    def setDefaultFont(*args): return _mpfc.WSCfontSet_setDefaultFont(*args)
    def getDefaultFontNo(*args): return _mpfc.WSCfontSet_getDefaultFontNo(*args)
    def getDefaultFont(*args): return _mpfc.WSCfontSet_getDefaultFont(*args)
    def __del__(self, destroy=_mpfc.delete_WSCfontSet):
        try:
            if self.thisown: destroy(self)
        except: pass

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

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

WSGFdestroyPixmap = _mpfc.WSGFdestroyPixmap


WSGIappObjectList = _mpfc.WSGIappObjectList
WSCSHEET_DEFAULT = _mpfc.WSCSHEET_DEFAULT
WSCSHEET_NONE = _mpfc.WSCSHEET_NONE
WSCSHEET_HORZ = _mpfc.WSCSHEET_HORZ
WSCSHEET_VERT = _mpfc.WSCSHEET_VERT
WSCSHEET_BOTH = _mpfc.WSCSHEET_BOTH
WSCSHEET_DEF_ROW_HEIGHT = _mpfc.WSCSHEET_DEF_ROW_HEIGHT
WSCSHEET_DEF_COL_WIDTH = _mpfc.WSCSHEET_DEF_COL_WIDTH
WSCSHEET_DEFCOLOR = _mpfc.WSCSHEET_DEFCOLOR
WSCSHEET_DEFFONT = _mpfc.WSCSHEET_DEFFONT
WSCSHEET_DEF_ROWS = _mpfc.WSCSHEET_DEF_ROWS
WSCSHEET_DEF_COLS = _mpfc.WSCSHEET_DEF_COLS
WSCSHEET_DEF_FIXEDROWS = _mpfc.WSCSHEET_DEF_FIXEDROWS
WSCSHEET_DEF_FIXEDCOLS = _mpfc.WSCSHEET_DEF_FIXEDCOLS
WSCSHEET_DB_SORT_ASC = _mpfc.WSCSHEET_DB_SORT_ASC
WSCSHEET_DB_SORT_DESC = _mpfc.WSCSHEET_DB_SORT_DESC
class WSCsheet(WSCform):
    __swig_setmethods__ = {}
    for _s in [WSCform]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, WSCsheet, name, value)
    __swig_getmethods__ = {}
    for _s in [WSCform]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, WSCsheet, name)
    def __repr__(self):
        return "<C WSCsheet instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, WSCsheet, 'this', _mpfc.new_WSCsheet(*args))
        _swig_setattr(self, WSCsheet, 'thisown', 1)
    def __del__(self, destroy=_mpfc.delete_WSCsheet):
        try:
            if self.thisown: destroy(self)
        except: pass
    def initialize(*args): return _mpfc.WSCsheet_initialize(*args)
    def clear(*args): return _mpfc.WSCsheet_clear(*args)
    def getRowCount(*args): return _mpfc.WSCsheet_getRowCount(*args)
    def setRowCount(*args): return _mpfc.WSCsheet_setRowCount(*args)
    def getColumnCount(*args): return _mpfc.WSCsheet_getColumnCount(*args)
    def setColumnCount(*args): return _mpfc.WSCsheet_setColumnCount(*args)
    def getRowHeight(*args): return _mpfc.WSCsheet_getRowHeight(*args)
    def setRowHeight(*args): return _mpfc.WSCsheet_setRowHeight(*args)
    def getColumnWidth(*args): return _mpfc.WSCsheet_getColumnWidth(*args)
    def setColumnWidth(*args): return _mpfc.WSCsheet_setColumnWidth(*args)
    def getFixedRowCount(*args): return _mpfc.WSCsheet_getFixedRowCount(*args)
    def setFixedRowCount(*args): return _mpfc.WSCsheet_setFixedRowCount(*args)
    def getFixedColumnCount(*args): return _mpfc.WSCsheet_getFixedColumnCount(*args)
    def setFixedColumnCount(*args): return _mpfc.WSCsheet_setFixedColumnCount(*args)
    def getFixedRowHeight(*args): return _mpfc.WSCsheet_getFixedRowHeight(*args)
    def setFixedRowHeight(*args): return _mpfc.WSCsheet_setFixedRowHeight(*args)
    def getFixedColumnWidth(*args): return _mpfc.WSCsheet_getFixedColumnWidth(*args)
    def setFixedColumnWidth(*args): return _mpfc.WSCsheet_setFixedColumnWidth(*args)
    def setSheetBkColor(*args): return _mpfc.WSCsheet_setSheetBkColor(*args)
    def getSheetBkColor(*args): return _mpfc.WSCsheet_getSheetBkColor(*args)
    def setCellDefBkColor(*args): return _mpfc.WSCsheet_setCellDefBkColor(*args)
    def getCellDefBkColor(*args): return _mpfc.WSCsheet_getCellDefBkColor(*args)
    def setCellBkColor(*args): return _mpfc.WSCsheet_setCellBkColor(*args)
    def getCellBkColor(*args): return _mpfc.WSCsheet_getCellBkColor(*args)
    def setCellDefTextColor(*args): return _mpfc.WSCsheet_setCellDefTextColor(*args)
    def getCellDefTextColor(*args): return _mpfc.WSCsheet_getCellDefTextColor(*args)
    def setCellTextColor(*args): return _mpfc.WSCsheet_setCellTextColor(*args)
    def getCellTextColor(*args): return _mpfc.WSCsheet_getCellTextColor(*args)
    def setFixedBkColor(*args): return _mpfc.WSCsheet_setFixedBkColor(*args)
    def getFixedBkColor(*args): return _mpfc.WSCsheet_getFixedBkColor(*args)
    def setFixedTextColor(*args): return _mpfc.WSCsheet_setFixedTextColor(*args)
    def getFixedTextColor(*args): return _mpfc.WSCsheet_getFixedTextColor(*args)
    def setGridColor(*args): return _mpfc.WSCsheet_setGridColor(*args)
    def getGridColor(*args): return _mpfc.WSCsheet_getGridColor(*args)
    def setGridLines(*args): return _mpfc.WSCsheet_setGridLines(*args)
    def getGridLines(*args): return _mpfc.WSCsheet_getGridLines(*args)
    def setCellGridLines(*args): return _mpfc.WSCsheet_setCellGridLines(*args)
    def getCellGridLines(*args): return _mpfc.WSCsheet_getCellGridLines(*args)
    def setText(*args): return _mpfc.WSCsheet_setText(*args)
    def getText(*args): return _mpfc.WSCsheet_getText(*args)
    def setFixedText(*args): return _mpfc.WSCsheet_setFixedText(*args)
    def getFixedText(*args): return _mpfc.WSCsheet_getFixedText(*args)
    def getCellNo(*args): return _mpfc.WSCsheet_getCellNo(*args)
    def setFocusCell(*args): return _mpfc.WSCsheet_setFocusCell(*args)
    def getFocusCell(*args): return _mpfc.WSCsheet_getFocusCell(*args)
    def getFocusCol(*args): return _mpfc.WSCsheet_getFocusCol(*args)
    def getFocusRow(*args): return _mpfc.WSCsheet_getFocusRow(*args)
    def setRow(*args): return _mpfc.WSCsheet_setRow(*args)
    def getRow(*args): return _mpfc.WSCsheet_getRow(*args)
    def setStartRow(*args): return _mpfc.WSCsheet_setStartRow(*args)
    def getStartRow(*args): return _mpfc.WSCsheet_getStartRow(*args)
    def setEndRow(*args): return _mpfc.WSCsheet_setEndRow(*args)
    def getEndRow(*args): return _mpfc.WSCsheet_getEndRow(*args)
    def setCol(*args): return _mpfc.WSCsheet_setCol(*args)
    def getCol(*args): return _mpfc.WSCsheet_getCol(*args)
    def setStartCol(*args): return _mpfc.WSCsheet_setStartCol(*args)
    def getStartCol(*args): return _mpfc.WSCsheet_getStartCol(*args)
    def setEndCol(*args): return _mpfc.WSCsheet_setEndCol(*args)
    def getEndCol(*args): return _mpfc.WSCsheet_getEndCol(*args)
    def setSelectCell(*args): return _mpfc.WSCsheet_setSelectCell(*args)
    def getSelectCell(*args): return _mpfc.WSCsheet_getSelectCell(*args)
    def setEditEnabled(*args): return _mpfc.WSCsheet_setEditEnabled(*args)
    def getEditEnabled(*args): return _mpfc.WSCsheet_getEditEnabled(*args)
    def getFocusCellRect(*args): return _mpfc.WSCsheet_getFocusCellRect(*args)
    def getVisibleCellRect(*args): return _mpfc.WSCsheet_getVisibleCellRect(*args)
    def getCellRect(*args): return _mpfc.WSCsheet_getCellRect(*args)
    def setTopVisibleRow(*args): return _mpfc.WSCsheet_setTopVisibleRow(*args)
    def getTopVisibleRow(*args): return _mpfc.WSCsheet_getTopVisibleRow(*args)
    def setTopVisibleCol(*args): return _mpfc.WSCsheet_setTopVisibleCol(*args)
    def getTopVisibleCol(*args): return _mpfc.WSCsheet_getTopVisibleCol(*args)
    def setCellDefFont(*args): return _mpfc.WSCsheet_setCellDefFont(*args)
    def getCellDefFont(*args): return _mpfc.WSCsheet_getCellDefFont(*args)
    def setCellFont(*args): return _mpfc.WSCsheet_setCellFont(*args)
    def getCellFont(*args): return _mpfc.WSCsheet_getCellFont(*args)
    def setFixedCellFont(*args): return _mpfc.WSCsheet_setFixedCellFont(*args)
    def getFixedCellFont(*args): return _mpfc.WSCsheet_getFixedCellFont(*args)
    def setVertAutoNumber(*args): return _mpfc.WSCsheet_setVertAutoNumber(*args)
    def getVertAutoNumber(*args): return _mpfc.WSCsheet_getVertAutoNumber(*args)
    def setHorzAutoNumber(*args): return _mpfc.WSCsheet_setHorzAutoNumber(*args)
    def getHorzAutoNumber(*args): return _mpfc.WSCsheet_getHorzAutoNumber(*args)
    def getCellAlignemnt(*args): return _mpfc.WSCsheet_getCellAlignemnt(*args)
    def getFixedCellAlignemnt(*args): return _mpfc.WSCsheet_getFixedCellAlignemnt(*args)
    def setCellAlignemnt(*args): return _mpfc.WSCsheet_setCellAlignemnt(*args)
    def setFixedCellAlignemnt(*args): return _mpfc.WSCsheet_setFixedCellAlignemnt(*args)
    def setCellLock(*args): return _mpfc.WSCsheet_setCellLock(*args)
    def getCellLock(*args): return _mpfc.WSCsheet_getCellLock(*args)
    def getClientWidth(*args): return _mpfc.WSCsheet_getClientWidth(*args)
    def getClientHeight(*args): return _mpfc.WSCsheet_getClientHeight(*args)
    def setNoRefresh(*args): return _mpfc.WSCsheet_setNoRefresh(*args)
    def getNoRefresh(*args): return _mpfc.WSCsheet_getNoRefresh(*args)
    def insertRow(*args): return _mpfc.WSCsheet_insertRow(*args)
    def insertCol(*args): return _mpfc.WSCsheet_insertCol(*args)
    def deleteRow(*args): return _mpfc.WSCsheet_deleteRow(*args)
    def deleteCol(*args): return _mpfc.WSCsheet_deleteCol(*args)
    def setDataSource(*args): return _mpfc.WSCsheet_setDataSource(*args)
    def getDataSource(*args): return _mpfc.WSCsheet_getDataSource(*args)
    def setTableName(*args): return _mpfc.WSCsheet_setTableName(*args)
    def getTableName(*args): return _mpfc.WSCsheet_getTableName(*args)
    def setDbItem(*args): return _mpfc.WSCsheet_setDbItem(*args)
    def getDbItem(*args): return _mpfc.WSCsheet_getDbItem(*args)
    def setDbSortItem1(*args): return _mpfc.WSCsheet_setDbSortItem1(*args)
    def getDbSortItem1(*args): return _mpfc.WSCsheet_getDbSortItem1(*args)
    def setDbSort1(*args): return _mpfc.WSCsheet_setDbSort1(*args)
    def getDbSort1(*args): return _mpfc.WSCsheet_getDbSort1(*args)
    def setDbSortItem2(*args): return _mpfc.WSCsheet_setDbSortItem2(*args)
    def getDbSortItem2(*args): return _mpfc.WSCsheet_getDbSortItem2(*args)
    def setDbSort2(*args): return _mpfc.WSCsheet_setDbSort2(*args)
    def getDbSort2(*args): return _mpfc.WSCsheet_getDbSort2(*args)
    def setDbSortItem3(*args): return _mpfc.WSCsheet_setDbSortItem3(*args)
    def getDbSortItem3(*args): return _mpfc.WSCsheet_getDbSortItem3(*args)
    def setDbSort3(*args): return _mpfc.WSCsheet_setDbSort3(*args)
    def getDbSort3(*args): return _mpfc.WSCsheet_getDbSort3(*args)
    def setDbFilter(*args): return _mpfc.WSCsheet_setDbFilter(*args)
    def getDbFilter(*args): return _mpfc.WSCsheet_getDbFilter(*args)
    def setDbStmtString(*args): return _mpfc.WSCsheet_setDbStmtString(*args)
    def getDbStmtString(*args): return _mpfc.WSCsheet_getDbStmtString(*args)
    def dbRefresh(*args): return _mpfc.WSCsheet_dbRefresh(*args)

class WSCsheetPtr(WSCsheet):
    def __init__(self, this):
        _swig_setattr(self, WSCsheet, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, WSCsheet, 'thisown', 0)
        _swig_setattr(self, WSCsheet,self.__class__,WSCsheet)
_mpfc.WSCsheet_swigregister(WSCsheetPtr)

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

