There are two traversal shortcuts I use all the time: Ctrl-O and Ctrl-T.

Ctrl-O shows the methods of the class in the current editor in a popup.
Hit Ctrl-O when the popup is up, and you'll see all the inherited
methods as well. This is incredibly useful, as it allows me to bounce
between methods even when I'm not sure which class is implementing
which method.

Ctrl-T shows the type hierarchy of a selected type in a popup. This is the
complement to Ctrl-O. When I'm sure of what
interface I'm looking at, but I really want to pick a particular implementation
and want to go trawling through that
implementation for a bit, Ctrl-T will show me all the subclasses or
implementors for that type.

There is a third option which I haven't used much. Ctrl-F3 shows the
methods of a selected type in a popup. I can see how this can be useful,
but in practice I have a pretty good idea of which methods are attached
 to which classes and Ctrl-Space fills most of my needs there.

However, I have been missing a couple of things. These are the shortcuts
I just found recently, and are very good for hitting up random files:

Ctrl-E shows a popup list of all the open files.
Ctrl-Shift-T creates a dialog box that you can use to navigate to any class.
Ctrl-Shift-R creates a dialog box that shows any resource in the project
(basically any file.)
Alternately, there's an Eclipse plugin called GotoFile which seems to behave
a little more "IDEAish".

Finally, I found a plugin which actually integrates Eclipse with Windows!
Eclipse Platform Extensions is actually functional and useful, although
you wouldn't guess it by looking at the website. Although it says that
it provides a "System GC" functionality, it actually does far more,
like provide a "Open in Windows Explorer" and
"Open Command Window here" dialog to the Package Explorer.

You can allow your users to access the help system over the Internet or an intranet, by
installing the infocenter and the documentation plug-ins on a server. Clients view help
by navigating to a URL, and the help system is shown in their web browser. The
infocenter help system can be used both for client applications and for web
applications, either of which can have their help accessed remotely. All features
of help system except infopops and active help are supported.

The infocenter help system allows passing number of options that can be used to
customize various aspects of the infocenter. The following options are supported:

• -eclipsehome eclipseInstallPath - specifies Eclipse installation directory.
  This directory is a parent to "plugins" directory and eclipse executable.
  The option must be provided, when current directory from which infocenter
  is launched, is not the same as Eclipse installation directory.
• -data instanceArea - specifies a path that Eclipse can use to write instance data.
  The value can be an absolute path of a directory, or a path relative to Eclipse
  installation directory. The option must be provided when Eclipse is installed in
  the read only location, or has been customized to override osgi.instance.area
  or osgi.instance.area.default properties.
• -host helpServerHost - specifies host name of the interface that help server
  will use. It overrides host name specified in the application server plugin preferences.
• -port helpServerPort - specifies port number that help server will use. It overrides
  port number specified in the application server plugin preferences.
• -locales localeList - specifies a list of locales that infocenter will recognize and
  provide a customized content for. If the option is not specified, infocenter will
  build navigation, and index documents for each preferred locale of the browsers
  accessing the infocenter. When the option is present, locales from browser
  requests will be matched with locales in the list. If browser preferred locale
  does not exist in the list, but its language part does, it will be used. Subsequently,
  additional browser locales in decreased order of preference will be matched
  against the list. If none of the browser locales (or its language part) matches any
  locale on the list, the client will be served content in the default locale - server
  locale or locale passed with -nl option. For example using options

  -nl en -locales de en es fr it ja ko pt_BR zh_CN zh_TW

  will cause infocenter operating in 10 locales. All other locales will receive content
  for en locale.
• -dir rtl - sets right-to-left rendering direction of help UI in the browser.
• -noexec - indicates that Eclipse executable should not be used. You may need to use
  this option when running on a platform for which Eclipse executable is not available.
• Additionally, most options accepted by Eclipse executable can be passed. They are
  especially useful during debugging and for applying customization to Eclipse.
  For example, passing options

  -vmargs -Xmx256M 

  increases memory available to the infocenter and will allow serving a larger book collection.

Installation/packaging

These steps are for the help system integrator and are not meant to address all the possible scenarios.
 It is assumed that all your documentation is delivered as Eclipse plug-ins and, in general, you are
familiar with the eclipse help system.

