jremconfigview.java

JRemoteControl is a simple Java&#8482 driven bluetooth remote control.It allows you to initiate virt

/*
 * JRemCntl - Copyright (C) 2007 Filippo Di Vattimo <[e-mail]>
 * See COPYING
 */

package fildiv.jremcntl.server.gui.app;

import java.awt.Color;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.util.Enumeration;
import java.util.Vector;

import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.JTree;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;

import fildiv.jremcntl.server.gui.core.AddRemoveOpSupport;
import fildiv.jremcntl.server.gui.core.DocModifiedContent;
import fildiv.jremcntl.server.gui.core.DocumentAttachedEvent;
import fildiv.jremcntl.server.gui.core.DocumentEvent;
import fildiv.jremcntl.server.gui.core.DocumentListener;
import fildiv.jremcntl.server.gui.core.DocumentModifiedEvent;
import fildiv.jremcntl.server.gui.model.JRemCommandDoc;
import fildiv.jremcntl.server.gui.model.JRemConfigDoc;
import fildiv.jremcntl.server.gui.model.JRemContextDoc;
import fildiv.jremcntl.server.gui.util.swing.JTreeDropTarget;
import fildiv.jremcntl.server.gui.util.swing.JTreeTransferHandler;
import fildiv.jremcntl.server.gui.util.swing.SwingUtils;

public class JRemConfigView extends JPanel {

	private JRemConfigViewListener viewListener;
	
	private JRemConfigDoc configDoc; // @jve:decl-index=0:

	private DocumentListener listener;

	private static final long serialVersionUID = 1L;

	private JTree jTree = null;

	protected interface TreeVisitProcessor {
		void process(DefaultMutableTreeNode node);

		boolean continueProcessing();
	}

	protected static class FindNodeTreeVisitorProcessor implements
			TreeVisitProcessor {

		private DefaultMutableTreeNode node = null;

		private Object nodeToFind;

		public FindNodeTreeVisitorProcessor(Object nodeToFind) {
			this.nodeToFind = nodeToFind;
		}

		public void process(DefaultMutableTreeNode node) {
			Object obj = node.getUserObject();
			if (obj == nodeToFind) {
				this.node = node;
			}
		}

		public boolean continueProcessing() {
			return node == null;
		}

		public DefaultMutableTreeNode getNode() {
			return node;
		}

	}


	/**
	 * This is the default constructor
	 */
	public JRemConfigView(JRemConfigViewListener viewListener) {
		super();
		initialize();

		this.viewListener = viewListener;
		
		listener = new DocumentListener() {

			public void actionPerformed(DocumentEvent event) {
				updateView(event);
			}

		};
	}

	/**
	 * This method initializes this
	 * 
	 * @return void
	 */
	private void initialize() {
		GridBagConstraints gridBagConstraints3 = new GridBagConstraints();
		gridBagConstraints3.gridx = 0;
		gridBagConstraints3.insets = new Insets(2, 2, 0, 0);
		gridBagConstraints3.gridy = 1;
		GridBagConstraints gridBagConstraints2 = new GridBagConstraints();
		gridBagConstraints2.fill = GridBagConstraints.BOTH;
		gridBagConstraints2.gridy = 0;
		gridBagConstraints2.ipadx = 241;
		gridBagConstraints2.ipady = 132;
		gridBagConstraints2.weightx = 1.0;
		gridBagConstraints2.weighty = 1.0;
		gridBagConstraints2.gridx = 0;
		this.setLayout(new GridBagLayout());
		this.setSize(300, 200);
		this.add(getJTree(), gridBagConstraints2);		
	}

