Eclipse中的TreeViewer类和ListViewer类

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

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

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

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

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

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

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

接着建立几个实体类:

ITreeEntry.java

 1 /**
 2  * 树上的每个一个节点都对应的是一个实体,这个实体是树上的一个节点.
 3  * 首先在定义实体类(People City Country)之前要先定义这个接口ITreeEntry
 4  * 树的节点接口
 5  * @author kongxiaohan
 6  */
 7 public interface ITreeEntry {
 8     /*
 9      * 设置dedao 树节点的名称    
10      * 只声明抽象方法,不声明字段名
11      */
12     public String getName();
13     public void setName(String name);
14     
15     
16     /*
17      * 设置与得到子节点集合.
18      */
19     public void setChildren(List<ITreeEntry> children);
20     public List<ITreeEntry> getChildren();
21 }

City.java

 1 /**
 2  * City城市实体类
 3  * @author kongxiaohan
 4  *
 5  */
 6 public class City implements ITreeEntry{
 7     private Long id; // 唯一识别码，在数据库里常为自动递增的ID列
 8     private String name;// 城市名
 9     
10     private List<ITreeEntry> peoples;//City实体的子节点  城市中的人，装在一个List集合中
11     
12     public City(String name) {
13         super();
14         this.name = name;
15     }
16     
17     public Long getId() {
18         return id;
19     }
20     public void setId(Long id) {
21         this.id = id;
22     }
23     public String getName() {
24         return name;
25     }
26     public void setName(String name) {
27         this.name = name;
28     }
29     
30     //这个地方是设置子节点....当前是City实体,其子节点是People实体
31     @Override
32     public void setChildren(List<ITreeEntry> children) {
33         //这个地方我犯了一错误,以前写习惯了,this.name = name
34         //所以一开始这个地方我写的是this.peoples = peoples 
35         //在Country实体类中也是这个错误,所以运行出来的程序只有一列国家名,国家下面的城市都没有了....
36         this.peoples = children;
37     }
38 
39     @Override
40     public List<ITreeEntry> getChildren() {
41         return peoples;
42     }
43 }

Country.java

 1 /**
 2  * Country国家实体类
 3  * @author kongxiaohan
 4  */
 5 public class Country implements ITreeEntry {
 6     private Long id; // 唯一识别码，在数据库里常为自动递增的ID列
 7     private String name; // 国家名
 8     
 9     private List<ITreeEntry> cities; //Country实体的子节点是城市 City 此国家所包含的的城市的集合，集合元素为City对象
10     
11     public Country() {
12     }
13     
14     public Country(String name) {
15         super();
16         this.name = name;
17     }
18     
19     public Long getId() {
20         return id;
21     }
22     public void setId(Long id) {
23         this.id = id;
24     }
25     public String getName() {
26         return name;
27     }
28     public void setName(String name) {
29         this.name = name;
30     }
31     
32     @Override
33     public void setChildren(List<ITreeEntry> children) {
34         this.cities = children;
35     }
36 
37     @Override
38     public List<ITreeEntry> getChildren() {
39         return cities;
40     }
41 }

People.java

 1 public class People implements ITreeEntry {
 2     private Long id; // 唯一识别码，在数据库里常为自动递增的ID列
 3     private String name; // 姓名
 4     private boolean sex; // 性别 true男，flase女
 5     private int age; // 年龄
 6     private Date createDate; // 记录的建立日期，是java.util.Date，而不是java.sql.Date
 7 
 8     public People(String name) {
 9         super();
10         this.name = name;
11     }
12     public Long getId() {
13         return id;
14     }
15     public void setId(Long id) {
16         this.id = id;
17     }
18     public String getName() {
19         return name;
20     }
21     public void setName(String name) {
22         this.name = name;
23     }
24     public boolean isSex() {
25         return sex;
26     }
27     public void setSex(boolean sex) {
28         this.sex = sex;
29     }
30     public int getAge() {
31         return age;
32     }
33     public void setAge(int age) {
34         this.age = age;
35     }
36     public Date getCreateDate() {
37         return createDate;
38     }
39     public void setCreateDate(Date createDate) {
40         this.createDate = createDate;
41     }
42     
43     
44     //因为人是这个树的最小子节点,所以这个地方空实现接口中的这两个方法就可以了
45     @Override
46     public void setChildren(List<ITreeEntry> children) {
47     }
48     @Override
49     public List<ITreeEntry> getChildren() {
50         return null;
51     }
52 }

