workspacenavigator.java

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

package com.opensymphony.workflow.designer;

import java.util.List;
import java.util.*;
import java.awt.*;
import java.awt.event.MouseEvent;
import java.awt.event.MouseAdapter;
import java.net.MalformedURLException;
import java.io.File;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.tree.*;

import com.opensymphony.workflow.loader.*;
import com.opensymphony.workflow.FactoryException;
import com.opensymphony.workflow.designer.swing.FileDropHandler;
import com.opensymphony.workflow.designer.actions.AssignPalette;
import com.opensymphony.workflow.designer.actions.DeleteWorkflow;
import com.opensymphony.workflow.designer.actions.ImportWorkflow;

/**
 * @author Hani Suleiman ([e-mail])
 *         Date: May 15, 2003
 *         Time: 8:56:07 PM
 */
public class WorkspaceNavigator extends JTree implements TreeSelectionListener, TreeModelListener
{
  private WorkflowDesigner designer;
  private DefaultMutableTreeNode rootNode;
  private String currentWorkflow;
  private WorkflowFactory currentWorkspace = null;
	private DefaultTreeCellRenderer  cellRenderer = new WorkspaceCellRenderer();
  
  private JPopupMenu popup;
  private DeleteWorkflow deleteWorkflow;
  private AssignPalette assignPalette;

  public WorkspaceNavigator(WorkflowDesigner designer)
  {
    super(new DefaultTreeModel(new DefaultMutableTreeNode(ResourceManager.getString("workspace.none"))));
    rootNode = (DefaultMutableTreeNode)getModel().getRoot();
    this.designer = designer;
    addTreeSelectionListener(this);
    setEditable(false);
    getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
    setShowsRootHandles(true);
    setCellRenderer(cellRenderer);
    getModel().addTreeModelListener(this);

    popup = new JPopupMenu();
    popup.setInvoker(this);
    //this is kinda a hack, since we assume that importworkflow has already been registered
    //(which it has, but only because the toolbar is created before the nav, so a bit fragile
    deleteWorkflow = new DeleteWorkflow(designer);
    assignPalette = new AssignPalette(designer);
    popup.add(new JMenuItem(ActionManager.register("deleteflow", deleteWorkflow)));
    ActionManager.register("assign.palette", assignPalette);
    assignPalette.setEnabled(false);
    popup.add(new JMenuItem(assignPalette));

    addMouseListener(new MouseAdapter()
    {
      public void mousePressed(MouseEvent e)
      {
        handlePopup(e);
      }

      public void mouseReleased(MouseEvent e)
      {
        handlePopup(e);
      }

      private void handlePopup(MouseEvent e)
      {
        if(e.isPopupTrigger())
        {
          int row = getRowForLocation(e.getX(), e.getY());
          if(row != -1)
          {
            TreePath path = getPathForRow(row);
            if(path.getPathCount() != 2) return;
            String workflowName = path.getLastPathComponent().toString();
            Point p = new Point(e.getX(), e.getY());
            SwingUtilities.convertPointToScreen(p, WorkspaceNavigator.this);
            deleteWorkflow.setWorkflow(workflowName);
            assignPalette.setWorkflow(workflowName);
            popup.setLocation(p.x, p.y);
            popup.setVisible(true);
          }
        }
      }
    });

    new FileDropHandler(this, true)
    {
      public void filesDropped(File[] files)
      {
        for(int i = 0; i < files.length; i++)
        {
          File file = files[i];
          if(file.getName().endsWith(".xml") && !file.isDirectory())
          {
            try
            {
              ((ImportWorkflow)ActionManager.get("importflow")).importURL(file.toURL());
            }
            catch(MalformedURLException e)
            {
              e.printStackTrace();
            }
          }
        }
      }
    };
  }

  public void selectWorkflow(String name)
  {
    Object root = getModel().getRoot();
    int count = getModel().getChildCount(root);
    for(int i = 0; i < count; i++)
    {
      DefaultMutableTreeNode node = (DefaultMutableTreeNode)getModel().getChild(root, i);
      if (node.getUserObject() instanceof WorkflowDescriptor)
      {
      	WorkflowDescriptor desc = (WorkflowDescriptor)node.getUserObject();
      	if(desc.getName().equals(name))
      	{
					designer.selectWorkflow(name);
        	
        	TreePath path = new TreePath(new Object[]{root, node});
        	getSelectionModel().setSelectionPath(path);
        	expandPath(path);
        	return;
      	}
      }
    }
  }

