Stop A GUI in a middle of process in MATLAB

Question

I'm designing a GUI using GUIDE in MATLAB R2014b. My program has a long loop (takes 2~5h to process). I want have a button in my GUI that the user stop the process every time he/she want (The GUI is updating graphs and texts continuously based on result of loops). Something like pressing Control+C not after ending a loop. How can I implement this?

PS. I don't want MATLAB remove my workspace. The user can continue the process with previous loaded data and workspace by changing some options in GUI.

Answer 1

Here is a trick that should work: Somewhere in the GUI, like in its OpeningFcn for instance, initialize a flag named for example StopNow to false and store it in the handles structure of the GUI. Then in the loop that takes long to execute, put an if statement with a call to return whenever the flag is set to true. That will stop the execution of the loop and you will have access to your data. You can make a pushbutton to change the flag value.

Sample code: I made a simple GUI that starts enumerating digits in a for loop and printing them in a text box. When you press the STOP button, the flag is set to true and the loop stops. If something is unclear please tell me.

function StopGUI

clear
clc
close all

%// Create figure and uielements
handles.fig = figure('Position',[440 500 400 150]);

handles.CalcButton = uicontrol('Style','Pushbutton','Position',[60 70 80 40],'String','Calculate','Callback',@CalculateCallback);

handles.StopButton = uicontrol('Style','Pushbutton','Position',[250 70 80 40],'String','STOP','Callback',@StopCallback);

%// Initialize flag
handles.StopNow = false;

handles.Val1Text = uicontrol('Style','Text','Position',[150 100 60 20],'String','Value 1');
handles.Val1Edit = uicontrol('Style','Edit','Position',[150 70 60 20],'String','');



guidata(handles.fig,handles); %// Save handles structure of GUI. IMPORTANT

    function CalculateCallback(~,~)

        %// Retrieve elements from handles structure.
        handles = guidata(handles.fig);


        for k = 1:1000

            if handles.StopNow == false
                set(handles.Val1Edit,'String',num2str(k));
                pause(.5) %// The pause is just so we see the numbers changing in the text box.

            else
         msgbox('Process stopped');
                return
            end

        end

        guidata(handles.fig,handles); %// Save handles structure of GUI.
    end

    function StopCallback(~,~)

        %// Retrieve elements from handles structure.
        handles = guidata(handles.fig);

        handles.StopNow = true;

        guidata(handles.fig,handles); %// Save handles structure of GUI.
    end

end

Screenshot after pressing the STOP button:

Hope that helps!

Answer 2

Best solution would be to use separate threads (one for the user interface and one for the processing) maybe using parallel toolbox. Anyhow this would be then quite complex to synchronise both.

So, here is a simple solution that only relies on anonymous functions (to delegate interface refreshing outside the processing block) and on drawnow function (to force the graphical interface to process its messages).

Sample application

The sample application to work with is very basic. It contains:

• A settings panel (with only one setting, the number of iterations for the processing block)
• A progress bar
• A Go/Cancel button

NB: Source code is quite long (about 250 lines, mainly due to gui creation), so I dropped it here.

GUI creation is not important. The most important parts are the processing block, the anonymous functions to instrument the code and the callbacks to react to the GUI events. I will thus detail theses only.

The processing block

Processing block is a simple routine:

function [] = processing(count, instrumentation)
%[
    for ki = 1:count,

        instrumentation.CheckCancel();
        instrumentation.Progress((ki-1)/count);

        if (ki > 1), pause(1); end

        instrumentation.CheckCancel();
        instrumentation.Progress(ki/count);

    end
%]
end

The only special thing about it is that it takes an additional instrumentation structure. This structure has two fields that points to two anonymous functions defined by the caller (i.e. the graphical interface). We'll see shortly how.

• CheckCancel is a function in charge of raising an error if the user wants to stop the processing.
• Progress is a function on which to delegate progression report.

Here is how the anonymous functions are connected to the graphical interface (see doProcessing sub-function in the code):

