Also see:

setExtendedState(int)
getExtendedState

Also see:

setExtendedState(int)
getExtendedState

Also see:

setExtendedState(int)
getExtendedState
since: 1.4 -

Also see:

setExtendedState(int)
getExtendedState
since: 1.4 -

Note that the correct test for frame being fully maximized is

(state & Frame.MAXIMIZED_BOTH) == Frame.MAXIMIZED_BOTH

To test is frame is maximized in some direction use

(state & Frame.MAXIMIZED_BOTH) != 0

Also see:

setExtendedState(int)
getExtendedState
since: 1.4 -

Also see:

setMaximizedBounds(Rectangle)
getMaximizedBounds
serial:
since: 1.4 -

Also see:

getTitle
setTitle(String)
serial:

Also see:

getMenuBar
setMenuBar(MenuBar)
serial:

Also see:

isResizable()
serial:

Also see:

setUndecorated(boolean)
isUndecorated()
Component#isDisplayable()
serial:
since: 1.4 -

serial:

 public Frame() throws HeadlessException 
{
     
        /* ensure that the necessary native libraries are loaded */
        Toolkit.loadLibraries();
        if (!GraphicsEnvironment.isHeadless()) {
            initIDs();
        }
        this("");
}

Constructs a new instance of Frame that is initially invisible. The title of the Frame is empty.

Throws:

HeadlessException - when GraphicsEnvironment.isHeadless() returns true

Also see:

java.awt.GraphicsEnvironment#isHeadless()
Component#setSize
Component#setVisible(boolean)
exception: HeadlessException - when GraphicsEnvironment.isHeadless() returns true

 public Frame(GraphicsConfiguration gc) 
{
        this("", gc);
}

Constructs a new, initially invisible {@code Frame} with the specified {@code GraphicsConfiguration}.

Parameters:

gc - the GraphicsConfiguration of the target screen device. If gc is null, the system default GraphicsConfiguration is assumed.

Throws:

IllegalArgumentException - if gc is not from a screen device.

HeadlessException - when GraphicsEnvironment.isHeadless() returns true

Also see:

java.awt.GraphicsEnvironment#isHeadless()
exception: IllegalArgumentException - if gc is not from a screen device.

exception: HeadlessException - when GraphicsEnvironment.isHeadless() returns true

since: 1.3 -

 public Frame(String title) throws HeadlessException 
{
        init(title, null);
}

Constructs a new, initially invisible Frame object with the specified title.

Parameters:

title - the title to be displayed in the frame's border. A null value is treated as an empty string, "".

Throws:

HeadlessException - when GraphicsEnvironment.isHeadless() returns true

Also see:

java.awt.GraphicsEnvironment#isHeadless()
java.awt.Component#setSize
java.awt.Component#setVisible(boolean)
java.awt.GraphicsConfiguration#getBounds
exception: HeadlessException - when GraphicsEnvironment.isHeadless() returns true

 public Frame(String title,
    GraphicsConfiguration gc) 
{
        super(gc);
        init(title, gc);
}

Constructs a new, initially invisible Frame object with the specified title and a GraphicsConfiguration.

Parameters:

title - the title to be displayed in the frame's border. A null value is treated as an empty string, "".

gc - the GraphicsConfiguration of the target screen device. If gc is null, the system default GraphicsConfiguration is assumed.

Throws:

IllegalArgumentException - if gc is not from a screen device.

HeadlessException - when GraphicsEnvironment.isHeadless() returns true

Also see:

java.awt.GraphicsEnvironment#isHeadless()
java.awt.Component#setSize
java.awt.Component#setVisible(boolean)
java.awt.GraphicsConfiguration#getBounds
exception: IllegalArgumentException - if gc is not from a screen device.

exception: HeadlessException - when GraphicsEnvironment.isHeadless() returns true

since: 1.3 -

 public  void addNotify() 
{
        synchronized (getTreeLock()) {
            if (peer == null) {
                peer = getToolkit().createFrame(this);
            }
            FramePeer p = (FramePeer)peer;
            MenuBar menuBar = this.menuBar;
            if (menuBar != null) {
                mbManagement = true;
                menuBar.addNotify();
                p.setMenuBar(menuBar);
            }
            p.setMaximizedBounds(maximizedBounds);
            super.addNotify();
        }
}

