treeviewbasedonnode.java

TTreeview 的 Java实例 Eclipes环境下

package demo.pluginA.treeview.xmlutils;


import java.util.Vector;
import java.util.List;

import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;

import demo.pluginA.treeview.data.*;

public class TreeViewBasedOnNode {
  static Display display = new Display();

  static Shell shell = new Shell(display);

  static final Tree tree = new Tree(shell, SWT.BORDER);

  static Vector nodes = new Vector();

  public static void traditional() {
    for (int i = 0; nodes != null && i < nodes.size(); i++) {
      TreeNode node = (TreeNode) nodes.elementAt(i);
      addNode(null, node);
    }
  }

  private static void addNode(TreeItem parentItem, TreeNode node) {
    TreeItem item = null;
    if (parentItem == null)
      item = new TreeItem(tree, SWT.NONE);
    else
      item = new TreeItem(parentItem, SWT.NONE);

    item.setText(node.getName());

    Vector subs = node.getSubCategories();
    for (int i = 0; subs != null && i < subs.size(); i++)
      addNode(item, (TreeNode) subs.elementAt(i));
  }
public void displayTreeView(List<ITreeEntry> list){
	
	for(int i=0; i<list.size(); i++){
		TreeNode tnProcess = new TreeNode(list.get(i).getName(), null);
		nodes.add(tnProcess);
		List<ITreeEntry> activity = list.get(i).getChildren();
		for(int j=0; j<activity.size(); j++){
			
		    TreeNode tnActivity = new TreeNode(activity.get(j).getName(), tnProcess);
			List<ITreeEntry> task = activity.get(j).getChildren();
			if(task == null)
				continue;
			for(int k=0; k<task.size(); k++){
				TreeNode tnTask = new TreeNode(task.get(k).getName(), tnActivity);
				List<ITreeEntry> step = task.get(k).getChildren();
				if(step == null)
					continue;
				for(int l=0; l<step.size(); l++){
					new TreeNode(step.get(l).getName(), tnTask);
				}

			}
		    
		}
		
	}
    TreeViewer treeViewer = new TreeViewer(tree);

    treeViewer.setContentProvider(new MyTreeContentProvider());

    treeViewer.setLabelProvider(new MyLabelProvider());
    treeViewer.setInput(nodes);
    tree.setSize(300, 200);
    shell.setSize(300, 200);

    shell.open();

    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        display.sleep();
      }
    }
    display.dispose();
}
public void displayTreeView(){
	
    TreeNode category = new TreeNode("A", null);
    nodes.add(category);

    category = new TreeNode("a1", category);
    new TreeNode("a11", category);
    new TreeNode("a12", category);

    category = new TreeNode("B", null);
    nodes.add(category);

    new TreeNode("b1", category);
    new TreeNode("b2", category);

    TreeViewer treeViewer = new TreeViewer(tree);

    treeViewer.setContentProvider(new MyTreeContentProvider());

    treeViewer.setLabelProvider(new MyLabelProvider());
    treeViewer.setInput(nodes);
    tree.setSize(300, 200);
    shell.setSize(300, 200);

    shell.open();

    while (!shell.isDisposed()) {
      if (!display.readAndDispatch()) {
        display.sleep();
      }
    }
    display.dispose();
  }

/*  public static void main(String[] args) {
	  
	  TreeViewBasedOnNode tv = new TreeViewBasedOnNode();
	  tv.displayTreeView();
 }*/
}  
class MyLabelProvider implements ILabelProvider {
  public String getText(Object element) {
    return ((TreeNode) element).getName();
  }

  public Image getImage(Object arg0) {
    return null;
  }

  public void addListener(ILabelProviderListener arg0) {
  }

  public void dispose() {
  }

  public boolean isLabelProperty(Object arg0, String arg1) {
    return false;
  }

  public void removeListener(ILabelProviderListener arg0) {
  }
}


class MyTreeContentProvider implements ITreeContentProvider{
  public Object[] getChildren(Object parentElement) {
    Vector subcats = ((TreeNode) parentElement).getSubCategories();
    return subcats == null ? new Object[0] : subcats.toArray();
  }

  public Object getParent(Object element) {
    return ((TreeNode) element).getParent();
  }

  public boolean hasChildren(Object element) {
    return ((TreeNode) element).getSubCategories() != null;
  }

  public Object[] getElements(Object inputElement) {
    if (inputElement != null && inputElement instanceof Vector) {
      return ((Vector) inputElement).toArray();
    }
    return new Object[0];
  }

  public void dispose() {
  }

  public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
  }
}


class TreeNode {
  private String name;

  private Vector subCategories;

  private TreeNode parent;

  public TreeNode(String name, TreeNode parent) {
    this.name = name;
    this.parent = parent;
    if (parent != null)
      parent.addSubCategory(this);
  }

  public Vector getSubCategories() {
    return subCategories;
  }

  private void addSubCategory(TreeNode subcategory) {
    if (subCategories == null)
      subCategories = new Vector();
    if (!subCategories.contains(subcategory))
      subCategories.add(subcategory);
  }

  public String getName() {
    return name;
  }

  public TreeNode getParent() {
    return parent;
  }
}