SWT常用组件-CSDN博客

摘自《基于Eclipse的开源框架技术与实战》第13章

SWT（Standard Widget Toolkit）本身仅仅是Eclipse组织为了开发Eclipse IDE环境所编写的一组底层图形界面 API。或许是无心插柳，或许是有意为之，至今为止，SWT无论在性能上还是外观上，都超越了Sun

公司提供的AWT和Swing。

本章主要介绍如下几方面的内容：
SWT程序
SWT中使用Swing组件
基类Control
常用组件
容器组件

13.1 SWT简介

Eclipse 是一个通用工具平台。它是一个开放的、可用于任何东西的可扩展 IDE，它为工具开发人员提供了灵活性及对软件技术的控制能力。Eclipse 为开发人员提供了生产大量 GUI 驱动的工具和应用程序的基础。而这项功能的基础就是基于GUI库的SWT 和 JFace。

13.1.1 概述

SWT（Standard Widget Toolkit）是Eclipse中的窗口小部件工具箱，它是一组窗口组件的实现，并能与底层操作系统图形用户界面平台紧密集成。另外，SWT定义了所有受支持平台上的公共可移植API，并尽可能地使用本机窗口小部件在每个平台上实现该API，这允许SWT在所有平台上维护一致的编程模型，且能立即反映底层操作系统图形用户界面外观中的任何更改。

JFace用来在 SWT 库顶部提供常见的应用程序用户界面功能。JFace并不试图“隐藏”SWT 或者替换它的功能。它提供一些类和接口，用来处理SWT对动态用户界面相关联的常见任务。

SWT/JFace是Eclispe的基础，Eclipse的Workbench就是建立在SWT/JFace之上的。另外，JFace是在SWT之上开发的，它和SWT形成一个交集，其中SWT提供最原始的组件，如图13-1所示。

图13-1 SWT/JFace和Workbench的关系

JFace对SWT进行了扩展，把用户熟悉的一些组件进行了封装，在开发中用户可以尽可能地用JFace组件来开发自己的应用。JFace程序和SWT程序类似，只不过JFace把常用的功能进行了提炼，使用户不必太关心SWT的一些细节。

提示：SWT提供了一套API，它因为Eclipse而生，但它完全可以脱离Eclipse而存在。

13.1.2 基本特性

SWT是一个套库函数，它创建了Java 版的本地操作系统 GUI 控件。它依赖于本机实现，这意味着基于SWT的应用程序具有以下几个关键特性。

它们的外观、行为和执行类似于“本机”应用程序。

所提供的窗口小部件（Widget）反映了主机操作系统上提供的窗口小部件（组件和控件）。

主机GUI库的任何特殊行为都在 SWT GUI 中得到反映。

这些目标使得SWT不同于Java技术的Swing，Swing的设计目标是消除操作系统的差异。SWT库反映了主机操作系统的基本窗口小部件，JFace 库有助于向 SWT 应用程序中添加大量服务，SWT最重要的扩展之一是将应用程序的数据模型与显示及更改它的GUI隔离开来。

SWT中有如下一些基本的组件。

（1）Widget：基本的 SWT GUI 组件（类似于 Java AWT 中的 Component 和 Swing 中的 JComponent），Widget 是一个抽象类。

（2）Control：拥有操作系统的对等物的窗口小部件，Control 是一个抽象类。

（3）Composite：包含其他控件的控件（类似于 Java AWT 中的 Container 和 Swing 中的JPanel）。

（4）Item：其他控件包含的窗口小部件（该控件可能是复合控件），如列表和表。Item 是一个抽象类。

这些窗口组件（或小部件）被安排在继承层次结构中。其中Widget是底层的类，继承关系如图13-2所示。

图13-2 Widget类的继承关系

几乎所有SWT GUI都是从某些基础部分开始创建的。所有SWT窗口组件都可以在 org.eclipse.swt.widget 或 org.eclipse.swt.custom 包中找到（一些Eclipse插件还在其他包中提供了定制的窗口组件）。窗口组件包中包含一些基于操作系统控件的控件，而定制包中则包含一些超出操作系统控件集之外的控件。一些定制的软件包控件类似于窗口小部件包中的控件。为了避免命名冲突，定制控件的名称都是以“C”开始的（例如，比较 CLabel 与 Label）。

在SWT中，所有控件（除了一些高级控件，比如 shell）在创建的时候都必须有一个父控件（一个复合实例）。在创建的时候，这些控件被自动“添加”到父控件中，这与必须明确添加到父控件中的 AWT/Swing 中的控件有所不同，自动添加产生了一种“自上而下”地构造GUI的方法。这样，所有控件都可以采用一个复合父控件（或者一个子类）作为构造函数的参数。

大多数控件都有一些必须在创建时设置的标记选项，因此大多数控件还有另外一个构造函数参数，通常称为样式或风格，该参数提供了设置这些选项的标记。所有这些参数值都是整型常量，并且都是在org.eclipse.swt包的SWT类中定义的。如果不需要任何参数，则可以使用SWT.NONE值。

提示：创建一个组件通常有两个参数，第一个为父组件，第二个为组件的显示样式，例如：“Button button = new Button(shell, SWT.RADIO);”。

13.2 SWT程序

SWT是一套独立的库，用户可以在SWT的基础上很容易地建立自己的应用，本节的目的就是要在SWT上建立一个简单的“Hello world”程序，读者可以在这个简单的程序上建立自己的应用。

13.2.1 加入SWT依赖的包

SWT为用户提供了一套API，用户如果要使用SWT进行开发，必须把所需的JAR包放在Eclipse项目的ClassPath中。在此笔者采用新建一个插件项目，插件项目会自动引用SWT相关的包，步骤如下。

（1）运行Eclipse。单击“File”→“New”→“Other”菜单项，在弹出的对话框中选择 Select 对话框左边的 Plug-in Development 向导。如图13-3所示，选择 Plug-in Project。

（2）单击“Next”按钮，弹出新建对话框，输入项目名称。此处使用了“com.free. swtjface.demo”。单击“Next”按钮后弹出新建对话框页，如图13-4所示。

