# This file was automatically generated by SWIG
package mpfc_perl;
require Exporter;
require DynaLoader;
@ISA = qw(Exporter DynaLoader);
package mpfcc;
bootstrap mpfc_perl;
package mpfc;
@EXPORT = qw( );

# ---------- BASE METHODS -------------

package mpfc;

sub TIEHASH {
    my ($classname,$obj) = @_;
    return bless $obj, $classname;
}

sub CLEAR { }

sub FIRSTKEY { }

sub NEXTKEY { }

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    $self->$member_func();
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    $self->$member_func($newval);
}

sub this {
    my $ptr = shift;
    return tied(%$ptr);
}


# ------- FUNCTION WRAPPERS --------

package mpfc;

*WSGIappDev = *mpfcc::WSGIappDev;
*WSGFwsInitialize = *mpfcc::WSGFwsInitialize;
*WSGFdestroyWindow = *mpfcc::WSGFdestroyWindow;
*WSGFdeviceInitialize = *mpfcc::WSGFdeviceInitialize;
*WSGIappMouse = *mpfcc::WSGIappMouse;
*WSGIappKeyboard = *mpfcc::WSGIappKeyboard;
*WSGIappFileSelect = *mpfcc::WSGIappFileSelect;
*WSGFsetDefaultEncoding = *mpfcc::WSGFsetDefaultEncoding;
*WSGFgettext = *mpfcc::WSGFgettext;
*WSGFimage = *mpfcc::WSGFimage;
*WSGIappColorSet = *mpfcc::WSGIappColorSet;
*WSGFindexColor = *mpfcc::WSGFindexColor;
*WSGFcolorName = *mpfcc::WSGFcolorName;
*WSGFcolor = *mpfcc::WSGFcolor;
*WSGIappImageSet = *mpfcc::WSGIappImageSet;
*WSGFimageName = *mpfcc::WSGFimageName;
*WSGIappFontSet = *mpfcc::WSGIappFontSet;
*WSGFdestroyPixmap = *mpfcc::WSGFdestroyPixmap;
*WSGIappMessageDialog = *mpfcc::WSGIappMessageDialog;
*WSGIappObjectList = *mpfcc::WSGIappObjectList;

############# Class : mpfc::WSCpoint ##############