Makes this Frame displayable by connecting it to a native screen resource. Making a frame displayable will cause any of its children to be made displayable. This method is called internally by the toolkit and should not be called directly by programs.

 String constructComponentName() 
{
        synchronized (Frame.class) {
            return base + nameCounter++;
        }
}

Construct a name for this component. Called by getName() when the name is null.

 public AccessibleContext getAccessibleContext() 
{
        if (accessibleContext == null) {
            accessibleContext = new AccessibleAWTFrame();
        }
        return accessibleContext;
}

Gets the AccessibleContext associated with this Frame. For frames, the AccessibleContext takes the form of an AccessibleAWTFrame. A new AccessibleAWTFrame instance is created if necessary.

 public int getCursorType() 
{
        return (getCursor().getType());
}

 public synchronized int getExtendedState() 
{
        FramePeer peer = (FramePeer)this.peer;
        if (peer != null) {
            state = peer.getState();
        }
        return state;
}

Gets the state of this frame. The state is represented as a bitwise mask.
• NORMAL
  Indicates that no state bits are set.
• ICONIFIED
• MAXIMIZED_HORIZ
• MAXIMIZED_VERT
• MAXIMIZED_BOTH
  Concatenates MAXIMIZED_HORIZ and MAXIMIZED_VERT.

 public static Frame[] getFrames() 
{
        Window[] allWindows = Window.getWindows();
        int frameCount = 0;
        for (Window w : allWindows) {
            if (w instanceof Frame) {
                frameCount++;
            }
        }
        Frame[] frames = new Frame[frameCount];
        int c = 0;
        for (Window w : allWindows) {
            if (w instanceof Frame) {
                frames[c++] = (Frame)w;
            }
        }
        return frames;
}

Returns an array of all {@code Frame}s created by this application. If called from an applet, the array includes only the {@code Frame}s accessible by that applet.

Warning: this method may return system created frames, such as a shared, hidden frame which is used by Swing. Applications should not assume the existence of these frames, nor should an application assume anything about these frames such as component positions, LayoutManagers or serialization.

Note: To obtain a list of all ownerless windows, including ownerless {@code Dialog}s (introduced in release 1.6), use Window.getOwnerlessWindows .

 public Image getIconImage() 
{
        java.util.List< Image > icons = this.icons;
        if (icons != null) {
            if (icons.size()  > 0) {
                return icons.get(0);
            }
        }
        return null;
}

Returns the image to be displayed as the icon for this frame.

This method is obsolete and kept for backward compatibility only. Use Window.getIconImages() instead.

If a list of several images was specified as a Window's icon, this method will return the first item of the list.

 public Rectangle getMaximizedBounds() 
{
        return maximizedBounds;
}

Gets maximized bounds for this frame. Some fields may contain Integer.MAX_VALUE to indicate that system supplied values for this field must be used.

 public MenuBar getMenuBar() 
{
        return menuBar;
}

Gets the menu bar for this frame.

 public synchronized int getState() 
{
        return (getExtendedState() & ICONIFIED) != 0 ? ICONIFIED : NORMAL;
}

Gets the state of this frame (obsolete).

In older versions of JDK a frame state could only be NORMAL or ICONIFIED. Since JDK 1.4 set of supported frame states is expanded and frame state is represented as a bitwise mask.

For compatibility with old programs this method still returns Frame.NORMAL and Frame.ICONIFIED but it only reports the iconic state of the frame, other aspects of frame state are not reported by this method.

 public String getTitle() 
{
        return title;
}

Gets the title of the frame. The title is displayed in the frame's border.

 public boolean isResizable() 
{
        return resizable;
}

Indicates whether this frame is resizable by the user. By default, all frames are initially resizable.

 public boolean isUndecorated() 
{
        return undecorated;
}