  public void removeWorkflow(String name)
  {
    Object root = getModel().getRoot();
    DefaultTreeModel model = (DefaultTreeModel)getModel();
    int count = model.getChildCount(root);
    for(int i = 0; i < count; i++)
    {
      DefaultMutableTreeNode node = (DefaultMutableTreeNode)model.getChild(root, i);
      if (node.getUserObject() instanceof WorkflowDescriptor)
      {
      	WorkflowDescriptor workflow = (WorkflowDescriptor)node.getUserObject();
      	if (workflow.getName().equals(name))
      	{ 
					model.removeNodeFromParent(node);
					return;
      	}
      }
    }
  }
	
	public void valueChanged(TreeSelectionEvent e)
	{
		DefaultMutableTreeNode node = (DefaultMutableTreeNode)getLastSelectedPathComponent();
		if (node == null) 
			return;
		designer.showDetails(node.getUserObject());
		Object user = node.getUserObject();
		if (user instanceof AbstractDescriptor)
		{
			if (user instanceof WorkflowDescriptor)
			{
				designer.selectWorkflow(((WorkflowDescriptor)user).getName());
			}
			else if (user instanceof ResultDescriptor)
			{
        // select the current workflow
				TreeNode[] nodes = node.getPath();
				if (nodes.length>2)
				{
					DefaultMutableTreeNode workflowNode = (DefaultMutableTreeNode)nodes[1];
					if (workflowNode.getUserObject() instanceof WorkflowDescriptor)
					{
						designer.selectWorkflow(((WorkflowDescriptor)workflowNode.getUserObject()).getName());	 	
					}
				}
				designer.selectCell((AbstractDescriptor)user);
			}
			else
			{
				AbstractDescriptor parentDescriptor = ((AbstractDescriptor)user).getParent();
				if (parentDescriptor instanceof WorkflowDescriptor)
				{
					designer.selectWorkflow(((WorkflowDescriptor)parentDescriptor).getName());
					designer.selectCell((AbstractDescriptor)user);
				}
			}
		}
	}	
	
  public void treeNodesChanged(TreeModelEvent e)
  {
    DefaultMutableTreeNode node;
    node = (DefaultMutableTreeNode)(e.getTreePath().getLastPathComponent());
    /*
     * If the event lists children, then the changed
     * node is the child of the node we've already
     * gotten.  Otherwise, the changed node and the
     * specified node are the same.
     */
    try
    {
      int index = e.getChildIndices()[0];
      node = (DefaultMutableTreeNode)(node.getChildAt(index));
    }
    catch(NullPointerException exc)
    {}
    String newValue = (String)node.getUserObject();
    designer.renameWorkflow(currentWorkflow, newValue);
    currentWorkflow = newValue;
  }

  public void setWorkspace(WorkflowFactory workspace)
  {
    removeChildNodes(rootNode);
    ((DefaultTreeModel)getModel()).reload();
    DefaultMutableTreeNode root = (DefaultMutableTreeNode)getModel().getRoot();
    if(workspace != null)
    {
      String[] workflows;
      currentWorkspace = workspace;
      try {
				workflows = workspace.getWorkflowNames();
      }
      catch(FactoryException t)
      {
      	return;
      }
      
      for(int i = 0; i < workflows.length; i++)
      {
        try 
        {
        	WorkflowDescriptor descriptor = workspace.getWorkflow(workflows[i], false);
        	addWorkflow(descriptor);
        }
        catch(FactoryException fe)
        {
        }
      }
      root.setUserObject(workspace.getName());
      expandRow(0);
    }
    else
    {
      root.setUserObject(ResourceManager.getString("workspace.none"));
    }
  }

	public void addWorkflow(String name)
	{
		if (currentWorkspace!=null)
		{
			try 
			{
				WorkflowDescriptor descriptor = currentWorkspace.getWorkflow(name);
				addWorkflow(descriptor);
			}
			catch(FactoryException fe)
			{        	
			}
		}
	}
	
