setState ( )源码实例Demo

java.awt.peer.FramePeer#setState ( )源码实例Demo

下面列出了java.awt.peer.FramePeer#setState ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。

源代码1 项目： jdk1.8-source-analysis 文件： Frame.java

/**
 * 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);
    }
}

源代码2 项目： dragonwell8_jdk 文件： Frame.java

/**
 * 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);
    }
}

源代码3 项目： TencentKona-8 文件： Frame.java

/**
 * 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);
    }
}

源代码4 项目： jdk8u60 文件： Frame.java

/**
 * 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);
    }
}

源代码5 项目： JDKSourceCode1.8 文件： Frame.java

/**
 * 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);
    }
}

源代码6 项目： openjdk-jdk8u 文件： Frame.java

/**
 * 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);
    }
}

源代码7 项目： openjdk-jdk8u-backup 文件： Frame.java

/**
 * 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);
    }
}

源代码8 项目： Bytecoder 文件： Frame.java

/**
 * 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);
    }
}

源代码9 项目： openjdk-jdk9 文件： Frame.java

/**
 * 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);
    }
}

源代码10 项目： jdk8u-jdk 文件： Frame.java

/**
 * 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);
    }
}

源代码11 项目： Java8CN 文件： Frame.java

/**
 * 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);
    }
}

源代码12 项目： hottub 文件： Frame.java

/**
 * 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);
    }
}

源代码13 项目： openjdk-8-source 文件： Frame.java

/**
 * 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);
    }
}

源代码14 项目： openjdk-8 文件： Frame.java

/**
 * 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);
    }
}

源代码15 项目： jdk8u_jdk 文件： Frame.java

/**
 * 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);
    }
}

源代码16 项目： jdk8u-jdk 文件： Frame.java

/**
 * 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);
    }
}

源代码17 项目： jdk-1.7-annotated 文件： Frame.java

/**
 * 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);
    }
}

源代码18 项目： jdk8u-dev-jdk 文件： Frame.java

/**
 * 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);
    }
}

如果文章对您有帮助，请点击页面广告。以鼓励作者做出的努力。

方法所在类

java.awt.peer.FramePeer