311 lines
11 KiB
Matlab
Executable File
311 lines
11 KiB
Matlab
Executable File
function varargout = gui_mainfcn(gui_State, varargin)
|
|
% GUI_MAINFCN Support function for creation and callback dispatch of GUIDE GUIs.
|
|
% 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-2006 The MathWorks, Inc.
|
|
% $Revision: 1.1.6.9 $ $Date: 2010/07/27 21:08:12 $
|
|
global ghandles
|
|
gui_StateFields = {'gui_Name'
|
|
'gui_Singleton'
|
|
'gui_OpeningFcn'
|
|
'gui_OutputFcn'
|
|
'gui_LayoutFcn'
|
|
'gui_Callback'};
|
|
gui_Mfile = '';
|
|
for i=1:length(gui_StateFields)
|
|
if ~isfield(gui_State, gui_StateFields{i})
|
|
error('MATLAB:gui_mainfcn:FieldNotFound', 'Could not find field %s in the gui_State struct in GUI M-file %s', gui_StateFields{i}, gui_Mfile);
|
|
elseif isequal(gui_StateFields{i}, 'gui_Name')
|
|
gui_Mfile = [gui_State.(gui_StateFields{i}), '.m'];
|
|
end
|
|
end
|
|
|
|
numargin = length(varargin);
|
|
|
|
if numargin == 0
|
|
% UNTITLED
|
|
% create the GUI only if we are not in the process of loading it
|
|
% already
|
|
gui_Create = true;
|
|
elseif local_isInvokeActiveXCallback(gui_State, varargin{:})
|
|
% UNTITLED(ACTIVEX,...)
|
|
vin{1} = gui_State.gui_Name;
|
|
vin{2} = [get(varargin{1}.Peer, 'Tag'), '_', varargin{end}];
|
|
vin{3} = varargin{1};
|
|
vin{4} = varargin{end-1};
|
|
vin{5} = guidata(varargin{1}.Peer);
|
|
feval(vin{:});
|
|
return;
|
|
elseif local_isInvokeHGCallback(gui_State, varargin{:})
|
|
% UNTITLED('CALLBACK',hObject,eventData,handles,...)
|
|
gui_Create = false;
|
|
else
|
|
% UNTITLED(...)
|
|
% create the GUI and hand varargin to the openingfcn
|
|
gui_Create = true;
|
|
end
|
|
|
|
if ~gui_Create
|
|
% In design time, we need to mark all components possibly created in
|
|
% the coming callback evaluation as non-serializable. This way, they
|
|
% will not be brought into GUIDE and not be saved in the figure file
|
|
% when running/saving the GUI from GUIDE.
|
|
designEval = false;
|
|
if (numargin>1 && ishghandle(varargin{2}))
|
|
fig = varargin{2};
|
|
while ~isempty(fig) && ~ishghandle(fig,'figure')
|
|
fig = get(fig,'parent');
|
|
end
|
|
|
|
designEval = isappdata(0,'CreatingGUIDEFigure') || isprop(fig,'__GUIDEFigure');
|
|
end
|
|
|
|
if designEval
|
|
beforeChildren = findall(fig);
|
|
end
|
|
|
|
% evaluate the callback now
|
|
varargin{1} = gui_State.gui_Callback;
|
|
if nargout
|
|
[varargout{1:nargout}] = feval(varargin{:});
|
|
else
|
|
feval(varargin{:});
|
|
end
|
|
|
|
% Set serializable of objects created in the above callback to off in
|
|
% design time. Need to check whether figure handle is still valid in
|
|
% case the figure is deleted during the callback dispatching.
|
|
if designEval && ishghandle(fig)
|
|
set(setdiff(findall(fig),beforeChildren), 'Serializable','off');
|
|
end
|
|
else
|
|
if gui_State.gui_Singleton
|
|
gui_SingletonOpt = 'reuse';
|
|
else
|
|
gui_SingletonOpt = 'new';
|
|
end
|
|
|
|
% Check user passing 'visible' P/V pair first so that its value can be
|
|
% used by oepnfig to prevent flickering
|
|
gui_Visible = 'auto';
|
|
gui_VisibleInput = '';
|
|
for index=1:2:length(varargin)
|
|
if length(varargin) == index || ~ischar(varargin{index})
|
|
break;
|
|
end
|
|
|
|
% Recognize 'visible' P/V pair
|
|
len1 = min(length('visible'),length(varargin{index}));
|
|
len2 = min(length('off'),length(varargin{index+1}));
|
|
if ischar(varargin{index+1}) && strncmpi(varargin{index},'visible',len1) && len2 > 1
|
|
if strncmpi(varargin{index+1},'off',len2)
|
|
gui_Visible = 'invisible';
|
|
gui_VisibleInput = 'off';
|
|
elseif strncmpi(varargin{index+1},'on',len2)
|
|
gui_Visible = 'visible';
|
|
gui_VisibleInput = 'on';
|
|
end
|
|
end
|
|
end
|
|
|
|
% Open fig file with stored settings. Note: This executes all component
|
|
% specific CreateFunctions with an empty HANDLES structure.
|
|
|
|
|
|
% Do feval on layout code in m-file if it exists
|
|
gui_Exported = ~isempty(gui_State.gui_LayoutFcn);
|
|
% this application data is used to indicate the running mode of a GUIDE
|
|
% GUI to distinguish it from the design mode of the GUI in GUIDE. it is
|
|
% only used by actxproxy at this time.
|
|
setappdata(0,genvarname(['OpenGuiWhenRunning_', gui_State.gui_Name]),1);
|
|
if gui_Exported
|
|
gui_hFigure = feval(gui_State.gui_LayoutFcn, gui_SingletonOpt);
|
|
|
|
% make figure invisible here so that the visibility of figure is
|
|
% consistent in OpeningFcn in the exported GUI case
|
|
if isempty(gui_VisibleInput)
|
|
gui_VisibleInput = get(gui_hFigure,'Visible');
|
|
end
|
|
set(gui_hFigure,'Visible','off')
|
|
|
|
% openfig (called by local_openfig below) does this for guis without
|
|
% the LayoutFcn. Be sure to do it here so guis show up on screen.
|
|
movegui(gui_hFigure,'onscreen');
|
|
else
|
|
gui_hFigure = local_openfig(gui_State.gui_Name, gui_SingletonOpt, gui_Visible);
|
|
% If the figure has InGUIInitialization it was not completely created
|
|
% on the last pass. Delete this handle and try again.
|
|
if isappdata(gui_hFigure, 'InGUIInitialization')
|
|
delete(gui_hFigure);
|
|
gui_hFigure = local_openfig(gui_State.gui_Name, gui_SingletonOpt, gui_Visible);
|
|
end
|
|
end
|
|
if isappdata(0, genvarname(['OpenGuiWhenRunning_', gui_State.gui_Name]))
|
|
rmappdata(0,genvarname(['OpenGuiWhenRunning_', gui_State.gui_Name]));
|
|
end
|
|
|
|
% Set flag to indicate starting GUI initialization
|
|
setappdata(gui_hFigure,'InGUIInitialization',1);
|
|
|
|
% Fetch GUIDE Application options
|
|
gui_Options = getappdata(gui_hFigure,'GUIDEOptions');
|
|
% Singleton setting in the GUI M-file takes priority if different
|
|
gui_Options.singleton = gui_State.gui_Singleton;
|
|
|
|
if ~isappdata(gui_hFigure,'GUIOnScreen')
|
|
% Adjust background color
|
|
if gui_Options.syscolorfig
|
|
set(gui_hFigure,'Color', get(0,'DefaultUicontrolBackgroundColor'));
|
|
end
|
|
|
|
% Generate HANDLES structure and store with GUIDATA. If there is
|
|
% user set GUI data already, keep that also.
|
|
data = guidata(gui_hFigure);
|
|
handles = guihandles(gui_hFigure);
|
|
if ~isempty(handles)
|
|
if isempty(data)
|
|
data = handles;
|
|
else
|
|
names = fieldnames(handles);
|
|
for k=1:length(names)
|
|
data.(char(names(k)))=handles.(char(names(k)));
|
|
end
|
|
end
|
|
end
|
|
guidata(gui_hFigure, data);
|
|
end
|
|
|
|
% Apply input P/V pairs other than 'visible'
|
|
for index=1:2:length(varargin)
|
|
if length(varargin) == index || ~ischar(varargin{index})
|
|
break;
|
|
end
|
|
|
|
len1 = min(length('visible'),length(varargin{index}));
|
|
if ~strncmpi(varargin{index},'visible',len1)
|
|
try set(gui_hFigure, varargin{index}, varargin{index+1}), catch break, end
|
|
end
|
|
end
|
|
|
|
% If handle visibility is set to 'callback', turn it on until finished
|
|
% with OpeningFcn
|
|
gui_HandleVisibility = get(gui_hFigure,'HandleVisibility');
|
|
if strcmp(gui_HandleVisibility, 'callback')
|
|
set(gui_hFigure,'HandleVisibility', 'on');
|
|
end
|
|
|
|
feval(gui_State.gui_OpeningFcn, gui_hFigure, [], guidata(gui_hFigure), varargin{:});
|
|
|
|
if isscalar(gui_hFigure) && ishghandle(gui_hFigure)
|
|
% Handle the default callbacks of predefined toolbar tools in this
|
|
% GUI, if any
|
|
guidemfile('restoreToolbarToolPredefinedCallback',gui_hFigure);
|
|
|
|
% Update handle visibility
|
|
set(gui_hFigure,'HandleVisibility', gui_HandleVisibility);
|
|
|
|
% Call openfig again to pick up the saved visibility or apply the
|
|
% one passed in from the P/V pairs
|
|
if ~gui_Exported
|
|
gui_hFigure = local_openfig(gui_State.gui_Name, 'reuse',gui_Visible);
|
|
elseif ~isempty(gui_VisibleInput)
|
|
set(gui_hFigure,'Visible',gui_VisibleInput);
|
|
end
|
|
if strcmpi(get(gui_hFigure, 'Visible'), 'on')
|
|
figure(gui_hFigure);
|
|
|
|
if gui_Options.singleton
|
|
setappdata(gui_hFigure,'GUIOnScreen', 1);
|
|
end
|
|
end
|
|
|
|
% Done with GUI initialization
|
|
if isappdata(gui_hFigure,'InGUIInitialization')
|
|
rmappdata(gui_hFigure,'InGUIInitialization');
|
|
end
|
|
|
|
% If handle visibility is set to 'callback', turn it on until
|
|
% finished with OutputFcn
|
|
gui_HandleVisibility = get(gui_hFigure,'HandleVisibility');
|
|
if strcmp(gui_HandleVisibility, 'callback')
|
|
set(gui_hFigure,'HandleVisibility', 'on');
|
|
end
|
|
gui_Handles = guidata(gui_hFigure);
|
|
else
|
|
gui_Handles = [];
|
|
end
|
|
|
|
if nargout
|
|
[varargout{1:nargout}] = feval(gui_State.gui_OutputFcn, gui_hFigure, [], gui_Handles);
|
|
else
|
|
feval(gui_State.gui_OutputFcn, gui_hFigure, [], gui_Handles);
|
|
end
|
|
|
|
if isscalar(gui_hFigure) && ishghandle(gui_hFigure)
|
|
set(gui_hFigure,'HandleVisibility', gui_HandleVisibility);
|
|
end
|
|
end
|
|
|
|
function gui_hFigure = local_openfig(name, singleton, visible)
|
|
|
|
% openfig with three arguments was new from R13. Try to call that first, if
|
|
% failed, try the old openfig.
|
|
if nargin('openfig') == 2
|
|
% OPENFIG did not accept 3rd input argument until R13,
|
|
% toggle default figure visible to prevent the figure
|
|
% from showing up too soon.
|
|
gui_OldDefaultVisible = get(0,'defaultFigureVisible');
|
|
set(0,'defaultFigureVisible','off');
|
|
gui_hFigure = openfig(name, singleton);
|
|
set(0,'defaultFigureVisible',gui_OldDefaultVisible);
|
|
else
|
|
gui_hFigure = openfig(name, singleton, visible);
|
|
end
|
|
|
|
function result = local_isInvokeActiveXCallback(gui_State, varargin)
|
|
|
|
try
|
|
result = ispc && iscom(varargin{1}) ...
|
|
&& isequal(varargin{1},gcbo);
|
|
catch
|
|
result = false;
|
|
end
|
|
|
|
function result = local_isInvokeHGCallback(gui_State, varargin)
|
|
|
|
try
|
|
fhandle = functions(gui_State.gui_Callback);
|
|
result = ~isempty(findstr(gui_State.gui_Name,fhandle.file)) || ...
|
|
(ischar(varargin{1}) ...
|
|
&& isequal(ishghandle(varargin{2}), 1) ...
|
|
&& (~isempty(strfind(varargin{1},[get(varargin{2}, 'Tag'), '_'])) || ...
|
|
~isempty(strfind(varargin{1}, '_CreateFcn'))) );
|
|
catch
|
|
result = false;
|
|
end
|
|
|