  public void addWorkflow(WorkflowDescriptor desc)
  {
    if (desc!=null)
   	{
   		// Add the workflow
   		DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(desc) {
   									public String toString()
										{
											if (getUserObject() instanceof WorkflowDescriptor)
											{
												return ((WorkflowDescriptor)getUserObject()).getName();
											}
											else
											{
												return super.toString();
											}
										}
   								};
			DefaultTreeModel model = (DefaultTreeModel)getModel();
    	DefaultMutableTreeNode root = (DefaultMutableTreeNode)model.getRoot();
    	model.insertNodeInto(childNode, root, root.getChildCount());
   	
   		// Add all the workflow childs (folders)
   		// meta
   		// registers
   		// trigger-functions
   		// initial-actions (folder)
			DefaultMutableTreeNode folderNode = new DefaultMutableTreeNode(ResourceManager.getString("initialactions.folder"));
   		model.insertNodeInto(folderNode, childNode, childNode.getChildCount());
   		addActions(desc.getInitialActions(), folderNode);
   		// global-actions (folder)
			folderNode = new DefaultMutableTreeNode(ResourceManager.getString("globalactions.folder"));
			model.insertNodeInto(folderNode, childNode, childNode.getChildCount());
			addActions(desc.getGlobalActions(), folderNode);
   		// common-actions (folder)
			folderNode = new DefaultMutableTreeNode(ResourceManager.getString("commonactions.folder"));
			model.insertNodeInto(folderNode, childNode, childNode.getChildCount());
			addCommonActions(desc, folderNode);
   		// steps (folder)
			folderNode = new DefaultMutableTreeNode(ResourceManager.getString("steps.folder"));
			model.insertNodeInto(folderNode, childNode, childNode.getChildCount());
			addSteps(desc, folderNode);
   		// splits (folder)
			folderNode = new DefaultMutableTreeNode(ResourceManager.getString("splits.folder"));
			model.insertNodeInto(folderNode, childNode, childNode.getChildCount());
			addSplits(desc, folderNode);
   		// joins (folder)
			folderNode = new DefaultMutableTreeNode(ResourceManager.getString("joins.folder"));
			model.insertNodeInto(folderNode, childNode, childNode.getChildCount());
			addJoins(desc, folderNode);
   	}
  }

	private void addActions(List actions, DefaultMutableTreeNode node)
	{
		if ((actions!=null)&&(node!=null))
		{
			DefaultTreeModel model = (DefaultTreeModel)getModel();
			removeChildNodes(node); 
		
			for (Iterator iterator=actions.iterator(); iterator.hasNext();)
			{
				ActionDescriptor action = (ActionDescriptor)iterator.next(); 
				DefaultMutableTreeNode actionNode = new DefaultMutableTreeNode(action) {
										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 addActionResults(ActionDescriptor action, DefaultMutableTreeNode node)
	{
		if ((action==null)||(node==null))
			return;
		
		DefaultTreeModel model = (DefaultTreeModel)getModel();
		removeChildNodes(node);
		
		//	add the action unconditional-results
		ResultDescriptor unconditional = action.getUnconditionalResult();
		if (unconditional!=null)
		{
			DefaultMutableTreeNode unconditionalNode = new DefaultMutableTreeNode(unconditional){
								 public String toString()
								 {
									 if (getUserObject() instanceof ResultDescriptor)
									 {
										 String name = ((ResultDescriptor)getUserObject()).getDisplayName();
										 if ((name==null)||(name.length()==0))
										 {
										 		ActionDescriptor a = (ActionDescriptor)((ResultDescriptor)getUserObject()).getParent();
										 		if (a!=null)
										 			name = a.getName();
										 		else
										 			name = "";		
										 }
										 return name;
									 }
									 else
									 {
										 return super.toString();
									 }
								 }
							 };
			model.insertNodeInto(unconditionalNode, node, node.getChildCount());
		}
		// add the action conditional-results
		List results = action.getConditionalResults(); 			
		if (results!=null)
		{
			for (Iterator it=results.iterator(); it.hasNext();)
			{
				ConditionalResultDescriptor conditional = (ConditionalResultDescriptor)it.next();
				DefaultMutableTreeNode conditionalNode = new DefaultMutableTreeNode(conditional){
														 public String toString()
														 {
															 if (getUserObject() instanceof ConditionalResultDescriptor)
															 {
																 String name = ((ConditionalResultDescriptor)getUserObject()).getDisplayName();
																 if ((name==null)||(name.length()==0))
																 {
																 		ActionDescriptor a = (ActionDescriptor)((ConditionalResultDescriptor)getUserObject()).getParent();
																 		if (a!=null)
																 			name = a.getName();
																 		else
																 			name = "";
																 }
																 return name;
															 }
															 else
															 {
																 return super.toString();
															 }
														 }
													 };
				model.insertNodeInto(conditionalNode, node, node.getChildCount());
			}
		}
	}
	
	private void addCommonActions(WorkflowDescriptor desc, DefaultMutableTreeNode node)
	{
		if ((desc!=null)&&(node!=null))
		{
			DefaultTreeModel model = (DefaultTreeModel)getModel();
			removeChildNodes(node);
			
			Collection actions = desc.getCommonActions().values();  
			for (Iterator iterator=actions.iterator(); iterator.hasNext();)
			{
				ActionDescriptor action = (ActionDescriptor)iterator.next();
				DefaultMutableTreeNode actionNode = new DefaultMutableTreeNode(action) {