在阻止GUI的同时更新Swing组件

Question

I was programming a GUI today, which is doing longer calculations when pressing a button. While the calculations are running, I wanted to use intermediate results of the still running calculation and write them to a JLabel. The GUI however, should not be operable by the user before the calculation has finished. At first I was doing something like this:

(1)

public class GUI extends JFrame {

    JLabel label = new JLabel("Status: ");
    public GUI(){...}

    public void calculate() {
        for(int i = 0; i < 10; i++) {
            String one = calculationPartOne(i);
            label.setText("Status: " + one);
            label.repaint();  //*
            calculationPartTwo(i);
        }
    }
}

This did not work, the JLabel would only update after the calculation has finished. I also tried to .repaint() and .validate() all components involved at the line commented *, but it did nothing. So, after trying and searching Google/StackoOverflow the whole day I finally have a working solution, but I still do not understand why above does not work. I wanted the GUI to block, so naturally I ran the calculation in the same thread. However, calling any methods to repaint the GUI -inbetween- the calculation (making the calculation stop while the GUI is updated) did not work, and I do not understand why. Can someone explain?

In the end, I used the SwingWorker class to do my calculations, and use it's functions to update the JLabel while calculating. However, as I need the GUI to block, I now disable -all- the components before excuting the SwingWorker and have the SwingWorker re-enable all the components after finishing the calculation. So, I use SwingWorker, to not block the EDT, but then "fake" to block the EDT by disabling everything? This seems really paradox to me.

Here is an outline of what I have now:

public class GUI extends JFrame {
    JLabel label = new JLabel("Status: ");
    //I didn't use a list, but it works to illustrate it here
    List<Component> GUIComponents = ...; 
    public GUI() {...}

    public void calculate() {
        SwingWorker<Void, String> worker = new SwingWorker<Void, String>() {
            protected Void doInBackground() throws Exception {
                for(int i = 0; i < 10; i++) {
                    String one = calculationPartOne(i);
                    publish(one);
                    calculationPartTwo(i); //**
                }
            }

            protected void done() {
                setEnableGUI(true);
            }

            protected void process(List<String> chunk) {
                label.setText(chunk.get(chunk.size() - 1));
            }
        };
        setEnableGUI(false);
        worker.execute();
    }

    public void setEnableGUI(boolean e) {
        for(Component c : GUIComponents) {
            c.setEnabled(e);
        }
    }

    //**
    public void calculationPartTwo() {...}
}

This works.

I hope someone can clarify. This solutions feels wrong.

Answer 1

why wrong? the gui thread is for responding to user events only - so you should be doing your heavy lifting in the background - which is what youre doing with a SwingWorker.

also, the best way to prevent a user from changing a componenet is to do exactly that - disable the component before starting the heavu lifting, and enable once its done.

only thing you might want to consider is displaying the results of your calculation in a modal dialog - a JDialog that will pop above the parent window and block it. you could display the intermediate results and progress in this dialog and then once the calculation is done the dialog will close and unblock the UI obscured by it. this will save you fron having to disable all gui components indiviually in a loop and will also give you an option to have a "cancel" button to halt the work immediately.

Answer 2

However, calling any methods to repaint the GUI -inbetween- the calculation (making the calculation stop while the GUI is updated) did not work, and I do not understand why. Can someone explain?

repaint() requests are handled by the RepaintManager and are not done immediately. The RepaintManager basically schedules the repaint. Since repainting is done on the EDT, it can't be done until the EDT is free.

So, I use SwingWorker, to not block the EDT, but then "fake" to block the EDT by disabling everything? This seems really paradox to me.

You can always use an indeterminated JProgressBar. See How to Use Progress Bars .

Or maybe you would prefer to use the Disabled Glass Pane approach.

In some cases you can use:

label.paintImmediately(...);

to force the repainting of a component. But you still have the issue of disabling the GUI so its probably not a solution you should really be using.