/*
* Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package javax.swing;
import sun.awt.
AWTAccessor;
import javax.swing.plaf.
LayerUI;
import javax.swing.border.
Border;
import javax.accessibility.*;
import java.awt.*;
import java.awt.event.*;
import java.beans.
PropertyChangeEvent;
import java.beans.
PropertyChangeListener;
import java.io.
IOException;
import java.io.
ObjectInputStream;
import java.util.
ArrayList;
import java.security.
AccessController;
import java.security.
PrivilegedAction;
/**
* {@code JLayer} is a universal decorator for Swing components
* which enables you to implement various advanced painting effects as well as
* receive notifications of all {@code AWTEvent}s generated within its borders.
* <p>
* {@code JLayer} delegates the handling of painting and input events to a
* {@link javax.swing.plaf.LayerUI} object, which performs the actual decoration.
* <p>
* The custom painting implemented in the {@code LayerUI} and events notification
* work for the JLayer itself and all its subcomponents.
* This combination enables you to enrich existing components
* by adding new advanced functionality such as temporary locking of a hierarchy,
* data tips for compound components, enhanced mouse scrolling etc and so on.
* <p>
* {@code JLayer} is a good solution if you only need to do custom painting
* over compound component or catch input events from its subcomponents.
* <pre>
* import javax.swing.*;
* import javax.swing.plaf.LayerUI;
* import java.awt.*;
*
* public class JLayerSample {
*
* private static JLayer<JComponent> createLayer() {
* // This custom layerUI will fill the layer with translucent green
* // and print out all mouseMotion events generated within its borders
* LayerUI<JComponent> layerUI = new LayerUI<JComponent>() {
*
* public void paint(Graphics g, JComponent c) {
* // paint the layer as is
* super.paint(g, c);
* // fill it with the translucent green
* g.setColor(new Color(0, 128, 0, 128));
* g.fillRect(0, 0, c.getWidth(), c.getHeight());
* }
*
* public void installUI(JComponent c) {
* super.installUI(c);
* // enable mouse motion events for the layer's subcomponents
* ((JLayer) c).setLayerEventMask(AWTEvent.MOUSE_MOTION_EVENT_MASK);
* }
*
* public void uninstallUI(JComponent c) {
* super.uninstallUI(c);
* // reset the layer event mask
* ((JLayer) c).setLayerEventMask(0);
* }
*
* // overridden method which catches MouseMotion events
* public void eventDispatched(AWTEvent e, JLayer<? extends JComponent> l) {
* System.out.println("AWTEvent detected: " + e);
* }
* };
* // create a component to be decorated with the layer
* JPanel panel = new JPanel();
* panel.add(new JButton("JButton"));
*
* // create the layer for the panel using our custom layerUI
* return new JLayer<JComponent>(panel, layerUI);
* }
*
* private static void createAndShowGUI() {
* final JFrame frame = new JFrame();
* frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
*
* // work with the layer as with any other Swing component
* frame.add(createLayer());
*
* frame.setSize(200, 200);
* frame.setLocationRelativeTo(null);
* frame.setVisible(true);
* }
*
* public static void main(String[] args) throws Exception {
* SwingUtilities.invokeAndWait(new Runnable() {
* public void run() {
* createAndShowGUI();
* }
* });
* }
* }
* </pre>
*
* <b>Note:</b> {@code JLayer} doesn't support the following methods:
* <ul>
* <li>{@link Container#add(java.awt.Component)}</li>
* <li>{@link Container#add(String, java.awt.Component)}</li>
* <li>{@link Container#add(java.awt.Component, int)}</li>
* <li>{@link Container#add(java.awt.Component, Object)}</li>
* <li>{@link Container#add(java.awt.Component, Object, int)}</li>
* </ul>
* using any of of them will cause {@code UnsupportedOperationException} to be thrown,
* to add a component to {@code JLayer}
* use {@link #setView(Component)} or {@link #setGlassPane(JPanel)}.
*
* @param <V> the type of {@code JLayer}'s view component
*
* @see #JLayer(Component)
* @see #setView(Component)
* @see #getView()
* @see javax.swing.plaf.LayerUI
* @see #JLayer(Component, LayerUI)
* @see #setUI(javax.swing.plaf.LayerUI)
* @see #getUI()
* @since 1.7
*
* @author Alexander Potochkin
*/
public final class
JLayer<V extends
Component>
extends
JComponent
implements
Scrollable,
PropertyChangeListener,
Accessible {
private V
view;
// this field is necessary because JComponent.ui is transient
// when layerUI is serializable
private
LayerUI<? super V>
layerUI;
private
JPanel glassPane;
private long
eventMask;
private transient boolean
isPainting;
private transient boolean
isPaintingImmediately;
private static final
LayerEventController eventController =
new
LayerEventController();
/**
* Creates a new {@code JLayer} object with a {@code null} view component
* and default {@link javax.swing.plaf.LayerUI}.
*
* @see #setView
* @see #setUI
*/
public
JLayer() {
this(null);
}
/**
* Creates a new {@code JLayer} object
* with default {@link javax.swing.plaf.LayerUI}.
*
* @param view the component to be decorated by this {@code JLayer}
*
* @see #setUI
*/
public
JLayer(V
view) {
this(
view, new
LayerUI<V>());
}
/**
* Creates a new {@code JLayer} object with the specified view component
* and {@link javax.swing.plaf.LayerUI} object.
*
* @param view the component to be decorated
* @param ui the {@link javax.swing.plaf.LayerUI} delegate
* to be used by this {@code JLayer}
*/
public
JLayer(V
view,
LayerUI<V>
ui) {
setGlassPane(
createGlassPane());
setView(
view);
setUI(
ui);
}
/**
* Returns the {@code JLayer}'s view component or {@code null}.
* <br>This is a bound property.
*
* @return the {@code JLayer}'s view component
* or {@code null} if none exists
*
* @see #setView(Component)
*/
public V
getView() {
return
view;
}
/**
* Sets the {@code JLayer}'s view component, which can be {@code null}.
* <br>This is a bound property.
*
* @param view the view component for this {@code JLayer}
*
* @see #getView()
*/
public void
setView(V
view) {
Component oldView =
getView();
if (
oldView != null) {
super.remove(
oldView);
}
if (
view != null) {
super.addImpl(
view, null,
getComponentCount());
}
this.
view =
view;
firePropertyChange("view",
oldView,
view);
revalidate();
repaint();
}
/**
* Sets the {@link javax.swing.plaf.LayerUI} which will perform painting
* and receive input events for this {@code JLayer}.
*
* @param ui the {@link javax.swing.plaf.LayerUI} for this {@code JLayer}
*/
public void
setUI(
LayerUI<? super V>
ui) {
this.
layerUI =
ui;
super.setUI(
ui);
}
/**
* Returns the {@link javax.swing.plaf.LayerUI} for this {@code JLayer}.
*
* @return the {@code LayerUI} for this {@code JLayer}
*/
public
LayerUI<? super V>
getUI() {
return
layerUI;
}
/**
* Returns the {@code JLayer}'s glassPane component or {@code null}.
* <br>This is a bound property.
*
* @return the {@code JLayer}'s glassPane component
* or {@code null} if none exists
*
* @see #setGlassPane(JPanel)
*/
public
JPanel getGlassPane() {
return
glassPane;
}
/**
* Sets the {@code JLayer}'s glassPane component, which can be {@code null}.
* <br>This is a bound property.
*
* @param glassPane the glassPane component of this {@code JLayer}
*
* @see #getGlassPane()
*/
public void
setGlassPane(
JPanel glassPane) {
Component oldGlassPane =
getGlassPane();
boolean
isGlassPaneVisible = false;
if (
oldGlassPane != null) {
isGlassPaneVisible =
oldGlassPane.
isVisible();
super.remove(
oldGlassPane);
}
if (
glassPane != null) {
AWTAccessor.
getComponentAccessor().
setMixingCutoutShape(
glassPane,
new
Rectangle());
glassPane.
setVisible(
isGlassPaneVisible);
super.addImpl(
glassPane, null, 0);
}
this.
glassPane =
glassPane;
firePropertyChange("glassPane",
oldGlassPane,
glassPane);
revalidate();
repaint();
}
/**
* Called by the constructor methods to create a default {@code glassPane}.
* By default this method creates a new JPanel with visibility set to true
* and opacity set to false.
*
* @return the default {@code glassPane}
*/
public
JPanel createGlassPane() {
return new
DefaultLayerGlassPane();
}
/**
* Sets the layout manager for this container. This method is
* overridden to prevent the layout manager from being set.
* <p>Note: If {@code mgr} is non-{@code null}, this
* method will throw an exception as layout managers are not supported on
* a {@code JLayer}.
*
* @param mgr the specified layout manager
* @exception IllegalArgumentException this method is not supported
*/
public void
setLayout(
LayoutManager mgr) {
if (
mgr != null) {
throw new
IllegalArgumentException("JLayer.setLayout() not supported");
}
}
/**
* A non-{@code null} border, or non-zero insets, isn't supported, to prevent the geometry
* of this component from becoming complex enough to inhibit
* subclassing of {@code LayerUI} class. To create a {@code JLayer} with a border,
* add it to a {@code JPanel} that has a border.
* <p>Note: If {@code border} is non-{@code null}, this
* method will throw an exception as borders are not supported on
* a {@code JLayer}.
*
* @param border the {@code Border} to set
* @exception IllegalArgumentException this method is not supported
*/
public void
setBorder(
Border border) {
if (
border != null) {
throw new
IllegalArgumentException("JLayer.setBorder() not supported");
}
}
/**
* This method is not supported by {@code JLayer}
* and always throws {@code UnsupportedOperationException}
*
* @throws UnsupportedOperationException this method is not supported
*
* @see #setView(Component)
* @see #setGlassPane(JPanel)
*/
protected void
addImpl(
Component comp,
Object constraints, int
index) {
throw new
UnsupportedOperationException(
"Adding components to JLayer is not supported, " +
"use setView() or setGlassPane() instead");
}
/**
* {@inheritDoc}
*/
public void
remove(
Component comp) {
if (
comp == null) {
super.remove(
comp);
} else if (
comp ==
getView()) {
setView(null);
} else if (
comp ==
getGlassPane()) {
setGlassPane(null);
} else {
super.remove(
comp);
}
}
/**
* {@inheritDoc}
*/
public void
removeAll() {
if (
view != null) {
setView(null);
}
if (
glassPane != null) {
setGlassPane(null);
}
}
/**
* Always returns {@code true} to cause painting to originate from {@code JLayer},
* or one of its ancestors.
*
* @return true
* @see JComponent#isPaintingOrigin()
*/
protected boolean
isPaintingOrigin() {
return true;
}
/**
* Delegates its functionality to the
* {@link javax.swing.plaf.LayerUI#paintImmediately(int, int, int, int, JLayer)} method,
* if {@code LayerUI} is set.
*
* @param x the x value of the region to be painted
* @param y the y value of the region to be painted
* @param w the width of the region to be painted
* @param h the height of the region to be painted
*/
public void
paintImmediately(int
x, int
y, int
w, int
h) {
if (!
isPaintingImmediately &&
getUI() != null) {
isPaintingImmediately = true;
try {
getUI().
paintImmediately(
x,
y,
w,
h, this);
} finally {
isPaintingImmediately = false;
}
} else {
super.paintImmediately(
x,
y,
w,
h);
}
}
/**
* Delegates all painting to the {@link javax.swing.plaf.LayerUI} object.
*
* @param g the {@code Graphics} to render to
*/
public void
paint(
Graphics g) {
if (!
isPainting) {
isPainting = true;
try {
super.paintComponent(
g);
} finally {
isPainting = false;
}
} else {
super.paint(
g);
}
}
/**
* This method is empty, because all painting is done by
* {@link #paint(Graphics)} and
* {@link javax.swing.plaf.LayerUI#update(Graphics, JComponent)} methods
*/
protected void
paintComponent(
Graphics g) {
}
/**
* The {@code JLayer} overrides the default implementation of
* this method (in {@code JComponent}) to return {@code false}.
* This ensures
* that the drawing machinery will call the {@code JLayer}'s
* {@code paint}
* implementation rather than messaging the {@code JLayer}'s
* children directly.
*
* @return false
*/
public boolean
isOptimizedDrawingEnabled() {
return false;
}
/**
* {@inheritDoc}
*/
public void
propertyChange(
PropertyChangeEvent evt) {
if (
getUI() != null) {
getUI().
applyPropertyChange(
evt, this);
}
}
/**
* Enables the events from JLayer and <b>all its descendants</b>
* defined by the specified event mask parameter
* to be delivered to the
* {@link LayerUI#eventDispatched(AWTEvent, JLayer)} method.
* <p>
* Events are delivered provided that {@code LayerUI} is set
* for this {@code JLayer} and the {@code JLayer}
* is displayable.
* <p>
* The following example shows how to correctly use this method
* in the {@code LayerUI} implementations:
* <pre>
* public void installUI(JComponent c) {
* super.installUI(c);
* JLayer l = (JLayer) c;
* // this LayerUI will receive only key and focus events
* l.setLayerEventMask(AWTEvent.KEY_EVENT_MASK | AWTEvent.FOCUS_EVENT_MASK);
* }
*
* public void uninstallUI(JComponent c) {
* super.uninstallUI(c);
* JLayer l = (JLayer) c;
* // JLayer must be returned to its initial state
* l.setLayerEventMask(0);
* }
* </pre>
*
* By default {@code JLayer} receives no events and its event mask is {@code 0}.
*
* @param layerEventMask the bitmask of event types to receive
*
* @see #getLayerEventMask()
* @see LayerUI#eventDispatched(AWTEvent, JLayer)
* @see Component#isDisplayable()
*/
public void
setLayerEventMask(long
layerEventMask) {
long
oldEventMask =
getLayerEventMask();
this.
eventMask =
layerEventMask;
firePropertyChange("layerEventMask",
oldEventMask,
layerEventMask);
if (
layerEventMask !=
oldEventMask) {
disableEvents(
oldEventMask);
enableEvents(
eventMask);
if (
isDisplayable()) {
eventController.
updateAWTEventListener(
oldEventMask,
layerEventMask);
}
}
}
/**
* Returns the bitmap of event mask to receive by this {@code JLayer}
* and its {@code LayerUI}.
* <p>
* It means that {@link javax.swing.plaf.LayerUI#eventDispatched(AWTEvent, JLayer)} method
* will only receive events that match the event mask.
* <p>
* By default {@code JLayer} receives no events.
*
* @return the bitmask of event types to receive for this {@code JLayer}
*/
public long
getLayerEventMask() {
return
eventMask;
}
/**
* Delegates its functionality to the {@link javax.swing.plaf.LayerUI#updateUI(JLayer)} method,
* if {@code LayerUI} is set.
*/
public void
updateUI() {
if (
getUI() != null) {
getUI().
updateUI(this);
}
}
/**
* Returns the preferred size of the viewport for a view component.
* <p>
* If the view component of this layer implements {@link Scrollable}, this method delegates its
* implementation to the view component.
*
* @return the preferred size of the viewport for a view component
*
* @see Scrollable
*/
public
Dimension getPreferredScrollableViewportSize() {
if (
getView() instanceof
Scrollable) {
return ((
Scrollable)
getView()).
getPreferredScrollableViewportSize();
}
return
getPreferredSize();
}
/**
* Returns a scroll increment, which is required for components
* that display logical rows or columns in order to completely expose
* one block of rows or columns, depending on the value of orientation.
* <p>
* If the view component of this layer implements {@link Scrollable}, this method delegates its
* implementation to the view component.
*
* @return the "block" increment for scrolling in the specified direction
*
* @see Scrollable
*/
public int
getScrollableBlockIncrement(
Rectangle visibleRect,
int
orientation, int
direction) {
if (
getView() instanceof
Scrollable) {
return ((
Scrollable)
getView()).
getScrollableBlockIncrement(
visibleRect,
orientation,
direction);
}
return (
orientation ==
SwingConstants.
VERTICAL) ?
visibleRect.
height :
visibleRect.
width;
}
/**
* Returns {@code false} to indicate that the height of the viewport does not
* determine the height of the layer, unless the preferred height
* of the layer is smaller than the height of the viewport.
* <p>
* If the view component of this layer implements {@link Scrollable}, this method delegates its
* implementation to the view component.
*
* @return whether the layer should track the height of the viewport
*
* @see Scrollable
*/
public boolean
getScrollableTracksViewportHeight() {
if (
getView() instanceof
Scrollable) {
return ((
Scrollable)
getView()).
getScrollableTracksViewportHeight();
}
return false;
}
/**
* Returns {@code false} to indicate that the width of the viewport does not
* determine the width of the layer, unless the preferred width
* of the layer is smaller than the width of the viewport.
* <p>
* If the view component of this layer implements {@link Scrollable}, this method delegates its
* implementation to the view component.
*
* @return whether the layer should track the width of the viewport
*
* @see Scrollable
*/
public boolean
getScrollableTracksViewportWidth() {
if (
getView() instanceof
Scrollable) {
return ((
Scrollable)
getView()).
getScrollableTracksViewportWidth();
}
return false;
}
/**
* Returns a scroll increment, which is required for components
* that display logical rows or columns in order to completely expose
* one new row or column, depending on the value of orientation.
* Ideally, components should handle a partially exposed row or column
* by returning the distance required to completely expose the item.
* <p>
* Scrolling containers, like {@code JScrollPane}, will use this method
* each time the user requests a unit scroll.
* <p>
* If the view component of this layer implements {@link Scrollable}, this method delegates its
* implementation to the view component.
*
* @return The "unit" increment for scrolling in the specified direction.
* This value should always be positive.
*
* @see Scrollable
*/
public int
getScrollableUnitIncrement(
Rectangle visibleRect, int
orientation,
int
direction) {
if (
getView() instanceof
Scrollable) {
return ((
Scrollable)
getView()).
getScrollableUnitIncrement(
visibleRect,
orientation,
direction);
}
return 1;
}
private void
readObject(
ObjectInputStream s)
throws
IOException,
ClassNotFoundException {
s.
defaultReadObject();
if (
layerUI != null) {
setUI(
layerUI);
}
if (
eventMask != 0) {
eventController.
updateAWTEventListener(0,
eventMask);
}
}
/**
* {@inheritDoc}
*/
public void
addNotify() {
super.addNotify();
eventController.
updateAWTEventListener(0,
eventMask);
}
/**
* {@inheritDoc}
*/
public void
removeNotify() {
super.removeNotify();
eventController.
updateAWTEventListener(
eventMask, 0);
}
/**
* Delegates its functionality to the {@link javax.swing.plaf.LayerUI#doLayout(JLayer)} method,
* if {@code LayerUI} is set.
*/
public void
doLayout() {
if (
getUI() != null) {
getUI().
doLayout(this);
}
}
/**
* Gets the AccessibleContext associated with this {@code JLayer}.
*
* @return the AccessibleContext associated with this {@code JLayer}.
*/
public
AccessibleContext getAccessibleContext() {
if (
accessibleContext == null) {
accessibleContext = new
AccessibleJComponent() {
public
AccessibleRole getAccessibleRole() {
return
AccessibleRole.
PANEL;
}
};
}
return
accessibleContext;
}
/**
* static AWTEventListener to be shared with all AbstractLayerUIs
*/
private static class
LayerEventController implements
AWTEventListener {
private
ArrayList<
Long>
layerMaskList =
new
ArrayList<
Long>();
private long
currentEventMask;
private static final long
ACCEPTED_EVENTS =
AWTEvent.
COMPONENT_EVENT_MASK |
AWTEvent.
CONTAINER_EVENT_MASK |
AWTEvent.
FOCUS_EVENT_MASK |
AWTEvent.
KEY_EVENT_MASK |
AWTEvent.
MOUSE_WHEEL_EVENT_MASK |
AWTEvent.
MOUSE_MOTION_EVENT_MASK |
AWTEvent.
MOUSE_EVENT_MASK |
AWTEvent.
INPUT_METHOD_EVENT_MASK |
AWTEvent.
HIERARCHY_EVENT_MASK |
AWTEvent.
HIERARCHY_BOUNDS_EVENT_MASK;
@
SuppressWarnings("unchecked")
public void
eventDispatched(
AWTEvent event) {
Object source =
event.
getSource();
if (
source instanceof
Component) {
Component component = (
Component)
source;
while (
component != null) {
if (
component instanceof
JLayer) {
JLayer l = (
JLayer)
component;
LayerUI ui =
l.
getUI();
if (
ui != null &&
isEventEnabled(
l.
getLayerEventMask(),
event.
getID()) &&
(!(
event instanceof
InputEvent) || !((
InputEvent)
event).
isConsumed())) {
ui.
eventDispatched(
event,
l);
}
}
component =
component.
getParent();
}
}
}
private void
updateAWTEventListener(long
oldEventMask, long
newEventMask) {
if (
oldEventMask != 0) {
layerMaskList.
remove(
oldEventMask);
}
if (
newEventMask != 0) {
layerMaskList.
add(
newEventMask);
}
long
combinedMask = 0;
for (
Long mask :
layerMaskList) {
combinedMask |=
mask;
}
// filter out all unaccepted events
combinedMask &=
ACCEPTED_EVENTS;
if (
combinedMask == 0) {
removeAWTEventListener();
} else if (
getCurrentEventMask() !=
combinedMask) {
removeAWTEventListener();
addAWTEventListener(
combinedMask);
}
currentEventMask =
combinedMask;
}
private long
getCurrentEventMask() {
return
currentEventMask;
}
private void
addAWTEventListener(final long
eventMask) {
AccessController.
doPrivileged(new
PrivilegedAction<
Void>() {
public
Void run() {
Toolkit.
getDefaultToolkit().
addAWTEventListener(
LayerEventController.this,
eventMask);
return null;
}
});
}
private void
removeAWTEventListener() {
AccessController.
doPrivileged(new
PrivilegedAction<
Void>() {
public
Void run() {
Toolkit.
getDefaultToolkit().
removeAWTEventListener(
LayerEventController.this);
return null;
}
});
}
private boolean
isEventEnabled(long
eventMask, int
id) {
return (((
eventMask &
AWTEvent.
COMPONENT_EVENT_MASK) != 0 &&
id >=
ComponentEvent.
COMPONENT_FIRST &&
id <=
ComponentEvent.
COMPONENT_LAST)
|| ((
eventMask &
AWTEvent.
CONTAINER_EVENT_MASK) != 0 &&
id >=
ContainerEvent.
CONTAINER_FIRST &&
id <=
ContainerEvent.
CONTAINER_LAST)
|| ((
eventMask &
AWTEvent.
FOCUS_EVENT_MASK) != 0 &&
id >=
FocusEvent.
FOCUS_FIRST &&
id <=
FocusEvent.
FOCUS_LAST)
|| ((
eventMask &
AWTEvent.
KEY_EVENT_MASK) != 0 &&
id >=
KeyEvent.
KEY_FIRST &&
id <=
KeyEvent.
KEY_LAST)
|| ((
eventMask &
AWTEvent.
MOUSE_WHEEL_EVENT_MASK) != 0 &&
id ==
MouseEvent.
MOUSE_WHEEL)
|| ((
eventMask &
AWTEvent.
MOUSE_MOTION_EVENT_MASK) != 0 &&
(
id ==
MouseEvent.
MOUSE_MOVED ||
id ==
MouseEvent.
MOUSE_DRAGGED))
|| ((
eventMask &
AWTEvent.
MOUSE_EVENT_MASK) != 0 &&
id !=
MouseEvent.
MOUSE_MOVED &&
id !=
MouseEvent.
MOUSE_DRAGGED &&
id !=
MouseEvent.
MOUSE_WHEEL &&
id >=
MouseEvent.
MOUSE_FIRST &&
id <=
MouseEvent.
MOUSE_LAST)
|| ((
eventMask &
AWTEvent.
INPUT_METHOD_EVENT_MASK) != 0 &&
id >=
InputMethodEvent.
INPUT_METHOD_FIRST &&
id <=
InputMethodEvent.
INPUT_METHOD_LAST)
|| ((
eventMask &
AWTEvent.
HIERARCHY_EVENT_MASK) != 0 &&
id ==
HierarchyEvent.
HIERARCHY_CHANGED)
|| ((
eventMask &
AWTEvent.
HIERARCHY_BOUNDS_EVENT_MASK) != 0 &&
(
id ==
HierarchyEvent.
ANCESTOR_MOVED ||
id ==
HierarchyEvent.
ANCESTOR_RESIZED)));
}
}
/**
* The default glassPane for the {@link javax.swing.JLayer}.
* It is a subclass of {@code JPanel} which is non opaque by default.
*/
private static class
DefaultLayerGlassPane extends
JPanel {
/**
* Creates a new {@link DefaultLayerGlassPane}
*/
public
DefaultLayerGlassPane() {
setOpaque(false);
}
/**
* First, implementation of this method iterates through
* glassPane's child components and returns {@code true}
* if any of them is visible and contains passed x,y point.
* After that it checks if no mouseListeners is attached to this component
* and no mouse cursor is set, then it returns {@code false},
* otherwise calls the super implementation of this method.
*
* @param x the <i>x</i> coordinate of the point
* @param y the <i>y</i> coordinate of the point
* @return true if this component logically contains x,y
*/
public boolean
contains(int
x, int
y) {
for (int
i = 0;
i <
getComponentCount();
i++) {
Component c =
getComponent(
i);
Point point =
SwingUtilities.
convertPoint(this, new
Point(
x,
y),
c);
if(
c.
isVisible() &&
c.
contains(
point)){
return true;
}
}
if (
getMouseListeners().length == 0
&&
getMouseMotionListeners().length == 0
&&
getMouseWheelListeners().length == 0
&& !
isCursorSet()) {
return false;
}
return super.contains(
x,
y);
}
}
}