Great question—this is a super common pain point when building GUI-based plotting tools alongside manual command-line workflows (I’m assuming you’re working in MATLAB here, given the figure/plot terminology, but similar logic applies to other environments like Python’s Matplotlib). Let’s walk through practical, actionable fixes:

Core Issue Recap #

The root problem is that most plotting commands default to using the current figure (gcf in MATLAB, plt.gcf() in Matplotlib). If your GUI figure ever becomes the current figure (e.g., if the user clicks it, or your GUI code accidentally sets it as current), any subsequent plot calls (even after running figure() to create a new blank figure) might target the GUI window instead of the new manual figure.

Fix 1: Hide the GUI Figure from Command-Line Context #

The cleanest way to prevent the GUI figure from ever being selected as the current figure is to restrict its handle visibility. When creating your GUI figure, set its HandleVisibility property to 'callback' (so only your GUI’s callback functions can access it) or 'off' (completely hidden from command-line and non-callback code):

% When initializing your GUI figure
gui_fig = figure(...
    'Tag', 'MyGUIFigure', ...
    'HandleVisibility', 'callback', ...
    'MenuBar', 'none', % Optional: Remove standard menus to avoid accidental focus
    'Resize', 'off'
);

With this setting, command-line calls like gcf or figure() will never target the GUI figure—only your tool’s explicitly created plotting figures (which you can leave with HandleVisibility='on') or manual command-line figures will be eligible to be current.

Fix 2: Force New Manual Figures to Be the Current Figure #

If you want to ensure that any figure() call from the command line automatically sets the new figure as the current one (even if the GUI figure was previously selected), override the default figure command. Create a custom figure.m file in your working directory (make sure it’s on your path) with this code:

function fig_handle = figure(varargin)
    % Call the built-in figure command to create the new figure
    fig_handle = builtin('figure', varargin{:});
    % Force the new figure to be the current one
    set(groot, 'CurrentFigure', fig_handle);
    % Optional: Tag manual figures for easy identification later
    set(fig_handle, 'Tag', 'ManualCommandLineFigure');
end

Now, every time someone runs figure() from the command line, the new figure is guaranteed to be the target for subsequent plot calls.

Fix 3: Use Event Listening to Auto-Redirect Plots #

You can set up a listener on the root graphics object that triggers whenever a new figure is created, ensuring the new figure becomes the current one. Add this code when initializing your tool:

% Listen for new figure creation events
set(groot, 'FigureCreatedFcn', @(src, event) set(src, 'CurrentFigure', event.Figure));

This is a hands-off way to ensure that any new figure (whether from your tool or the command line) automatically becomes the active plot target, eliminating the chance of plots going to the GUI window.

Fix 4: Explicitly Target Figures in All Plot Calls #

The most foolproof (though slightly more verbose) solution is to always specify the target figure (or axes) when plotting. In your tool’s plotting functions, use the explicit handle syntax:

% When your tool creates a plotting figure
tool_plot_fig = figure('Tag', 'ToolGeneratedPlotFigure');
tool_plot_axes = axes('Parent', tool_plot_fig);

% When plotting, explicitly target the axes/figure
plot(tool_plot_axes, x_data, y_data, 'Color', 'b');

For command-line users, you can encourage them to do the same:

% Manual command-line workflow
manual_fig = figure();
plot(manual_fig, x, y); % Or plot(axes(manual_fig), x, y)

This completely bypasses the "current figure" logic—plots go exactly where you specify, no exceptions.

内容的提问来源于stack exchange，提问作者Eric