+ * // create a component to be decorated with the layer
+ * JPanel panel = new JPanel();
+ * panel.add(new JButton("JButton"));
+ * // This custom layerUI will fill the layer with translucent green
+ * // and print out all mouseMotion events generated within its borders
+ * LayerUI<JPanel> layerUI = new LayerUI<JPanel>() {
+ * public void paint(Graphics g, JCompo nent 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());
+ * }
+ * // overridden method which catches MouseMotion events
+ * public void eventDispatched(AWTEvent e, JLayer<JPanel> l) {
+ * System.out.println("AWTEvent detected: " + e);
+ * }
+ * };
+ * // create the layer for the panel using our custom layerUI
+ * JLayer<JPanel> layer = new JLayer<JPanel>(panel, layerUI);
+ * // work with the layer as with any other Swing component
+ * frame.add(layer);
+ *
+ *
+ * Note: {@code JLayer} doesn't support the following methods:
+ *
+ * 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.
+ *
+ * @param layerEventMask the bitmask of event types to receive
+ *
+ * @throws IllegalArgumentException if the {@code layerEventMask} parameter
+ * contains unsupported event types
+ * @see #getLayerEventMask()
+ */
+ public void setLayerEventMask(long layerEventMask) {
+ if (layerEventMask != (layerEventMask & ACCEPTED_EVENTS)) {
+ throw new IllegalArgumentException(
+ "The event bitmask contains unsupported event types");
+ }
+ long oldEventMask = getLayerEventMask();
+ this.eventMask = layerEventMask;
+ firePropertyChange("layerEventMask", oldEventMask, layerEventMask);
+ if (layerEventMask != oldEventMask) {
+ disableEvents(oldEventMask);
+ enableEvents(eventMask);
+ eventController.updateAWTEventListener(this);
+ }
+ }
+
+ /**
+ * 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 ui delegate of this layer is not {@code null}, this method delegates its
+ * implementation to the {@code LayerUI.getPreferredScrollableViewportSize(JLayer)}
+ *
+ * @return the preferred size of the viewport for a view component
+ *
+ * @see Scrollable
+ * @see LayerUI#getPreferredScrollableViewportSize(JLayer)
+ */
+ public Dimension getPreferredScrollableViewportSize() {
+ if (getUI() != null) {
+ return getUI().getPreferredScrollableViewportSize(this);
+ }
+ 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 ui delegate of this layer is not {@code null}, this method delegates its
+ * implementation to the {@code LayerUI.getScrollableBlockIncrement(JLayer,Rectangle,int,int)}
+ *
+ * @return the "block" increment for scrolling in the specified direction
+ *
+ * @see Scrollable
+ * @see LayerUI#getScrollableBlockIncrement(JLayer, Rectangle, int, int)
+ */
+ public int getScrollableBlockIncrement(Rectangle visibleRect,
+ int orientation, int direction) {
+ if (getUI() != null) {
+ return getUI().getScrollableBlockIncrement(this, 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 ui delegate of this layer is not null, this method delegates its
+ * implementation to the {@code LayerUI.getScrollableTracksViewportHeight(JLayer)}
+ *
+ * @return whether the layer should track the height of the viewport
+ *
+ * @see Scrollable
+ * @see LayerUI#getScrollableTracksViewportHeight(JLayer)
+ */
+ public boolean getScrollableTracksViewportHeight() {
+ if (getUI() != null) {
+ return getUI().getScrollableTracksViewportHeight(this);
+ }
+ if (getParent() instanceof JViewport) {
+ return ((getParent()).getHeight() > getPreferredSize().height);
+ }
+ 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 ui delegate of this layer is not null, this method delegates its
+ * implementation to the {@code LayerUI.getScrollableTracksViewportWidth(JLayer)}
+ *
+ * @return whether the layer should track the width of the viewport
+ *
+ * @see Scrollable
+ * @see LayerUI#getScrollableTracksViewportWidth(JLayer)
+ */
+ public boolean getScrollableTracksViewportWidth() {
+ if (getUI() != null) {
+ return getUI().getScrollableTracksViewportWidth(this);
+ }
+ if (getParent() instanceof JViewport) {
+ return ((getParent()).getWidth() > getPreferredSize().width);
+ }
+ 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 ui delegate of this layer is not {@code null}, this method delegates its
+ * implementation to the {@code LayerUI.getScrollableUnitIncrement(JLayer,Rectangle,int,int)}
+ *
+ * @return The "unit" increment for scrolling in the specified direction.
+ * This value should always be positive.
+ *
+ * @see Scrollable
+ * @see LayerUI#getScrollableUnitIncrement(JLayer, Rectangle, int, int)
+ */
+ public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation,
+ int direction) {
+ if (getUI() != null) {
+ return getUI().getScrollableUnitIncrement(
+ this, visibleRect, orientation, direction);
+ }
+ return 1;
+ }
+
+ private void readObject(ObjectInputStream s)
+ throws IOException, ClassNotFoundException {
+ s.defaultReadObject();
+ if (getUI() != null) {
+ setUI(getUI());
+ }
+ if (getLayerEventMask() != 0) {
+ eventController.updateAWTEventListener(this);
+ }
+ }
+
+ /**
+ * static AWTEventListener to be shared with all AbstractLayerUIs
+ */
+ private static class LayerEventController implements AWTEventListener {
+ private ArrayList+ * To enable the {@code AWTEvent} of the particular type, + * you call {@link javax.swing.JLayer#setLayerEventMask} + * in {@link #installUI(javax.swing.JComponent)} + * and set the layer event mask to {@code 0} + * in {@link #uninstallUI(javax.swing.JComponent)} after that + * + * @param e the event to be dispatched + * @param l the layer this LayerUI is set to + * + * @see JLayer#setLayerEventMask(long) + * @see javax.swing.JLayer#getLayerEventMask() + */ + public void eventDispatched(AWTEvent e, JLayer l){ + } + + /** + * Invoked when {@link javax.swing.JLayer#updateUI()} is called + * by the {@code JLayer} this {@code LayerUI} is set to. + * + * @param l the {@code JLayer} which UI is updated + */ + public void updateUI(JLayer l){ + } + + /** + * Configures the {@code JLayer} this {@code LayerUI} is set to. + * The default implementation registers the {@code LayerUI} + * as a property change listener for the passed {@code JLayer} component. + * + * @param c the {@code JLayer} component where this UI delegate is being installed + */ + public void installUI(JComponent c) { + addPropertyChangeListener((JLayer) c); + } + + /** + * Reverses the configuration which was previously set + * in the {@link #installUI(JComponent)} method. + * The default implementation unregisters the property change listener + * for the passed JLayer component. + * + * @param c the component from which this UI delegate is being removed. + */ + public void uninstallUI(JComponent c) { + removePropertyChangeListener((JLayer) c); + } + + /** + * Adds a PropertyChangeListener to the listener list. The listener is + * registered for all bound properties of this class. + *
+ * If {@code listener} is {@code null}, + * no exception is thrown and no action is performed. + * + * @param listener the property change listener to be added + * @see #removePropertyChangeListener + * @see #getPropertyChangeListeners + * @see #addPropertyChangeListener(String, java.beans.PropertyChangeListener) + */ + public void addPropertyChangeListener(PropertyChangeListener listener) { + propertyChangeSupport.addPropertyChangeListener(listener); + } + + /** + * Removes a PropertyChangeListener from the listener list. This method + * should be used to remove PropertyChangeListeners that were registered + * for all bound properties of this class. + * + * If {@code listener} is {@code null}, + * no exception is thrown and no action is performed. + * + * @param listener the PropertyChangeListener to be removed + * @see #addPropertyChangeListener + * @see #getPropertyChangeListeners + * @see #removePropertyChangeListener(String, PropertyChangeListener) + */ + public void removePropertyChangeListener(PropertyChangeListener listener) { + propertyChangeSupport.removePropertyChangeListener(listener); + } + + /** + * Returns an array of all the property change listeners + * registered on this component. + * + * @return all of this ui's {@code PropertyChangeListener}s + * or an empty array if no property change + * listeners are currently registered + * @see #addPropertyChangeListener + * @see #removePropertyChangeListener + * @see #getPropertyChangeListeners(String) + */ + public PropertyChangeListener[] getPropertyChangeListeners() { + return propertyChangeSupport.getPropertyChangeListeners(); + } + + /** + * Adds a PropertyChangeListener to the listener list for a specific + * property. + * + * If {@code propertyName} or {@code listener} is {@code null}, + * no exception is thrown and no action is taken. + * + * @param propertyName one of the property names listed above + * @param listener the property change listener to be added + * @see #removePropertyChangeListener(String, PropertyChangeListener) + * @see #getPropertyChangeListeners(String) + * @see #addPropertyChangeListener(String, PropertyChangeListener) + */ + public void addPropertyChangeListener(String propertyName, + PropertyChangeListener listener) { + propertyChangeSupport.addPropertyChangeListener(propertyName, listener); + } + + /** + * Removes a {@code PropertyChangeListener} from the listener + * list for a specific property. This method should be used to remove + * {@code PropertyChangeListener}s + * that were registered for a specific bound property. + * + * If {@code propertyName} or {@code listener} is {@code null}, + * no exception is thrown and no action is taken. + * + * @param propertyName a valid property name + * @param listener the PropertyChangeListener to be removed + * @see #addPropertyChangeListener(String, PropertyChangeListener) + * @see #getPropertyChangeListeners(String) + * @see #removePropertyChangeListener(PropertyChangeListener) + */ + public void removePropertyChangeListener(String propertyName, + PropertyChangeListener listener) { + propertyChangeSupport.removePropertyChangeListener(propertyName, listener); + } + + /** + * Returns an array of all the listeners which have been associated + * with the named property. + * + * @return all of the {@code PropertyChangeListener}s associated with + * the named property; if no such listeners have been added or + * if {@code propertyName} is {@code null}, an empty + * array is returned + * @see #addPropertyChangeListener(String, PropertyChangeListener) + * @see #removePropertyChangeListener(String, PropertyChangeListener) + * @see #getPropertyChangeListeners + */ + public PropertyChangeListener[] getPropertyChangeListeners(String propertyName) { + return propertyChangeSupport.getPropertyChangeListeners(propertyName); + } + + /** + * Support for reporting bound property changes for Object properties. + * This method can be called when a bound property has changed and it will + * send the appropriate PropertyChangeEvent to any registered + * PropertyChangeListeners. + * + * @param propertyName the property whose value has changed + * @param oldValue the property's previous value + * @param newValue the property's new value + */ + protected void firePropertyChange(String propertyName, + Object oldValue, Object newValue) { + propertyChangeSupport.firePropertyChange(propertyName, oldValue, newValue); + } + + /** + * Notifies the {@code LayerUI} when any of its property are changed + * and enables updating every {@code JLayer} this {@code LayerUI} instance is set to. + * + * @param evt the PropertyChangeEvent generated by this {@code LayerUI} + * @param l the {@code JLayer} this LayerUI is set to + */ + public void applyPropertyChange(PropertyChangeEvent evt, JLayer l) { + } + + /** + * Returns the preferred size of the viewport for a view component. + * + * @return the preferred size of the viewport for a view component + * @see Scrollable#getPreferredScrollableViewportSize() + */ + public Dimension getPreferredScrollableViewportSize(JLayer l) { + if (l.getView() instanceof Scrollable) { + return ((Scrollable)l.getView()).getPreferredScrollableViewportSize(); + } + return l.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. + * + * @return the "block" increment for scrolling in the specified direction + * @see Scrollable#getScrollableBlockIncrement(Rectangle, int, int) + */ + public int getScrollableBlockIncrement(JLayer l, + Rectangle visibleRect, + int orientation, int direction) { + if (l.getView() instanceof Scrollable) { + return ((Scrollable)l.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. + * + * @return whether the layer should track the height of the viewport + * @see Scrollable#getScrollableTracksViewportHeight() + */ + public boolean getScrollableTracksViewportHeight(JLayer l) { + if (l.getView() instanceof Scrollable) { + return ((Scrollable)l.getView()).getScrollableTracksViewportHeight(); + } + if (l.getParent() instanceof JViewport) { + return (((JViewport)l.getParent()).getHeight() > l.getPreferredSize().height); + } + 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. + * + * @return whether the layer should track the width of the viewport + * @see Scrollable + * @see LayerUI#getScrollableTracksViewportWidth(JLayer) + */ + public boolean getScrollableTracksViewportWidth(JLayer l) { + if (l.getView() instanceof Scrollable) { + return ((Scrollable)l.getView()).getScrollableTracksViewportWidth(); + } + if (l.getParent() instanceof JViewport) { + return (((JViewport)l.getParent()).getWidth() > l.getPreferredSize().width); + } + 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 JScrollPane, will use this method
+ * each time the user requests a unit scroll.
+ *
+ * @return The "unit" increment for scrolling in the specified direction.
+ * This value should always be positive.
+ * @see Scrollable#getScrollableUnitIncrement(Rectangle, int, int)
+ */
+ public int getScrollableUnitIncrement(JLayer l,
+ Rectangle visibleRect,
+ int orientation, int direction) {
+ if (l.getView() instanceof Scrollable) {
+ return ((Scrollable)l.getView()).getScrollableUnitIncrement(
+ visibleRect, orientation, direction);
+ }
+ return 1;
+ }
+
+ /**
+ * If the {@code JLayer}'s view component is not {@code null},
+ * this calls the view's {@code getBaseline()} method.
+ * Otherwise, the default implementation is called.
+ *
+ * @param c {@code JLayer} to return baseline resize behavior for
+ * @param width the width to get the baseline for
+ * @param height the height to get the baseline for
+ * @return baseline or a value < 0 indicating there is no reasonable
+ * baseline
+ */
+ public int getBaseline(JComponent c, int width, int height) {
+ JLayer l = (JLayer) c;
+ if (l.getView() != null) {
+ return l.getView().getBaseline(width, height);
+ }
+ return super.getBaseline(c, width, height);
+ }
+
+ /**
+ * If the {@code JLayer}'s view component is not {@code null},
+ * this calls the view's {@code getBaselineResizeBehavior()} method.
+ * Otherwise, the default implementation is called.
+ *
+ * @param c {@code JLayer} to return baseline resize behavior for
+ * @return an enum indicating how the baseline changes as the component
+ * size changes
+ */
+ public Component.BaselineResizeBehavior getBaselineResizeBehavior(JComponent c) {
+ JLayer l = (JLayer) c;
+ if (l.getView() != null) {
+ return l.getView().getBaselineResizeBehavior();
+ }
+ return super.getBaselineResizeBehavior(c);
+ }
+}
\ No newline at end of file
diff --git a/test/javax/swing/JLayer/SerializationTest/SerializationTest.java b/test/javax/swing/JLayer/SerializationTest/SerializationTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c18e41491e1f84543bdebf7ddb5373261957b3f
--- /dev/null
+++ b/test/javax/swing/JLayer/SerializationTest/SerializationTest.java
@@ -0,0 +1,53 @@
+/*
+ * @test
+ * @summary Makes sure that JLayer is synchronizable
+ * @author Alexander Potochkin
+ * @run main SerializationTest
+ */
+
+import javax.swing.*;
+import javax.swing.plaf.LayerUI;
+import java.io.ByteArrayInputStream;
+import java.io.ObjectOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ByteArrayOutputStream;
+
+public class SerializationTest {
+
+ public static void main(String[] args) throws Exception {
+ ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+ ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream);
+
+ JLayer