	/**
	 * This method initializes jTree
	 * 
	 * @return javax.swing.JTree
	 */
	private JTree getJTree() {
		if (jTree == null) {
			jTree = new JTree();
			jTree.setDragEnabled(true);
			jTree.setTransferHandler(new JTreeTransferHandler() {
				protected void exportDone(JTree tree, Object draggedNode, Object targetNode)  {
					JRemConfigView.this.exportDone(tree, draggedNode, targetNode);
				}
			});
			jTree.setForeground(Color.white);
			jTree.setDropTarget(new JTreeDropTarget() {
				protected boolean acceptDrop(JTree tree, Object nodeOver) {
					return DeNUtils.validateExportAction(tree, nodeOver);
				}
				
				protected boolean canExpandPath(JTree tree, Object nodeOver) {
					return DeNUtils.canExpandPath(tree, nodeOver);					
				}
			});
			jTree.getSelectionModel().setSelectionMode(
					TreeSelectionModel.SINGLE_TREE_SELECTION);
			jTree.addTreeSelectionListener(new TreeSelectionListener() {

				public void valueChanged(TreeSelectionEvent e) {
					DefaultMutableTreeNode node = 
						(DefaultMutableTreeNode) jTree.getLastSelectedPathComponent();

					if (node == null) 
						return;
					
					Object nodeObj = node.getUserObject();
					if (nodeObj instanceof JRemConfigDoc)
						viewListener.configRootSelected();
					else if (nodeObj instanceof JRemContextDoc)
						viewListener.contextSelected( (JRemContextDoc) nodeObj);
					else {
						assert nodeObj instanceof JRemCommandDoc;
						viewListener.commandSelected( (JRemCommandDoc) nodeObj);
					}
				}
				
			});
			
		}
		return jTree;
	}

	public void expandAll(boolean expand) {
		SwingUtils.expandAll(getJTree(), expand);
	}
	
	public void select(Object item) {

		if (item == null)
			return;
		
		DefaultMutableTreeNode node = findNode(item);
				
		TreePath p = new TreePath(node.getPath());			
		getJTree().setSelectionPath(p);
	}

	public void setConfigDoc(JRemConfigDoc configDoc) {

		if (this.configDoc != null)
			this.configDoc.removeActionListener(listener);

		this.configDoc = configDoc;
		this.configDoc.addActionListener(listener);
	}

	private void updateView(DocumentEvent event) {

		try {

			SwingUtils.showWaitCursor(this, true);

			if (event instanceof DocumentModifiedEvent)
				updateTree((DocumentModifiedEvent) event);
			else {
				if (event instanceof DocumentAttachedEvent)
					initTree();
				else
					clearTree();
			}
		} finally {
			
			SwingUtils.showWaitCursor(this, false);
		}
	}

	private void clearTree() {
		jTree.removeAll();

	}

	private void initTree() {

		clearTree();

		DefaultMutableTreeNode root = new DefaultMutableTreeNode(configDoc);
		DefaultTreeModel model = new DefaultTreeModel(root);
		jTree.setModel(model);

		Vector contexts = configDoc.getContexts();

		for (int ctxIndex = 0; ctxIndex < contexts.size(); ++ctxIndex) {

			JRemContextDoc context = (JRemContextDoc) contexts.get(ctxIndex);

			DefaultMutableTreeNode contextNode = 
				new DefaultMutableTreeNode(context);
			addCommandNodes(contextNode);
			
			root.add(contextNode);
		}

		model.reload();
	}

	private void addCommandNodes(DefaultMutableTreeNode contextNode) {

		JRemContextDoc context = (JRemContextDoc) contextNode.getUserObject();
		
		Vector commands = context.getCommands();

		for (int cmdIndex = 0; cmdIndex < commands.size(); ++cmdIndex) {

			JRemCommandDoc command = (JRemCommandDoc) commands
					.get(cmdIndex);
			DefaultMutableTreeNode commandNode = 
				createCommandNode(command);
			contextNode.add(commandNode);
		}
		
	}

