BlogJava-The Spark of Thinking-文章分类-SWT/JFace

SWT/Jface开发入门指南(十一) （转）

The Spark of Thinking — Thu, 20 Jul 2006 10:16:00 GMT

JFace中的工具条和菜单

前一节中我们简单介绍了一下 Action 。其实所谓的 Action 就是一个最常用的事件，举个例子来说，对于一个按钮来说它可以有多个事件，比如按键，焦点，鼠标，等等等等吧，但是实际上在使用程序的时候，我们最关心的，就是按下去这个按钮会发生什么，这个其实就是所谓的 Action 。如果大家以前做过 swing/awt 变成的话，应该对 Action 不会陌生。

在 JFace 里面，一个 Action 可以对应多个 GUI 对象，这些对象就是所谓的 Contribution Item 。比如我们在一般程序里面很常见的“文件”菜单，下面都会有“新建”，“保存”等等。同时我们可以在工具条上放置相应的按钮，那么这些都是有相同的功能，在 JFace 里面我们可以只写一个 Action ，然后把它映射到不同的 ContributionItem 去，而不必为每个部件都写一串处理事件。

我们下面还是通过一个简单的例子来说明，在 JFace 中怎么使用菜单和工具条这两种最基本也是最有用的 Contribution Item 。

我们这个程序写得很傻，就是一个光秃秃的窗口上做了一个菜单和工具条按钮，功能也只有一个，就是每次点一下，就弹出一个输入框来问你名字是什么，然后显示一个 Hello, xxx 之类的。

首先我们还是来写一个 Action 类：

1
2 public class SayHiAction extends Action {
3     private Shell shell;
4
5     public SayHiAction(Shell shell) {
6         super();
7         this.shell = shell;
8         this.setText("Say&Hi@Ctrl+H");
9     }
10
11     @Override
12     public void run() {
13         InputDialog input = new InputDialog(shell, "Input your name",
14                 "Please input your name here:", null, null);
15         if (input.open() == Window.OK) {
16             MessageDialog.openInformation(shell, "Hello", "Hello, "
17                     + input.getValue() + "!");
18         }
19
20     }
21
22 }
23

代码段 17

这只是一个很简单的 Action 类，没有太多可说的。

然后我们创建一个 ApplicationWindow 类：

1
2 public class Hiyou extends ApplicationWindow {
3
4     private SayHiAction hiaction;
5     public Hiyou(Shell parentShell) {
6         super(parentShell);
7         hiaction=new SayHiAction(getShell());
8         addMenuBar();
9         addToolBar(SWT.FLAT | SWT.WRAP);
10     }
11
12     @Override
13     protected ToolBarManager createToolBarManager(int style) {
14         ToolBarManager toolbar=new ToolBarManager();
15         toolbar.add(hiaction);
16         return toolbar;
17     }
18
19     @Override
20     protected MenuManager createMenuManager() {
21         MenuManager menubar=new MenuManager();
22         MenuManager fileMenu=new MenuManager("&File");
23         fileMenu.add(hiaction);
24         menubar.add(fileMenu);
25         return menubar;
26     }
27
28     /**
29      * @param args
30      */
31     public static void main(String[] args) {
32         Hiyou window=new Hiyou(null);
33         window.setBlockOnOpen(true);
34         window.open();
35         Display.getCurrent().dispose();
36     }
37
38 }
39

代码段 18

大家可能已经注意到了，在这里面我们重载了 createMenuManager 和 createToolBarManager 两个方法，它们的用途就和名字一样，一个是用来创建菜单的，一个是用来创建工具条的。重载了这两个方法以后，通过在构造函数中调用 addMenuBar 和 addToolBar 让工具条和菜单显示出来。

这里值得一提的是 MenuManager 和 ToolBarManager 类，如果大家翻一下 API 文档的话会发现它们都是所谓的 contribution manager （实现了 IConntributionManager 接口），你可以通过这些 contribution manager 来实现对特定组件的管理（添加删除等等）。

具体到菜单的创建，看了我们上面的代码就很明白了，就直接调用相应 MenuManager 的 add 方法把 action 添加上就可以了。 JFace 会自动找到这个 Action 的 getText 方法设置菜单的文字。如果是有好几层菜单，那么只要在重新 new 一个 MenuManager 添加到已有的 MenuManager 里面就可以了。就象前面代码中的：

