Java Code Examples for java.awt.peer.FramePeer#setState()

The following examples show how to use java.awt.peer.FramePeer#setState() . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source File: Frame.java    From jdk8u-jdk with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 2
Source File: Frame.java    From jdk8u-dev-jdk with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 3
Source File: Frame.java    From jdk-1.7-annotated with Apache License 2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 4
Source File: Frame.java    From jdk8u-jdk with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 5
Source File: Frame.java    From jdk8u_jdk with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 6
Source File: Frame.java    From openjdk-8 with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 7
Source File: Frame.java    From openjdk-8-source with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 8
Source File: Frame.java    From hottub with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 9
Source File: Frame.java    From Java8CN with Apache License 2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 10
Source File: Frame.java    From jdk1.8-source-analysis with Apache License 2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 11
Source File: Frame.java    From openjdk-jdk9 with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li>{@code NORMAL}
 * <br>Indicates that no state bits are set.
 * <li>{@code ICONIFIED}
 * <li>{@code MAXIMIZED_HORIZ}
 * <li>{@code MAXIMIZED_VERT}
 * <li>{@code MAXIMIZED_BOTH}
 * <br>Concatenates {@code MAXIMIZED_HORIZ}
 * and {@code MAXIMIZED_VERT}.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 12
Source File: Frame.java    From Bytecoder with Apache License 2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li>{@code NORMAL}
 * <br>Indicates that no state bits are set.
 * <li>{@code ICONIFIED}
 * <li>{@code MAXIMIZED_HORIZ}
 * <li>{@code MAXIMIZED_VERT}
 * <li>{@code MAXIMIZED_BOTH}
 * <br>Concatenates {@code MAXIMIZED_HORIZ}
 * and {@code MAXIMIZED_VERT}.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 13
Source File: Frame.java    From openjdk-jdk8u-backup with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 14
Source File: Frame.java    From openjdk-jdk8u with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 15
Source File: Frame.java    From JDKSourceCode1.8 with MIT License 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 16
Source File: Frame.java    From jdk8u60 with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 17
Source File: Frame.java    From TencentKona-8 with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}
Example 18
Source File: Frame.java    From dragonwell8_jdk with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the state of this frame. The state is
 * represented as a bitwise mask.
 * <ul>
 * <li><code>NORMAL</code>
 * <br>Indicates that no state bits are set.
 * <li><code>ICONIFIED</code>
 * <li><code>MAXIMIZED_HORIZ</code>
 * <li><code>MAXIMIZED_VERT</code>
 * <li><code>MAXIMIZED_BOTH</code>
 * <br>Concatenates <code>MAXIMIZED_HORIZ</code>
 * and <code>MAXIMIZED_VERT</code>.
 * </ul>
 * <p>Note that if the state is not supported on a
 * given platform, neither the state nor the return
 * value of the {@link #getExtendedState} method will
 * be changed. The application may determine whether
 * a specific state is supported via the {@link
 * java.awt.Toolkit#isFrameStateSupported} method.
 * <p><b>If the frame is currently visible on the
 * screen</b> (the {@link #isShowing} method returns
 * {@code true}), the developer should examine the
 * return value of the {@link
 * java.awt.event.WindowEvent#getNewState} method of
 * the {@code WindowEvent} received through the
 * {@link java.awt.event.WindowStateListener} to
 * determine that the state has actually been
 * changed.
 * <p><b>If the frame is not visible on the
 * screen</b>, 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
 * {@link
 * java.awt.event.WindowEvent#WINDOW_STATE_CHANGED}
 * events is not guaranteed in this case also.
 *
 * @param state a bitwise mask of frame state constants
 * @since   1.4
 * @see java.awt.Window#addWindowStateListener
 */
public void setExtendedState(int state) {
    if ( !isFrameStateSupported( state ) ) {
        return;
    }
    synchronized (getObjectLock()) {
        this.state = state;
    }
    // peer.setState must be called outside of object lock
    // synchronization block to avoid possible deadlock
    FramePeer peer = (FramePeer)this.peer;
    if (peer != null) {
        peer.setState(state);
    }
}