Eclipse中的TreeViewer类和ListViewer类

TreeViewer和TableViewer在使用上还是有很多相似之处.TreeViewer中冶有TableViewer中的过滤器和排序器.具体使用看TableViewer中的使用.

和Table有JFace的扩展TableViewer一样,Tree也有一个JFace中的扩展,那就是TreeViewer.因为TreeViewer和TableViewer继承自同一个父类StructuredViewer所以两者有很多方法的使用是一样的.例如:都使用setInput方法输入数据,都有内容器,标签器,以及排序器,过滤器等.

建立一个树节点的接口类:

树节点由两个基本特征,名称和子节点.这里把这两个特征抽象出来写成一个接口,然后将要做树节点的实体类实现此接口.

主义这个接口不是必须的.仅仅是为了今后操作方便,以及规范化涉及才建立的.

但是每个实体对应的都是树上的一个节点.这里定义一个树中节点的通用接口.

然后每个实体类都实现这个接口.

接着建立几个实体类:

ITreeEntry.java

 /**
  * 树上的每个一个节点都对应的是一个实体,这个实体是树上的一个节点.
  * 首先在定义实体类(People City Country)之前要先定义这个接口ITreeEntry
  * 树的节点接口
  * @author kongxiaohan
  */
 public interface ITreeEntry {
     /*
      * 设置dedao 树节点的名称
      * 只声明抽象方法,不声明字段名
      */
     public String getName();
     public void setName(String name);

     /*
      * 设置与得到子节点集合.
      */
     public void setChildren(List<ITreeEntry> children);
     public List<ITreeEntry> getChildren();
 }

City.java

 /**
  * City城市实体类
  * @author kongxiaohan
  *
  */
 public class City implements ITreeEntry{
     private Long id; // 唯一识别码，在数据库里常为自动递增的ID列
     private String name;// 城市名

     private List<ITreeEntry> peoples;//City实体的子节点  城市中的人，装在一个List集合中

     public City(String name) {
         super();
         this.name = name;
     }

     public Long getId() {
         return id;
     }
     public void setId(Long id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }

     //这个地方是设置子节点....当前是City实体,其子节点是People实体
     @Override
     public void setChildren(List<ITreeEntry> children) {
         //这个地方我犯了一错误,以前写习惯了,this.name = name
         //所以一开始这个地方我写的是this.peoples = peoples
         //在Country实体类中也是这个错误,所以运行出来的程序只有一列国家名,国家下面的城市都没有了....
         this.peoples = children;
     }

     @Override
     public List<ITreeEntry> getChildren() {
         return peoples;
     }
 }

Country.java

 /**
  * Country国家实体类
  * @author kongxiaohan
  */
 public class Country implements ITreeEntry {
     private Long id; // 唯一识别码，在数据库里常为自动递增的ID列
     private String name; // 国家名

     private List<ITreeEntry> cities; //Country实体的子节点是城市 City 此国家所包含的的城市的集合，集合元素为City对象

     public Country() {
     }

     public Country(String name) {
         super();
         this.name = name;
     }

     public Long getId() {
         return id;
     }
     public void setId(Long id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }

     @Override
     public void setChildren(List<ITreeEntry> children) {
         this.cities = children;
     }

     @Override
     public List<ITreeEntry> getChildren() {
         return cities;
     }
 }

People.java

 public class People implements ITreeEntry {
     private Long id; // 唯一识别码，在数据库里常为自动递增的ID列
     private String name; // 姓名
     private boolean sex; // 性别 true男，flase女
     private int age; // 年龄
     private Date createDate; // 记录的建立日期，是java.util.Date，而不是java.sql.Date

     public People(String name) {
         super();
         this.name = name;
     }
     public Long getId() {
         return id;
     }
     public void setId(Long id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public boolean isSex() {
         return sex;
     }
     public void setSex(boolean sex) {
         this.sex = sex;
     }
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }
     public Date getCreateDate() {
         return createDate;
     }
     public void setCreateDate(Date createDate) {
         this.createDate = createDate;
     }

     //因为人是这个树的最小子节点,所以这个地方空实现接口中的这两个方法就可以了
     @Override
     public void setChildren(List<ITreeEntry> children) {
     }
     @Override
     public List<ITreeEntry> getChildren() {
         return null;
     }
 }

制造各个实体类的工具类