图13-3 新建插件对话框

图13-4 新建项目

（3）单击“Next”按钮，在接下来的对话框中单击“Finish”按钮，建立一个空的插件项目在此项目中，Eclipse中已经自动引入了此插件所需要依赖的包，其中包括SWT/JFace所用到的包如图13-5所示。

图13-5 插件依赖的包

如果用户想加入SWT/JFace相关的包，也可以手动加入下面几个包“org.eclipse.swt.win32. win32.x86_3.1.1.jar”、“org.eclipse.swt_3.1.0.jar”和“org.eclipse.jface_3.1.1.jar”到插件的类路径中。

提示：对于初学者，通过创建插件项目自动引入SWT的JAR包是一个比较好的方法，如果开发插件项目，用户也不用但心SWT的JAR包没有引入的问题。

13.2.2 “Hello world”程序

现在SWT所依赖的包已经加入到了项目的ClassPath中，SWT程序和Java的程序一样，也是通过main函数运行的，如例程13-1所示。

例程13-1 HelloWorldSwt.java

    package com.free.helloworld;
…
public class HelloWorldSwt {
public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.setText("hello world! Window");
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
}

这段程序虽然很简单，但是它反映了书写SWT程序的步骤：

（1）创建一个Display对象。Display对象是SWT和操作系统通信的桥梁。

（2）创建一个或者多个Shell对象。可以认为Shell代表了程序的窗口。

（3）在Shell内创建各种部件（widget），如按钮、下拉框和列表等。

（4）对各个部件进行初始化（外观、状态等），同时为各种部件的事件创建监听器（listener）。监听器可以监听窗口的消息，在此没有添加监听器，将会在后面的章节重点介绍监听器的注册。

（5）调用Shell对象的open()方法以显示窗体。

（6）对各种事件进行监听并处理，直到程序发出退出消息。

（7）调用Display对象的dispose()方法以结束程序。

提示：SWT程序的运行和例程13-1类似，读者如果不清楚SWT程序的运行机制，可以直接复制上面的样板代码就可以了。

13.2.3 运行SWT应用

SWT程序的运行要通过JNI调用相应的操作系统控件，运行SWT程序和运行Java应用程序有点不同，在Eclipse中用户可以选择运行SWT程序（SWT Application），步骤如下：

（1）打开Java的默认视图，在“Hello world”程序的文件上单击鼠标右键。

（2）选择“SWT Application”菜单，如图13-6所示。

图13-6 运行SWT程序

（3）单击“SWT Application”菜单运行，运行效果如图13-7所示。

图13-7 SWT“Hello world”程序

HelloWorldSwt程序只创建了一个窗口（shell），读者可以把shell当成其他组件的父窗口，创建其他组件。

13.3 使用Swing组件

SWT和Swing其实在概念上有很多相似的地方，它们之间最大的一个不同点是：Swing完全从跨平台的角度考虑，用Swing实现的组件完全是用Java编写的，没有用到和操作系统相关的组件。但SWT采用了更聪明的方式，如果操作系统有相关的组件，那么SWT只会采用JNI的方式调用相关的组件，如果操作系统不提供组件才会考虑用Java来创建。

13.3.1 添加Swing的组件

在项目开发中，如果用Swing开发了前期的工作，又不想用SWT重写这些代码，该怎么做呢？SWT提供了完美的解决方案，用户可以把用Swing编写出来的组件放在SWT的组件之上，而不需要放弃以前的代码（但可能会牺牲界面的风格和效率）。

在SWT的组件中可以添加Swing组件。SWT的组件只是作为Swing组件的一个父容器，要在SWT中加入Swing组件的步骤如下：

（1）添加SWT的组件。

（2）在SWT的组件上添加Swing的Frame。

（3）在Frame上添加其他Swing的组件。

如例程13-2展示了如何在SWT中添加Swing的Table组件。

例程13-2 SwingTableInSwt.java

  public class SwingTableInSwt {public static void main(String[] args) {
final Display display = new Display();
final Shell shell = new Shell(display);
shell.setLayout(new FillLayout());
//新建SWT组件
Composite composite = new Composite(shell, SWT.NO_BACKGROUND
| SWT.EMBEDDED);
try {
System.setProperty("sun.awt.noerasebackground", "true");
} catch (NoSuchMethodError error) {
}
//在SWT组件上新建一个Frame容器
Frame frame = SWT_AWT.new_Frame(composite);
Panel panel = new Panel(new BorderLayout()) {
public void update(java.awt.Graphics g) {

paint(g);
}
};
//在容器中添加子容器
frame.add(panel);
JRootPane root = new JRootPane();
panel.add(root);
java.awt.Container contentPane = root.getContentPane();
int nrows = 1000, ncolumns = 10;
Vector rows = new Vector();
for (int i = 0; i < nrows; i++) {
Vector row = new Vector();
for (int j = 0; j < ncolumns; j++) {
row.addElement("Item " + i + "-" + j);
}
rows.addElement(row);
}
Vector columns = new Vector();
for (int i = 0; i < ncolumns; i++) {
columns.addElement("Column " + i);
}
JTable table = new JTable(rows, columns);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.createDefaultColumnsFromModel();
JScrollPane scrollPane = new JScrollPane(table);
contentPane.setLayout(new BorderLayout());
//添加相应的组件
contentPane.add(scrollPane);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
}
}

按照添加Swing组件的步骤，创建了Composite作为安置Swing组件的窗口，JTable为一个Swing的组件，而通过“Frame frame = SWT_AWT.new_Frame(composite);”创建的frame为SWT和Swing创建了桥梁。

13.3.2 程序运行效果

在上例中，SWT组件添加了一个Swing的JTable组件，程序运行效果如图13-8所示

图13-8 SWT组件上加入Swing的组件

要把基于Swing的产品移植到Eclipse中，为了最大限度地减少工作量，通常会用到通过SWT组件集成Swing的组件，虽然显示的界面会有一些不协调，但也已大大减少重新开发的时间。

13.4 基类Control

