JFrame (extended) state, iconified/maximized/normal question

Question

Greetings and salutations,
I've been removing some rough edges from my last application and I noticed the
following: before an application quits every location/size of the top level components
is written to a file. When the application starts again everything is read back in
again and the application shows itself just as it was before it closed the last time.
There's one little quirck though:
A JFrame can be in one of three states when an application quits:
1) iconified; nothing is wrong here, i.e. the application comes back on in the same
iconified state and after de-iconification the JFrame shows up the same as
before the previous quiting.
2) 'normal': same as above: the JFrame shows up identical as before quiting
the application the previous time.
3) maximized: the new incarnation shows up as a maximized JFrame, but after
'demaximalization' (sorry) the JFrame keeps its maximum size, i.e. if still fills up
the entire screen.
Before quiting I save the bounds, the state and the extended state of a JFrame
and reinstate these values after a new incarnation of the application. I think I've
tried all 2^3 == 8 possible permutations of this all, but option 3) keeps giving
me trouble, i.e. the bounds don't work after 'demaximalization'.
Ideas anyone?
kind regards,
Jos

Answer 1

Here's a test program for people who want to experiment around a bit, but are reluctant to create a test class:import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;
public class Test extends JFrame {
    public Test () {
        setDefaultCloseOperation (WindowConstants.DISPOSE_ON_CLOSE);
        setTitle ("Test");
        WindowInfo windowInfo;
        try {
            windowInfo = read ();
        } catch (Exception exception) {
            System.err.println ("couldn't read window.info");
            windowInfo = new WindowInfo ();
        setLocation (windowInfo.location);
        setSize (windowInfo.size);
        setExtendedState (windowInfo.extendedState);
        addWindowListener (new WindowAdapter () {
            public void windowClosing (WindowEvent event) {
                try {
                    write (new WindowInfo (getLocation (), getSize (), getExtendedState ()));
                } catch (Exception exception) {
                    System.err.println ("couldn't write window.info");
        setVisible (true);
    public static void main (String... parameters) {
        new Test ();
    private WindowInfo read () throws ClassNotFoundException, IOException {
        ObjectInputStream in = null;
        try {
            in = new ObjectInputStream (new FileInputStream ("window.info"));
            return (WindowInfo) in.readObject ();
        } finally {
            if (in != null) {
                try {
                    in.close ();
                } catch (IOException exception) {}
    private void write (WindowInfo windowInfo) throws IOException {
        ObjectOutputStream out = null;
        try {
            out = new ObjectOutputStream (new FileOutputStream ("window.info"));
            out.writeObject (windowInfo);
        } finally {
            if (out != null) {
                try {
                    out.close ();
                } catch (IOException exception) {}
    private class WindowInfo implements Serializable {
        public Point location;
        public Dimension size;
        public int extendedState;
        public WindowInfo () {
            size = new Dimension (600, 400);
            Dimension screenSize = Toolkit.getDefaultToolkit ().getScreenSize ();
            location = new Point (screenSize.width / 2 - size.width / 2, screenSize.height / 2 - size.height / 2);
            extendedState = NORMAL;
        public WindowInfo (Point location, Dimension size, int extendedState) {
            this.location = location;
            this.size = size;
            this.extendedState = extendedState;
}Note that I fooled around myself a bit too.