workspacenavigator.java

一个很好实用的工作流OSWORKFLOW开发例子.有着非常优秀的灵活性.

										public String toString()
										{
											if (getUserObject() instanceof ActionDescriptor)
											{
												return ((ActionDescriptor)getUserObject()).getName();
											}
											else
											{
												return super.toString();
											}
										}
									};
				model.insertNodeInto(actionNode, node, node.getChildCount());
				addActionResults(action, actionNode);
			}			 
		}
	}
	
	private void addSplitResults(SplitDescriptor split, DefaultMutableTreeNode node)
	{
		if ((split==null)||(node==null))
			return;
	
		DefaultTreeModel model = (DefaultTreeModel)getModel();
		removeChildNodes(node);
		
		List results = split.getResults();  			
		if (results!=null)
		{
			for (Iterator it=results.iterator(); it.hasNext();)
			{
				ResultDescriptor unconditional = (ResultDescriptor)it.next();
				DefaultMutableTreeNode resultNode = new DefaultMutableTreeNode(unconditional){
														 public String toString()
														 {
															 if (getUserObject() instanceof ResultDescriptor)
															 {
																 String name = ((ResultDescriptor)getUserObject()).getDisplayName();
																 if ((name==null)||(name.length()==0))
																 {
																		// TODO verificare il nome da assegnare nel caso il displayname sia vuoto
																		name = "Split Result";
																 }
																 return name;
															 }
															 else
															 {
																 return super.toString();
															 }
														 }
													 };
				model.insertNodeInto(resultNode, node, node.getChildCount());
			}
		}
	}

	private void addJoinResult(JoinDescriptor join, DefaultMutableTreeNode node)
	{
		if ((join==null)||(node==null))
			return;

		DefaultTreeModel model = (DefaultTreeModel)getModel();
		removeChildNodes(node);

		ResultDescriptor result = join.getResult();  			
		if (result!=null)
		{
			DefaultMutableTreeNode resultNode = new DefaultMutableTreeNode(result){
														 public String toString()
														 {
															 if (getUserObject() instanceof ResultDescriptor)
															 {
																 String name = ((ResultDescriptor)getUserObject()).getDisplayName();
																 if ((name==null)||(name.length()==0))
																 {
																		// TODO verificare il nome da assegnare nel caso il displayname sia vuoto
																		name = "Join Result";
																 }
																 return name;
															 }
															 else
															 {
																 return super.toString();
															 }
														 }
													 };
			model.insertNodeInto(resultNode, node, node.getChildCount());
		}
	}

	private void addSteps(WorkflowDescriptor desc, DefaultMutableTreeNode node)
	{
		if ((desc!=null)&&(node!=null))
		{
			DefaultTreeModel model = (DefaultTreeModel)getModel();
			removeChildNodes(node);
			
			List steps = desc.getSteps();  
			for (Iterator iterator=steps.iterator(); iterator.hasNext();)
			{
				StepDescriptor step = (StepDescriptor)iterator.next();
				DefaultMutableTreeNode stepNode = new DefaultMutableTreeNode(step) {
										public String toString()
										{
											if (getUserObject() instanceof StepDescriptor)
											{
												return ((StepDescriptor)getUserObject()).getName();
											}
											else
											{
												return super.toString();
											}
										}
									};
				model.insertNodeInto(stepNode, node, node.getChildCount());
				addActions(step.getActions(), stepNode); 
			}			 
		}
	}
  
  private void addSplits(WorkflowDescriptor desc, DefaultMutableTreeNode node)
  {
		if ((desc!=null)&&(node!=null))
		{
			DefaultTreeModel model = (DefaultTreeModel)getModel();
			removeChildNodes(node); 
			
			List splits = desc.getSplits();   
			for (Iterator iterator=splits.iterator(); iterator.hasNext();)
			{
				SplitDescriptor split = (SplitDescriptor)iterator.next();
				DefaultMutableTreeNode splitNode = new DefaultMutableTreeNode(split) {
										public String toString()
										{
											if (getUserObject() instanceof SplitDescriptor)
											{
												String s = "Split #" + ((SplitDescriptor)getUserObject()).getId();  
												return s;  
											}
											else
											{
												return super.toString();
											}
										}
									};
				model.insertNodeInto(splitNode, node, node.getChildCount());
				addSplitResults(split, splitNode);
			}			 
		}
  }
  
  private void addJoins(WorkflowDescriptor desc, DefaultMutableTreeNode node)
  {
		if ((desc!=null)&&(node!=null))
		{
			DefaultTreeModel model = (DefaultTreeModel)getModel();
			removeChildNodes(node);		
				
			List joins = desc.getJoins();    
			for (Iterator iterator=joins.iterator(); iterator.hasNext();)
			{
				JoinDescriptor join = (JoinDescriptor)iterator.next();
				DefaultMutableTreeNode joinNode = new DefaultMutableTreeNode(join) {
										public String toString()
										{
											if (getUserObject() instanceof JoinDescriptor)
											{
												String s = "Join #" + ((JoinDescriptor)getUserObject()).getId();   
												return s;  
											}
											else
											{
												return super.toString();
											}
										}
									};
				model.insertNodeInto(joinNode, node, node.getChildCount());
				addJoinResult(join, joinNode);
			}			 
		}
  }
  
  public void selectTreeNode(WorkflowDescriptor workflow, AbstractDescriptor desc)
 	{
  	// select a tree item  
  	if ((workflow==null)||(desc==null))
  		return;
		DefaultMutableTreeNode root = (DefaultMutableTreeNode)getModel().getRoot();
		// loop over the workspace childs (the workflows)
		for (int i=0; i<root.getChildCount(); i++)
		{
			DefaultMutableTreeNode workflowNode = (DefaultMutableTreeNode)root.getChildAt(i);
			if (workflowNode.getUserObject()==workflow)
			{
				// search over all the childs of the workflow
				if (workflowNode.getUserObject()==desc)
				{
					selectExpandNode(workflowNode);
				}
				else
				{
					DefaultMutableTreeNode node = findNodeRecursive(workflowNode, desc);
					if (node!=null)
					{
						selectExpandNode(node);
					}
				}
				break;		 
			}
		}
  }
 	
	private DefaultMutableTreeNode findNodeRecursive(DefaultMutableTreeNode parentNode, AbstractDescriptor desc)
	{
		if ((parentNode==null)||(desc==null))
			return null;
			
		for (int i=0; i<parentNode.getChildCount(); i++)
		{
			DefaultMutableTreeNode childNode = (DefaultMutableTreeNode)parentNode.getChildAt(i);  
			if (childNode.getUserObject()==desc)
			{
				return childNode;
			}
			else
			{
				DefaultMutableTreeNode node = findNodeRecursive(childNode, desc);
				if (node!=null)
					return node;
			}
		}
		return null;
	}
 	
 	private DefaultMutableTreeNode findFolderNode(WorkflowDescriptor workflow, String folderName)
 	{
		if (workflow==null)
			return null;
		DefaultMutableTreeNode root = (DefaultMutableTreeNode)getModel().getRoot();
		DefaultMutableTreeNode workflowNode = findNodeRecursive(root, workflow);
		if (workflowNode!=null)
		{
			for (int z=0; z<workflowNode.getChildCount(); z++)
			{
				DefaultMutableTreeNode folderNode = (DefaultMutableTreeNode)workflowNode.getChildAt(z);
				if (folderNode.getUserObject() instanceof String)
				{
					String s = (String)folderNode.getUserObject();
					if (s.equals(folderName))
					{
						return folderNode; 							
					}
				}
			}
		}
		return null;
 	}
 	
 	private void selectExpandNode(DefaultMutableTreeNode node)
 	{
		TreeNode[] nodes = node.getPath();
		TreePath path = new TreePath(nodes);  
		getSelectionModel().setSelectionPath(path);
		expandPath(path);
		scrollPathToVisible(path);
	}
 	
 	public void reloadSteps(WorkflowDescriptor workflow)
 	{
 		DefaultMutableTreeNode stepFolder = findFolderNode(workflow, ResourceManager.getString("steps.folder")); 	
 		if (stepFolder!=null)
 		{
 			addSteps(workflow, stepFolder);
 		}
 	}
 	
	public void reloadSplits(WorkflowDescriptor workflow)
	{
		DefaultMutableTreeNode splitsFolder = findFolderNode(workflow, ResourceManager.getString("splits.folder")); 	
		if (splitsFolder!=null)
		{
			addSplits(workflow, splitsFolder);
		}
	}
 	
	public void reloadJoins(WorkflowDescriptor workflow)
	{
		DefaultMutableTreeNode joinsFolder = findFolderNode(workflow, ResourceManager.getString("joins.folder")); 	
		if (joinsFolder!=null)
		{
			addJoins(workflow, joinsFolder);
		}
	}
 	
 	public void reloadInitialAction(WorkflowDescriptor workflow)
 	{
		DefaultMutableTreeNode iaFolder = findFolderNode(workflow, ResourceManager.getString("initialactions.folder")); 	
		if (iaFolder!=null)
		{
			addActions(workflow.getInitialActions(), iaFolder);
		}
 	}
 	
 	public void reloadStep(WorkflowDescriptor workflow, StepDescriptor step)
 	{
 		DefaultMutableTreeNode stepNode = findNodeRecursive(findFolderNode(workflow, ResourceManager.getString("steps.folder")), step);
 		if (stepNode!=null)
 		{
 			addActions(step.getActions(), stepNode);	
 		}
 	}
 	
	public void reloadSplit(WorkflowDescriptor workflow, SplitDescriptor split)
	{
		DefaultMutableTreeNode splitNode = findNodeRecursive(findFolderNode(workflow, ResourceManager.getString("splits.folder")), split);
		if (splitNode!=null)
		{
			addSplitResults(split, splitNode);	
		}
	}
 	
 	public void reloadJoin(WorkflowDescriptor workflow, JoinDescriptor join)
 	{
		DefaultMutableTreeNode joinNode = findNodeRecursive(findFolderNode(workflow, ResourceManager.getString("joins.folder")), join);
		if (joinNode!=null)
		{
			addJoinResult(join, joinNode);	
		}
 	}
 	
 	public void reloadAction(WorkflowDescriptor workflow, ActionDescriptor action)
 	{
		DefaultMutableTreeNode root = (DefaultMutableTreeNode)getModel().getRoot();
		DefaultMutableTreeNode workflowNode = findNodeRecursive(root, workflow);
 		DefaultMutableTreeNode actionNode = findNodeRecursive(workflowNode, action);  
 		if (actionNode!=null)
 		{
 			addActionResults(action, actionNode);
 		}
 	}
 	
 	public void reloadWorkflow(WorkflowDescriptor workflow)
 	{
 		reloadInitialAction(workflow);
 		reloadSteps(workflow);
 		reloadJoins(workflow);
 		reloadSplits(workflow);
 	}
 	
	private void removeChildNodes(DefaultMutableTreeNode parentNode)
	{
		DefaultTreeModel model = (DefaultTreeModel)getModel();
		while (model.getChildCount(parentNode)>0)
		{
			DefaultMutableTreeNode node = (DefaultMutableTreeNode)parentNode.getFirstChild(); 
			model.removeNodeFromParent(node);
		}
	}
 	
  public void treeNodesInserted(TreeModelEvent e)
  {
  }

  public void treeNodesRemoved(TreeModelEvent e)
  {
  }

  public void treeStructureChanged(TreeModelEvent e)
  {
  }
  
  
  /*
   * @author acapitani
   */
  static class WorkspaceCellRenderer extends DefaultTreeCellRenderer
	{ 	
		public WorkspaceCellRenderer()
		{
			super();
		//	setClosedIcon(ResourceManager.getIcon("action"));
		//	setOpenIcon(ResourceManager.getIcon("action"));
		//	setLeafIcon(ResourceManager.getIcon("step"));
		}
  	
		public Component getTreeCellRendererComponent(JTree tree, Object value,
									boolean sel,
									boolean expanded,
									boolean leaf, int row,
									boolean hasFocus)
			{
				Component result = super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus);
				if (value instanceof DefaultMutableTreeNode)
				{
					Object obj = ((DefaultMutableTreeNode)value).getUserObject();
					if (obj instanceof WorkflowDescriptor)
					{
						// workflow icon
						setIcon(ResourceManager.getIcon("layout"));
					}
					else if (obj instanceof ActionDescriptor)
					{
						// action icon
						setIcon(ResourceManager.getIcon("action"));
					}
					else if (obj instanceof ConditionalResultDescriptor)
					{
						// conditional-result icon
						setIcon(ResourceManager.getIcon("conditional.result"));
					}
					else if (obj instanceof ResultDescriptor)
					{
						// unconditional-result icon
						setIcon(ResourceManager.getIcon("unconditional.result"));
					}
					else if (obj instanceof StepDescriptor)
					{
						// step icon
						setIcon(ResourceManager.getIcon("step"));
					}
					else if (obj instanceof SplitDescriptor)
					{
						// split icon
						setIcon(ResourceManager.getIcon("split"));
					}
					else if (obj instanceof JoinDescriptor)
					{
						setIcon(ResourceManager.getIcon("join"));
					}
				}
				return result; 
			} 	
		}
}