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);
    }
}
 
如果文章对您有帮助,请点击页面广告。以鼓励作者做出的努力。
 方法所在类