Docking VL first implementation

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

+package fr.soleil.docking.vl;
+
+import java.util.HashMap;
+import java.util.Map;
+
+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.DockingDesktop;
+import com.vldocking.swing.docking.RelativeDockablePosition;
+import com.vldocking.swing.docking.event.DockingActionCloseEvent;
+import com.vldocking.swing.docking.event.DockingActionEvent;
+import com.vldocking.swing.docking.event.DockingActionListener;
+
+@SuppressWarnings("serial")
+public class SoleilDockingDesktop extends DockingDesktop {
+	protected Map<String, RelativeDockablePosition> closedPositions = new HashMap<String, RelativeDockablePosition>();
+
+	private boolean closeEnabled;
+	private boolean autoHideEnabled;
+	private boolean maximizeEnabled;
+	private boolean floatingEnabled;
+
+	public SoleilDockingDesktop() {
+		this(true, false, true, false);
+	}
+
+	public SoleilDockingDesktop(boolean close, boolean autoHide,
+			boolean maximize, boolean floating) {
+		super();
+		closeEnabled = close;
+		autoHideEnabled = autoHide;
+		maximizeEnabled = maximize;
+		floatingEnabled = floating;
+		addDockingActionListener(generateDockingActionListener());
+	}
+
+	@Override
+	public void addDockable(Dockable dockable) {
+		DockKey key = dockable.getDockKey();
+		key.setCloseEnabled(closeEnabled);
+		key.setAutoHideEnabled(autoHideEnabled);
+		key.setMaximizeEnabled(maximizeEnabled);
+		key.setFloatEnabled(floatingEnabled);
+		super.addDockable(dockable, new RelativeDockablePosition(1,0, 0.5, 0.5));
+		//super.addDockable(dockable);
+	}
+
+	private DockingActionListener generateDockingActionListener() {
+		DockingActionListener result = new DockingActionListener() {
+			public boolean acceptDockingAction(DockingActionEvent event) {
+				return true;
+			}
+
+			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, position);
+			} else {
+				addDockable(dockable);
+			}
+		}
+	}
+
+	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

@@ -10,138 +10,141 @@ import java.io.ObjectOutputStream;
 
 import javax.swing.JComponent;
 import javax.swing.JOptionPane;
+import javax.swing.UIManager;
 
-import com.vldocking.swing.docking.Dockable;
 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.PerspectiveFactory;