制造各个实体类的工具类

DataFactory.java

 1 /**
 2  * 此类负责生成TreeViewer的方法setInput所需要的参数.
 3  * @author kongxiaohan
 4  * 
 5  * 这个地方我没有用书中用的局部代码块,在组织代码的时候确实犯了一些小错误,
 6  * 确实体会到了局部代码块的意义,代码读起来容易,而且节省了内存.
 7  */
 8 public class DataFactory {
 9     /**
10      * 在这个方法中定义生成的数据
11      * 要有人People的数据对象
12      * 要有国家Country的数据对象
13      * 要有城市City的数据对象
14      * @return
15      */
16     public static Object createTreeData(){
17         //生成人People的数据对象
18         People people1 = new People("张A");
19         People people2 = new People("张B");
20         People people3 = new People("张C");
21         People people4 = new People("张D");
22         People people5 = new People("张E");
23         People people6 = new People("张F");
24         People people7 = new People("张G");
25         People people8 = new People("张H");
26         People people9 = new People("张I");
27         
28         //生成城市City的数据对象
29         City city1 = new City("北京");
30         City city2 = new City("广州");
31         City city3 = new City("东京");
32         City city4 = new City("芝加哥");
33         City city5 = new City("洛杉矶");
34         
35         //生成国家Country的的数据对象
36         Country country1 = new Country("中国");
37         Country country2 = new Country("日本");
38         Country country3 = new Country("美国");
39         
40         /**
41          * 将这些封装的对象建立关系.
42          */
43         //1.人和城市的关系 
44         //张A 张B 张C 在帝都
45         ArrayList<ITreeEntry> list1 = new ArrayList<ITreeEntry>();
46         list1.add(people1);
47         list1.add(people2);
48         list1.add(people3);
49         city1.setChildren(list1);
50         
51         //张D 张E 张F在广州 
52         ArrayList<ITreeEntry> list2 = new ArrayList<ITreeEntry>();
53         list2.add(people4);
54         list2.add(people5);
55         list2.add(people6);
56         city2.setChildren(list2);        
57         
58         //张G 在东京
59         ArrayList<ITreeEntry> list3 = new ArrayList<ITreeEntry>();
60         list3.add(people7);
61         city3.setChildren(list3);        
62 
63         //张I 在芝加哥
64         ArrayList<ITreeEntry> list4 = new ArrayList<ITreeEntry>();
65         list4.add(people8);
66         city4.setChildren(list4);        
67 
68         //张H 在洛杉矶
69         ArrayList<ITreeEntry> list5 = new ArrayList<ITreeEntry>();
70         list5.add(people9);
71         city5.setChildren(list5);        
72         
73         //2.城市和国家的关系
74         //北京 上海  广州是中国的
75         ArrayList<ITreeEntry> list6 = new ArrayList<ITreeEntry>();
76         list6.add(city1);
77         list6.add(city2);
78         country1.setChildren(list6);
79         
80         //东京是日本的
81         ArrayList<ITreeEntry> list7 = new ArrayList<ITreeEntry>();
82         list7.add(city3);
83         country2.setChildren(list7);
84         
85         //芝加哥和洛杉矶是美国的
86         ArrayList<ITreeEntry> list8 = new ArrayList<ITreeEntry>();
87         list8.add(city4);
88         list8.add(city5);
89         country3.setChildren(list8);
90         
91         //3.将国家置于一个对象之下,这个对象可以是一个List也可以是个数组
92         //国家是这个树上的最上层的节点.国家和国家之间是并列的关系,把这几个国家放到一个List集合对象中.
93         ArrayList<ITreeEntry> list9 = new ArrayList<ITreeEntry>();
94         list9.add(country1);
95         list9.add(country2);
96         list9.add(country3);
97         return list9;
98     }
99 }