menubar.add(fileMenu);

至于工具条就更简单了，创建一个 ToolBarManager 然后直接 add 对应的 Action 就可以了。

添加图标

如果菜单只是文字还没有什么，如果你的工具条都是文字是不是会显得干巴巴的？其实只要我们为 Action 设置 ImageDescriptor 就可以了，比如你可以自己画一个图标保存到 Action 的包下面（我画了一个 hi.gif ），然后把 Action 的构造函数改写成这样：

public SayHiAction(Shell shell) {
         super ();
         this .shell = shell;
         this .setText( " Say&Hi@Ctrl+H " );
         this .setImageDescriptor(ImageDescriptor.createFromFile( this .getClass(),
                 " hi.gif " ));
    }

大家注意最后一句话，就是为 action 设置图标的。然后再运行一下就会发现菜单和工具栏都有图标了。

在这里给一个社区做个广告，大家可以登陆到在中国 eclipse 社区（ http://www.eclipseworld.org ），在那里你也可以找到很多的帮助和支持，当然，你也可以在那里找到我。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=523860

[点击此处收藏本文] 幻发表于 2005年11月06日 13:12:00

The Spark of Thinking 2006-07-20 18:16 发表评论

SWT/JFace开发入门指南（十）(转)

The Spark of Thinking — Thu, 20 Jul 2006 10:13:00 GMT

JFace中的事件模式

大家好，因为工作的事情搞了一个多月，现在终于暂时安定下来了。这一系列的文章我也会继续往下写。

在这一节中，我会向大家介绍 JFace 中的事件模式。其实我相信这篇文章的读者应该大部分都会接触 eclipse ，这样可能也会接触过 eclipse 的插件开发。就是没有接触过，大家也可能会有在 eclipse 里面新建工程的时候出于各种原因（比如好奇心）点了 plug-in project 的时候吧。其实作为一个程序员来讲，保持好奇是很重要的。如果你大概看过一个 plug-in project 的结构，虽然可能不能全部理解，但是我相信也应该对 Action 之类有一些了解。我们这一节主要就是围绕 Action 来写的。为了增加可读性，我们首先介绍几个名词，这些名词都可以从 eclipse 的文档中找到。

什么是 Action

JFace 中的一个 Action 可以简单地理解成一个命令。那么它和事件有什么关系呢？比如说我点了一个菜单，那么点击本身就是一个事件，但是这个事件的影响就是相应的命令被执行了。大家日常使用的一些软件比如 Office 都是有菜单和工具栏的，而一个菜单项和一个工具栏可能执行的是同一个命令。比如 Word 里面要新建一个文档的话可以通过 “ 文件 ” 菜单下的 “ 新建 ” 实现，也可以通过点击工具栏上相应的图标实现。这个新建地功能本身在 JFace 里面是可以使用 Action 来实现的。

在 JFace 里面， Action 可以关联到菜单，工具条，以及按钮（也就是 Button ）。当然关于如何关联，我们会在后面向大家详细介绍。

Action 在 JFace 里面的定义是一个接口 org.eclipse.jface.action.IAction 。当然实际上你写程序的时候必须自己来实现这个接口，写出自己的 Action 类来。

IAction 里面最重要的方法是 run() ，它也是事件触发以后执行的代码。其他的方法都是一些辅助性的方法，不是我们要关注的重点。为了能够将精力集中在我们所关注的事情上，通常我们不是实现 IAction 接口，而是通过继承 org.eclipse.jface.action.Action 这个抽象类来实现 Action 。下面我们通过一个例子来说明 Action 的用法。

Hello,Action!

首先我们先不管用户界面，先定义一个最简单的 Action 类。

1 public class HelloAction extends Action{
2     private Shell shell;
3
4     public HelloAction(Shell shell) {
5         super("&Hello",Action.AS_PUSH_BUTTON);
6         this.shell=shell;
7     }
8
9
10     @Override
11     public void run() {
12         MessageDialog.openInformation(shell, "Hello", "Hello,Action!");
13     }
14
15 }
16

代码段 1 5

