gui_mainfcn.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 "gui_mainfcn.hpp"
#include "libsgl.hpp"
#include "guidata.hpp"
#include "guihandles.hpp"
#include "libmatlbm.hpp"
#include "libmmfile.hpp"
#include "openfig.hpp"

static mxChar _array3_[8] = { 'g', 'u', 'i', '_', 'N', 'a', 'm', 'e' };
static mxArray * _mxarray2_ = mclInitializeString(8, _array3_);

static mxChar _array5_[13] = { 'g', 'u', 'i', '_', 'S', 'i', 'n',
                               'g', 'l', 'e', 't', 'o', 'n' };
static mxArray * _mxarray4_ = mclInitializeString(13, _array5_);

static mxChar _array7_[14] = { 'g', 'u', 'i', '_', 'O', 'p', 'e',
                               'n', 'i', 'n', 'g', 'F', 'c', 'n' };
static mxArray * _mxarray6_ = mclInitializeString(14, _array7_);

static mxChar _array9_[13] = { 'g', 'u', 'i', '_', 'O', 'u', 't',
                               'p', 'u', 't', 'F', 'c', 'n' };
static mxArray * _mxarray8_ = mclInitializeString(13, _array9_);

static mxChar _array11_[13] = { 'g', 'u', 'i', '_', 'L', 'a', 'y',
                                'o', 'u', 't', 'F', 'c', 'n' };
static mxArray * _mxarray10_ = mclInitializeString(13, _array11_);

static mxChar _array13_[12] = { 'g', 'u', 'i', '_', 'C', 'a',
                                'l', 'l', 'b', 'a', 'c', 'k' };
static mxArray * _mxarray12_ = mclInitializeString(12, _array13_);

static mxArray * _array1_[6] = { _mxarray2_, _mxarray4_, _mxarray6_,
                                 _mxarray8_, _mxarray10_, _mxarray12_ };
static mwArray _mxarray0_ = mclInitializeCellVector(6, 1, _array1_);
static mwArray _mxarray14_ = mclInitializeCharVector(0, 0, (mxChar *)NULL);
static mwArray _mxarray15_ = mclInitializeDoubleVector(0, 0, (double *)NULL);

static mxChar _array17_[64] = { 'C', 'o', 'u', 'l', 'd', ' ', 'n', 'o',
                                't', ' ', 'f', 'i', 'n', 'd', ' ', 'f',
                                'i', 'e', 'l', 'd', ' ', '%', 's', ' ',
                                'i', 'n', ' ', 't', 'h', 'e', ' ', 'g',
                                'u', 'i', '_', 'S', 't', 'a', 't', 'e',
                                ' ', 's', 't', 'r', 'u', 'c', 't', ' ',
                                'i', 'n', ' ', 'G', 'U', 'I', ' ', 'M',
                                '-', 'f', 'i', 'l', 'e', ' ', '%', 's' };
static mwArray _mxarray16_ = mclInitializeString(64, _array17_);
static mwArray _mxarray18_ = mclInitializeString(8, _array3_);

static mxChar _array20_[2] = { '.', 'm' };
static mwArray _mxarray19_ = mclInitializeString(2, _array20_);
static mwArray _mxarray21_ = mclInitializeDouble(0.0);
static mwArray _mxarray22_ = mclInitializeDouble(1.0);
static mwArray _mxarray23_ = mclInitializeDouble(2.0);
static mwArray _mxarray24_ = mclInitializeDouble(3.0);

static mxChar _array26_[5] = { 'r', 'e', 'u', 's', 'e' };
static mwArray _mxarray25_ = mclInitializeString(5, _array26_);

static mxChar _array28_[3] = { 'n', 'e', 'w' };
static mwArray _mxarray27_ = mclInitializeString(3, _array28_);

static mxChar _array30_[19] = { 'I', 'n', 'G', 'U', 'I', 'I', 'n',
                                'i', 't', 'i', 'a', 'l', 'i', 'z',
                                'a', 't', 'i', 'o', 'n' };
static mwArray _mxarray29_ = mclInitializeString(19, _array30_);

static mxChar _array32_[12] = { 'G', 'U', 'I', 'D', 'E', 'O',
                                'p', 't', 'i', 'o', 'n', 's' };
static mwArray _mxarray31_ = mclInitializeString(12, _array32_);

static mxChar _array34_[11] = { 'G', 'U', 'I', 'O', 'n', 'S',
                                'c', 'r', 'e', 'e', 'n' };
static mwArray _mxarray33_ = mclInitializeString(11, _array34_);

static mxChar _array36_[5] = { 'C', 'o', 'l', 'o', 'r' };
static mwArray _mxarray35_ = mclInitializeString(5, _array36_);

static mxChar _array38_[31] = { 'D', 'e', 'f', 'a', 'u', 'l', 't', 'U',
                                'i', 'c', 'o', 'n', 't', 'r', 'o', 'l',
                                'B', 'a', 'c', 'k', 'g', 'r', 'o', 'u',
                                'n', 'd', 'C', 'o', 'l', 'o', 'r' };
