Remove JXLayer, migrate to JLayer.

ui_swing/build.gradle

@@ -1,5 +1,4 @@
 dependencies {
   bundle group: 'com.miglayout', name: 'miglayout-swing', version: '4.2'
-  bundle group: 'org.swinglabs', name: 'jxlayer', version: '3.0.4'
   bundle group: 'com.greboid.libraries', name: 'menuscroller', version: 'latest.release'
 }

ui_swing/src/com/dmdirc/addons/ui_swing/components/LockedLayer.java

@@ -1,329 +0,0 @@
-
-/**
- * Copyright (c) 2006-2009, Alexander Potochkin All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification, are permitted
- * provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice, this list of conditions
- * and the following disclaimer. * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the documentation and/or other
- * materials provided with the distribution. * Neither the name of the JXLayer project nor the names
- * of its contributors may be used to endorse or promote products derived from this software without
- * specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
- * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-package com.dmdirc.addons.ui_swing.components;
-
-import java.awt.Component;
-import java.awt.Cursor;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.awt.KeyboardFocusManager;
-import java.awt.event.FocusEvent;
-import java.awt.event.FocusListener;
-
-import javax.swing.JComponent;
-import javax.swing.SwingUtilities;
-
-import org.jdesktop.jxlayer.JXLayer;
-import org.jdesktop.jxlayer.plaf.AbstractBufferedLayerUI;
-import org.jdesktop.jxlayer.plaf.effect.LayerEffect;
-
-/**
- * An implementation of the {@code BufferedLayerUI} which provides a lightweight disabling for the
- * content of its {@link JXLayer}. This allows temporarily blocking a part of the interface with all
- * it subcomponents, it is also useful when some kind of action is in progress, e.g. reading data
- * from a database.
- * <p>
- * When {@code true} is passed to the {@link #setLocked(boolean)}, the {@code JXLayer} of this
- * {@code LockableLayerUI} becomes "locked". It sets the "wait" mouse cursor and stops reacting on
- * mouse, keyboard and focus events.
- * <p>
- * If {@code setLocked(boolean)} is called with {@code false} parameter after that, the
- * {@code JXLayer}, together with all its subcomponents, gets back to live.
- * <p>
- * Subclasses usually override {@link #paintLayer(Graphics2D,JXLayer)} or
- * {@link #getLayerEffects(JXLayer)} to implement some visual effects when {@code JXLayer} is in
- * locked state.
- * <p>
- * Here is an example of using {@code LockableLayerUI}:
- * <pre>
- * JComponent myComponent = getMyComponent(); // just any component
- *
- * LockableLayerUI lockableUI = new LockableLayerUI();
- * JXLayer&lt;JComponent&gt; layer = new JXLayer&lt;JComponent&gt;(myComponent,
- * lockableUI);
- *
- * // locking the layer, use lockableUI.setLocked(false) to unlock
- * lockableUI.setLocked(true);
- *
- * // add the layer to a frame or a panel, like any other component
- * frame.add(layer);
- * </pre>
- *
- * @param <T> Generic type
- */
-public class LockedLayer<T extends JComponent> extends AbstractBufferedLayerUI<T> {
-
-    /** A version number for this class. */
-    private static final long serialVersionUID = 1;
-    /** Are we locked. */
-    private boolean locked;
-    /** Most recent focus owner? */
-    private Component recentFocusOwner;
-    /** Cursor to show when locked. */
-    private Cursor lockedCursor = Cursor.getPredefinedCursor(
-            Cursor.DEFAULT_CURSOR);
-    /** Effect to apply when locked. */
-    private LayerEffect[] lockedEffects = new LayerEffect[0];
-    /** Focus listener. */
-    private final transient FocusListener focusListener = new FocusListener() {
-
-        @Override
-        public void focusGained(final FocusEvent e) {
-            // we don't want extra repaintings
-            // when focus comes from another window
-            if (e.getOppositeComponent() != null) {
-                setDirty(true);
-            }
-        }
-
-        @Override
-        public void focusLost(final FocusEvent e) {
-            //Ignore
-        }
-    };
-
-    /**
-     * Creates a new instance of LockableUI.
-     */
-    public LockedLayer() {
-        this((LayerEffect[]) null);
-    }
-
-    /**
-     * Creates a new instance of LockableUI, passed lockedEffects will be used for when this UI in
-     * the locked state.
-     *
-     * @param effects effects to be used when this UI is locked
-     *
-     * @see #setLocked(boolean)
-     * @see #setLockedEffects(LayerEffect...)
-     */
-    public LockedLayer(final LayerEffect... effects) {
-
-        setLockedEffects(effects);
-    }
-
-    @Override
-    public void installUI(final JComponent c) {
-        super.installUI(c);
-        // we need to repaint the layer when it receives the focus
-        // otherwise the focused component will have it on the buffer image
-        c.addFocusListener(focusListener);
-    }
-
-    @Override
-    public void uninstallUI(final JComponent c) {
-        super.uninstallUI(c);
-        c.removeFocusListener(focusListener);
-    }
-
-    /**
-     * Returns {@code true} if this {@code LockableLayerUI} is in locked state and all
-     * {@link JXLayer}'s mouse, keyboard and focus events are temporarily blocked, otherwise returns
-     * {@code false}.
-     *
-     * @return {@code true} if this {@code LockableLayerUI} is in locked state and all
-     *         {@code JXLayer}'s mouse, keyboard and focus events are temporarily blocked, otherwise
-     *         returns {@code false}
-     */
-    public boolean isLocked() {
-        return locked;
-    }
-
-    /**
-     * If {@code isLocked} is {@code true} then all mouse, keyboard and focus events from the
-     * {@link JXLayer} of this {@code LockableLayerUI} will be temporarily blocked.
-     *
-     * @param isLocked if {@code true} then all mouse, keyboard and focus events from the
-     *                 {@code JXLayer} of this {@code LockableLayerUI} will be temporarily blocked
-     */
-    public void setLocked(final boolean isLocked) {
-        if (isLocked != isLocked()) {
-            if (getLayer() != null) {
-                final KeyboardFocusManager kfm = KeyboardFocusManager.
-                        getCurrentKeyboardFocusManager();
-                final Component focusOwner = kfm.getPermanentFocusOwner();
-                final boolean focusInLayer = focusOwner != null
-                        && SwingUtilities.isDescendingFrom(focusOwner,
-                                getLayer());
-                if (isLocked) {
-                    if (focusInLayer && kfm.getFocusedWindow()
-                            == SwingUtilities.getWindowAncestor(getLayer())) {
-                        recentFocusOwner = focusOwner;
-                        // setDirty() will be called from the layer's
-                        //focusListener when focus already left layer's view
-                        //and hiding it in the paintLayer() won't mess the
-                        //focus up getLayer().requestFocusInWindow();
-                    } else {
-                        setDirty(true);
-                    }
-                    // the mouse cursor is set to the glassPane
-                    getLayer().getGlassPane().setCursor(getLockedCursor());
-                } else {
-                    // show the view again
-                    getLayer().getView().setVisible(true);
-                    // restore the focus if it is still in the layer
-                    if (focusInLayer && recentFocusOwner != null) {
-                        recentFocusOwner.requestFocusInWindow();
-                    }
-                    recentFocusOwner = null;
-                    getLayer().getGlassPane().setCursor(null);
-                }
-            }
-            this.locked = isLocked;
-            firePropertyChange("locked", !isLocked, isLocked);
-        }
-    }
-
-    // If it is locked, the buffer image will be updated
-    // only if the layer changes its size or setDirty(true) was called
-    @Override
-    protected boolean isIncrementalUpdate(
-            final JXLayer<? extends T> l) {
-        return !isLocked();
-    }
-
-    @Override
-    protected void paintLayer(final Graphics2D g2,
-            final JXLayer<? extends T> l) {
-        if (isLocked()) {
-            // Note: this code will be called only if layer changes its size,
-            // or setDirty(true) was called,
-            // otherwise the previously created buffer is used
-            l.getView().setVisible(true);
-            l.paint(g2);
-            // hide the layer's view component
-            // this is the only way to disable key shortcuts
-            // installed on its subcomponents
-            l.getView().setVisible(false);
-        }
-    }
-
-    @Override
-    public void paint(final Graphics g, final JComponent c) {
-        super.paint(g, c);
-        // if it is not locked, we need to paint the layer as is
-        // otherwise we also need to paint it again;
-        // if there are any glassPane's children
-        // they should be shown unfiltered
-        c.paint(g);
-    }
-
-    /**
-     * Returns the mouse cursor to be used by this {@code LockableLayerUI} when it locked state.
-     *
-     * @return the mouse cursor to be used by this {@code LockableLayerUI} when it locked state
-     *
-     * @see #getLockedCursor()
-     * @see #setLocked(boolean)
-     */
-    public Cursor getLockedCursor() {
-        return lockedCursor;
-    }
-
-    /**
-     * Sets the mouse cursor to be used by this {@code LockableLayerUI} when it locked state.
-     *
-     * @param newCursor the mouse cursor to be used by this {@code LockableLayerUI} when it locked
-     *                  state
-     */
-    public void setLockedCursor(final Cursor newCursor) {
-        final Cursor oldCursor = getLockedCursor();
-        this.lockedCursor = newCursor;
-        firePropertyChange("lockedCursor", oldCursor, newCursor);
-        if (isLocked()) {
-            getLayer().getGlassPane().setCursor(newCursor);
-        }
-    }
-
-    /**
-     * Returns the effects to be used when this UI is locked.
-     *
-     * @return the effects to be used when this UI is locked
-     *
-     * @see #setLocked(boolean)
-     */
-    public LayerEffect[] getLockedEffects() {
-        final LayerEffect[] result = new LayerEffect[lockedEffects.length];
-        System.arraycopy(lockedEffects, 0, result, 0, result.length);
-        return result;
-    }
-
-    /**
-     * This method returns the array of {@code LayerEffect}s set using
-     * {@link #setLockedEffects(LayerEffect...)}
-     * <p>
-     * If a {@code LockableUI} provides more extensive API to support different {@code Effect}s
-     * depending on its state or on the state of the passed {@code JXLayer}, this method should be
-     * overridden.
-     *
-     * @param l Layer to get effects from
-     *
-     * @return Locked layer effect
-     *
-     * @see #setLockedEffects (LayerEffect...)
-     * @see #getLockedEffects()
-     */
-    protected LayerEffect[] getLockedEffects(
-            final JXLayer<? extends JComponent> l) {
-        return getLockedEffects();
-    }
-
-    /**
-     * Sets the effects to be used when this UI is locked.
-     *
-     * @param effects the effects to be used when this UI is locked
-     *
-     * @see #setLocked(boolean)
-     */
-    public void setLockedEffects(final LayerEffect... effects) {
-        final LayerEffect[] layerEffect;
-        final LayerEffect[] oldEffects = getLockedEffects();
-        if (effects == null) {
-            layerEffect = new LayerEffect[0];
-        } else {
-            layerEffect = effects;
-        }
-        for (LayerEffect effect : getLockedEffects()) {
-            effect.removePropertyChangeListener(this);
-        }
-        this.lockedEffects = new LayerEffect[layerEffect.length];
-        System.arraycopy(layerEffect, 0, this.lockedEffects, 0,
-                layerEffect.length);
-        for (LayerEffect lockedEffect : layerEffect) {
-            lockedEffect.addPropertyChangeListener(this);
-        }
-        firePropertyChange("lockedEffects", oldEffects, layerEffect);
-    }
-
-    @Override
-    protected LayerEffect[] getLayerEffects(final JXLayer<? extends T> l) {
-        if (isLocked()) {
-            return getLockedEffects(l);
-        } else {
-            return super.getLayerEffects(l);
-        }
-    }
-
-}

