SWT JFace 常用组件

1按钮组件（Button）

  （1）Button组件常用样式

    SWT.PUSH按钮

    SWT.CHECK多选按钮

    SWT.RADIO单选按钮

    SWT.ARROW箭头按钮

    SWT.NONE默认按钮

    SWT.CENTER文字居中与SWT.NONE

    SWT.LEFT左对齐

    SWT.RIGHT右对齐

    SWT.BORDER深陷型按钮

    SWT.FLAT平面型按钮

    一个Button可以指定多个样式，只要将指定的各个样式用符号“|”连接起来即可

    Button bt=new Button(shell,SWT.CHECK|SWT.BORDER|SWT.LEFT);

    多选、深陷、左对齐

  （2）Button组件的常用方法

    setText(String string),设置组件的标签文字

    setBounds(int x,int y,int width,int height);//设置组件的坐标位置和大小

    setEnabled(Boolean enabled);设置组件是否可用，默认为true

    setFont(Font font);设置文字的字体

    setForeground(Color color);设置前景色

    setBackground(Color color);设置背景色

    setImage(Image image);设置显示用的图片

    setSelection(Boolean selected);设置是否选中,默认为false

    setToolTipText(String string);设置鼠标停留在组件上是显示的提示信息

 

2标签组件（Label）

  （1）Label常见式样

    SWT.CENTER  居中

    SWT.RIGHT  右对齐

    SWT.LEFT  左对齐

    SWT.NONE  默认样式

    SWT.WRAP  自动换行

    SWT.BORDER  深陷型

    SWT.SEPARATOR  分栏符，默认为竖线分栏符

    HORIZONTAL  横线分栏符

 

3文本框组件（Text）

  （1）Text常见式样

    SWT.NONE  默认式样

    SWT.CENTER

    SWT.RIGHT

    SWT.LEFT

    SWT.MULTI  可以输入多行，需回车换行

    SWT.WRAP  可以输入多行，自动换行

    SWT.PASSWORD  密码型，输入字符显示成“*”

    SWT.BORDER    深陷型

    SWT.V_SCROLL  垂直滚动条

    SWT.H_SCROLL  水平滚动条

 

4下拉框组件（Combo）

  （1）Combo常见样式

    SWT.NONE    默认

    SWT.READ_ONLY  只读

    SWT.SIMPLE    无需单击下拉框，列表会一直显示

 

  （2）Combo下拉框常用方法

    add(String string)  在Combo上添加一项

    add(String string,int index)  在Combo的第index（从0开始）项后插入一项

    deselectAll()    使Combo组件中的当前选项为空

    removeAll()      将Combo中的所有选项清空

    setItems(String[] items)  将数组中的各项依次加入到Combo中

    select(int index)  将Combo的第index+1项设置为当前选择项

 

5列表框组件（List）

  （1）List常见样式

    SWT.NONE    默认样式

    SWT.V_SCROLL  带垂直滚动条

    SWT.MULTI    允许复选

    SWT.SINGLE    允许单选

 

  （2）常用方法

    List和Combo组件的方法是一样的，但由于List可选择多项，而Combo只能选择一项

  ，所以List没有getText()方法，List的取值使用getSelection（），返回一个String

  数组。

 

6菜单（Menu，MenuItem）

    菜单（Menu、MenuItem）是常用的SWT组件，Menu是一个菜单栏，同时也是一个容器

  ，可以容纳菜单项（MenuItem）

  （1）Menu样式

    SWT.BAR    菜单栏，用于主菜单

    SWT.DROP_DOWN  下拉菜单，用于子菜单

    SWT.POP_UP    鼠标右键弹出菜单

  （2）MenuItem式样

    SWT.CASCADE    有子菜单的菜单项

    SWT.CHECK    选中后前面显示一个小勾

    SWT.PUSH    普通型菜单

    SWT.RADIO    选中后前面显示一个圆点

    SWT.SEPARATOR  分隔符

  （3）建立菜单一般步骤

    ①首先建立一个菜单栏，需要用到SWT.BAR属性

      Menu mainMunu=new Menu(shell,SWT.BAR);

    ②在窗体中指定需要显示的菜单栏

      shell.setMenuBar(mainMenu);

    ③创建顶级菜单项，需要使用SWT.CASCADE属性

      MenuItem fileItem=new MenuItem(mainMenu,SWT.CASCADE);

      fileItem.setText("file&F");

    ④创建与顶级菜单项相关的下拉式菜单

      Menu fileMenu=new Menu(shell,SWT.DROP_DOWN);

    ⑤将顶级菜单项与下拉菜单关联

      fileItem.setMenu(fileMenu);

    二级菜单的建立只需要重复③~⑤即可

 

容器类

1面板（Composite）

  （1）Composite常用方法

    getLayout()  获得布局管理器

    getLayoutData()    得到布局数据

    getParent()    得到容纳该容器的父容器

    getShell()    得到容纳该容器的Shell

    layout()    将容器上的组件重新布局，相当于刷新

 

 

2分组框（Group）

    Group是Composite的子类，所以两者用法基本相同。主要区别是Group显示有一个方框，且方

  框线上还可以显示说明文字

 

3选项卡（TabFolder、TabItem）

    选项卡包括一个选项卡（TabFolder类）和一个选项页（TabItem类），TabFolder是容器，可

  以容纳其它容器和组件，但TabItem不是容器，可以把它看成是一个选项标签，TabFolder通过

  TabItem来对其中的组件进行控制。每一个TabItem用setControl（）来控制一个界面组件。

 

布局管理器

1充满式布局（FillLayout）

    FillLayout是最简单的布局管理器，它把组件按一行或一列充满整个容器，并强制组件的大小一致。

  一般组件高度和最高组件相同，宽度与最宽组件相同。FillLayout不能折行，不能设置边界距离和间距。

  如果容器中只有一个组件，则该组件会充满整个容器。

  （1）构造方法

    FillLayout()  创建按一行充满容器的对象。

    FillLayout(int type)  创建按指定类型充满容器的对象，type有：SWT.HORIZONTAL（行）

      SWT.VERTICAL（列）

  （2）常用属性

    int type 指定组件充满容器的类型

      FillLayout.type=SWT.VERTICAL 或 SWT.HORIZONTAL;

 

2行式布局（RowLayout）

    RowLayout可以是组件折行显示，可以设置边界距离和间距。另外，还可以对每个组件通过setLayoutData()

  方法设置RowData对象。RowData用来设置组件大小。

  （1）构造方法

    RowLayout()    创建按行放置组件的对象

    RowLayout(int type)  创建按指定类型放置组件的对象。type：SWT.HORIZONTAL  SWT.VERTICAL

  （2）常用属性

    int marginWidth    组件距容器边缘的宽度（像素），默认为0

    int marginHeight  组件距容器边缘的高度（像素），默认为0

    int marginTop    组件距容器上边缘的距离（像素），默认为3

    int marginBottom  组件距容器下边缘的距离（像素），默认为3

    int spacing      组件之间的距离，默认值为3

    boolean justify    如果该属性为true，则组件间的距离随容器的拉伸而变大，默认值为false

    boolean wrap    如果该属性为true，当空间不足时会自动折行，默认为true

    boolean pack    如果该属性为true，组件大小为设定值；如果为false，则强制组件大小相同

              默认为true

    int tyep      SWT.HORIZONTAL（行）  SWT.VERTICAL（列）

  （2）RowData类

    RowData称为RowLayout的布局数据类，可用于改变容器中组件外观形状，其构造方法为

      RowData（int width，int height）

 

3网格式布局（GridLayout）

    GridLayout是实用而且功能强大的标准布局，也是较为复杂的一种布局。这种布局把容器分成网格

  ，把组件放置在网格中。GridLayout有很多可配置属性，和RowLayout一样，也有专用的布局数据类

  GridData.GridLayout的构造方法无参数，但可以通过GridData和设置GridLayout属性来设置组建的排列、

  形状、和位置。

  （1）GridLayout属性

    int numColumn    设置容器的列数，组件从左到右按列放置，当组件数大于列数时，下一个组件

              将自动添加到新的一行

    boolean makeColumnsEqualWidth  强制使列都具有相同的宽度，默认为false

    int marginWidth    设置组件与容器边缘的水平距离，默认值为5

    int marginHeight  设置组件与容器边缘的垂直高度，默认值为5

    int horizontalSpacing  设置列与列之间的间距，默认为5

    int verticalSpacing    设置行与行之间的间隔，默认为5

 

  （2）布局数据类（GridData类）

    GridData是GridLayout专用的布局数据类，用GridData可以构建很多复杂的布局方式。

    ①构造方法

      GridData()  创建一个属性值为默认值的对象

      GridData（int type）

    ②GridData常用类型

      GridData.FILL  通常与对象属性horizontalAlignment和verticalAlignment配合使用，充满对象

              属性指定空间。

      GridData.FILL_HORIZONTAL    水平充满，

      GridData.FILL_VERTICAL      垂直充满

      GridData.FILL_BOTH        双向充满

      GridData.HORIZONTAL_ALIGN_BEGINNING    水平靠在对齐

      GridData.HORIZONTAL_ALIGN_END      水平靠右对齐

      GridData.HORIZONTAL_ALIGN_CENTER    水平居中对齐

    ③GridData常有对象属性如下：

      int horizontalSpan  设置组件占用的列数，默认为1

      int verticalSpan  设置组件占用的行数，默认为1

      horizontalAlignment  设置组件对齐方式为水平方向

      verticalAlignment  设置组件对齐方式为垂直方向

      grabExcessHorizontalSpace  抢占额外水平空间

      grabExcessVerticalSpace    抢占额外垂直空间

        horizontalAlignment和verticalAlignment可以取以下值：

      GEGINNING  开始（水平对齐时居左，垂直对齐时居上）

      CENTER    居中，默认

      END      结束（水平对齐时居右，垂直对齐时居下）

      FILL    充满

 

4表格式布局（FormLayout）

    FormLayout是一种非常灵活、精确的布局方式，FormData使其专用的布局数据类。

  此外，还增加了一个FormAttachment类。FormAttachment定义了组件的四边与父容器

  （Shell、Composite）的边距，为保证组件在父容器中的相对位置不变，FormAttachment

  类用不同的构造方法来实现组件的定位，用FormData和FormAttachment配合，可以创建复杂

  的界面，而且当主窗体大小改变时，组件的相对位置能保持相对不变。

  （1）FormLayout构造函数

    FormLayout（）;

  （2）FormLayout的属性

    int marginWidth    //设置组件与容器边缘的水平距离，默认值为0

    int marginHeihgt  //设置组件与容器边缘的垂直距离，默认为0

  （3）FormData类

    ①FormData的构造方法

      FormData（）

      FormData（int width，int height）设置组件的宽度和高度

    ②FormData的属性

      width  设置组件的宽度

      height  设置组件的高度

      top 和 FormAttachment配合设置组件底部和父容器底部的边距

      left 和 FormAttachment配合设置组件右边和父容器右边的边框

          如果FormData中的width和height设置的宽度和高度与FormAttachment设置的约束

      发生冲突，则按照FormAttachment设置，width和height的设定值就不起作用了。

  （3）FormAttachment类

      Attachment的含义是附着、粘贴。FormAttachment类就是用来指定组件在父容器中粘贴的

    位置。FormAttachment计算组件粘贴位置和组件大小的方法是依据下面的表达式：

      y=ax+b

    ①FormatAttachment构造方法

      FormatAttachment()组件紧贴父容器的左边缘和上边缘，如果父容器设置了FormLayout属

    性marginWidth、marginHeight，则距父容器的上边缘和左边缘为其值。

      FormatAttachment(Control control)以指定组件control为参照物

      FormatAttachment(Control control,int offset)以指定组件control为参照物，相对指定

                            组件偏移量为offset

      FormatAttachment(Control control,int offset,int alignment)对齐方式为alignment

        SWT.TOP  SWT.BOTTOM  SWT.LEFT  SWT.RIGHT  SWT.CENTER

      FormAttachment(int m,int n,int offset)以组件相对与父容器宽度或高度的百分比(即斜率a)来给

        组件定位，m为a的分子，n为分母，offset为偏移量

      FormAttachment(int m,int offer)  n默认为100

      FormAttachment(int m) n默认为100，offset默认为0

 

 

SWT的常用事件

    所有事件、监听器和适配器都放在包org.eclipse.swt.events中。

  （1）SWT中常用事件如下：

    ①addMouseListener鼠标监听器

      mouseDown()

      mouseUP()

      mouseDoubleClick()

    ②addKeyListener按键监听器

      keyPressed()

      keyReleased()

    ③addSelectionListener组件选择监听器

      widgetSelected()

    ④addFocusListener焦点监听器

      focusGained()   得到焦点

      focusLost()    失去焦点        

 容器类

通常，组件构建在容器类中，容器构建在主窗体（shell）中，主窗体也是容器，也就是说，容器不仅可以容纳组件，也可以容纳容器。有了容器，就可以通过 它来对组件进行集体操作。例如，容器在界面上移动时，其上的组件也会随着容器移动，容器隐藏，其组件也会被隐藏，容器销毁（dispose），其组件也会 被销毁。

1 面板
面板（Composite类）是最常用的容器。主窗体（shell）是面板（Composite）的子类。面板的构造方法格式如下：
Composite(Composite parent,int style)
第 一个参数表示该容器创建在哪个容器上，第二个参数表示容器的式样。Composite的式样一般都是用SWT.NONE，这时Composite在界面是 不显示出来的，只是发挥着容器的作用。如果要让容器形成凹陷效果，可以用SWT.BORDER式样。例如，在主窗体中创建一个容器：
Composite composite=new Composite(shell,SWT.NONE);
Composite的常用方法：
getLayout()：得到布局管理器。
getLayoutData()：得到布局数据。
getParent()：得到容纳该容器的父容器。
getShell()：得到容纳该容器的Shell。
layout()：将容器上的组件重新布局，相当于刷新。


package edu.ch4;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
public class Sample4_8 {
public static void main(String[] args) {
Display display=new Display();//创建一个display对象。
final Shell shell=new Shell(display);//shell是程序的主窗体
shell.setText("容器示例");
Composite composite1=new Composite(shell,SWT.NONE);
composite1.setBounds(10,10,100,50);
Composite composite2=new Composite(shell,SWT.BORDER);
composite2.setBounds(120,10,100,50);
Label lb1=new Label(composite1,SWT.NONE);
lb1.setText("面板1");
lb1.pack();
Label lb2=new Label(composite2,SWT.NONE);
lb2.setText("面板2");
lb2.pack();
shell.pack();
shell.open();
while(!shell.isDisposed()){ //如果主窗体没有关闭则一直循环
if(!display.readAndDispatch()){ //如果display不忙
display.sleep(); //休眠
}
}
display.dispose(); //销毁display
}
}



2 分组框
分组框（Group类）是面板（Composite类）的子类，所以两者用法基本相同。主要区别是Group显示有一个方框，且方框线上还可以显示说明文字。

package edu.ch4;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.*;
public class Sample4_9 {
public static void main(String[] args) {
Display display=new Display();//创建一个display对象。
final Shell shell=new Shell(display);//shell是程序的主窗体
shell.setText("分组框示例");
Group group1=new Group(shell,SWT.NONE); //创建分组框
group1.setText("录入信息"); //设置分组框说明信息
group1.setBounds(10,20,200,100);
Label lb1=new Label(group1,SWT.NONE); //在分组框中加入组件
lb1.setText("姓名：");
lb1.setBounds(10,20,70,20);
Text text1=new Text(group1,SWT.BORDER);
text1.setBounds(90,20,70,20);
Label lb2=new Label(group1,SWT.NONE);
lb2.setText("地址：");
lb2.setBounds(10,50,70,20);
Text text2=new Text(group1,SWT.BORDER);
text2.setBounds(90,50,70,20);
shell.pack();
shell.open();
while(!shell.isDisposed()){ //如果主窗体没有关闭则一直循环
if(!display.readAndDispatch()){ //如果display不忙
display.sleep(); //休眠
}
}
display.dispose(); //销毁display
}
}


3 选项卡
选项卡包括一个选项卡（TabFolder类）和一个选项页（TabItem类），TabFolder是容器，可以容纳其他容器和组件，但TabItem 不是容器，可以把它看成是一个选项标签，TabFolder通过TabItem来对其中的组件进行控制。每一个TabItem用setControl() 方法来控制一个界面组件。

package edu.ch4;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.*;
public class Sample4_10 {
public static void main(String[] args) {
Display display=new Display();//创建一个display对象。
final Shell shell=new Shell(display);//shell是程序的主窗体
shell.setText("选项卡示例");
TabFolder tabFolder=new TabFolder(shell,SWT.NONE);//声明一个选项卡容器
tabFolder.setBounds(5,5,180,130); //设置选项卡的位置和大小
TabItem tabItem1=new TabItem(tabFolder,SWT.NONE);//声明第1个选项页
tabItem1.setText("选项1"); //设置选项页的标题
{
//创建第1个分组框，建立在tabFolder上
Group group1=new Group(tabFolder,SWT.NONE);
group1.setText("录入信息"); //设置分组框说明信息
tabItem1.setControl(group1); //让tabItem1控制group1
Label lb1=new Label(group1,SWT.NONE); //注意Label建立在group1上
lb1.setText("姓名：");
lb1.setBounds(10,20,70,20);
Text text1=new Text(group1,SWT.BORDER);
text1.setBounds(90,20,70,20);
Label lb2=new Label(group1,SWT.NONE);
lb2.setText("地址：");
lb2.setBounds(10,50,70,20);
Text text2=new Text(group1,SWT.BORDER);
text2.setBounds(90,50,70,20);
}
TabItem tabItem2=new TabItem(tabFolder,SWT.NONE); //声明第2个选项页
tabItem2.setText("选项2");
{
//创建第2个分组框，建立在tabFolder上
Group group2=new Group(tabFolder,SWT.NONE);
tabItem2.setControl(group2); //让tabItem2控制group2
group2.setText("兴趣爱好");
Button bt1=new Button(group2,SWT.CHECK);
bt1.setBounds(20,20,70,20);
bt1.setText("音乐");
Button bt2=new Button(group2,SWT.CHECK);
bt2.setBounds(20,50,70,20);
bt2.setText("美术");
Button bt3=new Button(group2,SWT.CHECK);
bt3.setBounds(20,80,70,20);
bt3.setText("体育");
}
shell.pack();
shell.open();
while(!shell.isDisposed()){ //如果主窗体没有关闭则一直循环
if(!display.readAndDispatch()){ //如果display不忙
display.sleep(); //休眠
}
}
display.dispose(); //销毁display
}
}

SWT/Jface Shell 屏幕居中的三种方法

对话框居中的3种方法:

1.

int width = shell.getMonitor().getClientArea().width;
int height = shell.getMonitor().getClientArea().height;
int x = shell.getSize().x;
int y = shell.getSize().y;
if (x > width) {
    shell.getSize().x = width;
}
if (y > height) {
    shell.getSize().y = height;
}
shell.setLocation((width - x) / 2, (height - y) / 2);

2.
Rectangle bounds = Display.getDefault().getPrimaryMonitor().getBounds();
Rectangle rect = shell.getBounds();
int x = bounds.x + (bounds.width - rect.width) / 2;
int y = bounds.y + (bounds.height - rect.height) / 2;
shell.setLocation(x, y);

 

3.

int screenH = Toolkit.getDefaultToolkit().getScreenSize().height;
int screenW = Toolkit.getDefaultToolkit().getScreenSize().width;
int shellH = shell.getBounds().height;
int shellW = shell.getBounds().width;
if(shellH > screenH)
shellH = screenH;
if(shellW > screenW)
shellW = screenW;
shell.setLocation(((screenW - shellW) / 2), ((screenH - shellH) / 2));

另一篇相关资料：

1、Eclipse中swt的配置
建议配置：jdk1.4.2以及eclipse3.1
在代码中调用swt控件之前，首先建立一个项目，然后选择该项目的properties -> Java Build Path，将standard Widget ToolKit加入到Library页当中。如下图所示：
接下来可以建立第一个eclipse小程序，新建一个class，并且在该class所对应的代码中输入如下程序，其中package以及class名称根据实际情况来确定名称。
package mypakage;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.*;
/*导入需要的类库*/
public class Myfrm1 {
public Myfrm1() {
super();
}
public static void main(String[] args) {
Display display = new Display();
Shell shell = new Shell(display);
/*shell为一个窗口对象*/
Label label = new Label(shell, SWT.NONE);
label.setText("Hello, World!"); /*创建一个标签对象并且设置标题文字*/
label.pack();
shell.pack();
shell.open(); /*打开并显示窗口*/

while(!shell.isDisposed())
if(!display.readAndDispatch())
display.sleep(); /*在窗口没有销毁之前，显示对象一直处于等待状态*/

display.dispose(); /*否则，销毁对象，释放对象所占据的资源*/
label.dispose();
}
}

运行上述代码（run -> debug -> swt application）将产生如下所示的一个窗口

2、button的使用
按钮可能的类型有很多，例如：
SWT.BORDER 含有边框的按钮

SWT.CHECK 复选按钮

SWT.PUSH 普通按钮

SWT.RADIO 单选按钮

3、Text的使用
文本框的类型也有很多种选择，例如：
SWT.BORDER 含有边框

SWT.READ_ONLY 只读

下图为包含按钮以及文本框的窗口

设计上述窗口所对应的代码为：
package mypakage;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.*;
public class Myfrm1 {
public Myfrm1() {
super();
}
public static void main(String[] args) {
Display display = new Display( );
Shell shell = new Shell(display);
shell.setSize(300, 200);
shell.setLayout(new RowLayout( ));
shell.setText("Button Example");
final Button button = new Button(shell, SWT.BORDER);
button.setText("Click Me");
final Text text = new Text(shell, SWT.BORDER); 
shell.open( );

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

如果想对控件的位置以及大小进行精确的设置，可以使用setBounds(x, y, width, height)方法来取代shell.setLayout(new RowLayout( ))。例如：button.setBounds(80, 80, 90, 20);

button的监听及事件处理
对按钮单击事件处理的代码：
button.addSelectionListener(new SelectionListener( )
{
public void widgetSelected(SelectionEvent event)
{
text.setText("No worries!");
}
public void widgetDefaultSelected(SelectionEvent event)

{
text.setText("No worries!");
}
});

将以上代码加入到shell.open之前，当点击按钮时产生以下效果：

分析：由于为button按钮增加了一个监听器，按钮时刻处于被“监控”的状态，当按钮控件被选择（点击）既选择事件发生时，对文本控件进行赋值”No worries”。

根据监听事件的原理，设计如下程序，该程序能够获得鼠标的X坐标，显示在文本框中：

package mypakage;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.*;

public class Myfrm1 {
public Myfrm1() {
super();
}
public static void main(String[] args) {
Display display = new Display( );
Shell shell = new Shell(display);
shell.setSize(300, 200);
shell.setLayout(new RowLayout( ));
final Text text = new Text(shell, SWT.SHADOW_IN);

shell.addMouseMoveListener(new MouseMoveListener( )
{
public void mouseMove(MouseEvent e)
{
Integer y=new Integer(e.x); /*将x坐标转换为Integer类型的对象*/
text.setText(y.toString()); 
}
});

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

监听方式：
ControlListener 用于处理移动以及尺寸变化

FocusListener 用于处理得到焦点以及失去焦点

KeyListener 处理按键的输入

MouseListener , MouseMoveListener, MouseTrackListener 对鼠标的动作进行处理

SelectionListener 处理控件的选择行为（包括按钮的点击）

注意：监听方式与其所能够处理的事件具有一定的关联性，既监听方式决定了所能够处理事件的种类，例如：

shell.addMouseListener(new MouseListener( )
{
public void mouseMove(MouseEvent e)
{text.setText("mousemove");}
public void mouseDoubleClick(MouseEvent e)
{text.setText("mousedbclc");}
public void mouseDown(MouseEvent e)
{}
public void mouseUp(MouseEvent e)
{}
});

你会发现在鼠标移动时，text.setText("mousemove");始终不能够执行；并且mouseDown、mouseUp事件不能够省略，原因就在于MouseListener只能处理mouseDoubleClick、mouseDown、mouseUp三类事件，而且这三类事件不能够分离。

3、List控件
List控件的样式包括：
SWT.BORDER 含有边框

SWT.H_SCROLL 含有水平滚动条

SWT.V_SCROLL 含有垂直滚动条

SWT.SINGLE 允许单选

SWT.MULTI 允许复选

若要创建一个含有从11个元素的List，可以通过以下代码来实现
final List list = new List (shell, SWT.SINGLE);
for (int i=0;i<=10;i++)
list.add("item"+i);

 

以下实例能够判断List控件中所选择的选项，并且输出显示在控制台中：
package mypakage;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.*;
public class Myfrm1 {
public Myfrm1() {
super();
}
public static void main(String[] args) {
Display display = new Display ( );
Shell shell = new Shell (display);
shell.setText("List Example");
shell.setSize(300, 200);
shell.setLayout(new FillLayout(SWT.VERTICAL));
final List list = new List (shell, SWT.BORDER | SWT.MULTI | SWT.V_SCROLL); 
for (int loopIndex = 0; loopIndex < 100; loopIndex++){ 
list.add("Item " + loopIndex);
}
list.addSelectionListener(new SelectionListener( )
{
public void widgetSelected(SelectionEvent event)
{
int selections[] = list.getSelectionIndices ( );
String outText = "";
for (int loopIndex = 0; loopIndex < selections.length; 
loopIndex++) outText += selections[loopIndex] + " ";
System.out.println ("You selected: " + outText);
}
public void widgetDefaultSelected(SelectionEvent event)
{
int [] selections = list.getSelectionIndices ( );
String outText = "";
for (int loopIndex = 0; loopIndex < selections.length; loopIndex++) 
outText += selections[loopIndex] + " ";
System.out.println ("You selected: " + outText);
}
});
shell.open ( );
while (!shell.isDisposed ( )) {
if (!display.readAndDispatch ( )) display.sleep ( );
}
display.dispose ( );
}
}

效果图：

You selected: 4 5 6 7 8 9 10
分析：list.getSelectionIndices ( )方法将会获得被选择项目的集合， selections[]或者[] elections表示动态一维数组。

4、Menu控件
建立菜单的一般步骤为：
1、在建立菜单时，首先需要建立一个菜单栏，需要使用SWT.BAR属性
Menu menuBar = new Menu(shell, SWT.BAR);

2、在菜单栏的基础之上，创建下拉菜单的所对应的顶级菜单项，需要使用SWT.CASCADE属性
fileMenuHeader = new MenuItem(menuBar, SWT.CASCADE);
fileMenuHeader.setText("&File");

3、建立与顶级菜单项相关的下拉式菜单
dropMenu1 = new Menu(shell, SWT.DROP_DOWN);

4、将顶级菜单项与下拉菜单关联
MenuHeader1.setMenu(dropMenu1);

5、为下拉菜单添加子菜单项
dropitem1= new MenuItem(dropMenu1, SWT.PUSH);
dropitem1.setText("open");
…
…

6、最后，在窗口中指定需要显示的菜单栏
shell.setMenuBar(menuBar);

 

菜单的监听及事件
参照按钮的监听以及事件，设计如下程序，当点击 File子菜单下的“open”时，在文本框中显示“click open menu!”
dropitem1.addSelectionListener(new SelectionListener()
{
public void widgetSelected(SelectionEvent event)
{
text.setText("click open menu!");
}
public void widgetDefaultSelected(SelectionEvent event)
{
text.setText("click open menu!");
}
});

5、使用工具栏toobar
建立工具栏可以通过如下方式：ToolBar toolbar = new ToolBar(shell, SWT.NONE);
在工具栏的基础之上创建工具栏子按钮，并且设置子按钮的标题：

ToolItem item1 = new ToolItem(toolbar, SWT.PUSH);
item1.setText("item1");

例如：
ToolBar toolbar = new ToolBar(shell, SWT.NONE);
ToolItem item1 = new ToolItem(toolbar, SWT.PUSH);
item1.setText("item1");
ToolItem item2 = new ToolItem(toolbar, SWT.PUSH);
item2.setText("item2");

 

工具栏的监听及事件
实例：创建一个监听对象，将该监听对象应用于每一个按钮，最终来判断鼠标点击的是哪一个按钮，效果图如下。
Listener listener = new Listener( ) {
public void handleEvent(Event event) {
ToolItem item =(ToolItem)event.widget;
String string = item.getText( );
text.setText("You selected:" + string); }
};
item1.addListener(SWT.Selection, listener);
item2.addListener(SWT.Selection, listener);
item3.addListener(SWT.Selection, listener);
item4.addListener(SWT.Selection, listener);

 

6、滚动条slider的使用
滚动条分为有边框、垂直、水平三种类型，利用slider.setBounds方法可以指定滚动条所在的位置。
滚动条所能够处理事件的包括：
SWT.ARROW_DOWN 向下或向右按钮被点击

SWT.ARROW_UP 向左或向上按钮被点击

SWT.DRAG 滑块按钮被托动

SWT.END 滑块到达终点

SWT.HOME 滑块到达起点

SWT.PAGE_DOWN 下方或右侧的滚动条被点击

SWT.PAGE_UP 上方或左侧的滚动条被点击
实例：根据滑块的位置移动按钮位置
slider.addListener(SWT.Selection, new Listener( ) {

public void handleEvent(Event event) {

switch(event.detail) {

case SWT.ARROW_DOWN: button.setBounds(slider.getSelection(),0,20,10);

break;

case SWT.ARROW_UP:button.setBounds(slider.getSelection(),0,20,10);

break;

case SWT.DRAG:button.setBounds(slider.getSelection(),0,20,10);

break;

case SWT.END:button.setBounds(slider.getSelection(),0,20,10);

break;

case SWT.HOME:button.setBounds(slider.getSelection(),0,20,10);

break;

case SWT.PAGE_DOWN:button.setBounds(slider.getSelection(),0,20,10);

break;

case SWT.PAGE_UP:button.setBounds(slider.getSelection(),0,20,10);

break;

}
}

});

 

7、树形控件Tree 
树形控件使用的方法为，首先创建一个Tree类型的对象，其次在该对象的基础之上继续扩展节点，以及扩展节点的子节点。
final Tree tree = new Tree(shell, SWT.BORDER);
可以利用tree.setSize方法来改变树形控件的大小。在创建节点时，需要指明该节点所依赖的父节点的名称，如TreeItem item0 = new TreeItem(tree, 0);，那么item0将成为tree对象中的0级（顶级）节点。
如下程序将在tree对象的基础之上产生9个节点：
final Tree tree = new Tree(shell, SWT.BORDER);

tree.setSize(290, 290);

for(int loopIndex1 = 2000; loopIndex1 <= 2008; loopIndex1++) {

TreeItem item0 = new TreeItem(tree, 0);

item0.setText("Year " + loopIndex1);

}

在上述实例的基础上为每一个0级节点的基础上扩展出12个节点：
for(int loopIndex1 = 2000; loopIndex1 <= 2008; loopIndex1++) {

TreeItem item0 = new TreeItem(tree, 0);

item0.setText("Year " + loopIndex1);

for(int loopIndex2 = 1; loopIndex2 <= 12; loopIndex2++) {

TreeItem item1 = new TreeItem(item0, 0);

item1.setText("Month " + loopIndex2);
}

}

8、对话框dialog
对话框是一个依托于主窗体的子窗体，如图所示。

例如：当在主窗体中点击按钮时，弹出一个对话框dialog，当关闭对话框时按钮显示“dialog is disposed”

Display display = new Display( );

final Shell shell = new Shell(display);

shell.setSize(300, 200);

shell.setText("main");

final Button opener = new Button(shell, SWT.PUSH);

opener.setText("Click Me");

opener.setBounds(20, 20, 50, 25);

final Shell dialog = new Shell(shell, SWT.APPLICATION_MODAL |

SWT.DIALOG_TRIM);

dialog.setText("dialog");

dialog.setBounds(10,10,50,60);

dialog.addDisposeListener(new DisposeListener(){

public void widgetDisposed(DisposeEvent e){

opener.setText("dialog is disposed");

}
});

Listener openerListener = new Listener( ) {

public void handleEvent(Event event) {

dialog.open( );

}

};

opener.addListener(SWT.Selection, openerListener);

shell.open( );

while(!dialog.isDisposed( )) {

if(!display.readAndDispatch( )) display.sleep( );

}

while (!shell.isDisposed( )) {

if (!display.readAndDispatch( ))

display.sleep( );

}

display.dispose( );