这段代码其实应该还是很好读懂的。带参的构造函数带进来一个 Shell 实例，而 run() 方法说明了这个 Action 的功能就是显示一个对话框。第 5 行中的代码调用了父类的构造函数，其中第一个参数是 Action 对应的文本，前面的 & 符号表明了 H 是热键，而第二个参数则是一个风格参数。如果大家继续向后看的话，就会发现这个 Action 被附加在了一个按钮上面，而按钮上显示的文本就是 Hello ，如果你定义的风格不是 AS_PUSH_BUTTON 而是 AS_RADIO_BUTTON 的话就会发现按钮已经不是一个纯粹的按钮了，而是一个单选钮。相应的其他风格可以参照 Javadoc。

1
2 public class HelloJface extends ApplicationWindow {
3     public HelloJface(Shell shell) {
4         super(shell);
5     }
6       @Override
7     protected Control createContents(Composite parent) {
8           HelloAction action=new HelloAction(parent.getShell());
9           ActionContributionItem aci=new ActionContributionItem(action);
10           aci.fill(parent);
11           return parent;
12    }
13    /**
14     * @param args
15     */
16    public static void main(String[] args) {
17
18        HelloJface demo = new HelloJface(null);
19        demo.setBlockOnOpen(true);
20        demo.open();
21        Display.getCurrent().dispose();
22
23    }
24 }

代码段 16

和前面一节的代码相比，我们只是修改了 createContents 方法。首先创建了一个 HelloAction 的实例，然后又创建了一个 ActionContributionItem 的实例，最后调用了这个实例的 fill 方法将按钮添加到窗口中，这就是全部了。是不是很简单呢？程序运行出来的效果如下图：

图 1 6

可能看了这个例子，你会认为 ActionContributionItem 这个类表示的就是一个按钮了。但是实际上并不是的，它在图形界面上表示成什么样子，随着不同的 fill 调用又有不同。在下一节中，我会向大家深入介绍 Contribution Item 以及 JFace 中的菜单，工具条等的应用。这一节就到这里结束了，因为刚刚换了工作环境，有很多事情需要去做，所以写得比较短，请大家见谅：）。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=505209

The Spark of Thinking 2006-07-20 18:13 发表评论

SWT/JFace开发入门指南（九）

The Spark of Thinking — Thu, 20 Jul 2006 10:09:00 GMT

摘要: JFace 的 Hello,world ！我们仍然是从一个最简单的 Hello,world! 开始介绍 JFace ... 阅读全文

The Spark of Thinking 2006-07-20 18:09 发表评论

SWT/JFace开发入门指南（七） (转)

The Spark of Thinking — Thu, 20 Jul 2006 10:08:00 GMT

摘要: 几种特殊的部件好像因为大家的抱怨比较多，感觉这一段 csdn 的 blog 似乎又有恢复稳定的迹象了， ^_^ 。 ... 阅读全文

The Spark of Thinking 2006-07-20 18:08 发表评论

SWT/JFace开发入门指南（八）(转)

The Spark of Thinking — Thu, 20 Jul 2006 10:08:00 GMT

JFace 以及其他

关于 JFace ：一个简单的介绍

我们已经有了 swt ，我们用 swt 可以写出一个完整的程序来，那么我们为什么需要 Jface 呢？

对于这一点，本文作者（就是我了，嘿嘿）的理解是：使用 JFace 比只是单纯地使用 swt 编程更加简单，或者说：代码量更少。毕竟，你完全可以用汇编写一个用户界面，但是付出的代价似乎大了一点 :P 。

如果你在使用 swt 编程，那么 JFace 的知识并不是必需的：你完全可以不用 JFace 就可以写出任何你需要的功能。但是如果你使用 JFace ，你必需对 swt 有一些了解，因为 JFace 需要 swt 的各种部件构建用户界面。

我觉得我们可以在某种程度上这样看 JFace ：它封装了一部分 swt 的功能，所谓“封装”可以从几个方面来看：

首先，你可以使用 JFace 的某些机制来代替 swt 中的一些机制

其次， JFace 中各种功能的实现都是依赖于底层的 swt 的。

最后，你可以在使用 JFace 时候同时使用 swt 。

这篇文章的组织结构

在这篇文章以后的部分，我将会向大家介绍以下的内容：

首先，我会从一个简单的示例程序开始展示如何开始写一个 JFace 程序

之后我会向大家介绍 JFace 的事件模型（与 swt 的事件模型不同）

然后我会向大家介绍与构建 JFace 用户界面相关的一些知识。

目前来讲，因为我刚刚写到这里，这是我所能想到的一些部分，当然，可能在以后的文章中略有不同。

另外的参考资料

在这一系列文章的第一节（ http://blog.csdn.net/jayliu/archive/2005/04/29/367757.aspx ）中，我向大家介绍了一些参考资料。现在向大家再介绍一篇在 IBM developerworks 上发现的一篇很好的文章：

在 eclipse Workbench 之外使用 eclipse GUI ，这篇文章共有三部分，地址列在下面：

http://www-128.ibm.com/developerworks/cn/linux/opensource/os-ecgui1/index.html

http://www-128.ibm.com/developerworks/cn/linux/opensource/os-ecgui2/index.html

http://www-128.ibm.com/developerworks/cn/linux/opensource/os-ecgui3/index.html

环境的配置

关于如何配置编程环境，可以参照这一系列文章的第一篇（ http://blog.csdn.net/jayliu/archive/2005/04/29/367757.aspx ），在这里我不再赘述。

FeedBack

如果你有什么意见，可以直接在我的 blog( http://blog.csdn.net.jayliu ) 留言，或者给我发 email: mailto:jayliu@mail.csdn.net

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=387461

The Spark of Thinking 2006-07-20 18:08 发表评论

SWT/JFace开发入门指南（五） (转)

The Spark of Thinking — Thu, 20 Jul 2006 10:07:00 GMT

使用 Visual Editor 加速你的开发

在 eclipse 中，你可以使用 Visual Editor 来进行拖放式的图形界面设计。实际上我觉得在这一方面大家应该可以很容易上手。

如果你安装了 VE 的话，在新建一个 swt 工程的时候你就可以省好多力气了：你不需要找那些名字 n 长的 jar ，然后一个一个导入工程的 build path 里面，而是仅仅需要添加一个 User Library ，就像下面图示一样：

图 7

你可以新建一个 Visual Class 。

图8

之后就可以使用 VE 进行可视化的编辑了：

图 9

关于 VE 的具体应用，我在这里不作具体介绍(说实话，我觉得用起来还是比较简单的），如果你觉得实在有必要看一篇详细的指南的话，可以参照这篇文章： Extending The Visual Editor
Tutorial: Enabling support for a custom widget

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=376043

The Spark of Thinking 2006-07-20 18:07 发表评论

SWT/JFace开发入门指南（六） (转)

The Spark of Thinking — Thu, 20 Jul 2006 10:07:00 GMT

使用 Layout 管理 UI 布局

我们在前面在一些例子中已经使用过 Layout 了。那么 Layout 到底是做什么的呢？

我们知道，在设计用户界面时候，我们可以采用的一种办法是手动的为每个部件设置合适当大小和位置。但是这样的话，如果你所要显示的部件比较多，编程量就会非常大，特别是考虑到窗体大小变化时候各种部件的重绘。而实际上，我们可以利用一些通用的规则或者说算法来安排这些部件的排列。比如下图所示的这个窗体：

图 10

很显然，对于这些规则化的部件排列，应该有一些更简单的办法，而不是在代码的各个部分写 xxx.setBounds 之类。 swt 给我们提供了这样的办法，就是使用 Layout 。

你可以把一个 Layout 看成是安排部件位置和大小的一个规则，在应用了 Layout 的 Composite （我们在这里第一次提到了 Composite ， Composite 就是一个能够包含其他控件的容器，比如 Shell 就是一个 Composite ，我们会在后面的部分详细介绍 Composite ）中，所有的子控件都会按照这个规则来进行排列。

在目前（写这篇文章的时候 eclipse 最新版本是 3.1M7 ）， org.eclipse.swt.layout 包中包含四种已经定义好的 Layout ，它们分别是： FillLayout ， FormLayou ， GridLayout 和 RowLayout 。我在这里不再一一作介绍，而是推荐大家看一下这篇文章《 Understanding Layouts in SWT 》。相信如果你有兴趣看完它的话，就会对 Layout 有比较深的了解。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=376421

The Spark of Thinking 2006-07-20 18:07 发表评论

SWT/JFace开发入门指南（四）(转)

The Spark of Thinking — Thu, 20 Jul 2006 09:59:00 GMT

摘要: 让你的 swt 程序动起来在向使用者提供最差的用户体验方面，中国的 IT 企业始终走在时代的最前端。之所以有这样的感慨其... 阅读全文

The Spark of Thinking 2006-07-20 17:59 发表评论

SWT/JFace开发入门指南（三）(转)

The Spark of Thinking — Thu, 20 Jul 2006 09:53:00 GMT

摘要: 初步体验 widget 大家好，五一已经过去了，你们玩得开心么？ ... 阅读全文

The Spark of Thinking 2006-07-20 17:53 发表评论

SWT/JFace开发入门指南（二）(转载)

The Spark of Thinking — Thu, 20 Jul 2006 09:32:00 GMT

摘要: 从 Hello, world! 开始了解 Display 和 Shell ... 阅读全文

The Spark of Thinking 2006-07-20 17:32 发表评论

SWT/JFace开发入门指南（一）(转载)

The Spark of Thinking — Thu, 20 Jul 2006 09:31:00 GMT

摘要: 写在前面的话终于决定提起笔来写一篇关于 swt 和 JFace 编程的文章。在开始之前，我想先介绍一下你能够从将要出现的这一系列文章里得到什么，以及更重要的，你不能... 阅读全文

The Spark of Thinking 2006-07-20 17:31 发表评论

Eclipse插件开发之新手入门

The Spark of Thinking — Thu, 20 Jul 2006 07:54:00 GMT

现在在internet上已经可以见到不少的eclipse插件开发的入门文章，这里我写本文的目的主要是将我自己的体会和最开始的学习告诉给大家。同时也希望本文能使用最为简单的方法来让大家了解开发eclipse插件的基础。需要注意的是，要学习eclipse的插件开发，你需要：

　　会使用eclipse来开发java应用程序

　　了解插件这个词的概念

　　了解一些xml的知识本文是一个入门的文章，只是向大家说明开发一个插件的简单步骤，同时了解在开发插件时涉及到的技术面会有哪些。

　　eclipse sdk概述

　　我们通常使用的eclipse也就是我们这里所说的eclipse sdk，这个sdk中包括了很多的内容，如下图所示：

　　运行时核心(eclipse platform) - sdk必须一个eclipse platform，它自身不具有任何对最终用户有意义的功能，它是一个加载所有插件的基础平台。也就是eclipse的运行时最小集合了。

　　java 开发工具(jdt) - 我们所有的有关java的开发部分都是由这个插件来完成了，它形成了对于java最为基础的编辑、编译、运行、调试、发布的环境。

　　插件开发者环境(pde) - 开发插件的插件，我们如果要开发插件哪么我们就会发现所有的工作环境都是由它来提供的。它提供了用来自动创建、处理、调试和部署插件的工具。

　　我们将来要开发的插件都是由平台来加载和运行，而pde则是开发插件的开发环境，jdt则是开发插件时的java代码的开发环境。

　　创建插件项目

　　设置引用项目

　　开发插件时需要大量的外部库，这些外部库主要是现有的eclipse中各个插件所提供的库。为了开发方便，我们先将这些外部库由一个项目统一引用。

　　从资源透视图中，使用文件＞导入...＞外部插件和段。
　　在下一步中选择抽取源归档并在项目中创建源文件夹。
　　到显示称为选择的屏幕，选择 org.eclipse.ui，然后单击完成按钮。

　　创建项目

　　在eclipse需要创建一个空的插件项目，为了让我们更好的理解插件中各个文件的来源，我们从一个空白的插件项目开始：

　　1) 打开新建项目...向导（文件＞新建＞项目...）并从插件开发类别中选择插件项目。

　　2) 将com.huangdong.examples.helloworld用作项目的名称。缺省情况下，向导还会将com.huangdong.examples.helloworld设置为标识。

　　3) 最终，确保在插件代码生成器页面上选择了创建空白插件项目。

　　4) 当询问您是否想切换到“插件开发”透视图时，回答是。

　　5) 选择com.huangdong.examples.helloworld项目并打开属性对话框。

　　6) 在java构建路径属性中，选择项目选项卡，并选择项目org.eclipse.ui。这些包含了项目需要的导入类。

　　7) 重建项目。
　　创建一个插件内容

　　创建一个新的小视图

　　下面我们为该项目加入一个很简单的视图：

　　1) 在项目的src目录下创建包com.huangdong.examples.helloworld。

　　2) 在此包中创建称为helloworldview的新类其超类为org.eclipse.ui.part.viewpart。

　　在helloworldview中加入以下代码：

　　package com.huangdong.examples.helloworld;

　　import org.eclipse.swt.swt;
　　import org.eclipse.swt.widgets.composite;
　　import org.eclipse.swt.widgets.label;
　　import org.eclipse.ui.part.viewpart;

　　public class helloworldview extends viewpart {

　　label label;

　　public void createpartcontrol(composite parent) {
　　label = new label(parent, swt.wrap);
　　label.settext("hello world");
　　}

　　public void setfocus() {}
　　}

　　我们为该类定义了一个变量lable，在createpartcontrol方法中初始化并设置了一个显示的字符串。

　　护展扩展点

　　让eclipse添加这个视图，需要扩展org.eclipse.ui.views扩展点。所有的这些需要在plugin.xml中进行描述。该清单文件描述插件，包括插件的代码所在的位置以及正在添加的扩展。

　　将以下内容复制到plugin.xml中：

　　＜?xml version="1.0" encoding="utf-8"?＞
　　＜plugin id="com.huangdong.examples.helloworld"
　　name="com.huangdong.examples.helloworld"
　　version="1.0.0"
　　provider-name="huangdong"＞

　　＜runtime＞
　　＜library name="helloworld.jar"/＞
　　＜/runtime＞
　　＜requires＞
　　＜import plugin="org.eclipse.ui"/＞
　　＜/requires＞

　　＜extension point="org.eclipse.ui.views"＞
　　＜category
　　name="hello"
　　id="com.huangdong.examples.helloworld.hello"＞
　　＜/category＞
　　＜view
　　name="hello greetings"
　　category="com.huangdong.examples.helloworld.hello"
　　class="com.huangdong.examples.helloworld.helloworldview"
　　id="com.huangdong.examples.helloworld.helloworldview"＞
　　＜/view＞
　　＜/extension＞

　　＜/plugin＞

　　在plugin域中定义了插件的名称、标识和版本。同时在runtime域中定义了插件代码将打包于helloworld.jar文件中。在requires域中定义了该插件所要使用的依赖插件，由于我们要使用swt api和工作台所以列示了org.eclipse.ui。最后，在extension中说明了要们要扩展org.eclipse.ui.views扩展点。首先我们在category中定义了视图的类别，在工作台的显示视图对话框中，可以使用类别来将相关的视图集中在一起。我们定义的类别名为“hello”。同时也定义了我们的视图，名为“hello greetings”，这个视图将会显示在“显示视图”对话框和视图的标题栏中，这里我们还通过class标识来说明了实现这个视图的最终类。

　　通过plugin.xml的定义，eclipse才会真正的找到插件可以做的行为，以及这些行为最终实现的具体java类。

　　在插件清单文件中使用了许多标识。个别扩展点通常会定义需要标识的配置参数（例如，以上用于视图扩展点的类别标识）。我们还要定义插件标识。通常，应该对所有标识都使用 java 包名前缀，以便确保所有已安装的插件都是唯一的。

　　在前缀后面使用的特定名称完全由您自己决定。然而，如果插件标识前缀刚好与其中一个包的名称相同，则应该避免在该包中使用类名。否则，将很难分辨您正在查看标识名还是类名。

　　还应该避免对不同的扩展配置参数使用相同的标识。在上述清单中，已经使用了公共标识前缀（com.huangdong.examples.helloworld），但是，我们的所有标识都是唯一的。此命名方法可以帮助我们阅读文件并了解哪些标识是相关的。

　　运行和测试插件

　　运行插件是一件很简单的事，这些在pde中给我们提供了很好的支持。只需要在菜单中选择运行＞运行为＞运行时工作台，在运行时会弹出一个重复插件的提示框，可以按确定跳过，不必在意。这样会启动一个已经安装好插件的eclipse。

　　启动后在菜单中选择窗口＞显示视图＞其它，在显示视图对话框中会有一个分类为hello，点开hello分类会看到hello greetings，选择后点确定按钮。在最下面的视图中可以见到以下界面：

　　到这里，如果你看到了这个图，哪么恭喜你，你的第一个eclipse插件成功运行了

The Spark of Thinking 2006-07-20 15:54 发表评论

eclipse中的线程

The Spark of Thinking — Thu, 20 Jul 2006 07:49:00 GMT

寒假我就上网很少了,真的非常不好意思.eclipse中的线程是开发eclipse插件中一个比较重要的基础,而很多书上都没有说,我最后抽时间写了这篇入门文章,希望对大家有帮助.

我先大致讲一讲GUI程序中的线程.
虽然各个操作系统之间的线程机制是不一样的,但是大致是相同的.当用户使用GUI程序时,如果点鼠标或按下键盘上的键等时,操作系统会产生对应的GUI事件,它来决定哪个窗口或程序来接受每一个事件并且放到程序的事件队列中.
任何GUI程序的底层结构就是一个事件循环.程序首先初始化事件循环,并开始循环,这个循环会从事件队列依次接收GUI事件并一一做出相应的反应.程序应该对事件做出快速的反应使程序一直对用户有响应,举个例子,用户点了一下程序里的一个按钮结果程序就没反应了,那么这个程序应该算是一个失败的程序吧.
如果某个UI事件引发了某个需要长时间的事务,那么应该把它放到一个另外的单独的线程中,这样程序的那个事件循环就能够马上回来响应用户的下一个操作.线程是非常复杂的一个主题,如果处理的不好很容易造成死锁等很糟糕的情况.

还好,eclipse为我们开发插件提供了一个方便的UI线程包,大大的简化了很多底层复杂的东西.先看看几个简单的概念.
1.SWT UI线程
SWT用的是操作系统直接支持的线程模式,程序会在主程序里运行一个时间循环并依次在这个线程里响应事件.看下面这段代码,UI线程就是创建Display的那个线程.
public static void main (String [] args) {
Display display = new Display ();
Shell shell = new Shell (display);
shell.open ();
// 开始事件循环
// 关掉窗口后
while (!shell.isDisposed ()) {
if (!display.readAndDispatch ())
display.sleep ();
}
display.dispose ();
}
简单的小程序里,一个UI线程就能够满足需要了.
但如果是长时间的操作,你就最好不要用UI线程来做这些事,可以交给Job去做.它其实就是另外启动的线程,也就是等会我要说的非UI线程.

2.Job
Job类由org.eclipse.core.runtime插件提供.它能够让客户程序员轻松的在另外的线程中执行代码.
看一个小例子
Job job = new Job("My First Job") {
protected IStatus run(IProgressMonitor monitor) {
System.out.println("Hello World (from a background job)");
return Status.OK_STATUS;
}
};
job.setPriority(Job.SHORT);
job.schedule(); // start as soon as possible

Job的默认优先级是Job.Long,这里例子中的优先级要比它高.
只要调用Job#schedule()，它就会尽快在另外的线程中运行run()中的代码.
再看一个小例子:
final Job job = new Job("Long Running Job") {
protected IStatus run(IProgressMonitor monitor) {
try {
while(hasMoreWorkToDo()) {
// do some work
// ...
if (monitor.isCanceled()) return Status.CANCEL_STATUS;
}
return Status.OK_STATUS;
} finally {
schedule(60000); // start again in an hour
}
}
};
job.addJobChangeListener(new JobChangeAdapter() {
public void done(IJobChangeEvent event) {
if (event.getResult().isOK())
postMessage("Job completed successfully");
else
postError("Job did not complete successfully");
}
});
job.setSystem(true);
job.schedule(); // start as soon as possible

monitor 是一个进度显示条,它会在运行job时自动显示,如果任务成功运行完成,返回Status.OK_STATUS,如果中途被用户在进度显示条那里中断,就返回Status.CANCEL_STATUS.上面schedule(60000);它是让job每过1小时就自动运行,Job又一个非常强大的功能.
然后后面是可以给job添加监听器.
job.setSystem(true);这一句是把这个job设置为系统级别的.如果调用setUser(true),那么就被定义为用户级别的,用户级别和默认级别的job
在运行时会以UI形式反映出来,如果是用户job,那么会弹出一个进度显示窗口,能让用户选择在后台里运行.
下图是一个job自动运行时的效果:
=700) window.open('http://blog.csdn.net/images/blog_csdn_net/starshus/runindialog.gif');" src="http://blog.csdn.net/images/blog_csdn_net/starshus/runindialog.gif" onload="if(this.width>'700')this.width='700';" border="0" twffan="done" />
再介绍job常常用到的一个方法Job#join().
系统调用到某个job,调用它的run()方法:
再看下面这个例子:

class TrivialJob extends Job {
public TrivialJob() {
super("Trivial Job");
}
public IStatus run(IProgressMonitor monitor) {
System.out.println("This is a job");
return Status.OK_STATUS;
}
}

job的创建和计划如下所示:

TrivialJob job = new TrivialJob();
System.out.println("About to schedule a job");
job.schedule();
System.out.println("Finished scheduling a job");

他们的执行是和时间没关系的,输出可能如下:
About to schedule a job
This is a job
Finished scheduling a job

也可能是:

About to schedule a job
Finished scheduling a job
This is a job

如果希望某个job运行完成后在继续时,可以使用join()方法.
join()会一直阻塞到该job运行完.

例子:
TrivialJob job = new TrivialJob();
System.out.println("About to schedule a job");
job.schedule();
job.join();
if (job.getResult().isOk())
System.out.println("Job completed with success");
else
System.out.println("Job did not complete successfully");

上面的代码执行后,输出应该就是这样:

About to schedule a job
This is a job
Job completed with success

Job的功能是很强大的,还有很多功能我以后会介绍,也可以查阅官方帮助文档.这里先把几个常用的问题解决掉.
参见:
http://help.eclipse.org/help30/index.jsp?topic=/org.eclipse.platform.doc.isv/guide/runtime_jobs.htm

3.如果在Job中加上改变UI的代码就会失败.
原因如下:
如果是在非UI线程中调用UI,SWT就会抛出一个SWTException.
要在一个非UI线程改变UI的话有几种技术:

第一种,用:
Display#syncExec(Runnable)或
Diaplay#asyncExec(Runnable)

第二种:
已经开发了另外一种Job,就是UIJob,可以直接在它里面运行改变UI的代码,其实它就是在SWT的asyncExec()方法里运行的.所有继承UIJob的类应

该覆写runInUIThread方法而不是run方法.

3.关于进度显示
在Jface中:
org.eclipse.jface.operations包定义了一些接口用来在进度条下运行长时间的任务.
可以参见:
http://help.eclipse.org/help30/index.jsp?topic=/org.eclipse.platform.doc.isv/guide/jface_operations.htm

在eclipse插件和RCP开发中:
用户级别的job是互操作性最强的,它不仅能够让用户用Cancel键取消job，而且可以在Detail中展示具体情况,但是注意:
Detail只会在下面两种方法中出现:
IProgressService#busyCursorWhile或
IProgressService#runInUI
1)IProgressService#busyCursorWhile的用法例子:
注意这里的run()中做些和UI无关的事.
IProgressService progressService = PlatformUI.getWorkbench().getProgressService();
progressService.busyCursorWhile(new IRunnableWithProgress(){
public void run(IProgressMonitor monitor) {
//do non-UI work
}
});
效果:
=700) window.open('http://blog.csdn.net/images/blog_csdn_net/starshus/cursor.gif');" src="http://blog.csdn.net/images/blog_csdn_net/starshus/cursor.gif" onload="if(this.width>'700')this.width='700';" border="0" twffan="done" />
2)IProgressService#runInUI的用法例子:
注意这里的run()中可以做些和UI有关的事.
progressService.runInUI(
PlatformUI.getWorkbench().getProgressService(),
new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) {
//do UI work
}
},
Platform.getWorkspace().getRoot());
效果:
=700) window.open('http://blog.csdn.net/images/blog_csdn_net/starshus/inui.gif');" src="http://blog.csdn.net/images/blog_csdn_net/starshus/inui.gif" onload="if(this.width>'700')this.width='700';" border="0" twffan="done" />
这里最后一个参数可以是null,或者是这个操作的规则,在这里我们是设定运行这个UI操作时锁定工作台.
更加具体的可以参见:
http://help.eclipse.org/help30/index.jsp?topic=/org.eclipse.platform.doc.isv/guide/workbench_jobs.htm

另外,有少数时候,我们不想弹出一个进度条窗口,而是只在最底下的状态栏显示就可以了,很简单,写自己的Job类时,在构造方法里加上一句:
setUser(false);就可以了.

The Spark of Thinking 2006-07-20 15:49 发表评论