Indicates whether this frame is undecorated. By default, all frames are initially decorated.

 protected String paramString() 
{
        String str = super.paramString();
        if (title != null) {
            str += ",title=" + title;
        }
        if (resizable) {
            str += ",resizable";
        }
        getExtendedState();     // sync with peer
        if (state == NORMAL) {
            str += ",normal";
        }
        else {
            if ((state & ICONIFIED) != 0) {
                str += ",iconified";
            }
            if ((state & MAXIMIZED_BOTH) == MAXIMIZED_BOTH) {
                str += ",maximized";
            }
            else if ((state & MAXIMIZED_HORIZ) != 0) {
                str += ",maximized_horiz";
            }
            else if ((state & MAXIMIZED_VERT) != 0) {
                str += ",maximized_vert";
            }
        }
        return str;
}

Returns a string representing the state of this Frame. This method is intended to be used only for debugging purposes, and the content and format of the returned string may vary between implementations. The returned string may be empty but may not be null.

  void postProcessKeyEvent(KeyEvent e) 
{
        if (menuBar != null && menuBar.handleShortcut(e)) {
            e.consume();
            return;
        }
        super.postProcessKeyEvent(e);
}

 public  void remove(MenuComponent m) 
{
        if (m == null) {
            return;
        }
        synchronized (getTreeLock()) {
            if (m == menuBar) {
                menuBar = null;
                FramePeer peer = (FramePeer)this.peer;
                if (peer != null) {
                    mbManagement = true;
                    if (valid) {
                        invalidate();
                    }
                    peer.setMenuBar(null);
                    m.removeNotify();
                }
                m.parent = null;
            } else {
                super.remove(m);
            }
        }
}

Removes the specified menu bar from this frame.

 public  void removeNotify() 
{
        synchronized (getTreeLock()) {
            FramePeer peer = (FramePeer)this.peer;
            if (peer != null) {
                // get the latest Frame state before disposing
                getState();
                if (menuBar != null) {
                    mbManagement = true;
                    peer.setMenuBar(null);
                    menuBar.removeNotify();
                }
            }
            super.removeNotify();
        }
}

Makes this Frame undisplayable by removing its connection to its native screen resource. Making a Frame undisplayable will cause any of its children to be made undisplayable. This method is called by the toolkit internally and should not be called directly by programs.

 public  void setCursor(int cursorType) 
{
        if (cursorType <  DEFAULT_CURSOR || cursorType  > MOVE_CURSOR) {
            throw new IllegalArgumentException("illegal cursor type");
        }
        setCursor(Cursor.getPredefinedCursor(cursorType));
}

 public synchronized  void setExtendedState(int state) 
{
        if ( !isFrameStateSupported( state ) ) {
            return;
        }
        this.state = state;
        FramePeer peer = (FramePeer)this.peer;
        if (peer != null) {
            peer.setState(state);
        }
}

Sets the state of this frame. The state is represented as a bitwise mask.
• NORMAL
  Indicates that no state bits are set.
• ICONIFIED
• MAXIMIZED_HORIZ
• MAXIMIZED_VERT
• MAXIMIZED_BOTH
  Concatenates MAXIMIZED_HORIZ and MAXIMIZED_VERT.

Note that if the state is not supported on a given platform, neither the state nor the return value of the #getExtendedState method will be changed. The application may determine whether a specific state is supported via the java.awt.Toolkit#isFrameStateSupported method.