DataFactory.java

 /**
  * 此类负责生成TreeViewer的方法setInput所需要的参数.
  * @author kongxiaohan
  *
  * 这个地方我没有用书中用的局部代码块,在组织代码的时候确实犯了一些小错误,
  * 确实体会到了局部代码块的意义,代码读起来容易,而且节省了内存.
  */
 public class DataFactory {
     /**
      * 在这个方法中定义生成的数据
      * 要有人People的数据对象
      * 要有国家Country的数据对象
      * 要有城市City的数据对象
      * @return
      */
     public static Object createTreeData(){
         //生成人People的数据对象
         People people1 = new People("张A");
         People people2 = new People("张B");
         People people3 = new People("张C");
         People people4 = new People("张D");
         People people5 = new People("张E");
         People people6 = new People("张F");
         People people7 = new People("张G");
         People people8 = new People("张H");
         People people9 = new People("张I");

         //生成城市City的数据对象
         City city1 = new City("北京");
         City city2 = new City("广州");
         City city3 = new City("东京");
         City city4 = new City("芝加哥");
         City city5 = new City("洛杉矶");

         //生成国家Country的的数据对象
         Country country1 = new Country("中国");
         Country country2 = new Country("日本");
         Country country3 = new Country("美国");

         /**
          * 将这些封装的对象建立关系.
          */
         //1.人和城市的关系
         //张A 张B 张C 在帝都
         ArrayList<ITreeEntry> list1 = new ArrayList<ITreeEntry>();
         list1.add(people1);
         list1.add(people2);
         list1.add(people3);
         city1.setChildren(list1);

         //张D 张E 张F在广州
         ArrayList<ITreeEntry> list2 = new ArrayList<ITreeEntry>();
         list2.add(people4);
         list2.add(people5);
         list2.add(people6);
         city2.setChildren(list2);        

         //张G 在东京
         ArrayList<ITreeEntry> list3 = new ArrayList<ITreeEntry>();
         list3.add(people7);
         city3.setChildren(list3);        

         //张I 在芝加哥
         ArrayList<ITreeEntry> list4 = new ArrayList<ITreeEntry>();
         list4.add(people8);
         city4.setChildren(list4);        

         //张H 在洛杉矶
         ArrayList<ITreeEntry> list5 = new ArrayList<ITreeEntry>();
         list5.add(people9);
         city5.setChildren(list5);        

         //2.城市和国家的关系
         //北京 上海  广州是中国的
         ArrayList<ITreeEntry> list6 = new ArrayList<ITreeEntry>();
         list6.add(city1);
         list6.add(city2);
         country1.setChildren(list6);

         //东京是日本的
         ArrayList<ITreeEntry> list7 = new ArrayList<ITreeEntry>();
         list7.add(city3);
         country2.setChildren(list7);

         //芝加哥和洛杉矶是美国的
         ArrayList<ITreeEntry> list8 = new ArrayList<ITreeEntry>();
         list8.add(city4);
         list8.add(city5);
         country3.setChildren(list8);

         //3.将国家置于一个对象之下,这个对象可以是一个List也可以是个数组
         //国家是这个树上的最上层的节点.国家和国家之间是并列的关系,把这几个国家放到一个List集合对象中.
         ArrayList<ITreeEntry> list9 = new ArrayList<ITreeEntry>();
         list9.add(country1);
         list9.add(country2);
         list9.add(country3);
         return list9;
     }
 }

内容器:TreeViewerContentProvider.java

