guihandles.cpp

matlab的可执行程序

//
// 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 "guihandles.hpp"
#include "libsgl.hpp"
#include "isvarname.hpp"
#include "libmatlbm.hpp"
#include "libmmfile.hpp"
#include "libmwsglm.hpp"
static mwArray _mxarray0_ = mclInitializeDoubleVector(0, 0, (double *)NULL);

static mxChar _array2_[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 _mxarray1_ = mclInitializeString(54, _array2_);

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

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

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

static mxChar _array10_[3] = { 't', 'a', 'g' };
static mwArray _mxarray9_ = mclInitializeString(3, _array10_);

void InitializeModule_guihandles() {
}

void TerminateModule_guihandles() {
}

static mwArray guihandles_getParentFigure(mwArray fig_in = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxGuihandles_getParentFigure(int nlhs,
                                   mxArray * plhs[],
                                   int nrhs,
                                   mxArray * prhs[]);
static mwArray guihandles_createHandles(mwArray fig = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxGuihandles_createHandles(int nlhs,
                                 mxArray * plhs[],
                                 int nrhs,
                                 mxArray * prhs[]);
static mwArray Mguihandles(int nargout_, mwArray h);
static mwArray Mguihandles_getParentFigure(int nargout_, mwArray fig_in);
static mwArray Mguihandles_createHandles(int nargout_, mwArray fig);

static mexFunctionTableEntry local_function_table_[2]
  = { { "getParentFigure", mlxGuihandles_getParentFigure, 1, 1, NULL },
      { "createHandles", mlxGuihandles_createHandles, 1, 1, NULL } };

_mexLocalFunctionTable _local_function_table_guihandles
  = { 2, local_function_table_ };

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

//
// The function "mlxGuihandles" contains the feval interface for the
// "guihandles" M-function from file
// "e:\matlab6.5\toolbox\matlab\uitools\guihandles.m" (lines 1-78). The feval
// function calls the implementation version of guihandles through this
// function. This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
void mlxGuihandles(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: guihandles Line: 1 Column:"
                  " 1 The function \"guihandles\" was called with m"
                  "ore than the declared number of outputs (1).")));
        }
        if (nrhs > 1) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: guihandles Line: 1 Column:"
                  " 1 The function \"guihandles\" was called with m"
                  "ore 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] = Mguihandles(nlhs, mprhs[0]);
        plhs[0] = mplhs[0].FreezeData();
    }
    MW_END_MLX();
}

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

//
// The function "mlxGuihandles_getParentFigure" contains the feval interface
// for the "guihandles/getParentFigure" M-function from file
// "e:\matlab6.5\toolbox\matlab\uitools\guihandles.m" (lines 78-86). The feval
// function calls the implementation version of guihandles/getParentFigure
// through this function. This function processes any input arguments and
// passes them to the implementation version of the function, appearing above.
//
void mlxGuihandles_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: guihandles/getParentFigure Line: 78 C"
                  "olumn: 1 The function \"guihandles/getParentFigure\" was ca"
                  "lled with more than the declared number of outputs (1).")));
        }
        if (nrhs > 1) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: guihandles/getParentFigure Line: 78 C"
                  "olumn: 1 The function \"guihandles/getParentFigure\" was ca"
                  "lled 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] = Mguihandles_getParentFigure(nlhs, mprhs[0]);
        plhs[0] = mplhs[0].FreezeData();
    }
    MW_END_MLX();
}

//
// The function "guihandles_createHandles" contains the normal interface for
// the "guihandles/createHandles" M-function from file
// "e:\matlab6.5\toolbox\matlab\uitools\guihandles.m" (lines 86-111). This
// function processes any input arguments and passes them to the implementation
// version of the function, appearing above.
//
static mwArray guihandles_createHandles(mwArray fig) {
    int nargout = 1;
    mwArray handles = mwArray::UNDEFINED;
    handles = Mguihandles_createHandles(nargout, fig);
    return handles;
}

//
// The function "mlxGuihandles_createHandles" contains the feval interface for
// the "guihandles/createHandles" M-function from file
// "e:\matlab6.5\toolbox\matlab\uitools\guihandles.m" (lines 86-111). The feval
// function calls the implementation version of guihandles/createHandles
// through this function. This function processes any input arguments and
// passes them to the implementation version of the function, appearing above.
//
void mlxGuihandles_createHandles(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: guihandles/createHandles Line: 86 Co"
                  "lumn: 1 The function \"guihandles/createHandles\" was call"
                  "ed with more than the declared number of outputs (1).")));
        }
        if (nrhs > 1) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: guihandles/createHandles Line: 86 Co"
                  "lumn: 1 The function \"guihandles/createHandles\" 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] = Mguihandles_createHandles(nlhs, mprhs[0]);
        plhs[0] = mplhs[0].FreezeData();
    }
    MW_END_MLX();
}

//
// The function "Mguihandles" is the implementation version of the "guihandles"
// M-function from file "e:\matlab6.5\toolbox\matlab\uitools\guihandles.m"
// (lines 1-78). 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.
//
//
// function handles = guihandles(h)
//
static mwArray Mguihandles(int nargout_, mwArray h) {
    mwLocalFunctionTable save_local_function_table_
      = &_local_function_table_guihandles;
    int nargin_ = nargin(1, mwVarargin(h));
    mwArray handles = mwArray::UNDEFINED;
    mwArray ans = mwArray::UNDEFINED;
    mwArray fig = mwArray::UNDEFINED;
    //
    // %GUIHANDLES Return a structure of handles.
    // %   HANDLES = GUIHANDLES(H) returns a structure containing handles of
    // %   objects in a figure, using their tags as fieldnames.  Objects
    // %   are excluded if their tags are empty, or are not legal variable