1. Download the Eclipse Platform Runtime Binary driver from www.eclipse.org.
2. Install (unzip) the driver in a directory, d:\myApp. This will create an eclipse sub-directory,
   d:\myApp\eclipse that contains the code required for the Eclipse platform
   (which includes the help system).

How to start or stop infocenter from command line

The org.eclipse.help.standalone.Infocenter class has a main method that you can use to
launch infocenter from a command line. The command line arguments syntax is:

-command start | shutdown | [-eclipsehome eclipseInstallPath] 
[-data instanceArea] [-host helpServerHost] [-locales localeList] 
[-port helpServerPort] [-dir rtl] [-noexec] [platform options] 
[-vmargs JavaVMarguments]

To start an infocenter on port 8081 issue a start command by running

java -classpath d:\myApp\eclipse\plugins\org.eclipse.help.base_3.1.0.jar 
org.eclipse.help.standalone.Infocenter -command start -eclipsehome 
d:\myApp\eclipse -port 8081

To shut the infocenter down issue a shutdown command by running

java -classpath d:\myApp\eclipse\plugins\org.eclipse.help.base_3.1.0.jar 
org.eclipse.help.standalone.Infocenter -command shutdown -eclipsehome 
d:\myApp\eclipse

Using the infocenter

Start the web server. Point a web browser to the path "help" web application running on a port
specified when starting the infocenter.  On the machine the infocenter is installed, this would be
http://localhost:8081/help/.

How to start or stop infocenter from Java

When including infocenter as part of another application, it may be more convenient to start it
and stop using Java APIs instead of using system commands. Follow the steps if it is the case:

1. Make sure d:\myApp\eclipse\plugins\org.eclipse.help.base_3.1.0.jar is on your app classpath.
   The class you use to start, and shut down the infocenter isorg.eclipse.help.standalone.Infocenter.
2. Create an array of String containing options that you want to pass to the infocenter. Typically,
   the eclipsehome and port options are needed.

   String[] options = new String[] { "-eclipsehome", "d:\\myApp\\eclipse" ,
    "-port", "8081" }; 

3. In your application, create an instance of the Help class by passing the options.

   Infocenter infocenter = new Help(options); 

4. To start the help system:

   helpSystem.start();

5. To shut the infocenter down:

   helpSystem.shutdown(); 

Making infocenter available on the web

Eclipse contains a complete infocenter and does not require other server software to run.
However, in unsecure environment like Internet, it is recommended infocenter is not accessed
directly by clients, but is made available through an HTTP server or an application server.
Most servers come with modules or servlets for delegating certain request to other web
resources. For example, one may configure a proxy module of Apache HTTP Server to
redirect requests made to http://mycompany.com/myproduct/infocenter to
http://internalserver:8081/help that runs an infocenter. Adding the lines

LoadModule proxy_module modules/ApacheModuleProxy.dll
ProxyPass /myproduct/infocenter http://internalserver:8081/help
ProxyPassReverse /myproduct/infocenter http://internalserver:8081/help

Some versions of Apache HTTP server, may contain AddDefaultCharset directive enabled in
configuration file. Remove the directive or replace with

AddDefaultCharset Off

Running multiple instance of infocenter

Multiple instances of infocenter can be run on a machine from one installation. Each started
instance must use its own port and be provided with a workspace, hence -port and -data
options must be specified. The instances can serve documentation from different set of plug-ins,
by providing a valid platform configuration with -configuration option.

If -configuration is not used and configuration directory is shared among multiple infocenter
instances, with overlapping set of locales, it must be ensured that all search indexes are created
by one infocenter instance before another instance is started. Indexes are saved in the configuration
directory, and write access is not synchronized across infocenter processes.

[Optional] Installing a minimal set of plug-ins

The infocenter does not require the entire  Eclipse Platform package. It is possible to run the
infocenter with the following plug-ins (located in the  eclipse\plugins directory):

org.apache.lucene
org.eclipse.core.runtime
org.eclipse.help
org.eclipse.help.appserver
org.eclipse.help.base
org.eclipse.help.webapp
org.eclipse.osgi
org.eclipse.tomcat
org.eclipse.update.configurator


Some documentation plug-ins may have dependencies on other plug-ins, usually by specifying required
plug-ins in their plugin.xml. The dependent plug-ins need to be installed on the infocenter as well.
Additionally, plug-ins that were designed for earlier than 3.0 version of Eclipse implicitly require an org.eclipse.core.runtime.compatibility being present plug-in to work.

