//
// MATLAB Compiler: 3.0
// Date: Wed Jul 14 12:15:03 2004
// Arguments: "-B" "macro_default" "-O" "all" "-O" "fold_scalar_mxarrays:on"
// "-O" "fold_non_scalar_mxarrays:on" "-O" "optimize_integer_for_loops:on" "-O"
// "array_indexing:on" "-O" "optimize_conditionals:on" "-B" "sglcpp" "-p" "-W"
// "main" "-L" "Cpp" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-W" "mainhg"
// "libmwsglm.mlib" "QQchabu.m" 
//
#include "guidata.hpp"
#include "libsgl.hpp"
#include "libmatlbm.hpp"
#include "libmmfile.hpp"

static mxChar _array1_[15] = { 'U', 's', 'e', 'd', 'B', 'y', 'G', 'U',
                               'I', 'D', 'a', 't', 'a', '_', 'm' };
static mwArray _mxarray0_ = mclInitializeString(15, _array1_);
static mwArray _mxarray2_ = mclInitializeDouble(1.0);
static mwArray _mxarray3_ = mclInitializeDouble(2.0);
static mwArray _mxarray4_ = mclInitializeDouble(0.0);
static mwArray _mxarray5_ = mclInitializeDoubleVector(0, 0, (double *)NULL);

static mxChar _array7_[54] = { 'H', ' ', 'm', 'u', 's', 't', ' ', 'b', 'e',
                               ' ', 't', 'h', 'e', ' ', 'h', 'a', 'n', 'd',
                               'l', 'e', ' ', 't', 'o', ' ', 'a', ' ', 'f',
                               'i', 'g', 'u', 'r', 'e', ' ', 'o', 'r', ' ',
                               'f', 'i', 'g', 'u', 'r', 'e', ' ', 'd', 'e',
                               's', 'c', 'e', 'n', 'd', 'e', 'n', 't', '.' };
static mwArray _mxarray6_ = mclInitializeString(54, _array7_);

static mxChar _array9_[6] = { 'f', 'i', 'g', 'u', 'r', 'e' };
static mwArray _mxarray8_ = mclInitializeString(6, _array9_);

static mxChar _array11_[4] = { 't', 'y', 'p', 'e' };
static mwArray _mxarray10_ = mclInitializeString(4, _array11_);

static mxChar _array13_[6] = { 'p', 'a', 'r', 'e', 'n', 't' };
static mwArray _mxarray12_ = mclInitializeString(6, _array13_);

void InitializeModule_guidata() {
}

void TerminateModule_guidata() {
}