package mpfc::WSCpoint;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
*swig_x_get = *mpfcc::WSCpoint_x_get;
*swig_x_set = *mpfcc::WSCpoint_x_set;
*swig_y_get = *mpfcc::WSCpoint_y_get;
*swig_y_set = *mpfcc::WSCpoint_y_set;
*setPoint = *mpfcc::WSCpoint_setPoint;
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCpoint(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCpoint($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCrect ##############

package mpfc::WSCrect;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
*swig_x_get = *mpfcc::WSCrect_x_get;
*swig_x_set = *mpfcc::WSCrect_x_set;
*swig_y_get = *mpfcc::WSCrect_y_get;
*swig_y_set = *mpfcc::WSCrect_y_set;
*swig_width_get = *mpfcc::WSCrect_width_get;
*swig_width_set = *mpfcc::WSCrect_width_set;
*swig_height_get = *mpfcc::WSCrect_height_get;
*swig_height_set = *mpfcc::WSCrect_height_set;
*setRect = *mpfcc::WSCrect_setRect;
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCrect(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCrect($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCstring ##############

package mpfc::WSCstring;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCstring(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCstring($self);
        delete $OWNER{$self};
    }
}

*setString = *mpfcc::WSCstring_setString;
*getString = *mpfcc::WSCstring_getString;
*getChars = *mpfcc::WSCstring_getChars;
*getEncoding = *mpfcc::WSCstring_getEncoding;
*isExist = *mpfcc::WSCstring_isExist;
*addString = *mpfcc::WSCstring_addString;
*cutString = *mpfcc::WSCstring_cutString;
*insertString = *mpfcc::WSCstring_insertString;
*deleteChar = *mpfcc::WSCstring_deleteChar;
*deleteChars = *mpfcc::WSCstring_deleteChars;
*clear = *mpfcc::WSCstring_clear;
*delLineFeed = *mpfcc::WSCstring_delLineFeed;
*delString = *mpfcc::WSCstring_delString;
*delHeadSpace = *mpfcc::WSCstring_delHeadSpace;
*delTailSpace = *mpfcc::WSCstring_delTailSpace;
*to_upper = *mpfcc::WSCstring_to_upper;
*to_lower = *mpfcc::WSCstring_to_lower;
*replaceString = *mpfcc::WSCstring_replaceString;
*getWords = *mpfcc::WSCstring_getWords;
*getWordCharPos = *mpfcc::WSCstring_getWordCharPos;
*getWord = *mpfcc::WSCstring_getWord;
*_seek_next_line = *mpfcc::WSCstring__seek_next_line;
*tell = *mpfcc::WSCstring_tell;
*seek = *mpfcc::WSCstring_seek;
*seekEnd = *mpfcc::WSCstring_seekEnd;
*eof = *mpfcc::WSCstring_eof;
*getLines = *mpfcc::WSCstring_getLines;
*gets = *mpfcc::WSCstring_gets;
*eq = *mpfcc::WSCstring_eq;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvariant ##############

package mpfc::WSCvariant;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvariant(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvariant($self);
        delete $OWNER{$self};
    }
}

*getChar = *mpfcc::WSCvariant_getChar;
*getUnsignedChar = *mpfcc::WSCvariant_getUnsignedChar;
*getShort = *mpfcc::WSCvariant_getShort;
*getUnsignedShort = *mpfcc::WSCvariant_getUnsignedShort;
*getLong = *mpfcc::WSCvariant_getLong;
*getUnsignedLong = *mpfcc::WSCvariant_getUnsignedLong;
*getInt = *mpfcc::WSCvariant_getInt;
*getUnsignedInt = *mpfcc::WSCvariant_getUnsignedInt;
*getFloat = *mpfcc::WSCvariant_getFloat;
*getDouble = *mpfcc::WSCvariant_getDouble;
*getCharPtr = *mpfcc::WSCvariant_getCharPtr;
*getInstancePtr = *mpfcc::WSCvariant_getInstancePtr;
*setValue = *mpfcc::WSCvariant_setValue;
*getType = *mpfcc::WSCvariant_getType;
*getTypeName = *mpfcc::WSCvariant_getTypeName;
*clear = *mpfcc::WSCvariant_clear;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSDappDev ##############

package mpfc::WSDappDev;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
*execInitHandler = *mpfcc::WSDappDev_execInitHandler;
*handleEvents = *mpfcc::WSDappDev_handleEvents;
*getInstanceName = *mpfcc::WSDappDev_getInstanceName;
*getWidth = *mpfcc::WSDappDev_getWidth;
*getHeight = *mpfcc::WSDappDev_getHeight;
*update = *mpfcc::WSDappDev_update;
*exit = *mpfcc::WSDappDev_exit;
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSDappDev(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSDappDev($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCbase ##############

package mpfc::WSCbase;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCbase(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCbase($self);
        delete $OWNER{$self};
    }
}

*init = *mpfcc::WSCbase_init;
*getInitialized = *mpfcc::WSCbase_getInitialized;
*onMouseIn = *mpfcc::WSCbase_onMouseIn;
*onMouseOut = *mpfcc::WSCbase_onMouseOut;
*onMouseMove = *mpfcc::WSCbase_onMouseMove;
*onMousePress = *mpfcc::WSCbase_onMousePress;
*onMouseRelease = *mpfcc::WSCbase_onMouseRelease;
*onExpose = *mpfcc::WSCbase_onExpose;
*onResize = *mpfcc::WSCbase_onResize;
*onVisibleChange = *mpfcc::WSCbase_onVisibleChange;
*onSensitiveChange = *mpfcc::WSCbase_onSensitiveChange;
*onParentVisibleChange = *mpfcc::WSCbase_onParentVisibleChange;
*onParentSensitiveChange = *mpfcc::WSCbase_onParentSensitiveChange;
*onEditModeChange = *mpfcc::WSCbase_onEditModeChange;
*onFocusChange = *mpfcc::WSCbase_onFocusChange;
*onSpecialFocusChange = *mpfcc::WSCbase_onSpecialFocusChange;
*onChildAdded = *mpfcc::WSCbase_onChildAdded;
*onSelectionChange = *mpfcc::WSCbase_onSelectionChange;
*onGuiPolicyChange = *mpfcc::WSCbase_onGuiPolicyChange;
*onDefaultColorChange = *mpfcc::WSCbase_onDefaultColorChange;
*getInstanceName = *mpfcc::WSCbase_getInstanceName;
*setVisible = *mpfcc::WSCbase_setVisible;
*getVisible = *mpfcc::WSCbase_getVisible;
*getProperty = *mpfcc::WSCbase_getProperty;
*setProperty = *mpfcc::WSCbase_setProperty;
*addProcedure = *mpfcc::WSCbase_addProcedure;
*setParent = *mpfcc::WSCbase_setParent;
*getParent = *mpfcc::WSCbase_getParent;
*getParentWindow = *mpfcc::WSCbase_getParentWindow;
*getChildInstance = *mpfcc::WSCbase_getChildInstance;
*setInternalObject = *mpfcc::WSCbase_setInternalObject;
*getInternalObject = *mpfcc::WSCbase_getInternalObject;
*setDefaultValue = *mpfcc::WSCbase_setDefaultValue;
*existProperty = *mpfcc::WSCbase_existProperty;
*getDefaultProperty = *mpfcc::WSCbase_getDefaultProperty;
*setFocus = *mpfcc::WSCbase_setFocus;
*setSpecialFocus = *mpfcc::WSCbase_setSpecialFocus;
*setParentVisible = *mpfcc::WSCbase_setParentVisible;
*setSensitive = *mpfcc::WSCbase_setSensitive;
*setParentSensitive = *mpfcc::WSCbase_setParentSensitive;
*getParentVisible = *mpfcc::WSCbase_getParentVisible;
*getSensitive = *mpfcc::WSCbase_getSensitive;
*getParentSensitive = *mpfcc::WSCbase_getParentSensitive;
*getFocus = *mpfcc::WSCbase_getFocus;
*getSpecialFocus = *mpfcc::WSCbase_getSpecialFocus;
*setAbsoluteDraw = *mpfcc::WSCbase_setAbsoluteDraw;
*getAbsoluteDraw = *mpfcc::WSCbase_getAbsoluteDraw;
*setUserData = *mpfcc::WSCbase_setUserData;
*getUserData = *mpfcc::WSCbase_getUserData;
*setVariantData = *mpfcc::WSCbase_setVariantData;
*getVariantData = *mpfcc::WSCbase_getVariantData;
*execProcedure = *mpfcc::WSCbase_execProcedure;
*draw = *mpfcc::WSCbase_draw;
*clear = *mpfcc::WSCbase_clear;
*redraw = *mpfcc::WSCbase_redraw;
*cdraw = *mpfcc::WSCbase_cdraw;
*getNewInstance = *mpfcc::WSCbase_getNewInstance;
*getFocusInstance = *mpfcc::WSCbase_getFocusInstance;
*getSpecialFocusInstance = *mpfcc::WSCbase_getSpecialFocusInstance;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSDmouse ##############

package mpfc::WSDmouse;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSDmouse(@_);
    bless $self, $pkg if defined($self);
}

*getMousePosition = *mpfcc::WSDmouse_getMousePosition;
*getMouseStatus = *mpfcc::WSDmouse_getMouseStatus;
*setMousePosition = *mpfcc::WSDmouse_setMousePosition;
*setMouseCursor = *mpfcc::WSDmouse_setMouseCursor;
*addMouseCursor = *mpfcc::WSDmouse_addMouseCursor;
*getMouseCursorName = *mpfcc::WSDmouse_getMouseCursorName;
*getMouseCursorId = *mpfcc::WSDmouse_getMouseCursorId;
*getMouseCursor = *mpfcc::WSDmouse_getMouseCursor;
*getStatus = *mpfcc::WSDmouse_getStatus;
*setStatus = *mpfcc::WSDmouse_setStatus;
*getTargetBtn = *mpfcc::WSDmouse_getTargetBtn;
*setTargetBtn = *mpfcc::WSDmouse_setTargetBtn;
*setMouseFocusClient = *mpfcc::WSDmouse_setMouseFocusClient;
*getMouseFocusClient = *mpfcc::WSDmouse_getMouseFocusClient;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSDmouse($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCform ##############

package mpfc::WSCform;
@ISA = qw( mpfc mpfc::WSCbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCform(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCform($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCnwbase ##############

package mpfc::WSCnwbase;
@ISA = qw( mpfc mpfc::WSCbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCnwbase(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCnwbase($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCngbase ##############

package mpfc::WSCngbase;
@ISA = qw( mpfc mpfc::WSCbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCngbase(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCngbase($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvlabel ##############

package mpfc::WSCvlabel;
@ISA = qw( mpfc mpfc::WSCnwbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvlabel(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvlabel($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvbtn ##############

package mpfc::WSCvbtn;
@ISA = qw( mpfc mpfc::WSCvlabel );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvbtn(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvbtn($self);
        delete $OWNER{$self};
    }
}

*onKey = *mpfcc::WSCvbtn_onKey;
*onActivate = *mpfcc::WSCvbtn_onActivate;
*setDrawFocusBorder = *mpfcc::WSCvbtn_setDrawFocusBorder;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvfbtn ##############

package mpfc::WSCvfbtn;
@ISA = qw( mpfc mpfc::WSCvbtn );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvfbtn(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvfbtn($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvklabel ##############

package mpfc::WSCvklabel;
@ISA = qw( mpfc mpfc::WSCvlabel );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvklabel(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvklabel($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvkflabel ##############

package mpfc::WSCvkflabel;
@ISA = qw( mpfc mpfc::WSCvklabel );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvkflabel(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvkflabel($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSDkeyboard ##############

package mpfc::WSDkeyboard;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
*setKey = *mpfcc::WSDkeyboard_setKey;
*getKey = *mpfcc::WSDkeyboard_getKey;
*withShift = *mpfcc::WSDkeyboard_withShift;
*withLock = *mpfcc::WSDkeyboard_withLock;
*withCntl = *mpfcc::WSDkeyboard_withCntl;
*withAlt = *mpfcc::WSDkeyboard_withAlt;
*isCursorKey = *mpfcc::WSDkeyboard_isCursorKey;
*isFuncKey = *mpfcc::WSDkeyboard_isFuncKey;
*isTtyFunction = *mpfcc::WSDkeyboard_isTtyFunction;
*getFepStatus = *mpfcc::WSDkeyboard_getFepStatus;
*getEnableFep = *mpfcc::WSDkeyboard_getEnableFep;
*isPressed = *mpfcc::WSDkeyboard_isPressed;
*setWithShift = *mpfcc::WSDkeyboard_setWithShift;
*setWithLock = *mpfcc::WSDkeyboard_setWithLock;
*setWithCntl = *mpfcc::WSDkeyboard_setWithCntl;
*setWithAlt = *mpfcc::WSDkeyboard_setWithAlt;
*setIsCursorKey = *mpfcc::WSDkeyboard_setIsCursorKey;
*setIsFuncKey = *mpfcc::WSDkeyboard_setIsFuncKey;
*setIsTtyFunction = *mpfcc::WSDkeyboard_setIsTtyFunction;
*setIsPressed = *mpfcc::WSDkeyboard_setIsPressed;
*getTextString = *mpfcc::WSDkeyboard_getTextString;
*getText = *mpfcc::WSDkeyboard_getText;
*setSelectedString = *mpfcc::WSDkeyboard_setSelectedString;
*getSelectedString = *mpfcc::WSDkeyboard_getSelectedString;
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSDkeyboard(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSDkeyboard($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvifield ##############

package mpfc::WSCvifield;
@ISA = qw( mpfc mpfc::WSCvlabel );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvifield(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvifield($self);
        delete $OWNER{$self};
    }
}

*onCursorBlink = *mpfcc::WSCvifield_onCursorBlink;
*onKeyHook = *mpfcc::WSCvifield_onKeyHook;
*onKeyInput = *mpfcc::WSCvifield_onKeyInput;
*onKey = *mpfcc::WSCvifield_onKey;
*onActivate = *mpfcc::WSCvifield_onActivate;
*onValueChange = *mpfcc::WSCvifield_onValueChange;
*onSelectionChange = *mpfcc::WSCvifield_onSelectionChange;
*onVisibleChange = *mpfcc::WSCvifield_onVisibleChange;
*onParentVisibleChange = *mpfcc::WSCvifield_onParentVisibleChange;
*setCursorFore = *mpfcc::WSCvifield_setCursorFore;
*getCursorFore = *mpfcc::WSCvifield_getCursorFore;
*setCurPos = *mpfcc::WSCvifield_setCurPos;
*replaceSelectedString = *mpfcc::WSCvifield_replaceSelectedString;
*getSelectedString = *mpfcc::WSCvifield_getSelectedString;
*deleteSelectedString = *mpfcc::WSCvifield_deleteSelectedString;
*setSelect = *mpfcc::WSCvifield_setSelect;
*getSelectedPos = *mpfcc::WSCvifield_getSelectedPos;
*getString = *mpfcc::WSCvifield_getString;
*addString = *mpfcc::WSCvifield_addString;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvkslabel ##############

package mpfc::WSCvkslabel;
@ISA = qw( mpfc mpfc::WSCvifield );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvkslabel(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvkslabel($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvmifield ##############

package mpfc::WSCvmifield;
@ISA = qw( mpfc mpfc::WSCvifield );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvmifield(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvmifield($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvpifield ##############

package mpfc::WSCvpifield;
@ISA = qw( mpfc mpfc::WSCvifield );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvpifield(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvpifield($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCtextField ##############

package mpfc::WSCtextField;
@ISA = qw( mpfc mpfc::WSCform );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCtextField(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCtextField($self);
        delete $OWNER{$self};
    }
}

*addString = *mpfcc::WSCtextField_addString;
*replaceSelectedString = *mpfcc::WSCtextField_replaceSelectedString;
*getSelectedString = *mpfcc::WSCtextField_getSelectedString;
*getString = *mpfcc::WSCtextField_getString;
*deleteSelectedString = *mpfcc::WSCtextField_deleteSelectedString;
*setSelect = *mpfcc::WSCtextField_setSelect;
*getSelectedPos = *mpfcc::WSCtextField_getSelectedPos;
*getLines = *mpfcc::WSCtextField_getLines;
*getTopLine = *mpfcc::WSCtextField_getTopLine;
*setTopLine = *mpfcc::WSCtextField_setTopLine;
*getBottomLine = *mpfcc::WSCtextField_getBottomLine;
*setBottomLine = *mpfcc::WSCtextField_setBottomLine;
*getTextFrame = *mpfcc::WSCtextField_getTextFrame;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvarrow ##############

package mpfc::WSCvarrow;
@ISA = qw( mpfc mpfc::WSCvbtn );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvarrow(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvarrow($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvscrBar ##############

package mpfc::WSCvscrBar;
@ISA = qw( mpfc mpfc::WSCnwbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvscrBar(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvscrBar($self);
        delete $OWNER{$self};
    }
}

*onActivate = *mpfcc::WSCvscrBar_onActivate;
*onBegin = *mpfcc::WSCvscrBar_onBegin;
*onEnd = *mpfcc::WSCvscrBar_onEnd;
*onIncrement = *mpfcc::WSCvscrBar_onIncrement;
*onDecrement = *mpfcc::WSCvscrBar_onDecrement;
*onPageIncrement = *mpfcc::WSCvscrBar_onPageIncrement;
*onPageDecrement = *mpfcc::WSCvscrBar_onPageDecrement;
*onValueChange = *mpfcc::WSCvscrBar_onValueChange;
*getMaxSlideValue = *mpfcc::WSCvscrBar_getMaxSlideValue;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvpolyAttr ##############

package mpfc::WSCvpolyAttr;
@ISA = qw( mpfc mpfc::WSCnwbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvpolyAttr(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvpolyAttr($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvmeter ##############

package mpfc::WSCvmeter;
@ISA = qw( mpfc mpfc::WSCvpolyAttr );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvmeter(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvmeter($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvclock ##############

package mpfc::WSCvclock;
@ISA = qw( mpfc mpfc::WSCvlabel );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvclock(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvclock($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvslider ##############

package mpfc::WSCvslider;
@ISA = qw( mpfc mpfc::WSCnwbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvslider(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvslider($self);
        delete $OWNER{$self};
    }
}

*onActivate = *mpfcc::WSCvslider_onActivate;
*onDragInterval = *mpfcc::WSCvslider_onDragInterval;
*onValueChange = *mpfcc::WSCvslider_onValueChange;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCpulldownMenu ##############

package mpfc::WSCpulldownMenu;
@ISA = qw( mpfc mpfc::WSCvlabel );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCpulldownMenu(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCpulldownMenu($self);
        delete $OWNER{$self};
    }
}

*onActivate = *mpfcc::WSCpulldownMenu_onActivate;
*setItemSensitive = *mpfcc::WSCpulldownMenu_setItemSensitive;
*setValueSensitive = *mpfcc::WSCpulldownMenu_setValueSensitive;
*getItemSensitive = *mpfcc::WSCpulldownMenu_getItemSensitive;
*getValue = *mpfcc::WSCpulldownMenu_getValue;
*getItems = *mpfcc::WSCpulldownMenu_getItems;
*beginCascade = *mpfcc::WSCpulldownMenu_beginCascade;
*addItem = *mpfcc::WSCpulldownMenu_addItem;
*endCascade = *mpfcc::WSCpulldownMenu_endCascade;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCcomboBox ##############

package mpfc::WSCcomboBox;
@ISA = qw( mpfc mpfc::WSCform );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCcomboBox(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCcomboBox($self);
        delete $OWNER{$self};
    }
}

*onActivate = *mpfcc::WSCcomboBox_onActivate;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCoption ##############

package mpfc::WSCoption;
@ISA = qw( mpfc mpfc::WSCform );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCoption(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCoption($self);
        delete $OWNER{$self};
    }
}

*onActivate = *mpfcc::WSCoption_onActivate;
*onValueChange = *mpfcc::WSCoption_onValueChange;
*setItemSensitive = *mpfcc::WSCoption_setItemSensitive;
*setSelectValue = *mpfcc::WSCoption_setSelectValue;
*getValue = *mpfcc::WSCoption_getValue;
*getItemValue = *mpfcc::WSCoption_getItemValue;
*getSelectStatus = *mpfcc::WSCoption_getSelectStatus;
*getItemNum = *mpfcc::WSCoption_getItemNum;
*getItems = *mpfcc::WSCoption_getItems;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCgrid ##############

package mpfc::WSCgrid;
@ISA = qw( mpfc mpfc::WSCform );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCgrid(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCgrid($self);
        delete $OWNER{$self};
    }
}

*onInputFixed = *mpfcc::WSCgrid_onInputFixed;
*getCellNo = *mpfcc::WSCgrid_getCellNo;
*getHColumns = *mpfcc::WSCgrid_getHColumns;
*getVColumns = *mpfcc::WSCgrid_getVColumns;
*getItem = *mpfcc::WSCgrid_getItem;
*setItem = *mpfcc::WSCgrid_setItem;
*getItemAlignment = *mpfcc::WSCgrid_getItemAlignment;
*setCellForeColor = *mpfcc::WSCgrid_setCellForeColor;
*setCellBackColor = *mpfcc::WSCgrid_setCellBackColor;
*setCellInputStatus = *mpfcc::WSCgrid_setCellInputStatus;
*getCellInputStatus = *mpfcc::WSCgrid_getCellInputStatus;
*getFocusedCell = *mpfcc::WSCgrid_getFocusedCell;
*setFocusedCell = *mpfcc::WSCgrid_setFocusedCell;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvimage ##############

package mpfc::WSCvimage;
@ISA = qw( mpfc mpfc::WSCnwbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvimage(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvimage($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvrect ##############

package mpfc::WSCvrect;
@ISA = qw( mpfc mpfc::WSCvpolyAttr );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvrect(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvrect($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvarc ##############

package mpfc::WSCvarc;
@ISA = qw( mpfc mpfc::WSCvpolyAttr );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvarc(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvarc($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvpoly ##############

package mpfc::WSCvpoly;
@ISA = qw( mpfc mpfc::WSCvpolyAttr );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvpoly(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvpoly($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvline ##############

package mpfc::WSCvline;
@ISA = qw( mpfc mpfc::WSCnwbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvline(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvline($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSDimage ##############

package mpfc::WSDimage;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSDimage(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSDimage($self);
        delete $OWNER{$self};
    }
}

*destroyImage = *mpfcc::WSDimage_destroyImage;
*getImageWidth = *mpfcc::WSDimage_getImageWidth;
*getImageHeight = *mpfcc::WSDimage_getImageHeight;
*getReady = *mpfcc::WSDimage_getReady;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvdrawingArea ##############

package mpfc::WSCvdrawingArea;
@ISA = qw( mpfc mpfc::WSCnwbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvdrawingArea(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvdrawingArea($self);
        delete $OWNER{$self};
    }
}

*beginDraw = *mpfcc::WSCvdrawingArea_beginDraw;
*endDraw = *mpfcc::WSCvdrawingArea_endDraw;
*setForeColor = *mpfcc::WSCvdrawingArea_setForeColor;
*setBackColor = *mpfcc::WSCvdrawingArea_setBackColor;
*setLineWidth = *mpfcc::WSCvdrawingArea_setLineWidth;
*setLineDashType = *mpfcc::WSCvdrawingArea_setLineDashType;
*setHatchPattern = *mpfcc::WSCvdrawingArea_setHatchPattern;
*setRegion = *mpfcc::WSCvdrawingArea_setRegion;
*drawArc = *mpfcc::WSCvdrawingArea_drawArc;
*drawFillArc = *mpfcc::WSCvdrawingArea_drawFillArc;
*drawLine = *mpfcc::WSCvdrawingArea_drawLine;
*drawLines = *mpfcc::WSCvdrawingArea_drawLines;
*drawRect = *mpfcc::WSCvdrawingArea_drawRect;
*drawFillRect = *mpfcc::WSCvdrawingArea_drawFillRect;
*drawRects = *mpfcc::WSCvdrawingArea_drawRects;
*drawFillRects = *mpfcc::WSCvdrawingArea_drawFillRects;
*drawPoly = *mpfcc::WSCvdrawingArea_drawPoly;
*drawFillPoly = *mpfcc::WSCvdrawingArea_drawFillPoly;
*drawGradation = *mpfcc::WSCvdrawingArea_drawGradation;
*drawImage = *mpfcc::WSCvdrawingArea_drawImage;
*drawStretchedImage = *mpfcc::WSCvdrawingArea_drawStretchedImage;
*drawString = *mpfcc::WSCvdrawingArea_drawString;
*drawFillString = *mpfcc::WSCvdrawingArea_drawFillString;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvbarGraph ##############

package mpfc::WSCvbarGraph;
@ISA = qw( mpfc mpfc::WSCnwbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvbarGraph(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvbarGraph($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvlineGraph ##############

package mpfc::WSCvlineGraph;
@ISA = qw( mpfc mpfc::WSCnwbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvlineGraph(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvlineGraph($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvgraphScale ##############

package mpfc::WSCvgraphScale;
@ISA = qw( mpfc mpfc::WSCnwbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvgraphScale(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvgraphScale($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvgraphMatrix ##############

package mpfc::WSCvgraphMatrix;
@ISA = qw( mpfc mpfc::WSCnwbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvgraphMatrix(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvgraphMatrix($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvtimer ##############

package mpfc::WSCvtimer;
@ISA = qw( mpfc mpfc::WSCngbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvtimer(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvtimer($self);
        delete $OWNER{$self};
    }
}

*onActivate = *mpfcc::WSCvtimer_onActivate;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvspace ##############

package mpfc::WSCvspace;
@ISA = qw( mpfc mpfc::WSCngbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvspace(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvspace($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvballoonHelp ##############

package mpfc::WSCvballoonHelp;
@ISA = qw( mpfc mpfc::WSCngbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvballoonHelp(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvballoonHelp($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvcsocket ##############

package mpfc::WSCvcsocket;
@ISA = qw( mpfc mpfc::WSCngbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvcsocket(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvcsocket($self);
        delete $OWNER{$self};
    }
}

*onActivate = *mpfcc::WSCvcsocket_onActivate;
*read = *mpfcc::WSCvcsocket_read;
*write = *mpfcc::WSCvcsocket_write;
*exec = *mpfcc::WSCvcsocket_exec;
*setBindAddr = *mpfcc::WSCvcsocket_setBindAddr;
*getBindAddr = *mpfcc::WSCvcsocket_getBindAddr;
*getErrorMessage = *mpfcc::WSCvcsocket_getErrorMessage;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvssocket ##############

package mpfc::WSCvssocket;
@ISA = qw( mpfc mpfc::WSCngbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvssocket(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvssocket($self);
        delete $OWNER{$self};
    }
}

*onActivate = *mpfcc::WSCvssocket_onActivate;
*read = *mpfcc::WSCvssocket_read;
*write = *mpfcc::WSCvssocket_write;
*getDestAddr = *mpfcc::WSCvssocket_getDestAddr;
*getErrorMessage = *mpfcc::WSCvssocket_getErrorMessage;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvudpsocket ##############

package mpfc::WSCvudpsocket;
@ISA = qw( mpfc mpfc::WSCngbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvudpsocket(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvudpsocket($self);
        delete $OWNER{$self};
    }
}

*onActivate = *mpfcc::WSCvudpsocket_onActivate;
*read = *mpfcc::WSCvudpsocket_read;
*write = *mpfcc::WSCvudpsocket_write;
*getDestAddr = *mpfcc::WSCvudpsocket_getDestAddr;
*setBindAddr = *mpfcc::WSCvudpsocket_setBindAddr;
*getBindAddr = *mpfcc::WSCvudpsocket_getBindAddr;
*start = *mpfcc::WSCvudpsocket_start;
*stop = *mpfcc::WSCvudpsocket_stop;
*getErrorMessage = *mpfcc::WSCvudpsocket_getErrorMessage;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvremoteClient ##############

package mpfc::WSCvremoteClient;
@ISA = qw( mpfc mpfc::WSCngbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvremoteClient(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvremoteClient($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvremoteServer ##############

package mpfc::WSCvremoteServer;
@ISA = qw( mpfc mpfc::WSCngbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvremoteServer(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvremoteServer($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvdb ##############

package mpfc::WSCvdb;
@ISA = qw( mpfc mpfc::WSCngbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvdb(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvdb($self);
        delete $OWNER{$self};
    }
}

*open = *mpfcc::WSCvdb_open;
*close = *mpfcc::WSCvdb_close;
*isOpen = *mpfcc::WSCvdb_isOpen;
*sqlExecute = *mpfcc::WSCvdb_sqlExecute;
*beginTran = *mpfcc::WSCvdb_beginTran;
*commitTran = *mpfcc::WSCvdb_commitTran;
*abortTran = *mpfcc::WSCvdb_abortTran;
*getErrorMessage = *mpfcc::WSCvdb_getErrorMessage;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCdbRecord ##############

package mpfc::WSCdbRecord;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCdbRecord(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCdbRecord($self);
        delete $OWNER{$self};
    }
}

*open = *mpfcc::WSCdbRecord_open;
*close = *mpfcc::WSCdbRecord_close;
*isEOF = *mpfcc::WSCdbRecord_isEOF;
*isOpen = *mpfcc::WSCdbRecord_isOpen;
*getColValue = *mpfcc::WSCdbRecord_getColValue;
*setColValue = *mpfcc::WSCdbRecord_setColValue;
*edit = *mpfcc::WSCdbRecord_edit;
*update = *mpfcc::WSCdbRecord_update;
*addnew = *mpfcc::WSCdbRecord_addnew;
*deleterow = *mpfcc::WSCdbRecord_deleterow;
*moveNext = *mpfcc::WSCdbRecord_moveNext;
*movePrevious = *mpfcc::WSCdbRecord_movePrevious;
*moveFirst = *mpfcc::WSCdbRecord_moveFirst;
*moveLast = *mpfcc::WSCdbRecord_moveLast;
*getColIndex = *mpfcc::WSCdbRecord_getColIndex;
*getColType = *mpfcc::WSCdbRecord_getColType;
*getColLength = *mpfcc::WSCdbRecord_getColLength;
*getRowCount = *mpfcc::WSCdbRecord_getRowCount;
*getColCount = *mpfcc::WSCdbRecord_getColCount;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCwindow ##############

package mpfc::WSCwindow;
@ISA = qw( mpfc mpfc::WSCbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCwindow(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCwindow($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCmainWindow ##############

package mpfc::WSCmainWindow;
@ISA = qw( mpfc mpfc::WSCwindow );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCmainWindow(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCmainWindow($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCbaseDialog ##############

package mpfc::WSCbaseDialog;
@ISA = qw( mpfc mpfc::WSCwindow );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCbaseDialog(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCbaseDialog($self);
        delete $OWNER{$self};
    }
}

*getStatus = *mpfcc::WSCbaseDialog_getStatus;
*popup = *mpfcc::WSCbaseDialog_popup;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCdialog ##############

package mpfc::WSCdialog;
@ISA = qw( mpfc mpfc::WSCbaseDialog );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCdialog(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCdialog($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCmessageDialog ##############

package mpfc::WSCmessageDialog;
@ISA = qw( mpfc mpfc::WSCbaseDialog );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCmessageDialog(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCmessageDialog($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCinputDialog ##############

package mpfc::WSCinputDialog;
@ISA = qw( mpfc mpfc::WSCbaseDialog );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCinputDialog(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCinputDialog($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCwizardDialog ##############

package mpfc::WSCwizardDialog;
@ISA = qw( mpfc mpfc::WSCbaseDialog );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCwizardDialog(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCwizardDialog($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCfileSelect ##############

package mpfc::WSCfileSelect;
@ISA = qw( mpfc mpfc::WSCbaseDialog );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCfileSelect(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCfileSelect($self);
        delete $OWNER{$self};
    }
}

*getFileName = *mpfcc::WSCfileSelect_getFileName;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCworkingDialog ##############

package mpfc::WSCworkingDialog;
@ISA = qw( mpfc mpfc::WSCbaseDialog );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCworkingDialog(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCworkingDialog($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCindexForm ##############

package mpfc::WSCindexForm;
@ISA = qw( mpfc mpfc::WSCform );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCindexForm(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCindexForm($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCsform ##############

package mpfc::WSCsform;
@ISA = qw( mpfc mpfc::WSCform );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCsform(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCsform($self);
        delete $OWNER{$self};
    }
}

*getStatus = *mpfcc::WSCsform_getStatus;
*setAdjustChildren = *mpfcc::WSCsform_setAdjustChildren;
*setManaged = *mpfcc::WSCsform_setManaged;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvtoggle ##############

package mpfc::WSCvtoggle;
@ISA = qw( mpfc mpfc::WSCvlabel );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvtoggle(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvtoggle($self);
        delete $OWNER{$self};
    }
}

*setStatus = *mpfcc::WSCvtoggle_setStatus;
*getStatus = *mpfcc::WSCvtoggle_getStatus;
*getGroupValue = *mpfcc::WSCvtoggle_getGroupValue;
*setGroupValue = *mpfcc::WSCvtoggle_setGroupValue;
*clearGroupValue = *mpfcc::WSCvtoggle_clearGroupValue;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvradio ##############

package mpfc::WSCvradio;
@ISA = qw( mpfc mpfc::WSCvtoggle );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvradio(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvradio($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCradioGroup ##############

package mpfc::WSCradioGroup;
@ISA = qw( mpfc mpfc::WSCform );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCradioGroup(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCradioGroup($self);
        delete $OWNER{$self};
    }
}

*onValueChange = *mpfcc::WSCradioGroup_onValueChange;
*setItemSensitive = *mpfcc::WSCradioGroup_setItemSensitive;
*getItemSensitive = *mpfcc::WSCradioGroup_getItemSensitive;
*getItem = *mpfcc::WSCradioGroup_getItem;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCcheckGroup ##############

package mpfc::WSCcheckGroup;
@ISA = qw( mpfc mpfc::WSCradioGroup );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCcheckGroup(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCcheckGroup($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCvertForm ##############

package mpfc::WSCvertForm;
@ISA = qw( mpfc mpfc::WSCform );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCvertForm(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCvertForm($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSChorzForm ##############

package mpfc::WSChorzForm;
@ISA = qw( mpfc mpfc::WSCvertForm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSChorzForm(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSChorzForm($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCmenuArea ##############

package mpfc::WSCmenuArea;
@ISA = qw( mpfc mpfc::WSCform );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCmenuArea(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCmenuArea($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCtform ##############

package mpfc::WSCtform;
@ISA = qw( mpfc mpfc::WSCform );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCtform(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCtform($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCfform ##############

package mpfc::WSCfform;
@ISA = qw( mpfc mpfc::WSCbase );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCfform(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCfform($self);
        delete $OWNER{$self};
    }
}

*execResizeEvent = *mpfcc::WSCfform_execResizeEvent;
*setNoRefresh = *mpfcc::WSCfform_setNoRefresh;
*getNoRefresh = *mpfcc::WSCfform_getNoRefresh;
*setFloated = *mpfcc::WSCfform_setFloated;
*getFloated = *mpfcc::WSCfform_getFloated;
*getPixmapStyle = *mpfcc::WSCfform_getPixmapStyle;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCprform ##############

package mpfc::WSCprform;
@ISA = qw( mpfc mpfc::WSCform );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCprform(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCprform($self);
        delete $OWNER{$self};
    }
}

*prdraw = *mpfcc::WSCprform_prdraw;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCj3wform ##############

package mpfc::WSCj3wform;
@ISA = qw( mpfc mpfc::WSCform );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCj3wform(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCj3wform($self);
        delete $OWNER{$self};
    }
}

*loadFile = *mpfcc::WSCj3wform_loadFile;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCscrForm ##############

package mpfc::WSCscrForm;
@ISA = qw( mpfc mpfc::WSCform );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCscrForm(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCscrForm($self);
        delete $OWNER{$self};
    }
}

*onScrMousePress = *mpfcc::WSCscrForm_onScrMousePress;
*onScrMouseRelease = *mpfcc::WSCscrForm_onScrMouseRelease;
*onScrMouseMove = *mpfcc::WSCscrForm_onScrMouseMove;
*getVisibleWidth = *mpfcc::WSCscrForm_getVisibleWidth;
*getVisibleHeight = *mpfcc::WSCscrForm_getVisibleHeight;
*getScrFrame = *mpfcc::WSCscrForm_getScrFrame;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSClist ##############

package mpfc::WSClist;
@ISA = qw( mpfc mpfc::WSCscrForm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSClist(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSClist($self);
        delete $OWNER{$self};
    }
}

*onSort = *mpfcc::WSClist_onSort;
*onItemSelected = *mpfcc::WSClist_onItemSelected;
*onInputFixed = *mpfcc::WSClist_onInputFixed;
*setLabelHeight = *mpfcc::WSClist_setLabelHeight;
*delAll = *mpfcc::WSClist_delAll;
*getLabel = *mpfcc::WSClist_getLabel;
*getNum = *mpfcc::WSClist_getNum;
*getItem = *mpfcc::WSClist_getItem;
*addItem = *mpfcc::WSClist_addItem;
*replaceItem = *mpfcc::WSClist_replaceItem;
*delPos = *mpfcc::WSClist_delPos;
*getPreSelectedPos = *mpfcc::WSClist_getPreSelectedPos;
*setPreSelectPos = *mpfcc::WSClist_setPreSelectPos;
*getSelectedPos = *mpfcc::WSClist_getSelectedPos;
*setSelectPos = *mpfcc::WSClist_setSelectPos;
*getSelectedItem = *mpfcc::WSClist_getSelectedItem;
*setTopPos = *mpfcc::WSClist_setTopPos;
*setBottomPos = *mpfcc::WSClist_setBottomPos;
*getTopPos = *mpfcc::WSClist_getTopPos;
*getBottomPos = *mpfcc::WSClist_getBottomPos;
*updateList = *mpfcc::WSClist_updateList;
*setLabelProperty = *mpfcc::WSClist_setLabelProperty;
*setLabelClass = *mpfcc::WSClist_setLabelClass;
*getSelectItemChanged = *mpfcc::WSClist_getSelectItemChanged;
*setSelectItemChanged = *mpfcc::WSClist_setSelectItemChanged;
*setItemVisible = *mpfcc::WSClist_setItemVisible;
*setItemValue = *mpfcc::WSClist_setItemValue;
*getItemValue = *mpfcc::WSClist_getItemValue;
*getInputString = *mpfcc::WSClist_getInputString;
*cancelInput = *mpfcc::WSClist_cancelInput;
*getSeparator = *mpfcc::WSClist_getSeparator;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCverbList ##############

package mpfc::WSCverbList;
@ISA = qw( mpfc mpfc::WSClist );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCverbList(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCverbList($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCtreeList ##############

package mpfc::WSCtreeList;
@ISA = qw( mpfc mpfc::WSClist );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCtreeList(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCtreeList($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCdirTree ##############

package mpfc::WSCdirTree;
@ISA = qw( mpfc mpfc::WSCtreeList );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCdirTree(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCdirTree($self);
        delete $OWNER{$self};
    }
}

*setSelectedDirName = *mpfcc::WSCdirTree_setSelectedDirName;
*getSelectedDirName = *mpfcc::WSCdirTree_getSelectedDirName;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSDcolor ##############

package mpfc::WSDcolor;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSDcolor(@_);
    bless $self, $pkg if defined($self);
}

*getColorName = *mpfcc::WSDcolor_getColorName;
*getUsePrivateCell = *mpfcc::WSDcolor_getUsePrivateCell;
*setUsePrivateCell = *mpfcc::WSDcolor_setUsePrivateCell;
*getRGB = *mpfcc::WSDcolor_getRGB;
*setColorName = *mpfcc::WSDcolor_setColorName;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSDcolor($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCcolorSet ##############

package mpfc::WSCcolorSet;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCcolorSet(@_);
    bless $self, $pkg if defined($self);
}

*getColor = *mpfcc::WSCcolorSet_getColor;
*getColorName = *mpfcc::WSCcolorSet_getColorName;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCcolorSet($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCimageSet ##############

package mpfc::WSCimageSet;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCimageSet(@_);
    bless $self, $pkg if defined($self);
}

*getImageNo = *mpfcc::WSCimageSet_getImageNo;
*getImage = *mpfcc::WSCimageSet_getImage;
*getImageName = *mpfcc::WSCimageSet_getImageName;
*destroyImage = *mpfcc::WSCimageSet_destroyImage;
*destroyAllImage = *mpfcc::WSCimageSet_destroyAllImage;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCimageSet($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSDfont ##############

package mpfc::WSDfont;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSDfont(@_);
    bless $self, $pkg if defined($self);
}

*getFontHeight = *mpfcc::WSDfont_getFontHeight;
*setFontName = *mpfcc::WSDfont_setFontName;
*getFontName = *mpfcc::WSDfont_getFontName;
*getStringWidth = *mpfcc::WSDfont_getStringWidth;
*getStringHeight = *mpfcc::WSDfont_getStringHeight;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSDfont($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCfontSet ##############

package mpfc::WSCfontSet;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCfontSet(@_);
    bless $self, $pkg if defined($self);
}

*getFont = *mpfcc::WSCfontSet_getFont;
*getStringWidth = *mpfcc::WSCfontSet_getStringWidth;
*getStringHeight = *mpfcc::WSCfontSet_getStringHeight;
*setDefaultFont = *mpfcc::WSCfontSet_setDefaultFont;
*getDefaultFontNo = *mpfcc::WSCfontSet_getDefaultFontNo;
*getDefaultFont = *mpfcc::WSCfontSet_getDefaultFont;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCfontSet($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCbaseList ##############

package mpfc::WSCbaseList;
@ISA = qw( mpfc );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCbaseList(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCbaseList($self);
        delete $OWNER{$self};
    }
}

*getInstance = *mpfcc::WSCbaseList_getInstance;
*getClassList = *mpfcc::WSCbaseList_getClassList;
*addClient = *mpfcc::WSCbaseList_addClient;
*delClient = *mpfcc::WSCbaseList_delClient;
*countObject = *mpfcc::WSCbaseList_countObject;
*addNeedUpdate = *mpfcc::WSCbaseList_addNeedUpdate;
*addNeedInitialize = *mpfcc::WSCbaseList_addNeedInitialize;
*execUpdate = *mpfcc::WSCbaseList_execUpdate;
*execInitialize = *mpfcc::WSCbaseList_execInitialize;
*setUserData = *mpfcc::WSCbaseList_setUserData;
*getUserData = *mpfcc::WSCbaseList_getUserData;
*getInstanceList = *mpfcc::WSCbaseList_getInstanceList;
*getRemoteInstance = *mpfcc::WSCbaseList_getRemoteInstance;
*setSearchInstanceHandler = *mpfcc::WSCbaseList_setSearchInstanceHandler;
*searchInstance = *mpfcc::WSCbaseList_searchInstance;
*existInstance = *mpfcc::WSCbaseList_existInstance;
*addEvent = *mpfcc::WSCbaseList_addEvent;
*delEvent = *mpfcc::WSCbaseList_delEvent;
*execEvent = *mpfcc::WSCbaseList_execEvent;
*addRemoteInstanceData = *mpfcc::WSCbaseList_addRemoteInstanceData;
*delRemoteInstanceData = *mpfcc::WSCbaseList_delRemoteInstanceData;
*getRemoteInstanceListUpdated = *mpfcc::WSCbaseList_getRemoteInstanceListUpdated;
*setRemoteInstanceListUpdated = *mpfcc::WSCbaseList_setRemoteInstanceListUpdated;
*addExportInstanceList = *mpfcc::WSCbaseList_addExportInstanceList;
*delExportInstanceList = *mpfcc::WSCbaseList_delExportInstanceList;
*addExportInstanceUpdateList = *mpfcc::WSCbaseList_addExportInstanceUpdateList;
*delExportInstanceUpdateList = *mpfcc::WSCbaseList_delExportInstanceUpdateList;
*addExportInstanceDeleteList = *mpfcc::WSCbaseList_addExportInstanceDeleteList;
*delExportInstanceDeleteList = *mpfcc::WSCbaseList_delExportInstanceDeleteList;
*getExportInstanceDeleteList = *mpfcc::WSCbaseList_getExportInstanceDeleteList;
*getExportInstanceUpdateList = *mpfcc::WSCbaseList_getExportInstanceUpdateList;
*getExportInstanceList = *mpfcc::WSCbaseList_getExportInstanceList;
*getRemoteInstanceData = *mpfcc::WSCbaseList_getRemoteInstanceData;
*getRemoteInstanceList = *mpfcc::WSCbaseList_getRemoteInstanceList;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : mpfc::WSCsheet ##############

package mpfc::WSCsheet;
@ISA = qw( mpfc mpfc::WSCform );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = mpfcc::new_WSCsheet(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        mpfcc::delete_WSCsheet($self);
        delete $OWNER{$self};
    }
}

*init = *mpfcc::WSCsheet_init;
*clear = *mpfcc::WSCsheet_clear;
*getRowCount = *mpfcc::WSCsheet_getRowCount;
*setRowCount = *mpfcc::WSCsheet_setRowCount;
*getColumnCount = *mpfcc::WSCsheet_getColumnCount;
*setColumnCount = *mpfcc::WSCsheet_setColumnCount;
*getRowHeight = *mpfcc::WSCsheet_getRowHeight;
*setRowHeight = *mpfcc::WSCsheet_setRowHeight;
*getColumnWidth = *mpfcc::WSCsheet_getColumnWidth;
*setColumnWidth = *mpfcc::WSCsheet_setColumnWidth;
*getFixedRowCount = *mpfcc::WSCsheet_getFixedRowCount;
*setFixedRowCount = *mpfcc::WSCsheet_setFixedRowCount;
*getFixedColumnCount = *mpfcc::WSCsheet_getFixedColumnCount;
*setFixedColumnCount = *mpfcc::WSCsheet_setFixedColumnCount;
*getFixedRowHeight = *mpfcc::WSCsheet_getFixedRowHeight;
*setFixedRowHeight = *mpfcc::WSCsheet_setFixedRowHeight;
*getFixedColumnWidth = *mpfcc::WSCsheet_getFixedColumnWidth;
*setFixedColumnWidth = *mpfcc::WSCsheet_setFixedColumnWidth;
*setSheetBkColor = *mpfcc::WSCsheet_setSheetBkColor;
*getSheetBkColor = *mpfcc::WSCsheet_getSheetBkColor;
*setCellDefBkColor = *mpfcc::WSCsheet_setCellDefBkColor;
*getCellDefBkColor = *mpfcc::WSCsheet_getCellDefBkColor;
*setCellBkColor = *mpfcc::WSCsheet_setCellBkColor;
*getCellBkColor = *mpfcc::WSCsheet_getCellBkColor;
*setCellDefTextColor = *mpfcc::WSCsheet_setCellDefTextColor;
*getCellDefTextColor = *mpfcc::WSCsheet_getCellDefTextColor;
*setCellTextColor = *mpfcc::WSCsheet_setCellTextColor;
*getCellTextColor = *mpfcc::WSCsheet_getCellTextColor;
*setFixedBkColor = *mpfcc::WSCsheet_setFixedBkColor;
*getFixedBkColor = *mpfcc::WSCsheet_getFixedBkColor;
*setFixedTextColor = *mpfcc::WSCsheet_setFixedTextColor;
*getFixedTextColor = *mpfcc::WSCsheet_getFixedTextColor;
*setGridColor = *mpfcc::WSCsheet_setGridColor;
*getGridColor = *mpfcc::WSCsheet_getGridColor;
*setGridLines = *mpfcc::WSCsheet_setGridLines;
*getGridLines = *mpfcc::WSCsheet_getGridLines;
*setCellGridLines = *mpfcc::WSCsheet_setCellGridLines;
*getCellGridLines = *mpfcc::WSCsheet_getCellGridLines;
*setText = *mpfcc::WSCsheet_setText;
*getText = *mpfcc::WSCsheet_getText;
*setFixedText = *mpfcc::WSCsheet_setFixedText;
*getFixedText = *mpfcc::WSCsheet_getFixedText;
*getCellNo = *mpfcc::WSCsheet_getCellNo;
*setFocusCell = *mpfcc::WSCsheet_setFocusCell;
*getFocusCell = *mpfcc::WSCsheet_getFocusCell;
*getFocusCol = *mpfcc::WSCsheet_getFocusCol;
*getFocusRow = *mpfcc::WSCsheet_getFocusRow;
*setRow = *mpfcc::WSCsheet_setRow;
*getRow = *mpfcc::WSCsheet_getRow;
*setStartRow = *mpfcc::WSCsheet_setStartRow;
*getStartRow = *mpfcc::WSCsheet_getStartRow;
*setEndRow = *mpfcc::WSCsheet_setEndRow;
*getEndRow = *mpfcc::WSCsheet_getEndRow;
*setCol = *mpfcc::WSCsheet_setCol;
*getCol = *mpfcc::WSCsheet_getCol;
*setStartCol = *mpfcc::WSCsheet_setStartCol;
*getStartCol = *mpfcc::WSCsheet_getStartCol;
*setEndCol = *mpfcc::WSCsheet_setEndCol;
*getEndCol = *mpfcc::WSCsheet_getEndCol;
*setSelectCell = *mpfcc::WSCsheet_setSelectCell;
*getSelectCell = *mpfcc::WSCsheet_getSelectCell;
*setEditEnabled = *mpfcc::WSCsheet_setEditEnabled;
*getEditEnabled = *mpfcc::WSCsheet_getEditEnabled;
*getFocusCellRect = *mpfcc::WSCsheet_getFocusCellRect;
*getVisibleCellRect = *mpfcc::WSCsheet_getVisibleCellRect;
*getCellRect = *mpfcc::WSCsheet_getCellRect;
*setTopVisibleRow = *mpfcc::WSCsheet_setTopVisibleRow;
*getTopVisibleRow = *mpfcc::WSCsheet_getTopVisibleRow;
*setTopVisibleCol = *mpfcc::WSCsheet_setTopVisibleCol;
*getTopVisibleCol = *mpfcc::WSCsheet_getTopVisibleCol;
*setCellDefFont = *mpfcc::WSCsheet_setCellDefFont;
*getCellDefFont = *mpfcc::WSCsheet_getCellDefFont;
*setCellFont = *mpfcc::WSCsheet_setCellFont;
*getCellFont = *mpfcc::WSCsheet_getCellFont;
*setFixedCellFont = *mpfcc::WSCsheet_setFixedCellFont;
*getFixedCellFont = *mpfcc::WSCsheet_getFixedCellFont;
*setVertAutoNumber = *mpfcc::WSCsheet_setVertAutoNumber;
*getVertAutoNumber = *mpfcc::WSCsheet_getVertAutoNumber;
*setHorzAutoNumber = *mpfcc::WSCsheet_setHorzAutoNumber;
*getHorzAutoNumber = *mpfcc::WSCsheet_getHorzAutoNumber;
*setCellAlignemnt = *mpfcc::WSCsheet_setCellAlignemnt;
*getCellAlignemnt = *mpfcc::WSCsheet_getCellAlignemnt;
*setFixedCellAlignemnt = *mpfcc::WSCsheet_setFixedCellAlignemnt;
*getFixedCellAlignemnt = *mpfcc::WSCsheet_getFixedCellAlignemnt;
*setCellLock = *mpfcc::WSCsheet_setCellLock;
*getCellLock = *mpfcc::WSCsheet_getCellLock;
*getClientWidth = *mpfcc::WSCsheet_getClientWidth;
*getClientHeight = *mpfcc::WSCsheet_getClientHeight;
*setNoRefresh = *mpfcc::WSCsheet_setNoRefresh;
*getNoRefresh = *mpfcc::WSCsheet_getNoRefresh;
*insertRow = *mpfcc::WSCsheet_insertRow;
*insertCol = *mpfcc::WSCsheet_insertCol;
*deleteRow = *mpfcc::WSCsheet_deleteRow;
*deleteCol = *mpfcc::WSCsheet_deleteCol;
*setDataSource = *mpfcc::WSCsheet_setDataSource;
*getDataSource = *mpfcc::WSCsheet_getDataSource;
*setTableName = *mpfcc::WSCsheet_setTableName;
*getTableName = *mpfcc::WSCsheet_getTableName;
*setDbItem = *mpfcc::WSCsheet_setDbItem;
*getDbItem = *mpfcc::WSCsheet_getDbItem;
*setDbSortItem1 = *mpfcc::WSCsheet_setDbSortItem1;
*getDbSortItem1 = *mpfcc::WSCsheet_getDbSortItem1;
*setDbSort1 = *mpfcc::WSCsheet_setDbSort1;
*getDbSort1 = *mpfcc::WSCsheet_getDbSort1;
*setDbSortItem2 = *mpfcc::WSCsheet_setDbSortItem2;
*getDbSortItem2 = *mpfcc::WSCsheet_getDbSortItem2;
*setDbSort2 = *mpfcc::WSCsheet_setDbSort2;
*getDbSort2 = *mpfcc::WSCsheet_getDbSort2;
*setDbSortItem3 = *mpfcc::WSCsheet_setDbSortItem3;
*getDbSortItem3 = *mpfcc::WSCsheet_getDbSortItem3;
*setDbSort3 = *mpfcc::WSCsheet_setDbSort3;
*getDbSort3 = *mpfcc::WSCsheet_getDbSort3;
*setDbFilter = *mpfcc::WSCsheet_setDbFilter;
*getDbFilter = *mpfcc::WSCsheet_getDbFilter;
*setDbStmtString = *mpfcc::WSCsheet_setDbStmtString;
*getDbStmtString = *mpfcc::WSCsheet_getDbStmtString;
*dbRefresh = *mpfcc::WSCsheet_dbRefresh;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


# ------- VARIABLE STUBS --------

package mpfc;

*WS_DATA_SOURCE_NONE = *mpfcc::WS_DATA_SOURCE_NONE;
*WS_DATA_SOURCE_INSTANCE = *mpfcc::WS_DATA_SOURCE_INSTANCE;
*WS_DATA_SOURCE_FILE = *mpfcc::WS_DATA_SOURCE_FILE;
*WS_TEXT = *mpfcc::WS_TEXT;
*WS_BINARY = *mpfcc::WS_BINARY;
*WS_NORMAL = *mpfcc::WS_NORMAL;
*WS_TREE = *mpfcc::WS_TREE;
*WS_VERBOSE = *mpfcc::WS_VERBOSE;
*WS_HAVE_CHILD = *mpfcc::WS_HAVE_CHILD;
*WS_HAVE_BROS = *mpfcc::WS_HAVE_BROS;
*WS_OPEN = *mpfcc::WS_OPEN;
*WS_INDENT_LEVEL = *mpfcc::WS_INDENT_LEVEL;
*WS_ABSOLUTE_OPEN = *mpfcc::WS_ABSOLUTE_OPEN;
*WS_ICON = *mpfcc::WS_ICON;
*WS_SFORM_FIXED = *mpfcc::WS_SFORM_FIXED;
*WS_SFORM_UNDER_RESIZING = *mpfcc::WS_SFORM_UNDER_RESIZING;
*WS_EXEC_NONE = *mpfcc::WS_EXEC_NONE;
*WS_EXEC_RD = *mpfcc::WS_EXEC_RD;
*WS_EXEC_RDWR = *mpfcc::WS_EXEC_RDWR;
*WS_EXEC_WR = *mpfcc::WS_EXEC_WR;
*WS_DOUBLE_CLICK_TIME = *mpfcc::WS_DOUBLE_CLICK_TIME;
*WS_POLICY_ORIGINAL = *mpfcc::WS_POLICY_ORIGINAL;
*WS_POLICY_WINDOWS = *mpfcc::WS_POLICY_WINDOWS;
*WS_POLICY_GRADATION = *mpfcc::WS_POLICY_GRADATION;
*WS_POLICY_AQUA = *mpfcc::WS_POLICY_AQUA;
*WS_EN_DEFAULT = *mpfcc::WS_EN_DEFAULT;
*WS_EN_LOCALE = *mpfcc::WS_EN_LOCALE;
*WS_EN_NONE = *mpfcc::WS_EN_NONE;
*WS_EN_ISO8859_1 = *mpfcc::WS_EN_ISO8859_1;
*WS_EN_ISO8859_2 = *mpfcc::WS_EN_ISO8859_2;
*WS_EN_ISO8859_3 = *mpfcc::WS_EN_ISO8859_3;
*WS_EN_ISO8859_4 = *mpfcc::WS_EN_ISO8859_4;
*WS_EN_ISO8859_5 = *mpfcc::WS_EN_ISO8859_5;
*WS_EN_ISO8859_6 = *mpfcc::WS_EN_ISO8859_6;
*WS_EN_ISO8859_7 = *mpfcc::WS_EN_ISO8859_7;
*WS_EN_ISO8859_8 = *mpfcc::WS_EN_ISO8859_8;
*WS_EN_ISO8859_9 = *mpfcc::WS_EN_ISO8859_9;
*WS_EN_ISO8859_10 = *mpfcc::WS_EN_ISO8859_10;
*WS_EN_ISO8859_11 = *mpfcc::WS_EN_ISO8859_11;
*WS_EN_ISO8859_12 = *mpfcc::WS_EN_ISO8859_12;
*WS_EN_ISO8859_13 = *mpfcc::WS_EN_ISO8859_13;
*WS_EN_ISO8859_14 = *mpfcc::WS_EN_ISO8859_14;
*WS_EN_ISO8859_15 = *mpfcc::WS_EN_ISO8859_15;
*WS_EN_UTF8 = *mpfcc::WS_EN_UTF8;
*WS_EN_KOI8R = *mpfcc::WS_EN_KOI8R;
*WS_EN_EUCJP = *mpfcc::WS_EN_EUCJP;
*WS_EN_SJIS = *mpfcc::WS_EN_SJIS;
*WS_EN_EUCKR = *mpfcc::WS_EN_EUCKR;
*WS_EN_EUCCN = *mpfcc::WS_EN_EUCCN;
*WS_EN_BIG5 = *mpfcc::WS_EN_BIG5;
*WS_DIALOG_CANCEL = *mpfcc::WS_DIALOG_CANCEL;
*WS_DIALOG_OK = *mpfcc::WS_DIALOG_OK;
*WS_DIALOG_NO = *mpfcc::WS_DIALOG_NO;
*WS_DIALOG_DONE = *mpfcc::WS_DIALOG_DONE;
*WSCDB_SQL_CONCUR_READ_ONLY = *mpfcc::WSCDB_SQL_CONCUR_READ_ONLY;
*WSCDB_SQL_CONCUR_LOCK = *mpfcc::WSCDB_SQL_CONCUR_LOCK;
*WSCDB_SQL_CONCUR_ROWVER = *mpfcc::WSCDB_SQL_CONCUR_ROWVER;
*WSCDB_SQL_CONCUR_VALUES = *mpfcc::WSCDB_SQL_CONCUR_VALUES;
*WSCDB_SQL_CONCUR_DEFAULT = *mpfcc::WSCDB_SQL_CONCUR_DEFAULT;
*WSCDB_SQL_CURSOR_FORWARD_ONLY = *mpfcc::WSCDB_SQL_CURSOR_FORWARD_ONLY;
*WSCDB_SQL_CURSOR_KEYSET_DRIVEN = *mpfcc::WSCDB_SQL_CURSOR_KEYSET_DRIVEN;
*WSCDB_SQL_CURSOR_DYNAMIC = *mpfcc::WSCDB_SQL_CURSOR_DYNAMIC;
*WSCDB_SQL_CURSOR_STATIC = *mpfcc::WSCDB_SQL_CURSOR_STATIC;
*WSCDB_SQL_CURSOR_TYPE_DEFAULT = *mpfcc::WSCDB_SQL_CURSOR_TYPE_DEFAULT;
*WSCDB_FIELD_TYPE_CHAR = *mpfcc::WSCDB_FIELD_TYPE_CHAR;
*WSCDB_FIELD_TYPE_NUMERIC = *mpfcc::WSCDB_FIELD_TYPE_NUMERIC;
*WSCDB_FIELD_TYPE_DECIMAL = *mpfcc::WSCDB_FIELD_TYPE_DECIMAL;
*WSCDB_FIELD_TYPE_INTEGER = *mpfcc::WSCDB_FIELD_TYPE_INTEGER;
*WSCDB_FIELD_TYPE_SMALLINT = *mpfcc::WSCDB_FIELD_TYPE_SMALLINT;
*WSCDB_FIELD_TYPE_FLOAT = *mpfcc::WSCDB_FIELD_TYPE_FLOAT;
*WSCDB_FIELD_TYPE_REAL = *mpfcc::WSCDB_FIELD_TYPE_REAL;
*WSCDB_FIELD_TYPE_DOUBLE = *mpfcc::WSCDB_FIELD_TYPE_DOUBLE;
*WSCDB_FIELD_TYPE_DATE = *mpfcc::WSCDB_FIELD_TYPE_DATE;
*WSCDB_FIELD_TYPE_TIME = *mpfcc::WSCDB_FIELD_TYPE_TIME;
*WSCDB_FIELD_TYPE_TIMESTAMP = *mpfcc::WSCDB_FIELD_TYPE_TIMESTAMP;
*WSCDB_FIELD_TYPE_NONE = *mpfcc::WSCDB_FIELD_TYPE_NONE;
*WSCSHEET_DEFAULT = *mpfcc::WSCSHEET_DEFAULT;
*WSCSHEET_NONE = *mpfcc::WSCSHEET_NONE;
*WSCSHEET_HORZ = *mpfcc::WSCSHEET_HORZ;
*WSCSHEET_VERT = *mpfcc::WSCSHEET_VERT;
*WSCSHEET_BOTH = *mpfcc::WSCSHEET_BOTH;
*WSCSHEET_DEF_ROW_HEIGHT = *mpfcc::WSCSHEET_DEF_ROW_HEIGHT;
*WSCSHEET_DEF_COL_WIDTH = *mpfcc::WSCSHEET_DEF_COL_WIDTH;
*WSCSHEET_DEFCOLOR = *mpfcc::WSCSHEET_DEFCOLOR;
*WSCSHEET_DEFFONT = *mpfcc::WSCSHEET_DEFFONT;
*WSCSHEET_DEF_ROWS = *mpfcc::WSCSHEET_DEF_ROWS;
*WSCSHEET_DEF_COLS = *mpfcc::WSCSHEET_DEF_COLS;
*WSCSHEET_DEF_FIXEDROWS = *mpfcc::WSCSHEET_DEF_FIXEDROWS;
*WSCSHEET_DEF_FIXEDCOLS = *mpfcc::WSCSHEET_DEF_FIXEDCOLS;
*WSCSHEET_DB_SORT_ASC = *mpfcc::WSCSHEET_DB_SORT_ASC;
*WSCSHEET_DB_SORT_DESC = *mpfcc::WSCSHEET_DB_SORT_DESC;
*WS_MOUSE_SHIFT = *mpfcc::WS_MOUSE_SHIFT;
*WS_MOUSE_LOCK = *mpfcc::WS_MOUSE_LOCK;
*WS_MOUSE_CONTROL = *mpfcc::WS_MOUSE_CONTROL;
*WS_MOUSE_MOD = *mpfcc::WS_MOUSE_MOD;
*WS_MOUSE_BTN1 = *mpfcc::WS_MOUSE_BTN1;
*WS_MOUSE_BTN2 = *mpfcc::WS_MOUSE_BTN2;
*WS_MOUSE_BTN3 = *mpfcc::WS_MOUSE_BTN3;
*WS_MOUSE_BTN4 = *mpfcc::WS_MOUSE_BTN4;
*WS_MOUSE_BTN5 = *mpfcc::WS_MOUSE_BTN5;
*WS_READ = *mpfcc::WS_READ;
*WS_WRITE = *mpfcc::WS_WRITE;
*WS_RW = *mpfcc::WS_RW;
*WS_SHADOW_OUT = *mpfcc::WS_SHADOW_OUT;
*WS_SHADOW_IN = *mpfcc::WS_SHADOW_IN;
*WS_SHADOW_EOUT = *mpfcc::WS_SHADOW_EOUT;
*WS_SHADOW_EIN = *mpfcc::WS_SHADOW_EIN;
*WS_SHADOW_BORDER = *mpfcc::WS_SHADOW_BORDER;
*WS_LEFT = *mpfcc::WS_LEFT;
*WS_RIGHT = *mpfcc::WS_RIGHT;
*WS_CENTER = *mpfcc::WS_CENTER;
*WS_UP = *mpfcc::WS_UP;
*WS_TOP = *mpfcc::WS_TOP;
*WS_DOWN = *mpfcc::WS_DOWN;
*WS_BOTTOM = *mpfcc::WS_BOTTOM;
*WS_LEFT_TOP = *mpfcc::WS_LEFT_TOP;
*WS_LEFT_BOTTOM = *mpfcc::WS_LEFT_BOTTOM;
*WS_RIGHT_TOP = *mpfcc::WS_RIGHT_TOP;
*WS_RIGHT_BOTTOM = *mpfcc::WS_RIGHT_BOTTOM;
*WS_RET = *mpfcc::WS_RET;
*WS_TAB = *mpfcc::WS_TAB;
*WS_STAB = *mpfcc::WS_STAB;
*WS_NO_ERR = *mpfcc::WS_NO_ERR;
*WS_OK = *mpfcc::WS_OK;
*WS_ERR = *mpfcc::WS_ERR;
*WS_REMOTE_CALL_FAILED = *mpfcc::WS_REMOTE_CALL_FAILED;
*False = *mpfcc::False;
*True = *mpfcc::True;
*WSTlong = *mpfcc::WSTlong;
*WSTulong = *mpfcc::WSTulong;
*WSTshort = *mpfcc::WSTshort;
*WSTushort = *mpfcc::WSTushort;
*WSTchar = *mpfcc::WSTchar;
*WSTuchar = *mpfcc::WSTuchar;
*WSTfloat = *mpfcc::WSTfloat;
*WSTdouble = *mpfcc::WSTdouble;
*WSTvoidptr = *mpfcc::WSTvoidptr;
*WSTcharptr = *mpfcc::WSTcharptr;
*WSTvoid = *mpfcc::WSTvoid;
*WSTbool = *mpfcc::WSTbool;
*WSTint = *mpfcc::WSTint;
*WSTuint = *mpfcc::WSTuint;
*WSEV_HASH_MAX_NUM = *mpfcc::WSEV_HASH_MAX_NUM;
*WSEV_NONE = *mpfcc::WSEV_NONE;
*WSEV_INITIALIZE = *mpfcc::WSEV_INITIALIZE;
*WSEV_DELETE = *mpfcc::WSEV_DELETE;
*WSEV_ACTIVATE = *mpfcc::WSEV_ACTIVATE;
*WSEV_VALUE_CH = *mpfcc::WSEV_VALUE_CH;
*WSEV_FOCUS_CH = *mpfcc::WSEV_FOCUS_CH;
*WSEV_VISIBLE_CH = *mpfcc::WSEV_VISIBLE_CH;
*WSEV_SENSITIVE_CH = *mpfcc::WSEV_SENSITIVE_CH;
*WSEV_PARENT_VISIBLE_CH = *mpfcc::WSEV_PARENT_VISIBLE_CH;
*WSEV_PARENT_SENSITIVE_CH = *mpfcc::WSEV_PARENT_SENSITIVE_CH;
*WSEV_EXPOSE = *mpfcc::WSEV_EXPOSE;
*WSEV_RESIZE = *mpfcc::WSEV_RESIZE;
*WSEV_MOUSE_IN = *mpfcc::WSEV_MOUSE_IN;
*WSEV_MOUSE_OUT = *mpfcc::WSEV_MOUSE_OUT;
*WSEV_MOUSE_PRESS = *mpfcc::WSEV_MOUSE_PRESS;
*WSEV_MOUSE_RELEASE = *mpfcc::WSEV_MOUSE_RELEASE;
*WSEV_MOUSE_MOVE = *mpfcc::WSEV_MOUSE_MOVE;
*WSEV_KEY_PRESS = *mpfcc::WSEV_KEY_PRESS;
*WSEV_KEY_RELEASE = *mpfcc::WSEV_KEY_RELEASE;
*WSEV_KEY_HOOK = *mpfcc::WSEV_KEY_HOOK;
*WSEV_MOUSE_DOUBLE_CLICK = *mpfcc::WSEV_MOUSE_DOUBLE_CLICK;
*WSEV_SORT = *mpfcc::WSEV_SORT;
*WSEV_GUI_POLICY_CH = *mpfcc::WSEV_GUI_POLICY_CH;
*WSEV_ITEM_SELECTED = *mpfcc::WSEV_ITEM_SELECTED;
*WSEV_STATUS_CH = *mpfcc::WSEV_STATUS_CH;
*WSEV_INPUT_FIXED = *mpfcc::WSEV_INPUT_FIXED;
*WSEV_BEGIN = *mpfcc::WSEV_BEGIN;
*WSEV_END = *mpfcc::WSEV_END;
*WSEV_INCREMENT = *mpfcc::WSEV_INCREMENT;
*WSEV_DECREMENT = *mpfcc::WSEV_DECREMENT;
*WSEV_PAGE_INCREMENT = *mpfcc::WSEV_PAGE_INCREMENT;
*WSEV_PAGE_DECREMENT = *mpfcc::WSEV_PAGE_DECREMENT;
*WSEV_SCR_MOUSE_PRESS = *mpfcc::WSEV_SCR_MOUSE_PRESS;
*WSEV_SCR_MOUSE_RELEASE = *mpfcc::WSEV_SCR_MOUSE_RELEASE;
*WSEV_SCR_MOUSE_MOVE = *mpfcc::WSEV_SCR_MOUSE_MOVE;
*WSEV_EDIT_MODE_CH = *mpfcc::WSEV_EDIT_MODE_CH;
*WSEV_SPECIAL_FOCUS_CH = *mpfcc::WSEV_SPECIAL_FOCUS_CH;
*WSEV_CHILD_ADDED = *mpfcc::WSEV_CHILD_ADDED;
*WSEV_SELECTION_CH = *mpfcc::WSEV_SELECTION_CH;
*WSK_BackSpace = *mpfcc::WSK_BackSpace;
*WSK_Tab = *mpfcc::WSK_Tab;
*WSK_Linefeed = *mpfcc::WSK_Linefeed;
*WSK_Clear = *mpfcc::WSK_Clear;
*WSK_Return = *mpfcc::WSK_Return;
*WSK_Pause = *mpfcc::WSK_Pause;
*WSK_Scroll_Lock = *mpfcc::WSK_Scroll_Lock;
*WSK_Sys_Req = *mpfcc::WSK_Sys_Req;
*WSK_Escape = *mpfcc::WSK_Escape;
*WSK_Delete = *mpfcc::WSK_Delete;
*WSK_Kanji = *mpfcc::WSK_Kanji;
*WSK_Muhenkan = *mpfcc::WSK_Muhenkan;
*WSK_Henkan_Mode = *mpfcc::WSK_Henkan_Mode;
*WSK_Henkan = *mpfcc::WSK_Henkan;
*WSK_Romaji = *mpfcc::WSK_Romaji;
*WSK_Hiragana = *mpfcc::WSK_Hiragana;
*WSK_Katakana = *mpfcc::WSK_Katakana;
*WSK_Hiragana_Katakana = *mpfcc::WSK_Hiragana_Katakana;
*WSK_Zenkaku = *mpfcc::WSK_Zenkaku;
*WSK_Hankaku = *mpfcc::WSK_Hankaku;
*WSK_Zenkaku_Hankaku = *mpfcc::WSK_Zenkaku_Hankaku;
*WSK_Touroku = *mpfcc::WSK_Touroku;
*WSK_Massyo = *mpfcc::WSK_Massyo;
*WSK_Kana_Lock = *mpfcc::WSK_Kana_Lock;
*WSK_Kana_Shift = *mpfcc::WSK_Kana_Shift;
*WSK_Eisu_Shift = *mpfcc::WSK_Eisu_Shift;
*WSK_Eisu_toggle = *mpfcc::WSK_Eisu_toggle;
*WSK_Home = *mpfcc::WSK_Home;
*WSK_Left = *mpfcc::WSK_Left;
*WSK_Up = *mpfcc::WSK_Up;
*WSK_Right = *mpfcc::WSK_Right;
*WSK_Down = *mpfcc::WSK_Down;
*WSK_Prior = *mpfcc::WSK_Prior;
*WSK_Page_Up = *mpfcc::WSK_Page_Up;
*WSK_Page_Down = *mpfcc::WSK_Page_Down;
*WSK_End = *mpfcc::WSK_End;
*WSK_Print = *mpfcc::WSK_Print;
*WSK_Execute = *mpfcc::WSK_Execute;
*WSK_Insert = *mpfcc::WSK_Insert;
*WSK_Cancel = *mpfcc::WSK_Cancel;
*WSK_Help = *mpfcc::WSK_Help;
*WSK_Break = *mpfcc::WSK_Break;
*WSK_Num_Lock = *mpfcc::WSK_Num_Lock;
*WSK_KP_Space = *mpfcc::WSK_KP_Space;
*WSK_KP_Tab = *mpfcc::WSK_KP_Tab;
*WSK_KP_Enter = *mpfcc::WSK_KP_Enter;
*WSK_KP_F1 = *mpfcc::WSK_KP_F1;
*WSK_KP_F2 = *mpfcc::WSK_KP_F2;
*WSK_KP_F3 = *mpfcc::WSK_KP_F3;
*WSK_KP_F4 = *mpfcc::WSK_KP_F4;
*WSK_KP_Home = *mpfcc::WSK_KP_Home;
*WSK_KP_Left = *mpfcc::WSK_KP_Left;
*WSK_KP_Up = *mpfcc::WSK_KP_Up;
*WSK_KP_Right = *mpfcc::WSK_KP_Right;
*WSK_KP_Down = *mpfcc::WSK_KP_Down;
*WSK_KP_Prior = *mpfcc::WSK_KP_Prior;
*WSK_KP_Page_Up = *mpfcc::WSK_KP_Page_Up;
*WSK_KP_Next = *mpfcc::WSK_KP_Next;
*WSK_KP_Page_Down = *mpfcc::WSK_KP_Page_Down;
*WSK_KP_End = *mpfcc::WSK_KP_End;
*WSK_KP_Begin = *mpfcc::WSK_KP_Begin;
*WSK_KP_Insert = *mpfcc::WSK_KP_Insert;
*WSK_KP_Delete = *mpfcc::WSK_KP_Delete;
*WSK_KP_Equal = *mpfcc::WSK_KP_Equal;
*WSK_KP_Multiply = *mpfcc::WSK_KP_Multiply;
*WSK_KP_Add = *mpfcc::WSK_KP_Add;
*WSK_KP_Separator = *mpfcc::WSK_KP_Separator;
*WSK_KP_Subtract = *mpfcc::WSK_KP_Subtract;
*WSK_KP_Decimal = *mpfcc::WSK_KP_Decimal;
*WSK_KP_Divide = *mpfcc::WSK_KP_Divide;
*WSK_KP_0 = *mpfcc::WSK_KP_0;
*WSK_KP_1 = *mpfcc::WSK_KP_1;
*WSK_KP_2 = *mpfcc::WSK_KP_2;
*WSK_KP_3 = *mpfcc::WSK_KP_3;
*WSK_KP_4 = *mpfcc::WSK_KP_4;
*WSK_KP_5 = *mpfcc::WSK_KP_5;
*WSK_KP_6 = *mpfcc::WSK_KP_6;
*WSK_KP_7 = *mpfcc::WSK_KP_7;
*WSK_KP_8 = *mpfcc::WSK_KP_8;
*WSK_KP_9 = *mpfcc::WSK_KP_9;
*WSK_F1 = *mpfcc::WSK_F1;
*WSK_F2 = *mpfcc::WSK_F2;
*WSK_F3 = *mpfcc::WSK_F3;
*WSK_F4 = *mpfcc::WSK_F4;
*WSK_F5 = *mpfcc::WSK_F5;
*WSK_F6 = *mpfcc::WSK_F6;
*WSK_F7 = *mpfcc::WSK_F7;
*WSK_F8 = *mpfcc::WSK_F8;
*WSK_F9 = *mpfcc::WSK_F9;
*WSK_F10 = *mpfcc::WSK_F10;
*WSK_F11 = *mpfcc::WSK_F11;
*WSK_L1 = *mpfcc::WSK_L1;
*WSK_F12 = *mpfcc::WSK_F12;
*WSK_L2 = *mpfcc::WSK_L2;
*WSK_F13 = *mpfcc::WSK_F13;
*WSK_L3 = *mpfcc::WSK_L3;
*WSK_F14 = *mpfcc::WSK_F14;
*WSK_L4 = *mpfcc::WSK_L4;
*WSK_F15 = *mpfcc::WSK_F15;
*WSK_L5 = *mpfcc::WSK_L5;
*WSK_F16 = *mpfcc::WSK_F16;
*WSK_L6 = *mpfcc::WSK_L6;
*WSK_F17 = *mpfcc::WSK_F17;
*WSK_L7 = *mpfcc::WSK_L7;
*WSK_F18 = *mpfcc::WSK_F18;
*WSK_L8 = *mpfcc::WSK_L8;
*WSK_F19 = *mpfcc::WSK_F19;
*WSK_L9 = *mpfcc::WSK_L9;
*WSK_F20 = *mpfcc::WSK_F20;
*WSK_L10 = *mpfcc::WSK_L10;
*WSK_F21 = *mpfcc::WSK_F21;
*WSK_R1 = *mpfcc::WSK_R1;
*WSK_F22 = *mpfcc::WSK_F22;
*WSK_R2 = *mpfcc::WSK_R2;
*WSK_F23 = *mpfcc::WSK_F23;
*WSK_R3 = *mpfcc::WSK_R3;
*WSK_F24 = *mpfcc::WSK_F24;
*WSK_R4 = *mpfcc::WSK_R4;
*WSK_F25 = *mpfcc::WSK_F25;
*WSK_R5 = *mpfcc::WSK_R5;
*WSK_F26 = *mpfcc::WSK_F26;
*WSK_R6 = *mpfcc::WSK_R6;
*WSK_F27 = *mpfcc::WSK_F27;
*WSK_R7 = *mpfcc::WSK_R7;
*WSK_F28 = *mpfcc::WSK_F28;
*WSK_R8 = *mpfcc::WSK_R8;
*WSK_F29 = *mpfcc::WSK_F29;
*WSK_R9 = *mpfcc::WSK_R9;
*WSK_F30 = *mpfcc::WSK_F30;
*WSK_R10 = *mpfcc::WSK_R10;
*WSK_F31 = *mpfcc::WSK_F31;
*WSK_R11 = *mpfcc::WSK_R11;
*WSK_F32 = *mpfcc::WSK_F32;
*WSK_R12 = *mpfcc::WSK_R12;
*WSK_F33 = *mpfcc::WSK_F33;
*WSK_R13 = *mpfcc::WSK_R13;
*WSK_F34 = *mpfcc::WSK_F34;
*WSK_R14 = *mpfcc::WSK_R14;
*WSK_F35 = *mpfcc::WSK_F35;
*WSK_R15 = *mpfcc::WSK_R15;
*WSK_Shift_L = *mpfcc::WSK_Shift_L;
*WSK_Shift_R = *mpfcc::WSK_Shift_R;
*WSK_Control_L = *mpfcc::WSK_Control_L;
*WSK_Control_R = *mpfcc::WSK_Control_R;
*WSK_Caps_Lock = *mpfcc::WSK_Caps_Lock;
*WSK_Shift_Lock = *mpfcc::WSK_Shift_Lock;
*WSK_Meta_L = *mpfcc::WSK_Meta_L;
*WSK_Meta_R = *mpfcc::WSK_Meta_R;
*WSK_Alt_L = *mpfcc::WSK_Alt_L;
*WSK_Alt_R = *mpfcc::WSK_Alt_R;
*WSK_Super_L = *mpfcc::WSK_Super_L;
*WSK_Super_R = *mpfcc::WSK_Super_R;
*WSK_Hyper_L = *mpfcc::WSK_Hyper_L;
*WSK_Hyper_R = *mpfcc::WSK_Hyper_R;
*WSK_space = *mpfcc::WSK_space;
*WSK_exclam = *mpfcc::WSK_exclam;
*WSK_quotedbl = *mpfcc::WSK_quotedbl;
*WSK_numbersign = *mpfcc::WSK_numbersign;
*WSK_dollar = *mpfcc::WSK_dollar;
*WSK_percent = *mpfcc::WSK_percent;
*WSK_ampersand = *mpfcc::WSK_ampersand;
*WSK_apostrophe = *mpfcc::WSK_apostrophe;
*WSK_quoteright = *mpfcc::WSK_quoteright;
*WSK_parenleft = *mpfcc::WSK_parenleft;
*WSK_parenright = *mpfcc::WSK_parenright;
*WSK_asterisk = *mpfcc::WSK_asterisk;
*WSK_plus = *mpfcc::WSK_plus;
*WSK_comma = *mpfcc::WSK_comma;
*WSK_minus = *mpfcc::WSK_minus;
*WSK_period = *mpfcc::WSK_period;
*WSK_slash = *mpfcc::WSK_slash;
*WSK_0 = *mpfcc::WSK_0;
*WSK_1 = *mpfcc::WSK_1;
*WSK_2 = *mpfcc::WSK_2;
*WSK_3 = *mpfcc::WSK_3;
*WSK_4 = *mpfcc::WSK_4;
*WSK_5 = *mpfcc::WSK_5;
*WSK_6 = *mpfcc::WSK_6;
*WSK_7 = *mpfcc::WSK_7;
*WSK_8 = *mpfcc::WSK_8;
*WSK_9 = *mpfcc::WSK_9;
*WSK_colon = *mpfcc::WSK_colon;
*WSK_semicolon = *mpfcc::WSK_semicolon;
*WSK_less = *mpfcc::WSK_less;
*WSK_equal = *mpfcc::WSK_equal;
*WSK_greater = *mpfcc::WSK_greater;
*WSK_question = *mpfcc::WSK_question;
*WSK_at = *mpfcc::WSK_at;
*WSK_A = *mpfcc::WSK_A;
*WSK_B = *mpfcc::WSK_B;
*WSK_C = *mpfcc::WSK_C;
*WSK_D = *mpfcc::WSK_D;
*WSK_E = *mpfcc::WSK_E;
*WSK_F = *mpfcc::WSK_F;
*WSK_G = *mpfcc::WSK_G;
*WSK_H = *mpfcc::WSK_H;
*WSK_I = *mpfcc::WSK_I;
*WSK_J = *mpfcc::WSK_J;
*WSK_K = *mpfcc::WSK_K;
*WSK_L = *mpfcc::WSK_L;
*WSK_M = *mpfcc::WSK_M;
*WSK_N = *mpfcc::WSK_N;
*WSK_O = *mpfcc::WSK_O;
*WSK_P = *mpfcc::WSK_P;
*WSK_Q = *mpfcc::WSK_Q;
*WSK_R = *mpfcc::WSK_R;
*WSK_S = *mpfcc::WSK_S;
*WSK_T = *mpfcc::WSK_T;
*WSK_U = *mpfcc::WSK_U;
*WSK_V = *mpfcc::WSK_V;
*WSK_W = *mpfcc::WSK_W;
*WSK_X = *mpfcc::WSK_X;
*WSK_Y = *mpfcc::WSK_Y;
*WSK_Z = *mpfcc::WSK_Z;
*WSK_bracketleft = *mpfcc::WSK_bracketleft;
*WSK_backslash = *mpfcc::WSK_backslash;
*WSK_bracketright = *mpfcc::WSK_bracketright;
*WSK_asciicircum = *mpfcc::WSK_asciicircum;
*WSK_underscore = *mpfcc::WSK_underscore;
*WSK_grave = *mpfcc::WSK_grave;
*WSK_quoteleft = *mpfcc::WSK_quoteleft;
*WSK_a = *mpfcc::WSK_a;
*WSK_b = *mpfcc::WSK_b;
*WSK_c = *mpfcc::WSK_c;
*WSK_d = *mpfcc::WSK_d;
*WSK_e = *mpfcc::WSK_e;
*WSK_f = *mpfcc::WSK_f;
*WSK_g = *mpfcc::WSK_g;
*WSK_h = *mpfcc::WSK_h;
*WSK_i = *mpfcc::WSK_i;
*WSK_j = *mpfcc::WSK_j;
*WSK_k = *mpfcc::WSK_k;
*WSK_l = *mpfcc::WSK_l;
*WSK_m = *mpfcc::WSK_m;
*WSK_n = *mpfcc::WSK_n;
*WSK_o = *mpfcc::WSK_o;
*WSK_p = *mpfcc::WSK_p;
*WSK_q = *mpfcc::WSK_q;
*WSK_r = *mpfcc::WSK_r;
*WSK_s = *mpfcc::WSK_s;
*WSK_t = *mpfcc::WSK_t;
*WSK_u = *mpfcc::WSK_u;
*WSK_v = *mpfcc::WSK_v;
*WSK_w = *mpfcc::WSK_w;
*WSK_x = *mpfcc::WSK_x;
*WSK_y = *mpfcc::WSK_y;
*WSK_z = *mpfcc::WSK_z;
*WSK_braceleft = *mpfcc::WSK_braceleft;
*WSK_bar = *mpfcc::WSK_bar;
*WSK_braceright = *mpfcc::WSK_braceright;
*WSK_asciitilde = *mpfcc::WSK_asciitilde;
*WS_LIST_TREE_OPEN = *mpfcc::WS_LIST_TREE_OPEN;
*WS_LIST_TREE_OPEN_CH = *mpfcc::WS_LIST_TREE_OPEN_CH;
*WS_LIST_INDENT_LEVEL = *mpfcc::WS_LIST_INDENT_LEVEL;
*WS_LIST_INDENT_STATUS = *mpfcc::WS_LIST_INDENT_STATUS;
*WS_LIST_LABEL_LIST = *mpfcc::WS_LIST_LABEL_LIST;
*WS_LIST_TOP = *mpfcc::WS_LIST_TOP;
1;