	private void updateTree(DocumentModifiedEvent event) {

		DocModifiedContent content = (DocModifiedContent) event
				.getWhatModified();

		Object affectObject = content.getAffectObject();
		if (affectObject instanceof DocumentModifiedEvent) {
			updateTree((DocumentModifiedEvent) affectObject);
			return;
		}

		int modifyType = content.getModifyType();
		AddRemoveOpSupport opSupport = (AddRemoveOpSupport) 
			content.getModifySupport();

		if (affectObject instanceof JRemConfigDoc) {
			updateConfigTreeNode(modifyType, opSupport);
		} else if (affectObject instanceof JRemContextDoc) {
			updateContextTreeNode((JRemContextDoc) affectObject, modifyType, opSupport);
		} else if (affectObject instanceof JRemCommandDoc) {
			updateCommandTreeNode((JRemCommandDoc) affectObject, modifyType, opSupport);
		} else {
			assert false;
		}
	}

	private void updateConfigTreeNode(int modifyType, AddRemoveOpSupport opSupport) {

		switch(modifyType) {
		case JRemConfigDoc.MODIFIED_CONTENT_TYPE_ADD_CONTEXT:
			manageInsertContextNode(opSupport);
			break;
	
		case JRemConfigDoc.MODIFIED_CONTENT_TYPE_REM_CONTEXT:
			remContextNode( (JRemContextDoc) opSupport.getSource());
			break;
			
		default:
			modifyConfigTreeNode(modifyType);
		}		
	}

	private void modifyConfigTreeNode(int modifyType) {
				
		DefaultTreeModel model = (DefaultTreeModel) jTree.getModel();
		model.nodeChanged((DefaultMutableTreeNode) model.getRoot());

	}

	private void updateCommandTreeNode(JRemCommandDoc command, int modifyType, 
			AddRemoveOpSupport opSupport) {

		modifyCommandNode(command);
	}

	private void updateContextTreeNode(JRemContextDoc context, 
			int modifyType, AddRemoveOpSupport opSupport) {

		switch(modifyType) {
		case JRemContextDoc.MODIFIED_CONTENT_TYPE_ADD_COMMAND:
			manageInsertCommandNode(opSupport);
			break;
	
		case JRemContextDoc.MODIFIED_CONTENT_TYPE_REM_COMMAND:
			remCommandNode( (JRemCommandDoc) opSupport.getSource());
			break;
	
		default:
			modifyContextNode(context);
			break;
		}
	}

	private void remContextNode(JRemContextDoc context) {

		DefaultMutableTreeNode node = findNode(context);
		if (node == null)
			return;
		
		node.removeFromParent();

		DefaultTreeModel model = (DefaultTreeModel) jTree.getModel();
		model.reload();

		modifyConfigTreeNode(0);		
	}

	private void modifyContextNode(JRemContextDoc context) {

		DefaultMutableTreeNode node = findNode(context);
		if (node == null)
			return;

		modifyContentNodeImpl(node);
	}

	private void modifyContentNodeImpl(DefaultMutableTreeNode node) {
		
		DefaultTreeModel model = (DefaultTreeModel) jTree.getModel();
		model.nodeChanged(node);
	}

	private DefaultMutableTreeNode createContextNode(JRemContextDoc srcContext) {
		
		DefaultMutableTreeNode srcNode = new DefaultMutableTreeNode(srcContext);
		addCommandNodes(srcNode);
		return srcNode;
	}
	
	private DefaultMutableTreeNode createCommandNode(JRemCommandDoc srcCommand) {
		return new DefaultMutableTreeNode(srcCommand);
	}	
	
	private void manageInsertContextNode(AddRemoveOpSupport opSupport) {

		TreeModel model = jTree.getModel();
		
		JRemContextDoc srcContext = (JRemContextDoc) opSupport.getSource();
		JRemContextDoc dstContext = (JRemContextDoc) opSupport.getDestination();

		DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();		
		DefaultMutableTreeNode srcNode = createContextNode(srcContext);

		DefaultMutableTreeNode dstNode = null;
		
		if (dstContext != null)
			dstNode = findNode(dstContext);
		
		manageInsertNode(root, srcNode, dstNode, 
				opSupport.isInsertAfter());

	}