static mwArray guidata_getParentFigure(mwArray fig_in = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxGuidata_getParentFigure(int nlhs,
                                mxArray * plhs[],
                                int nrhs,
                                mxArray * prhs[]);
static mwArray Mguidata(int nargout_, mwArray h, mwArray data_in);
static mwArray Mguidata_getParentFigure(int nargout_, mwArray fig_in);

static mexFunctionTableEntry local_function_table_[1]
  = { { "getParentFigure", mlxGuidata_getParentFigure, 1, 1, NULL } };

_mexLocalFunctionTable _local_function_table_guidata
  = { 1, local_function_table_ };

//
// The function "Nguidata" contains the nargout interface for the "guidata"
// M-function from file "e:\matlab6.5\toolbox\matlab\uitools\guidata.m" (lines
// 1-99). This interface is only produced if the M-function uses the special
// variable "nargout". The nargout interface allows the number of requested
// outputs to be specified via the nargout argument, as opposed to the normal
// interface which dynamically calculates the number of outputs based on the
// number of non-NULL inputs it receives. This function processes any input
// arguments and passes them to the implementation version of the function,
// appearing above.
//
mwArray Nguidata(int nargout, mwArray h, mwArray data_in) {
    mwArray data = mwArray::UNDEFINED;
    data = Mguidata(nargout, h, data_in);
    return data;
}

//
// The function "guidata" contains the normal interface for the "guidata"
// M-function from file "e:\matlab6.5\toolbox\matlab\uitools\guidata.m" (lines
// 1-99). This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
mwArray guidata(mwArray h, mwArray data_in) {
    int nargout = 1;
    mwArray data = mwArray::UNDEFINED;
    data = Mguidata(nargout, h, data_in);
    return data;
}

//
// The function "Vguidata" contains the void interface for the "guidata"
// M-function from file "e:\matlab6.5\toolbox\matlab\uitools\guidata.m" (lines
// 1-99). The void interface is only produced if the M-function uses the
// special variable "nargout", and has at least one output. The void interface
// function specifies zero output arguments to the implementation version of
// the function, and in the event that the implementation version still returns
// an output (which, in MATLAB, would be assigned to the "ans" variable), it
// deallocates the output. This function processes any input arguments and
// passes them to the implementation version of the function, appearing above.
//
void Vguidata(mwArray h, mwArray data_in) {
    mwArray data = mwArray::UNDEFINED;
    data = Mguidata(0, h, data_in);
}

//
// The function "mlxGuidata" contains the feval interface for the "guidata"
// M-function from file "e:\matlab6.5\toolbox\matlab\uitools\guidata.m" (lines
// 1-99). The feval function calls the implementation version of guidata
// through this function. This function processes any input arguments and
// passes them to the implementation version of the function, appearing above.
//
void mlxGuidata(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
    MW_BEGIN_MLX();
    {
        mwArray mprhs[2];
        mwArray mplhs[1];
        int i;
        mclCppUndefineArrays(1, mplhs);
        if (nlhs > 1) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: guidata Line: 1 Column: "
                  "1 The function \"guidata\" was called with mor"
                  "e than the declared number of outputs (1).")));
        }
        if (nrhs > 2) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: guidata Line: 1 Column: "
                  "1 The function \"guidata\" was called with mor"
                  "e than the declared number of inputs (2).")));
        }
        for (i = 0; i < 2 && i < nrhs; ++i) {
            mprhs[i] = mwArray(prhs[i], 0);
        }
        for (; i < 2; ++i) {
            mprhs[i].MakeDIN();
        }
        mplhs[0] = Mguidata(nlhs, mprhs[0], mprhs[1]);
        plhs[0] = mplhs[0].FreezeData();
    }
    MW_END_MLX();
}

//
// The function "guidata_getParentFigure" contains the normal interface for the
// "guidata/getParentFigure" M-function from file
// "e:\matlab6.5\toolbox\matlab\uitools\guidata.m" (lines 99-105). This
// function processes any input arguments and passes them to the implementation
// version of the function, appearing above.
//
static mwArray guidata_getParentFigure(mwArray fig_in) {
    int nargout = 1;
    mwArray fig = mwArray::UNDEFINED;
    fig = Mguidata_getParentFigure(nargout, fig_in);
    return fig;
}

//
// The function "mlxGuidata_getParentFigure" contains the feval interface for
// the "guidata/getParentFigure" M-function from file
// "e:\matlab6.5\toolbox\matlab\uitools\guidata.m" (lines 99-105). The feval
// function calls the implementation version of guidata/getParentFigure through
// this function. This function processes any input arguments and passes them
// to the implementation version of the function, appearing above.
//
void mlxGuidata_getParentFigure(int nlhs,
                                mxArray * plhs[],
                                int nrhs,
                                mxArray * prhs[]) {
    MW_BEGIN_MLX();
    {
        mwArray mprhs[1];
        mwArray mplhs[1];
        int i;
        mclCppUndefineArrays(1, mplhs);
        if (nlhs > 1) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: guidata/getParentFigure Line: 99 Co"
                  "lumn: 1 The function \"guidata/getParentFigure\" was call"
                  "ed with more than the declared number of outputs (1).")));
        }
        if (nrhs > 1) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: guidata/getParentFigure Line: 99 Co"
                  "lumn: 1 The function \"guidata/getParentFigure\" was call"
                  "ed with more than the declared number of inputs (1).")));
        }
        for (i = 0; i < 1 && i < nrhs; ++i) {
            mprhs[i] = mwArray(prhs[i], 0);
        }
        for (; i < 1; ++i) {
            mprhs[i].MakeDIN();
        }
        mplhs[0] = Mguidata_getParentFigure(nlhs, mprhs[0]);
        plhs[0] = mplhs[0].FreezeData();
    }
    MW_END_MLX();
}

//
// The function "Mguidata" is the implementation version of the "guidata"
// M-function from file "e:\matlab6.5\toolbox\matlab\uitools\guidata.m" (lines
// 1-99). It contains the actual compiled code for that M-function. It is a
// static function and must only be called from one of the interface functions,
// appearing below.
//