static mwArray _mxarray37_ = mclInitializeString(31, _array38_);

static mxChar _array40_[7] = { 'v', 'i', 's', 'i', 'b', 'l', 'e' };
static mwArray _mxarray39_ = mclInitializeString(7, _array40_);

static mxChar _array42_[3] = { 'o', 'f', 'f' };
static mwArray _mxarray41_ = mclInitializeString(3, _array42_);

static mxChar _array44_[2] = { 'o', 'n' };
static mwArray _mxarray43_ = mclInitializeString(2, _array44_);

static mxChar _array46_[16] = { 'H', 'a', 'n', 'd', 'l', 'e', 'V', 'i',
                                's', 'i', 'b', 'i', 'l', 'i', 't', 'y' };
static mwArray _mxarray45_ = mclInitializeString(16, _array46_);

static mxChar _array48_[8] = { 'c', 'a', 'l', 'l', 'b', 'a', 'c', 'k' };
static mwArray _mxarray47_ = mclInitializeString(8, _array48_);

static mxChar _array50_[7] = { 'V', 'i', 's', 'i', 'b', 'l', 'e' };
static mwArray _mxarray49_ = mclInitializeString(7, _array50_);

static mxChar _array52_[4] = { 'a', 'u', 't', 'o' };
static mwArray _mxarray51_ = mclInitializeString(4, _array52_);

static mxChar _array54_[20] = { 'd', 'e', 'f', 'a', 'u', 'l', 't',
                                'F', 'i', 'g', 'u', 'r', 'e', 'V',
                                'i', 's', 'i', 'b', 'l', 'e' };
static mwArray _mxarray53_ = mclInitializeString(20, _array54_);

void InitializeModule_gui_mainfcn() {
}

void TerminateModule_gui_mainfcn() {
    mxDestroyArray(_mxarray12_);
    mxDestroyArray(_mxarray10_);
    mxDestroyArray(_mxarray8_);
    mxDestroyArray(_mxarray6_);
    mxDestroyArray(_mxarray4_);
    mxDestroyArray(_mxarray2_);
}

static mwArray gui_mainfcn_local_openfig(mwArray name = mwArray::DIN,
                                         mwArray singleton = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxGui_mainfcn_local_openfig(int nlhs,
                                  mxArray * plhs[],
                                  int nrhs,
                                  mxArray * prhs[]);
static mwArray Mgui_mainfcn(int nargout_, mwArray gui_State, mwArray varargin);
static mwArray Mgui_mainfcn_local_openfig(int nargout_,
                                          mwArray name,
                                          mwArray singleton);

static mexFunctionTableEntry local_function_table_[1]
  = { { "local_openfig", mlxGui_mainfcn_local_openfig, 2, 1, NULL } };

_mexLocalFunctionTable _local_function_table_gui_mainfcn
  = { 1, local_function_table_ };

//
// The function "Ngui_mainfcn" contains the nargout interface for the
// "gui_mainfcn" M-function from file
// "e:\matlab6.5\toolbox\matlab\uitools\gui_mainfcn.m" (lines 1-182). 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 Ngui_mainfcn(int nargout,
                     mwVarargout varargout,
                     mwArray gui_State,
                     mwVarargin varargin) {
    nargout += varargout.Nargout();
    varargout.GetCell() = Mgui_mainfcn(nargout, gui_State, varargin.ToArray());
    return varargout.AssignOutputs();
}

//
// The function "gui_mainfcn" contains the normal interface for the
// "gui_mainfcn" M-function from file
// "e:\matlab6.5\toolbox\matlab\uitools\gui_mainfcn.m" (lines 1-182). This
// function processes any input arguments and passes them to the implementation
// version of the function, appearing above.
//
mwArray gui_mainfcn(mwVarargout varargout,
                    mwArray gui_State,
                    mwVarargin varargin) {
    int nargout = 0;
    nargout += varargout.Nargout();
    varargout.GetCell() = Mgui_mainfcn(nargout, gui_State, varargin.ToArray());
    return varargout.AssignOutputs();
}

//
// The function "Vgui_mainfcn" contains the void interface for the
// "gui_mainfcn" M-function from file
// "e:\matlab6.5\toolbox\matlab\uitools\gui_mainfcn.m" (lines 1-182). 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 Vgui_mainfcn(mwArray gui_State, mwVarargin varargin) {
    mwArray varargout = mwArray::UNDEFINED;
    varargout = Mgui_mainfcn(0, gui_State, varargin.ToArray());
}