标签器还比较简单,在TreeViewer中最主要和最复杂的是内容器,熟悉内容器是掌握TreeViewer的要点.

 /**
  * "内容器" 由它决定哪些对象记录应该输出在TreeViewer里显示.
  * @author kongxiaohan
  *
  */
 public class TreeViewerContentProvider  implements ITreeContentProvider{

     /**
      * 这个方法决定树的一级目录显示哪些对象
      * @param inputElement 是用tv.setInput()方法输入的那个对象
      * @return Object[]一个数组，数组中一个元素就是一个结点
      */
     @Override
     public Object[] getElements(Object inputElement) {
         if (inputElement instanceof List) {
             List list = (List) inputElement;
             return list.toArray();
         } else {
             return new Object[0]; // 生成一个空数组
         }
     }

     /**
      * 判断某结点是否有子结点。如果有子结点，这时结点前都有一个“＋”号图标
      *
      * @param element 需要判断是否有子的结点
      * @return true有子结点，false无子结点
      */
     @Override
     public boolean hasChildren(Object element) {
         ITreeEntry entry = (ITreeEntry) element;
         List<ITreeEntry> list = entry.getChildren();
         if (list == null || list.isEmpty()) {
             return false;
         } else {
             return true;
         }
     }

     /**
      * 由这个方法决定父结点应该显示那些子结点。
      *
      * @param parentElement 当前被点击的结点对象
      * @return 由子结点做为元素的数组
      */
     @Override
     public Object[] getChildren(Object parentElement) {
         ITreeEntry entry = (ITreeEntry) parentElement;
         List<ITreeEntry> list = entry.getChildren();
         if (list == null || list.isEmpty()) {
             return new Object[0];
         } else {
             return list.toArray();
         }
     }

     //>>>>>>>>>>>>>>>>>>>>>>>>>书上说以下三个方法是没有用的,空实现就哦了>>>>>>>>>>>>>>>>>>>>>>
     @Override
     public Object getParent(Object element) {
         return null;
     }

     @Override
     public void dispose() {
     }

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

程序说明:在内容器中最关键的是getElements,hasChildren,getChildren这三个方法.

1.getElements自在显示"第一级"结点的时候才会被执行.

2.hasChildren主要用于判断当前说系那是的节点是否有子节点,如果有子节点则前面显示一个"+"号图标,而有"+"号的结点则可以单击展开其下一级的子节点.

3.当单击右"子"的结点的时候,才会执行getChildren方法.展开其子节点后,又会对子节点执行一遍hasChildren方法,以决定其各子结点前是否显示"+"图标.

下面是"内容器"在启动,单击,关闭窗口时执行的过程.

下面以本例来解释这个图:

1.树界面启动的时候 ,先执行inputChanged()方法,接着执行getElements方法,其inputElement参数就是由setInput传入的对象:包含所有实体对象的List,此List在getElements中被转化成一个数组,数组包含第一级结点的两个元素,中国,美国,日本,他们将首先显示在页面上.接下来执行三次hasChildren方法,判断中国,日本和美国是否有子节点.他们都有子节点.,所以方法返回True,两结点前都显示"+"图标.

2.单击右子节点的中国:先执行一次getChildren方法,方法的parentElement参数就是中国结点对象.方法中把中国的子节点取出转换陈给一个数组返回,此数组包含3个元素"北京,上海,济南".接下来连续执行3次hasChildren方法来判断"北京,上海,济南"是否有子节点,如果有在结点的前面显示一个"+"图标.

3.单击没有子节点的结点:不会有执行内容器中的任何方法.

4.关闭窗口:会先后执行inputChanged和dispose方法.

标签器TreeViewerLableProvider.java

将标签器写成单独的外部类,以便于后面的实例共用,其代码如下,在getText方法中element的类型可以是国家,城市,人,由于他们都是属于一个接口,所以getText的代码简洁不少.getImage()的实现参考TableViewer的标签器.

 /**
  * "标签器" 控制记录在树中显示的文字和图像等.
  * @author kongxiaohan
  */
 public class TreeViewerLableProvider implements ILabelProvider {

     /**
      * 记录显示的文字。不能返回NULL值
      */
     @Override
     public String getText(Object element) {
         //得到这个节点对应的名字,首先对element进行强制类型转换
         ITreeEntry entry = (ITreeEntry) element;
         return entry.getName();
     }

     /**
      * 记录显示的图像，可以返回NULL值
      */
     @Override
     public Image getImage(Object element) {
         return null;
     }

 //>>>>>>>>>>>>>>>>>>>>>>书上说一下几个方法没有用,空实现就可以了.>>>>>>>>>>>>>>>>>>>>>>>>>
     @Override
     public void addListener(ILabelProviderListener listener) {
         // TODO Auto-generated method stub

     }

     @Override
     public void removeListener(ILabelProviderListener listener) {
         // TODO Auto-generated method stub

     }
     @Override
     public void dispose() {
         // TODO Auto-generated method stub

     }
     @Override
     public boolean isLabelProperty(Object element, String property) {
         // TODO Auto-generated method stub
         return false;
     }
 }

给TreeViewer加上右键菜单的方法和TableViewer相似,也要用到Action,ActionGroup,MenuManager类.当然程序要根据树的特点稍作改动.

MyActionGroup内含有各Action类,在实现Action时,对传入的结点对象要记得进行空值判断.因为TreeViewer的大部分方法都不支持空值参数.会导致异常并中断程序.

MyActionGroup.java

 public class MyActionGroup extends ActionGroup {
     //ActionGroup这是个抽象类,但是其中并没有抽象方法.
     private TreeViewer treeViewer;

     //构造方法
     public MyActionGroup(TreeViewer treeViewer) {
         this.treeViewer = treeViewer;
     }

     /**
      * 生成菜单Menu,并将两个Action传入
      */
     public void fillContextMenu(IMenuManager mgr) {
         /*
          * 加入两个Action对象到菜单管理器
          */
         MenuManager menuManager = (MenuManager) mgr; // 把接口类转换成其实现类.
         //用MenuManager管理Action
         menuManager.add(new OpenAction());
         menuManager.add(new RefreshAction());
         menuManager.add(new ExpandAction());
         menuManager.add(new CollapseAction());
         menuManager.add(new AddEntryAction());
         menuManager.add(new RemoveEntryAction());
         menuManager.add(new ModifyEntryAction());
         /*
          * 把这些功能加入到右键的Menu菜单中.
          */
         Tree tree = treeViewer.getTree();
         Menu menu = menuManager.createContextMenu(tree);
         tree.setMenu(menu);
     }

     /**
      * 打开"菜单"对应的Action类
      */
     private class OpenAction extends Action {
         public OpenAction() {
             setText("打开");
         }
         /**
          * 继承自Action的方法，动作代码写此方法中
          */
         //覆盖Action中的run()方法.
         public void run() {
             ITreeEntry obj = getSelTreeEntry();//getgetSelTreeEntry()得到当前节点
             if (obj != null) {
                 //弹出一个这个节点名字的对话框.
                 MessageDialog.openInformation(null, null, obj.getName());
             }
         }
     }

     /**
      * 刷新对应的Action类.
      */
     private class RefreshAction extends Action {
         public RefreshAction() {
             setText("刷新");
         }

         //覆盖Action类中的run()方法,里面是调用的refresh()方法.
         public void run() {
             treeViewer.refresh();// 调用TreeViewer的刷新方法
         }
     }

     /**
      * 展开当前结点的Action类
      */
     private class ExpandAction extends Action {
         public ExpandAction() {
             setText("展开");
         }
         //重写run()方法
         public void run() {
             ITreeEntry obj = getSelTreeEntry();
             if (obj != null) {
                 treeViewer.expandToLevel(obj, 1);
                 // 这个方法后面的数字是展开的层级数.这个地方设置成仅仅展开1个层级.
             }
         }
     }

     /**
      * 收缩当前结点的Action类
      */
     private class CollapseAction extends Action {
         public CollapseAction() {
             setText("收缩");
         }
         //重写run()方法
         public void run() {
             ITreeEntry obj = getSelTreeEntry();
             if (obj != null) {
                 treeViewer.collapseToLevel(obj, -1); // -1为将当前结点的所有子结点收缩
             }
         }
     }

     /**
      * 给当前结点增加一个子结点的Action类
      */
     private class AddEntryAction extends Action {
         public AddEntryAction() {
             setText("增加");
         }
         @Override
         public void run() {
             ITreeEntry obj = getSelTreeEntry();
             if (obj == null || obj instanceof People) {
                 return;
             }
             InputDialog dialog = new InputDialog(null, "给当前结点增加一个子结点", "输入名称", "请输入你要增加的节点的名字", null);
             if (dialog.open() == InputDialog.OK) {// 如果单击OK按钮
                 String entryName = dialog.getValue(); // 得到Dialog输入值
                 /* 根据单击结点的不同类型生成相应的子结点 */
                 ITreeEntry newEntry = null;
                 if (obj instanceof Country) {
                     newEntry = new City(entryName);
                 } else if (obj instanceof City) {
                     newEntry = new People(entryName);
                 }
                 /* 在增加子结点之前将父结点展开 */
                 if (!treeViewer.getExpandedState(obj)) {
                     treeViewer.expandToLevel(obj, 1);
                 }
                 treeViewer.add(obj, newEntry);// 增加结点
             }
         }
     }

     /**
      * 删除结点的Action类
      */
     private class RemoveEntryAction extends Action {
         public RemoveEntryAction() {
             setText("删除");
         }
         @Override
         public void run() {
             ITreeEntry obj = getSelTreeEntry();
             if (obj == null) {
                 return;
             }
             treeViewer.remove(obj);
         }
     }

     /**
      * 修改结点名称的Action类
      */
     private class ModifyEntryAction extends Action {
         public ModifyEntryAction() {
             setText("修改");
         }
         @Override
         public void run() {
             ITreeEntry obj = getSelTreeEntry();
             if (obj == null) {
                 return;
             }
             InputDialog dialog = new InputDialog(null, "修改结点", "输入新名称", obj.getName(), null);
             if (dialog.open() == InputDialog.OK) {
                 String entryName = dialog.getValue();//得到对话框中的值.
                 obj.setName(entryName);//给这个节点设置成得到的对话框中的名字.
                 treeViewer.refresh(obj); // 刷新结点
             }
         }
     }
     /**
      * 这个方法是自定义的方法,这个方法的作用就是得到当前选择的节点.
      */
     private ITreeEntry getSelTreeEntry() {
         IStructuredSelection selection = (IStructuredSelection) treeViewer.getSelection();
         ITreeEntry treeEntry = (ITreeEntry) (selection.getFirstElement());
         return treeEntry;
     }
 }

TreeViewer.java的实例

 public class TreeViewer1 {
     public static void main(String[] args) {
         TreeViewer1 window = new TreeViewer1();
         window.open();
     }

     //定义这个open()方法.就是创建一个典型的SWT程序的步骤
     public void open(){
         //1.Display负责管理一实现循环和控制UI线程和其他线程之间的通信
         final Display display = new Display();
         //2.创建一个或者多个Shell(shell是程序的主窗口)
         final Shell shell = new Shell();
         //3.设置shell的布局.
         shell.setSize(200, 300);
         //设置shell的布局为FillLayout
         shell.setLayout(new FillLayout());
         shell.setText("TreeViewer的第一个例子");

         Composite c = new Composite(shell, SWT.NONE);
         c.setLayout(new FillLayout());
         TreeViewer treeViewer = new TreeViewer(c, SWT.BORDER);
         treeViewer.setContentProvider(new TreeViewerContentProvider());
         treeViewer.setLabelProvider(new TreeViewerLableProvider());
         // 和TableViewer一样，数据的入口也是setInput方法
         Object inputObj = DataFactory.createTreeData();
         treeViewer.setInput(inputObj);

         /*
         //调用自定义的方法创建表格
         createTableViewer(shell);
         //4.设定内容器
         tableviewer.setContentProvider(new TableViewerContentProvider());
         //5.设定标签器
         tableviewer.setLabelProvider(new TableViewerLabelProvider());
         //6.用setInput输入数据(把PeopleFactory产生的List集合传进来)
         tableviewer.setInput(PeopleFactory.getPeoples());
         */

         //7.创建Shell中的组件(这个例子中没有加入组件,只有一个空窗口)
         shell.open();
         //8.写一个时间转发循环
         while(!shell.isDisposed()){//如果主窗口没有关闭,则一直循环
             //dispose 是"处理,处置,毁掉"的意思
             if(!display.readAndDispatch()){//// 如果display不忙
                 display.sleep();// display休眠
             }
         }
     }
 }

TreeViewer1.java的运行结果图

TreeViewer2.java

 public class TreeViewer2 {

     public static void main(String[] args) {
         TreeViewer2 window = new TreeViewer2();
         window.open();
     }

     public void open() {
         final Display display = new Display();
         final Shell shell = new Shell();
         shell.setSize(200, 300);

         shell.setLayout(new FillLayout());
         Composite c = new Composite(shell, SWT.NONE);
         c.setLayout(new FillLayout());
         TreeViewer treeViewer = new TreeViewer(c, SWT.BORDER);
         treeViewer.setContentProvider(new TreeViewerContentProvider());
         treeViewer.setLabelProvider(new TreeViewerLableProvider());
         Object inputObj = DataFactory.createTreeData();
         //>>>>>>>>>>>>>相比于TreeViewer1.java增加的>>>>>>>>>>>>>>>>>>>>>>>>>
         //生成一个ActionGroup对象
         MyActionGroup actionGroup = new MyActionGroup(treeViewer);
         // 调用fillContextMenu方法将按钮注入到菜单对象中
         actionGroup.fillContextMenu(new MenuManager());
         // --------------加入代码：END--------------------
         treeViewer.setInput(inputObj);
         // -----------------------------
         shell.open();
         while (!shell.isDisposed()) {
             if (!display.readAndDispatch()) {
                 display.sleep();
             }
         }
     }
 }

TreeViewer2.java的运行结果图:

上面的这个是<<Eclispe从入门到精通>>中第一版的代码,在第二版中对一些功能进行了一些改进.

该进在于"不同的结点显示不同的菜单".

树的"人"结点是没有子节点的.因此对于"人"这个节点来说,右键菜单中的"展开,收缩,增加"菜单项都没有任何意义,应该隐藏起来,再根据当前节点的类型决定要将哪些Action加入菜单中.按着这个思路将MyActionGroup类的fillContextMenu方法修改如下: