Merge dockingvl into docking

dockingvl/.gitignore

+.project
+.classpath
+.settings
+target
+

dockingvl/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>fr.soleil.maven.parent</groupId>
+    <artifactId>java-updated-versions</artifactId>
+    <version>0-SNAPSHOT</version>
+  </parent>
+
+  <groupId>fr.soleil.lib</groupId>
+  <artifactId>DockingVl</artifactId>
+  <version>1.1.3</version>
+  <name>Docking VL</name>
+  <description>VL Docking implementation of DockingCore</description>
+
+  <developers>
+    <developer>
+      <id>girardot</id>
+      <name>Raphaël GIRARDOT</name>
+      <email>raphael.girardot@synchrotron-soleil.fr</email>
+      <organization>SOLEIL</organization>
+      <organizationUrl>http://www.synchrotron-soleil.fr</organizationUrl>
+      <roles>
+        <role>Manager</role>
+      </roles>
+      <timezone>1</timezone>
+    </developer>
+    <developer>
+      <id>viguier</id>
+      <name>Grégory VIGUIER</name>
+      <email>gregory.viguier@synchrotron-soleil.fr</email>
+      <organization>SOLEIL</organization>
+      <organizationUrl>http://www.synchrotron-soleil.fr</organizationUrl>
+      <roles>
+        <role>Java Developer</role>
+      </roles>
+      <timezone>1</timezone>
+    </developer>
+  </developers>
+
+  <scm>
+    <connection>scm:git:git@gitlab.synchrotron-soleil.fr:software-control-system/libraries/java/dockingvl.git</connection>
+    <developerConnection>scm:git:git@gitlab.synchrotron-soleil.fr:software-control-system/libraries/java/dockingvl.git</developerConnection>
+    <url>https://gitlab.synchrotron-soleil.fr/software-control-system/libraries/java/dockingvl</url>
+  </scm>
+
+  <build>
+    <plugins>
+      <plugin>
+        <artifactId>maven-resources-plugin</artifactId>
+        <configuration>
+          <encoding>${project.build.sourceEncoding}</encoding>
+        </configuration>
+      </plugin>
+      <plugin>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <configuration>
+          <encoding>${project.build.sourceEncoding}</encoding>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+
+  <dependencies>
+    <dependency>
+      <groupId>fr.soleil.lib</groupId>
+      <artifactId>DockingCore</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>com.vlsolutions</groupId>
+      <artifactId>vldocking</artifactId>
+      <version>3.0.2</version>
+    </dependency>
+  </dependencies>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+</project>

dockingvl/src/main/java/fr/soleil/docking/vl/SoleilDockingDesktop.java

+/*******************************************************************************
+ * Copyright (c) 2008-2019 Synchrotron SOLEIL
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
+ ******************************************************************************/
+package fr.soleil.docking.vl;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.vldocking.swing.docking.Dockable;
+import com.vldocking.swing.docking.DockableState;
+import com.vldocking.swing.docking.DockableState.Location;
+import com.vldocking.swing.docking.DockingDesktop;
+import com.vldocking.swing.docking.RelativeDockablePosition;
+import com.vldocking.swing.docking.event.DockableSelectionEvent;
+import com.vldocking.swing.docking.event.DockableSelectionListener;
+import com.vldocking.swing.docking.event.DockingActionCloseEvent;
+import com.vldocking.swing.docking.event.DockingActionEvent;
+import com.vldocking.swing.docking.event.DockingActionListener;
+
+import fr.soleil.docking.vl.view.VlDockView;
+
+public class SoleilDockingDesktop extends DockingDesktop {
+
+    private static final long serialVersionUID = -6192752805034560434L;
+
+    protected final Map<String, RelativeDockablePosition> closedPositions;
+
+    protected boolean closeEnabled;
+    protected boolean autoHideEnabled;
+    protected boolean maximizeEnabled;
+    protected boolean floatingEnabled;
+
+    public SoleilDockingDesktop() {
+        this(true, false, true, false);
+    }
+
+    public SoleilDockingDesktop(boolean close, boolean autoHide, boolean maximize, boolean floating) {
+        super();
+        closedPositions = new HashMap<>();
+        closeEnabled = close;
+        autoHideEnabled = autoHide;
+        maximizeEnabled = maximize;
+        floatingEnabled = floating;
+        addDockingActionListener(generateDockingActionListener());
+        addDockableSelectionListener(new DockableSelectionListener() {
+            @Override
+            public void selectionChanged(DockableSelectionEvent dse) {
+                if (dse.getSelectedDockable() instanceof VlDockView) {
+                    ((VlDockView) dse.getSelectedDockable()).focusGained(null);
+                }
+            }
+        });
+    }
+
+    @Override
+    public void addDockable(Dockable dockable) {
+        if (dockable != null) {
+            // DockKey key = dockable.getDockKey();
+            // key.setCloseEnabled(closeEnabled);
+            // key.setAutoHideEnabled(autoHideEnabled);
+            // key.setMaximizeEnabled(maximizeEnabled);
+            // key.setFloatEnabled(floatingEnabled);
+
+            addDockingActionListener((VlDockView) dockable);
+            super.addDockable(dockable, new RelativeDockablePosition(1, 0, 0.5, 0.5));
+        }
+    }
+
+    private DockingActionListener generateDockingActionListener() {
+        DockingActionListener result = new DockingActionListener() {
+            @Override
+            public boolean acceptDockingAction(DockingActionEvent event) {
+                return true;
+            }
+
+            @Override
+            public void dockingActionPerformed(DockingActionEvent event) {
+                if (event.getActionType() == DockingActionEvent.ACTION_CLOSE) {
+                    Dockable closedDockable = ((DockingActionCloseEvent) event).getDockable();
+                    DockableState state = getDockableState(closedDockable);
+                    RelativeDockablePosition position = state.getPosition();
+                    closedPositions.put(closedDockable.getDockKey().getKey(), position);
+                }
+            }
+        };
+        return result;
+    }
+
+    public void showDockable(Dockable dockable) {
+        DockableState state = getDockableState(dockable);
+        if (state == null || Location.CLOSED.equals(state.getLocation())
+                || Location.HIDDEN.equals(state.getLocation())) {
+            RelativeDockablePosition position = getPositionForClosedView(dockable);
+            if (position == null) {
+                addDockable(dockable);
+            } else {
+                addDockable(dockable, position);
+            }
+        }
+    }
+
+    private RelativeDockablePosition getPositionForClosedView(Dockable dockable) {
+        RelativeDockablePosition result = null;
+        if (dockable != null) {
+            result = closedPositions.get(dockable.getDockKey().getKey());
+        }
+        return result;
+    }
+
+}

dockingvl/src/main/java/fr/soleil/docking/vl/VlDockDockingManager.java

+/*******************************************************************************
+ * Copyright (c) 2008-2019 Synchrotron SOLEIL
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
+ ******************************************************************************/
+package fr.soleil.docking.vl;
+
+import java.awt.Color;
+import java.beans.PropertyChangeEvent;
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import javax.swing.JComponent;
+import javax.swing.UIManager;
+
+import com.vldocking.swing.docking.DockingDesktop;
+import com.vldocking.swing.docking.DockingPreferences;
+
+import fr.soleil.docking.ADockingManager;
+import fr.soleil.docking.exception.DockingException;
+import fr.soleil.docking.perspective.IPerspective;
+import fr.soleil.docking.perspective.IPerspectiveFactory;
+import fr.soleil.docking.perspective.PerspectiveFactory;
+import fr.soleil.docking.view.IViewFactory;
+import fr.soleil.docking.vl.view.VlDockView;
+import fr.soleil.docking.vl.view.VlDockViewFactory;
+
+public class VlDockDockingManager extends ADockingManager {
+    protected SoleilDockingDesktop mainDockingDesktop;
+
+    public VlDockDockingManager() {
+        this(new VlDockViewFactory(), new PerspectiveFactory());
+    }
+
+    public VlDockDockingManager(IViewFactory viewFactory) {
+        this(viewFactory, new PerspectiveFactory());
+    }
+
+    public VlDockDockingManager(IViewFactory viewFactory, IPerspectiveFactory perspectiveFactory) {
+        super(viewFactory, perspectiveFactory);
+        DockingPreferences.setShadowDesktopStyle();
+        UIManager.getDefaults().put("TabbedDockableContainer.tabPlacement", 1);
+    }
+
+    @Override
+    protected void initDockingArea() {
+        mainDockingDesktop = new SoleilDockingDesktop();
+        mainDockingDesktop.setOpaqueContents(true);
+    }
+
+    @Override
+    public JComponent getDockingArea() {
+        if (mainDockingDesktop == null) {
+            initDockingArea();
+        }
+        return mainDockingDesktop;
+    }
+
+    public DockingDesktop getDockingDesktop() {
+        return (DockingDesktop) getDockingArea();
+    }
+
+    @Override
+    public JComponent createNewDockingArea(Color background) {
+        SoleilDockingDesktop result = new SoleilDockingDesktop(false, false, true, false);
+        if (background != null) {
+            result.setBackground(background);
+        }
+        return result;
+    }
+
+    @Override
+    public void setDockingAreaBeackground(JComponent dockingArea, Color areaBackground) {
+        if (dockingArea != null) {
+            dockingArea.setBackground(areaBackground);
+        }
+    }
+
+    @Override
+    public void applyPerspective(IPerspective perspective, JComponent dockingArea) throws DockingException {
+        DockingException dockingException = null;
+        if ((perspective != null) && (perspective.getByteArray() != null) && (perspective.getByteArray().length > 0)
+                && (dockingArea instanceof SoleilDockingDesktop)) {
+            SoleilDockingDesktop mainDockingDesktop = (SoleilDockingDesktop) dockingArea;
+            InputStream ois = null;
+            ByteArrayInputStream bais = null;
+            try {
+                bais = new ByteArrayInputStream(perspective.getByteArray());
+                // ois = new ObjectInputStream(bais);
+                ois = new BufferedInputStream(bais);
+                mainDockingDesktop.readXML(ois);
+            } catch (Exception e) {
+                dockingException = new DockingException(getClass().getSimpleName()
+                        + ".applyPerspective(): Unexpected Error", e);
+            } finally {
+                try {
+                    if (ois != null) {
+                        ois.close();
+                    }
+                    // Actually there is no effect to close bais ...
+                } catch (IOException e) {
+                    if (dockingException == null) {
+                        dockingException = new DockingException("I/O Exception", e);
+                    } else {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+        if (dockingException != null) {
+            throw dockingException;
+        }
+    }
+
+    @Override
+    public void updatePerspective(IPerspective perspective, JComponent dockingArea) throws DockingException {
+        DockingException dockingException = null;
+        if ((perspective != null) && (dockingArea instanceof SoleilDockingDesktop)) {
+            SoleilDockingDesktop mainDockingDesktop = (SoleilDockingDesktop) dockingArea;
+            ByteArrayOutputStream baos = null;
+            OutputStream ous = null;
+            baos = new ByteArrayOutputStream();
+            try {
+                // ous = new ObjectOutputStream(baos);
+                ous = new BufferedOutputStream(baos);
+                mainDockingDesktop.writeXML(ous);
+            } catch (IOException e) {
+                dockingException = new DockingException(getClass().getSimpleName()
+                        + ".updatePerspective(): Unexpected Error", e);
+            } finally {
+                try {
+                    if (ous != null) {
+                        ous.close();
+                    }
+                    // Actually there is no effect to close baos ...
+                } catch (IOException e) {
+                    if (dockingException == null) {
+                        dockingException = new DockingException("I/O Exception", e);
+                    } else {
+                        e.printStackTrace();
+                    }
+                }
+            }
+            perspective.setByteArray(baos.toByteArray());
+        }
+        if (dockingException != null) {
+            throw dockingException;
+        }
+    }
+
+    @Override
+    protected void updateViews(PropertyChangeEvent evt) {
+        if (evt.getSource() == this.viewFactory) {
+            VlDockView newView = (VlDockView) evt.getNewValue();
+            VlDockView oldView = (VlDockView) evt.getOldValue();
+            if (newView == null) { // removed
+                mainDockingDesktop.remove(oldView);
+            } else {
+                mainDockingDesktop.addDockable(newView);
+            }
+        }
+    }
+
+    @Override
+    public void setEnabledDocking(boolean enabledDocking, JComponent dockingArea) {
+        // TODO manage docking availability
+        System.out.println("VlDockDockingManager.setEnabledDocking()");
+    }
+
+    @Override
+    public boolean isEnabledDocking(JComponent dockingArea) {
+        // TODO manage docking availability
+        return true;
+    }
+
+    @Override
+    public void setUndockEnabled(boolean enabled, JComponent dockingArea) {
+        // TODO manage undocking possibility
+        System.out.println("VlDockDockingManager.setUndockEnabled()");
+    }
+
+    @Override
+    public boolean isUndockEnabled(JComponent dockingArea) {
+        // TODO manage undocking possibility
+        return true;
+    }
+
+    @Override
+    public boolean canRestoreExactViewPosition() {
+        return false;
+    }
+}

dockingvl/src/main/java/fr/soleil/docking/vl/view/VlDockView.java

+/*******************************************************************************
+ * Copyright (c) 2008-2019 Synchrotron SOLEIL
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
+ ******************************************************************************/
+package fr.soleil.docking.vl.view;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.event.FocusEvent;
+import java.awt.event.FocusListener;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.swing.Icon;
+
+import com.vldocking.swing.docking.DockKey;
+import com.vldocking.swing.docking.Dockable;
+import com.vldocking.swing.docking.DockableState;
+import com.vldocking.swing.docking.DockableState.Location;
+import com.vldocking.swing.docking.DockingUtilities;
+import com.vldocking.swing.docking.TabbedDockableContainer;
+import com.vldocking.swing.docking.event.DockingActionCloseEvent;
+import com.vldocking.swing.docking.event.DockingActionEvent;
+import com.vldocking.swing.docking.event.DockingActionListener;
+
+import fr.soleil.docking.event.ViewEvent;
+import fr.soleil.docking.listener.IViewListener;
+import fr.soleil.docking.listener.ViewListenerDelegate;
+import fr.soleil.docking.view.IView;
+import fr.soleil.docking.vl.SoleilDockingDesktop;
+
+public class VlDockView implements IView, Dockable, DockingActionListener, FocusListener {
+
+    protected Object id;
+    protected boolean enabled;
+    protected String title;
+    protected Component component;
+    protected Icon icon;
+    protected DockKey key;
+    protected SoleilDockingDesktop dockingDesktop;
+    protected final ViewListenerDelegate delegate;
+
+    public VlDockView(String title, Icon icon, Component component, Object id) {
+        this.title = title;
+        this.icon = icon;
+        this.component = component;
+        this.id = id;
+        if (id instanceof String) {
+            String stringId = (String) id;
+            this.key = new DockKey(stringId, title, title, icon);
+        } else {
+            this.key = new DockKey(title, title, title, icon);
+        }
+
+        delegate = new ViewListenerDelegate();
+        this.component.addFocusListener(this);
+    }
+
+    public void setDockingDesktop(SoleilDockingDesktop dockingDesktop) {
+        this.dockingDesktop = dockingDesktop;
+        dockingDesktop.registerDockable(this);
+    }
+
+    @Override
+    public Component getComponent() {
+        return component;
+    }
+
+    @Override
+    public Object getId() {
+        return id;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    @Override
+    public void setEnabled(boolean enabled) {
+        this.enabled = enabled;
+    }
+
+    @Override
+    public boolean isVisible() {
+        DockableState state = dockingDesktop.getDockableState(this);
+        boolean visible = false;
+        if (state != null) {
+            Location location = state.getLocation();
+            visible = (location != Location.CLOSED) && (location != Location.HIDDEN);
+        }
+        return visible;
+    }
+
+    @Override
+    public void setVisible(boolean visible) {
+        if (visible != isVisible()) {
+            if (visible) {
+                dockingDesktop.showDockable(this);
+            } else {
+                dockingDesktop.close(this);
+            }
+            component.setVisible(visible);
+            component.setEnabled(visible);
+        }
+    }
+
+    @Override
+    public void select() {
+        setVisible(true);
+        focus(component, true);
+        focusGained(new FocusEvent(component, FocusEvent.FOCUS_GAINED));
+        // Following code is the one that really works
+        TabbedDockableContainer tabbedDockableContainer = DockingUtilities.findTabbedDockableContainer(this);
+        if (tabbedDockableContainer != null) {
+            tabbedDockableContainer.setSelectedDockable(this);
+        }
+    }
+
+    protected static boolean focus(Component comp, boolean forceFocus) {
+        boolean focused = false;
+        if (comp != null) {
+            if (forceFocus || (comp.isVisible() && comp.isShowing())) {
+                if (comp.isFocusable()) {
+                    comp.requestFocus();
+                    comp.requestFocusInWindow();
+                    focused = true;
+                } else if (comp instanceof Container) {
+                    Container container = (Container) comp;
+                    for (Component child : container.getComponents()) {
+                        if (focus(child, false)) {
+                            focused = true;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        return focused;
+    }
+
+    @Override
+    public String getTitle() {
+        return title;
+    }
+
+    @Override
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    @Override
+    public Icon getIcon() {
+        return icon;
+    }
+
+    @Override
+    public void setIcon(Icon icon) {
+        this.icon = icon;
+    }
+
+    @Override
+    public Color getViewBackground() {
+        return component.getBackground();
+    }
+
+    @Override
+    public void setViewBackground(Color bg) {
+        if (component instanceof Container) {
+            List<Component> components = getAllComponents((Container) component);
+            setComponentsBackground(components, bg);
+        }
+        component.setBackground(bg);
+    }
+
+    @Override
+    public Color getViewForeground() {
+        return component.getForeground();
+    }
+
+    @Override
+    public void setViewForeground(Color fg) {
+        component.setForeground(fg);
+    }
+
+    /**
+     * Sets the background of all {@link Component}s in a given {@link List}
+     * 
+     * @param components The {@link List}
+     * @param bg The background to set
+     */
+    protected void setComponentsBackground(List<?> components, Color bg) {
+        if (components != null) {
+            for (Object comp : components) {
+                if (comp instanceof Component) {
+                    ((Component) comp).setBackground(bg);
+                }
+            }
+        }
+    }
+
+    /**
+     * Sets the foreground of all {@link Component}s in a given {@link List}
+     * 
+     * @param components The {@link List}
+     * @param bg The foreground to set
+     */
+    protected void setComponentsForeground(List<?> components, Color bg) {
+        if (components != null) {
+            for (Object comp : components) {
+                if (comp instanceof Component) {
+                    ((Component) comp).setForeground(bg);
+                }
+            }
+        }
+    }
+
+    public List<Component> getAllComponents(final Container c) {
+        Component[] comps = c.getComponents();
+        List<Component> compList = new ArrayList<Component>();
+        for (Component comp : comps) {
+            compList.add(comp);
+            if (comp instanceof Container) {
+                compList.addAll(getAllComponents((Container) comp));
+            }
+        }
+        return compList;
+    }
+
+    @Override
+    public void setClosable(boolean closable) {
+        key.setCloseEnabled(closable);
+    }
+
+    @Override
+    public void addViewListener(final IViewListener listener) {
+        delegate.addViewListener(listener);
+    }
+
+    @Override
+    public void removeViewListener(IViewListener listener) {
+        delegate.removeViewListener(listener);
+    }
+
+    @Override
+    public DockKey getDockKey() {
+        return key;
+    }
+
+    @Override
+    public boolean acceptDockingAction(DockingActionEvent event) {
+        return true;
+    }
+
+    @Override
+    public void dockingActionPerformed(DockingActionEvent e) {
+        if (e.getActionType() == DockingActionEvent.ACTION_CLOSE) {
+            Dockable closedDockable = ((DockingActionCloseEvent) e).getDockable();
+            if (getDockKey().getKey().equals(closedDockable.getDockKey().getKey())) {
+                delegate.warnListeners(new ViewEvent(this, ViewEvent.VIEW_CLOSED));
+            }
+        }
+    }
+
+    @Override
+    public void focusGained(FocusEvent e) {
+        delegate.warnListeners(new ViewEvent(this, ViewEvent.FOCUS_GAINED));
+    }
+
+    @Override
+    public void focusLost(FocusEvent e) {
+        delegate.warnListeners(new ViewEvent(this, ViewEvent.FOCUS_LOST));
+    }
+
+}

dockingvl/src/main/java/fr/soleil/docking/vl/view/VlDockViewFactory.java

+/*******************************************************************************
+ * Copyright (c) 2008-2019 Synchrotron SOLEIL
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
+ ******************************************************************************/
+package fr.soleil.docking.vl.view;
+
+import java.awt.Component;
+
+import javax.swing.Icon;
+import javax.swing.JComponent;
+
+import fr.soleil.docking.ADockingManager;
+import fr.soleil.docking.view.AbstractViewFactory;
+import fr.soleil.docking.view.IView;
+import fr.soleil.docking.vl.SoleilDockingDesktop;
+import fr.soleil.docking.vl.VlDockDockingManager;
+
+public class VlDockViewFactory extends AbstractViewFactory {
+
+    public VlDockViewFactory() {
+        super();
+    }
+
+    @Override
+    protected IView createView(String title, Icon icon, Component component, Object id) {
+        IView result = new VlDockView(title, icon, component, id);
+        return result;
+    }
+
+    @Override
+    protected void updateViewForDockingArea(IView view, JComponent dockingArea) {
+        if ((view instanceof VlDockView) && (dockingArea instanceof SoleilDockingDesktop)) {
+            VlDockView vlDockView = (VlDockView) view;
+            SoleilDockingDesktop dockingDesktop = (SoleilDockingDesktop) dockingArea;
+            dockingDesktop.addDockable(vlDockView);
+            vlDockView.setDockingDesktop(dockingDesktop);
+        }
+    }
+
+    @Override
+    public ADockingManager generateDockingManager() {
+        return new VlDockDockingManager(this);
+    }
+
+}