% Connect instrumentation callbacks with the gui
instrumentation.CheckCancel = @(ratio)onCheckCancel(dlg);
instrumentation.Progress = @(ratio)onProgress(dlg, ratio);

% Perform the processing
processing(settings.NumberOfIterations, instrumentation);

Progress and CheckCancel handlers

Here is the handler defined by the GUI for Progress:

function [] = onProgress(dlg, ratio)
%[
    % Update the progress bar value
    data = guidata(dlg);
    uiprogress(data.handles.pbProgress, ratio);

    % Force interface to refresh
    drawnow();
%]
end

This is simple, it just updates progressbar control and forces the GUI to refresh (remind that matlab is single-threaded and is currently executing the processing block, so we need to force GUI refreshing).

Here is the handler for CheckCancel:

function [] = onCheckCancel(dlg)
%[
    % Force interface to process its events
    drawnow();

    % Check 'UserData' has not been modified during events processing
    guiState = get(dlg, 'UserData');
    if (~isempty(guiState) && ....
        strcmp(guiState, 'CancelRequested') || strcmp(guiState, 'CloseRequested'))
        error('System:OperationCanceledException', 'Operation canceled');
    end
%]
end

Again, this is quite simple. We force the GUI to process events (buttons clicks, etc...) and then we read if UserData was modified to some expected value. If so, we raise an exception to stop the processing. Remind again that currently executing code is the processing block.

GUI events handlers

The GUI has only two interesting events. Either the user clicks the close button, either he/she clicks the Go/Cancel button.

NB: Remind that even if matlab is locked in executing the processing block, GUI events are still processed because processing block is calling drawnow from time to time (by the mean of the instrumentation delegates).

Here is the code for the close button:

function [] = onCloseRequest(dlg)
%[
    % If already in computation mode    
    if (~isempty(get(dlg, 'UserData')))
        % Just indicate close is requested and leave immediatly
        set(dlg, 'UserData', 'CloseRequested');
        data = guidata(dlg);
        set(data.handles.btnGoCancel, 'Enable', 'off', 'String', 'Cancelling...');
        return;
    end

    % Immediate close
    delete(dlg);
%]
end

This is simple, if we are in running mode, we just signal we want to stop, else we close the dialog immediately.

Here is the code for the go/cancel button:

function [] = onGoCancelClick(dlg)
%[
    % If already in computation mode    
    if (~isempty(get(dlg, 'UserData')))
        % Just indicate cancel is requested and leave immediatly
        set(dlg, 'UserData', 'CancelRequested');
        data = guidata(dlg);
        set(data.handles.btnGoCancel, 'Enable', 'off', 'String', 'Cancelling...');
        return;
   end

    % Go into computation mode
    [settings, err] = tryReadSettings(dlg);
    if (~isempty(err))
        waitfor(msgbox(err.message, 'Invalid settings', 'Error', 'Modal'));
    else
        enterComputationMode(dlg);
        err = doProcessing(dlg, settings);
        leaveComputationMode(dlg, err);
    end
%]
end

It's a little longer, anyhow this is the same. If we're in running mode, we just indicate we want to stop; else, the interface is in normal mode, and we start the processing.

Functions tryReadSettings, enterComputationMode and leaveComputationMode are just glue to update controls in the interface and nicely report for errors or cancellation.

Conclusion

We have designed a responsive graphical interface relying only on drawnow and anonymous functions. This is of course just a trick and a better solution would be to use multitasking.

The graphical interface was created here programmatically. Principle is the same if build with GUIDE or with the help of the GUI Layout toolbox.

Instrumentation callbacks can further be improved, for instance, by adding a Log field to report processing details in a textbox or to some back-end similar to Log4Net (with just a message level and message value). Or by adding callback for intermediate results.

Interface can also be improved or modified, for instance why not to run processing whenever a setting is modified (i.e. just stopping any current run and without the need to manually click on a 'Go/Cancel' button each time).

There are a lot of possibilities. Here, just providing some ground application to start with (or not ...).