在介绍组件之前，有必要介绍一下Control类。Control类是一个抽象类，它是所有窗口组件（即在Windows中能获得句柄的部件）的基类。

13.4.1 继承关系

Control类是为继承而设计的，所有窗口组件都继承于Control类，如图13-9所示。

图13-9 Control类的继承关系

Control的一个实例代表Windows中的一个窗口组件，其中有窗口名柄属性，但是在程序中不能够直接访问。

13.4.2 Control类的常用方法

Control类提供了窗口组件中的常用方法，所有的窗口组件都可以调用Control类的方法，常用方法如下。

1）setBounds (int x, int y, int width, int height)

解释：设定窗口组件的位置，参数（x,y）为窗口组件左上角顶点相对于父窗口的坐标，（width,height）为窗口的宽度和高度。

示例：button.setBounds(40, 50, 100, 30)。

2）setEnabled (boolean enabled)

解释：设定窗口是否可用，参数enabled为true表示窗口可用，为false表示窗口禁用。

示例：button.setEnabled(false)。

3）setVisible (boolean visible)

解释：设定窗口是否可显示，参数visible为true表示窗口可显示，为false表示窗口不可显示。

示例：button.setVisible(false)。

4）setToolTipText (String string)

解释：设定鼠标指向窗口时的提示信息，参数string为提示信息的内容。

示例：button.setToolTipText("very good")。

5）setFont (Font font)

解释：设定窗口文字的字体，参数font为字体对象。

示例：button. setFont (font)。

6）setForeground (Color color)

解释：设定窗口的前景色，参数color为颜色对象。

示例：button. setForeground (color)。

7）setBackground (Color color)

解释：设定窗口的背景色，参数color为颜色对象。

示例：button. setBackground (color)。

8）setCursor (Cursor cursor)
解释：设定窗口的光标形状，参数cursor为光标对象。

示例：button.setCursor(new Cursor(null,SWT.CURSOR_WAIT));

9）Control (Composite parent, int style)

解释：窗口组件中的构造函数一般会调用Control类的构造函数，参数parent为当前构建的窗口的父窗口，style为当前构建窗口的样式（默认可以指定为SWT.NONE）。

示例：Button button = new Button(shell, SWT.NONE)。

另外，Control类还实现了一些和窗口有关的方法，例如createWidget和createHandle等，这些方法直接和操作系统相关，有兴趣的读者可以继续研究。

提示：并不是所有的组件调用Control的方法都有用，有些方法是为某些特殊的组件而存在的。

13.5 常用组件

有些组件在大多数操作系统都存在，SWT直接通过JNI封装了这些组件。

13.5.1 按钮

Button（按钮）是SWT组件常用的一种。在组件中添加一个按钮很简单，只需要指定按钮的父组件和相应的样式即可，例如：“Button button = new Button(shell, SWT.PUSH)”语句在shell组件中添加了一个普通的按钮。

另外，添加一个按钮一般来说会指定按钮的位置（如果未指定布局信息）和按钮的显示标签，如例程13-3所示。

例程13-3 HelloWorldButton.java

    package com.free.normal;…
public class HelloWorldButton {
public HelloWorldButton() {
Display display = new Display();
Shell shell = new Shell(display);
//指定父组件和按钮样式
Button button = new Button(shell, SWT.PUSH);
//指定按钮的位置
button.setBounds(40, 50, 100, 30);
//指定按钮的显示标签
button.setText("Click Me");
shell.setSize(200, 200);
shell.open();

while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
public static void main(String[] args) {
new HelloWorldButton();
}
}

上例中展示了如何在一个窗口中添加一个按钮，程序运行效果如图13-10所示。

图13-10 按钮组件

按钮的样式有很多种，在SWT中，CheckBox（复选框）和RadioBox（单选框）都是不同样式的按钮。

如果按钮为复选框或单选框，可以通过“getSelection”方法判断按钮是否被选中。

13.5.2 标签

Lable（标签）是SWT组件常用的组件之一。在组件中添加一个标签很简单，只需要指定按钮的父组件和相应的样式即可，例如“Label label = new Label(shell, SWT.SEPARATOR | SWT.VERTICAL)”语句在shell组件中添加了一个标签。

可以为SWT组件指定复合样式，SWT将按复合样式显示组件，如标签示例，如例程13-4所示。

例程13-4 HelloWorldLabel.java

   public class HelloWorldLabel {public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.setLayout(new FillLayout());
Label label1 = new Label(shell, SWT.WRAP);
label1.setText("very good!");

new Label(shell, SWT.SEPARATOR | SWT.HORIZONTAL);
new Label(shell, SWT.SEPARATOR | SWT.VERTICAL);

Label label2 = new Label(shell, SWT.NONE);
label2.setText("gan.shu.man");

shell.setSize(200, 70);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
}
}

上例窗口中添加了4个标签，并为每个标签设置了不同的显示样式，程序运行效果如图13-11所示。

图13-11 标签组件

标签可以作为显示文本的组件，也可以作为分隔符。如果作为分隔符，标签不显示文字信息。

13.5.3 文本框

Text组件是SWT中的文本框，在组件中添加一个文本框很简单，只需要指定文本框的父组件和相应的样式即可，例如“Text t = new Text(shell, SWT.MULTI | SWT.BORDER | SWT.WRAP | SWT.V_SCROLL)”语句在shell组件中添加了一个文本框。

文本框有多种显示样式，如例程13-5所示。