Infocenter plug-ins can be updated without restarting the infocenter, using commands explained
in Updating a running infocenter from command line topic. To use this functionality, the minimal
set of plug-ins must include org.eclipse.update.core plug-in.

See Help System Preferences for more information on customizing help system.

//定义一个Job
class AJob extends Job
{
 public AJob()
 {
  super("Andy's Job");
 }

 public IStatus run(IProgressMonitor monitor)
 {
  System.out.println("This is Andy's Job");
  return Status.OK_STATUS;
 }
}

schedule后，任务在平台线程等待队列中排队，等待调度执行。
调用方式1：

//异步调用
AJob job = new AJob();
job.schedule(); //唤起平台线程来调度这个Job

调用方式2：

//结束后再运行
AJob job = new AJob();
job.schedule();
 // do some other things.
job.join();        //block，直到job完成或调用线程被中断
if(job.getResult().isOk())
{
 //Job completed with success.
}
else
{
 //Job did not complete successfully.
}

if(!job.cancel())
{
 job.join();
} //cancel可能不会立即成功，我们用join等待cancel操作完成。

To do this right click the project in Package Explorer or Navigator view and got to either Java Code Style or Java Compiler options. Check the Enable project specific settings.

This will create a .settings folder in the project root. Eclipse will add and maintain the project specific configuration in this folder. Commit this folder to the version control. Thats it. Now the project settings are shared with the team. When the other team members synchronize with the repository they will get the project settings too. Any team member can update and check in the settings. Cool!

/**//**
   * This method is called when 'Finish' button is pressed 
   * in the wizard. We will create an operation and run it
   * using wizard as execution context.
   */
  public boolean performFinish() {
    final String containerName = page.getContainerName();
    final String fileName = page.getFileName();
    IRunnableWithProgress op = new IRunnableWithProgress() 
    {
      public void run(IProgressMonitor monitor) 
          throws InvocationTargetException 
      {
        try {
          doFinish(containerName, fileName, monitor);
        } catch (CoreException e) {
          throw new InvocationTargetException(e);
        } finally {
          monitor.done();
        }
      }
    };
    try {
      getContainer().run(true, false, op);
    } catch (InterruptedException e) {
      return false;
    } catch (InvocationTargetException e) {
      Throwable realException = e.getTargetException();
      MessageDialog.openError(
          getShell(), 
          "Error", realException.getMessage());
      return false;
    }
    return true;
  }

/**//*  */
/**//**
   * The worker method. It will find the container, create
   * the file if missing or just replace its contents, and 
   * open the editor on the newly created file.
   */

  private void doFinish(
      String containerName,
      String fileName,
      IProgressMonitor monitor)
      throws CoreException 
  {
    // create a sample file
    monitor.beginTask("Creating " + fileName, 2);
    IWorkspaceRoot root = 
        ResourcesPlugin.getWorkspace().getRoot();
    IResource resource = root.findMember(
        new Path(containerName));
    if (!resource.exists() || 
        !(resource instanceof IContainer)) 
    {
      throwCoreException("Container \"" + 
          containerName + "\" does not exist.");
    }
    IContainer container = (IContainer) resource;
    final IFile file = 
        container.getFile(new Path(fileName));
    try {
      InputStream stream = openContentStream();
      if (file.exists()) {
        file.setContents(stream, true, true, monitor);
      } else {
        file.create(stream, true, monitor);
      }
      stream.close();
    } catch (IOException e) {
    }
    monitor.worked(1);
    monitor.setTaskName("Opening file for editing");
    getShell().getDisplay().asyncExec(new Runnable() {
        public void run() {
          IWorkbenchPage page =
              PlatformUI.getWorkbench().
              getActiveWorkbenchWindow().getActivePage();
          try {
            IDE.openEditor(page, file, true);
          } catch (PartInitException e) {
          }
        }
      });
    monitor.worked(1);
  }

This code is a simple SWT wizard page. The most interesting characteristic of this class is in the handleBrowse method. This method uses Eclipse's ContainerSelectionDialog for displaying the folders in the workspace.

