chebguiwindow.m

function varargout = chebguiwindow(varargin)
% CHEBGUIWINDOW Driver file for Chebfun's CHEBGUI
%  This m-file populates and controls Chebfun's CHEBGUI.
%
% See also chebgui

% Copyright 2011 by The University of Oxford and The Chebfun Developers. 
% See http://www.maths.ox.ac.uk/chebfun/ for Chebfun information.

% Begin initialization code - DO NOT EDIT
gui_Singleton = 1;
gui_State = struct('gui_Name', mfilename, ...
    'gui_Singleton',  gui_Singleton, ...
    'gui_OpeningFcn', @chebguiwindow_OpeningFcn, ...
    'gui_OutputFcn',  @chebguiwindow_OutputFcn, ...
    'gui_LayoutFcn',  [] , ...
    'gui_Callback',   []);
if nargin && ischar(varargin{1})
    gui_State.gui_Callback = str2func(varargin{1});
end

if nargout
    [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
    warnstate = warning('off','MATLAB:hg:uicontrol:ParameterValuesMustBeValid');
    try
        gui_mainfcn(gui_State, varargin{:});
        warning(warnstate);
    catch ME
        warning(warnstate)
        MEID = ME.identifier;
        if ~isempty(strfind(MEID,'Chebgui:'))
            % These are expected GUI errors. We only show the dialog
            errordlg(cleanErrorMsg(ME.message), 'Chebgui error', 'modal');
            uiwait
            resetComponents(varargin{4});
            
            % If in debug mode, we throw the error to the command window as
            % well
            if get(varargin{4}.menu_debug,'UserData')
                rethrow(ME)
            end
        else
            % Show an error dialog, but also throw the error to the command
            % window
            errordlg(cleanErrorMsg(ME.message), 'Chebgui error', 'modal');
            uiwait
            resetComponents(varargin{4});
            rethrow(ME)
        end
    end
end
% End initialization code - DO NOT EDIT

% --- Executes just before chebguiwindow is made visible.
function chebguiwindow_OpeningFcn(hObject, eventdata, handles, varargin)
% This function has no output args, see Output(1-x^2)*exp(-30*(x+.5)^2)Fcn.
% hObject    handle to figure
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
% varargin   command line arguments to chebguiwindow (see VARARGIN)

% Choose default command line output for chebguiwindow
handles.output = hObject;

initialisefigures(handles)

% Variable that determines whether a solution is available
handles.hasSolution = 0;

% Variable which stores the initial guess/condition
handles.init = [];

% Variable which stores imported variables from workspace
handles.importedVar = struct;


% Get the GUI object from the input argument
if ~isempty(varargin)
    handles.guifile = varargin{1};
else
    cgTemp = chebgui('type','bvp');
    handles.guifile = loadexample(cgTemp,-1); % Load a random example
end
% Create a new structure which contains information about the latest
% solution obtained
handles.latest = struct;

% Store the default length of pausing between plots for BVPs and the
% tolerance in the userdata field of relevant menu objects.
set(handles.menu_odeplottingpause,'UserData','0.5');
set(handles.menu_tolerance,'UserData','1e-10');

% Create UserData for the Fix-Y-axis options (so that we can display
% something if it gets called without selecting a demo).
set(handles.menu_pdefixon,'UserData',{''});

% Populate the Demos menu, but only once (i.e. if user calls chebgui again,
% don't reload the examples).
if isempty(get(handles.menu_demos,'UserData'))
    loaddemo_menu(handles.guifile,handles);
    handles.demosLoaded = 1;
end
% Load the input fields
loadfields(handles.guifile,handles);

% Make sure the GUI starts in the correct mode
switchmode(handles.guifile,handles,handles.guifile.type);

% Get the system font size and store in handles
s = char(com.mathworks.services.FontPrefs.getCodeFont);
if s(end-2) == '='
    fs = round(3/4*str2num(s(end-1)));
else
    fs = round(3/4*str2num(s(end-2:end-1)));
end
set(handles.tempedit,'FontSize',fs);

% set(handles.check_uselatest,'String',{'Use latest';'solution'}); 

% Set the solve button to green
set(handles.button_solve,'String','Solve');
set(handles.button_solve,'BackgroundColor',[43 129 86]/256);
    
% Update handles structure
guidata(hObject, handles);

% UIWAIT makes chebguiwindow wait for user response (see UIRESUME)
% uiwait(handles.chebguimainwindow);

% --- Outputs from this function are returned to the command line.
function varargout = chebguiwindow_OutputFcn(hObject, eventdata, handles)
% varargout  cell array for returning output args (see VARARGOUT);
% hObject    handle to figure
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

% Get default command line output from handles structure
if nargout > 0,
    varargout{1} = handles.output;
end
% If nargout == 2, return the fll set of handles
if nargout > 1,
    varargout{2} = handles;
end

% -------------------------------------------------------------------------
% ---------- Callback functions for the objects of the GUI ----------------
% -------------------------------------------------------------------------

% -------------------------------------------------------------------------
% ------------- Functions which call chebgui methods ----------------------
% -------------------------------------------------------------------------

function button_clear_Callback(hObject, eventdata, handles)
if strcmp(get(handles.button_clear,'String'),'Clear all')
    [newGUI handles] = cleargui(handles.guifile,handles);
    handles.guifile = newGUI;
    guidata(hObject, handles);
elseif strcmp(get(handles.button_clear,'String'),'Pause')
    set(handles.button_clear,'String','Continue');
    set(handles.button_clear,'BackgroundColor',[43 129 86]/256);
    % Re-enable figure buttons
    set(handles.button_figsol,'Enable','on');
    set(handles.button_fignorm,'Enable','on');
else
    % Disable figure buttons
    set(handles.button_figsol,'Enable','off');
    set(handles.button_fignorm,'Enable','off');
    set(handles.button_clear,'String','Pause');
    set(handles.button_clear,'BackgroundColor',[255 179 0]/256);  
end

function button_solve_Callback(hObject, eventdata, handles)
% uicontrol(handles.panel_input)
% figure(handles.chebguimainwindow)
% set(hObject, 'Enable', 'off');
% drawnow;
% set(hObject, 'Enable', 'on');
handles = solveGUI(handles.guifile,handles);
guidata(hObject, handles);

function input_LBC_Callback(hObject, eventdata, handles)
newString = cellstr(get(hObject,'String'));
newString = removeTabs(newString); % Remove tabs
set(hObject,'String',newString);
handles = callbackBCs(handles.guifile,handles,newString,'lbc');
handles.guifile.LBC = newString;
guidata(hObject, handles);


function input_RBC_Callback(hObject, eventdata, handles)
newString = cellstr(get(hObject,'String'));
newString = removeTabs(newString); % Remove tabs
set(hObject,'String',newString);
handles = callbackBCs(handles.guifile,handles,newString,'rbc');
handles.guifile.RBC = newString;
guidata(hObject, handles);

% -------------------------------------------------------------------------
% --------- Functions which do their work without chebgui methods ---------
% -------------------------------------------------------------------------

function dom_left_Callback(hObject, eventdata, handles)
% Store the contents of input1_editText as a string. if the string
% is not a number then input will be empty
input = str2num(get(hObject,'String'));
% Checks to see if input is not numeric or empty. If so, default left end
% of the domain is taken to be -1.
if isempty(input) || isnan(input)
    warndlg('Left endpoint of domain unrecognized, default value -1 used.')
    set(hObject,'String','-1')
end

set(handles.input_GUESS,'Enable','on');
set(handles.toggle_useLatest,'Value',0);
set(handles.toggle_useLatest,'Enable','off');

handles.guifile.DomLeft = get(hObject,'String');
guidata(hObject, handles);


function dom_right_Callback(hObject, eventdata, handles)
input = str2num(get(hObject,'String'));
% Checks to see if input is not numeric or empty. If so, default right end
% of the domain is taken to be 1.
if isempty(input) || isnan(input)
    warndlg('Right endpoint of domain unrecognized, default value 1 used.')
    set(hObject,'String','1')
end

set(handles.input_GUESS,'Enable','on');
set(handles.toggle_useLatest,'Value',0);
set(handles.toggle_useLatest,'Enable','off');

handles.guifile.DomRight = get(hObject,'String');
guidata(hObject, handles);


function input_domain_Callback(hObject, eventdata, handles)
in = get(hObject,'String');
input = str2num(in);
% Checks to see if input is not numeric or empty. If so, default left end
% of the domain is taken to be -1.
if input(1) >= input(end)
    warndlg('Empty domain. Default value [-1,1] used.')
    in = '[-1,1]';
    set(hObject,'String',in);
elseif isempty(input) || any(isnan(input)) || length(input)<2
    warndlg('Domain unrecognized. Default value [-1,1] used.')
    in = '[-1,1]';
    set(hObject,'String',in);
elseif ~any(strfind(in,'['))
    in = ['[' in ']'];
    set(hObject,'String',in);
end

set(handles.input_GUESS,'Enable','on');
set(handles.toggle_useLatest,'Value',0);
set(handles.toggle_useLatest,'Enable','off');

handles.guifile.domain = in;
guidata(hObject, handles);

% --- Executes during object creation, after setting all properties.
function input_domain_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end




% -------------------------------------------------------------------------
% ------- Functions which do their work in a couple of lines of code ------
% -------------------------------------------------------------------------

function input_GUESS_Callback(hObject, eventdata, handles)
newString = cellstr(get(hObject,'String'));

% Remove tabs
newString = removeTabs(newString);
set(hObject,'String',newString);

handles.guifile.init = newString;
if isempty(newString) || (iscell(newString) && numel(newString)==1 && isempty(newString{1}))
    handles.init = '';
    axes(handles.fig_sol);
    cla(handles.fig_sol,'reset');
    guidata(hObject, handles);
    return
end

loadVariables(handles.importedVar)


guidata(hObject, handles);

xtTemp = chebfun('x',str2num(handles.guifile.domain));
% handles.init
if ~exist('r','var'), r = xtTemp; end
if ~exist('x','var'), x = xtTemp; end
if ~exist('t','var'), t = xtTemp; end
% Do something clever with multilines
str = cellstr(get(hObject,'String'));
init = [];
for k = 1:numel(str)
    strk = str{k};
    equalSigns = find(strk=='=');
    if numel(equalSigns) > 1
        error('Chebgui:InitInput','Too many equals signs in input.');
    elseif numel(equalSigns) == 1
        strk = strk(equalSigns+1:end);
    elseif numel(str) > 1
        error('Chebgui:InitInput',...
            'Error constructing initial guess. Input must include the names of the dependent variables, i.e. be on the form "u = %s",...',strk)
    end
        
    strk = deblank(vectorize(strk));
    try
        if ~isempty(strk)
            init = [init eval(strk)];
        end
    catch ME
        error('Chebgui:InitInput',ME.message)
    end
end
handles.init = init;
axes(handles.fig_sol);
plot(handles.init,'linewidth',2)
if ~isempty(handles.guifile.options.fixYaxisLower)
    ylim([str2num(handles.guifile.options.fixYaxisLower) ...
        str2num(handles.guifile.options.fixYaxisUpper)]);
end
if handles.guifile.options.grid, grid on,  end
guidata(hObject, handles);

function loadVariables(importedVar)
fNames = fieldnames(importedVar);
for i=1:length(fNames), assignin('caller',fNames{i},importedVar.(fNames{i})), end


function input_DE_Callback(hObject, eventdata, handles)
str = cellstr(get(hObject,'String'));

% Remove tabs
str = removeTabs(str);

% Update the DE input and store in guifile
set(handles.input_DE,'String',str);
handles.guifile.DE = str;

% Auto PDE and EIG detection
for k = 1:numel(str)
    strk = str{k};
    if any(strfind(strk,'_'))
        if ~get(handles.button_pde,'value')
            handles = switchmode(handles.guifile,handles,'pde');
        end
        break
    elseif any(strfind(strk,'lam') | strfind(strk,'lambda'))
        if ~get(handles.button_eig,'value')
            handles = switchmode(handles.guifile,handles,'eig');
        end
        break
    end
end
guidata(hObject, handles);

function str = removeTabs(str)
for k = 1:numel(str)
    idx = 1;
    strk = str{k};
    while ~isempty(idx)
        idx = strfind(strk,double(9));
        strk(idx) = [];
    end
    str{k} = strk;
end

%% Keypresses
function input_DE_KeyPressFcn(hObject, eventdata, handles)
if strcmp(eventdata.Key,'tab'), 
    if strcmp(eventdata.Modifier,'shift')
        if get(handles.button_pde,'value')
            uicontrol(handles.input_timedomain); 
        else
            uicontrol(handles.input_domain); 
        end
    elseif get(handles.button_pde,'value')
        uicontrol(handles.input_LBC); 
    else
        uicontrol(handles.input_BC); 
    end
end
function input_BC_KeyPressFcn(hObject, eventdata, handles)
if strcmp(eventdata.Key,'tab')
    if strcmp(eventdata.Modifier,'shift')
        uicontrol(handles.input_DE); 
    else
        uicontrol(handles.input_GUESS); 
    end
end
function input_LBC_KeyPressFcn(hObject, eventdata, handles)
if strcmp(eventdata.Key,'tab')
    if strcmp(eventdata.Modifier,'shift')
        uicontrol(handles.input_DE); 
    else
        uicontrol(handles.input_RBC); 
    end
end
function input_RBC_KeyPressFcn(hObject, eventdata, handles)
if strcmp(eventdata.Key,'tab')
    if strcmp(eventdata.Modifier,'shift')
        uicontrol(handles.input_LBC); 
    else
        uicontrol(handles.input_GUESS); 
    end
end
function input_GUESS_KeyPressFcn(hObject, eventdata, handles)
if strcmp(eventdata.Key,'tab')
    if strcmp(eventdata.Modifier,'shift')
        uicontrol(handles.input_BC); 
    else
        uicontrol(handles.button_solve);
        set(handles.button_solve,'selected','on');
    end
end
function popupmenu_sigma_KeyPressFcn(hObject, eventdata, handles)
if strcmp(eventdata.Key,'tab')
    if strcmp(eventdata.Modifier,'shift')
        uicontrol(handles.edit_eigN); 
    else
        uicontrol(handles.button_solve); 
    end
end
function button_solve_KeyPressFcn(hObject, eventdata, handles)
if strcmp(eventdata.Key,'tab')
    if strcmp(eventdata.Modifier,'shift')
        if get(handles.button_eig,'value')
            uicontrol(handles.input_BC); 
        else
            uicontrol(handles.input_GUESS); 
        end
    else
        uicontrol(handles.button_clear); 
    end
elseif strcmp(eventdata.Key,'return')
    button_solve_Callback(hObject, eventdata, handles);
end
function button_clear_KeyPressFcn(hObject, eventdata, handles)
if strcmp(eventdata.Key,'tab')
    if strcmp(eventdata.Modifier,'shift')
        uicontrol(handles.button_solve); 
    else
        uicontrol(handles.button_export); 
    end
elseif strcmp(eventdata.Key,'return')
    button_clear_Callback(hObject, eventdata, handles);
end
function button_export_KeyPressFcn(hObject, eventdata, handles)
if strcmp(eventdata.Key,'tab')
    if strcmp(eventdata.Modifier,'shift')
        uicontrol(handles.button_clear); 
    elseif get(handles.button_exportsoln,'enabled')
        uicontrol(handles.button_exportsoln);
    else 
        uicontrol(handles.input_domain);
    end
elseif strcmp(eventdata.Key,'return')
    button_export_Callback(hObject, eventdata, handles);
end
%%

function input_timedomain_Callback(hObject, eventdata, handles)
str = get(hObject,'String');
if iscell(str), str = str{:}; end
num = str2num(str);

options.WindowStyle = 'modal';

% Indicates we had timedomain with negative spacing (0:-.1:1)
while isempty(num) 
    str = inputdlg('Time domain should be a vector of length >2, with positive spacing, at which times solution is returned','Set time domain',...
        1,{'0:.1:1'},options);
    if isempty(str), str = ''; break, end
    str = str{:};
    num = str2num(str);
    
end

while (~isempty(str) && numel(num) < 3)
    h = (num(2)-num(1))/20;
    def = sprintf('%s:%s:%s',num2str(num(1),'%0.0f'),num2str(h,'%0.2g'),num2str(num(2),'%0.0f'));
    str = inputdlg('Time domain should be a vector of length >2 at which times solution is returned','Set time domain',...
        1,{def},options);
    if isempty(str), str = ''; break, end
    str = str{:};
    num = str2num(str);
end
set(handles.input_timedomain,'String',str);   
handles.guifile.timedomain = str;
guidata(hObject, handles);

% -------------------------------------------------------------------------
% -------------------- Unsorted functions  --------------------------------
% -------------------------------------------------------------------------

function button_fignorm_Callback(hObject, eventdata, handles)

% Check the type of the problem
if get(handles.button_ode,'Value');
    latestNorms = handles.latest.norms;
    figure;
    semilogy(latestNorms,'-*','Linewidth',2),title('Norm of updates'), xlabel('Number of iteration')
    if length(latestNorms) > 1
        XTickVec = 1:max(floor(length(latestNorms)/5),1):length(latestNorms);
        set(gca,'XTick', XTickVec), xlim([1 length(latestNorms)]), grid on
    else % Don't display fractions on iteration plots
        set(gca,'XTick', 1)
    end
elseif get(handles.button_pde,'Value');
    u = handles.latest.solution;
    tt = handles.latest.solutionT;
    varnames = handles.varnames;
    
    xLab = handles.indVarName{1};
    tLab = handles.indVarName{2};
    
    if ~iscell(u)
        figure
        waterfall(u,tt,'simple','linewidth',2)
        xlabel(xLab), ylabel(tLab); zlabel(varnames{1});
    else
        figure
        for k = 1:numel(u)
            subplot(1,numel(u),k);
            waterfall(u{k},tt,'simple','linewidth',2)
            xlabel(xLab), ylabel(tLab), zlabel(varnames{k})
            title(varnames{k})
        end
        
        tmp = u{k}(:,1);
        u1 = tmp.vals(1);
        tmp = get(tmp,'vals');
        x1 = tmp(1);
        
        figure
        cols = get(0,'DefaultAxesColorOrder');
        for k = 1:numel(u)
            plot3(x1,tt(1),u1,'linewidth',2,'color',cols(k,:)); hold on
        end
        legend(varnames{:})
        for k = 1:numel(u)
            waterfall(u{k},tt,'simple','linewidth',2,'edgecolor',cols(k,:))
        end
        xlabel(xLab), ylabel(tLab), grid on
    end
else % eigs
    
    figure, h1 = gca;
    
    if strcmp(handles.latest.type,'eig')
        selection = get(handles.iter_list,'Value');
        ploteigenmodes(handles.guifile,handles,selection,[],h1);
    end
    
end

function button_figsol_Callback(hObject, eventdata, handles)
if get(handles.button_ode,'Value');
    latestSolution = handles.latest.solution;
    figure
    plot(latestSolution,'Linewidth',2), title('Solution at end of iteration')
    xlabel(handles.indVarName);
    varnames = handles.varnames;
    if numel(varnames) == 1
        ylabel(varnames)
    end
    % Turn on grid
    if handles.guifile.options.grid, grid on,  end
    if numel(handles.varnames) > 1, legend(handles.varnames), end
elseif get(handles.button_pde,'Value');
    u = handles.latest.solution;
    tt = handles.latest.solutionT;
    
    varnames = handles.varnames;  
    xLab = handles.indVarName{1};
    tLab = handles.indVarName{2};    
    
    titleStr = sprintf('Solution at final time, %s = %f',tLab,tt(end));
    figure
    if ~iscell(u)
        plot(u(:,end),'Linewidth',2)
        xlabel(xLab);
        ylabel(varnames);
        title(titleStr)
    else
        v = chebfun;
        for k = 1:numel(u)
            uk = u{k};
            v(:,k) = uk(:,end);
        end
        plot(v,'Linewidth',2);
        xlabel(xLab);
        legend(varnames);
        title(titleStr)
    end
    % Turn on grid
    if handles.guifile.options.grid, grid on,  end
    
    % Turn on fixed y-limits
    if ~isempty(handles.guifile.options.fixYaxisLower)
        ylim([str2num(handles.guifile.options.fixYaxisLower) ...
            str2num(handles.guifile.options.fixYaxisUpper)]);
    end
else
    figure, h1 = gca;
    if strcmp(handles.latest.type,'eig')
        selection = get(handles.iter_list,'Value');
        ploteigenmodes(handles.guifile,handles,selection,h1,[]);
    end
end


function toggle_useLatest_Callback(hObject, eventdata, handles)
newVal = get(hObject,'Value');

if newVal % User wants to use latest solution
    set(handles.input_GUESS,'String','Using latest solution');
    set(handles.input_GUESS_cover,'Visible','On');
else
    set(handles.input_GUESS,'String','');
    set(handles.input_GUESS,'Enable','On');
    set(handles.input_GUESS_cover,'Visible','Off');
    handles.guifile.init = '';
end
guidata(hObject, handles);


% --- Executes when chebguimainwindow is resized.
function chebguimainwindow_ResizeFcn(hObject, eventdata, handles)
% hObject    handle to chebguimainwindow (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)


function button_ode_Callback(hObject, eventdata, handles)
handles = switchmode(handles.guifile,handles,'bvp');
guidata(hObject, handles);

% --- Executes on button press in button_pde.
function button_pde_Callback(hObject, eventdata, handles)
handles = switchmode(handles.guifile,handles,'pde');
guidata(hObject, handles);

% --- Executes on button press in button_pde.
function button_eig_Callback(hObject, eventdata, handles)
handles = switchmode(handles.guifile,handles,'eig');
guidata(hObject, handles);



% --- Executes on selection change in iter_list.
function iter_list_Callback(hObject, eventdata, handles)
% Hints: contents = cellstr(get(hObject,'String')) returns iter_list contents as cell array
%        contents{get(hObject,'Value')} returns selected item from iter_list

% Selecting from the list only does something when we are in e-value mode
% Display corresponding e-funcs when clicking on e-value.

% set(handles.fig_sol,'XLimMode','Manual');

if strcmp(handles.latest.type,'eig')
    selection = get(handles.iter_list,'Value');
    ploteigenmodes(handles.guifile,handles,selection);
end

% xlim(handles.fig_norm,xlim_norm); ylim(handles.fig_norm,ylim_norm);
% -------------------------------------------------------------------------
% ---------------------- Other subfunctions -------------------------------
% -------------------------------------------------------------------------

function initialisefigures(handles)
cla(handles.fig_sol,'reset');
title('Solutions'), box on
cla(handles.fig_norm,'reset');
title('Updates'), box on

% -------------------------------------------------------------------------
% ----------------- All CreateFcn are stored here -------------------------
% -------------------------------------------------------------------------

function dom_left_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end


function dom_right_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end


function input_DE_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end


function input_RBC_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end


function input_GUESS_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end


function input_LBC_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end


function iter_list_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end


function fig_logo_CreateFcn(hObject, eventdata, handles)
% Hint: place code in OpeningFcn to populate
f = chebpoly(10);
plot(f,'interval',[-1,.957],'linew',3), hold on

t = - cos(pi*(2:8)'/10) *0.99;  % cheb extrema (tweaked)
y = 0*t;
h = text( t, y, num2cell(transpose('chebfun')), ...
    'fontsize',16,'hor','cen','vert','mid') ;

flist = listfonts;
k = strmatch('Rockwell',flist);  % 1st choice
k = [k; strmatch('Luxi Serif',flist)];  % 2nd choice
k = [k; strmatch('luxiserif',flist)];  % 2.5th choice
k = [k; strmatch('Times',flist)];  % 3rd choice
if ~isempty(k), set(h,'fontname',flist{k(1)}), end

axis([-1.02 .98 -2 2]), axis off


function fig_sol_CreateFcn(hObject, eventdata, handles)
% Hint: place code in OpeningFcn to populate fig_sol


function fig_norm_CreateFcn(hObject, eventdata, handles)
% Hint: place code in OpeningFcn to populate fig_norm


function input_timedomain_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end

function tempedit_CreateFcn(hObject, eventdata, handles)

function ylim1_CreateFcn(hObject, eventdata, handles)
function ylim1_Callback(hObject, eventdata, handles)
function ylim2_CreateFcn(hObject, eventdata, handles)
function ylim2_Callback(hObject, eventdata, handles)

function button_solve_ButtonDownFcn(hObject, eventdata, handles)
% -------------------------------------------------------------------------
% ----------------- Right-clicking functions ------------------------------
% -------------------------------------------------------------------------

function input_DE_ButtonDownFcn(hObject, eventdata, handles)
chebguiedit('chebguiwindow', handles.chebguimainwindow,'input_DE');
input_DE_Callback(hObject, eventdata, handles); % Go through the callback function
function input_LBC_ButtonDownFcn(hObject, eventdata, handles)
chebguiedit('chebguiwindow', handles.chebguimainwindow,'input_LBC');
input_LBC_Callback(hObject, eventdata, handles); % Go through the callback function
function input_RBC_ButtonDownFcn(hObject, eventdata, handles)
chebguiedit('chebguiwindow', handles.chebguimainwindow,'input_RBC');
input_RBC_Callback(hObject, eventdata, handles); % Go through the callback function
function input_GUESS_ButtonDownFcn(hObject, eventdata, handles)
chebguiedit('chebguiwindow', handles.chebguimainwindow,'input_GUESS');
input_GUESS_Callback(hObject, eventdata, handles); % Go through the callback function

function editfontsize_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end

% -------------------------------------------------------------------------
% ----------------- Callbacks for menu items  ----------------------------
% -------------------------------------------------------------------------

% --------------------------------------------------------------------
function menu_file_Callback(hObject, eventdata, handles)
% hObject    handle to menu_file (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)


% --------------------------------------------------------------------
function menu_opengui_Callback(hObject, eventdata, handles)
[filename pathname filterindex] = uigetfile('*.guifile','Pick a file');
if ~filterindex, return, end
cgTemp = chebgui(fullfile(pathname,filename));
loadfields(cgTemp,handles);
handles.guifile = cgTemp;
if ~isempty(cgTemp.type)
    handles = switchmode(cgTemp,handles,cgTemp.type);
end    
guidata(hObject, handles);

% --------------------------------------------------------------------
function menu_savegui_Callback(hObject, eventdata, handles)
[filename pathname filterindex] = uiputfile('*.guifile','Pick a file');
if ~filterindex, return, end

% name = input('What would you like to name this GUI file? ');
name = '';

if get(handles.button_ode,'value')
    demotype = 'bvp';
elseif get(handles.button_pde,'value')
    demotype = 'pde';
else
    demotype = 'eig';
end
dom = get(handles.input_domain,'string');
t = get(handles.input_timedomain,'string');
DE = get(handles.input_DE,'string');
BC = get(handles.input_BC,'string');
LBC = get(handles.input_LBC,'string');
RBC = get(handles.input_RBC,'string');
init = get(handles.input_GUESS,'string');
tol = '';
damping = '';
plotting = '';

DE = mycell2str(DE);
BC = mycell2str(BC);
LBC = mycell2str(LBC);
RBC = mycell2str(RBC);
init = mycell2str(init);

if strcmp(demotype,'pde')
    s = sprintf(['''%s''\n', ...
            'type = ''%s'';\n', ... 
            'domain = ''%s'';\n', ...
            't = ''%s'';\n', ...
            'DE = %s;\n', ...
            'LBC = %s;\n', ...
            'RBC = %s;\n', ...
            'init = %s;\n', ...
            'tol = ''%s'';\n', ...
            'damping = ''%s'';\n', ...
            'plotting = ''%s'';'], ...
    name, demotype, dom, t, DE, LBC, RBC, init, tol, damping, plotting);
else
    s = sprintf(['''%s''\n', ...
            'type = ''%s'';\n', ... 
            'domain = ''%s'';\n', ...
            'DE = %s;\n', ...
            'BC = %s;\n', ...
            'init = %s;\n', ...
            'tol = ''%s'';\n', ...
            'damping = ''%s'';\n', ...
            'plotting = ''%s'';'], ...
    name, demotype, dom, DE, BC, init, tol, damping, plotting);
end
    
fid = fopen(fullfile(pathname,filename),'w+');
fprintf(fid,s);
fclose(fid);

function out = mycell2str(in)
isc = iscell(in);
if ~isc
    in = {in};
    out = '';
else
    out = '{';
end
for k = 1:numel(in)
    if k > 1,  out = [out ' ; ']; end
    out = [out '''' strrep(in{k},'''','''''') ''''];
end
if isc
    out = [out '}'];
end

% --------------------------------------------------------------------
function menu_demos_Callback(hObject, eventdata, handles)


function menu_bvps_Callback(hObject, eventdata, handles)


function menu_ivps_Callback(hObject, eventdata, handles)


function menu_systems_Callback(hObject, eventdata, handles)


function menu_help_Callback(hObject, eventdata, handles)


function menu_openhelp_Callback(hObject, eventdata, handles)
doc('chebgui')


% --------------------------------------------------------------------
function Untitled_9_Callback(hObject, eventdata, handles)


% --------------------------------------------------------------------
function menu_pdesingle_Callback(hObject, eventdata, handles)


% --------------------------------------------------------------------
function menu_pdesystems_Callback(hObject, eventdata, handles)


% --------------------------------------------------------------------
function menu_export_Callback(hObject, eventdata, handles)
% Offer more options if a solution exists.
if handles.hasSolution
    set(handles.menu_exportmatfile,'Enable','on')
    set(handles.menu_exportworkspace,'Enable','on')
else
    set(handles.menu_exportmatfile,'Enable','off')
    set(handles.menu_exportworkspace,'Enable','off')
end

% --------------------------------------------------------------------
function menu_exportmfile_Callback(hObject, eventdata, handles)
export(handles.guifile,handles,'.m')


function menu_exportchebgui_Callback(hObject, eventdata, handles)
export(handles.guifile,handles,'GUI')

function menu_exportworkspace_Callback(hObject, eventdata, handles)
export(handles.guifile,handles,'Workspace')


function menu_exportmatfile_Callback(hObject, eventdata, handles)
export(handles.guifile,handles,'.mat')


function menu_options_Callback(hObject, eventdata, handles)

function menu_close_Callback(hObject, eventdata, handles)
delete(handles.chebguimainwindow)

function uipanel13_DeleteFcn(hObject, eventdata, handles)


function tempedit_Callback(hObject, eventdata, handles)





function menu_odedampednewton_Callback(hObject, eventdata, handles)


function menu_odedampednewtonon_Callback(hObject, eventdata, handles)
handles.guifile.options.damping = '1';
set(handles.menu_odedampednewtonon,'checked','on');
set(handles.menu_odedampednewtonoff,'checked','off');
guidata(hObject, handles);


function menu_odedampednewtonoff_Callback(hObject, eventdata, handles)
handles.guifile.options.damping = '0';
set(handles.menu_odedampednewtonon,'checked','off');
set(handles.menu_odedampednewtonoff,'checked','on');
guidata(hObject, handles);


function menu_odeplotting_Callback(hObject, eventdata, handles)

function menu_pdeplotting_Callback(hObject, eventdata, handles)

function menu_odeplottingon_Callback(hObject, eventdata, handles)
% Obtain length of pause from handles
handles.guifile.options.plotting = get(handles.menu_odeplottingpause,'UserData'); 
set(handles.menu_odeplottingon,'checked','on');
set(handles.menu_odeplottingoff,'checked','off');
guidata(hObject, handles);


function menu_odeplottingoff_Callback(hObject, eventdata, handles)
handles.guifile.options.plotting = 'off'; % Should store value of plotting length
set(handles.menu_odeplottingon,'checked','off');
set(handles.menu_odeplottingoff,'checked','on');
guidata(hObject, handles)


function menu_odeplottingpause_Callback(hObject, eventdata, handles)
options.WindowStyle = 'modal';
valid = 0;
while ~valid
    pauseInput = inputdlg('Length of pause between plots:','Set pause length',...
        1,{get(hObject,'UserData')},options);
    if isempty(pauseInput) % User pressed cancel
        break
    elseif ~isempty(str2num(pauseInput{1})) % Valid input
        valid = 1;
        % Store new value in the UserData of the object
        set(hObject,'UserData',pauseInput{1});
        % Update length of pause in the chebgui object
        handles.guifile.options.plotting = pauseInput{1};
        % Change the marking of the options
        set(handles.menu_odeplottingon,'checked','on');
        set(handles.menu_odeplottingoff,'checked','off');
    else
        f = errordlg('Invalid input.', 'Chebgui error', 'modal');
        uiwait(f); 
    end
end
guidata(hObject, handles)

% --------------------------------------------------------------------
function menu_plotOpt_Callback(hObject, eventdata, handles)

% --------------------------------------------------------------------
function menu_showgrid_Callback(hObject, eventdata, handles)


% --------------------------------------------------------------------
function menu_pdeholdplot_Callback(hObject, eventdata, handles)

% --------------------------------------------------------------------
function menu_pdefix_Callback(hObject, eventdata, handles)


% --------------------------------------------------------------------
function menu_pdeplotfield_Callback(hObject, eventdata, handles)


% --------------------------------------------------------------------
function menu_pdeholdploton_Callback(hObject, eventdata, handles)
handles.guifile.options.pdeholdplot = 1; % Turn holding off
set(handles.menu_pdeholdploton,'checked','on');
set(handles.menu_pdeholdplotoff,'checked','off');
guidata(hObject, handles);


% --------------------------------------------------------------------
function menu_pdeholdplotoff_Callback(hObject, eventdata, handles)
handles.guifile.options.pdeholdplot = 0; % Turn holding off
set(handles.menu_pdeholdploton,'checked','off');
set(handles.menu_pdeholdplotoff,'checked','on');
guidata(hObject, handles);


% --------------------------------------------------------------------
function menu_pdeplottingon_Callback(hObject, eventdata, handles)
handles.guifile.options.plotting = 'on'; % Obtain length of pause from handles
set(handles.menu_pdeplottingon,'checked','on');
set(handles.menu_pdeplottingoff,'checked','off');
guidata(hObject, handles);


% --------------------------------------------------------------------
function menu_pdeplottingoff_Callback(hObject, eventdata, handles)
handles.guifile.options.plotting = 'off'; % Obtain length of pause from handles
set(handles.menu_pdeplottingon,'checked','off');
set(handles.menu_pdeplottingoff,'checked','on');
guidata(hObject, handles);


function menu_tolerance_Callback(hObject, eventdata, handles)
options.WindowStyle = 'modal';
valid = 0;
while ~valid
    tolInput = inputdlg('Tolerance for solution:','Set tolerance',...
        1,{get(hObject,'UserData')},options);
    if isempty(tolInput) % User pressed cancel
        break
    elseif ~isempty(str2num(tolInput{1})) % Valid input
        valid = 1;
        % Store new value in the UserData of the object
        set(hObject,'UserData',tolInput{1});
        % Update the chebgui object
        handles.guifile.tol = tolInput{1};
    else
        f = errordlg('Invalid input.', 'Chebgui error', 'modal');
        uiwait(f); 
    end
end
guidata(hObject, handles)


% --- Executes on button press in check_uselatest.
function check_uselatest_Callback(hObject, eventdata, handles)
% hObject    handle to check_uselatest (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

% Hint: get(hObject,'Value') returns toggle state of check_uselatest


% --------------------------------------------------------------------
function menu_showgridon_Callback(hObject, eventdata, handles)
handles.guifile.options.grid = 1; % Turn grid on
set(handles.menu_showgridon,'checked','on');
set(handles.menu_showgridoff,'checked','off');
axes(handles.fig_sol);  grid on
axes(handles.fig_norm); grid on
guidata(hObject, handles);


% --------------------------------------------------------------------
function menu_showgridoff_Callback(hObject, eventdata, handles)
handles.guifile.options.grid = 0; % Turn grid off
set(handles.menu_showgridon,'checked','off');
set(handles.menu_showgridoff,'checked','on');
axes(handles.fig_sol); grid off
axes(handles.fig_norm);  grid off
guidata(hObject, handles);


function menu_fixN_Callback(hObject, eventdata, handles)


function menu_annotateplots_Callback(hObject, eventdata, handles)


% --------------------------------------------------------------------
function menu_pdefixon_Callback(hObject, eventdata, handles)
options.WindowStyle = 'modal';
valid = 0;
defaultAnswer = {handles.guifile.options.fixYaxisLower,...
    handles.guifile.options.fixYaxisUpper};
while ~valid
    fixInput = inputdlg({'Lower y-limit:','Upper y-limit:'},'Fix y-axis',...
        1,defaultAnswer,options);
    if isempty(fixInput) % User pressed cancel
        break
    elseif ~isempty(str2num(fixInput{1})) &&  ~isempty(str2num(fixInput{2})) % Valid input
        valid = 1;
        % Store new value in the UserData of the object
        set(hObject,'UserData',fixInput);
        % Update the chebgui object
        handles.guifile.options.fixYaxisLower = fixInput{1};
        handles.guifile.options.fixYaxisUpper = fixInput{2};
    else
        f = errordlg('Invalid input.', 'Chebgui error', 'modal');
        uiwait(f); 
    end
end

% Change checking
set(handles.menu_pdefixon,'checked','on');
set(handles.menu_pdefixoff,'checked','off');
guidata(hObject, handles);

% --------------------------------------------------------------------
function menu_pdefixoff_Callback(hObject, eventdata, handles)
% Clear out fix information
handles.guifile.options.fixYaxisLower = '';
handles.guifile.options.fixYaxisUpper = '';

% Change checking
set(handles.menu_pdefixon,'checked','off');
set(handles.menu_pdefixoff,'checked','on');
guidata(hObject, handles);

function sigma_Callback(hObject, eventdata, handles)

% --- Executes during object creation, after setting all properties.
function sigma_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end


% --------------------------------------------------------------------
function menu_eigsscalar_Callback(hObject, eventdata, handles)

% --- Executes on button press in button_export.
function button_export_Callback(hObject, eventdata, handles)
export(handles.guifile,handles,'.m');


% --- Executes on button press in button_realplot.
function button_realplot_Callback(hObject, eventdata, handles)
set(handles.button_realplot,'Value',1)
set(handles.button_imagplot,'Value',0)
set(handles.button_envelope,'Value',0)
selection = get(handles.iter_list,'Value');
ploteigenmodes(handles.guifile,handles,selection)
    
% --- Executes on button press in button_imagplot.
function button_imagplot_Callback(hObject, eventdata, handles)
set(handles.button_realplot,'Value',0)
set(handles.button_imagplot,'Value',1)
set(handles.button_envelope,'Value',0)
selection = get(handles.iter_list,'Value');
ploteigenmodes(handles.guifile,handles,selection)

% --- Executes on button press in button_envelope.
function button_envelope_Callback(hObject, eventdata, handles)
set(handles.button_realplot,'Value',0)
set(handles.button_imagplot,'Value',0)
set(handles.button_envelope,'Value',1)
selection = get(handles.iter_list,'Value');
ploteigenmodes(handles.guifile,handles,selection)


% --------------------------------------------------------------------
function menu_fixNon_Callback(hObject, eventdata, handles)
options.WindowStyle = 'modal';
valid = 0;
defaultAnswer = {handles.guifile.options.fixN};
while ~valid
    fixInput = inputdlg({'Number of gridpoints:'},'Fix space discretisation',...
        1,defaultAnswer,options);
    if isempty(fixInput) % User pressed cancel
        break
    elseif ~mod(str2num(fixInput{1}),1) % Only allow integers 
        valid = 1;
        % Store new value in the UserData of the object
        set(hObject,'UserData',fixInput);
        % Update the chebgui object
        handles.guifile.options.fixN = fixInput{1};
    else
        f = errordlg('Invalid input.', 'Chebgui error', 'modal');
        uiwait(f); 
    end
end

% Change checking
set(handles.menu_fixNon,'checked','on');
set(handles.menu_fixNoff,'checked','off');
guidata(hObject, handles);


% --------------------------------------------------------------------
function menu_fixNoff_Callback(hObject, eventdata, handles)
handles.guifile.options.fixN = '';
% Change checking
set(handles.menu_fixNon,'checked','off');
set(handles.menu_fixNoff,'checked','on');
guidata(hObject, handles);

% --------------------------------------------------------------------
function menu_sigma_Callback(hObject, eventdata, handles)
% options.WindowStyle = 'modal';
% valid = 0;
% defaultAnswer = {handles.guifile.sigma};
% while ~valid
%     in = inputdlg({'Set sigma, e.g., ''LR'',''SR'',''LM'', ''SM'', etc'},'Set sigma',...
%         1,defaultAnswer,options);
%     if isempty(in) % User pressed cancel
%         break
%     elseif any(strcmpi(in{1},{'LR','SR','LM', 'SM'})) || ~isempty(str2num(in{1}))
%         in = in{1};
%         valid = 1;
%         % Store new value in the UserData of the object
%         set(hObject,'UserData',in);
%         % Update the chebgui object
%         handles.guifile.sigma = in;
%     else
%         f = errordlg('Invalid input.', 'Chebgui error', 'modal');
%         uiwait(f); 
%     end
% end
% guidata(hObject, handles);

% --------------------------------------------------------------------
function menu_eigno_Callback(hObject, eventdata, handles)
% options.WindowStyle = 'modal';
% valid = 0;
% defaultAnswer = {handles.guifile.options.numeigs};
% if isempty(defaultAnswer{:}), defaultAnswer = {'6'}; end % As defined in linop/eigs
% while ~valid
%     in = inputdlg({'Number of eigenvalues to find?'},'Number of eigenvalues?',...
%         1,defaultAnswer,options);
%     if isempty(in) % User pressed cancel
%         break
%     elseif ~mod(str2num(in{1}),1) % Only allow integers
%         in = in{1};
%         valid = 1;
%         % Store new value in the UserData of the object
%         set(hObject,'UserData',in);
%         % Update the chebgui object
%         handles.guifile.options.numeigs = in;
%     else
%         f = errordlg('Invalid input.', 'Chebgui error', 'modal');
%         uiwait(f); 
%     end
% end
% guidata(hObject, handles);


% --------------------------------------------------------------------
function menu_import_Callback(hObject, eventdata, handles)
% Obtain a 'whos' list from the base workspace
variables =  evalin('base','whos');
baseVarNames = {variables.name};
% Create a list dialog
[selection,OK] = listdlg('PromptString','Select variable(s) to import:',...
    'ListString',baseVarNames,'Name','Import variables to GUI',...
    'OKString','Import','ListSize',[160 200],'ListString',baseVarNames);
if ~OK, return, end % User pressed cancel

% Store all the selected variables in the handles
for selCounter = 1:length(selection)
    handles.importedVar.(baseVarNames{selection(selCounter)}) = ...
        evalin('base',baseVarNames{selection(selCounter)});
end
guidata(hObject, handles);


% --------------------------------------------------------------------
function menu_eigssystem_Callback(hObject, eventdata, handles)
% hObject    handle to menu_eigssystem (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)


% --- Executes on key press with focus on chebguimainwindow and none of its controls.
function chebguimainwindow_KeyPressFcn(hObject, eventdata, handles)
% hObject    handle to chebguimainwindow (see GCBO)
% eventdata  structure with the following fields (see FIGURE)
%	Key: name of the key that was pressed, in lower case
%	Character: character interpretation of the key(s) that was pressed
%	Modifier: name(s) of the modifier key(s) (i.e., control, shift) pressed
% handles    structure with handles and user data (see GUIDATA)
edata = eventdata;
if ~isempty(edata.Modifier) && strcmp(edata.Modifier{1},'control')
    switch edata.Key
        case 'return'
            button_solve_Callback(hObject, eventdata, handles);
        case 'e'
            button_export_Callback(hObject, eventdata, handles);
        case {'+','equal'}
            button_fontinc_Callback(hObject, eventdata, handles);
        case {'-','hyphen'}
            button_fontdec_Callback(hObject, eventdata, handles);
        case 'p'
            if any(strcmp(get(handles.button_clear,'String'),{'Pause','Continue'}))
                button_clear_Callback(hObject, eventdata, handles);
            end
    end
end
% PressedKeyNo = double(get(gcbo,'CurrentCharacter'))



function edit_eigN_Callback(hObject, eventdata, handles)
in = get(handles.edit_eigN,'String');
if ~isempty(in) && isempty(str2num(in))
    errordlg('Invalid input. Number of eigenvalues must be an integer.', 'Chebgui error', 'modal');
    set(handles.edit_eigN,'String',handles.guifile.options.numeigs);
else
    handles.guifile.options.numeigs = in;
end
guidata(hObject, handles);

function edit_eigN_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end


function edit37_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end
function edit37_Callback(hObject, eventdata, handles)
in = get(handles.edit_eigN,'String');
if ~isempty(in) && isempty(str2num(in))
    errordlg('Invalid input.', 'Chebgui error', 'modal');
else
    handles.guifile.options.numeigs = in;
end
guidata(hObject, handles);


% --- Executes on selection change in popupmenu_sigma.
function popupmenu_sigma_Callback(hObject, eventdata, handles)
selected = get(hObject,'Value');
switch selected
    case 1
        handles.guifile.sigma = '';
    case 2
        handles.guifile.sigma = 'lm';
    case 3
        handles.guifile.sigma = 'sm';
    case 4
        handles.guifile.sigma = 'lr';
    case 5
        handles.guifile.sigma = 'sr';
    case 6
        handles.guifile.sigma = 'li';
    case 7
        handles.guifile.sigma = 'si';
end
guidata(hObject, handles);

% --- Executes during object creation, after setting all properties.
function popupmenu_sigma_CreateFcn(hObject, eventdata, handles)
% hObject    handle to popupmenu_sigma (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    empty - handles not created until after all CreateFcns called

% Hint: popupmenu controls usually have a white background on Windows.
%       See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end


% --------------------------------------------------------------------
function menu_annotateon_Callback(hObject, eventdata, handles)
% --------------------------------------------------------------------
function menu_annotateoff_Callback(hObject, eventdata, handles)
% --------------------------------------------------------------------
function menu_about_Callback(hObject, eventdata, handles)
aboutWindow = dialog('WindowStyle', 'normal', 'Name', 'About chebgui','Position', [500 500 200 200]);
aboutString = sprintf(['Chebgui was developed by Asgeir Birkisson and Nick Hale ',...
    'as an interface to the differential equations in Chebfun.']);
uicontrol(aboutWindow, ... % Text
             'Style','text', ...
             'String', aboutString,...
             'position',[0 -90 200 200])
uicontrol(aboutWindow, ... % Close button
             'Style','pushbutton','String', 'Close','position',[65 10 75 20],'callback',@(a,b,c)delete(aboutWindow))


hPlotAxes = axes(...       % Axes for plotting the selected plot
                 'Parent', aboutWindow, ...
                 'Units', 'normalized', ...
                 'HandleVisibility','callback','position',[0.1 0.6 .8 .25]);

% Plot the logo
f = chebpoly(10);
xx = linspace(-1,.957,1000);
plot(hPlotAxes,xx,f(xx),'linewidth',3)
t = -cos(pi*(2:8)'/10) *0.99;  % cheb extrema (tweaked)
y = 0*t;
h = text(t, y, num2cell(transpose('chebgui')), ...
    'fontsize',16,'hor','cen','vert','mid','parent',hPlotAxes);
flist = listfonts;
k = strmatch('Rockwell',flist);  % 1st choice
k = [k; strmatch('Luxi Serif',flist)];  % 2nd choice
k = [k; strmatch('luxiserif',flist)];  % 2.5th choice
k = [k; strmatch('Times',flist)];  % 3rd choice
if ~isempty(k), set(h,'fontname',flist{k(1)}), end
axis(hPlotAxes,'off')
       
       
function menu_shortcuts_Callback(hObject, eventdata, handles)
% hObject    handle to menu_shortcuts (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
aboutWindow = dialog('WindowStyle', 'normal', 'Name', 'About chebgui','Position', [500 500 200 275]);
aboutString = sprintf(['The following keyboard shortcuts are supported (case insensitive):\n', ...
    'Ctrl + Return = Solve\n', ...
    'Ctrl + P = Pause\n', ...
    'Ctrl + E = Export to .m file\n', ...
    'Ctrl + + = Increase font-size\n', ...
    'Ctrl + - = Decrease font-size',    ]);
uicontrol(aboutWindow, ... % Text
             'Style','text', ...
             'String', aboutString,...
             'position',[0 -40 200 200])
uicontrol(aboutWindow, ... % Close button
             'Style','pushbutton','String', 'Close','position',[65 10 75 20],'callback',@(a,b,c)delete(aboutWindow))


hPlotAxes = axes(...       % Axes for plotting the selected plot
                 'Parent', aboutWindow, ...
                 'Units', 'normalized', ...
                 'HandleVisibility','callback','position',[0.1 0.6 .8 .25]);

% Plot the logo
f = chebpoly(10);
xx = linspace(-1,.957,1000);
plot(hPlotAxes,xx,f(xx),'linewidth',3)
t = -cos(pi*(2:8)'/10) *0.99;  % cheb extrema (tweaked)
y = 0*t;
h = text(t, y, num2cell(transpose('chebgui')), ...
    'fontsize',16,'hor','cen','vert','mid','parent',hPlotAxes);
flist = listfonts;
k = strmatch('Rockwell',flist);  % 1st choice
k = [k; strmatch('Luxi Serif',flist)];  % 2nd choice
k = [k; strmatch('luxiserif',flist)];  % 2.5th choice
k = [k; strmatch('Times',flist)];  % 3rd choice
if ~isempty(k), set(h,'fontname',flist{k(1)}), end
axis(hPlotAxes,'off')

function input_GUESS_cover_Callback(hObject, eventdata, handles)
% hObject    handle to input_GUESS_cover (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of input_GUESS_cover as text
%        str2double(get(hObject,'String')) returns contents of input_GUESS_cover as a double


% --- Executes during object creation, after setting all properties.
function input_GUESS_cover_CreateFcn(hObject, eventdata, handles)
% hObject    handle to input_GUESS_cover (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.
%       See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end

function msg = cleanErrorMsg(msg)
errUsingLoc = strfind(msg,sprintf('Error using'));
if errUsingLoc
    % Trim everything before this
    msg = msg(errUsingLoc:end);
    % Look for first two line breaks (char(10))
    idx = find(msg==char(10),1);
    % Take only what's after the 2nd
    msg = msg(idx+1:end);
end



function input_BC_Callback(hObject, eventdata, handles)
newString = cellstr(get(hObject,'String'));
newString = removeTabs(newString); % Remove tabs
set(hObject,'String',newString);
handles = callbackBCs(handles.guifile,handles,newString,'bc');
handles.guifile.BC = newString;
guidata(hObject, handles);


function input_BC_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end


% --- Executes on button press in button_exportsoln.
function button_exportsoln_Callback(hObject, eventdata, handles)
export(handles.guifile,handles,'WorkspaceJustVars')


% --- Executes on button press in togglebutton4.
function togglebutton4_Callback(hObject, eventdata, handles)
% hObject    handle to togglebutton4 (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

% Hint: get(hObject,'Value') returns toggle state of togglebutton4


% --- Executes on button press in button_fontinc.
function button_fontinc_Callback(hObject, eventdata, handles)
% hObject    handle to button_fontinc (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

% Get a list of all the names in the handles
names = fieldnames(handles);
textLocs = strfind(names,'text_');
inputLocs = strfind(names,'input_');
buttonLocs = strfind(names,'button_');
panelLocs = strfind(names,'panel_');
toggleLocs = strfind(names,'toggle_');

% Deal with variable maximum for input and noninput-type handles
fontsizediff = []; flag = 0;
tmp = strfind(names,'fontsizediff');
if any([tmp{:}])
    fontsizediff = handles.fontsizediff;
end
if isempty(fontsizediff), fontsizediff = 0; end

% Combine all the locations of elements whose font we wish to change
allLocs = strcat(textLocs,inputLocs,buttonLocs,panelLocs,toggleLocs);

for fieldCounter = 1:length(textLocs)
    if ~isempty(allLocs{fieldCounter})
        % Access the field values dynamically using the .( ) call. We
        % access the font size of each element separately as they can have
        % different relative font sizes.
        currFontSize = get(handles.(names{fieldCounter}),'FontSize');
        if currFontSize >= 30
            % Do nothing (global max)
        elseif (isempty(inputLocs{fieldCounter})&&currFontSize >= 16)
            % Size of non input-type handles is further limited
            if ~flag
                % Record this, so a difference doesn't develop
                fontsizediff = min(fontsizediff+1,13); % 13 = 30-16-1
                flag = true; % but only do this once!
            end
        else
            newFontSize = currFontSize + 1;        
            % Update the fontsize, again using the dynamic access
            set(handles.(names{fieldCounter}),'FontSize',newFontSize)     
        end
    end
end
handles.fontsizediff = fontsizediff;  
guidata(hObject, handles);


% --- Executes on button press in button_fontdec.
function button_fontdec_Callback(hObject, eventdata, handles)
% hObject    handle to button_fontdec (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
% Get a list of all the names in the handles
names = fieldnames(handles);
textLocs = strfind(names,'text_');
inputLocs = strfind(names,'input_');
buttonLocs = strfind(names,'button_');
panelLocs = strfind(names,'panel_');
toggleLocs = strfind(names,'toggle_');

% Combine all the locations of elements whose font we wish to change
allLocs = strcat(textLocs,inputLocs,buttonLocs,panelLocs,toggleLocs);

% Deal with variable maximum for input and noninput-type handles
fontsizediff = []; flag = 0;
tmp = strfind(names,'fontsizediff');
if any([tmp{:}])
    fontsizediff = handles.fontsizediff;
end
if isempty(fontsizediff), fontsizediff = 0; end

for fieldCounter = 1:length(textLocs)
    if ~isempty(allLocs{fieldCounter})
        % Access the field values dynamically using the .( ) call
        currFontSize = get(handles.(names{fieldCounter}),'FontSize');
        newFontSize = currFontSize;
        if isempty(inputLocs{fieldCounter})
            % Deal with non input-type handles
            if flag
                % We only want update the diff once, so continue 
                continue
            elseif fontsizediff > 0
                % Update the diff and set flag
                fontsizediff = fontsizediff - 1;
                flag = 1;
                continue
            elseif currFontSize > 5
                newFontSize = currFontSize - 1; 
            end
        elseif currFontSize > 5
            % Input-type handles are easier
            newFontSize = currFontSize - 1;   
        end
        % Update the fontsize, again using the dynamic access
        set(handles.(names{fieldCounter}),'FontSize',newFontSize)  
    end
end
handles.fontsizediff = fontsizediff;
guidata(hObject, handles);

function keypress(hObject, eventdata, handles)
newString = cellstr(get(hObject,'String'));
newString = removeTabs(newString); % Remove tabs
set(hObject,'String',newString);
handles = callbackBCs(handles.guifile,handles,newString,'rbc');
handles.guifile.RBC = newString;
guidata(hObject, handles);


% --------------------------------------------------------------------
function menu_test_Callback(hObject, eventdata, handles)
T = 0;
folders = {'bvpdemos','pdedemos','eigdemos'};
for k = 1:numel(folders)
    subdir = fullfile(fileparts(which('chebtest')),'@chebgui','private',folders{k});
    subdirlist = dir(subdir);
    subdirnames = { subdirlist.name };
    fprintf([folders{k}(1:3) , '\n']);
    for j = 1:length(subdirnames)
        if subdirlist(j).isdir, continue; end;
        file = fullfile(subdir,subdirnames{j});
        cgTemp = chebgui(file);
        loadfields(cgTemp,handles);
        handles.guifile = cgTemp;
        if ~isempty(cgTemp.type)
            handles = switchmode(cgTemp,handles,cgTemp.type);
        end    
        handles.hasSolution = 0;
        name = subdirnames{j};
        name = strrep(name,'.guifile','');
        fprintf(['  ' , name]);
        try 
            tic
                handles = solveGUI(handles.guifile,handles);
            t = toc;
            guidata(hObject, handles);
            T = T + t;
            if ~handles.hasSolution
                try close('Chebgui error'), end %#ok<TRYNC>
                error('CHEBGUI:test:NoSol','No solution returned');
            end
            fprintf('  passed in %4.4f seconds.\n',t);
        catch ME %#ok<NASGU>
            try close('Chebgui error'), end %#ok<TRYNC>
            fprintf('  FAILED.\n');
        end
    end
end
fprintf('TOTAL TIME = %4.4f.\n',T);


function menu_debug_Callback(hObject, eventdata, handles)
% hObject    handle to menu_debug (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
if strcmp(get(handles.menu_debug,'checked'),'on')
    set(handles.menu_debug,'checked','off');
    set(handles.menu_debug,'UserData',0);
else
    set(handles.menu_debug,'checked','on');
    set(handles.menu_debug,'UserData',1);
end
guidata(hObject, handles);


function resetComponents(handles)
% Enable buttons, figures, etc. Set button to 'solve' again
set(handles.button_solve,'String','Solve');
set(handles.button_solve,'BackgroundColor',[43 129 86]/256);
set(handles.button_clear,'String','Clear all');
set(handles.button_clear,'BackgroundColor',get(handles.button_export,'BackgroundColor'));
set(handles.button_figsol,'Enable','on');
set(handles.button_fignorm,'Enable','on');
set(handles.button_exportsoln,'Enable','off');
set(handles.menu_demos,'Enable','on');

% --------------------------------------------------------------------


% --------------------------------------------------------------------


% --------------------------------------------------------------------