If the frame is currently visible on the screen (the #isShowing method returns {@code true}), the developer should examine the return value of the java.awt.event.WindowEvent#getNewState method of the {@code WindowEvent} received through the java.awt.event.WindowStateListener to determine that the state has actually been changed.

If the frame is not visible on the screen, the events may or may not be generated. In this case the developer may assume that the state changes immediately after this method returns. Later, when the {@code setVisible(true)} method is invoked, the frame will attempt to apply this state. Receiving any java.awt.event.WindowEvent#WINDOW_STATE_CHANGED events is not guaranteed in this case also.

 public  void setIconImage(Image image) 
{
        super.setIconImage(image);
}

{@inheritDoc}

 public synchronized  void setMaximizedBounds(Rectangle bounds) 
{
        this.maximizedBounds = bounds;
        FramePeer peer = (FramePeer)this.peer;
        if (peer != null) {
            peer.setMaximizedBounds(bounds);
        }
}

Sets the maximized bounds for this frame.

When a frame is in maximized state the system supplies some defaults bounds. This method allows some or all of those system supplied values to be overridden.

If bounds is null, accept bounds supplied by the system. If non-null you can override some of the system supplied values while accepting others by setting those fields you want to accept from system to Integer.MAX_VALUE.

On some systems only the size portion of the bounds is taken into account.

 public  void setMenuBar(MenuBar mb) 
{
        synchronized (getTreeLock()) {
            if (menuBar == mb) {
                return;
            }
            if ((mb != null) && (mb.parent != null)) {
                mb.parent.remove(mb);
            }
            if (menuBar != null) {
                remove(menuBar);
            }
            menuBar = mb;
            if (menuBar != null) {
                menuBar.parent = this;
                FramePeer peer = (FramePeer)this.peer;
                if (peer != null) {
                    mbManagement = true;
                    menuBar.addNotify();
                    if (valid) {
                        invalidate();
                    }
                    peer.setMenuBar(menuBar);
                }
            }
        }
}

Sets the menu bar for this frame to the specified menu bar.

 public  void setResizable(boolean resizable) 
{
        boolean oldResizable = this.resizable;
        boolean testvalid = false;
        synchronized (this) {
            this.resizable = resizable;
            FramePeer peer = (FramePeer)this.peer;
            if (peer != null) {
                peer.setResizable(resizable);
                testvalid = true;
            }
        }
        // On some platforms, changing the resizable state affects
        // the insets of the Frame. If we could, we'd call invalidate()
        // from the peer, but we need to guarantee that we're not holding
        // the Frame lock when we call invalidate().
        if (testvalid && valid) {
            invalidate();
        }
        firePropertyChange("resizable", oldResizable, resizable);
}

Sets whether this frame is resizable by the user.

 public synchronized  void setState(int state) 
{
        int current = getExtendedState();
        if (state == ICONIFIED && (current & ICONIFIED) == 0) {
            setExtendedState(current | ICONIFIED);
        }
        else if (state == NORMAL && (current & ICONIFIED) != 0) {
            setExtendedState(current & ~ICONIFIED);
        }
}

Sets the state of this frame (obsolete).

In older versions of JDK a frame state could only be NORMAL or ICONIFIED. Since JDK 1.4 set of supported frame states is expanded and frame state is represented as a bitwise mask.

For compatibility with applications developed earlier this method still accepts {@code Frame.NORMAL} and {@code Frame.ICONIFIED} only. The iconic state of the frame is only changed, other aspects of frame state are not affected by this method. If the state passed to this method is neither {@code Frame.NORMAL} nor {@code Frame.ICONIFIED} the method performs no actions at all.

Note that if the state is not supported on a given platform, neither the state nor the return value of the #getState method will be changed. The application may determine whether a specific state is supported via the java.awt.Toolkit#isFrameStateSupported method.

If the frame is currently visible on the screen (the #isShowing method returns {@code true}), the developer should examine the return value of the java.awt.event.WindowEvent#getNewState method of the {@code WindowEvent} received through the java.awt.event.WindowStateListener to determine that the state has actually been changed.

If the frame is not visible on the screen, the events may or may not be generated. In this case the developer may assume that the state changes immediately after this method returns. Later, when the {@code setVisible(true)} method is invoked, the frame will attempt to apply this state. Receiving any java.awt.event.WindowEvent#WINDOW_STATE_CHANGED events is not guaranteed in this case also.

 public  void setTitle(String title) 
{
        String oldTitle = this.title;
        if (title == null) {
            title = "";
        }
        synchronized(this) {
            this.title = title;
            FramePeer peer = (FramePeer)this.peer;
            if (peer != null) {
                peer.setTitle(title);
            }
        }
        firePropertyChange("title", oldTitle, title);
}

Sets the title for this frame to the specified string.

 public  void setUndecorated(boolean undecorated) 
{
        /* Make sure we don't run in the middle of peer creation.*/
        synchronized (getTreeLock()) {
            if (isDisplayable()) {
                throw new IllegalComponentStateException("The frame is displayable.");
            }
            this.undecorated = undecorated;
        }
}

Disables or enables decorations for this frame. This method can only be called while the frame is not displayable.