On Feb 12, 9:59 pm, samuel.chea...@gmail.com wrote:
...

Probably a variety of things, but since
I do not understand what your code is
supposed to be doing, and the current
behaviour is easily explained, I am not
sure how to best advise.

The reason the .setVisible() call that
was highlighted (with that extremely
verbose line that wrapped and spoiled
a clean compilation) has no effect is
that the GUI is already visible, and
cannot become any *more* visible.

A couple of println() statements can
show that the code evaluates true at
the first if of the createGUI() method.

That is the code path that sets the GUI
visible.  Any further calls are redundant.

Perhaps you should explain how this is
supposed to look to the end user.
What happens, and why?

Andrew T.

samuel.cheadle@gmail.com schrieb:

Yes, you do :)

In Swing there's a thread, called Event Dispatch(ing) Thread, EDT for
short. Most work is done on this thread - painting, platform independend
event handling (notifying listeners) and so on.

Therefore, if a button notifies it's listeners, this code also runs on
the EDT.

Q: So, what is the consequence if your program waits for a
   few seconds within a listener like ActionListener?
A: Right, it forces the current thread to wait for a few seconds.

Q: And what's the current thread?
A: Right, the EDT.

Q: And since the EDT is responsible for painting (in Swing),
   what happens?
A: Right, nothing gets painted until the listener's method returns.
   The GUI is "blocked".

Q: Hmm. But how can you wait for a few seconds if one clicks
   on a button without blocking the GUI?
A: Move the waiting procedure into a new thread. But be careful:
   Only one thread may manipulate the GUI: the EDT. This leads
   us to the last question:

Q: How do I manipulate the GUI from a non-EDT thread?
A: Short: Never :)
   Long: You have to ensure that the UI manipulating code runs
         on the EDT. Either your code runs on the EDT already
         (like the actionPerformed method) or you put your
         code into the event dispatching queue which is processed
         by the EDT. This can be done via
         java.awt.EventQueue.invokeLater or
         javax.swing.Utilities.invokeLater
         (the latter just calls java.awt.EventQueue.invokeLater).

I've attached some (untested - even not compiled) code.

You may also want to use SwingWorker instead of the horrible
Runnable-cascades.

Bye
Michael

public class Test {

    private JButton button;

    private void initComponents() {
        button = new JButton("Hide");
        button.addActionListener( new ActionListener() {
            public void actionPerformed( ActionEvent e ) {
                // first: make the button invisible
                button.setVisible(false);

                // now we have to return quickly so we
                // don't block the EDT.
                // Therefore create another Thread.
                Thread t = new Thread( new Runnable() {
                    public void run() {
                        try {
                            Thread.sleep(2000);
                        } catch ( InterruptedException ie ) {
                        }
                        // after the two seconds we want
                        // to show the button again.
                        // since we're not on the EDT,
                        // let's put the setVisible-code
                        // into the Event Dispatching Queue
                        SwingUtilities.invokeLater( new Runnable() {
                            public void run() {
                                button.setVisible(true);
                            }
                        });
                    }
                });

                // and start it:
                t.setPriority( Thread.NORM_PRIORITY );
                t.start();
            }
        });
    }

    public void createAndShowGUI() {
        initComponents();

        JFrame frame = new JFrame("Test");
        frame.setDefaultCloseOperation( JFrame.DISPOSE_ON_CLOSE );
        frame.add( button );
        frame.pack();
        frame.setVisible(true);
    }

    public static final void main( String args[] ) {

        // we're on the main thread, so we ensure that
        // GUI creation is done on the EDT

        SwingUtilities.invokeLater( new Runnable() {
            public void run() {
                new Test().createAndShowGUI();
            }
        });
    }
}