例程13-5 HelloWorldText.java

   public class HelloWorldText {public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.setLayout(new GridLayout(1, false));
// 添加单行文本框
new Text(shell, SWT.BORDER);
// 添加右对齐单行文本框
new Text(shell, SWT.RIGHT | SWT.BORDER);
// 添加以密码形式显示的文本框
new Text(shell, SWT.PASSWORD | SWT.BORDER);
// 添加只读文本框
new Text(shell, SWT.READ_ONLY | SWT.BORDER).setText("Read Only");
// 添加多行显示文本框
Text t = new Text(shell, SWT.MULTI | SWT.BORDER | SWT.WRAP | SWT.V_SCROLL);
//给文本属性赋值
t.setText("very long sting test!very long sting test!very long sting 
test!very long sting test!");

t.setLayoutData(new GridData(GridData.FILL_BOTH));

shell.setSize(200,200);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
}

窗口中添加了5个不同样式的文本框，并为每个文本框设置了不同的显示样式，程序运行效果如图13-12所示

图13-12 文本框组件

不同类型的标签只要指定不同的样式即可，如上图所示，文本框有左对齐、右对齐、密码框、只读文本框和多行显示的文本框。

13.5.4 下拉框

Combo组件是SWT中的下拉列表框，用户可以通过“Combo combo = new Combo(shell, SWT.DROP_DOWN)”在shell组件上添加下拉列表框，另外，可以通过“combo.setItems (ITEMS)”设置下拉列表框的下拉列表，其中“ITEMS”是String的数组。下拉列表框有几种显示样式，代码如例程13-6所示。

例程13-6 HelloWorldCombo.java

  public class HelloWorldCombo {//下拉列表项
private static final String[] ITEMS = { "Alpha", "Bravo", "Charlie", "Delta",
"Echo", "Foxtrot", "Golf", "Hotel", "India", "Juliet", "Kilo", "Lima", "Mike",
"November", "Oscar", "Papa", "Quebec", "Romeo", "Sierra", "Tango", "Uniform",
"Victor", "Whiskey", "X-Ray", "Yankee", "Zulu"
};
public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.setLayout(new RowLayout());
//添加下拉按钮样式的下拉列表框
Combo combo = new Combo(shell, SWT.DROP_DOWN);
//设置下拉列表项
combo.setItems(ITEMS);

//添加只读样式的下拉列表框
Combo readOnly = new Combo(shell, SWT.DROP_DOWN | SWT.READ_ONLY);
//设置下拉列表项
readOnly.setItems(ITEMS);
//添加无下拉按钮样式的下拉列表框
Combo simple = new Combo(shell, SWT.SIMPLE);
//设置下拉列表项
simple.setItems(ITEMS);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
}

窗口中添加了3个不同样式的下拉列表框，并且设置了下拉列表框的显示样式，程序运行效果如图13-13所示。

图13-13 下拉列表框组件

上例中只是添加了Combo的显示信息，通常用户会希望所选择的Item项关联到一个对象，当选择了某一个Item项后，可以直接从此Item项中取得所选的对象，然后操作这些对象。用户可以通过Widget 类的“public void setData (String key, Object value)”和“public Object getData (String key)”方法实现此功能。

Combo是Widget的子类，当初始化Combo时，可以通过setData方法把Item项的字符串和相应的对象关联起来，当选择此项时再通过getData方法把当前选择项的对象取出来。Widget类中通过一个对象数组保存用户设置的对象的引用。

提示：Widget是所有窗口组件的父类，组件如果支持多项数据显示，并可以选择这些数据，都可以通过getData和setData方法获得组件关联的对象

13.5.5 列表

List组件是SWT中的列表框，用户可以通过“List single = new List(shell, SWT.BORDER | SWT.SINGLE | SWT.V_SCROLL)”在shell组件上添加列表框，还可以通过“setItems(ITEMS)”设置下拉列表框的下拉列表，其中“ITEMS”是String的数组。列表框有几种显示样式，代码如例程13-7所示。

例程13-7 HelloWorldList.java

   public class HelloWorldList {//列表项
private static final String[] ITEMS = { "Alpha", "Bravo", "Charlie", 
"Delta","Echo", "Foxtrot", "Golf", "Hotel", "India", "Juliet", "Kilo",
"Lima", "Mike", "November", "Oscar", "Papa", "Quebec", "Romeo", 
"Sierra", "Tango", "Uniform","Victor", "Whiskey", "X-Ray", "Yankee", 
"Zulu"
};
public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.setLayout(new FillLayout());
//添加只能单选的列表框
List single = new List(shell, SWT.BORDER | SWT.SINGLE | SWT.V_SCROLL);
//添加列表项
for (int i = 0, n = ITEMS.length; i < n; i++) {
single.add(ITEMS[i]);
}
//选择第5项
single.select(4);
//添加可多选的列表框
List multi = new List(shell, SWT.BORDER | SWT.MULTI | SWT.V_SCROLL);
//添加列表项
multi.setItems(ITEMS);
//选择第10项到第12项
multi.select(9, 11);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
}

上例窗口中添加了两个列表框，一个为单选列表框，一个为多选列表框，程序运行效果如图13-14所示。

图13-14 列表框组件

提示：选择列表框的多项值，可以是连续或不连续的列表项，如果选择不连续的列表项，要先按住【Shift】键再通过鼠标选择。

13.6 容器组件

容器组件能够作为其他组件的父组件，包含其他的组件。

13.6.1 面板容器Composite

Composite是SWT中常用的组件，它的作用相当于一个容器面板，用户可以创建一个面板对象，通过面板对象来添加其他的子组件。

在GUI的开发中，为了布局的方便，常常用Composite来添加子组件。在Composite上设置相应的布局，从而使局部的布局效果不一样。一般来说，面板可以设置成SWT.NONE的样式，另外还可以给Composite设置成带边框的样式。创建一个面板很简单，代码如例程13-8所示。

例程13-8 ComposizeExample.java

    public class ComposizeExample {public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.setLayout(new FillLayout());

//创建面板
Composite composite1 = new Composite(shell, SWT.BORDER);
composite1.setLayout(new RowLayout(SWT.VERTICAL));
new Button(composite1, SWT.RADIO).setText("John");
new Button(composite1, SWT.RADIO).setText("Paul");
new Button(composite1, SWT.RADIO).setText("George");
new Button(composite1, SWT.RADIO).setText("Ringo");

Composite composite2 = new Composite(shell, SWT.NONE);
composite2.setLayout(new RowLayout(SWT.VERTICAL));
new Button(composite2, SWT.CHECK).setText("Barry");
new Button(composite2, SWT.CHECK).setText("Robin");
new Button(composite2, SWT.CHECK).setText("Maurice");

shell.setSize(200, 200);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
}

以上程序创建了两个面板，一个设置成SWT.BORDER样式（带边框），另一个设置成SWT.NONE样式（未添加样式），程序运行效果如图13-15所示。

图13-15 Composite组件

Composite组件是一个面板容器，Composite组件还能够包含非容器，也能包含其他容器组件，包括Composite组件。

13.6.2 分组容器Group

在SWT中，Group组件代表分组框，用户可以通过分组框把内容上相关的子组件组合在一起，例如某一类人、某一种水果等。

用户可以通过Group建立一个特定的分组，每一个分组有一个名称，可以通过Group的setText设置分组的显示名称，代码如例程13-9所示。

例程13-9 GroupExample.java

    public class GroupExample {
public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.setLayout(new FillLayout());//添加分组框
Group group1 = new Group(shell, SWT.SHADOW_IN);
//设置分组框的显示标题
group1.setText("Who's your favorite?");
group1.setLayout(new RowLayout(SWT.VERTICAL));
new Button(group1, SWT.RADIO).setText("John");
new Button(group1, SWT.RADIO).setText("Paul");
new Button(group1, SWT.RADIO).setText("George");
new Button(group1, SWT.RADIO).setText("Ringo");

Group group2 = new Group(shell, SWT.NO_RADIO_GROUP);
group2.setText("Who's your favorite?");
group2.setLayout(new RowLayout(SWT.VERTICAL));
new Button(group2, SWT.CHECK).setText("Barry");
new Button(group2, SWT.CHECK).setText("Robin");
new Button(group2, SWT.CHECK).setText("Maurice");

shell.setSize(300, 200);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
}

以上程序创建了两个分组框，每个分组框都设定了相关显示标题，程序运行效果如图13-16所示。

图13-16 Group组件

Group组件和Composite组件的不同之处在于Group组件可以设置标题，用来表示分组的信息。

13.6.3 分页签容器TabFolder和TabItem

在很多应用程序中，由于信息量比较大，一页可能显示不下所有的信息，这就要求多页组件的支持。

在SWT中，通过TabFolder组织分页框，TabItem为每一个分页，创建一个分页框，步骤如下：

（1）在容器中创建一个TabFolder对象，例如“TabFolder tabFolder = new TabFolder(shell, SWT.BORDER);”。

（2）在TabFolder中创建一个TabItem对象，例如“TabItem tabItem = new TabItem (tabFolder, SWT.NULL);”。

（3）设置TabItem的显示标签，例如“tabItem.setText("Very good");”。

（4）设置每一分页的Control对象（即在此页的顶层组件，一般是容器），例如“tabItem.setControl(composite);”。

为了更好地掌握分页框，下面通过一个实例演示如何创建分页框，代码如例程13-10所示。

例程13-10 TabFolderExample.java

    public class TabFolderExample {
public static void main(String[] args) {
Display display = new Display();
final Shell shell = new Shell(display);
shell.setText("Tab Folder Example");
shell.setSize(450, 250);//创建分页框
final TabFolder tabFolder = new TabFolder(shell, SWT.BORDER);
for (int loopIndex = 0; loopIndex < 3; loopIndex++) {
//创建分页项
TabItem tabItem = new TabItem(tabFolder, SWT.NULL);
//设置分页项的标题
tabItem.setText("Tab " + loopIndex);
Text text = new Text(tabFolder, SWT.BORDER);
text.setText("This is page " + loopIndex);
//设置Control对象
tabItem.setControl(text);
}

TabItem tabItem = new TabItem(tabFolder, SWT.NULL);
tabItem.setText("Tab " + 3);
Composite composite = new Composite(tabFolder, SWT.BORDER);
Text text = new Text(composite, SWT.BORDER);
text.setText("This is page " + 3);
text.setBounds(10, 10, 100, 20);
//设置Control对象
tabItem.setControl(composite);


tabFolder.setSize(400, 200);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
}
}

以上程序创建了4个分页，其中第4个分页的Control对象为一个容器，程序运行效果如图13-17所示。

图13-17 TabFolder\TabItem组件

通常，每一个分页项都是一个容器组件，这样每一个分页就是一个容器，可以包含其他的组件。

13.6.4 分隔框容器SashForm

SashForm是SWT中的分隔框组件，在容器中，有时需要调整容器中元素的大小，这就要用到SashForm。在SWT中添加分隔框的步骤如下：

（1）在容器中创建SashForm对象，例如“sashForm = new SashForm(shell, SWT. HORIZONTAL);”。

（2）在SashForm对象中添加分隔项（即分隔框的子组件），可以是SashForm或Control的子类，例如“Text text1 = new Text(sashForm, SWT.CENTER);”。

（3）设置SashForm中分隔项显示比例的权重（可选），例如“sashForm.setWeights(new int[]{1, 2, 3});”，表示3个分隔项之间的显示比例为“1:2:3”。

为了更好地掌握分隔框，下面通过一个实例演示如何创建分隔框，代码如例程13-11所示。

例程13-11 SashFormExample.java

    public class SashFormExample {
Display display = new Display();
Shell shell = new Shell(display);
SashForm sashForm;
SashForm sashForm2;public SashFormExample() {
shell.setLayout(new FillLayout());
//添加分隔框
sashForm = new SashForm(shell, SWT.HORIZONTAL);
//添加分隔项
Text text1 = new Text(sashForm, SWT.CENTER);
text1.setText("Text in pane #1");
Text text2 = new Text(sashForm, SWT.CENTER);
text2.setText("Text in pane #2");

//添加子分隔框
sashForm2 = new SashForm(sashForm, SWT.VERTICAL);
final Label labelA = new Label(sashForm2, SWT.BORDER | SWT.CENTER);
labelA.setText("Label in pane A");
final Label labelB = new Label(sashForm2, SWT.BORDER |SWT.CENTER);
labelB.setText("Label in pane B");
//添加ControlListener监听器
text1.addControlListener(new ControlListener() {
public void controlMoved(ControlEvent e) {
}
public void controlResized(ControlEvent e) {
System.out.println("Resized");
}
});
//设置分隔框中组件显示比例的权重
sashForm.setWeights(new int[]{1, 2, 3});
labelA.addMouseListener(new MouseListener() {
public void mouseDoubleClick(MouseEvent e) {
if(sashForm2.getMaximizedControl() == labelA)
sashForm2.setMaximizedControl(null);
else
sashForm2.setMaximizedControl(labelA);
}
public void mouseDown(MouseEvent e) {
}
public void mouseUp(MouseEvent e) {
}
});
shell.setSize(450, 200);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
// If no more entries in event queue
display.sleep();
}
}
display.dispose();
}
public static void main(String[] args) {
new SashFormExample();
}
}