/**
   * Uses the standard container selection dialog to
   * choose the new value for the container field.
   */
  private void handleBrowse() {
    ContainerSelectionDialog dialog =
        new ContainerSelectionDialog(
            getShell(),
            ResourcesPlugin.getWorkspace().getRoot(),
            false,
            "Select new file container");
    if (dialog.open() == ContainerSelectionDialog.OK) {
      Object[] result = dialog.getResult();
      if (result.length == 1) {
        containerText.setText(
            ((Path)result[0]).toOSString());
      }
    }
  }

在我们小组的设计中，Plugin和控制逻辑是分成两个工程单独开发的，Plugin主要实现界面功能，通过调用控制逻辑实现数据存储、Blog发布、打印等功能，所以接触到了制作库插件这个过程，现在写下来，希望有点帮助。

如何制作库插件：
将库工程转换为Plugin工程，在MANIFEST.MF的overview里定义ID，在Runtime里加入你要公开的包（Exported Packages）。OK

如何使用库插件，主要分为三步：
1、在Dependencies Tab的Required Plug-ins中加入你的库插件（保证输出项目时导出相应的库插件）
2、然后Compute build path（使项目能够顺利通过编译）
3、在运行对话框的Plugin Tab里单击Add required plugins，这样项目才能正常运行

有一点忘了就会挺郁闷的！

  RCP  Eclipse Plugin

详细的制作Help过程我就不说了，在这里可以找到。

要注意三个问题：
1、添加的插件要齐全，使用Help要增加以下几个插件：
org.apache.ant
org.apache.lucene
org.eclipse.help.appserver
org.eclipse.help.base
org.eclipse.help.ui
org.eclipse.help.webapp
org.eclipse.tomcat

2、在Build里添加html文件的信息，使html文件能正确导出，如：
bin.includes = plugin.xml,\
               *.jar,\
               plugin.properties,\
               book.xml,\
               html/,\
               icons/

3、在html文件中不能有中文的链接（显示为乱码，服务器会提示找不到该文件），所以html和图片的名称尽量用英文，内容用中文倒没有问题。

可能的原因：今天看Eclipse的RCP Tutorial时注意到Eclipse RCP所需的Plugin最小集是org.eclipse.core.runtime和org.eclipse.ui，又记起昨天使用了PDE的调试功能，所以org.eclipse.debug.core，org.eclipse.debug.ui可能是调试时生成的，或者是以前别的项目用过出错工程的workspace目录，生成了一些别的Plugin目录，而多出的Plugin在Plugin.xml文件里注册的menu在我的程序里没有被添加（或者没有定义对应的MenuPath），于是就抛出了：Invalid Menu Extension (Path is invalid)

不过还有一个问题：怎么workspace的.Plugin文件夹里只有org.eclipse.ui.workbench而没有org.eclipse.core.runtime，有谁知道这是为什么吗？

《Contributing to Eclipse》分为四个循环，第一个循环是第零个循环（hahaha）。

第零个循环介绍了Eclipse的基础架构，然后通过编写一个最简单的HelloWorld Plugin带我们走进Contributing的大门。

先说说这里列出的比较重要的概念：
Eclipse分为三层：Platform、JDT、PDE。其中PDE是对JDT的扩展，提供了插件开发支持。

Platform又分为两层：Core（Workspace、Runtime）、UI（Workbench、JFace、SWT）。
下面分别介绍一下：
Runtime --- 定义了插件的基础设施。启动时发现所有可用插件并管理插件的加载。
Workspace --- 管理一个或多个顶级项目。
SWT（Standard Widget Toolkit）--- 提供图形显示功能，定义了一组标准窗体组件。
JFace --- 建立在SWT上的一组比较小的UI框架，提供对常用UI任务的支持。
Workbench --- Eclipse的UI聚合体，核心要素是编辑器、视图（View）和视角（Perspective）。
其中视角（Perspective）定义了各工作台部件的可视化排列方式。

All Right. That's how you get it.
Go on, be a tiger.

上software.hit.edu.cn看Flash没有问题，打开一个Word文档也OK，应该是内嵌了IE吧。

看了代码也只发现一个setLocation(URL)，没有跟本地系统联系的代码，难道SWT里的Browser本身就内嵌了IE。

以前也听说过SWT是不用虚拟机的（是吗？），都是调用本地的dll，只是现在亲眼目睹了。

这不有点像AWT吗？！