praktikum-holons/src/ui/view/outliner/HolonView.java

package ui.view.outliner;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;

import javax.swing.DropMode;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JTree;
import javax.swing.ToolTipManager;
import javax.swing.TransferHandler;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;

import classes.Holon;
import classes.HolonElement;
import ui.controller.Control;
import utility.ImageImport;
/**
 * An Outliner Tab.
 * A high level view on the Model with respect to the Holon Structure. 
 * @author Tom 
 *
 */
public class HolonView extends JPanel{
	private Control control; 
	private JTree tree;
	private DefaultMutableTreeNode root;
	public HolonView(Outliner parent, Control control) {
		this.control = control;
		this.setLayout(new BorderLayout());
		initilizePanel();
		parent.outlinerUpdate.addListener(() -> updateTreeStructure());
	}

	private void initilizePanel() {
		tree = generateTree();
		tree.setCellRenderer(new HolonJtreeRenderer());
		tree.setDragEnabled(true);
        tree.setDropMode(DropMode.ON_OR_INSERT);
        tree.setTransferHandler(new HolonTransferHandler());
        tree.getSelectionModel().setSelectionMode(
                TreeSelectionModel.SINGLE_TREE_SELECTION);
        ToolTipManager.sharedInstance().registerComponent(tree);
        TreeUtils.expand(tree);
        tree.setRootVisible(true);
		this.add(TreeUtils.makePanelFromTree(tree));
	}
	
	
	private JTree generateTree() {
		root = generateFromHolon(control.getModel().getStateHolon());
		return new JTree(root);
	}
	
	private DefaultMutableTreeNode generateFromHolon(Holon holon) {
		DefaultMutableTreeNode node = new DefaultMutableTreeNode(new HolonInfo(holon));
		for(Holon child : holon.getChildView()) {
			node.add(generateFromHolon(child));
		}
		for(HolonElement ele : holon.getElementView()) {
			node.add(new DefaultMutableTreeNode(new ElementInfo(ele)));
		}
		return node;
	}
	private void updateTreeStructure() {
		root.removeAllChildren();
		Holon holon = control.getModel().getStateHolon();
		for(Holon child : holon.getChildView()) {
			root.add(generateFromHolon(child));
		}
		for(HolonElement ele : holon.getElementView()) {
			root.add(new DefaultMutableTreeNode(new ElementInfo(ele)));
		}
		tree.updateUI();
		TreeUtils.expand(tree);
	}
	
	interface HolonNode{
		public Transferable getTransferable(HolonTransferHandler handler);
		public Icon getIcon(); 
		public String getToolTip();
	}
	static final Icon elementIcon = new ImageIcon(ImageImport.loadImage("/Button_Images/element.png",16,16));
	static final String elementToolTip = "Element";
	class ElementInfo implements HolonNode{
		private HolonElement element;
		ElementInfo(HolonElement element){
			this.element = element;
		}
		@Override
		public String toString(){
			return element.getName();
		}
		
		public HolonElement getElement()
		{
			return element;
		}
		@Override
		public Transferable getTransferable(HolonTransferHandler handler) {
			return handler.new ElementTransferable(element);
		}
		@Override
		public Icon getIcon() {
			return elementIcon;
		}
		@Override
		public String getToolTip() {
			return elementToolTip;
		}
	}
	static final Icon holonIcon = new ImageIcon(ImageImport.loadImage("/Button_Images/holon.png",16,16));
	static final String holonToolTip = "Holon";
	class HolonInfo implements HolonNode{
		private Holon holon;
		HolonInfo(Holon holon){
			this.holon = holon;
		}
		@Override
		public String toString(){
			return holon.name;
		}
		
		public Holon getElement()
		{
			return holon;
		}
		