内容器:TreeViewerContentProvider.java

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

 1 /**
 2  * "内容器" 由它决定哪些对象记录应该输出在TreeViewer里显示.
 3  * @author kongxiaohan
 4  *
 5  */
 6 public class TreeViewerContentProvider  implements ITreeContentProvider{
 7 
 8     /**
 9      * 这个方法决定树的一级目录显示哪些对象
10      * @param inputElement 是用tv.setInput()方法输入的那个对象
11      * @return Object[]一个数组，数组中一个元素就是一个结点
12      */
13     @Override
14     public Object[] getElements(Object inputElement) {
15         if (inputElement instanceof List) {
16             List list = (List) inputElement;
17             return list.toArray();
18         } else {
19             return new Object[0]; // 生成一个空数组
20         }
21     }
22     
23     
24     /**
25      * 判断某结点是否有子结点。如果有子结点，这时结点前都有一个“＋”号图标
26      * 
27      * @param element 需要判断是否有子的结点
28      * @return true有子结点，false无子结点
29      */
30     @Override
31     public boolean hasChildren(Object element) {
32         ITreeEntry entry = (ITreeEntry) element;
33         List<ITreeEntry> list = entry.getChildren();
34         if (list == null || list.isEmpty()) {
35             return false;
36         } else {
37             return true;
38         }
39     }
40     
41     
42     /**
43      * 由这个方法决定父结点应该显示那些子结点。
44      * 
45      * @param parentElement 当前被点击的结点对象
46      * @return 由子结点做为元素的数组
47      */
48     @Override
49     public Object[] getChildren(Object parentElement) {
50         ITreeEntry entry = (ITreeEntry) parentElement;
51         List<ITreeEntry> list = entry.getChildren();
52         if (list == null || list.isEmpty()) {
53             return new Object[0];
54         } else {
55             return list.toArray();
56         }
57     }
58 
59     //>>>>>>>>>>>>>>>>>>>>>>>>>书上说以下三个方法是没有用的,空实现就哦了>>>>>>>>>>>>>>>>>>>>>>
60     @Override
61     public Object getParent(Object element) {
62         return null;
63     }
64 
65     @Override
66     public void dispose() {
67     }
68     
69     @Override
70     public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
71     }
72 }

程序说明:在内容器中最关键的是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的标签器.

 1 /**
 2  * "标签器" 控制记录在树中显示的文字和图像等.
 3  * @author kongxiaohan
 4  */
 5 public class TreeViewerLableProvider implements ILabelProvider {
 6 
 7     /**
 8      * 记录显示的文字。不能返回NULL值
 9      */
10     @Override
11     public String getText(Object element) {
12         //得到这个节点对应的名字,首先对element进行强制类型转换
13         ITreeEntry entry = (ITreeEntry) element;
14         return entry.getName();
15     }
16     
17     /**
18      * 记录显示的图像，可以返回NULL值
19      */    
20     @Override
21     public Image getImage(Object element) {
22         return null;
23     }
24     
25 //>>>>>>>>>>>>>>>>>>>>>>书上说一下几个方法没有用,空实现就可以了.>>>>>>>>>>>>>>>>>>>>>>>>>    
26     @Override
27     public void addListener(ILabelProviderListener listener) {
28         // TODO Auto-generated method stub
29         
30     }
31 
32     @Override
33     public void removeListener(ILabelProviderListener listener) {
34         // TODO Auto-generated method stub
35         
36     }
37     @Override
38     public void dispose() {
39         // TODO Auto-generated method stub
40         
41     }
42     @Override
43     public boolean isLabelProperty(Object element, String property) {
44         // TODO Auto-generated method stub
45         return false;
46     }
47 }

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

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

MyActionGroup.java

  1 public class MyActionGroup extends ActionGroup {
  2     //ActionGroup这是个抽象类,但是其中并没有抽象方法.
  3     private TreeViewer treeViewer;
  4 
  5     //构造方法
  6     public MyActionGroup(TreeViewer treeViewer) {
  7         this.treeViewer = treeViewer;
  8     }
  9     
 10     /**
 11      * 生成菜单Menu,并将两个Action传入
 12      */
 13     public void fillContextMenu(IMenuManager mgr) {
 14         /*
 15          * 加入两个Action对象到菜单管理器
 16          */
 17         MenuManager menuManager = (MenuManager) mgr; // 把接口类转换成其实现类.
 18         //用MenuManager管理Action
 19         menuManager.add(new OpenAction());
 20         menuManager.add(new RefreshAction());
 21         menuManager.add(new ExpandAction());
 22         menuManager.add(new CollapseAction());
 23         menuManager.add(new AddEntryAction());
 24         menuManager.add(new RemoveEntryAction());
 25         menuManager.add(new ModifyEntryAction());
 26         /*
 27          * 把这些功能加入到右键的Menu菜单中.
 28          */
 29         Tree tree = treeViewer.getTree();
 30         Menu menu = menuManager.createContextMenu(tree);
 31         tree.setMenu(menu);
 32     }
 33     
 34     /**
 35      * 打开"菜单"对应的Action类
 36      */
 37     private class OpenAction extends Action {
 38         public OpenAction() {
 39             setText("打开");
 40         }
 41         /**
 42          * 继承自Action的方法，动作代码写此方法中
 43          */
 44         //覆盖Action中的run()方法.
 45         public void run() {
 46             ITreeEntry obj = getSelTreeEntry();//getgetSelTreeEntry()得到当前节点
 47             if (obj != null) {
 48                 //弹出一个这个节点名字的对话框.
 49                 MessageDialog.openInformation(null, null, obj.getName());
 50             }
 51         }
 52     }
 53     
 54     /**
 55      * 刷新对应的Action类.
 56      */
 57     private class RefreshAction extends Action {
 58         public RefreshAction() {
 59             setText("刷新");
 60         }
 61 
 62         //覆盖Action类中的run()方法,里面是调用的refresh()方法.
 63         public void run() {
 64             treeViewer.refresh();// 调用TreeViewer的刷新方法
 65         }
 66     }
 67 
 68     /**
 69      * 展开当前结点的Action类
 70      */
 71     private class ExpandAction extends Action {
 72         public ExpandAction() {
 73             setText("展开");
 74         }
 75         //重写run()方法
 76         public void run() {
 77             ITreeEntry obj = getSelTreeEntry();
 78             if (obj != null) {
 79                 treeViewer.expandToLevel(obj, 1); 
 80                 // 这个方法后面的数字是展开的层级数.这个地方设置成仅仅展开1个层级.
 81             }
 82         }
 83     }
 84 
 85     /**
 86      * 收缩当前结点的Action类
 87      */
 88     private class CollapseAction extends Action {
 89         public CollapseAction() {
 90             setText("收缩");
 91         }
 92         //重写run()方法
 93         public void run() {
 94             ITreeEntry obj = getSelTreeEntry();
 95             if (obj != null) {
 96                 treeViewer.collapseToLevel(obj, -1); // -1为将当前结点的所有子结点收缩
 97             }
 98         }
 99     }
100 
101     /**
102      * 给当前结点增加一个子结点的Action类
103      */
104     private class AddEntryAction extends Action {
105         public AddEntryAction() {
106             setText("增加");
107         }
108         @Override
109         public void run() {
110             ITreeEntry obj = getSelTreeEntry();
111             if (obj == null || obj instanceof People) {
112                 return;
113             }
114             InputDialog dialog = new InputDialog(null, "给当前结点增加一个子结点", "输入名称", "请输入你要增加的节点的名字", null);
115             if (dialog.open() == InputDialog.OK) {// 如果单击OK按钮
116                 String entryName = dialog.getValue(); // 得到Dialog输入值
117                 /* 根据单击结点的不同类型生成相应的子结点 */
118                 ITreeEntry newEntry = null;
119                 if (obj instanceof Country) {
120                     newEntry = new City(entryName);
121                 } else if (obj instanceof City) {
122                     newEntry = new People(entryName);
123                 }
124                 /* 在增加子结点之前将父结点展开 */
125                 if (!treeViewer.getExpandedState(obj)) {
126                     treeViewer.expandToLevel(obj, 1);
127                 }
128                 treeViewer.add(obj, newEntry);// 增加结点
129             }
130         }
131     }
132 
133     /**
134      * 删除结点的Action类
135      */
136     private class RemoveEntryAction extends Action {
137         public RemoveEntryAction() {
138             setText("删除");
139         }
140         @Override
141         public void run() {
142             ITreeEntry obj = getSelTreeEntry();
143             if (obj == null) {
144                 return;
145             }
146             treeViewer.remove(obj);
147         }
148     }
149 
150     /**
151      * 修改结点名称的Action类
152      */
153     private class ModifyEntryAction extends Action {
154         public ModifyEntryAction() {
155             setText("修改");
156         }
157         @Override
158         public void run() {
159             ITreeEntry obj = getSelTreeEntry();
160             if (obj == null) {
161                 return;
162             }
163             InputDialog dialog = new InputDialog(null, "修改结点", "输入新名称", obj.getName(), null);
164             if (dialog.open() == InputDialog.OK) {
165                 String entryName = dialog.getValue();//得到对话框中的值.
166                 obj.setName(entryName);//给这个节点设置成得到的对话框中的名字.
167                 treeViewer.refresh(obj); // 刷新结点
168             }
169         }
170     }
171     /**
172      * 这个方法是自定义的方法,这个方法的作用就是得到当前选择的节点.
173      */
174     private ITreeEntry getSelTreeEntry() {
175         IStructuredSelection selection = (IStructuredSelection) treeViewer.getSelection();
176         ITreeEntry treeEntry = (ITreeEntry) (selection.getFirstElement());
177         return treeEntry;
178     }
179 }

TreeViewer.java的实例

 1 public class TreeViewer1 {
 2     public static void main(String[] args) {
 3         TreeViewer1 window = new TreeViewer1();
 4         window.open();
 5     }
 6     
 7     //定义这个open()方法.就是创建一个典型的SWT程序的步骤
 8     public void open(){
 9         //1.Display负责管理一实现循环和控制UI线程和其他线程之间的通信
10         final Display display = new Display();
11         //2.创建一个或者多个Shell(shell是程序的主窗口)
12         final Shell shell = new Shell();
13         //3.设置shell的布局.
14         shell.setSize(200, 300);
15         //设置shell的布局为FillLayout
16         shell.setLayout(new FillLayout());
17         shell.setText("TreeViewer的第一个例子");
18         
19         
20         Composite c = new Composite(shell, SWT.NONE);
21         c.setLayout(new FillLayout());
22         TreeViewer treeViewer = new TreeViewer(c, SWT.BORDER);
23         treeViewer.setContentProvider(new TreeViewerContentProvider());
24         treeViewer.setLabelProvider(new TreeViewerLableProvider());
25         // 和TableViewer一样，数据的入口也是setInput方法
26         Object inputObj = DataFactory.createTreeData();
27         treeViewer.setInput(inputObj);
28         
29         /*
30         //调用自定义的方法创建表格
31         createTableViewer(shell);
32         //4.设定内容器
33         tableviewer.setContentProvider(new TableViewerContentProvider());
34         //5.设定标签器
35         tableviewer.setLabelProvider(new TableViewerLabelProvider());
36         //6.用setInput输入数据(把PeopleFactory产生的List集合传进来)
37         tableviewer.setInput(PeopleFactory.getPeoples());
38         */
39         
40         //7.创建Shell中的组件(这个例子中没有加入组件,只有一个空窗口)
41         shell.open();
42         //8.写一个时间转发循环
43         while(!shell.isDisposed()){//如果主窗口没有关闭,则一直循环
44             //dispose 是"处理,处置,毁掉"的意思
45             if(!display.readAndDispatch()){ 如果display不忙
46                 display.sleep();// display休眠
47             }
48         }
49     }
50 }

TreeViewer1.java的运行结果图

TreeViewer2.java

 1 public class TreeViewer2 {
 2 
 3     public static void main(String[] args) {
 4         TreeViewer2 window = new TreeViewer2();
 5         window.open();
 6     }
 7     
 8     public void open() {
 9         final Display display = new Display();
10         final Shell shell = new Shell();
11         shell.setSize(200, 300);
12 
13         shell.setLayout(new FillLayout());
14         Composite c = new Composite(shell, SWT.NONE);
15         c.setLayout(new FillLayout());
16         TreeViewer treeViewer = new TreeViewer(c, SWT.BORDER);
17         treeViewer.setContentProvider(new TreeViewerContentProvider());
18         treeViewer.setLabelProvider(new TreeViewerLableProvider());
19         Object inputObj = DataFactory.createTreeData();
20         //>>>>>>>>>>>>>相比于TreeViewer1.java增加的>>>>>>>>>>>>>>>>>>>>>>>>>
21         //生成一个ActionGroup对象
22         MyActionGroup actionGroup = new MyActionGroup(treeViewer);
23         // 调用fillContextMenu方法将按钮注入到菜单对象中
24         actionGroup.fillContextMenu(new MenuManager());
25         // --------------加入代码：END--------------------
26         treeViewer.setInput(inputObj);
27         // -----------------------------
28         shell.open();
29         while (!shell.isDisposed()) {
30             if (!display.readAndDispatch()) {
31                 display.sleep();
32             }
33         }
34     }
35 }

TreeViewer2.java的运行结果图:

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

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

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