+import fr.soleil.docking.vl.view.VlDockView;
 import fr.soleil.docking.vl.view.VlDockViewFactory;
 
 public class VlDockDockingManager extends ADockingManager {
-    protected DockingDesktop rootWindow;
-
-    public VlDockDockingManager() {
-        super(new VlDockViewFactory(), new PerspectiveFactory());
-    }
-
-    @Override
-    public JComponent getDockingArea() {
-        if (rootWindow == null) {
-            rootWindow = (DockingDesktop) createNewDockingArea(null);
-            rootWindow.setOpaqueContents(true);
-        }
-        return rootWindow;
-    }
-
-    public DockingDesktop getDockingDesktop() {
-        return (DockingDesktop) getDockingArea();
-    }
-
-    @Override
-    public JComponent createNewDockingArea(Color background) {
-        DockingDesktop result = new DockingDesktop();
-        if (background != null) {
-            result.setBackground(background);
-        }
-        return result;
-    }
-
-    @Override
-    public void setDockingAreaBeackground(JComponent dockingArea, Color areaBackground) {
-        if (dockingArea != null) {
-            dockingArea.setBackground(areaBackground);
-        }
-    }
-
-    // /**
-    // * Creates a new docking area with a given background {@link Color}
-    // *
-    // * @param background The background {@link Color}
-    // * @return A {@link JComponent}
-    // */
-    // @Override
-    // public JComponent createNewDockingArea(Color background) {
-    // DockingDesktop result = (DockingDesktop) createNewDockingArea();
-    // if (background != null) {
-    // result.setBackground(background);
-    // }
-    // return result;
-    // }
-
-    @Override
-    public void loadPerspective(IPerspective perspective) {
-        if (perspective.getByteArray().length > 0) {
-
-            ObjectInputStream ois = null;
-            ByteArrayInputStream bais = null;
-            try {
-
-                bais = new ByteArrayInputStream(perspective.getByteArray());
-                ois = new ObjectInputStream(bais);
-                rootWindow.readXML(ois);
-            } catch (Exception e) {
-                JOptionPane.showMessageDialog(rootWindow, "Perspective.load() :" + " Unexpected Error (see traces)",
-                        "INFONODE Docking - Error", JOptionPane.ERROR_MESSAGE);
-            } finally {
-                try {
-                    if (ois != null) {
-                        ois.close();
-                    }
-                    // Actually there is no effect to close bais ...
-                } catch (IOException e) {
-                    e.printStackTrace();
-                }
-            }
-        }
-    }
-
-    @Override
-    protected void savePerspective(IPerspective perspective) {
-        ByteArrayOutputStream baos = null;
-        ObjectOutputStream ous = null;
-        baos = new ByteArrayOutputStream();
-        try {
-            ous = new ObjectOutputStream(baos);
-            rootWindow.writeXML(ous);
-        } catch (IOException e) {
-            e.printStackTrace();
-            JOptionPane.showMessageDialog(rootWindow, "Perspective.save() :" + " Unexpected Error (see traces)",
-                    "INFONODE Docking - Error", JOptionPane.ERROR_MESSAGE);
-        } finally {
-            try {
-                ous.close();
-                // Actually there is no effect to close baos ...
-            } catch (IOException e) {
-                e.printStackTrace();
-            }
-        }
-        perspective.setByteArray(baos.toByteArray());
-
-    }
-
-    @Override
-    protected void updateViews(PropertyChangeEvent evt) {
-        if (evt.getSource() == this.viewFactory) {
-            Dockable newView = (Dockable) evt.getNewValue();
-            Dockable oldView = (Dockable) evt.getOldValue();
-            if (newView == null) { // removed
-                rootWindow.remove(oldView);
-            } else {
-                rootWindow.addDockable(newView);
-            }
-        }
-    }
-
-    @Override
-    public void setEnabledDocking(boolean enabledDocking) {
-        //
-    }
-
-    @Override
-    public boolean isEnabledDocking() {
-        return true;
-    }
-
+	protected SoleilDockingDesktop mainDockingDesktop;
+
+	public VlDockDockingManager() {
+		super(new VlDockViewFactory(), new PerspectiveFactory());
+		DockingPreferences.setShadowDesktopStyle();
+		UIManager.getDefaults().put("TabbedDockableContainer.tabPlacement", 1);
+	}
+
+	@Override
+	public JComponent getDockingArea() {
+		if (mainDockingDesktop == null) {
+			mainDockingDesktop = (SoleilDockingDesktop) new SoleilDockingDesktop();
+			mainDockingDesktop.setOpaqueContents(true);
+		}
+		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 loadPerspective(IPerspective perspective)
+			throws DockingException {
+		DockingException dockingException = null;
+		if (perspective.getByteArray().length > 0) {
+
+			ObjectInputStream ois = null;
+			ByteArrayInputStream bais = null;
+			try {
+
+				bais = new ByteArrayInputStream(perspective.getByteArray());
+				ois = new ObjectInputStream(bais);
+				mainDockingDesktop.readXML(ois);
+			} catch (Exception e) {
+				dockingException = new DockingException("Perspective.load() :"
+						+ " 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
+	protected void savePerspective(IPerspective perspective) {
+		ByteArrayOutputStream baos = null;
+		ObjectOutputStream ous = null;
+		baos = new ByteArrayOutputStream();
+		try {
+			ous = new ObjectOutputStream(baos);
+			mainDockingDesktop.writeXML(ous);
+		} catch (IOException e) {
+			e.printStackTrace();
+			JOptionPane.showMessageDialog(mainDockingDesktop,
+					"Perspective.save() :" + " Unexpected Error (see traces)",
+					"VLDock - Error", JOptionPane.ERROR_MESSAGE);
+		} finally {
+			try {
+				ous.close();
+				// Actually there is no effect to close baos ...
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		perspective.setByteArray(baos.toByteArray());
+
+	}
+
+	@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) {
+		System.out.println("VlDockDockingManager.setEnabledDocking()");
+	}
+
+	@Override
+	public boolean isEnabledDocking() {
+		return true;
+	}
 }

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

@@ -9,149 +9,176 @@ 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.event.DockingActionEvent;
+import com.vldocking.swing.docking.event.DockingActionListener;
 
 import fr.soleil.docking.view.IView;
 import fr.soleil.docking.view.IViewListener;
-import fr.soleil.docking.vl.VlDockDockingManager;
-
-public class VlDockView  implements IView {
-	  protected Object id;
-	    protected boolean enabled;
-	    protected boolean visible;
-	    protected String title;
-	    protected Component component;
-	    protected Icon icon;
-	    protected DockKey key;
-	    protected VlDockDockingManager manager;
-
-	    public VlDockView(String title, Icon icon, Component component, Object id, VlDockDockingManager manager) {
-	        this.title = title;
-	        this.icon = icon;
-	        this.component = component;
-	        this.id = id;
-	        this.key = new DockKey(title, title, title, icon);
-	        this.key.setFloatEnabled(false);
-	        this.manager = manager;
-	    }
-
-	    @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() {
-	        return visible;
-	    }
-
-	    @Override
-	    public void setVisible(boolean visible) {
-	        this.visible = visible;
-
-	    }
-
-	    @Override
-	    public String getTitle() {
-	        return title;
-	    }
-
-	    @Override
-	    public Icon getIcon() {
-	        return 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) {
-	        // TODO Auto-generated method stub
-
-	    }
-
-	    @Override
-	    public void addViewListener(IViewListener listener) {
-	        // TODO Auto-generated method stub
-
-	    }
+import fr.soleil.docking.vl.SoleilDockingDesktop;
+
+public class VlDockView implements IView, Dockable {
+	protected Object id;
+	protected boolean enabled;
+	protected boolean visible;
+	protected String title;
+	protected Component component;
+	protected Icon icon;
+	protected DockKey key;
+	protected SoleilDockingDesktop dockingDesktop;
+
+	public VlDockView(String title, Icon icon, Component component, Object id) {
+		this.title = title;
+		this.icon = icon;
+		this.component = component;
+		this.id = id;
+		this.key = new DockKey(title, title, title, icon);
+	}
+	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() {
+		return visible;
+	}
+
+	@Override
+	public void setVisible(boolean visible) {
+		this.visible = visible;
+		if (visible) {
+			dockingDesktop.showDockable(this);
+		} else {
+			dockingDesktop.close(this);
+		}
+		component.setVisible(visible);
+		component.setEnabled(visible);
+	}
+
+	@Override
+	public String getTitle() {
+		return title;
+	}
+
+	@Override
+	public Icon getIcon() {
+		return 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) {
+
+	}
+
+	@Override
+	public void addViewListener(final IViewListener listener) {
+		new DockingActionListener() {
+			public boolean acceptDockingAction(DockingActionEvent event) {
+				return true;
+			}
+
+			public void dockingActionPerformed(DockingActionEvent event) {
+				if (event.getActionType() == DockingActionEvent.ACTION_CLOSE) {
+					listener.viewClosed();
+				}
+			}
+		};
+
+	}
+
+	@Override
+	public DockKey getDockKey() {
+		return key;
+	}
 }

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

@@ -7,22 +7,24 @@ import javax.swing.JComponent;
 
 import fr.soleil.docking.view.AbstractViewFactory;
 import fr.soleil.docking.view.IView;
+import fr.soleil.docking.vl.SoleilDockingDesktop;
 
 public class VlDockViewFactory extends AbstractViewFactory {
 
+	
     public VlDockViewFactory() {
         super();
     }
 
     @Override
     protected IView createView(String title, Icon icon, Component component, Object id) {
-        // TODO Auto-generated method stub
-        return null;
+    	IView result = new VlDockView(title, icon, component, id);
+    	return result;
     }
 
     @Override
     protected void updateViewForDockingArea(IView view, JComponent dockingArea) {
-        // TODO Auto-generated method stub
+        ((VlDockView)view).setDockingDesktop((SoleilDockingDesktop) dockingArea);
     }
 
 }