以上程序中为嵌套的分隔框组件，第一层分隔项的显示比例为“1:2:3”，程序运行效果如图13-18所示。

图13-18 SashForm组件

SashForm和标签分隔符不同，SashForm分隔的几个组件大小可以通过SashForm调整。

13.7 其他组件

SWT中还有一些常用的组件，它们在SWT开发中也是不可缺少的。

13.7.1 菜单组件

在程序中，菜单是提供信息比较好的方式，SWT中通过Menu和MenuItem实现菜单和菜单项，在程序中添加菜单的步骤如下。

（1）创建Menu对象，并指定创建的样式，例如“menuBar = new Menu(shell, SWT.BAR);”。

（2）创建MenuItem对象，并指定创建样式，例如“fileEnglishItem = new MenuItem (fileMenu, SWT.RADIO);”。

（3）设置Menu和MenuItem的关联（Menu中还可以有子Menu），例如“fileMenuHeader. setMenu(fileMenu);”。

（4）添加MenuItem的事件监听器，例如“fileEnglishItem.addSelectionListener(new RadioItemListener());”。

为了更好地掌握菜单，下面通过一个实例演示如何创建菜单，代码如例程13-12所示。

例程13-12 MenuExample.java

    public class MenuExample {Display display;
Shell shell;
Menu menuBar, fileMenu, editMenu;
MenuItem fileMenuHeader, editMenuHeader;
MenuItem fileExitItem, fileSaveItem, fileEnglishItem, fileGermanItem,
editCopyItem;
Text text;
public MenuExample() {
display = new Display();
shell = new Shell(display);
shell.setText("Menu Example");
shell.setSize(300, 200);
text = new Text(shell, SWT.BORDER);
text.setBounds(80, 50, 150, 25);
//添加主菜单项
menuBar = new Menu(shell, SWT.BAR);
//添加一级子菜单
fileMenuHeader = new MenuItem(menuBar, SWT.CASCADE);
fileMenuHeader.setText("&File");
//添加一级子菜单的菜单项
fileMenu = new Menu(shell, SWT.DROP_DOWN);
fileMenuHeader.setMenu(fileMenu);
fileSaveItem = new MenuItem(fileMenu, SWT.PUSH);
fileSaveItem.setText("&Save");
fileEnglishItem = new MenuItem(fileMenu, SWT.RADIO);
fileEnglishItem.setText("English");
fileGermanItem = new MenuItem(fileMenu, SWT.RADIO);
fileGermanItem.setText("German");
fileExitItem = new MenuItem(fileMenu, SWT.PUSH);
fileExitItem.setText("E&xit");
editMenuHeader = new MenuItem(menuBar, SWT.CASCADE);
editMenuHeader.setText("&Edit");
editMenu = new Menu(shell, SWT.DROP_DOWN);
editMenuHeader.setMenu(editMenu);
editCopyItem = new MenuItem(editMenu, SWT.PUSH);
editCopyItem.setText("&Copy");
//添加菜单项的事件监听器
fileExitItem.addSelectionListener(new MenuItemListener());
fileSaveItem.addSelectionListener(new MenuItemListener());
editCopyItem.addSelectionListener(new MenuItemListener());
fileEnglishItem.addSelectionListener(new RadioItemListener());
fileGermanItem.addSelectionListener(new RadioItemListener());
shell.setMenuBar(menuBar);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
}
class MenuItemListener extends SelectionAdapter {
public void widgetSelected(SelectionEvent event) {
text.setText("You selected " + ((MenuItem) event.widget).getText());
if (((MenuItem) event.widget).getText().equals("E&xit")) {
shell.close();
}
}
}
class RadioItemListener extends SelectionAdapter {
public void widgetSelected(SelectionEvent event) {
MenuItem item = (MenuItem) event.widget;
text.setText(item.getText() + " is on.");
}
}
public static void main(String[] args) {
MenuExample menuExample = new MenuExample();
}
}

以上程序中添加了主菜单，并在主菜单中添加了两个子菜单项，子菜单项添加了相应的事件响应机制，程序运行效果如图13-19所示。

图13-19 Menu\MenuItem组件

菜单是可以级联的，在子菜单中还能够包含其他的菜单项。

13.7.2 工具栏组件ToolBar和ToolItem

ToolBar是SWT中的工具栏组件，ToolItem是工具栏中的工具项（一般表现为按钮或分隔符，也可以是其他组件），在程序中添加工具栏的步骤如下：

（1）创建ToolBar对象，并指定创建的样式，例如“toolBar = new ToolBar(shell, SWT.FLAT | SWT.WRAP | SWT.RIGHT);”。

（2）创建ToolItem对象，并指定创建样式，例如“ToolItem itemPush = new ToolItem (toolBar, SWT.PUSH);”。

（3）设置ToolItem的图标和相关属性，例如“itemPush.setImage(icon);”。

（4）添加ToolItem的事件监听器，例如“itemPush.addListener(SWT.Selection,selection Listener);”。

为了更好地掌握工具栏组件，下面通过一个实例演示如何创建工具栏组件，代码如例程13-13所示。

例程13-13 ToolBarExample.java

   public class ToolBarExample {
Display display = new Display();Shell shell = new Shell(display);
ToolBar toolBar;
public ToolBarExample() {
//添加工具栏
toolBar = new ToolBar(shell, SWT.FLAT | SWT.WRAP | SWT.RIGHT);
//添加工具项
ToolItem itemPush = new ToolItem(toolBar, SWT.PUSH);
itemPush.setText("PUSH item");
//设置工具项的显示图标
Image icon = new Image(shell.getDisplay(), "icons/new.gif");
itemPush.setImage(icon);
ToolItem itemCheck = new ToolItem(toolBar, SWT.CHECK);
itemCheck.setText("CHECK item");
ToolItem itemRadio1 = new ToolItem(toolBar, SWT.RADIO);
itemRadio1.setText("RADIO item 1");
ToolItem itemRadio2 = new ToolItem(toolBar, SWT.RADIO);
itemRadio2.setText("RADIO item 2");
ToolItem itemSeparator = new ToolItem(toolBar, SWT.SEPARATOR);
final ToolItem itemDropDown = new ToolItem(toolBar, SWT.DROP_DOWN);
itemDropDown.setText("DROP_DOWN item");
itemDropDown.setToolTipText("Click here to see a drop down menu ...");
final Menu menu = new Menu(shell, SWT.POP_UP);
new MenuItem(menu, SWT.PUSH).setText("Menu item 1");
new MenuItem(menu, SWT.PUSH).setText("Menu item 2");
new MenuItem(menu, SWT.SEPARATOR);
new MenuItem(menu, SWT.PUSH).setText("Menu item 3");
//设置工具项的事件监听器
itemDropDown.addListener(SWT.Selection, new Listener() {
public void handleEvent(Event event) {
if (event.detail == SWT.ARROW) {
Rectangle bounds = itemDropDown.getBounds();
Point point = toolBar.toDisplay(bounds.x, bounds.y
+ bounds.height);
//设置菜单的显示位置
menu.setLocation(point);
menu.setVisible(true);
}
}
});
//设置工具项的事件监听器
Listener selectionListener = new Listener() {
public void handleEvent(Event event) {
ToolItem item = (ToolItem) event.widget;
System.out.println(item.getText() + " is selected");
if ((item.getStyle() & SWT.RADIO) != 0
|| (item.getStyle() & SWT.CHECK) != 0)
System.out.println("Selection status: "
+ item.getSelection());
}
};
itemPush.addListener(SWT.Selection, selectionListener);
itemCheck.addListener(SWT.Selection, selectionListener);
itemRadio1.addListener(SWT.Selection, selectionListener);
itemRadio2.addListener(SWT.Selection, selectionListener);
itemDropDown.addListener(SWT.Selection, selectionListener);
toolBar.pack();
shell.addListener(SWT.Resize, new Listener() {
public void handleEvent(Event event) {
Rectangle clientArea = shell.getClientArea();
toolBar.setSize(toolBar.computeSize(clientArea.width,
SWT.DEFAULT));
}
});
shell.setSize(400, 100);
shell.open();

while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
public static void main(String[] args) {
new ToolBarExample();
}
}

程序添加了工具栏，并在工具栏中添加了相应的工具项，工具项中添加了相应的事件响应机制，程序运行效果如图13-20所示。

图13-20 工具栏组件

本示例显示了工具栏和菜单栏的配合使用，菜单动态设定显示的位置。

13.7.3 工具栏组件CoolBar和CoolItem

CoolBar是另外一种形式的工具栏，它能够调整CoolItem的位置，每一个CoolItem可以设定相关的组件（也可以是另一个工具栏），创建CoolBar的步骤如下：

（1）创建CoolBar对象，并指定创建的样式，例如“CoolBar composite = new CoolBar (parent, SWT.NONE);”。

（2）创建CoolItem对象，并指定创建样式，例如“CoolItem item = new CoolItem(composite, SWT.NONE);”。

（3）设置CoolItem的Control对象，例如“item.setControl(tb);”。

CoolBar相当于一个面板容器，CoolItem是容器中的每一项，CoolItem能设置相应的组件作为此项的子容器（也可以是其他组件）。为了更好地掌握CoolBar组件，下面通过一个实例演示如何创建CoolBar组件，代码如例程13-14所示。

例程13-14 CoolBarExample.java

   public class CoolBarExample extends ApplicationWindow {
public CoolBarExample() {
super(null);
}protected Control createContents(Composite parent) {
getShell().setText("CoolBar Test");
String asCoolItemSection[] = { "File", "Formatting", "Search" };
//添加CoolBar
CoolBar composite = new CoolBar(parent, SWT.NONE);
for (int idxCoolItem = 0; idxCoolItem < 3; ++idxCoolItem) {
CoolItem item = new CoolItem(composite, SWT.NONE);
//添加子组件
ToolBar tb = new ToolBar(composite, SWT.FLAT);
for (int idxItem = 0; idxItem < 3; ++idxItem) {
ToolItem ti = new ToolItem(tb, SWT.NONE);
ti.setText(asCoolItemSection[idxCoolItem] + " Item #"
+ idxItem);
}
Point p = tb.computeSize(SWT.DEFAULT, SWT.DEFAULT);
tb.setSize(p);
Point p2 = item.computeSize(p.x, p.y);

//设置为一个CoolItem的控制类
item.setControl(tb);
item.setSize(p2);
}
return composite;
}
public static void main(String[] args) {
CoolBarExample app = new CoolBarExample();
app.setBlockOnOpen(true);
app.open();
Display.getCurrent().dispose();
}
}

以上代码演示了如何创建CoolBar。CoolBar中每一个CoolItem可以根据用户的需要调整位置，程序运行效果如图13-21所示。

图13-21 CoolBar组件

CoolBar和ToolBar的展现样式不一样，CoolBar可以动态调整工具栏的位置。

13.7.4 滚动组件Slider

为了方便用户输入数据，SWT中提供了Slider组件，用户可通过Slider设置数据的增量值，用来控制其他组件，也可以作为滚动条控制其他组件中的数据显示。添加Slider组件的步骤如下：

（1）创建Slider对象，并指定创建的样式，例如“Slider slide = new Slider(shell, SWT.HORIZONTAL);”。

（2）设置Slider的最大值和最小值，例如“slide.setMaximum(100);”。

（3）设置Slider增量的增加或递减值，例如“slide.setIncrement(1);”。

（4）添加Slider的事件监听器，例如“slide.addSelectionListener(selectionListener);”。

为了更好地掌握Slider组件，下面通过一个实例演示如何创建Slider组件，代码如例程13-15所示。

例程13-15 SliderExample.java

   public class SliderExample {Display dispaly;
Shell shell;
SliderExample() {
dispaly = new Display();
shell = new Shell(dispaly);
shell.setSize(300, 250);
shell.setText("A Slider Example");
//添加Slider对象
final Slider slide = new Slider(shell, SWT.V_SCROLL);
//设置Slider的位置和大小
slide.setBounds(170, 25, 25, 20);
//设置Slider的最小值
slide.setMinimum(0);
//设置Slider的最大值 
slide.setMaximum(100);
//设置Slider单击左右箭头的增加或递减值
slide.setIncrement(1);
final Text t = new Text(shell, SWT.BORDER);
t.setBounds(115, 25, 55, 20);
t.setText("0");
t.setFocus();
//添加Slider的事件监听器
slide.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
t.setText(new Integer(slide.getSelection()).toString());
}
});
shell.open();
while (!shell.isDisposed()) {
if (!dispaly.readAndDispatch())
dispaly.sleep();
}
dispaly.dispose();
}
public static void main(String[] args) {
new SliderExample();
}
}

以上代码添加了一个Text组件和一个Slider组件。Slider组件设置了增量值为1，另外Slider组件添加了选择事件，当选择了Slider组件后，Slider将为Text组件赋值。程序运行效果如图13-22所示。

图13-22 Slider组件

Slider组件要配合其他的组件使用，辅助其他的组件完成功能。

13.7.5 刻度组件Scale

Scale和Slider类似，在SWT中都表示一种尺度，但两者的表现形式不一样，Scale更像一个刻度，而Slider则是提供一个滚动条。添加Scale组件的步骤如下：

（1）创建Scale对象，并指定创建的样式，例如“Scale scale = new Scale(shell, SWT. VERTICAL);”。

（2）设置Scale的最大值和最小值，例如“scale.setMaximum(20);”。

（3）设置Scale增量的增加或递减值，例如“scale.setPageIncrement(5);”。

（4）添加Scale的事件监听器，例如“scale.addSelectionListener(selectionListener);”。

为了更好地掌握Scale组件，下面通过一个实例演示如何创建Scale组件，代码如例程13-16所示。

例程13-16 ScaleExample.java

    public class ScaleExample {
Display display = new Display();
Shell shell = new Shell(display);Scale scale;
Text value;
public ScaleExample() {
shell.setLayout(new GridLayout(1, true));
Label label = new Label(shell, SWT.NULL);
label.setText("Volume:");
//添加Scale组件
scale = new Scale(shell, SWT.VERTICAL);
scale.setBounds(0, 0, 40, 200);
//设置Scale的最大值
scale.setMaximum(20);
//设置Scale的最小值   
scale.setMinimum(0);
//设置Scale的增量值
scale.setPageIncrement(5);
//添加Scale的事件监听器
scale.addListener(SWT.Selection, new Listener() {
public void handleEvent(Event event) {
int perspectiveValue = scale.getMaximum() - scale.getSelection() + 
scale.getMinimum();
value.setText("Vol: " + perspectiveValue);
}
});
value = new Text(shell, SWT.BORDER | SWT.SINGLE);
value.setEditable(false);
scale.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_CENTER));
value.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_CENTER));
shell.pack();
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
private void init() {
}
public static void main(String[] args) {
new ScaleExample();
}
}

上例中，通过事件监听器监听当前选择的刻度，并用Text组件显示出来，程序运行效果如图13-23所示。

图13-23 Scale组件

Scale组件能够精确地显示刻度，用户可以设制好刻度的范围，这是非常有用的。

13.7.6 进度条组件ProgressBar

ProgressBar是SWT中的进度条组件。进度条提供了比较长时间操作的进度信息。添加ProgressBar组件的步骤如下：

（1）创建ProgressBar对象，并指定创建的样式，例如“ProgressBar pb1 = new ProgressBar (shell, SWT.HORIZONTAL | SWT.SMOOTH);”。

（2）设置ProgressBar的最大值和最小值，例如“pb1.setMaximum(30);”。

（3）在长时间的任务中设置当前进度条的进度，例如“progressBar.setSelection (progress Bar.getSelection() + 1);”。

进度条能反映当前的工作进度，为了配合处理长时间的任务，进度条经常配合线程使用，以免产生阻塞影响界面的操作。为了更好地掌握ProgressBar组件，下面通过一个实例演示如何创建ProgressBar组件，代码如例程13-17所示。

例程13-17 ProgressBarExample.java

    public class ProgressBarExample {
public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
shell.setLayout(new GridLayout());
//添加平滑的进度条
ProgressBar pb1 = new ProgressBar(shell, SWT.HORIZONTAL | SWT.SMOOTH);
pb1.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
//设置进度条的最小值
pb1.setMinimum(0);
//设置进度条的最大值
pb1.setMaximum(30);
//添加自动递增的进度条
ProgressBar pb2 = new ProgressBar(shell, SWT.HORIZONTAL | 
SWT.INDETERMINATE);
pb2.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
//添加线程，在线程中处理长时间的任务，并最终反映在平滑进度条上
new LongRunningOperation(display, pb1).start();
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
}
}
class LongRunningOperation extends Thread {
private Display display;
private ProgressBar progressBar;public LongRunningOperation(Display display, ProgressBar progressBar) {
this.display = display;
this.progressBar = progressBar;
}
public void run() {
//模仿长时间的任务
for (int i = 0; i < 30; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {

}
display.asyncExec(new Runnable() {
public void run() {
if (progressBar.isDisposed()) return;
//进度条递增
progressBar.setSelection(progressBar.getSelection() + 1);
}
});
}
}
}

以上代码添加了两个进度条，一个进度条为自动显示增加进度的信息（SWT.INDETERMINAT样式），另外一个进度条通过线程处理长时间的任务，并设定进度条的信息。程序运行效果如图13-24所示。