* {@code JLayer} delegates the handling of painting and input events to a * {@link javax.swing.plaf.LayerUI} object, which performs the actual decoration. *
* 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. *
* {@code JLayer} is a good solution if you only need to do custom painting * over compound component or catch input events from its subcomponents. *
* 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();
* }
* });
* }
* }
*
*
* Note: {@code JLayer} doesn't support the following methods:
* 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. *
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 all its descendants * defined by the specified event mask parameter * to be delivered to the * {@link LayerUI#eventDispatched(AWTEvent, JLayer)} method. *
* Events are delivered provided that {@code LayerUI} is set * for this {@code JLayer} and the {@code JLayer} * is displayable. *
* The following example shows how to correctly use this method * in the {@code LayerUI} implementations: *
* 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);
* }
*
*
* 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}.
* * It means that {@link javax.swing.plaf.LayerUI#eventDispatched(AWTEvent, JLayer)} method * will only receive events that match the event mask. *
* 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. *
* 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. *
* 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. *
* 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. *
* 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. *
* Scrolling containers, like {@code JScrollPane}, will use this method * each time the user requests a unit scroll. *
* 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}.
*/
@SuppressWarnings("serial") // anonymous class
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