+ * A "top-level window" is an instance of the {@code Window} class (or its + * descendant, such as {@code JFrame}). + *
+ * Some of the mentioned features may not be supported by the native platform. + * To determine whether a particular feature is supported, the user must use + * the {@code isTranslucencySupported()} method of the class passing a desired + * translucency kind (a member of the {@code Translucency} enum) as an + * argument. + *
+ * The per-pixel alpha feature also requires the user to create her/his + * windows using a translucency-capable graphics configuration. + * The {@code isTranslucencyCapable()} method must + * be used to verify whether any given GraphicsConfiguration supports + * the trasnlcency effects. + *
* WARNING: This class is an implementation detail and only meant * for limited use outside of the core platform. This API may change * drastically between update release, and it may even be @@ -50,6 +70,344 @@ private AWTUtilities() { } + /** Kinds of translucency supported by the underlying system. + * @see #isTranslucencySupported + */ + public static enum Translucency { + /** + * Represents support in the underlying system for windows each pixel + * of which is guaranteed to be either completely opaque, with + * an alpha value of 1.0, or completely transparent, with an alpha + * value of 0.0. + */ + PERPIXEL_TRANSPARENT, + + /** + * Represents support in the underlying system for windows all of + * the pixels of which have the same alpha value between or including + * 0.0 and 1.0. + */ + TRANSLUCENT, + + /** + * Represents support in the underlying system for windows that + * contain or might contain pixels with arbitrary alpha values + * between and including 0.0 and 1.0. + */ + PERPIXEL_TRANSLUCENT; + } + + + /** + * Returns whether the given level of translucency is supported by + * the underlying system. + * + * Note that this method may sometimes return the value + * indicating that the particular level is supported, but + * the native windowing system may still not support the + * given level of translucency (due to the bugs in + * the windowing system). + * + * @param translucencyKind a kind of translucency support + * (either PERPIXEL_TRANSPARENT, + * TRANSLUCENT, or PERPIXEL_TRANSLUCENT) + * @return whether the given translucency kind is supported + */ + public static boolean isTranslucencySupported(Translucency translucencyKind) { + switch (translucencyKind) { + case PERPIXEL_TRANSPARENT: + return isWindowShapingSupported(); + case TRANSLUCENT: + return isWindowOpacitySupported(); + case PERPIXEL_TRANSLUCENT: + return isWindowTranslucencySupported(); + } + return false; + } + + + /** + * Returns whether the windowing system supports changing the opacity + * value of top-level windows. + * Note that this method may sometimes return true, but the native + * windowing system may still not support the concept of + * translucency (due to the bugs in the windowing system). + */ + private static boolean isWindowOpacitySupported() { + Toolkit curToolkit = Toolkit.getDefaultToolkit(); + if (!(curToolkit instanceof SunToolkit)) { + return false; + } + return ((SunToolkit)curToolkit).isWindowOpacitySupported(); + } + + /** + * Set the opacity of the window. The opacity is at the range [0..1]. + * Note that setting the opacity level of 0 may or may not disable + * the mouse event handling on this window. This is + * a platform-dependent behavior. + * + * In order for this method to enable the translucency effect, + * the isTranslucencySupported() method should indicate that the + * TRANSLUCENT level of translucency is supported. + * + *
Also note that the window must not be in the full-screen mode + * when setting the opacity value < 1.0f. Otherwise + * the IllegalArgumentException is thrown. + * + * @param window the window to set the opacity level to + * @param opacity the opacity level to set to the window + * @throws NullPointerException if the window argument is null + * @throws IllegalArgumentException if the opacity is out of + * the range [0..1] + * @throws IllegalArgumentException if the window is in full screen mode, + * and the opacity is less than 1.0f + * @throws UnsupportedOperationException if the TRANSLUCENT translucency + * kind is not supported + */ + public static void setWindowOpacity(Window window, float opacity) { + if (window == null) { + throw new NullPointerException( + "The window argument should not be null."); + } + + AWTAccessor.getWindowAccessor().setOpacity(window, opacity); + } + + /** + * Get the opacity of the window. If the opacity has not + * yet being set, this method returns 1.0. + * + * @param window the window to get the opacity level from + * @throws NullPointerException if the window argument is null + */ + public static float getWindowOpacity(Window window) { + if (window == null) { + throw new NullPointerException( + "The window argument should not be null."); + } + + return AWTAccessor.getWindowAccessor().getOpacity(window); + } + + /** + * Returns whether the windowing system supports changing the shape + * of top-level windows. + * Note that this method may sometimes return true, but the native + * windowing system may still not support the concept of + * shaping (due to the bugs in the windowing system). + */ + public static boolean isWindowShapingSupported() { + Toolkit curToolkit = Toolkit.getDefaultToolkit(); + if (!(curToolkit instanceof SunToolkit)) { + return false; + } + return ((SunToolkit)curToolkit).isWindowShapingSupported(); + } + + /** + * Returns an object that implements the Shape interface and represents + * the shape previously set with the call to the setWindowShape() method. + * If no shape has been set yet, or the shape has been reset to null, + * this method returns null. + * + * @param window the window to get the shape from + * @return the current shape of the window + * @throws NullPointerException if the window argument is null + */ + public static Shape getWindowShape(Window window) { + if (window == null) { + throw new NullPointerException( + "The window argument should not be null."); + } + return AWTAccessor.getWindowAccessor().getShape(window); + } + + /** + * Sets a shape for the given window. + * If the shape argument is null, this methods restores + * the default shape making the window rectangular. + *
Note that in order to set a shape, the window must be undecorated. + * If the window is decorated, this method ignores the {@code shape} + * argument and resets the shape to null. + *
Also note that the window must not be in the full-screen mode + * when setting a non-null shape. Otherwise the IllegalArgumentException + * is thrown. + *
Depending on the platform, the method may return without + * effecting the shape of the window if the window has a non-null warning + * string ({@link Window#getWarningString()}). In this case the passed + * shape object is ignored. + * + * @param window the window to set the shape to + * @param shape the shape to set to the window + * @throws NullPointerException if the window argument is null + * @throws IllegalArgumentException if the window is in full screen mode, + * and the shape is not null + * @throws UnsupportedOperationException if the PERPIXEL_TRANSPARENT + * translucency kind is not supported + */ + public static void setWindowShape(Window window, Shape shape) { + if (window == null) { + throw new NullPointerException( + "The window argument should not be null."); + } + AWTAccessor.getWindowAccessor().setShape(window, shape); + } + + private static boolean isWindowTranslucencySupported() { + /* + * Per-pixel alpha is supported if all the conditions are TRUE: + * 1. The toolkit is a sort of SunToolkit + * 2. The toolkit supports translucency in general + * (isWindowTranslucencySupported()) + * 3. There's at least one translucency-capable + * GraphicsConfiguration + */ + + Toolkit curToolkit = Toolkit.getDefaultToolkit(); + if (!(curToolkit instanceof SunToolkit)) { + return false; + } + + if (!((SunToolkit)curToolkit).isWindowTranslucencySupported()) { + return false; + } + + GraphicsEnvironment env = + GraphicsEnvironment.getLocalGraphicsEnvironment(); + + // If the default GC supports translucency return true. + // It is important to optimize the verification this way, + // see CR 6661196 for more details. + if (isTranslucencyCapable(env.getDefaultScreenDevice() + .getDefaultConfiguration())) + { + return true; + } + + // ... otherwise iterate through all the GCs. + GraphicsDevice[] devices = env.getScreenDevices(); + + for (int i = 0; i < devices.length; i++) { + GraphicsConfiguration[] configs = devices[i].getConfigurations(); + for (int j = 0; j < configs.length; j++) { + if (isTranslucencyCapable(configs[j])) { + return true; + } + } + } + + return false; + } + + /** + * Enables the per-pixel alpha support for the given window. + * Once the window becomes non-opaque (the isOpaque is set to false), + * the drawing sub-system is starting to respect the alpha value of each + * separate pixel. If a pixel gets painted with alpha color component + * equal to zero, it becomes visually transparent, if the alpha of the + * pixel is equal to 255, the pixel is fully opaque. Interim values + * of the alpha color component make the pixel semi-transparent (i.e. + * translucent). + *
Note that in order for the window to support the per-pixel alpha + * mode, the window must be created using the GraphicsConfiguration + * for which the {@link #isTranslucencyCapable} + * method returns true. + *
Also note that some native systems enable the per-pixel translucency + * mode for any window created using the translucency-compatible + * graphics configuration. However, it is highly recommended to always + * invoke the setWindowOpaque() method for these windows, at least for + * the sake of cross-platform compatibility reasons. + *
Also note that the window must not be in the full-screen mode + * when making it non-opaque. Otherwise the IllegalArgumentException + * is thrown. + *
If the window is a {@code Frame} or a {@code Dialog}, the window must + * be undecorated prior to enabling the per-pixel translucency effect (see + * {@link Frame#setUndecorated()} and/or {@link Dialog#setUndecorated()}). + * If the window becomes decorated through a subsequent call to the + * corresponding {@code setUndecorated()} method, the per-pixel + * translucency effect will be disabled and the opaque property reset to + * {@code true}. + *
Depending on the platform, the method may return without + * effecting the opaque property of the window if the window has a non-null + * warning string ({@link Window#getWarningString()}). In this case + * the passed 'isOpaque' value is ignored. + * + * @param window the window to set the shape to + * @param isOpaque whether the window must be opaque (true), + * or translucent (false) + * @throws NullPointerException if the window argument is null + * @throws IllegalArgumentException if the window uses + * a GraphicsConfiguration for which the + * {@code isTranslucencyCapable()} + * method returns false + * @throws IllegalArgumentException if the window is in full screen mode, + * and the isOpaque is false + * @throws IllegalArgumentException if the window is decorated and the + * isOpaque argument is {@code false}. + * @throws UnsupportedOperationException if the PERPIXEL_TRANSLUCENT + * translucency kind is not supported + */ + public static void setWindowOpaque(Window window, boolean isOpaque) { + if (window == null) { + throw new NullPointerException( + "The window argument should not be null."); + } + if (!isOpaque && !isTranslucencySupported(Translucency.PERPIXEL_TRANSLUCENT)) { + throw new UnsupportedOperationException( + "The PERPIXEL_TRANSLUCENT translucency kind is not supported"); + } + AWTAccessor.getWindowAccessor().setOpaque(window, isOpaque); + } + + /** + * Returns whether the window is opaque or translucent. + * + * @param window the window to set the shape to + * @return whether the window is currently opaque (true) + * or translucent (false) + * @throws NullPointerException if the window argument is null + */ + public static boolean isWindowOpaque(Window window) { + if (window == null) { + throw new NullPointerException( + "The window argument should not be null."); + } + + return AWTAccessor.getWindowAccessor().isOpaque(window); + } + + /** + * Verifies whether a given GraphicsConfiguration supports + * the PERPIXEL_TRANSLUCENT kind of translucency. + * All windows that are intended to be used with the {@link #setWindowOpaque} + * method must be created using a GraphicsConfiguration for which this method + * returns true. + *
Note that some native systems enable the per-pixel translucency + * mode for any window created using a translucency-capable + * graphics configuration. However, it is highly recommended to always + * invoke the setWindowOpaque() method for these windows, at least + * for the sake of cross-platform compatibility reasons. + * + * @param gc GraphicsConfiguration + * @throws NullPointerException if the gc argument is null + * @return whether the given GraphicsConfiguration supports + * the translucency effects. + */ + public static boolean isTranslucencyCapable(GraphicsConfiguration gc) { + if (gc == null) { + throw new NullPointerException("The gc argument should not be null"); + } + /* + return gc.isTranslucencyCapable(); + */ + Toolkit curToolkit = Toolkit.getDefaultToolkit(); + if (!(curToolkit instanceof SunToolkit)) { + return false; + } + return ((SunToolkit)curToolkit).isTranslucencyCapable(gc); + } + /** * Sets a 'mixing-cutout' shape for the given component. * diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/com/sun/awt/SecurityWarning.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/src/share/classes/com/sun/awt/SecurityWarning.java Thu Apr 09 13:12:58 2009 -0700 @@ -0,0 +1,169 @@ +/* + * Copyright 2008-2009 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Sun designates this + * particular file as subject to the "Classpath" exception as provided + * by Sun in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +package com.sun.awt; + +import java.awt.*; +import java.awt.geom.*; + +import sun.awt.AWTAccessor; + + +/** + * Security Warning control interface. + * + * This class provides a couple of methods that help a developer relocate + * the AWT security warning to an appropriate position relative to the current + * window size. A "top-level window" is an instance of the {@code Window} + * class (or its descendant, such as {@code JFrame}). The security warning + * is applied to all windows created by an untrusted code. All such windows + * have a non-null "warning string" (see {@link Window#getWarningString()}). + *
+ * WARNING: This class is an implementation detail and only meant + * for limited use outside of the core platform. This API may change + * drastically between update release, and it may even be + * removed or be moved to some other packages or classes. + */ +public final class SecurityWarning { + + /** + * The SecurityWarning class should not be instantiated + */ + private SecurityWarning() { + } + + /** + * Gets the size of the security warning. + * + * The returned value is not valid until the peer has been created. Before + * invoking this method a developer must call the {@link Window#pack()}, + * {@link Window#setVisible()}, or some other method that creates the peer. + * + * @param window the window to get the security warning size for + * + * @throws NullPointerException if the window argument is null + * @throws IllegalArgumentException if the window is trusted (i.e. + * the {@code getWarningString()} returns null) + */ + public static Dimension getSize(Window window) { + if (window == null) { + throw new NullPointerException( + "The window argument should not be null."); + } + if (window.getWarningString() == null) { + throw new IllegalArgumentException( + "The window must have a non-null warning string."); + } + // We don't check for a non-null peer since it may be destroyed + // after assigning a valid value to the security warning size. + + return AWTAccessor.getWindowAccessor().getSecurityWarningSize(window); + } + + /** + * Sets the position of the security warning. + *
+ * The {@code alignmentX} and {@code alignmentY} arguments specify the + * origin of the coordinate system used to calculate the position of the + * security warning. The values must be in the range [0.0f...1.0f]. The + * {@code 0.0f} value represents the left (top) edge of the rectangular + * bounds of the window. The {@code 1.0f} value represents the right + * (bottom) edge of the bounds. Whenever the size of the window changes, + * the origin of the coordinate system gets relocated accordingly. For + * convenience a developer may use the {@code Component.*_ALIGNMENT} + * constants to pass predefined values for these arguments. + *
+ * The {@code point} argument specifies the location of the security + * warning in the coordinate system described above. If both {@code x} and + * {@code y} coordinates of the point are equal to zero, the warning will + * be located right in the origin of the coordinate system. On the other + * hand, if both {@code alignmentX} and {@code alignmentY} are equal to + * zero (i.e. the origin of the coordinate system is placed at the top-left + * corner of the window), then the {@code point} argument represents the + * absolute location of the security warning relative to the location of + * the window. The "absolute" in this case means that the position of the + * security warning is not effected by resizing of the window. + *
+ * Note that the security warning managment code guarantees that: + *
+ * The default position of the security warning is in the upper-right + * corner of the window, two pixels to the right from the right edge. This + * corresponds to the following arguments passed to this method: + *
java.awt.event.KeyEvent.VK_TAB
* java.awt.event.KeyEvent.VK_SPACE
*
+ * Alternatively, the key code may be obtained by calling
+ * java.awt.event.KeyEvent.getExtendedKeyCodeForChar.
+ *
* The modifiers consist of any combination of:BufferStrategy object
@@ -799,8 +799,24 @@
}
}
+ // Whether this Component has had the background erase flag
+ // specified via SunToolkit.disableBackgroundErase(). This is
+ // needed in order to make this function work on X11 platforms,
+ // where currently there is no chance to interpose on the creation
+ // of the peer and therefore the call to XSetBackground.
+ transient boolean backgroundEraseDisabled;
+
static {
AWTAccessor.setComponentAccessor(new AWTAccessor.ComponentAccessor() {
+ public void setBackgroundEraseDisabled(Component comp, boolean disabled) {
+ comp.backgroundEraseDisabled = disabled;
+ }
+ public boolean getBackgroundEraseDisabled(Component comp) {
+ return comp.backgroundEraseDisabled;
+ }
+ public Rectangle getBounds(Component comp) {
+ return new Rectangle(comp.x, comp.y, comp.width, comp.height);
+ }
public void setMixingCutoutShape(Component comp, Shape shape) {
Region region = shape == null ? null :
Region.getInstance(shape, null);
@@ -829,6 +845,22 @@
}
}
}
+
+ public void setGraphicsConfiguration(Component comp,
+ GraphicsConfiguration gc)
+ {
+ comp.setGraphicsConfiguration(gc);
+ }
+ public boolean requestFocus(Component comp, CausedFocusEvent.Cause cause) {
+ return comp.requestFocus(cause);
+ }
+ public boolean canBeFocusOwner(Component comp) {
+ return comp.canBeFocusOwner();
+ }
+
+ public boolean isVisible_NoClientCode(Component comp) {
+ return comp.isVisible_NoClientCode();
+ }
});
}
@@ -996,50 +1028,21 @@
*/
public GraphicsConfiguration getGraphicsConfiguration() {
synchronized(getTreeLock()) {
- if (graphicsConfig != null) {
- return graphicsConfig;
- } else if (getParent() != null) {
- return getParent().getGraphicsConfiguration();
- } else {
- return null;
- }
+ return getGraphicsConfiguration_NoClientCode();
}
}
final GraphicsConfiguration getGraphicsConfiguration_NoClientCode() {
- GraphicsConfiguration graphicsConfig = this.graphicsConfig;
- Container parent = this.parent;
- if (graphicsConfig != null) {
- return graphicsConfig;
- } else if (parent != null) {
- return parent.getGraphicsConfiguration_NoClientCode();
- } else {
- return null;
- }
- }
-
- /**
- * Resets this Component's
- * GraphicsConfiguration back to a default
- * value. For most componenets, this is null.
- * Called from the Toolkit thread, so NO CLIENT CODE.
- */
- void resetGC() {
+ return graphicsConfig;
+ }
+
+ void setGraphicsConfiguration(GraphicsConfiguration gc) {
synchronized(getTreeLock()) {
- graphicsConfig = null;
- }
- }
-
- /*
- * Not called on Component, but needed for Canvas and Window
- */
- void setGCFromPeer() {
- synchronized(getTreeLock()) {
- if (peer != null) { // can't imagine how this will be false,
- // but just in case
- graphicsConfig = peer.getGraphicsConfiguration();
- } else {
- graphicsConfig = null;
+ graphicsConfig = gc;
+
+ ComponentPeer peer = getPeer();
+ if (peer != null) {
+ peer.updateGraphicsData(gc);
}
}
}
@@ -6663,23 +6666,7 @@
// Update stacking order
- if (parent != null && parent.peer != null) {
- ContainerPeer parentContPeer = (ContainerPeer) parent.peer;
- // if our parent is lightweight and we are not
- // we should call restack on nearest heavyweight
- // container.
- if (parentContPeer instanceof LightweightPeer
- && ! (peer instanceof LightweightPeer))
- {
- Container hwParent = getNativeContainer();
- if (hwParent != null && hwParent.peer != null) {
- parentContPeer = (ContainerPeer) hwParent.peer;
- }
- }
- if (parentContPeer.isRestackSupported()) {
- parentContPeer.restack();
- }
- }
+ peer.setZOrder(getHWPeerAboveMe());
if (!isAddNotifyComplete) {
mixOnShowing();
@@ -7170,8 +7157,8 @@
requestFocusHelper(false, true);
}
- void requestFocus(CausedFocusEvent.Cause cause) {
- requestFocusHelper(false, true, cause);
+ boolean requestFocus(CausedFocusEvent.Cause cause) {
+ return requestFocusHelper(false, true, cause);
}
/**
@@ -7456,7 +7443,7 @@
// sometimes most recent focus owner may be null, but focus owner is not
// e.g. we reset most recent focus owner if user removes focus owner
focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
- if (focusOwner != null && getContainingWindow(focusOwner) != window) {
+ if (focusOwner != null && focusOwner.getContainingWindow() != window) {
focusOwner = null;
}
}
@@ -8689,30 +8676,8 @@
* null, if component is not a part of window hierarchy
*/
Window getContainingWindow() {
- return getContainingWindow(this);
- }
- /**
- * Returns the Window ancestor of the component comp.
- * @return Window ancestor of the component or component by itself if it is Window;
- * null, if component is not a part of window hierarchy
- */
- static Window getContainingWindow(Component comp) {
- while (comp != null && !(comp instanceof Window)) {
- comp = comp.getParent();
- }
-
- return (Window)comp;
- }
-
-
-
-
-
-
-
-
-
-
+ return SunToolkit.getContainingWindow(this);
+ }
/**
* Initialize JNI field and method IDs
@@ -9575,6 +9540,27 @@
return nextAbove < 0 ? -1 : nextAbove;
}
+ final ComponentPeer getHWPeerAboveMe() {
+ checkTreeLock();
+
+ Container cont = getContainer();
+ int indexAbove = getSiblingIndexAbove();
+
+ while (cont != null) {
+ for (int i = indexAbove; i > -1; i--) {
+ Component comp = cont.getComponent(i);
+ if (comp != null && comp.isDisplayable() && !comp.isLightweight()) {
+ return comp.getPeer();
+ }
+ }
+
+ indexAbove = cont.getSiblingIndexAbove();
+ cont = cont.getContainer();
+ }
+
+ return null;
+ }
+
final int getSiblingIndexBelow() {
checkTreeLock();
Container parent = getContainer();
@@ -9827,4 +9813,29 @@
}
// ****************** END OF MIXING CODE ********************************
+
+ private static boolean doesClassImplement(Class cls, String interfaceName) {
+ if (cls == null) return false;
+
+ for (Class c : cls.getInterfaces()) {
+ if (c.getName().equals(interfaceName)) {
+ return true;
+ }
+ }
+ return doesClassImplement(cls.getSuperclass(), interfaceName);
+ }
+
+ /**
+ * Checks that the given object implements the given interface.
+ * @param obj Object to be checked
+ * @param interfaceName The name of the interface. Must be fully-qualified interface name.
+ * @return true, if this object implements the given interface,
+ * false, otherwise, or if obj or interfaceName is null
+ */
+ static boolean doesImplement(Object obj, String interfaceName) {
+ if (obj == null) return false;
+ if (interfaceName == null) return false;
+
+ return doesClassImplement(obj.getClass(), interfaceName);
+ }
}
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/java/awt/Container.java
--- a/jdk/src/share/classes/java/awt/Container.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/java/awt/Container.java Thu Apr 09 13:12:58 2009 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1995-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1995-2009 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -167,6 +167,9 @@
transient int listeningBoundsChildren;
transient int descendantsCount;
+ /* Non-opaque window support -- see Window.setLayersOpaque */
+ transient Color preserveBackgroundColor = null;
+
/**
* JDK 1.1 serialVersionUID
*/
@@ -267,9 +270,13 @@
/**
* Gets the number of components in this panel.
+ * + * Note: This method should be called under AWT tree lock. + * * @return the number of components in this panel. * @see #getComponent * @since JDK1.1 + * @see Component#getTreeLock() */ public int getComponentCount() { return countComponents(); @@ -281,43 +288,65 @@ */ @Deprecated public int countComponents() { - synchronized (getTreeLock()) { - return component.size(); - } + // This method is not synchronized under AWT tree lock. + // Instead, the calling code is responsible for the + // synchronization. See 6784816 for details. + return component.size(); } /** * Gets the nth component in this container. + *
+ * Note: This method should be called under AWT tree lock. + * * @param n the index of the component to get. * @return the nth component in this container. * @exception ArrayIndexOutOfBoundsException * if the nth value does not exist. + * @see Component#getTreeLock() */ public Component getComponent(int n) { - synchronized (getTreeLock()) { - if ((n < 0) || (n >= component.size())) { - throw new ArrayIndexOutOfBoundsException("No such child: " + n); - } + // This method is not synchronized under AWT tree lock. + // Instead, the calling code is responsible for the + // synchronization. See 6784816 for details. + try { return component.get(n); + } catch (IndexOutOfBoundsException z) { + throw new ArrayIndexOutOfBoundsException("No such child: " + n); } } /** * Gets all the components in this container. + *
+ * Note: This method should be called under AWT tree lock.
+ *
* @return an array of all the components in this container.
+ * @see Component#getTreeLock()
*/
public Component[] getComponents() {
+ // This method is not synchronized under AWT tree lock.
+ // Instead, the calling code is responsible for the
+ // synchronization. See 6784816 for details.
return getComponents_NoClientCode();
}
+
// NOTE: This method may be called by privileged threads.
// This functionality is implemented in a package-private method
// to insure that it cannot be overridden by client subclasses.
// DO NOT INVOKE CLIENT CODE ON THIS THREAD!
final Component[] getComponents_NoClientCode() {
+ return component.toArray(EMPTY_ARRAY);
+ }
+
+ /*
+ * Wrapper for getComponents() method with a proper synchronization.
+ */
+ Component[] getComponentsSync() {
synchronized (getTreeLock()) {
- return component.toArray(EMPTY_ARRAY);
+ return getComponents();
}
- } // getComponents_NoClientCode()
+ }
/**
* Determines the insets of this container, which indicate the size
@@ -503,6 +532,9 @@
adjustDescendants(-(comp.countHierarchyMembers()));
comp.parent = null;
+ if (needRemoveNotify) {
+ comp.setGraphicsConfiguration(null);
+ }
component.remove(index);
invalidateIfValid();
@@ -643,10 +675,7 @@
// each HW descendant independently.
return !comp.peer.isReparentSupported();
} else {
- // if container didn't change we still might need to recreate component's window as
- // changes to zorder should be reflected in native window stacking order and it might
- // not be supported by the platform. This is important only for heavyweight child
- return !((ContainerPeer)(newNativeContainer.peer)).isRestackSupported();
+ return false;
}
}
@@ -786,6 +815,7 @@
component.add(index, comp);
}
comp.parent = this;
+ comp.setGraphicsConfiguration(getGraphicsConfiguration());
adjustListeningChildren(AWTEvent.HIERARCHY_EVENT_MASK,
comp.numListening(AWTEvent.HIERARCHY_EVENT_MASK));
@@ -802,11 +832,6 @@
if (peer != null) {
if (comp.peer == null) { // Remove notify was called or it didn't have peer - create new one
comp.addNotify();
- // New created peer creates component on top of the stacking order
- Container newNativeContainer = getHeavyweightContainer();
- if (((ContainerPeer)newNativeContainer.getPeer()).isRestackSupported()) {
- ((ContainerPeer)newNativeContainer.getPeer()).restack();
- }
} else { // Both container and child have peers, it means child peer should be reparented.
// In both cases we need to reparent native widgets.
Container newNativeContainer = getHeavyweightContainer();
@@ -815,13 +840,8 @@
// Native container changed - need to reparent native widgets
newNativeContainer.reparentChild(comp);
}
- // If component still has a peer and it is either container or heavyweight
- // and restack is supported we have to restack native windows since order might have changed
- if ((!comp.isLightweight() || (comp instanceof Container))
- && ((ContainerPeer)newNativeContainer.getPeer()).isRestackSupported())
- {
- ((ContainerPeer)newNativeContainer.getPeer()).restack();
- }
+ comp.peer.setZOrder(comp.getHWPeerAboveMe());
+
if (!comp.isLightweight() && isLightweight()) {
// If component is heavyweight and one of the containers is lightweight
// the location of the component should be fixed.
@@ -1034,9 +1054,9 @@
}
checkAddToSelf(comp);
checkNotAWindow(comp);
- if (thisGC != null) {
- comp.checkGD(thisGC.getDevice().getIDstring());
- }
+ if (thisGC != null) {
+ comp.checkGD(thisGC.getDevice().getIDstring());
+ }
/* Reparent the component and tidy up the tree's state. */
if (comp.parent != null) {
@@ -1053,6 +1073,7 @@
component.add(index, comp);
}
comp.parent = this;
+ comp.setGraphicsConfiguration(thisGC);
adjustListeningChildren(AWTEvent.HIERARCHY_EVENT_MASK,
comp.numListening(AWTEvent.HIERARCHY_EVENT_MASK));
@@ -1091,6 +1112,19 @@
}
}
+ @Override
+ void setGraphicsConfiguration(GraphicsConfiguration gc) {
+ synchronized (getTreeLock()) {
+ super.setGraphicsConfiguration(gc);
+
+ for (Component comp : component) {
+ if (comp != null) {
+ comp.setGraphicsConfiguration(gc);
+ }
+ }
+ }
+ }
+
/**
* Checks that all Components that this Container contains are on
* the same GraphicsDevice as this Container. If not, throws an
@@ -1148,6 +1182,7 @@
comp.parent = null;
component.remove(index);
+ comp.setGraphicsConfiguration(null);
invalidateIfValid();
if (containerListener != null ||
@@ -1224,6 +1259,7 @@
layoutMgr.removeLayoutComponent(comp);
}
comp.parent = null;
+ comp.setGraphicsConfiguration(null);
if (containerListener != null ||
(eventMask & AWTEvent.CONTAINER_EVENT_MASK) != 0 ||
Toolkit.enabledOnToolkit(AWTEvent.CONTAINER_EVENT_MASK)) {
@@ -1339,7 +1375,7 @@
}
private int getListenersCount(int id, boolean enabledOnToolkit) {
- assert Thread.holdsLock(getTreeLock());
+ checkTreeLock();
if (enabledOnToolkit) {
return descendantsCount;
}
@@ -1357,7 +1393,7 @@
final int createHierarchyEvents(int id, Component changed,
Container changedParent, long changeFlags, boolean enabledOnToolkit)
{
- assert Thread.holdsLock(getTreeLock());
+ checkTreeLock();
int listeners = getListenersCount(id, enabledOnToolkit);
for (int count = listeners, i = 0; count > 0; i++) {
@@ -1372,7 +1408,7 @@
final void createChildHierarchyEvents(int id, long changeFlags,
boolean enabledOnToolkit)
{
- assert Thread.holdsLock(getTreeLock());
+ checkTreeLock();
if (component.isEmpty()) {
return;
}
@@ -1507,6 +1543,7 @@
* @see #validate
*/
protected void validateTree() {
+ checkTreeLock();
if (!isValid()) {
if (peer instanceof ContainerPeer) {
((ContainerPeer)peer).beginLayout();
@@ -1783,7 +1820,7 @@
// super.paint(); -- Don't bother, since it's a NOP.
GraphicsCallback.PaintCallback.getInstance().
- runComponents(component.toArray(EMPTY_ARRAY), g, GraphicsCallback.LIGHTWEIGHTS);
+ runComponents(getComponentsSync(), g, GraphicsCallback.LIGHTWEIGHTS);
}
}
@@ -1838,7 +1875,7 @@
}
GraphicsCallback.PrintCallback.getInstance().
- runComponents(component.toArray(EMPTY_ARRAY), g, GraphicsCallback.LIGHTWEIGHTS);
+ runComponents(getComponentsSync(), g, GraphicsCallback.LIGHTWEIGHTS);
}
}
@@ -1851,7 +1888,7 @@
public void paintComponents(Graphics g) {
if (isShowing()) {
GraphicsCallback.PaintAllCallback.getInstance().
- runComponents(component.toArray(EMPTY_ARRAY), g, GraphicsCallback.TWO_PASSES);
+ runComponents(getComponentsSync(), g, GraphicsCallback.TWO_PASSES);
}
}
@@ -1873,8 +1910,8 @@
void paintHeavyweightComponents(Graphics g) {
if (isShowing()) {
GraphicsCallback.PaintHeavyweightComponentsCallback.getInstance().
- runComponents(component.toArray(EMPTY_ARRAY), g, GraphicsCallback.LIGHTWEIGHTS |
- GraphicsCallback.HEAVYWEIGHTS);
+ runComponents(getComponentsSync(), g,
+ GraphicsCallback.LIGHTWEIGHTS | GraphicsCallback.HEAVYWEIGHTS);
}
}
@@ -1887,7 +1924,7 @@
public void printComponents(Graphics g) {
if (isShowing()) {
GraphicsCallback.PrintAllCallback.getInstance().
- runComponents(component.toArray(EMPTY_ARRAY), g, GraphicsCallback.TWO_PASSES);
+ runComponents(getComponentsSync(), g, GraphicsCallback.TWO_PASSES);
}
}
@@ -1909,8 +1946,8 @@
void printHeavyweightComponents(Graphics g) {
if (isShowing()) {
GraphicsCallback.PrintHeavyweightComponentsCallback.getInstance().
- runComponents(component.toArray(EMPTY_ARRAY), g, GraphicsCallback.LIGHTWEIGHTS |
- GraphicsCallback.HEAVYWEIGHTS);
+ runComponents(getComponentsSync(), g,
+ GraphicsCallback.LIGHTWEIGHTS | GraphicsCallback.HEAVYWEIGHTS);
}
}
@@ -2460,9 +2497,7 @@
* @since 1.2
*/
public Component findComponentAt(int x, int y) {
- synchronized (getTreeLock()) {
- return findComponentAt(x, y, true);
- }
+ return findComponentAt(x, y, true);
}
/**
@@ -2475,58 +2510,60 @@
* The addition of this feature is temporary, pending the
* adoption of new, public API which exports this feature.
*/
- final Component findComponentAt(int x, int y, boolean ignoreEnabled)
- {
- if (isRecursivelyVisible()){
- return findComponentAtImpl(x, y, ignoreEnabled);
+ final Component findComponentAt(int x, int y, boolean ignoreEnabled) {
+ synchronized (getTreeLock()) {
+ if (isRecursivelyVisible()){
+ return findComponentAtImpl(x, y, ignoreEnabled);
+ }
}
return null;
}
final Component findComponentAtImpl(int x, int y, boolean ignoreEnabled){
+ checkTreeLock();
+
if (!(contains(x, y) && visible && (ignoreEnabled || enabled))) {
return null;
}
// Two passes: see comment in sun.awt.SunGraphicsCallback
- synchronized (getTreeLock()) {
- for (int i = 0; i < component.size(); i++) {
- Component comp = component.get(i);
- if (comp != null &&
- !(comp.peer instanceof LightweightPeer)) {
- if (comp instanceof Container) {
- comp = ((Container)comp).findComponentAtImpl(x - comp.x,
- y - comp.y,
- ignoreEnabled);
- } else {
- comp = comp.locate(x - comp.x, y - comp.y);
- }
- if (comp != null && comp.visible &&
- (ignoreEnabled || comp.enabled))
- {
- return comp;
- }
+ for (int i = 0; i < component.size(); i++) {
+ Component comp = component.get(i);
+ if (comp != null &&
+ !(comp.peer instanceof LightweightPeer)) {
+ if (comp instanceof Container) {
+ comp = ((Container)comp).findComponentAtImpl(x - comp.x,
+ y - comp.y,
+ ignoreEnabled);
+ } else {
+ comp = comp.locate(x - comp.x, y - comp.y);
}
- }
- for (int i = 0; i < component.size(); i++) {
- Component comp = component.get(i);
- if (comp != null &&
- comp.peer instanceof LightweightPeer) {
- if (comp instanceof Container) {
- comp = ((Container)comp).findComponentAtImpl(x - comp.x,
- y - comp.y,
- ignoreEnabled);
- } else {
- comp = comp.locate(x - comp.x, y - comp.y);
- }
- if (comp != null && comp.visible &&
- (ignoreEnabled || comp.enabled))
- {
- return comp;
- }
+ if (comp != null && comp.visible &&
+ (ignoreEnabled || comp.enabled))
+ {
+ return comp;
}
}
}
+ for (int i = 0; i < component.size(); i++) {
+ Component comp = component.get(i);
+ if (comp != null &&
+ comp.peer instanceof LightweightPeer) {
+ if (comp instanceof Container) {
+ comp = ((Container)comp).findComponentAtImpl(x - comp.x,
+ y - comp.y,
+ ignoreEnabled);
+ } else {
+ comp = comp.locate(x - comp.x, y - comp.y);
+ }
+ if (comp != null && comp.visible &&
+ (ignoreEnabled || comp.enabled))
+ {
+ return comp;
+ }
+ }
+ }
+
return this;
}
@@ -2584,13 +2621,6 @@
for (int i = 0; i < component.size(); i++) {
component.get(i).addNotify();
}
- // Update stacking order if native platform allows
- ContainerPeer cpeer = (ContainerPeer)peer;
- if (cpeer.isRestackSupported()) {
- cpeer.restack();
- }
-
-
}
}
@@ -3488,7 +3518,7 @@
private void writeObject(ObjectOutputStream s) throws IOException {
ObjectOutputStream.PutField f = s.putFields();
f.put("ncomponents", component.size());
- f.put("component", component.toArray(EMPTY_ARRAY));
+ f.put("component", getComponentsSync());
f.put("layoutMgr", layoutMgr);
f.put("dispatcher", dispatcher);
f.put("maxSize", maxSize);
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/java/awt/DefaultKeyboardFocusManager.java
--- a/jdk/src/share/classes/java/awt/DefaultKeyboardFocusManager.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/java/awt/DefaultKeyboardFocusManager.java Thu Apr 09 13:12:58 2009 -0700
@@ -479,7 +479,7 @@
// that a Component outside of the focused Window receives a
// FOCUS_GAINED event. We synthesize a WINDOW_GAINED_FOCUS
// event in that case.
- final Window newFocusedWindow = Component.getContainingWindow(newFocusOwner);
+ final Window newFocusedWindow = SunToolkit.getContainingWindow(newFocusOwner);
final Window currentFocusedWindow = getGlobalFocusedWindow();
if (newFocusedWindow != null &&
newFocusedWindow != currentFocusedWindow)
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/java/awt/Dialog.java
--- a/jdk/src/share/classes/java/awt/Dialog.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/java/awt/Dialog.java Thu Apr 09 13:12:58 2009 -0700
@@ -1226,7 +1226,7 @@
synchronized (getTreeLock()) {
if (keepBlockingEDT) {
keepBlockingEDT = false;
- PeerEvent wakingEvent = new PeerEvent(this, new WakingRunnable(), PeerEvent.PRIORITY_EVENT);
+ PeerEvent wakingEvent = new PeerEvent(getToolkit(), new WakingRunnable(), PeerEvent.PRIORITY_EVENT);
AppContext curAppContext = AppContext.getAppContext();
if (showAppContext != curAppContext) {
// Wake up event dispatch thread on which the dialog was
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/java/awt/Frame.java
--- a/jdk/src/share/classes/java/awt/Frame.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/java/awt/Frame.java Thu Apr 09 13:12:58 2009 -0700
@@ -36,6 +36,7 @@
import java.io.IOException;
import sun.awt.AppContext;
import sun.awt.SunToolkit;
+import sun.awt.AWTAccessor;
import java.lang.ref.WeakReference;
import javax.accessibility.*;
@@ -738,11 +739,15 @@
* @since 1.4
* @see java.awt.Window#addWindowStateListener
*/
- public synchronized void setExtendedState(int state) {
+ public void setExtendedState(int state) {
if ( !isFrameStateSupported( state ) ) {
return;
}
- this.state = state;
+ 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);
@@ -804,12 +809,27 @@
* @see #setExtendedState(int)
* @since 1.4
*/
- public synchronized int getExtendedState() {
- FramePeer peer = (FramePeer)this.peer;
- if (peer != null) {
- state = peer.getState();
+ public int getExtendedState() {
+ synchronized (getObjectLock()) {
+ return state;
}
- return state;
+ }
+
+ static {
+ AWTAccessor.setFrameAccessor(
+ new AWTAccessor.FrameAccessor() {
+ public void setExtendedState(Frame frame, int state) {
+ synchronized(frame.getObjectLock()) {
+ frame.state = state;
+ }
+ }
+ public int getExtendedState(Frame frame) {
+ synchronized(frame.getObjectLock()) {
+ return frame.state;
+ }
+ }
+ }
+ );
}
/**
@@ -967,7 +987,7 @@
if (resizable) {
str += ",resizable";
}
- getExtendedState(); // sync with peer
+ int state = getExtendedState();
if (state == NORMAL) {
str += ",normal";
}
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/java/awt/GraphicsConfiguration.java
--- a/jdk/src/share/classes/java/awt/GraphicsConfiguration.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/java/awt/GraphicsConfiguration.java Thu Apr 09 13:12:58 2009 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -434,4 +434,20 @@
}
return defaultImageCaps;
}
+
+ /**
+ * Returns whether this GraphicsConfiguration supports
+ * the {@link GraphicsDevice.WindowTranslucency#PERPIXEL_TRANSLUCENT
+ * PERPIXEL_TRANSLUCENT} kind of translucency.
+ *
+ * @param gc GraphicsConfiguration
+ * @throws NullPointerException if the gc argument is null
+ * @return whether the given GraphicsConfiguration supports
+ * the translucency effects.
+ * @see Window#setBackground(Color)
+ */
+ /*public */boolean isTranslucencyCapable() {
+ // Overridden in subclasses
+ return false;
}
+}
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/java/awt/GraphicsDevice.java
--- a/jdk/src/share/classes/java/awt/GraphicsDevice.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/java/awt/GraphicsDevice.java Thu Apr 09 13:12:58 2009 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -27,7 +27,10 @@
package java.awt;
import java.awt.image.ColorModel;
+
+import sun.awt.AWTAccessor;
import sun.awt.AppContext;
+import sun.awt.SunToolkit;
/**
* The GraphicsDevice class describes the graphics devices
@@ -109,6 +112,31 @@
*/
public final static int TYPE_IMAGE_BUFFER = 2;
+ /** Kinds of translucency supported by the underlying system.
+ * @see #isTranslucencySupported
+ */
+ /*public */static enum WindowTranslucency {
+ /**
+ * Represents support in the underlying system for windows each pixel
+ * of which is guaranteed to be either completely opaque, with
+ * an alpha value of 1.0, or completely transparent, with an alpha
+ * value of 0.0.
+ */
+ PERPIXEL_TRANSPARENT,
+ /**
+ * Represents support in the underlying system for windows all of
+ * the pixels of which have the same alpha value between or including
+ * 0.0 and 1.0.
+ */
+ TRANSLUCENT,
+ /**
+ * Represents support in the underlying system for windows that
+ * contain or might contain pixels with arbitrary alpha values
+ * between and including 0.0 and 1.0.
+ */
+ PERPIXEL_TRANSLUCENT;
+ }
+
/**
* Returns the type of this GraphicsDevice.
* @return the type of this GraphicsDevice, which can
@@ -235,6 +263,21 @@
* @since 1.4
*/
public void setFullScreenWindow(Window w) {
+ if (w != null) {
+ //XXX: The actions should be documented in some non-update release.
+ /*
+ if (w.getShape() != null) {
+ w.setShape(w, null);
+ }
+ if (!w.isOpaque()) {
+ w.setOpaque(false);
+ }
+ if (w.getOpacity() < 1.0f) {
+ w.setOpacity(1.0f);
+ }
+ */
+ }
+
if (fullScreenWindow != null && windowedModeBounds != null) {
// if the window went into fs mode before it was realized it may
// have (0,0) dimensions
@@ -424,4 +467,94 @@
public int getAvailableAcceleratedMemory() {
return -1;
}
+
+ /**
+ * Returns whether the given level of translucency is supported
+ * this graphics device.
+ *
+ * @param translucencyKind a kind of translucency support
+ * @return whether the given translucency kind is supported
+ */
+ /*public */boolean isWindowTranslucencySupported(WindowTranslucency translucencyKind) {
+ switch (translucencyKind) {
+ case PERPIXEL_TRANSPARENT:
+ return isWindowShapingSupported();
+ case TRANSLUCENT:
+ return isWindowOpacitySupported();
+ case PERPIXEL_TRANSLUCENT:
+ return isWindowPerpixelTranslucencySupported();
+ }
+ return false;
+ }
+
+ /**
+ * Returns whether the windowing system supports changing the shape
+ * of top-level windows.
+ * Note that this method may sometimes return true, but the native
+ * windowing system may still not support the concept of
+ * shaping (due to the bugs in the windowing system).
+ */
+ static boolean isWindowShapingSupported() {
+ Toolkit curToolkit = Toolkit.getDefaultToolkit();
+ if (!(curToolkit instanceof SunToolkit)) {
+ return false;
+ }
+ return ((SunToolkit)curToolkit).isWindowShapingSupported();
+ }
+
+ /**
+ * Returns whether the windowing system supports changing the opacity
+ * value of top-level windows.
+ * Note that this method may sometimes return true, but the native
+ * windowing system may still not support the concept of
+ * translucency (due to the bugs in the windowing system).
+ */
+ static boolean isWindowOpacitySupported() {
+ Toolkit curToolkit = Toolkit.getDefaultToolkit();
+ if (!(curToolkit instanceof SunToolkit)) {
+ return false;
+ }
+ return ((SunToolkit)curToolkit).isWindowOpacitySupported();
+ }
+
+ boolean isWindowPerpixelTranslucencySupported() {
+ /*
+ * Per-pixel alpha is supported if all the conditions are TRUE:
+ * 1. The toolkit is a sort of SunToolkit
+ * 2. The toolkit supports translucency in general
+ * (isWindowTranslucencySupported())
+ * 3. There's at least one translucency-capable
+ * GraphicsConfiguration
+ */
+ Toolkit curToolkit = Toolkit.getDefaultToolkit();
+ if (!(curToolkit instanceof SunToolkit)) {
+ return false;
+ }
+ if (!((SunToolkit)curToolkit).isWindowTranslucencySupported()) {
+ return false;
+ }
+
+ // TODO: cache translucency capable GC
+ return getTranslucencyCapableGC() != null;
+ }
+
+ GraphicsConfiguration getTranslucencyCapableGC() {
+ // If the default GC supports translucency return true.
+ // It is important to optimize the verification this way,
+ // see CR 6661196 for more details.
+ GraphicsConfiguration defaultGC = getDefaultConfiguration();
+ if (defaultGC.isTranslucencyCapable()) {
+ return defaultGC;
+ }
+
+ // ... otherwise iterate through all the GCs.
+ GraphicsConfiguration[] configs = getConfigurations();
+ for (int j = 0; j < configs.length; j++) {
+ if (configs[j].isTranslucencyCapable()) {
+ return configs[j];
+ }
+ }
+
+ return null;
+ }
}
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/java/awt/KeyboardFocusManager.java
--- a/jdk/src/share/classes/java/awt/KeyboardFocusManager.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/java/awt/KeyboardFocusManager.java Thu Apr 09 13:12:58 2009 -0700
@@ -61,6 +61,7 @@
import sun.awt.SunToolkit;
import sun.awt.CausedFocusEvent;
import sun.awt.KeyboardFocusManagerPeerProvider;
+import sun.awt.AWTAccessor;
/**
* The KeyboardFocusManager is responsible for managing the active and focused
@@ -118,6 +119,32 @@
if (!GraphicsEnvironment.isHeadless()) {
initIDs();
}
+ AWTAccessor.setKeyboardFocusManagerAccessor(
+ new AWTAccessor.KeyboardFocusManagerAccessor() {
+ public int shouldNativelyFocusHeavyweight(Component heavyweight,
+ Component descendant,
+ boolean temporary,
+ boolean focusedWindowChangeAllowed,
+ long time,
+ CausedFocusEvent.Cause cause)
+ {
+ return KeyboardFocusManager.shouldNativelyFocusHeavyweight(
+ heavyweight, descendant, temporary, focusedWindowChangeAllowed, time, cause);
+ }
+ public boolean processSynchronousLightweightTransfer(Component heavyweight,
+ Component descendant,
+ boolean temporary,
+ boolean focusedWindowChangeAllowed,
+ long time)
+ {
+ return KeyboardFocusManager.processSynchronousLightweightTransfer(
+ heavyweight, descendant, temporary, focusedWindowChangeAllowed, time);
+ }
+ public void removeLastFocusRequest(Component heavyweight) {
+ KeyboardFocusManager.removeLastFocusRequest(heavyweight);
+ }
+ }
+ );
}
transient KeyboardFocusManagerPeer peer;
@@ -2208,7 +2235,7 @@
boolean temporary, boolean focusedWindowChangeAllowed,
long time)
{
- Window parentWindow = Component.getContainingWindow(heavyweight);
+ Window parentWindow = SunToolkit.getContainingWindow(heavyweight);
if (parentWindow == null || !parentWindow.syncLWRequests) {
return false;
}
@@ -2443,79 +2470,7 @@
}
}
}
- static void heavyweightButtonDown(Component heavyweight, long time) {
- heavyweightButtonDown(heavyweight, time, false);
- }
- static void heavyweightButtonDown(Component heavyweight, long time, boolean acceptDuplicates) {
- if (log.isLoggable(Level.FINE)) {
- if (heavyweight == null) {
- log.log(Level.FINE, "Assertion (heavyweight != null) failed");
- }
- if (time == 0) {
- log.log(Level.FINE, "Assertion (time != 0) failed");
- }
- }
- KeyboardFocusManager manager = getCurrentKeyboardFocusManager(SunToolkit.targetToAppContext(heavyweight));
- synchronized (heavyweightRequests) {
- HeavyweightFocusRequest hwFocusRequest = getLastHWRequest();
- Component currentNativeFocusOwner = (hwFocusRequest == null)
- ? manager.getNativeFocusOwner()
- : hwFocusRequest.heavyweight;
-
- // Behavior for all use cases:
- // 1. Heavyweight leaf Components (e.g., Button, Checkbox, Choice,
- // List, TextComponent, Canvas) that respond to button down.
- //
- // Native platform will generate a FOCUS_GAINED if and only if
- // the Component is not the focus owner (or, will not be the
- // focus owner when all outstanding focus requests are
- // processed).
- //
- // 2. Panel with no descendants.
- //
- // Same as (1).
- //
- // 3. Panel with at least one heavyweight descendant.
- //
- // This function should NOT be called for this case!
- //
- // 4. Panel with only lightweight descendants.
- //
- // Native platform will generate a FOCUS_GAINED if and only if
- // neither the Panel, nor any of its recursive, lightweight
- // descendants, is the focus owner. However, we want a
- // requestFocus() for any lightweight descendant to win out over
- // the focus request for the Panel. To accomplish this, we
- // differ from the algorithm for shouldNativelyFocusHeavyweight
- // as follows:
- // a. If the requestFocus() for a lightweight descendant has
- // been fully handled by the time this function is invoked,
- // then 'hwFocusRequest' will be null and 'heavyweight'
- // will be the native focus owner. Do *not* synthesize a
- // focus transfer to the Panel.
- // b. If the requestFocus() for a lightweight descendant has
- // been recorded, but not handled, then 'hwFocusRequest'
- // will be non-null and 'hwFocusRequest.heavyweight' will
- // equal 'heavyweight'. Do *not* append 'heavyweight' to
- // hwFocusRequest.lightweightRequests.
- // c. If the requestFocus() for a lightweight descendant is
- // yet to be made, then post a new HeavyweightFocusRequest.
- // If no lightweight descendant ever requests focus, then
- // the Panel will get focus. If some descendant does, then
- // the descendant will get focus by either a synthetic
- // focus transfer, or a lightweightRequests focus transfer.
-
- if (acceptDuplicates || heavyweight != currentNativeFocusOwner) {
- getCurrentKeyboardFocusManager
- (SunToolkit.targetToAppContext(heavyweight)).
- enqueueKeyEvents(time, heavyweight);
- heavyweightRequests.add
- (new HeavyweightFocusRequest(heavyweight, heavyweight,
- false, CausedFocusEvent.Cause.MOUSE_EVENT));
- }
- }
- }
/**
* Returns the Window which will be active after processing this request,
* or null if this is a duplicate request. The active Window is useful
@@ -2542,7 +2497,7 @@
(HeavyweightFocusRequest.CLEAR_GLOBAL_FOCUS_OWNER);
Component activeWindow = ((hwFocusRequest != null)
- ? Component.getContainingWindow(hwFocusRequest.heavyweight)
+ ? SunToolkit.getContainingWindow(hwFocusRequest.heavyweight)
: nativeFocusedWindow);
while (activeWindow != null &&
!((activeWindow instanceof Frame) ||
@@ -3013,8 +2968,8 @@
}
private static boolean focusedWindowChanged(Component to, Component from) {
- Window wto = Component.getContainingWindow(to);
- Window wfrom = Component.getContainingWindow(from);
+ Window wto = SunToolkit.getContainingWindow(to);
+ Window wfrom = SunToolkit.getContainingWindow(from);
if (wto == null && wfrom == null) {
return true;
}
@@ -3028,8 +2983,8 @@
}
private static boolean isTemporary(Component to, Component from) {
- Window wto = Component.getContainingWindow(to);
- Window wfrom = Component.getContainingWindow(from);
+ Window wto = SunToolkit.getContainingWindow(to);
+ Window wfrom = SunToolkit.getContainingWindow(from);
if (wto == null && wfrom == null) {
return false;
}
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/java/awt/MenuItem.java
--- a/jdk/src/share/classes/java/awt/MenuItem.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/java/awt/MenuItem.java Thu Apr 09 13:12:58 2009 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1995-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1995-2009 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -398,9 +398,11 @@
boolean handleShortcut(KeyEvent e) {
MenuShortcut s = new MenuShortcut(e.getKeyCode(),
(e.getModifiers() & InputEvent.SHIFT_MASK) > 0);
+ MenuShortcut sE = new MenuShortcut(e.getExtendedKeyCode(),
+ (e.getModifiers() & InputEvent.SHIFT_MASK) > 0);
// Fix For 6185151: Menu shortcuts of all menuitems within a menu
// should be disabled when the menu itself is disabled
- if (s.equals(shortcut) && isItemEnabled()) {
+ if ((s.equals(shortcut) || sE.equals(shortcut)) && isItemEnabled()) {
// MenuShortcut match -- issue an event on keydown.
if (e.getID() == KeyEvent.KEY_PRESSED) {
doMenuEvent(e.getWhen(), e.getModifiers());
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/java/awt/MenuShortcut.java
--- a/jdk/src/share/classes/java/awt/MenuShortcut.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/java/awt/MenuShortcut.java Thu Apr 09 13:12:58 2009 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1996-2003 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1996-2009 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -34,7 +34,21 @@
* For example, a menu shortcut for Ctrl-a (assuming that Control is
* the accelerator key) would be created with code like the following:
*
- * MenuShortcut ms = new MenuShortcut(KeyEvent.VK_A, false);
+ * MenuShortcut ms = new MenuShortcut(KeyEvent.VK_A, false);
+ *
or alternatively + *
+ * MenuShortcut ms = new MenuShortcut(KeyEvent.getExtendedKeyCodeForChar('A'), false);
+ *
+ * Menu shortcuts may also be constructed for a wider set of keycodes
+ * using the java.awt.event.KeyEvent.getExtendedKeyCodeForChar call.
+ * For example, a menu shortcut for "Ctrl+cyrillic ef" is created by
+ *
+ * MenuShortcut ms = new MenuShortcut(KeyEvent.getExtendedKeyCodeForChar('\u0444'), false);
+ *
+ * Note that shortcuts created with a keycode or an extended keycode defined as a constant in KeyEvent
+ * work regardless of the current keyboard layout. However, a shortcut made of
+ * an extended keycode not listed in KeyEvent
+ * only work if the current keyboard layout produces a corresponding letter.
*
* The accelerator key is platform-dependent and may be obtained * via {@link Toolkit#getMenuShortcutKeyMask}. diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/java/awt/Window.java --- a/jdk/src/share/classes/java/awt/Window.java Wed Jul 05 16:50:36 2017 +0200 +++ b/jdk/src/share/classes/java/awt/Window.java Thu Apr 09 13:12:58 2009 -0700 @@ -1,5 +1,5 @@ /* - * Copyright 1995-2008 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 1995-2009 Sun Microsystems, Inc. All Rights Reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,8 +25,10 @@ package java.awt; import java.awt.event.*; +import java.awt.geom.Point2D; import java.awt.im.InputContext; import java.awt.image.BufferStrategy; +import java.awt.image.BufferedImage; import java.awt.peer.ComponentPeer; import java.awt.peer.WindowPeer; import java.beans.PropertyChangeListener; @@ -49,6 +51,7 @@ import java.util.logging.Logger; import java.util.concurrent.atomic.AtomicBoolean; import javax.accessibility.*; +import sun.awt.AWTAccessor; import sun.awt.AppContext; import sun.awt.CausedFocusEvent; import sun.awt.SunToolkit; @@ -291,6 +294,25 @@ */ transient boolean isInShow = false; + /* + * Opacity level of the window + * + * @see #setOpacity(float) + * @see #getOpacity() + * @since 1.7 + */ + private float opacity = 1.0f; + + /* + * The shape assigned to this window. This field is set to null if + * no shape is set (rectangular window). + * + * @see #getShape() + * @see #setShape(Shape) + * @since 1.7 + */ + private Shape shape = null; + private static final String base = "win"; private static int nameCounter = 0; @@ -305,6 +327,23 @@ transient boolean isTrayIconWindow = false; + /** + * These fields are initialized in the native peer code + * or via AWTAccessor's WindowAccessor. + */ + private transient volatile int securityWarningWidth = 0; + private transient volatile int securityWarningHeight = 0; + + /** + * These fields represent the desired location for the security + * warning if this window is untrusted. + * See com.sun.awt.SecurityWarning for more details. + */ + private transient double securityWarningPointX = 2.0; + private transient double securityWarningPointY = 0.0; + private transient float securityWarningAlignmentX = RIGHT_ALIGNMENT; + private transient float securityWarningAlignmentY = TOP_ALIGNMENT; + static { /* ensure that the necessary native libraries are loaded */ Toolkit.loadLibraries(); @@ -373,6 +412,18 @@ } } + private GraphicsConfiguration initGC(GraphicsConfiguration gc) { + GraphicsEnvironment.checkHeadless(); + + if (gc == null) { + gc = GraphicsEnvironment.getLocalGraphicsEnvironment(). + getDefaultScreenDevice().getDefaultConfiguration(); + } + setGraphicsConfiguration(gc); + + return gc; + } + private void init(GraphicsConfiguration gc) { GraphicsEnvironment.checkHeadless(); @@ -384,14 +435,10 @@ setWarningString(); this.cursor = Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR); this.visible = false; - if (gc == null) { - this.graphicsConfig = - GraphicsEnvironment.getLocalGraphicsEnvironment(). - getDefaultScreenDevice().getDefaultConfiguration(); - } else { - this.graphicsConfig = gc; - } - if (graphicsConfig.getDevice().getType() != + + gc = initGC(gc); + + if (gc.getDevice().getType() != GraphicsDevice.TYPE_RASTER_SCREEN) { throw new IllegalArgumentException("not a screen device"); } @@ -399,8 +446,8 @@ /* offset the initial location with the original of the screen */ /* and any insets */ - Rectangle screenBounds = graphicsConfig.getBounds(); - Insets screenInsets = getToolkit().getScreenInsets(graphicsConfig); + Rectangle screenBounds = gc.getBounds(); + Insets screenInsets = getToolkit().getScreenInsets(gc); int x = getX() + screenBounds.x + screenInsets.left; int y = getY() + screenBounds.y + screenInsets.top; if (x != this.x || y != this.y) { @@ -2744,7 +2791,7 @@ sun.java2d.Disposer.addRecord(anchor, new WindowDisposerRecord(appContext, this)); addToWindowList(); - + initGC(null); } private void deserializeResources(ObjectInputStream s) @@ -2849,6 +2896,15 @@ if(aot) { setAlwaysOnTop(aot); // since 1.5; subject to permission check } + shape = (Shape)f.get("shape", null); + opacity = (Float)f.get("opacity", 1.0f); + + this.securityWarningWidth = 0; + this.securityWarningHeight = 0; + this.securityWarningPointX = 2.0; + this.securityWarningPointY = 0.0; + this.securityWarningAlignmentX = RIGHT_ALIGNMENT; + this.securityWarningAlignmentY = TOP_ALIGNMENT; deserializeResources(s); } @@ -2916,41 +2972,18 @@ } // inner class AccessibleAWTWindow - /** - * This method returns the GraphicsConfiguration used by this Window. - * @since 1.3 - */ - public GraphicsConfiguration getGraphicsConfiguration() { - //NOTE: for multiscreen, this will need to take into account - //which screen the window is on/mostly on instead of returning the - //default or constructor argument config. - synchronized(getTreeLock()) { - if (graphicsConfig == null && !GraphicsEnvironment.isHeadless()) { - graphicsConfig = - GraphicsEnvironment. getLocalGraphicsEnvironment(). - getDefaultScreenDevice(). - getDefaultConfiguration(); - } - return graphicsConfig; - } - } - - /** - * Reset this Window's GraphicsConfiguration to match its peer. - */ - void resetGC() { - if (!GraphicsEnvironment.isHeadless()) { - // use the peer's GC - setGCFromPeer(); - // if it's still null, use the default - if (graphicsConfig == null) { - graphicsConfig = GraphicsEnvironment. + @Override + void setGraphicsConfiguration(GraphicsConfiguration gc) { + if (gc == null) { + gc = GraphicsEnvironment. getLocalGraphicsEnvironment(). getDefaultScreenDevice(). getDefaultConfiguration(); - } + } + synchronized (getTreeLock()) { + super.setGraphicsConfiguration(gc); if (log.isLoggable(Level.FINER)) { - log.finer("+ Window.resetGC(): new GC is \n+ " + graphicsConfig + "\n+ this is " + this); + log.finer("+ Window.setGraphicsConfiguration(): new GC is \n+ " + getGraphicsConfiguration_NoClientCode() + "\n+ this is " + this); } } } @@ -3010,13 +3043,13 @@ // target location int dx = 0, dy = 0; // target GC - GraphicsConfiguration gc = this.graphicsConfig; + GraphicsConfiguration gc = getGraphicsConfiguration_NoClientCode(); Rectangle gcBounds = gc.getBounds(); Dimension windowSize = getSize(); // search a top-level of c - Window componentWindow = Component.getContainingWindow(c); + Window componentWindow = SunToolkit.getContainingWindow(c); if ((c == null) || (componentWindow == null)) { GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); gc = ge.getDefaultScreenDevice().getDefaultConfiguration(); @@ -3304,6 +3337,225 @@ } + // ******************** SHAPES & TRANSPARENCY CODE ******************** + + /** + * JavaDoc + */ + /*public */float getOpacity() { + synchronized (getTreeLock()) { + return opacity; + } + } + + /** + * JavaDoc + */ + /*public */void setOpacity(float opacity) { + synchronized (getTreeLock()) { + if (opacity < 0.0f || opacity > 1.0f) { + throw new IllegalArgumentException( + "The value of opacity should be in the range [0.0f .. 1.0f]."); + } + GraphicsConfiguration gc = getGraphicsConfiguration(); + GraphicsDevice gd = gc.getDevice(); + if (!gd.isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.TRANSLUCENT)) { + throw new UnsupportedOperationException( + "TRANSLUCENT translucency is not supported."); + } + if ((gc.getDevice().getFullScreenWindow() == this) && (opacity < 1.0f)) { + throw new IllegalArgumentException( + "Setting opacity for full-screen window is not supported."); + } + this.opacity = opacity; + WindowPeer peer = (WindowPeer)getPeer(); + if (peer != null) { + peer.setOpacity(opacity); + } + } + } + + /** + * JavaDoc + */ + /*public */Shape getShape() { + synchronized (getTreeLock()) { + return shape; + } + } + + /** + * JavaDoc + * + * @param window the window to set the shape to + * @param shape the shape to set to the window + * @throws IllegalArgumentException if the window is in full screen mode, + * and the shape is not null + */ + /*public */void setShape(Shape shape) { + synchronized (getTreeLock()) { + GraphicsConfiguration gc = getGraphicsConfiguration(); + GraphicsDevice gd = gc.getDevice(); + if (!gd.isWindowTranslucencySupported( + GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSPARENT)) + { + throw new UnsupportedOperationException( + "PERPIXEL_TRANSPARENT translucency is not supported."); + } + if ((gc.getDevice().getFullScreenWindow() == this) && (shape != null)) { + throw new IllegalArgumentException( + "Setting shape for full-screen window is not supported."); + } + this.shape = shape; + WindowPeer peer = (WindowPeer)getPeer(); + if (peer != null) { + peer.applyShape(shape == null ? null : Region.getInstance(shape, null)); + } + } + } + + /** + * JavaDoc + */ +/* + @Override + public void setBackground(Color bgColor) { + int alpha = bgColor.getAlpha(); + if (alpha < 255) { // non-opaque window + GraphicsConfiguration gc = getGraphicsConfiguration(); + GraphicsDevice gd = gc.getDevice(); + if (gc.getDevice().getFullScreenWindow() == this) { + throw new IllegalArgumentException( + "Making full-screen window non opaque is not supported."); + } + if (!gc.isTranslucencyCapable()) { + GraphicsConfiguration capableGC = gd.getTranslucencyCapableGC(); + if (capableGC == null) { + throw new IllegalArgumentException( + "PERPIXEL_TRANSLUCENT translucency is not supported"); + } + // TODO: change GC + } + setLayersOpaque(this, false); + } + + super.setBackground(bgColor); + + WindowPeer peer = (WindowPeer)getPeer(); + if (peer != null) { + peer.setOpaque(alpha == 255); + } + } +*/ + + private transient boolean opaque = true; + + void setOpaque(boolean opaque) { + synchronized (getTreeLock()) { + GraphicsConfiguration gc = getGraphicsConfiguration(); + if (!opaque && !com.sun.awt.AWTUtilities.isTranslucencyCapable(gc)) { + throw new IllegalArgumentException( + "The window must use a translucency-compatible graphics configuration"); + } + if (!com.sun.awt.AWTUtilities.isTranslucencySupported( + com.sun.awt.AWTUtilities.Translucency.PERPIXEL_TRANSLUCENT)) + { + throw new UnsupportedOperationException( + "PERPIXEL_TRANSLUCENT translucency is not supported."); + } + if ((gc.getDevice().getFullScreenWindow() == this) && !opaque) { + throw new IllegalArgumentException( + "Making full-screen window non opaque is not supported."); + } + setLayersOpaque(this, opaque); + this.opaque = opaque; + WindowPeer peer = (WindowPeer)getPeer(); + if (peer != null) { + peer.setOpaque(opaque); + } + } + } + + private void updateWindow(BufferedImage backBuffer) { + synchronized (getTreeLock()) { + WindowPeer peer = (WindowPeer)getPeer(); + if (peer != null) { + peer.updateWindow(backBuffer); + } + } + } + + private static final Color TRANSPARENT_BACKGROUND_COLOR = new Color(0, 0, 0, 0); + + private static void setLayersOpaque(Component component, boolean isOpaque) { + // Shouldn't use instanceof to avoid loading Swing classes + // if it's a pure AWT application. + if (Component.doesImplement(component, "javax.swing.RootPaneContainer")) { + javax.swing.RootPaneContainer rpc = (javax.swing.RootPaneContainer)component; + javax.swing.JRootPane root = rpc.getRootPane(); + javax.swing.JLayeredPane lp = root.getLayeredPane(); + Container c = root.getContentPane(); + javax.swing.JComponent content = + (c instanceof javax.swing.JComponent) ? (javax.swing.JComponent)c : null; + javax.swing.JComponent gp = + (rpc.getGlassPane() instanceof javax.swing.JComponent) ? + (javax.swing.JComponent)rpc.getGlassPane() : null; + if (gp != null) { + gp.setDoubleBuffered(isOpaque); + } + lp.setOpaque(isOpaque); + root.setOpaque(isOpaque); + root.setDoubleBuffered(isOpaque); //XXX: the "white rect" workaround + if (content != null) { + content.setOpaque(isOpaque); + content.setDoubleBuffered(isOpaque); //XXX: the "white rect" workaround + + // Iterate down one level to see whether we have a JApplet + // (which is also a RootPaneContainer) which requires processing + int numChildren = content.getComponentCount(); + if (numChildren > 0) { + Component child = content.getComponent(0); + // It's OK to use instanceof here because we've + // already loaded the RootPaneContainer class by now + if (child instanceof javax.swing.RootPaneContainer) { + setLayersOpaque(child, isOpaque); + } + } + } + } + + Color bg = component.getBackground(); + boolean hasTransparentBg = TRANSPARENT_BACKGROUND_COLOR.equals(bg); + + Container container = null; + if (component instanceof Container) { + container = (Container) component; + } + + if (isOpaque) { + if (hasTransparentBg) { + // Note: we use the SystemColor.window color as the default. + // This color is used in the WindowPeer implementations to + // initialize the background color of the window if it is null. + // (This might not be the right thing to do for other + // RootPaneContainers we might be invoked with) + Color newColor = null; + if (container != null && container.preserveBackgroundColor != null) { + newColor = container.preserveBackgroundColor; + } else { + newColor = SystemColor.window; + } + component.setBackground(newColor); + } + } else { + if (!hasTransparentBg && container != null) { + container.preserveBackgroundColor = bg; + } + component.setBackground(TRANSPARENT_BACKGROUND_COLOR); + } + } + + // ************************** MIXING CODE ******************************* // A window has a parent, but it does NOT have a container @@ -3341,6 +3593,87 @@ // ****************** END OF MIXING CODE ******************************** + // This method gets the window location/size as reported by the native + // system since the locally cached values may represent outdated data. + // NOTE: this method is invoked on the toolkit thread, and therefore + // is not supposed to become public/user-overridable. + private Point2D calculateSecurityWarningPosition(double x, double y, + double w, double h) + { + return new Point2D.Double( + x + w * securityWarningAlignmentX + securityWarningPointX, + y + h * securityWarningAlignmentY + securityWarningPointY); + } + + static { + AWTAccessor.setWindowAccessor(new AWTAccessor.WindowAccessor() { + public float getOpacity(Window window) { + return window.opacity; + } + public void setOpacity(Window window, float opacity) { + window.setOpacity(opacity); + } + public Shape getShape(Window window) { + return window.getShape(); + } + public void setShape(Window window, Shape shape) { + window.setShape(shape); + } + public boolean isOpaque(Window window) { + /* + return window.getBackground().getAlpha() < 255; + */ + synchronized (window.getTreeLock()) { + return window.opaque; + } + } + public void setOpaque(Window window, boolean opaque) { + /* + Color bg = window.getBackground(); + window.setBackground(new Color(bg.getRed(), bg.getGreen(), bg.getBlue(), + opaque ? 255 : 0)); + */ + window.setOpaque(opaque); + } + public void updateWindow(Window window, BufferedImage backBuffer) { + window.updateWindow(backBuffer); + } + + public Dimension getSecurityWarningSize(Window window) { + return new Dimension(window.securityWarningWidth, + window.securityWarningHeight); + } + + public void setSecurityWarningSize(Window window, int width, int height) + { + window.securityWarningWidth = width; + window.securityWarningHeight = height; + } + + public void setSecurityWarningPosition(Window window, + Point2D point, float alignmentX, float alignmentY) + { + window.securityWarningPointX = point.getX(); + window.securityWarningPointY = point.getY(); + window.securityWarningAlignmentX = alignmentX; + window.securityWarningAlignmentY = alignmentY; + + synchronized (window.getTreeLock()) { + WindowPeer peer = (WindowPeer)window.getPeer(); + if (peer != null) { + peer.repositionSecurityWarning(); + } + } + } + + public Point2D calculateSecurityWarningPosition(Window window, + double x, double y, double w, double h) + { + return window.calculateSecurityWarningPosition(x, y, w, h); + } + }); // WindowAccessor + } // static + } // class Window diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/java/awt/event/KeyEvent.java --- a/jdk/src/share/classes/java/awt/event/KeyEvent.java Wed Jul 05 16:50:36 2017 +0200 +++ b/jdk/src/share/classes/java/awt/event/KeyEvent.java Thu Apr 09 13:12:58 2009 -0700 @@ -1,5 +1,5 @@ /* - * Copyright 1996-2008 Sun Microsystems, Inc. All Rights Reserved. + * Copyright 1996-2009 Sun Microsystems, Inc. All Rights Reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -65,15 +65,16 @@ *
* For key pressed and key released events, the getKeyCode method returns * the event's keyCode. For key typed events, the getKeyCode method - * always returns VK_UNDEFINED. + * always returns {@code VK_UNDEFINED}. The {@code getExtendedKeyCode} method + * may also be used with many international keyboard layouts. * *
* "Key pressed" and "key released" events are lower-level and depend * on the platform and keyboard layout. They are generated whenever a key is * pressed or released, and are the only way to find out about keys that don't * generate character input (e.g., action keys, modifier keys, etc.). The key - * being pressed or released is indicated by the getKeyCode method, which returns - * a virtual key code. + * being pressed or released is indicated by the {@code getKeyCode} and {@code getExtendedKeyCode} + * methods, which return a virtual key code. * *
* Virtual key codes are used to report which keyboard key has @@ -111,6 +112,11 @@ * platform and keyboard layout. For example, the key that generates VK_Q * when using a U.S. keyboard layout will generate VK_A when using a French * keyboard layout. + *
VK_XXX
* keycodes defined in java.awt.event.KeyEvent.
+ * These codes and the wider array of codes for international
+ * keyboards may be obtained through
+ * java.awt.event.KeyEvent.getExtendedKeyCodeForChar.
* Mnemonics are case-insensitive, therefore a key event
* with the corresponding keycode would cause the button to be
* activated whether or not the Shift modifier was pressed.
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/javax/swing/Action.java
--- a/jdk/src/share/classes/javax/swing/Action.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/javax/swing/Action.java Thu Apr 09 13:12:58 2009 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2006 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -272,7 +272,9 @@
* one of the KeyEvent key codes. The value is
* commonly used to specify a mnemonic. For example:
* myAction.putValue(Action.MNEMONIC_KEY, KeyEvent.VK_A)
- * sets the mnemonic of myAction to 'a'.
+ * sets the mnemonic of myAction to 'a', while
+ * myAction.putValue(Action.MNEMONIC_KEY, KeyEvent.getExtendedKeyCodeForChar('\u0444'))
+ * sets the mnemonic of myAction to Cyrillic letter "Ef".
*
* @since 1.3
*/
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/javax/swing/JComponent.java
--- a/jdk/src/share/classes/javax/swing/JComponent.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/javax/swing/JComponent.java Thu Apr 09 13:12:58 2009 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -2888,7 +2888,10 @@
return false;
}
// Get the KeyStroke
+ // There may be two keystrokes associated with a low-level key event;
+ // in this case a keystroke made of an extended key code has a priority.
KeyStroke ks;
+ KeyStroke ksE = null;
if (e.getID() == KeyEvent.KEY_TYPED) {
ks = KeyStroke.getKeyStroke(e.getKeyChar());
@@ -2896,9 +2899,18 @@
else {
ks = KeyStroke.getKeyStroke(e.getKeyCode(),e.getModifiers(),
(pressed ? false:true));
+ if (e.getKeyCode() != e.getExtendedKeyCode()) {
+ ksE = KeyStroke.getKeyStroke(e.getExtendedKeyCode(),e.getModifiers(),
+ (pressed ? false:true));
+ }
}
- /* Do we have a key binding for e? */
+ // Do we have a key binding for e?
+ // If we have a binding by an extended code, use it.
+ // If not, check for regular code binding.
+ if(ksE != null && processKeyBinding(ksE, e, WHEN_FOCUSED, pressed)) {
+ return true;
+ }
if(processKeyBinding(ks, e, WHEN_FOCUSED, pressed))
return true;
@@ -2910,6 +2922,9 @@
while (parent != null && !(parent instanceof Window) &&
!(parent instanceof Applet)) {
if(parent instanceof JComponent) {
+ if(ksE != null && ((JComponent)parent).processKeyBinding(ksE, e,
+ WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, pressed))
+ return true;
if(((JComponent)parent).processKeyBinding(ks, e,
WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, pressed))
return true;
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/javax/swing/JLabel.java
--- a/jdk/src/share/classes/javax/swing/JLabel.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/javax/swing/JLabel.java Thu Apr 09 13:12:58 2009 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -503,10 +503,10 @@
* @see #setDisplayedMnemonic(int)
*/
public void setDisplayedMnemonic(char aChar) {
- int vk = (int) aChar;
- if(vk >= 'a' && vk <='z')
- vk -= ('a' - 'A');
- setDisplayedMnemonic(vk);
+ int vk = java.awt.event.KeyEvent.getExtendedKeyCodeForChar(aChar);
+ if (vk != java.awt.event.KeyEvent.VK_UNDEFINED) {
+ setDisplayedMnemonic(vk);
+ }
}
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/javax/swing/JTabbedPane.java
--- a/jdk/src/share/classes/javax/swing/JTabbedPane.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/javax/swing/JTabbedPane.java Thu Apr 09 13:12:58 2009 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -1628,7 +1628,9 @@
*
* A mnemonic must correspond to a single key on the keyboard
* and should be specified using one of the VK_XXX
- * keycodes defined in java.awt.event.KeyEvent.
+ * keycodes defined in java.awt.event.KeyEvent
+ * or one of the extended keycodes obtained through
+ * java.awt.event.KeyEvent.getExtendedKeyCodeForChar.
* Mnemonics are case-insensitive, therefore a key event
* with the corresponding keycode would cause the button to be
* activated whether or not the Shift modifier was pressed.
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/javax/swing/KeyStroke.java
--- a/jdk/src/share/classes/javax/swing/KeyStroke.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/javax/swing/KeyStroke.java Thu Apr 09 13:12:58 2009 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -162,6 +162,9 @@
*
java.awt.event.KeyEvent.getExtendedKeyCodeForChar.
+ *
* The modifiers consist of any combination of:java.awt.event.KeyEvent.getExtendedKeyCodeForChar.
+ *
* The modifiers consist of any combination of:Rectangle object. The bounds specify this
+ * component's width, height, and location relative to
+ * its parent.
+ */
+ Rectangle getBounds(Component comp);
+ /*
* Sets the shape of a lw component to cut out from hw components.
+ *
+ * See 6797587, 6776743, 6768307, and 6768332 for details
*/
void setMixingCutoutShape(Component comp, Shape shape);
+
+ /**
+ * Sets GraphicsConfiguration value for the component.
+ */
+ void setGraphicsConfiguration(Component comp, GraphicsConfiguration gc);
+ /*
+ * Requests focus to the component.
+ */
+ boolean requestFocus(Component comp, CausedFocusEvent.Cause cause);
+ /*
+ * Determines if the component can gain focus.
+ */
+ boolean canBeFocusOwner(Component comp);
+
+ /**
+ * Returns whether the component is visible without invoking
+ * any client code.
+ */
+ boolean isVisible_NoClientCode(Component comp);
}
- /* The java.awt.Component class accessor object.
+ /*
+ * An interface of accessor for java.awt.Window class.
+ */
+ public interface WindowAccessor {
+ /*
+ * Get opacity level of the given window.
+ */
+ float getOpacity(Window window);
+ /*
+ * Set opacity level to the given window.
+ */
+ void setOpacity(Window window, float opacity);
+ /*
+ * Get a shape assigned to the given window.
+ */
+ Shape getShape(Window window);
+ /*
+ * Set a shape to the given window.
+ */
+ void setShape(Window window, Shape shape);
+ /*
+ * Identify whether the given window is opaque (true)
+ * or translucent (false).
+ */
+ boolean isOpaque(Window window);
+ /*
+ * Set the opaque preoperty to the given window.
+ */
+ void setOpaque(Window window, boolean isOpaque);
+ /*
+ * Update the image of a non-opaque (translucent) window.
+ */
+ void updateWindow(Window window, BufferedImage backBuffer);
+
+ /** Get the size of the security warning.
+ */
+ Dimension getSecurityWarningSize(Window w);
+
+ /**
+ * Set the size of the security warning.
+ */
+ void setSecurityWarningSize(Window w, int width, int height);
+
+ /** Set the position of the security warning.
+ */
+ void setSecurityWarningPosition(Window w, Point2D point,
+ float alignmentX, float alignmentY);
+
+ /** Request to recalculate the new position of the security warning for
+ * the given window size/location as reported by the native system.
+ */
+ Point2D calculateSecurityWarningPosition(Window window,
+ double x, double y, double w, double h);
+ }
+
+ /*
+ * An accessor for the AWTEvent class.
+ */
+ public interface AWTEventAccessor {
+ /*
+ *
+ * Sets the flag on this AWTEvent indicating that it was
+ * generated by the system.
+ */
+ void setSystemGenerated(AWTEvent ev);
+ /*
+ *
+ * Indicates whether this AWTEvent was generated by the system.
+ */
+ boolean isSystemGenerated(AWTEvent ev);
+ }
+
+ /*
+ * An accessor for the java.awt.Frame class.
+ */
+ public interface FrameAccessor {
+ /*
+ * Sets the state of this frame.
+ */
+ void setExtendedState(Frame frame, int state);
+ /*
+ * Gets the state of this frame.
+ */
+ int getExtendedState(Frame frame);
+ }
+
+ /*
+ * An interface of accessor for the java.awt.KeyboardFocusManager class.
+ */
+ public interface KeyboardFocusManagerAccessor {
+ /*
+ * Indicates whether the native implementation should
+ * proceed with a pending focus request for the heavyweight.
+ */
+ int shouldNativelyFocusHeavyweight(Component heavyweight,
+ Component descendant,
+ boolean temporary,
+ boolean focusedWindowChangeAllowed,
+ long time,
+ CausedFocusEvent.Cause cause);
+ /*
+ * Delivers focus for the lightweight descendant of the heavyweight
+ * synchronously.
+ */
+ boolean processSynchronousLightweightTransfer(Component heavyweight,
+ Component descendant,
+ boolean temporary,
+ boolean focusedWindowChangeAllowed,
+ long time);
+ /*
+ * Removes the last focus request for the heavyweight from the queue.
+ */
+ void removeLastFocusRequest(Component heavyweight);
+ }
+
+ /*
+ * The java.awt.Component class accessor object.
*/
private static ComponentAccessor componentAccessor;
- /** Set an accessor object for the java.awt.Component class.
+ /*
+ * The java.awt.Window class accessor object.
+ */
+ private static WindowAccessor windowAccessor;
+
+ /*
+ * The java.awt.AWTEvent class accessor object.
+ */
+ private static AWTEventAccessor awtEventAccessor;
+
+ /*
+ * The java.awt.Frame class accessor object.
+ */
+ private static FrameAccessor frameAccessor;
+
+ /*
+ * The java.awt.KeyboardFocusManager class accessor object.
+ */
+ private static KeyboardFocusManagerAccessor kfmAccessor;
+
+ /*
+ * Set an accessor object for the java.awt.Component class.
*/
public static void setComponentAccessor(ComponentAccessor ca) {
componentAccessor = ca;
}
- /** Retrieve the accessor object for the java.awt.Window class.
+ /*
+ * Retrieve the accessor object for the java.awt.Window class.
*/
public static ComponentAccessor getComponentAccessor() {
if (componentAccessor == null) {
@@ -74,4 +257,69 @@
return componentAccessor;
}
+
+ /*
+ * Set an accessor object for the java.awt.Window class.
+ */
+ public static void setWindowAccessor(WindowAccessor wa) {
+ windowAccessor = wa;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.Window class.
+ */
+ public static WindowAccessor getWindowAccessor() {
+ if (windowAccessor == null) {
+ unsafe.ensureClassInitialized(Window.class);
+ }
+ return windowAccessor;
+ }
+
+ /*
+ * Set an accessor object for the java.awt.AWTEvent class.
+ */
+ public static void setAWTEventAccessor(AWTEventAccessor aea) {
+ awtEventAccessor = aea;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.AWTEvent class.
+ */
+ public static AWTEventAccessor getAWTEventAccessor() {
+ return awtEventAccessor;
+ }
+
+ /*
+ * Set an accessor object for the java.awt.Frame class.
+ */
+ public static void setFrameAccessor(FrameAccessor fa) {
+ frameAccessor = fa;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.Frame class.
+ */
+ public static FrameAccessor getFrameAccessor() {
+ if (frameAccessor == null) {
+ unsafe.ensureClassInitialized(Frame.class);
+ }
+ return frameAccessor;
+ }
+
+ /*
+ * Set an accessor object for the java.awt.KeyboardFocusManager class.
+ */
+ public static void setKeyboardFocusManagerAccessor(KeyboardFocusManagerAccessor kfma) {
+ kfmAccessor = kfma;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.KeyboardFocusManager class.
+ */
+ public static KeyboardFocusManagerAccessor getKeyboardFocusManagerAccessor() {
+ if (kfmAccessor == null) {
+ unsafe.ensureClassInitialized(KeyboardFocusManager.class);
+ }
+ return kfmAccessor;
+ }
}
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/sun/awt/ComponentAccessor.java
--- a/jdk/src/share/classes/sun/awt/ComponentAccessor.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/sun/awt/ComponentAccessor.java Thu Apr 09 13:12:58 2009 -0700
@@ -73,7 +73,6 @@
private static Field fieldPacked;
private static Field fieldIgnoreRepaint;
private static Field fieldPeer;
- private static Method methodResetGC;
private static Field fieldVisible;
private static Method methodIsEnabledImpl;
private static Method methodGetCursorNoClientCode;
@@ -124,9 +123,6 @@
fieldPeer = componentClass.getDeclaredField("peer");
fieldPeer.setAccessible(true);
- methodResetGC = componentClass.getDeclaredMethod("resetGC", (Class[]) null);
- methodResetGC.setAccessible(true);
-
fieldVisible = componentClass.getDeclaredField("visible");
fieldVisible.setAccessible(true);
@@ -425,18 +421,6 @@
return false;
}
- public static void resetGC(Component c) {
- try {
- methodResetGC.invoke(c, (Object[]) null);
- }
- catch (IllegalAccessException e) {
- log.log(Level.FINE, "Unable to access the Component object", e);
- }
- catch (InvocationTargetException e) {
- log.log(Level.FINE, "Unable to invoke on the Component object", e);
- }
- }
-
public static boolean getVisible(Component c) {
try {
return fieldVisible.getBoolean(c);
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/sun/awt/EmbeddedFrame.java
--- a/jdk/src/share/classes/sun/awt/EmbeddedFrame.java Wed Jul 05 16:50:36 2017 +0200
+++ b/jdk/src/share/classes/sun/awt/EmbeddedFrame.java Thu Apr 09 13:12:58 2009 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright 1996-2006 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright 1996-2009 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -585,5 +585,14 @@
}
public void updateMinimumSize() {
}
- }
+
+ public void setOpacity(float opacity) {
+ }
+ public void setOpaque(boolean isOpaque) {
+ }
+ public void updateWindow(BufferedImage backBuffer) {
+ }
+ public void repositionSecurityWarning() {
+ }
+ }
} // class EmbeddedFrame
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/classes/sun/awt/ExtendedKeyCodes.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/sun/awt/ExtendedKeyCodes.java Thu Apr 09 13:12:58 2009 -0700
@@ -0,0 +1,670 @@
+package sun.awt;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.awt.event.KeyEvent;
+
+public class ExtendedKeyCodes {
+ /**
+ * ATTN: These are the readonly hashes with load factor == 1;
+ * adding a value, please set the inital capacity to exact number of items
+ * or higher.
+ */
+ // Keycodes declared in KeyEvent.java with corresponding Unicode values.
+ private final static HashMapWindow ancestor of the component comp.
+ * @return Window ancestor of the component or component by itself if it is Window;
+ * null, if component is not a part of window hierarchy
+ */
+ public static Window getContainingWindow(Component comp) {
+ while (comp != null && !(comp instanceof Window)) {
+ comp = comp.getParent();
+ }
+ return (Window)comp;
+ }
+
private static Boolean sunAwtDisableMixing = null;
/**
@@ -1995,6 +2015,73 @@
public boolean isNativeGTKAvailable() {
return false;
}
+
+ // Cosntant alpha
+ public boolean isWindowOpacitySupported() {
+ return false;
+ }
+
+ // Shaping
+ public boolean isWindowShapingSupported() {
+ return false;
+ }
+
+ // Per-pixel alpha
+ public boolean isWindowTranslucencySupported() {
+ return false;
+ }
+
+ public boolean isTranslucencyCapable(GraphicsConfiguration gc) {
+ return false;
+ }
+
+ /**
+ * Returns whether or not a containing top level window for the passed
+ * component is
+ * {@link com.sun.awt.AWTUtilities.Translucency#PERPIXEL_TRANSLUCENT PERPIXEL_TRANSLUCENT}.
+ *
+ * @param c a Component which toplevel's to check
+ * @return {@code true} if the passed component is not null and has a
+ * containing toplevel window which is opaque (so per-pixel translucency
+ * is not enabled), {@code false} otherwise
+ * @see com.sun.awt.AWTUtilities.Translucency#PERPIXEL_TRANSLUCENT
+ * @see com.sun.awt.AWTUtilities#isWindowOpaque(Window)
+ */
+ public static boolean isContainingTopLevelOpaque(Component c) {
+ Window w = getContainingWindow(c);
+ // return w != null && (w).isOpaque();
+ return w != null && com.sun.awt.AWTUtilities.isWindowOpaque(w);
+ }
+
+ /**
+ * Returns whether or not a containing top level window for the passed
+ * component is
+ * {@link com.sun.awt.AWTUtilities.Translucency#TRANSLUCENT TRANSLUCENT}.
+ *
+ * @param c a Component which toplevel's to check
+ * @return {@code true} if the passed component is not null and has a
+ * containing toplevel window which has opacity less than
+ * 1.0f (which means that it is translucent), {@code false} otherwise
+ * @see com.sun.awt.AWTUtilities.Translucency#TRANSLUCENT
+ * @see com.sun.awt.AWTUtilities#getWindowOpacity(Window)
+ */
+ public static boolean isContainingTopLevelTranslucent(Component c) {
+ Window w = getContainingWindow(c);
+ // return w != null && (w).getOpacity() < 1.0f;
+ return w != null && com.sun.awt.AWTUtilities.getWindowOpacity((Window)w) < 1.0f;
+ }
+
+ /**
+ * Returns whether the native system requires using the peer.updateWindow()
+ * method to update the contents of a non-opaque window, or if usual
+ * painting procedures are sufficient. The default return value covers
+ * the X11 systems. On MS Windows this method is overriden in WToolkit
+ * to return true.
+ */
+ public boolean needUpdateWindow() {
+ return false;
+ }
+
} // class SunToolkit
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/share/native/sun/awt/utility/rect.c
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/native/sun/awt/utility/rect.c Thu Apr 09 13:12:58 2009 -0700
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2008-2009 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+#include "utility/rect.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/**
+ * bitsPerPixel must be 32 for now.
+ * outBuf must be large enough to conatin all the rectangles.
+ */
+int BitmapToYXBandedRectangles(int bitsPerPixel, int width, int height, unsigned char * buf, RECT_T * outBuf)
+{
+ //XXX: we might want to reuse the code in the splashscreen library,
+ // though we'd have to deal with the ALPHA_THRESHOLD and different
+ // image formats in this case.
+ int widthBytes = width * bitsPerPixel / 8;
+ int alignedWidth = (((widthBytes - 1) / 4) + 1) * 4;
+
+ RECT_T * out = outBuf;
+
+ RECT_T *pPrevLine = NULL, *pFirst = out, *pThis = pFirst;
+ int i, j, i0;
+ int length;
+
+ for (j = 0; j < height; j++) {
+ /* generate data for a scanline */
+
+ unsigned char *pSrc = (unsigned char *) buf + j * alignedWidth;
+ RECT_T *pLine = pThis;
+
+ i = 0;
+
+ do {
+ // pSrc[0,1,2] == B,G,R; pSrc[3] == Alpha
+ while (i < width && !pSrc[3]) {
+ pSrc += 4;
+ ++i;
+ }
+ if (i >= width)
+ break;
+ i0 = i;
+ while (i < width && pSrc[3]) {
+ pSrc += 4;
+ ++i;
+ }
+ RECT_SET(*pThis, i0, j, i - i0, 1);
+ ++pThis;
+ } while (i < width);
+
+ /* check if the previous scanline is exactly the same, merge if so
+ (this is the only optimization we can use for YXBanded rectangles,
+ and win32 supports YXBanded only */
+
+ length = pThis - pLine;
+ if (pPrevLine && pLine - pPrevLine == length) {
+ for (i = 0; i < length && RECT_EQ_X(pPrevLine[i], pLine[i]); ++i) {
+ }
+ if (i == pLine - pPrevLine) {
+ // do merge
+ for (i = 0; i < length; i++) {
+ RECT_INC_HEIGHT(pPrevLine[i]);
+ }
+ pThis = pLine;
+ continue;
+ }
+ }
+ /* or else use the generated scanline */
+
+ pPrevLine = pLine;
+ }
+
+ return pThis - pFirst;
+}
+
+#if defined(__cplusplus)
+}
+#endif
diff -r 15096652c4d4 -r f6d72be571ab jdk/src/solaris/classes/sun/awt/X11/InfoWindow.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/solaris/classes/sun/awt/X11/InfoWindow.java Thu Apr 09 13:12:58 2009 -0700
@@ -0,0 +1,495 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package sun.awt.X11;
+
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.peer.TrayIconPeer;
+import sun.awt.*;
+import java.awt.image.*;
+import java.text.BreakIterator;
+import java.util.logging.Logger;
+import java.util.logging.Level;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.lang.reflect.InvocationTargetException;
+
+/**
+ * An utility window class. This is a base class for Tooltip and Balloon.
+ */
+public abstract class InfoWindow extends Window {
+ private Container container;
+ private Closer closer;
+
+ protected InfoWindow(Frame parent, Color borderColor) {
+ super(parent);
+ container = new Container() {
+ @Override
+ public Insets getInsets() {
+ return new Insets(1, 1, 1, 1);
+ }
+ };
+ setLayout(new BorderLayout());
+ setBackground(borderColor);
+ add(container, BorderLayout.CENTER);
+ container.setLayout(new BorderLayout());
+
+ closer = new Closer();
+ }
+
+ public Component add(Component c) {
+ container.add(c, BorderLayout.CENTER);
+ return c;
+ }
+
+ protected void setCloser(Runnable action, int time) {
+ closer.set(action, time);
+ }
+
+ // Must be executed on EDT.
+ protected void show(Point corner, int indent) {
+ assert SunToolkit.isDispatchThreadForAppContext(this);
+
+ pack();
+
+ Dimension size = getSize();
+ // TODO: When 6356322 is fixed we should get screen bounds in
+ // this way: eframe.getGraphicsConfiguration().getBounds().
+ Dimension scrSize = Toolkit.getDefaultToolkit().getScreenSize();
+
+ if (corner.x < scrSize.width/2 && corner.y < scrSize.height/2) { // 1st square
+ setLocation(corner.x + indent, corner.y + indent);
+
+ } else if (corner.x >= scrSize.width/2 && corner.y < scrSize.height/2) { // 2nd square
+ setLocation(corner.x - indent - size.width, corner.y + indent);
+
+ } else if (corner.x < scrSize.width/2 && corner.y >= scrSize.height/2) { // 3rd square
+ setLocation(corner.x + indent, corner.y - indent - size.height);
+
+ } else if (corner.x >= scrSize.width/2 && corner.y >= scrSize.height/2) { // 4th square
+ setLocation(corner.x - indent - size.width, corner.y - indent - size.height);
+ }
+
+ super.show();
+ closer.schedule();
+ }
+
+ public void hide() {
+ closer.close();
+ }
+
+ private class Closer implements Runnable {
+ Runnable action;
+ int time;
+
+ public void run() {
+ doClose();
+ }
+
+ void set(Runnable action, int time) {
+ this.action = action;
+ this.time = time;
+ }
+
+ void schedule() {
+ XToolkit.schedule(this, time);
+ }
+
+ void close() {
+ XToolkit.remove(this);
+ doClose();
+ }
+
+ // WARNING: this method may be executed on Toolkit thread.
+ private void doClose() {
+ SunToolkit.executeOnEventHandlerThread(InfoWindow.this, new Runnable() {
+ public void run() {
+ InfoWindow.super.hide();
+ invalidate();
+ if (action != null) {
+ action.run();
+ }
+ }
+ });
+ }
+ }
+
+
+ private interface LiveArguments {
+ /** Whether the target of the InfoWindow is disposed. */
+ boolean isDisposed();
+
+ /** The bounds of the target of the InfoWindow. */
+ Rectangle getBounds();
+ }
+
+ public static class Tooltip extends InfoWindow {
+
+ public interface LiveArguments extends InfoWindow.LiveArguments {
+ /** The tooltip to be displayed. */
+ String getTooltipString();
+ }
+
+ private final Object target;
+ private final LiveArguments liveArguments;
+
+ private final Label textLabel = new Label("");
+ private final Runnable starter = new Runnable() {
+ public void run() {
+ display();
+ }};
+
+ private final static int TOOLTIP_SHOW_TIME = 10000;
+ private final static int TOOLTIP_START_DELAY_TIME = 1000;
+ private final static int TOOLTIP_MAX_LENGTH = 64;
+ private final static int TOOLTIP_MOUSE_CURSOR_INDENT = 5;
+ private final static Color TOOLTIP_BACKGROUND_COLOR = new Color(255, 255, 220);
+ private final static Font TOOLTIP_TEXT_FONT = XWindow.getDefaultFont();
+
+ public Tooltip(Frame parent, Object target,
+ LiveArguments liveArguments)
+ {
+ super(parent, Color.black);
+
+ this.target = target;
+ this.liveArguments = liveArguments;
+
+ XTrayIconPeer.suppressWarningString(this);
+
+ setCloser(null, TOOLTIP_SHOW_TIME);
+ textLabel.setBackground(TOOLTIP_BACKGROUND_COLOR);
+ textLabel.setFont(TOOLTIP_TEXT_FONT);
+ add(textLabel);
+ }
+
+ /*
+ * WARNING: this method is executed on Toolkit thread!
+ */
+ private void display() {
+ String tooltipString = liveArguments.getTooltipString();
+ if (tooltipString == null) {
+ return;
+ } else if (tooltipString.length() > TOOLTIP_MAX_LENGTH) {
+ textLabel.setText(tooltipString.substring(0, TOOLTIP_MAX_LENGTH));
+ } else {
+ textLabel.setText(tooltipString);
+ }
+
+ // Execute on EDT to avoid deadlock (see 6280857).
+ SunToolkit.executeOnEventHandlerThread(target, new Runnable() {
+ public void run() {
+ if (liveArguments.isDisposed()) {
+ return;
+ }
+ Point pointer = (Point)AccessController.doPrivileged(new PrivilegedAction() {
+ public Object run() {
+ if (!isPointerOverTrayIcon(liveArguments.getBounds())) {
+ return null;
+ }
+ return MouseInfo.getPointerInfo().getLocation();
+ }
+ });
+ if (pointer == null) {
+ return;
+ }
+ show(new Point(pointer.x, pointer.y), TOOLTIP_MOUSE_CURSOR_INDENT);
+ }
+ });
+ }
+
+ public void enter() {
+ XToolkit.schedule(starter, TOOLTIP_START_DELAY_TIME);
+ }
+
+ public void exit() {
+ XToolkit.remove(starter);
+ if (isVisible()) {
+ hide();
+ }
+ }
+
+ private boolean isPointerOverTrayIcon(Rectangle trayRect) {
+ Point p = MouseInfo.getPointerInfo().getLocation();
+ return !(p.x < trayRect.x || p.x > (trayRect.x + trayRect.width) ||
+ p.y < trayRect.y || p.y > (trayRect.y + trayRect.height));
+ }
+ }
+
+ public static class Balloon extends InfoWindow {
+
+ public interface LiveArguments extends InfoWindow.LiveArguments {
+ /** The action to be performed upon clicking the baloon. */
+ String getActionCommand();
+ }
+
+ private final LiveArguments liveArguments;
+ private final Object target;
+
+ private final static int BALLOON_SHOW_TIME = 10000;
+ private final static int BALLOON_TEXT_MAX_LENGTH = 256;
+ private final static int BALLOON_WORD_LINE_MAX_LENGTH = 16;
+ private final static int BALLOON_WORD_LINE_MAX_COUNT = 4;
+ private final static int BALLOON_ICON_WIDTH = 32;
+ private final static int BALLOON_ICON_HEIGHT = 32;
+ private final static int BALLOON_TRAY_ICON_INDENT = 0;
+ private final static Color BALLOON_CAPTION_BACKGROUND_COLOR = new Color(200, 200 ,255);
+ private final static Font BALLOON_CAPTION_FONT = new Font(Font.DIALOG, Font.BOLD, 12);
+
+ private Panel mainPanel = new Panel();
+ private Panel captionPanel = new Panel();
+ private Label captionLabel = new Label("");
+ private Button closeButton = new Button("X");
+ private Panel textPanel = new Panel();
+ private XTrayIconPeer.IconCanvas iconCanvas = new XTrayIconPeer.IconCanvas(BALLOON_ICON_WIDTH, BALLOON_ICON_HEIGHT);
+ private Label[] lineLabels = new Label[BALLOON_WORD_LINE_MAX_COUNT];
+ private ActionPerformer ap = new ActionPerformer();
+
+ private Image iconImage;
+ private Image errorImage;
+ private Image warnImage;
+ private Image infoImage;
+ private boolean gtkImagesLoaded;
+
+ private Displayer displayer = new Displayer();
+
+ public Balloon(Frame parent, Object target, LiveArguments liveArguments) {
+ super(parent, new Color(90, 80 ,190));
+ this.liveArguments = liveArguments;
+ this.target = target;
+
+ XTrayIconPeer.suppressWarningString(this);
+
+ setCloser(new Runnable() {
+ public void run() {
+ if (textPanel != null) {
+ textPanel.removeAll();
+ textPanel.setSize(0, 0);
+ iconCanvas.setSize(0, 0);
+ XToolkit.awtLock();
+ try {
+ displayer.isDisplayed = false;
+ XToolkit.awtLockNotifyAll();
+ } finally {
+ XToolkit.awtUnlock();
+ }
+ }
+ }
+ }, BALLOON_SHOW_TIME);
+
+ add(mainPanel);
+
+ captionLabel.setFont(BALLOON_CAPTION_FONT);
+ captionLabel.addMouseListener(ap);
+
+ captionPanel.setLayout(new BorderLayout());
+ captionPanel.add(captionLabel, BorderLayout.WEST);
+ captionPanel.add(closeButton, BorderLayout.EAST);
+ captionPanel.setBackground(BALLOON_CAPTION_BACKGROUND_COLOR);
+ captionPanel.addMouseListener(ap);
+
+ closeButton.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ hide();
+ }
+ });
+
+ mainPanel.setLayout(new BorderLayout());
+ mainPanel.setBackground(Color.white);
+ mainPanel.add(captionPanel, BorderLayout.NORTH);
+ mainPanel.add(iconCanvas, BorderLayout.WEST);
+ mainPanel.add(textPanel, BorderLayout.CENTER);
+
+ iconCanvas.addMouseListener(ap);
+
+ for (int i = 0; i < BALLOON_WORD_LINE_MAX_COUNT; i++) {
+ lineLabels[i] = new Label();
+ lineLabels[i].addMouseListener(ap);
+ lineLabels[i].setBackground(Color.white);
+ }
+
+ displayer.start();
+ }
+
+ public void display(String caption, String text, String messageType) {
+ if (!gtkImagesLoaded) {
+ loadGtkImages();
+ }
+ displayer.display(caption, text, messageType);
+ }
+
+ private void _display(String caption, String text, String messageType) {
+ captionLabel.setText(caption);
+
+ BreakIterator iter = BreakIterator.getWordInstance();
+ if (text != null) {
+ iter.setText(text);
+ int start = iter.first(), end;
+ int nLines = 0;
+
+ do {
+ end = iter.next();
+
+ if (end == BreakIterator.DONE ||
+ text.substring(start, end).length() >= 50)
+ {
+ lineLabels[nLines].setText(text.substring(start, end == BreakIterator.DONE ?
+ iter.last() : end));
+ textPanel.add(lineLabels[nLines++]);
+ start = end;
+ }
+ if (nLines == BALLOON_WORD_LINE_MAX_COUNT) {
+ if (end != BreakIterator.DONE) {
+ lineLabels[nLines - 1].setText(
+ new String(lineLabels[nLines - 1].getText() + " ..."));
+ }
+ break;
+ }
+ } while (end != BreakIterator.DONE);
+
+
+ textPanel.setLayout(new GridLayout(nLines, 1));
+ }
+
+ if ("ERROR".equals(messageType)) {
+ iconImage = errorImage;
+ } else if ("WARNING".equals(messageType)) {
+ iconImage = warnImage;
+ } else if ("INFO".equals(messageType)) {
+ iconImage = infoImage;
+ } else {
+ iconImage = null;
+ }
+
+ if (iconImage != null) {
+ Dimension tpSize = textPanel.getSize();
+ iconCanvas.setSize(BALLOON_ICON_WIDTH, (BALLOON_ICON_HEIGHT > tpSize.height ?
+ BALLOON_ICON_HEIGHT : tpSize.height));
+ iconCanvas.validate();
+ }
+
+ SunToolkit.executeOnEventHandlerThread(target, new Runnable() {
+ public void run() {
+ if (liveArguments.isDisposed()) {
+ return;
+ }
+ Point parLoc = getParent().getLocationOnScreen();
+ Dimension parSize = getParent().getSize();
+ show(new Point(parLoc.x + parSize.width/2, parLoc.y + parSize.height/2),
+ BALLOON_TRAY_ICON_INDENT);
+ if (iconImage != null) {
+ iconCanvas.updateImage(iconImage); // call it after the show(..) above
+ }
+ }
+ });
+ }
+
+ public void dispose() {
+ displayer.interrupt();
+ super.dispose();
+ }
+
+ private void loadGtkImages() {
+ if (!gtkImagesLoaded) {
+ errorImage = (Image)Toolkit.getDefaultToolkit().getDesktopProperty(
+ "gtk.icon.gtk-dialog-error.6.rtl");
+ warnImage = (Image)Toolkit.getDefaultToolkit().getDesktopProperty(
+ "gtk.icon.gtk-dialog-warning.6.rtl");
+ infoImage = (Image)Toolkit.getDefaultToolkit().getDesktopProperty(
+ "gtk.icon.gtk-dialog-info.6.rtl");
+ gtkImagesLoaded = true;
+ }
+ }
+
+ private class ActionPerformer extends MouseAdapter {
+ public void mouseClicked(MouseEvent e) {
+ // hide the balloon by any click
+ hide();
+ if (e.getButton() == MouseEvent.BUTTON1) {
+ ActionEvent aev = new ActionEvent(target, ActionEvent.ACTION_PERFORMED,
+ liveArguments.getActionCommand(),
+ e.getWhen(), e.getModifiers());
+ Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(aev);
+ }
+ }
+ }
+
+ private class Displayer extends Thread {
+ final int MAX_CONCURRENT_MSGS = 10;
+
+ ArrayBlockingQueue