	private void manageInsertCommandNode(AddRemoveOpSupport opSupport) {

		JRemCommandDoc srcCommand = (JRemCommandDoc) opSupport.getSource();
		JRemCommandDoc dstCommand = (JRemCommandDoc) opSupport.getDestination();

		DefaultMutableTreeNode rootNode = null;		
		JRemContextDoc rootContext = null;
		
		if (dstCommand != null)
			rootContext = (JRemContextDoc) dstCommand.getContext();
		else 
			rootContext = (JRemContextDoc) srcCommand.getContext();
		
		rootNode = (DefaultMutableTreeNode) 
			findNode(rootContext);
	
		DefaultMutableTreeNode srcNode = createCommandNode(srcCommand);
		DefaultMutableTreeNode dstNode = null;

		if (dstCommand != null)
			dstNode = findNode(dstCommand);
		
		manageInsertNode(rootNode, srcNode, dstNode, opSupport.isInsertAfter());

	}

	private void manageInsertNode(
			DefaultMutableTreeNode root, 
			DefaultMutableTreeNode srcNode, 
			DefaultMutableTreeNode dstNode,
			boolean insertAfter) {
		
		int childIndex = 0;
		if (dstNode != null) {
			childIndex = root.getIndex(dstNode);
		
			if (insertAfter)
				childIndex++;
		}

		DefaultTreeModel model =  (DefaultTreeModel) jTree.getModel();

		model.insertNodeInto(srcNode, root, childIndex);
		
		modifyContentNodeImpl(root);
		
	}
	
	private void remCommandNode(JRemCommandDoc command) {

		DefaultMutableTreeNode node = findNode(command);
		if (node == null)
			return;

		DefaultMutableTreeNode parent = (DefaultMutableTreeNode) node
				.getParent();
		node.removeFromParent();

		DefaultTreeModel model = (DefaultTreeModel) jTree.getModel();
		model.reload(parent);

		modifyContextNode((JRemContextDoc) command.getContext());
	}

	private void modifyCommandNode(JRemCommandDoc command) {

		DefaultMutableTreeNode node = findNode(command);
		if (node == null)
			return;

		DefaultTreeModel mode = (DefaultTreeModel) jTree.getModel();
		mode.nodeChanged(node);
	}

	public void visitAllNodes(TreeVisitProcessor vcb) {

		DefaultMutableTreeNode root = (DefaultMutableTreeNode) jTree.getModel()
				.getRoot();
		visitAllNodes(root, vcb);
	}

	public void visitAllNodes(DefaultMutableTreeNode node,
			TreeVisitProcessor vcb) {
		// node is visited exactly once

		process(node, vcb);

		if (!vcb.continueProcessing())
			return;

		if (node.getChildCount() >= 0) {
			for (Enumeration e = node.children(); e.hasMoreElements();) {
				DefaultMutableTreeNode nodeChild = (DefaultMutableTreeNode) e
						.nextElement();
				visitAllNodes(nodeChild, vcb);

				if (!vcb.continueProcessing())
					return;
			}
		}
	}

	private void process(DefaultMutableTreeNode node, TreeVisitProcessor vcb) {
		vcb.process(node);
	}

	private DefaultMutableTreeNode findNode(Object node) {

		FindNodeTreeVisitorProcessor ntv = new FindNodeTreeVisitorProcessor(
				node);
		visitAllNodes(ntv);

		return ntv.getNode();
	}

	/**
	 * This method initializes jButton
	 * 
	 * @return javax.swing.JButton
	 */
	
	protected void exportDone(JTree tree, Object draggedNode, Object targetNode) {
		DeNUtils.exportDone(tree, configDoc, draggedNode, targetNode);
	}

	public Object getCurrent() {
		
		DefaultMutableTreeNode node = 
			(DefaultMutableTreeNode) jTree.getLastSelectedPathComponent();
		if (node == null)
			return null;
		
		return node.getUserObject();
	}
}