archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-09-23 20:44:41 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

7027045: (doc) java/awt/Window.java has several typos in javadoc

Browse source 
Reviewed-by: art, serb
This commit is contained in:
Konstantin Perikov 2013-08-13 15:41:55 +04:00 • committed by Sergey Bylokhov
parent ad02c635e3
commit 36197b96c2
1 changed files with 189 additions and 189 deletions
Download patch file Download diff file Expand all files Collapse all files

378
jdk/src/share/classes/java/awt/Window.java
View file

@ -62,18 +62,18 @@ import sun.security.util.SecurityConstants;
import sun.util.logging.PlatformLogger; import sun.util.logging.PlatformLogger;
/** /**
* A <code>Window</code> object is a top-level window with no borders and no * A {@code Window} object is a top-level window with no borders and no
* menubar. * menubar.
* The default layout for a window is <code>BorderLayout</code>. * The default layout for a window is {@code BorderLayout}.
* <p> * <p>
* A window must have either a frame, dialog, or another window defined as its * A window must have either a frame, dialog, or another window defined as its
* owner when it's constructed. * owner when it's constructed.
* <p> * <p>
* In a multi-screen environment, you can create a <code>Window</code> * In a multi-screen environment, you can create a {@code Window}
* on a different screen device by constructing the <code>Window</code> * on a different screen device by constructing the {@code Window}
* with {@link #Window(Window, GraphicsConfiguration)}. The * with {@link #Window(Window, GraphicsConfiguration)}. The
* <code>GraphicsConfiguration</code> object is one of the * {@code GraphicsConfiguration} object is one of the
* <code>GraphicsConfiguration</code> objects of the target screen device. * {@code GraphicsConfiguration} objects of the target screen device.
* <p> * <p>
* In a virtual device multi-screen environment in which the desktop * In a virtual device multi-screen environment in which the desktop
* area could span multiple physical screen devices, the bounds of all * area could span multiple physical screen devices, the bounds of all
@ -87,21 +87,21 @@ import sun.util.logging.PlatformLogger;
* alt="Diagram shows virtual device containing 4 physical screens. Primary physical screen shows coords (0,0), other screen shows (-80,-100)." * alt="Diagram shows virtual device containing 4 physical screens. Primary physical screen shows coords (0,0), other screen shows (-80,-100)."
* ALIGN=center HSPACE=10 VSPACE=7> * ALIGN=center HSPACE=10 VSPACE=7>
* <p> * <p>
* In such an environment, when calling <code>setLocation</code>, * In such an environment, when calling {@code setLocation},
* you must pass a virtual coordinate to this method. Similarly, * you must pass a virtual coordinate to this method. Similarly,
* calling <code>getLocationOnScreen</code> on a <code>Window</code> returns * calling {@code getLocationOnScreen} on a {@code Window} returns
* virtual device coordinates. Call the <code>getBounds</code> method * virtual device coordinates. Call the {@code getBounds} method
* of a <code>GraphicsConfiguration</code> to find its origin in the virtual * of a {@code GraphicsConfiguration} to find its origin in the virtual
* coordinate system. * coordinate system.
* <p> * <p>
* The following code sets the location of a <code>Window</code> * The following code sets the location of a {@code Window}
* at (10, 10) relative to the origin of the physical screen * at (10, 10) relative to the origin of the physical screen
* of the corresponding <code>GraphicsConfiguration</code>. If the * of the corresponding {@code GraphicsConfiguration}. If the
* bounds of the <code>GraphicsConfiguration</code> is not taken * bounds of the {@code GraphicsConfiguration} is not taken
* into account, the <code>Window</code> location would be set * into account, the {@code Window} location would be set
* at (10, 10) relative to the virtual-coordinate system and would appear * at (10, 10) relative to the virtual-coordinate system and would appear
* on the primary physical screen, which might be different from the * on the primary physical screen, which might be different from the
* physical screen of the specified <code>GraphicsConfiguration</code>. * physical screen of the specified {@code GraphicsConfiguration}.
* *
* <pre> * <pre>
* Window w = new Window(Window owner, GraphicsConfiguration gc); * Window w = new Window(Window owner, GraphicsConfiguration gc);
@ -111,19 +111,19 @@ import sun.util.logging.PlatformLogger;
* *
* <p> * <p>
* Note: the location and size of top-level windows (including * Note: the location and size of top-level windows (including
* <code>Window</code>s, <code>Frame</code>s, and <code>Dialog</code>s) * {@code Window}s, {@code Frame}s, and {@code Dialog}s)
* are under the control of the desktop's window management system. * are under the control of the desktop's window management system.
* Calls to <code>setLocation</code>, <code>setSize</code>, and * Calls to {@code setLocation}, {@code setSize}, and
* <code>setBounds</code> are requests (not directives) which are * {@code setBounds} are requests (not directives) which are
* forwarded to the window management system. Every effort will be * forwarded to the window management system. Every effort will be
* made to honor such requests. However, in some cases the window * made to honor such requests. However, in some cases the window
* management system may ignore such requests, or modify the requested * management system may ignore such requests, or modify the requested
* geometry in order to place and size the <code>Window</code> in a way * geometry in order to place and size the {@code Window} in a way
* that more closely matches the desktop settings. * that more closely matches the desktop settings.
* <p> * <p>
* Due to the asynchronous nature of native event handling, the results * Due to the asynchronous nature of native event handling, the results
* returned by <code>getBounds</code>, <code>getLocation</code>, * returned by {@code getBounds}, {@code getLocation},
* <code>getLocationOnScreen</code>, and <code>getSize</code> might not * {@code getLocationOnScreen}, and {@code getSize} might not
* reflect the actual geometry of the Window on screen until the last * reflect the actual geometry of the Window on screen until the last
* request has been processed. During the processing of subsequent * request has been processed. During the processing of subsequent
* requests these values might change accordingly while the window * requests these values might change accordingly while the window
@ -340,7 +340,7 @@ public class Window extends Container implements Accessible {
*/ */
transient boolean isInShow = false; transient boolean isInShow = false;
/* /**
* The opacity level of the window * The opacity level of the window
* *
* @serial * @serial
@ -350,7 +350,7 @@ public class Window extends Container implements Accessible {
*/ */
private float opacity = 1.0f; private float opacity = 1.0f;
/* /**
* The shape assigned to this window. This field is set to {@code null} if * The shape assigned to this window. This field is set to {@code null} if
* no shape is set (rectangular window). * no shape is set (rectangular window).
* *
@ -415,21 +415,21 @@ public class Window extends Container implements Accessible {
/** /**
* Constructs a new, initially invisible window in default size with the * Constructs a new, initially invisible window in default size with the
* specified <code>GraphicsConfiguration</code>. * specified {@code GraphicsConfiguration}.
* <p> * <p>
* If there is a security manager, this method first calls * If there is a security manager, this method first calls
* the security manager's <code>checkTopLevelWindow</code> * the security manager's {@code checkTopLevelWindow}
* method with <code>this</code> * method with {@code this}
* as its argument to determine whether or not the window * as its argument to determine whether or not the window
* must be displayed with a warning banner. * must be displayed with a warning banner.
* *
* @param gc the <code>GraphicsConfiguration</code> of the target screen * @param gc the {@code GraphicsConfiguration} of the target screen
* device. If <code>gc</code> is <code>null</code>, the system default * device. If {@code gc} is {@code null}, the system default
* <code>GraphicsConfiguration</code> is assumed * {@code GraphicsConfiguration} is assumed
* @exception IllegalArgumentException if <code>gc</code> * @exception IllegalArgumentException if {@code gc}
* is not from a screen device * is not from a screen device
* @exception HeadlessException when * @exception HeadlessException when
* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> * {@code GraphicsEnvironment.isHeadless()} returns {@code true}
* *
* @see java.awt.GraphicsEnvironment#isHeadless * @see java.awt.GraphicsEnvironment#isHeadless
* @see java.lang.SecurityManager#checkTopLevelWindow * @see java.lang.SecurityManager#checkTopLevelWindow
@ -513,20 +513,20 @@ public class Window extends Container implements Accessible {
* Constructs a new, initially invisible window in the default size. * Constructs a new, initially invisible window in the default size.
* *
* <p>First, if there is a security manager, its * <p>First, if there is a security manager, its
* <code>checkTopLevelWindow</code> * {@code checkTopLevelWindow}
* method is called with <code>this</code> * method is called with {@code this}
* as its argument * as its argument
* to see if it's ok to display the window without a warning banner. * to see if it's ok to display the window without a warning banner.
* If the default implementation of <code>checkTopLevelWindow</code> * If the default implementation of {@code checkTopLevelWindow}
* is used (that is, that method is not overriden), then this results in * is used (that is, that method is not overriden), then this results in
* a call to the security manager's <code>checkPermission</code> method * a call to the security manager's {@code checkPermission} method
* with an <code>AWTPermission("showWindowWithoutWarningBanner")</code> * with an {@code AWTPermission("showWindowWithoutWarningBanner")}
* permission. It that method raises a SecurityException, * permission. It that method raises a SecurityException,
* <code>checkTopLevelWindow</code> returns false, otherwise it * {@code checkTopLevelWindow} returns false, otherwise it
* returns true. If it returns false, a warning banner is created. * returns true. If it returns false, a warning banner is created.
* *
* @exception HeadlessException when * @exception HeadlessException when
* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> * {@code GraphicsEnvironment.isHeadless()} returns {@code true}
* *
* @see java.awt.GraphicsEnvironment#isHeadless * @see java.awt.GraphicsEnvironment#isHeadless
* @see java.lang.SecurityManager#checkTopLevelWindow * @see java.lang.SecurityManager#checkTopLevelWindow
@ -538,21 +538,21 @@ public class Window extends Container implements Accessible {
/** /**
* Constructs a new, initially invisible window with the specified * Constructs a new, initially invisible window with the specified
* <code>Frame</code> as its owner. The window will not be focusable * {@code Frame} as its owner. The window will not be focusable
* unless its owner is showing on the screen. * unless its owner is showing on the screen.
* <p> * <p>
* If there is a security manager, this method first calls * If there is a security manager, this method first calls
* the security manager's <code>checkTopLevelWindow</code> * the security manager's {@code checkTopLevelWindow}
* method with <code>this</code> * method with {@code this}
* as its argument to determine whether or not the window * as its argument to determine whether or not the window
* must be displayed with a warning banner. * must be displayed with a warning banner.
* *
* @param owner the <code>Frame</code> to act as owner or <code>null</code> * @param owner the {@code Frame} to act as owner or {@code null}
* if this window has no owner * if this window has no owner
* @exception IllegalArgumentException if the <code>owner</code>'s * @exception IllegalArgumentException if the {@code owner}'s
* <code>GraphicsConfiguration</code> is not from a screen device * {@code GraphicsConfiguration} is not from a screen device
* @exception HeadlessException when * @exception HeadlessException when
* <code>GraphicsEnvironment.isHeadless</code> returns <code>true</code> * {@code GraphicsEnvironment.isHeadless} returns {@code true}
* *
* @see java.awt.GraphicsEnvironment#isHeadless * @see java.awt.GraphicsEnvironment#isHeadless
* @see java.lang.SecurityManager#checkTopLevelWindow * @see java.lang.SecurityManager#checkTopLevelWindow
@ -566,23 +566,23 @@ public class Window extends Container implements Accessible {
/** /**
* Constructs a new, initially invisible window with the specified * Constructs a new, initially invisible window with the specified
* <code>Window</code> as its owner. This window will not be focusable * {@code Window} as its owner. This window will not be focusable
* unless its nearest owning <code>Frame</code> or <code>Dialog</code> * unless its nearest owning {@code Frame} or {@code Dialog}
* is showing on the screen. * is showing on the screen.
* <p> * <p>
* If there is a security manager, this method first calls * If there is a security manager, this method first calls
* the security manager's <code>checkTopLevelWindow</code> * the security manager's {@code checkTopLevelWindow}
* method with <code>this</code> * method with {@code this}
* as its argument to determine whether or not the window * as its argument to determine whether or not the window
* must be displayed with a warning banner. * must be displayed with a warning banner.
* *
* @param owner the <code>Window</code> to act as owner or * @param owner the {@code Window} to act as owner or
* <code>null</code> if this window has no owner * {@code null} if this window has no owner
* @exception IllegalArgumentException if the <code>owner</code>'s * @exception IllegalArgumentException if the {@code owner}'s
* <code>GraphicsConfiguration</code> is not from a screen device * {@code GraphicsConfiguration} is not from a screen device
* @exception HeadlessException when * @exception HeadlessException when
* <code>GraphicsEnvironment.isHeadless()</code> returns * {@code GraphicsEnvironment.isHeadless()} returns
* <code>true</code> * {@code true}
* *
* @see java.awt.GraphicsEnvironment#isHeadless * @see java.awt.GraphicsEnvironment#isHeadless
* @see java.lang.SecurityManager#checkTopLevelWindow * @see java.lang.SecurityManager#checkTopLevelWindow
@ -598,27 +598,27 @@ public class Window extends Container implements Accessible {
/** /**
* Constructs a new, initially invisible window with the specified owner * Constructs a new, initially invisible window with the specified owner
* <code>Window</code> and a <code>GraphicsConfiguration</code> * {@code Window} and a {@code GraphicsConfiguration}
* of a screen device. The Window will not be focusable unless * of a screen device. The Window will not be focusable unless
* its nearest owning <code>Frame</code> or <code>Dialog</code> * its nearest owning {@code Frame} or {@code Dialog}
* is showing on the screen. * is showing on the screen.
* <p> * <p>
* If there is a security manager, this method first calls * If there is a security manager, this method first calls
* the security manager's <code>checkTopLevelWindow</code> * the security manager's {@code checkTopLevelWindow}
* method with <code>this</code> * method with {@code this}
* as its argument to determine whether or not the window * as its argument to determine whether or not the window
* must be displayed with a warning banner. * must be displayed with a warning banner.
* *
* @param owner the window to act as owner or <code>null</code> * @param owner the window to act as owner or {@code null}
* if this window has no owner * if this window has no owner
* @param gc the <code>GraphicsConfiguration</code> of the target * @param gc the {@code GraphicsConfiguration} of the target
* screen device; if <code>gc</code> is <code>null</code>, * screen device; if {@code gc} is {@code null},
* the system default <code>GraphicsConfiguration</code> is assumed * the system default {@code GraphicsConfiguration} is assumed
* @exception IllegalArgumentException if <code>gc</code> * @exception IllegalArgumentException if {@code gc}
* is not from a screen device * is not from a screen device
* @exception HeadlessException when * @exception HeadlessException when
* <code>GraphicsEnvironment.isHeadless()</code> returns * {@code GraphicsEnvironment.isHeadless()} returns
* <code>true</code> * {@code true}
* *
* @see java.awt.GraphicsEnvironment#isHeadless * @see java.awt.GraphicsEnvironment#isHeadless
* @see java.lang.SecurityManager#checkTopLevelWindow * @see java.lang.SecurityManager#checkTopLevelWindow
@ -936,7 +936,7 @@ public class Window extends Container implements Accessible {
/** /**
* @deprecated As of JDK version 1.1, * @deprecated As of JDK version 1.1,
* replaced by <code>setBounds(int, int, int, int)</code>. * replaced by {@code setBounds(int, int, int, int)}.
*/ */
@Deprecated @Deprecated
public void reshape(int x, int y, int width, int height) { public void reshape(int x, int y, int width, int height) {
@ -1122,16 +1122,16 @@ public class Window extends Container implements Accessible {
/** /**
* Releases all of the native screen resources used by this * Releases all of the native screen resources used by this
* <code>Window</code>, its subcomponents, and all of its owned * {@code Window}, its subcomponents, and all of its owned
* children. That is, the resources for these <code>Component</code>s * children. That is, the resources for these {@code Component}s
* will be destroyed, any memory they consume will be returned to the * will be destroyed, any memory they consume will be returned to the
* OS, and they will be marked as undisplayable. * OS, and they will be marked as undisplayable.
* <p> * <p>
* The <code>Window</code> and its subcomponents can be made displayable * The {@code Window} and its subcomponents can be made displayable
* again by rebuilding the native resources with a subsequent call to * again by rebuilding the native resources with a subsequent call to
* <code>pack</code> or <code>show</code>. The states of the recreated * {@code pack} or {@code show}. The states of the recreated
* <code>Window</code> and its subcomponents will be identical to the * {@code Window} and its subcomponents will be identical to the
* states of these objects at the point where the <code>Window</code> * states of these objects at the point where the {@code Window}
* was disposed (not accounting for additional modifications between * was disposed (not accounting for additional modifications between
* those actions). * those actions).
* <p> * <p>
@ -1363,14 +1363,14 @@ public class Window extends Container implements Accessible {
* If this window is insecure, the warning string is displayed * If this window is insecure, the warning string is displayed
* somewhere in the visible area of the window. A window is * somewhere in the visible area of the window. A window is
* insecure if there is a security manager, and the security * insecure if there is a security manager, and the security
* manager's <code>checkTopLevelWindow</code> method returns * manager's {@code checkTopLevelWindow} method returns
* <code>false</code> when this window is passed to it as an * {@code false} when this window is passed to it as an
* argument. * argument.
* <p> * <p>
* If the window is secure, then <code>getWarningString</code> * If the window is secure, then {@code getWarningString}
* returns <code>null</code>. If the window is insecure, this * returns {@code null}. If the window is insecure, this
* method checks for the system property * method checks for the system property
* <code>awt.appletWarning</code> * {@code awt.appletWarning}
* and returns the string value of that property. * and returns the string value of that property.
* @return the warning string for this window. * @return the warning string for this window.
* @see java.lang.SecurityManager#checkTopLevelWindow(java.lang.Object) * @see java.lang.SecurityManager#checkTopLevelWindow(java.lang.Object)
@ -1395,7 +1395,7 @@ public class Window extends Container implements Accessible {
} }
/** /**
* Gets the <code>Locale</code> object that is associated * Gets the {@code Locale} object that is associated
* with this window, if the locale has been set. * with this window, if the locale has been set.
* If no locale has been set, then the default locale * If no locale has been set, then the default locale
* is returned. * is returned.
@ -1432,7 +1432,7 @@ public class Window extends Container implements Accessible {
* implementation and/or the native system do not support * implementation and/or the native system do not support
* changing the mouse cursor shape. * changing the mouse cursor shape.
* @param cursor One of the constants defined * @param cursor One of the constants defined
* by the <code>Cursor</code> class. If this parameter is null * by the {@code Cursor} class. If this parameter is null
* then the cursor for this window will be set to the type * then the cursor for this window will be set to the type
* Cursor.DEFAULT_CURSOR. * Cursor.DEFAULT_CURSOR.
* @see Component#getCursor * @see Component#getCursor
@ -1579,7 +1579,7 @@ public class Window extends Container implements Accessible {
* <b>Warning:</b> this method may return system created windows, such * <b>Warning:</b> this method may return system created windows, such
* as a print dialog. Applications should not assume the existence of * as a print dialog. Applications should not assume the existence of
* these dialogs, nor should an application assume anything about these * these dialogs, nor should an application assume anything about these
* dialogs such as component positions, <code>LayoutManager</code>s * dialogs such as component positions, {@code LayoutManager}s
* or serialization. * or serialization.
* *
* @see Frame#getFrames * @see Frame#getFrames
@ -1601,7 +1601,7 @@ public class Window extends Container implements Accessible {
* <b>Warning:</b> this method may return system created windows, such * <b>Warning:</b> this method may return system created windows, such
* as a print dialog. Applications should not assume the existence of * as a print dialog. Applications should not assume the existence of
* these dialogs, nor should an application assume anything about these * these dialogs, nor should an application assume anything about these
* dialogs such as component positions, <code>LayoutManager</code>s * dialogs such as component positions, {@code LayoutManager}s
* or serialization. * or serialization.
* *
* @see Frame#getFrames * @see Frame#getFrames
@ -1646,17 +1646,17 @@ public class Window extends Container implements Accessible {
* java.awt.Dialog.ModalExclusionType Dialog.ModalExclusionType} for * java.awt.Dialog.ModalExclusionType Dialog.ModalExclusionType} for
* possible modal exclusion types. * possible modal exclusion types.
* <p> * <p>
* If the given type is not supported, <code>NO_EXCLUDE</code> is used. * If the given type is not supported, {@code NO_EXCLUDE} is used.
* <p> * <p>
* Note: changing the modal exclusion type for a visible window may have no * Note: changing the modal exclusion type for a visible window may have no
* effect until it is hidden and then shown again. * effect until it is hidden and then shown again.
* *
* @param exclusionType the modal exclusion type for this window; a <code>null</code> * @param exclusionType the modal exclusion type for this window; a {@code null}
* value is equivivalent to {@link Dialog.ModalExclusionType#NO_EXCLUDE * value is equivivalent to {@link Dialog.ModalExclusionType#NO_EXCLUDE
* NO_EXCLUDE} * NO_EXCLUDE}
* @throws SecurityException if the calling thread does not have permission * @throws SecurityException if the calling thread does not have permission
* to set the modal exclusion property to the window with the given * to set the modal exclusion property to the window with the given
* <code>exclusionType</code> * {@code exclusionType}
* @see java.awt.Dialog.ModalExclusionType * @see java.awt.Dialog.ModalExclusionType
* @see java.awt.Window#getModalExclusionType * @see java.awt.Window#getModalExclusionType
* @see java.awt.Toolkit#isModalExclusionTypeSupported * @see java.awt.Toolkit#isModalExclusionTypeSupported
@ -1762,7 +1762,7 @@ public class Window extends Container implements Accessible {
/** /**
* Adds the specified window state listener to receive window * Adds the specified window state listener to receive window
* events from this window. If <code>l</code> is <code>null</code>, * events from this window. If {@code l} is {@code null},
* no exception is thrown and no action is performed. * no exception is thrown and no action is performed.
* <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads" * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
* >AWT Threading Issues</a> for details on AWT's threading model. * >AWT Threading Issues</a> for details on AWT's threading model.
@ -1821,7 +1821,7 @@ public class Window extends Container implements Accessible {
/** /**
* Removes the specified window state listener so that it no * Removes the specified window state listener so that it no
* longer receives window events from this window. If * longer receives window events from this window. If
* <code>l</code> is <code>null</code>, no exception is thrown and * {@code l} is {@code null}, no exception is thrown and
* no action is performed. * no action is performed.
* <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads" * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
* >AWT Threading Issues</a> for details on AWT's threading model. * >AWT Threading Issues</a> for details on AWT's threading model.
@ -1861,7 +1861,7 @@ public class Window extends Container implements Accessible {
* Returns an array of all the window listeners * Returns an array of all the window listeners
* registered on this window. * registered on this window.
* *
* @return all of this window's <code>WindowListener</code>s * @return all of this window's {@code WindowListener}s
* or an empty array if no window * or an empty array if no window
* listeners are currently registered * listeners are currently registered
* *
@ -1877,7 +1877,7 @@ public class Window extends Container implements Accessible {
* Returns an array of all the window focus listeners * Returns an array of all the window focus listeners
* registered on this window. * registered on this window.
* *
* @return all of this window's <code>WindowFocusListener</code>s * @return all of this window's {@code WindowFocusListener}s
* or an empty array if no window focus * or an empty array if no window focus
* listeners are currently registered * listeners are currently registered
* *
@ -1893,7 +1893,7 @@ public class Window extends Container implements Accessible {
* Returns an array of all the window state listeners * Returns an array of all the window state listeners
* registered on this window. * registered on this window.
* *
* @return all of this window's <code>WindowStateListener</code>s * @return all of this window's {@code WindowStateListener}s
* or an empty array if no window state * or an empty array if no window state
* listeners are currently registered * listeners are currently registered
* *
@ -1909,17 +1909,17 @@ public class Window extends Container implements Accessible {
/** /**
* Returns an array of all the objects currently registered * Returns an array of all the objects currently registered
* as <code><em>Foo</em>Listener</code>s * as <code><em>Foo</em>Listener</code>s
* upon this <code>Window</code>. * upon this {@code Window}.
* <code><em>Foo</em>Listener</code>s are registered using the * <code><em>Foo</em>Listener</code>s are registered using the
* <code>add<em>Foo</em>Listener</code> method. * <code>add<em>Foo</em>Listener</code> method.
* *
* <p> * <p>
* *
* You can specify the <code>listenerType</code> argument * You can specify the {@code listenerType} argument
* with a class literal, such as * with a class literal, such as
* <code><em>Foo</em>Listener.class</code>. * <code><em>Foo</em>Listener.class</code>.
* For example, you can query a * For example, you can query a
* <code>Window</code> <code>w</code> * {@code Window} {@code w}
* for its window listeners with the following code: * for its window listeners with the following code:
* *
* <pre>WindowListener[] wls = (WindowListener[])(w.getListeners(WindowListener.class));</pre> * <pre>WindowListener[] wls = (WindowListener[])(w.getListeners(WindowListener.class));</pre>
@ -1928,14 +1928,14 @@ public class Window extends Container implements Accessible {
* *
* @param listenerType the type of listeners requested; this parameter * @param listenerType the type of listeners requested; this parameter
* should specify an interface that descends from * should specify an interface that descends from
* <code>java.util.EventListener</code> * {@code java.util.EventListener}
* @return an array of all objects registered as * @return an array of all objects registered as
* <code><em>Foo</em>Listener</code>s on this window, * <code><em>Foo</em>Listener</code>s on this window,
* or an empty array if no such * or an empty array if no such
* listeners have been added * listeners have been added
* @exception ClassCastException if <code>listenerType</code> * @exception ClassCastException if {@code listenerType}
* doesn't specify a class or interface that implements * doesn't specify a class or interface that implements
* <code>java.util.EventListener</code> * {@code java.util.EventListener}
* @exception NullPointerException if {@code listenerType} is {@code null} * @exception NullPointerException if {@code listenerType} is {@code null}
* *
* @see #getWindowListeners * @see #getWindowListeners
@ -1991,10 +1991,10 @@ public class Window extends Container implements Accessible {
/** /**
* Processes events on this window. If the event is an * Processes events on this window. If the event is an
* <code>WindowEvent</code>, it invokes the * {@code WindowEvent}, it invokes the
* <code>processWindowEvent</code> method, else it invokes its * {@code processWindowEvent} method, else it invokes its
* superclass's <code>processEvent</code>. * superclass's {@code processEvent}.
* <p>Note that if the event parameter is <code>null</code> * <p>Note that if the event parameter is {@code null}
* the behavior is unspecified and may result in an * the behavior is unspecified and may result in an
* exception. * exception.
* *
@ -2033,10 +2033,10 @@ public class Window extends Container implements Accessible {
* following occurs: * following occurs:
* <ul> * <ul>
* <li>A WindowListener object is registered via * <li>A WindowListener object is registered via
* <code>addWindowListener</code> * {@code addWindowListener}
* <li>Window events are enabled via <code>enableEvents</code> * <li>Window events are enabled via {@code enableEvents}
* </ul> * </ul>
* <p>Note that if the event parameter is <code>null</code> * <p>Note that if the event parameter is {@code null}
* the behavior is unspecified and may result in an * the behavior is unspecified and may result in an
* exception. * exception.
* *
@ -2082,10 +2082,10 @@ public class Window extends Container implements Accessible {
* following occurs: * following occurs:
* <ul> * <ul>
* <li>a WindowFocusListener is registered via * <li>a WindowFocusListener is registered via
* <code>addWindowFocusListener</code> * {@code addWindowFocusListener}
* <li>Window focus events are enabled via <code>enableEvents</code> * <li>Window focus events are enabled via {@code enableEvents}
* </ul> * </ul>
* <p>Note that if the event parameter is <code>null</code> * <p>Note that if the event parameter is {@code null}
* the behavior is unspecified and may result in an * the behavior is unspecified and may result in an
* exception. * exception.
* *
@ -2111,17 +2111,17 @@ public class Window extends Container implements Accessible {
/** /**
* Processes window state event occuring on this window by * Processes window state event occuring on this window by
* dispatching them to any registered <code>WindowStateListener</code> * dispatching them to any registered {@code WindowStateListener}
* objects. * objects.
* NOTE: this method will not be called unless window state events * NOTE: this method will not be called unless window state events
* are enabled for this window. This happens when one of the * are enabled for this window. This happens when one of the
* following occurs: * following occurs:
* <ul> * <ul>
* <li>a <code>WindowStateListener</code> is registered via * <li>a {@code WindowStateListener} is registered via
* <code>addWindowStateListener</code> * {@code addWindowStateListener}
* <li>window state events are enabled via <code>enableEvents</code> * <li>window state events are enabled via {@code enableEvents}
* </ul> * </ul>
* <p>Note that if the event parameter is <code>null</code> * <p>Note that if the event parameter is {@code null}
* the behavior is unspecified and may result in an * the behavior is unspecified and may result in an
* exception. * exception.
* *
@ -2145,7 +2145,7 @@ public class Window extends Container implements Accessible {
/** /**
* Implements a debugging hook -- checks to see if * Implements a debugging hook -- checks to see if
* the user has typed <i>control-shift-F1</i>. If so, * the user has typed <i>control-shift-F1</i>. If so,
* the list of child windows is dumped to <code>System.out</code>. * the list of child windows is dumped to {@code System.out}.
* @param e the keyboard event * @param e the keyboard event
*/ */
void preProcessKeyEvent(KeyEvent e) { void preProcessKeyEvent(KeyEvent e) {
@ -2176,21 +2176,21 @@ public class Window extends Container implements Accessible {
* automatically become always-on-top. If a window ceases to be * automatically become always-on-top. If a window ceases to be
* always-on-top, the windows that it owns will no longer be * always-on-top, the windows that it owns will no longer be
* always-on-top. When an always-on-top window is sent {@link #toBack * always-on-top. When an always-on-top window is sent {@link #toBack
* toBack}, its always-on-top state is set to <code>false</code>. * toBack}, its always-on-top state is set to {@code false}.
* *
* <p> When this method is called on a window with a value of * <p> When this method is called on a window with a value of
* <code>true</code>, and the window is visible and the platform * {@code true}, and the window is visible and the platform
* supports always-on-top for this window, the window is immediately * supports always-on-top for this window, the window is immediately
* brought forward, "sticking" it in the top-most position. If the * brought forward, "sticking" it in the top-most position. If the
* window isn`t currently visible, this method sets the always-on-top * window isn`t currently visible, this method sets the always-on-top
* state to <code>true</code> but does not bring the window forward. * state to {@code true} but does not bring the window forward.
* When the window is later shown, it will be always-on-top. * When the window is later shown, it will be always-on-top.
* *
* <p> When this method is called on a window with a value of * <p> When this method is called on a window with a value of
* <code>false</code> the always-on-top state is set to normal. The * {@code false} the always-on-top state is set to normal. The
* window remains in the top-most position but it`s z-order can be * window remains in the top-most position but it`s z-order can be
* changed as for any other window. Calling this method with a value * changed as for any other window. Calling this method with a value
* of <code>false</code> on a window that has a normal state has no * of {@code false} on a window that has a normal state has no
* effect. Setting the always-on-top state to false has no effect on * effect. Setting the always-on-top state to false has no effect on
* the relative z-order of the windows if there are no other * the relative z-order of the windows if there are no other
* always-on-top windows. * always-on-top windows.
@ -2250,9 +2250,9 @@ public class Window extends Container implements Accessible {
* window. Some platforms may not support always-on-top windows, some * window. Some platforms may not support always-on-top windows, some
* may support only some kinds of top-level windows; for example, * may support only some kinds of top-level windows; for example,
* a platform may not support always-on-top modal dialogs. * a platform may not support always-on-top modal dialogs.
* @return <code>true</code>, if the always-on-top mode is * @return {@code true}, if the always-on-top mode is
* supported by the toolkit and for this window, * supported by the toolkit and for this window,
* <code>false</code>, if always-on-top mode is not supported * {@code false}, if always-on-top mode is not supported
* for this window or toolkit doesn't support always-on-top windows. * for this window or toolkit doesn't support always-on-top windows.
* @see #setAlwaysOnTop(boolean) * @see #setAlwaysOnTop(boolean)
* @see Toolkit#isAlwaysOnTopSupported * @see Toolkit#isAlwaysOnTopSupported
@ -2265,8 +2265,8 @@ public class Window extends Container implements Accessible {
/** /**
* Returns whether this window is an always-on-top window. * Returns whether this window is an always-on-top window.
* @return <code>true</code>, if the window is in always-on-top state, * @return {@code true}, if the window is in always-on-top state,
* <code>false</code> otherwise * {@code false} otherwise
* @see #setAlwaysOnTop * @see #setAlwaysOnTop
* @since 1.5 * @since 1.5
*/ */
@ -2294,7 +2294,7 @@ public class Window extends Container implements Accessible {
/** /**
* Returns the child Component of this Window that will receive the focus * Returns the child Component of this Window that will receive the focus
* when this Window is focused. If this Window is currently focused, this * when this Window is focused. If this Window is currently focused, this
* method returns the same Component as <code>getFocusOwner()</code>. If * method returns the same Component as {@code getFocusOwner()}. If
* this Window is not focused, then the child Component that most recently * this Window is not focused, then the child Component that most recently
* requested focus will be returned. If no child Component has ever * requested focus will be returned. If no child Component has ever
* requested focus, and this is a focusable Window, then this Window's * requested focus, and this is a focusable Window, then this Window's
@ -2359,8 +2359,8 @@ public class Window extends Container implements Accessible {
} }
/** /**
* Gets a focus traversal key for this Window. (See <code> * Gets a focus traversal key for this Window. (See {@code
* setFocusTraversalKeys</code> for a full description of each key.) * setFocusTraversalKeys} for a full description of each key.)
* <p> * <p>
* If the traversal key has not been explicitly set for this Window, * If the traversal key has not been explicitly set for this Window,
* then this Window's parent's traversal key is returned. If the * then this Window's parent's traversal key is returned. If the
@ -2419,10 +2419,10 @@ public class Window extends Container implements Accessible {
} }
/** /**
* Always returns <code>true</code> because all Windows must be roots of a * Always returns {@code true} because all Windows must be roots of a
* focus traversal cycle. * focus traversal cycle.
* *
* @return <code>true</code> * @return {@code true}
* @see #setFocusCycleRoot * @see #setFocusCycleRoot
* @see Container#setFocusTraversalPolicy * @see Container#setFocusTraversalPolicy
* @see Container#getFocusTraversalPolicy * @see Container#getFocusTraversalPolicy
@ -2433,10 +2433,10 @@ public class Window extends Container implements Accessible {
} }
/** /**
* Always returns <code>null</code> because Windows have no ancestors; they * Always returns {@code null} because Windows have no ancestors; they
* represent the top of the Component hierarchy. * represent the top of the Component hierarchy.
* *
* @return <code>null</code> * @return {@code null}
* @see Container#isFocusCycleRoot() * @see Container#isFocusCycleRoot()
* @since 1.4 * @since 1.4
*/ */
@ -2448,16 +2448,16 @@ public class Window extends Container implements Accessible {
* Returns whether this Window can become the focused Window, that is, * Returns whether this Window can become the focused Window, that is,
* whether this Window or any of its subcomponents can become the focus * whether this Window or any of its subcomponents can become the focus
* owner. For a Frame or Dialog to be focusable, its focusable Window state * owner. For a Frame or Dialog to be focusable, its focusable Window state
* must be set to <code>true</code>. For a Window which is not a Frame or * must be set to {@code true}. For a Window which is not a Frame or
* Dialog to be focusable, its focusable Window state must be set to * Dialog to be focusable, its focusable Window state must be set to
* <code>true</code>, its nearest owning Frame or Dialog must be * {@code true}, its nearest owning Frame or Dialog must be
* showing on the screen, and it must contain at least one Component in * showing on the screen, and it must contain at least one Component in
* its focus traversal cycle. If any of these conditions is not met, then * its focus traversal cycle. If any of these conditions is not met, then
* neither this Window nor any of its subcomponents can become the focus * neither this Window nor any of its subcomponents can become the focus
* owner. * owner.
* *
* @return <code>true</code> if this Window can be the focused Window; * @return {@code true} if this Window can be the focused Window;
* <code>false</code> otherwise * {@code false} otherwise
* @see #getFocusableWindowState * @see #getFocusableWindowState
* @see #setFocusableWindowState * @see #setFocusableWindowState
* @see #isShowing * @see #isShowing
@ -2497,16 +2497,16 @@ public class Window extends Container implements Accessible {
/** /**
* Returns whether this Window can become the focused Window if it meets * Returns whether this Window can become the focused Window if it meets
* the other requirements outlined in <code>isFocusableWindow</code>. If * the other requirements outlined in {@code isFocusableWindow}. If
* this method returns <code>false</code>, then * this method returns {@code false}, then
* <code>isFocusableWindow</code> will return <code>false</code> as well. * {@code isFocusableWindow} will return {@code false} as well.
* If this method returns <code>true</code>, then * If this method returns {@code true}, then
* <code>isFocusableWindow</code> may return <code>true</code> or * {@code isFocusableWindow} may return {@code true} or
* <code>false</code> depending upon the other requirements which must be * {@code false} depending upon the other requirements which must be
* met in order for a Window to be focusable. * met in order for a Window to be focusable.
* <p> * <p>
* By default, all Windows have a focusable Window state of * By default, all Windows have a focusable Window state of
* <code>true</code>. * {@code true}.
* *
* @return whether this Window can be the focused Window * @return whether this Window can be the focused Window
* @see #isFocusableWindow * @see #isFocusableWindow
@ -2521,25 +2521,25 @@ public class Window extends Container implements Accessible {
/** /**
* Sets whether this Window can become the focused Window if it meets * Sets whether this Window can become the focused Window if it meets
* the other requirements outlined in <code>isFocusableWindow</code>. If * the other requirements outlined in {@code isFocusableWindow}. If
* this Window's focusable Window state is set to <code>false</code>, then * this Window's focusable Window state is set to {@code false}, then
* <code>isFocusableWindow</code> will return <code>false</code>. If this * {@code isFocusableWindow} will return {@code false}. If this
* Window's focusable Window state is set to <code>true</code>, then * Window's focusable Window state is set to {@code true}, then
* <code>isFocusableWindow</code> may return <code>true</code> or * {@code isFocusableWindow} may return {@code true} or
* <code>false</code> depending upon the other requirements which must be * {@code false} depending upon the other requirements which must be
* met in order for a Window to be focusable. * met in order for a Window to be focusable.
* <p> * <p>
* Setting a Window's focusability state to <code>false</code> is the * Setting a Window's focusability state to {@code false} is the
* standard mechanism for an application to identify to the AWT a Window * standard mechanism for an application to identify to the AWT a Window
* which will be used as a floating palette or toolbar, and thus should be * which will be used as a floating palette or toolbar, and thus should be
* a non-focusable Window. * a non-focusable Window.
* *
* Setting the focusability state on a visible <code>Window</code> * Setting the focusability state on a visible {@code Window}
* can have a delayed effect on some platforms &#151; the actual * can have a delayed effect on some platforms &#151; the actual
* change may happen only when the <code>Window</code> becomes * change may happen only when the {@code Window} becomes
* hidden and then visible again. To ensure consistent behavior * hidden and then visible again. To ensure consistent behavior
* across platforms, set the <code>Window</code>'s focusable state * across platforms, set the {@code Window}'s focusable state
* when the <code>Window</code> is invisible and then show it. * when the {@code Window} is invisible and then show it.
* *
* @param focusableWindowState whether this Window can be the focused * @param focusableWindowState whether this Window can be the focused
* Window * Window
@ -2726,7 +2726,7 @@ public class Window extends Container implements Accessible {
/** /**
* @deprecated As of JDK version 1.1 * @deprecated As of JDK version 1.1
* replaced by <code>dispatchEvent(AWTEvent)</code>. * replaced by {@code dispatchEvent(AWTEvent)}.
*/ */
@Deprecated @Deprecated
public boolean postEvent(Event e) { public boolean postEvent(Event e) {
@ -2876,22 +2876,22 @@ public class Window extends Container implements Accessible {
/** /**
* Writes default serializable fields to stream. Writes * Writes default serializable fields to stream. Writes
* a list of serializable <code>WindowListener</code>s and * a list of serializable {@code WindowListener}s and
* <code>WindowFocusListener</code>s as optional data. * {@code WindowFocusListener}s as optional data.
* Writes a list of child windows as optional data. * Writes a list of child windows as optional data.
* Writes a list of icon images as optional data * Writes a list of icon images as optional data
* *
* @param s the <code>ObjectOutputStream</code> to write * @param s the {@code ObjectOutputStream} to write
* @serialData <code>null</code> terminated sequence of * @serialData {@code null} terminated sequence of
* 0 or more pairs; the pair consists of a <code>String</code> * 0 or more pairs; the pair consists of a {@code String}
* and and <code>Object</code>; the <code>String</code> * and {@code Object}; the {@code String}
* indicates the type of object and is one of the following: * indicates the type of object and is one of the following:
* <code>windowListenerK</code> indicating a * {@code windowListenerK} indicating a
* <code>WindowListener</code> object; * {@code WindowListener} object;
* <code>windowFocusWindowK</code> indicating a * {@code windowFocusWindowK} indicating a
* <code>WindowFocusListener</code> object; * {@code WindowFocusListener} object;
* <code>ownedWindowK</code> indicating a child * {@code ownedWindowK} indicating a child
* <code>Window</code> object * {@code Window} object
* *
* @see AWTEventMulticaster#save(java.io.ObjectOutputStream, java.lang.String, java.util.EventListener) * @see AWTEventMulticaster#save(java.io.ObjectOutputStream, java.lang.String, java.util.EventListener)
* @see Component#windowListenerK * @see Component#windowListenerK
@ -3029,16 +3029,16 @@ public class Window extends Container implements Accessible {
} }
/** /**
* Reads the <code>ObjectInputStream</code> and an optional * Reads the {@code ObjectInputStream} and an optional
* list of listeners to receive various events fired by * list of listeners to receive various events fired by
* the component; also reads a list of * the component; also reads a list of
* (possibly <code>null</code>) child windows. * (possibly {@code null}) child windows.
* Unrecognized keys or values will be ignored. * Unrecognized keys or values will be ignored.
* *
* @param s the <code>ObjectInputStream</code> to read * @param s the {@code ObjectInputStream} to read
* @exception HeadlessException if * @exception HeadlessException if
* <code>GraphicsEnvironment.isHeadless</code> returns * {@code GraphicsEnvironment.isHeadless} returns
* <code>true</code> * {@code true}
* @see java.awt.GraphicsEnvironment#isHeadless * @see java.awt.GraphicsEnvironment#isHeadless
* @see #writeObject * @see #writeObject
*/ */
@ -3100,7 +3100,7 @@ public class Window extends Container implements Accessible {
/** /**
* This class implements accessibility support for the * This class implements accessibility support for the
* <code>Window</code> class. It provides an implementation of the * {@code Window} class. It provides an implementation of the
* Java Accessibility API appropriate to window user-interface elements. * Java Accessibility API appropriate to window user-interface elements.
* @since 1.3 * @since 1.3
*/ */
@ -3186,7 +3186,7 @@ public class Window extends Container implements Accessible {
* not changed. * not changed.
* <p> * <p>
* <b>Note</b>: If the lower edge of the window is out of the screen, * <b>Note</b>: If the lower edge of the window is out of the screen,
* then the window is placed to the side of the <code>Component</code> * then the window is placed to the side of the {@code Component}
* that is closest to the center of the screen. So if the * that is closest to the center of the screen. So if the
* component is on the right part of the screen, the window * component is on the right part of the screen, the window
* is placed to its left, and vice versa. * is placed to its left, and vice versa.
@ -3289,7 +3289,7 @@ public class Window extends Container implements Accessible {
* Creates a new strategy for multi-buffering on this component. * Creates a new strategy for multi-buffering on this component.
* Multi-buffering is useful for rendering performance. This method * Multi-buffering is useful for rendering performance. This method
* attempts to create the best strategy available with the number of * attempts to create the best strategy available with the number of
* buffers supplied. It will always create a <code>BufferStrategy</code> * buffers supplied. It will always create a {@code BufferStrategy}
* with that number of buffers. * with that number of buffers.
* A page-flipping strategy is attempted first, then a blitting strategy * A page-flipping strategy is attempted first, then a blitting strategy
* using accelerated buffers. Finally, an unaccelerated blitting * using accelerated buffers. Finally, an unaccelerated blitting
@ -3318,13 +3318,13 @@ public class Window extends Container implements Accessible {
* is called, the existing buffer strategy for this component is discarded. * is called, the existing buffer strategy for this component is discarded.
* @param numBuffers number of buffers to create, including the front buffer * @param numBuffers number of buffers to create, including the front buffer
* @param caps the required capabilities for creating the buffer strategy; * @param caps the required capabilities for creating the buffer strategy;
* cannot be <code>null</code> * cannot be {@code null}
* @exception AWTException if the capabilities supplied could not be * @exception AWTException if the capabilities supplied could not be
* supported or met; this may happen, for example, if there is not enough * supported or met; this may happen, for example, if there is not enough
* accelerated memory currently available, or if page flipping is specified * accelerated memory currently available, or if page flipping is specified
* but not possible. * but not possible.
* @exception IllegalArgumentException if numBuffers is less than 1, or if * @exception IllegalArgumentException if numBuffers is less than 1, or if
* caps is <code>null</code> * caps is {@code null}
* @see #getBufferStrategy * @see #getBufferStrategy
* @since 1.4 * @since 1.4
*/ */
@ -3334,8 +3334,8 @@ public class Window extends Container implements Accessible {
} }
/** /**
* Returns the <code>BufferStrategy</code> used by this component. This * Returns the {@code BufferStrategy} used by this component. This
* method will return null if a <code>BufferStrategy</code> has not yet * method will return null if a {@code BufferStrategy} has not yet
* been created or has been disposed. * been created or has been disposed.
* *
* @return the buffer strategy used by this component * @return the buffer strategy used by this component
@ -3376,7 +3376,7 @@ public class Window extends Container implements Accessible {
/** /**
* Sets whether this Window should appear at the default location for the * Sets whether this Window should appear at the default location for the
* native windowing system or at the current location (returned by * native windowing system or at the current location (returned by
* <code>getLocation</code>) the next time the Window is made visible. * {@code getLocation}) the next time the Window is made visible.
* This behavior resembles a native window shown without programmatically * This behavior resembles a native window shown without programmatically
* setting its location. Most windowing systems cascade windows if their * setting its location. Most windowing systems cascade windows if their
* locations are not explicitly set. The actual location is determined once the * locations are not explicitly set. The actual location is determined once the
@ -3386,8 +3386,8 @@ public class Window extends Container implements Accessible {
* "java.awt.Window.locationByPlatform" to "true", though calls to this method * "java.awt.Window.locationByPlatform" to "true", though calls to this method
* take precedence. * take precedence.
* <p> * <p>
* Calls to <code>setVisible</code>, <code>setLocation</code> and * Calls to {@code setVisible}, {@code setLocation} and
* <code>setBounds</code> after calling <code>setLocationByPlatform</code> clear * {@code setBounds} after calling {@code setLocationByPlatform} clear
* this property of the Window. * this property of the Window.
* <p> * <p>
* For example, after the following code is executed: * For example, after the following code is executed:
@ -3397,7 +3397,7 @@ public class Window extends Container implements Accessible {
* boolean flag = isLocationByPlatform(); * boolean flag = isLocationByPlatform();
* </blockquote></pre> * </blockquote></pre>
* The window will be shown at platform's default location and * The window will be shown at platform's default location and
* <code>flag</code> will be <code>false</code>. * {@code flag} will be {@code false}.
* <p> * <p>
* In the following sample: * In the following sample:
* <pre><blockquote> * <pre><blockquote>
@ -3406,13 +3406,13 @@ public class Window extends Container implements Accessible {
* boolean flag = isLocationByPlatform(); * boolean flag = isLocationByPlatform();
* setVisible(true); * setVisible(true);
* </blockquote></pre> * </blockquote></pre>
* The window will be shown at (10, 10) and <code>flag</code> will be * The window will be shown at (10, 10) and {@code flag} will be
* <code>false</code>. * {@code false}.
* *
* @param locationByPlatform <code>true</code> if this Window should appear * @param locationByPlatform {@code true} if this Window should appear
* at the default location, <code>false</code> if at the current location * at the default location, {@code false} if at the current location
* @throws <code>IllegalComponentStateException</code> if the window * @throws {@code IllegalComponentStateException} if the window
* is showing on screen and locationByPlatform is <code>true</code>. * is showing on screen and locationByPlatform is {@code true}.
* @see #setLocation * @see #setLocation
* @see #isShowing * @see #isShowing
* @see #setVisible * @see #setVisible
@ -3430,9 +3430,9 @@ public class Window extends Container implements Accessible {
} }
/** /**
* Returns <code>true</code> if this Window will appear at the default location * Returns {@code true} if this Window will appear at the default location
* for the native windowing system the next time this Window is made visible. * for the native windowing system the next time this Window is made visible.
* This method always returns <code>false</code> if the Window is showing on the * This method always returns {@code false} if the Window is showing on the
* screen. * screen.
* *
* @return whether this Window will appear at the default location * @return whether this Window will appear at the default location
@ -3509,8 +3509,8 @@ public class Window extends Container implements Accessible {
/** /**
* Determines whether this component will be displayed on the screen. * Determines whether this component will be displayed on the screen.
* @return <code>true</code> if the component and all of its ancestors * @return {@code true} if the component and all of its ancestors
* until a toplevel window are visible, <code>false</code> otherwise * until a toplevel window are visible, {@code false} otherwise
*/ */
boolean isRecursivelyVisible() { boolean isRecursivelyVisible() {
// 5079694 fix: for a toplevel to be displayed, its parent doesn't have to be visible. // 5079694 fix: for a toplevel to be displayed, its parent doesn't have to be visible.