ui_swing/src/com/dmdirc/addons/ui_swing/components/ToolTipPanel.java

@@ -34,16 +34,14 @@ import java.util.Map;
 import javax.swing.BorderFactory;
 import javax.swing.JComponent;
 import javax.swing.JLabel;
+import javax.swing.JLayer;
 import javax.swing.JPanel;
+import javax.swing.plaf.LayerUI;
 import javax.swing.text.SimpleAttributeSet;
 import javax.swing.text.StyleConstants;
 
 import net.miginfocom.swing.MigLayout;
 
-import org.jdesktop.jxlayer.JXLayer;
-import org.jdesktop.jxlayer.plaf.AbstractLayerUI;
-import org.jdesktop.jxlayer.plaf.LayerUI;
-
 /**
  * Panel to display tool tips of a component.
  */
@@ -165,13 +163,13 @@ public class ToolTipPanel extends JPanel implements MouseListener {
             return;
         }
         tooltips.put(component, tooltipText);
-        if (component instanceof JXLayer<?>) {
-            final LayerUI<JComponent> layerUI = new AbstractLayerUI<JComponent>() {
+        if (component instanceof JLayer<?>) {
+            final LayerUI<JComponent> layerUI = new LayerUI<JComponent>() {
                 private static final long serialVersionUID = -8698248993206174390L;
 
                 @Override
                 protected void processMouseEvent(final MouseEvent e,
-                        final JXLayer<? extends JComponent> comp) {
+                        final JLayer<? extends JComponent> comp) {
                     if (e.getID() == MouseEvent.MOUSE_ENTERED) {
                         setText(tooltips.get(comp));
                     } else if (e.getID() == MouseEvent.MOUSE_EXITED && comp.
@@ -181,7 +179,7 @@ public class ToolTipPanel extends JPanel implements MouseListener {
                     super.processMouseEvent(e, comp);
                 }
             };
-            UIUtilities.invokeLater(() -> ((JXLayer<JComponent>) component).setUI(layerUI));
+            UIUtilities.invokeLater(() -> ((JLayer<JComponent>) component).setUI(layerUI));
         } else {
             component.addMouseListener(this);
         }

ui_swing/src/com/dmdirc/addons/ui_swing/textpane/BackgroundPainter.java

@@ -35,8 +35,7 @@ import java.awt.Image;
 
 import javax.annotation.Nonnull;
 import javax.swing.JComponent;
-
-import org.jdesktop.jxlayer.plaf.LayerUI;
+import javax.swing.plaf.LayerUI;
 
 /**
  * Background painting layer UI. Paints a opaque background then paints the specified image onto the

ui_swing/src/com/dmdirc/addons/ui_swing/textpane/TextPane.java

@@ -52,13 +52,12 @@ import javax.swing.BoundedRangeModel;
 import javax.swing.DefaultBoundedRangeModel;
 import javax.swing.JComponent;
 import javax.swing.JLabel;
+import javax.swing.JLayer;
 import javax.swing.JScrollBar;
 import javax.swing.SwingConstants;
 
 import net.miginfocom.swing.MigLayout;
 
-import org.jdesktop.jxlayer.JXLayer;
-
 import static com.google.common.base.Preconditions.checkArgument;
 
 /**
@@ -122,7 +121,7 @@ public final class TextPane extends JComponent implements MouseWheelListener,
                 "textpanebackgroundoption");
         canvas = new TextPaneCanvas(this,
                 new CachingDocument<>(document, new AttributedStringMessageMaker()));
-        final JXLayer<JComponent> layer = new JXLayer<>(canvas);
+        final JLayer<JComponent> layer = new JLayer<>(canvas);
         layer.setUI(backgroundPainter);
         add(layer, "dock center");
         add(newLineIndicator, "dock south, center, grow");