//
// The function "mlxGui_mainfcn" contains the feval interface for the
// "gui_mainfcn" M-function from file
// "e:\matlab6.5\toolbox\matlab\uitools\gui_mainfcn.m" (lines 1-182). The feval
// function calls the implementation version of gui_mainfcn through this
// function. This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
void mlxGui_mainfcn(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
    MW_BEGIN_MLX();
    {
        mwArray mprhs[2];
        mwArray mplhs[1];
        int i;
        mclCppUndefineArrays(1, mplhs);
        for (i = 0; i < 1 && i < nrhs; ++i) {
            mprhs[i] = mwArray(prhs[i], 0);
        }
        for (; i < 1; ++i) {
            mprhs[i].MakeDIN();
        }
        mprhs[1] = mclCreateVararginCell(nrhs - 1, prhs + 1);
        mplhs[0] = Mgui_mainfcn(nlhs, mprhs[0], mprhs[1]);
        mclAssignVarargoutCell(0, nlhs, plhs, mplhs[0].FreezeData());
    }
    MW_END_MLX();
}

//
// The function "gui_mainfcn_local_openfig" contains the normal interface for
// the "gui_mainfcn/local_openfig" M-function from file
// "e:\matlab6.5\toolbox\matlab\uitools\gui_mainfcn.m" (lines 182-194). This
// function processes any input arguments and passes them to the implementation
// version of the function, appearing above.
//
static mwArray gui_mainfcn_local_openfig(mwArray name, mwArray singleton) {
    int nargout = 1;
    mwArray gui_hFigure = mwArray::UNDEFINED;
    gui_hFigure = Mgui_mainfcn_local_openfig(nargout, name, singleton);
    return gui_hFigure;
}

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

//
// The function "Mgui_mainfcn" is the implementation version of the
// "gui_mainfcn" M-function from file
// "e:\matlab6.5\toolbox\matlab\uitools\gui_mainfcn.m" (lines 1-182). 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 varargout = gui_mainfcn(gui_State, varargin)
//
static mwArray Mgui_mainfcn(int nargout_, mwArray gui_State, mwArray varargin) {
    mwLocalFunctionTable save_local_function_table_
      = &_local_function_table_gui_mainfcn;
    mwArray varargout = mwArray::UNDEFINED;
    mwArray gui_Handles = mwArray::UNDEFINED;
    mwArray gui_HandleVisibility = mwArray::UNDEFINED;
    mwArray index = mwArray::UNDEFINED;
    mwArray len2 = mwArray::UNDEFINED;
    mwArray len1 = mwArray::UNDEFINED;
    mwArray ind = mwArray::UNDEFINED;
    mwArray gui_MakeVisible = mwArray::UNDEFINED;
    mwArray gui_Options = mwArray::UNDEFINED;
    mwArray gui_hFigure = mwArray::UNDEFINED;
    mwArray gui_SingletonOpt = mwArray::UNDEFINED;
    mwArray _T0_ = mwArray::UNDEFINED;
    mwArray gui_Create = mwArray::UNDEFINED;
    mwArray numargin = mwArray::UNDEFINED;
    mwArray ans = mwArray::UNDEFINED;
    mwArray i = mwArray::UNDEFINED;
    mwArray gui_Mfile = mwArray::UNDEFINED;
    mwArray gui_StateFields = mwArray::UNDEFINED;
    //
    // % GUI_MAINFCN A function to handle default GUIDE GUI creation and callback dispatch.
    // %   GUI_MAINFCN is called from inside M-files generated by GUIDE to handle 
    // %   GUI creation, layout, and callback dispatch.
    // %
    // %   See also: GUIDE.
    // 
    // %   GUI_MAINFCN provides these command line APIs for dealing with GUIs
    // %
    // %      UNTITLED, by itself, creates a new UNTITLED or raises the existing
    // %      singleton*.
    // %
    // %      H = UNTITLED returns the handle to a new UNTITLED or the handle to
    // %      the existing singleton*.
    // %
    // %      UNTITLED('CALLBACK',hObject,eventData,handles,...) calls the local
    // %      function named CALLBACK in UNTITLED.M with the given input arguments.
    // %
    // %      UNTITLED('Property','Value',...) creates a new UNTITLED or raises the
    // %      existing singleton*.  Starting from the left, property value pairs are
    // %      applied to the GUI before untitled_OpeningFunction gets called.  An
    // %      unrecognized property name or invalid value makes property application
    // %      stop.  All inputs are passed to untitled_OpeningFcn via varargin.
    // %
    // %      *See GUI Options on GUIDE's Tools menu.  Choose "GUI allows only one
    // %      instance to run (singleton)".
    // 
    // %   Copyright 1984-2002 The MathWorks, Inc.
    // %   $Revision: 1.5 $ $Date: 2003/07/17 18:28:28 $
    // 
    // gui_StateFields =  {'gui_Name'
    //
    gui_StateFields = _mxarray0_;
    //
    // 'gui_Singleton'
    // 'gui_OpeningFcn'
    // 'gui_OutputFcn'
    // 'gui_LayoutFcn'
    // 'gui_Callback'};
    // gui_Mfile = '';
    //
    gui_Mfile = _mxarray14_;
    //
    // for i=1:length(gui_StateFields)
    //
    {
        int v_ = mclForIntStart(1);
        int e_ = mclLengthInt(mwVv(gui_StateFields, "gui_StateFields"));
        if (v_ > e_) {