		public void AddElement(HolonElement element) {
			if(element.holon != null) {
				element.holon.removeElement(element);
			}
			holon.addElement(element);
		}
		public void AddHolon(Holon holon) {
			holon.removeFromParent();
			this.holon.addChild(holon);
		}
		@Override
		public Transferable getTransferable(HolonTransferHandler handler) {
			return  handler.new HolonTransferable(holon);
		}
		@Override
		public Icon getIcon() {
			return holonIcon;
		}
		@Override
		public String getToolTip() {
			return holonToolTip;
		}
		
	}
	
	
	class HolonTransferHandler extends TransferHandler{
		DataFlavor holonFlavor;		
		DataFlavor[] holonFlavorArray = new DataFlavor[1]; 
		DataFlavor elementFlavor;
		DataFlavor[] elementFlavorArray = new DataFlavor[1]; 
		HolonTransferHandler(){
			try {
				String mimeType = DataFlavor.javaJVMLocalObjectMimeType +
                        ";class=\"" +
                        classes.Holon.class.getName() +
                        "\"";
				holonFlavor = new DataFlavor(mimeType);
				holonFlavorArray[0] = holonFlavor; 
				mimeType = DataFlavor.javaJVMLocalObjectMimeType +
                        ";class=\"" +
                        classes.HolonElement.class.getName() +
                        "\"";
				elementFlavor = new DataFlavor(mimeType);
				elementFlavorArray[0] = elementFlavor; 
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
		}
		@Override 
		public boolean canImport(TransferHandler.TransferSupport support) {
		        if(!support.isDrop()) {
		            return false;
		        }
		        support.setShowDropLocation(true);
		        //Only accept Element and Holon as Drop
		        if(!support.isDataFlavorSupported(holonFlavor) &&  !support.isDataFlavorSupported(elementFlavor)) {
		            return false;
		        }
		        
		        JTree.DropLocation location = (JTree.DropLocation)support.getDropLocation();
		        TreePath pathDrop = location.getPath();
		        DefaultMutableTreeNode node = (DefaultMutableTreeNode) pathDrop.getLastPathComponent();
		        //Element cannot be parent of a holon
		        if(!(node.getUserObject() instanceof HolonInfo)) {
		        	return false;
		        }
		        
		        JTree tree = (JTree) support.getComponent();
		        TreePath pathDrag = tree.getSelectionPath();
		        //Dont allow Cycles
		        if(pathDrag.isDescendant(pathDrop)) {
		        	return false;
		        }
	
		        return true;
	    }
		@Override 
		public boolean importData(TransferHandler.TransferSupport support) {
		        if(!canImport(support)) {
		            return false;
		        }
		        JTree.DropLocation location = (JTree.DropLocation)support.getDropLocation();
		        TreePath path = location.getPath();
		        DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
		        if(node.getUserObject() instanceof HolonInfo) {
		        	
		        	HolonInfo info = (HolonInfo) node.getUserObject();
		        	try {
		        		if(support.isDataFlavorSupported(holonFlavor)) {
		        			info.AddHolon((Holon) support.getTransferable().getTransferData(holonFlavor));
		        		}else if (support.isDataFlavorSupported(elementFlavor)){
		        			info.AddElement((HolonElement) support.getTransferable().getTransferData(elementFlavor));
		        		}
		        		
					} catch (UnsupportedFlavorException | IOException e) {
						e.printStackTrace();
					}
		        }
				return false;
		}
		protected void exportDone(JComponent source,
                Transferable data,
                int action) {
			updateTreeStructure();
		}
		
		@Override
		public int getSourceActions(JComponent c) {
		        return MOVE;
	    }
		@Override
		protected Transferable createTransferable(JComponent c) {
	        JTree tree = (JTree)c;
	        TreePath path = tree.getSelectionPath();
	        if(path != null) {
	        	DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
	        	Object userObject =	node.getUserObject();
	        	//Only allow Hollon to move
	        	if(userObject instanceof HolonInfo) {
	        		return ((HolonInfo) userObject).getTransferable(this);
	        		
	        	}
	        }
	        return null;
	    }
		
		public class HolonTransferable implements Transferable{
			Holon holon;
			
			
			public HolonTransferable(Holon holon) {
				this.holon = holon;
			}
			@Override
			public DataFlavor[] getTransferDataFlavors() {
				return holonFlavorArray;
			}

			@Override
			public boolean isDataFlavorSupported(DataFlavor flavor) {
				return holonFlavor.equals(flavor);
			}

			@Override
			public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
				 if(!isDataFlavorSupported(flavor))
		                throw new UnsupportedFlavorException(flavor);
	            return holon;
			}
			
		}
		public class ElementTransferable implements Transferable{
			HolonElement element;
			
			
			public ElementTransferable(HolonElement element) {
				this.element = element;
			}
			@Override
			public DataFlavor[] getTransferDataFlavors() {
				return elementFlavorArray;
			}

			@Override
			public boolean isDataFlavorSupported(DataFlavor flavor) {
				return elementFlavor.equals(flavor);
			}

			@Override
			public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
				 if(!isDataFlavorSupported(flavor))
		                throw new UnsupportedFlavorException(flavor);
	            return element;
			}
			
		}
	} 
	
	
	class HolonJtreeRenderer extends DefaultTreeCellRenderer {

	    public Component getTreeCellRendererComponent(
	                        JTree tree,
	                        Object value,
	                        boolean isSelected,
	                        boolean expanded,
	                        boolean leaf,
	                        int row,
	                        boolean hasFocus) {
	         super.getTreeCellRendererComponent(tree, value, isSelected, expanded, leaf, row, hasFocus);
	         DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
	         HolonNode Node = (HolonNode) node.getUserObject();
	         if(row != 0) {
	        	 this.setIcon(Node.getIcon());
	        	 this.setToolTipText(Node.getToolTip());	        	 
	         }
	         return this;
	    }
	}
	
}