1. 知识储备

1.1 Eclipse RCP

Eclipse RCP 是 Eclipse IDE 的基础架构，允许开发者构建强大的桌面应用程序。它提供了一组框架和工具，使开发者能够创建基于插件体系结构的、高度可定制的桌面应用程序。

以下是 Eclipse RCP 的一些关键概念和特性：

1. 插件体系结构： Eclipse RCP 基于插件的体系结构，允许开发者将应用程序划分为一系列独立的插件。每个插件负责提供特定的功能或服务。
2. 视图和编辑器： Eclipse RCP 提供了视图和编辑器框架，使开发者能够构建多窗口和多文档接口（MDI）应用程序。
3. 工作台：Eclipse RCP 应用程序包含一个工作台，其中包含了各种工具栏、视图和编辑器，用户可以根据自己的需求进行布局和定制。
4. SWT 和 JFace： Eclipse RCP 使用 SWT（Standard Widget Toolkit）和 JFace 来构建用户界面。SWT 提供了与本地操作系统交互的轻量级控件，而 JFace 则提供了更高级别的 UI 构建工具。
5. 扩展点和扩展： 插件通过使用扩展点和扩展机制来定义和贡献功能。这使得应用程序可以轻松地扩展和定制。
6. 特性和更新： Eclipse RCP 支持特性（Features）和更新（Update）机制，允许应用程序进行在线更新和升级。
7. Eclipse Marketplace： Eclipse RCP 应用程序可以利用 Eclipse Marketplace 中的各种插件和工具，以便更容易地扩展和定制功能。

2. 核心要素

2.1 核心配置

2.1.1 Product文件

Eclipse RCP 中的 .product 文件是用于定义和配置 Eclipse RCP 产品的文件。它描述了产品的名称、ID、版本、启动器配置、插件和特性等信息。以下是 .product 文件的主要元素和详解：

1. <product> 元素：
   1. 作用： 定义产品的基本信息。
   2. 属性：
      • name: 产品的显示名称。
      • id: 产品的唯一标识符。
      • version: 产品的版本号。
      • useFeatures: 指定是否使用特性（Features）来定义产品。

<product name="My RCP Product" id="com.example.myrcp.product" version="1.0.0" useFeatures="true">

1. <configIni> 元素：
   1. 作用： 配置产品的 config.ini 文件。
   2. 属性：
      • use: 指定是否使用默认的 config.ini 文件。

<configIni use="default"/>

1. <launcherArgs> 元素：
   1. 作用： 配置产品启动器的参数。

<launcherArgs>
</launcherArgs>

1. <launcher> 元素：
   1. 作用： 配置产品的启动器（launcher）。
   2. 属性：
      • solaris: 针对 Solaris 操作系统的配置。
      • win: 针对 Windows 操作系统的配置。

<launcher>
   <win useIco="false">
      <bmp/>
   </win>
</launcher>

1. <splash> 元素：
   1. 作用： 配置产品的启动时闪屏。
   2. 属性：
      • location: 闪屏图片的位置。
      • product: 与闪屏相关联的产品 ID。
      • foregroundColor: 闪屏前景色。
      • backgroundColor: 闪屏背景色。

<splash
   location="platform:/base/plugins/com.example.myrcp.product/splash.bmp"
   product="${eclipse.product}"
   foregroundColor="0,0,0"
   backgroundColor="255,255,255">
</splash>

1. <plugins> 元素：
   1. 作用： 定义产品使用的插件。
   2. 子元素：
      • <plugin>: 定义单个插件。

<plugins>
   <plugin id="com.example.plugin1" />
   <plugin id="com.example.plugin2" />
   <!-- 添加其他插件 -->
</plugins>

1. <features> 元素：
   1. 作用： 定义产品使用的特性。
   2. 子元素：
      • <feature>: 定义单个特性。

<features>
   <feature id="com.example.feature1" />
   <feature id="com.example.feature2" />
   <!-- 添加其他特性 -->
</features>

1. <configurations> 元素：
   1. 配置产品的插件和特性的启动顺序和启动级别。

<configurations>
      <plugin id="com.example.myproduct.product" autoStart="true" startLevel="1"/>
      <feature id="com.example.myproduct.feature" autoStart="true" startLevel="2"/>
</configurations>

以上是 .product 文件的一些关键元素，它们一起定义了 Eclipse RCP 产品的配置信息。在创建和配置产品时，你可以根据实际需求调整这些元素的属性和子元素。产品的配置文件在构建和打包产品时被用于生成最终的产品。

2.2 Eclipse插件开发介绍

org.eclipse.core.runtime.applications(程序入口)

org.eclipse.core.runtime.applications 是 Eclipse RCP（Rich Client Platform）中用于定义应用程序的扩展点。通过这个扩展点，可以声明和配置 Eclipse RCP 应用程序的入口点（Application），以及应用程序的其他相关信息。

以下是一些关键的类和接口，与 org.eclipse.core.runtime.applications 扩展点相关：

1. org.eclipse.core.runtime.applications 扩展点：

• 通过 org.eclipse.core.runtime.applications 扩展点，你可以声明和配置应用程序的入口点。这通常包括指定应用程序类、处理启动参数等信息。

<extension
      id="application"
      point="org.eclipse.core.runtime.applications">
   <application
         cardinality="singleton-global"
         thread="main"
         visible="true">
      <run
            class="org.example.MyApplication">
      </run>
   </application>
</extension>

API Information:

类属性的值必须表示org.eclipse.equinox.application.IApplication的实现者。接口org.eclipse.core.runtime.IPlatformRunnable已被弃用并替换为org.eclipse.equinox.application.IApplication接口。org.eclipse.core.runtime.IPlatformRunnable接口仅支持向后兼容。

1. IApplication 接口：

• IApplication 接口是 Eclipse RCP 中应用程序的入口点接口。你的应用程序类需要实现这个接口，并提供 start 和 stop 方法。

import org.eclipse.equinox.app.IApplication;
import org.eclipse.equinox.app.IApplicationContext;

public class MyApplication implements IApplication {
    public Object start(IApplicationContext context) throws Exception {
        // 应用程序启动时的逻辑
        return null;
    }

    public void stop() {
        // 应用程序停止时的逻辑
    }
}

1. ApplicationDescriptor 类：

• ApplicationDescriptor 类提供了对应用程序描述信息的访问。通过描述信息，可以获取有关应用程序的配置信息。

import org.eclipse.core.runtime.Platform;
import org.eclipse.equinox.app.IApplicationDescriptor;

public class MyAppDescriptor {
    public static void main(String[] args) {
        // 获取应用程序描述信息
        IApplicationDescriptor descriptor = Platform.getApplicationRegistry()
                .getDescriptors("your.application.id")[0];
        String appName = descriptor.getName();
        System.out.println("Application Name: " + appName);
    }
}

1. 使用方式：

• 创建实现了 IApplication 接口的类，实现其中的 start 和 stop 方法。
• 在插件的 plugin.xml 中声明应用程序扩展点，指定应用程序的实现类。
• 在 Eclipse IDE 中创建一个启动配置，选择要运行的应用程序。
• 启动应用程序时，Eclipse RCP 将调用指定的 IApplication 实现类的 start 方法。
• 应用程序的生命周期由 IApplicationContext 提供的上下文信息进行管理。

通过配置 org.eclipse.core.runtime.applications 扩展点，并实现 IApplication 接口，你可以定义和控制 Eclipse RCP 应用程序的行为。此外，通过使用应用程序描述信息，可以在运行时获取应用程序的相关信息。在实际使用中，需要替换示例中的标识符和类名为实际的应用程序标识符和类名。

org.eclipse.core.runtime.products(定义属性)

org.eclipse.core.runtime.products 扩展点是 Eclipse RCP（Rich Client Platform）中用于定义产品的扩展点。产品定义了一个独立的、可分发的 Eclipse 应用程序。通过定义产品，你可以配置应用程序的名称、图标、启动特性、插件等属性。

以下是 org.eclipse.core.runtime.products 扩展点中 <product> 元素的一些配置：

<extension id="coolProduct" point="org.eclipse.core.runtime.products"> 
      <product name="%coolName" application="coolApplication" description="%coolDescription"> 
          <property name="windowImages" value="window.gif"/> 
          <property name="aboutImage" value="image.gif"/> 
          <property name="aboutText" value="%aboutText"/> 
          <property name="appName" value="CoolApp"/> 
          <property name="welcomePage" value="$nl$/welcome.xml"/> 
          <property name="preferenceCustomization" value="plugin_customization.ini"/> 
      </product> 
   </extension> 

这些属性和元素定义了 Eclipse RCP 产品的一些关键特征，包括产品的标识、名称、启动应用程序、描述、图标、版本等。通过定义产品，你可以配置和分发独立的 Eclipse 应用程序。

org.eclipse.core.runtime.preferences(偏好设置)

org.eclipse.core.runtime.preferences 是 Eclipse IDE 中用于处理偏好设置（Preferences）的核心运行时插件。Eclipse 使用 Preferences 来存储用户和插件的配置信息，例如用户界面的外观、项目的设置等。

以下是一些关于 org.eclipse.core.runtime.preferences 的基本信息：

1. 功能：

• 提供了 Eclipse 运行时环境中用于管理偏好设置的支持。

2. 插件标识符：

• 插件 ID 为 org.eclipse.core.runtime.preferences。

3. 运行时 Preferences API：

• Eclipse 提供了运行时 Preferences API，允许插件在运行时存储和检索偏好设置。这些偏好设置以键值对的形式存储。

4. 使用 Preferences：

• 插件可以使用 org.eclipse.core.runtime.Preferences 类来访问和操作偏好设置。这包括存储和检索布尔值、整数值、浮点数值、字符串值等。

// 示例：存储和检索偏好设置
Preferences preferences = InstanceScope.INSTANCE.getNode("your.plugin.id");
preferences.putBoolean("booleanKey", true);
boolean value = preferences.getBoolean("booleanKey", false);

5. Preferences 存储位置：

• Eclipse 的偏好设置通常存储在工作区的 .metadata/.plugins/org.eclipse.core.runtime/.settings/ 目录下。每个插件都有一个对应的 .prefs 文件。

6. 监听偏好设置变化：

• 插件可以通过添加监听器来监视偏好设置的变化，以便在发生变化时采取相应的操作。

IPreferencesService service = Platform.getPreferencesService();
service.addPropertyChangeListener(listener, "your.plugin.id");

7. Workspace Preferences 和 Instance Preferences：

• Eclipse 提供了两种类型的 Preferences：Workspace Preferences 和 Instance Preferences。前者是在工作区级别存储的设置，后者是在实例级别存储的设置。

// 获取 Workspace Preferences
Preferences workspacePrefs = InstanceScope.INSTANCE.getNode("your.plugin.id");
// 获取 Instance Preferences
Preferences instancePrefs = InstanceScope.INSTANCE.getNode("your.plugin.id");

8**.** 项目中关于initializer类的配置，储存核心运行系统的偏好设置

class	设置内容
CorePreferenceInitializer
CarrierPreferenceInitializer
CommandPreferenceInitializer
ConfigPreferenceInitializer
DevicePreferenceInitializer
FabPreferenceInitializer
MaintenancePreferenceInitializer
SystemPreferenceInitializer

org.eclipse.help.toc(帮助内容)

org.eclipse.help.toc 扩展点是 Eclipse 中用于定义帮助系统中的表 of contents（TOC，目录）的扩展点。TOC 定义了帮助内容的层次结构，帮助用户浏览和导航到相关的帮助主题。

以下是 org.eclipse.help.toc 扩展点的一些关键元素和属性：

<toc> 元素：

• 作用： 定义 TOC（目录）的根元素。
• 属性：
  • file: 指定 TOC 的 XML 文件路径。

<topic> 元素：

• 作用： 定义帮助主题。
• 属性：
  • label: 主题的显示标签。
  • href: 主题的链接地址。
  • external: 指示主题是否为外部链接。
  • content: 指定主题内容的 HTML 文件路径。
  • link_to: 指定链接到另一个 TOC 的路径。

<topicContribution> 元素：

• 作用： 允许插件向 TOC 中添加额外的主题。
• 属性：
  • link: 指定要链接的 TOC 的路径。
  • toc: 指定用于扩展的 TOC 的路径。

示例：

<extension
     point="org.eclipse.help.toc">
  <toc
        file="toc.xml">
  </toc>
</extension>
<!-- toc.xml -->
<toc label="My Help">
  <topic label="Introduction" href="intro.html"/>
  <topic label="Installation" href="install.html"/>
  <topic label="Advanced Topics" href="advanced.html">
    <topic label="Configuration" href="config.html"/>
    <topic label="Customization" href="customize.html"/>
  </topic>
  <topicContribution toc="additional_toc.xml" link="Additional Topics"/>
</toc>

在上述示例中，org.eclipse.help.toc 扩展点指定了一个 TOC 文件 toc.xml。TOC 文件定义了一个帮助内容的层次结构，包括顶层主题和嵌套主题。还使用了 topicContribution 元素，允许通过链接到另一个 TOC（additional_toc.xml）扩展主题。

这样，Eclipse 帮助系统就可以通过这些定义提供层次结构化的帮助内容，用户可以通过 TOC 导航和浏览相关主题。

org.eclipse.help.contexts(上下文帮助)

org.eclipse.help.contexts 扩展点是 Eclipse 中用于定义上下文帮助（context-sensitive help）的扩展点。上下文帮助提供了与用户界面元素相关联的帮助内容，当用户在应用程序中浏览时，可以获取有关特定元素的详细信息。

以下是 org.eclipse.help.contexts 扩展点的一些关键元素和属性：

<contexts> 元素：

• 作用： 定义上下文帮助的根元素。
• 属性：
  • file: 指定上下文定义的 XML 文件路径。

<context> 元素：

• 作用： 定义一个上下文帮助项。
• 属性：
  • id: 上下文的唯一标识符。
  • title: 上下文的显示标题。
  • description: 上下文的描述信息。

<topic> 元素：

• 作用： 定义与上下文相关的帮助主题。
• 属性：
  • label: 主题的显示标签。
  • href: 主题的链接地址。

示例：

<extension
     point="org.eclipse.help.contexts">
  <contexts
        file="contexts.xml">
  </contexts>
</extension>
<!-- contexts.xml -->
<contexts>
  <context id="com.example.plugin.sampleContext" title="Sample Context" description="Context for the sample plugin">
    <topic label="Sample Topic" href="sampleTopic.html"/>
  </context>
</contexts>

在上述示例中，org.eclipse.help.contexts 扩展点指定了一个上下文定义的 XML 文件 contexts.xml。该文件定义了一个上下文帮助项，其中包括一个上下文（com.example.plugin.sampleContext）和一个与该上下文相关的帮助主题（Sample Topic）。用户可以通过上下文标识符查找并显示相关的上下文帮助。

org.eclipse.ui.actionSets(动作集扩展)

org.eclipse.ui.actionSets 扩展点是 Eclipse 中用于定义动作集（Action Set）的扩展点。动作集是一组在 Eclipse 工作台用户界面中可用的动作（Action）的集合，它们通常与特定功能或视图集成在一起。

以下是 org.eclipse.ui.actionSets 扩展点的一些关键元素和属性：

<actionSet> 元素：

• 作用： 定义一个动作集。
• 属性：
  • id: 动作集的唯一标识符。
  • label: 动作集的显示标签。
  • visible: 动作集是否可见，默认为 true。
  • menubarPath: 动作集在菜单栏中的位置。
  • toolbarPath: 动作集在工具栏中的位置。
  • description: 动作集的描述信息。

<action> 元素：

• 作用： 定义一个动作，它是动作集中的一个单独项。
• 属性：
  • id: 动作的唯一标识符。
  • label: 动作的显示标签。
  • class: 实现动作的类的完全限定名。
  • icon: 动作的图标路径。
  • tooltip: 动作的工具提示文本。

示例：

<extension
     point="org.eclipse.ui.actionSets">
  <actionSet
        id="com.example.myActionSet"
        label="My Action Set"
        visible="true"
        menubarPath="file/additions"
        toolbarPath="toolbar/myToolbar"
        description="Description of My Action Set">
    <action
          id="com.example.myAction"
          label="My Action"
          class="com.example.MyAction"
          icon="icons/myActionIcon.png"
          tooltip="Perform My Action">
    </action>
  </actionSet>
</extension>

在上述示例中，org.eclipse.ui.actionSets 扩展点指定了一个动作集。该动作集包含一个动作（com.example.myAction），该动作具有唯一标识符、显示标签、类名、图标路径和工具提示文本。动作集在菜单栏的 file/additions 位置和工具栏的 toolbar/myToolbar 位置可见，并且有一个描述信息。用户在 Eclipse 工作台中可以看到并使用此动作集及其包含的动作。

API 接口:

class属性的值必须是实现org. eclipse.ui.IWorkbenchWindowActionDelegate或org.eclipse.ui.IWorkbenchWindowPulldownDelegate的类的完全限定名。后者应该在style属性具有值下拉的情况下实现。该类是负责执行操作的处理程序。如果retarget属性为true，则忽略此属性，不应该提供。该类尽可能晚地加载，以避免在真正需要之前加载整个插件。

• IWorkbenchWindowPulldownDelegate :用于提供到工作台窗口工具栏中的下拉操作。它扩展了IWorkbenchWindowActionDelegate,并添加了一个初始化方法来定义操作的菜单生成器。
• IWorkbenchWindowActionDelegate :一个操作的接口，该操作被贡献到工作台窗口菜单或工具栏中。它扩展了IActionDelegate，并添加了一个初始化方法，用于将委托连接到它应该使用的工作台窗口。
• IActionDelegate :通过扩展点贡献的操作接口。此接口应由需要通过扩展点贡献操作的客户端实现。工作台将代表插件生成代理操作对象，以避免在用户需要之前必须激活插件。如果执行该操作，工作台将加载实现此接口的类并创建所谓的操作委托对象。然后请求和所有后续请求将通过代理操作转发给操作委托，该委托执行真正的工作。

  • 代理操作是出现在UI中的操作，因此操作委托需要与代理操作对话以保持适当的外观。一旦创建了操作委托，它将收到所有选择更改的通知，允许它适当地启用或禁用代理操作。

  • 在执行操作之前，不能就选择更改咨询操作委托，因为它不存在。因此，还应通过扩展中包含的简单XML规则来控制操作的启用状态。这些规则允许在加载操作委托的插件之前进行启用状态控制。

  • 客户端可以选择子类化所提供的抽象实现org.eclipse.ui.actions.ActionDelegate或直接实现接口。

  • 动作扩展的启用标准最初由enablesFor以及选择或启用定义。但是，一旦动作委托被实例化，它可以直接在其selsionChanged方法中控制动作启用状态。

  • 需要注意的是，工作台不会代表插件生成菜单。菜单路径必须引用已经存在的菜单。

动作和菜单标签可能包含使用以下规则编码助记符的特殊字符：

• 助记符是在翻译文本中选定字符前面使用与号 (‘&’) 字符指定的。由于与号不允许在XML字符串中使用，请使用&字符实体。

如果一个扩展为菜单或工具栏贡献了两个或多个操作，这些操作将以与它们在plugin.xml文件中列出的顺序相反的顺序出现。这种行为不可否认是不直观的。然而，它是在Eclipse平台API被冻结后发现的。现在更改行为将破坏依赖于现有行为的每个插件。

选择和启用元素是互斥的。启用元素可以使用子元素object tClass和object tState替换选择元素。例如，以下内容：

 <selection
  class="org.eclipse.core.resources.IFile"
  name="*.java">
 </selection>

可以用:

<enablement>
  <and>
   <objectClass name="org.eclipse.core.resources.IFile"/>
   <objectState name="extension" value="java"/>
  </and>
 </enablement>

实现接口:

插件可以使用此扩展点添加新的顶级菜单。插件还可以定义命名组，允许其他插件将其操作贡献到其中。

顶级菜单是通过使用以下路径属性值创建的：

• 添加-表示窗口菜单左侧的组。

省略path属性将导致将新菜单添加到添加菜单栏组中。

工作台窗口中的默认组在IWorkbenchActionConstants界面中定义。这些常量可以在代码中用于动态贡献。这些值也可以复制到XML文件中，以便与现有工作台菜单和工具栏进行细粒度集成。

工作台窗口中的各种菜单和工具栏项是通过算法定义的。在这些情况下，必须使用单独的机制来扩展窗口。例如，添加新的工作台视图会导致新菜单项出现在透视菜单中。导入、导出和新向导扩展也会自动添加到窗口中。

org.eclipse.ui.activities(活动界面)

org.eclipse.ui.activities 扩展点是 Eclipse 中用于定义活动（Activity）的扩展点。活动是一种机制，用于根据用户的角色或权限来限制特定的 UI 元素（如菜单项、工具栏按钮等）是否可见或可操作。通过活动，可以根据用户的上下文动态调整 Eclipse 工作台的界面元素。

以下是 org.eclipse.ui.activities 扩展点的一些关键元素和属性：

<activity> 元素：

• 作用： 定义一个活动。
• 属性：
  • id: 活动的唯一标识符。
  • name: 活动的显示名称。
  • description: 活动的描述信息。

<activityPatternBinding> 元素：

• 作用： 定义活动与 UI 元素的绑定关系，即指定哪些 UI 元素受活动的限制。
• 属性：
  • activityId: 关联的活动的唯一标识符。
  • pattern: UI 元素的 ID 模式，用于匹配需要受活动限制的 UI 元素。

<enabledWhen> 元素：

• 作用： 定义活动的启用条件，即指定何时活动生效。
• 属性：
  • checkEnabled: 描述活动的启用条件的表达式。

示例：

<extension
     point="org.eclipse.ui.activities">
  <activity
        id="com.example.myActivity"
        name="My Activity"
        description="Description of My Activity">
  </activity>
</extension>
<extension
     point="org.eclipse.ui.activities">
  <activityPatternBinding
        activityId="com.example.myActivity"
        pattern="com.example.myCommand">
  </activityPatternBinding>
</extension>
<extension
     point="org.eclipse.ui.activities">
  <activity
        id="com.example.anotherActivity"
        name="Another Activity"
        description="Description of Another Activity">
  </activity>
  <enabledWhen
        checkEnabled="someExpression">
     <with variable="activityId">
        <equals value="com.example.anotherActivity"/>
     </with>
  </enabledWhen>
</extension>

在上述示例中，org.eclipse.ui.activities 扩展点定义了两个活动：com.example.myActivity 和 com.example.anotherActivity。其中，com.example.myActivity 关联到 UI 元素的 ID 模式为 com.example.myCommand 的元素。com.example.anotherActivity 定义了一个启用条件，只有当表达式 someExpression 为真时，该活动才生效。这样，可以根据用户的上下文动态控制与这些活动相关的 UI 元素的可见性和可操作性。

org.eclipse.ui.bindings(快捷键绑定)

org.eclipse.ui.bindings 是 Eclipse 中用于定义键盘快捷键和绑定的扩展点。通过这个扩展点，可以定义在 Eclipse 工作台中执行操作的快捷键，以及将这些快捷键绑定到具体的操作。

以下是一些关键的元素和属性，通常在 org.eclipse.ui.bindings 扩展点中使用：

<bindings> 元素：

• 作用： 定义一组键盘快捷键绑定。
• 属性：
  • 无特定属性，但该元素的子元素为 <binding>。

<binding> 元素：

• 作用： 定义一个键盘快捷键绑定。
• 属性：
  • schemeId: 指定绑定的方案（scheme）的 ID。
  • contextId: 指定绑定的上下文（context）的 ID。
  • keySequence: 指定键盘快捷键的序列，例如 “CTRL+SHIFT+F”.
  • command: 指定与快捷键关联的命令的 ID。

<key> 元素：

• 作用： 定义一个键盘快捷键。
• 属性：
  • command: 关联的 Eclipse 命令的 ID。
  • schemeId: 所属的键盘方案的 ID。
  • contextId: 关联的上下文（context）的 ID。
  • keySequence: 描述按键的序列，例如 CTRL+ALT+S。
  • platform: 可选属性，指定按键在哪个平台上有效，如 win32、gtk 等。

示例：

<extension
     point="org.eclipse.ui.bindings">
  <key
        command="org.eclipse.ui.file.save"
        schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"
        contextId="org.eclipse.ui.contexts.window"
        sequence="CTRL+S">
  </key>
  <binding
        command="org.eclipse.ui.file.save"
        keySequence="CTRL+S">
  </binding>
</extension>

在上述示例中，org.eclipse.ui.bindings 扩展点定义了两个键盘快捷键绑定。第一个绑定将 “CTRL+S” 绑定到保存命令（org.eclipse.ui.file.save），而第二个绑定将 “CTRL+X” 绑定到剪切命令（org.eclipse.ui.edit.cut）。这些绑定是在默认的快捷键方案和窗口上下文中生效的。

通过使用 org.eclipse.ui.bindings 扩展点，Eclipse 插件可以自定义和扩展键盘快捷键的配置，以满足特定需求。

cmcs系统中场景应用：

commandId	schemeId	sequence	功能说明	备注
cmcs.command.core.refresh.view	cmcs.scheme.AcceleratorConfiguration	F5
cmcs.command.core.refresh.cache	cmcs.scheme.AcceleratorConfiguration	M1+F5
cmcs.command.core.LockClientAction	cmcs.scheme.AcceleratorConfiguration	M2+M3+L
cmcs.command.command.open.history	cmcs.scheme.AcceleratorConfiguration	M1+H
cmcs.command.command.open.detail	cmcs.scheme.AcceleratorConfiguration	ENTER
cmcs.command.command.change.priority	cmcs.scheme.AcceleratorConfiguration	M1+P
cmcs.command.command.reroute	cmcs.scheme.AcceleratorConfiguration	M1+R
cmcs.command.command.cancel	cmcs.scheme.AcceleratorConfiguration	M1+S

org.eclipse.ui.commands(事件命令)

org.eclipse.ui.commands 是 Eclipse IDE 中的扩展点，用于定义和配置命令。Eclipse IDE 中的各种用户操作，例如菜单项点击、工具栏按钮点击等，都会被映射到相应的命令上。通过 org.eclipse.ui.commands 扩展点，可以定义这些命令及其属性。

以下是 org.eclipse.ui.commands 扩展点的主要元素：

<command> 元素：

• **作用：**定义一个命令。
• 属性：
  • id: 命令的唯一标识符。
  • name: 命令的显示名称。
  • categoryId: 命令所属的类别的 ID。
  • description: 命令的描述信息。
  • defaultHandler: 命令的默认处理器的 ID。
  • categoryId: 命令所属的类别的 ID。
  • tracingEnabled: 是否启用追踪。

<category> 元素：

• 作用： 定义一个命令类别。
• 属性：
  • id: 命令类别的唯一标识符。
  • name: 命令类别的显示名称。
  • description: 命令类别的描述信息。

示例：

<extension
     point="org.eclipse.ui.commands">
  <category
        id="com.example.commandCategory"
        name="Command Category"
        description="Category for custom commands">
  </category>
  <command
        id="com.example.customCommand"
        name="Custom Command"
        description="A custom command"
        categoryId="com.example.commandCategory"
        defaultHandler="com.example.handlers.CustomCommandHandler">
  </command>
</extension>

在上述示例中，<category> 元素定义了一个命令类别，具有唯一标识符 com.example.commandCategory。然后，<command> 元素定义了一个命令，具有唯一标识符 com.example.customCommand，所属的类别为 com.example.commandCategory，并指定了默认的命令处理器com.example.handlers.CustomCommandHandler。

通过使用 org.eclipse.ui.commands 扩展点，开发者可以在 Eclipse IDE 中定义和配置命令，以支持用户界面上的各种交互操作。这有助于实现更灵活和可定制的用户体验。

org.eclipse.ui.contexts (上下文)

org.eclipse.ui.contexts 是 Eclipse IDE 中的扩展点，用于定义上下文（context）。上下文在 Eclipse IDE 中用于确定何时启用或禁用命令，以及何时触发监听器。通过定义上下文，可以根据特定的上下文状态来控制用户界面元素的行为。

以下是 org.eclipse.ui.contexts 扩展点的主要元素：

<context> 元素：

• 作用： 定义一个上下文。
• 属性：
  • id: 上下文的唯一标识符。
  • name: 上下文的显示名称。
  • description: 上下文的描述信息。
  • parentId: 可选属性，指定上下文的父级上下文。

<contextState> 元素：

• 作用： 定义上下文的状态。
• 属性：
  • id: 上下文状态的唯一标识符。
  • name: 上下文状态的显示名称。
  • description: 上下文状态的描述信息。
  • value: 上下文状态的值。

示例：

<extension
     point="org.eclipse.ui.contexts">
  <context
        id="com.example.myContext"
        name="My Context"
        description="Custom context for my feature">
  </context>
  <contextState
        id="com.example.myContextEnabled"
        name="Enabled"
        description="The context is enabled"
        value="com.example.myContextEnabled">
  </contextState>
</extension>

在上述示例中，<context> 元素定义了一个上下文，具有唯一标识符 com.example.myContext，显示名称为 “My Context”。然后，<contextState> 元素定义了上下文的状态，具有唯一标识符 com.example.myContextEnabled，显示名称为 “Enabled”，并且当上下文处于启用状态时，其值为 com.example.myContextEnabled。

通过使用 org.eclipse.ui.contexts 扩展点，开发者可以在 Eclipse IDE 中定义和配置上下文，以根据应用程序的状态控制用户界面元素的行为。这有助于实现更灵活和智能的用户交互。

org.eclipse.ui.decorators(资源装饰器)

org.eclipse.ui.decorators 是 Eclipse IDE 中的扩展点，用于定义和配置装饰器（decorators）。装饰器允许在资源（如项目、文件）或其他元素上添加附加信息或图标，以提供更多的可视化反馈。

以下是 org.eclipse.ui.decorators 扩展点的主要元素：

<decorator> 元素：

• 作用： 定义一个装饰器。
• 属性：
  • id: 装饰器的唯一标识符。
  • label: 装饰器的显示名称。
  • icon: 装饰器的图标路径。
  • state: 装饰器的默认状态。
  • location: 装饰器的位置，如 TOP_LEFT、BOTTOM_RIGHT 等。
  • class: 装饰器的实现类。
  • adaptable: 是否支持适配器。
  • lightweight: 是否为轻量级装饰器。

<enablement> 元素：

• 作用： 定义装饰器的启用条件。
• 内容： 一个或多个条件，用于确定何时启用装饰器。

示例：

<extension
     point="org.eclipse.ui.decorators">
  <decorator
        id="com.example.myDecorator"
        label="My Decorator"
        icon="icons/myDecorator.png"
        state="ENABLED"
        location="BOTTOM_RIGHT"
        class="com.example.decorators.MyDecorator">
    <enablement>
        <objectState name="org.eclipse.core.resources.projectOpen" value="true"/>
    </enablement>
  </decorator>
</extension>

在上述示例中，<decorator> 元素定义了一个装饰器，具有唯一标识符 com.example.myDecorator，显示名称为 “My Decorator”，图标路径为 “icons/myDecorator.png”，并且默认启用。该装饰器位于底部右侧（BOTTOM_RIGHT），使用 com.example.decorators.MyDecorator 类实现。通过 <enablement> 元素，指定了装饰器的启用条件，即当项目处于打开状态时（projectOpen 为 true）启用该装饰器。

通过使用 org.eclipse.ui.decorators 扩展点，开发者可以在 Eclipse IDE 中定义和配置装饰器，以增强用户界面的可视化效果。这有助于提供更丰富的信息反馈，使用户能够更清晰地理解资源或元素的状态。

cmcs中的应用：

id	class	描述
cmcs.decorator.fabExplorerlabelDecorator	FabExplorerLabelProvider	处理fab界面的装饰，各设备节点的图片，文本，联动状态变化等
cmcs.decorator.mcsConfigExplorerlabelDecorator	McsConfigExplorerLabelProvider
cmcs.decorator.fabStatusExplorerlabelDecorator	FabStatusExplorerLabelProvider

org.eclipse.ui.handlers(事件命令处理器)

org.eclipse.ui.handlers 是 Eclipse IDE 中的扩展点，用于定义和配置命令处理器（handlers）。处理器是与 Eclipse 命令相关联的代码，负责执行实际的操作或任务。通过定义处理器，可以将特定的行为与 Eclipse 命令关联起来。

以下是 org.eclipse.ui.handlers 扩展点的主要元素：

<command> 元素：

• 作用： 定义一个命令。
• 属性：
  • id: 命令的唯一标识符。
  • name: 命令的显示名称。
  • description: 命令的描述信息。
  • defaultHandler: 默认的命令处理器的 ID。

<handler> 元素：

• 作用： 定义一个命令处理器。
• 属性：
  • commandId: 关联的命令的 ID。
  • class: 命令处理器的实现类。
  • name: 命令处理器的显示名称。
  • description: 命令处理器的描述信息。

示例：

<extension
     point="org.eclipse.ui.handlers">
  <command
        id="com.example.myCommand"
        name="My Command"
        description="Custom command">
  </command>
  <handler
        commandId="com.example.myCommand"
        class="com.example.handlers.MyCommandHandler"
        name="My Command Handler"
        description="Handler for my custom command">
  </handler>
</extension>

在上述示例中，<command> 元素定义了一个命令，具有唯一标识符 com.example.myCommand，显示名称为 “My Command”。然后，<handler> 元素定义了一个命令处理器，将该处理器与命令 com.example.myCommand 关联，使用 com.example.handlers.MyCommandHandler 类实现。

通过使用 org.eclipse.ui.handlers 扩展点，开发者可以在 Eclipse IDE 中定义和配置命令及其处理器，实现用户界面上的各种交互操作。处理器是执行实际任务的地方，可以包含与命令相关的业务逻辑。

cmcs中的应用场景：

commandId	handler	描述
cmcs.command.command.cancel	sg.com.nsynus.cmcs.ui.core.commands.CommandHandler
cmcs.command.command.reroute	sg.com.nsynus.cmcs.ui.core.commands.CommandHandler
cmcs.command.command.change.priority	sg.com.nsynus.cmcs.ui.core.commands.CommandHandler
cmcs.command.command.open.detail	sg.com.nsynus.cmcs.ui.core.commands.CommandHandler
cmcs.command.command.open.history	sg.com.nsynus.cmcs.ui.core.commands.CommandHandler

org.eclipse.ui.perspectives(透视图：布局和功能)

org.eclipse.ui.perspectives 是 Eclipse IDE 中的扩展点，用于定义和配置透视图（perspectives）。透视图是 Eclipse IDE 中的一个重要概念，代表了不同的工作环境，每个透视图都包含了一组适用于特定任务或角色的编辑器、视图和操作。

以下是 org.eclipse.ui.perspectives 扩展点的主要元素：

<perspective> 元素：

• 作用： 定义一个透视图。
• 属性：
  • id: 透视图的唯一标识符。
  • name: 透视图的显示名称。
  • class: 透视图的实现类。
  • icon: 透视图的图标路径。
  • fixed: 是否为固定透视图。
  • description: 透视图的描述信息。

<reset> 元素：

• 作用： 定义透视图的重置操作。
• 属性：
  • perspectiveId: 要重置的透视图的 ID。

示例：

<extension
     point="org.eclipse.ui.perspectives">
  <perspective
        id="com.example.myPerspective"
        name="My Perspective"
        class="com.example.perspectives.MyPerspective"
        icon="icons/myPerspective.png"
        fixed="false"
        description="Custom perspective for my tasks">
  </perspective>
</extension>

在上述示例中，<perspective> 元素定义了一个透视图，具有唯一标识符 com.example.myPerspective，显示名称为 “My Perspective”，使用 com.example.perspectives.MyPerspective 类实现。透视图的图标路径为 “icons/myPerspective.png”，并且该透视图不是固定的（fixed="false"）。通过这个扩展，开发者可以自定义透视图，以适应特定的开发任务或工作流程。

通过使用 org.eclipse.ui.perspectives 扩展点，开发者可以在 Eclipse IDE 中定义和配置透视图，使用户能够根据自己的工作需求定制 IDE 的布局和功能。

CMCS的应用：

id	class	功能描述
cmcs.perspective.clientLock	ClientLockPerspective
cmcs.perspective.carrier	CarrierPerspective
cmcs.perspective.command	CommandPerspective
cmcs.perspective.commlog	CommLogPerspective
cmcs.perspective.config	ConfigPerspective
cmcs.perspective.device	DevicePerspective
cmcs.perspective.fab	FabPerspective
cmcs.perspective.history	HistoryPerspective
cmcs.perspective.maintenance	MaintenancePerspective
cmcs.perspective.statistics	StatisticsPerspective
cmcs.perspective.system	SystemPerspective
cn.com.nsynus.cim.cmcs.ui.perspective.PmsPerspective	PmsPerspective

org.eclipse.ui.perspectiveExtensions(透视图配置和功能)

org.eclipse.ui.perspectiveExtensions 是 Eclipse IDE 中的扩展点，用于向已定义的透视图（perspective）添加额外的配置或功能。通过这个扩展点，可以扩展透视图的行为，例如添加新的编辑器、视图、动作等。是org.eclipse.ui.perspectives 透视图的拓展。每个透视图可以存在多个View视图

以下是 org.eclipse.ui.perspectiveExtensions 扩展点的主要元素：

<perspectiveExtension> 元素：

• 作用： 定义透视图的扩展。
• 属性：
  • targetID: 要扩展的透视图的 ID。
  • id: 扩展的唯一标识符。

<editor> 元素：

• 作用： 定义一个编辑器。
• 属性：
  • id: 编辑器的唯一标识符。
  • icon: 编辑器的图标路径。
  • name: 编辑器的显示名称。
  • class: 编辑器的实现类。

<view> 元素：

• 作用： 定义一个视图。
• 属性：
  • id: 视图的唯一标识符。
  • icon: 视图的图标路径。
  • name: 视图的显示名称。
  • class: 视图的实现类。

<actionSet> 元素：

• 作用： 定义一个操作集。
• 属性：
  • id: 操作集的唯一标识符。

示例：

<extension
     point="org.eclipse.ui.perspectiveExtensions">
  <perspectiveExtension
        targetID="com.example.myPerspective"
        id="com.example.perspectiveExtension1">
    <editor
          id="com.example.myEditor"
          icon="icons/myEditor.png"
          name="My Editor"
          class="com.example.editors.MyEditor">
    </editor>
    <view
          id="com.example.myView"
          icon="icons/myView.png"
          name="My View"
          class="com.example.views.MyView">
    </view>
    <actionSet
          id="com.example.myActionSet">
    </actionSet>
  </perspectiveExtension>
</extension>

在上述示例中，<perspectiveExtension> 元素定义了一个透视图扩展，目标透视图的 ID 为 com.example.myPerspective，扩展的唯一标识符为 com.example.perspectiveExtension1。通过该扩展，向透视图添加了一个编辑器、一个视图和一个操作集。具体的编辑器、视图和操作集的定义则通过 <editor>、<view> 和 <actionSet> 元素完成。

通过使用 org.eclipse.ui.perspectiveExtensions 扩展点，开发者可以在 Eclipse IDE 中扩展已有的透视图，以添加自定义的编辑器、视图和操作集，从而满足特定的开发需求。这有助于定制 IDE 的功能，使其更适应用户的工作流程。

org.eclipse.ui.preferencePages(定义和配置偏好设置)

org.eclipse.ui.preferencePages 是 Eclipse IDE 中的扩展点，用于定义和配置首选项页面（Preference Pages）。首选项页面提供用户界面，允许用户配置和调整 Eclipse IDE 的各种设置和首选项。

以下是 org.eclipse.ui.preferencePages 扩展点的主要元素：

<page> 元素：

• 作用： 定义一个首选项页面。
• 属性：
  • id: 首选项页面的唯一标识符。
  • name: 首选项页面的显示名称。
  • class: 首选项页面的实现类。
  • category: 首选项页面的所属类别。

<category> 元素：

• 作用： 定义首选项页面的类别。
• 属性：
  • id: 类别的唯一标识符。
  • name: 类别的显示名称。

示例：

<extension
     point="org.eclipse.ui.preferencePages">
  <category
        id="com.example.myCategory"
        name="My Category">
  </category>
  <page
        id="com.example.myPreferencePage"
        name="My Preference Page"
        class="com.example.preferences.MyPreferencePage"
        category="com.example.myCategory">
  </page>
</extension>

在上述示例中，<category> 元素定义了一个首选项页面的类别，具有唯一标识符 com.example.myCategory 和显示名称 “My Category”。然后，<page> 元素定义了一个首选项页面，具有唯一标识符 com.example.myPreferencePage、显示名称 “My Preference Page”，使用 com.example.preferences.MyPreferencePage 类实现，并属于类别 com.example.myCategory。

通过使用 org.eclipse.ui.preferencePages 扩展点，开发者可以在 Eclipse IDE 中定义和配置首选项页面，以提供用户友好的界面，让用户能够方便地配置 IDE 的各种设置和首选项。这有助于提升用户体验和个性化 IDE 的行为。

org.eclipse.ui.propertiesView(配置属性视图)

org.eclipse.ui.propertiesView 是 Eclipse IDE 中的扩展点，用于配置和定义属性视图（Properties View）。属性视图是 Eclipse IDE 中的一个重要组件，它显示了当前选择的资源或元素的属性，允许用户查看和编辑这些属性。

以下是 org.eclipse.ui.propertiesView 扩展点的主要元素：

<propertySheet> 元素：

• 作用： 定义属性视图。
• 属性：
  • id: 属性视图的唯一标识符。
  • class: 属性视图的实现类。
  • showReadOnly: 是否显示只读属性，默认为 false。

示例：

<extension point="org.eclipse.ui.propertiesView">
   <propertySheet
         id="com.example.myPropertiesView"
         class="com.example.views.MyPropertiesView"
         showReadOnly="true">
   </propertySheet>
</extension>

在上述示例中，<propertySheet> 元素定义了一个属性视图，具有唯一标识符 com.example.myPropertiesView，使用 com.example.views.MyPropertiesView 类实现，并且设置了 showReadOnly 属性为 true，以显示只读属性。

通过使用 org.eclipse.ui.propertiesView 扩展点，开发者可以在 Eclipse IDE 中定义和配置属性视图，以提供一个可定制的属性编辑器，使用户能够查看和编辑资源或元素的属性。这有助于增强 IDE 的可扩展性和适应性。

org.eclipse.ui.viewActions(配置视图操作)

org.eclipse.ui.viewActions 是 Eclipse IDE 中的扩展点，用于定义和配置视图操作（View Actions）。视图操作是与视图关联的一组动作，允许用户执行特定的操作或任务。

以下是 org.eclipse.ui.viewActions 扩展点的主要元素：

<action> 元素：

• 作用： 定义一个视图操作。
• 属性：
  • id: 视图操作的唯一标识符。
  • label: 视图操作的显示名称。
  • class: 视图操作的实现类。
  • icon: 视图操作的图标路径。

示例：

<extension point="org.eclipse.ui.viewActions">
   <action
         id="com.example.myViewAction"
         label="My View Action"
         class="com.example.actions.MyViewAction"
         icon="icons/myActionIcon.png">
   </action>
</extension>

在上述示例中，<action> 元素定义了一个视图操作，具有唯一标识符 com.example.myViewAction，显示名称为 “My View Action”，使用 com.example.actions.MyViewAction 类实现，并且指定了图标路径为 “icons/myActionIcon.png”。

通过使用 org.eclipse.ui.viewActions 扩展点，开发者可以在 Eclipse IDE 中定义和配置与视图关联的操作，以扩展视图的功能和提供更丰富的用户交互。这有助于增强 IDE 的灵活性和用户体验。

https://archive.eclipse.org/eclipse/downloads/documentation/2.0/html/plugins/org.eclipse.platform.doc.isv/reference/extension-points/org_eclipse_ui_viewActions.html

org.eclipse.ui.views(定义和配置视图)

org.eclipse.ui.views 是 Eclipse IDE 中的扩展点，用于定义和配置视图（Views）。视图是 Eclipse IDE 中的一个核心概念，它提供了一种查看和操作特定数据或资源的方式，可以与编辑器、透视图等组件集成在一起。

以下是 org.eclipse.ui.views 扩展点的主要元素：

<view> 元素：

• 作用： 定义一个视图。
• 属性：
  • id: 视图的唯一标识符。
  • name: 视图的显示名称。
  • class: 视图的实现类。
  • icon: 视图的图标路径。
  • category: 视图所属的类别。

<category> 元素：

• 作用： 定义视图的类别。
• 属性：
  • id: 类别的唯一标识符。
  • name: 类别的显示名称。

示例：

<extension
     point="org.eclipse.ui.views">
  <category
        id="com.example.myCategory"
        name="My Views">
  </category>
  <view
        id="com.example.myView"
        name="My View"
        class="com.example.views.MyView"
        icon="icons/myViewIcon.png"
        category="com.example.myCategory">
  </view>
</extension>

在上述示例中，<category> 元素定义了一个视图的类别，具有唯一标识符 com.example.myCategory 和显示名称 “My Views”。然后，<view> 元素定义了一个视图，具有唯一标识符 com.example.myView、显示名称 “My View”，使用 com.example.views.MyView 类实现，并指定了图标路径为 “icons/myViewIcon.png”，同时属于类别 com.example.myCategory。

通过使用 org.eclipse.ui.views 扩展点，开发者可以在 Eclipse IDE 中定义和配置视图，以提供对特定数据或资源的可视化展示和操作。这有助于构建更丰富和灵活的用户界面，满足用户不同的工作需求。

API Information:

class属性的值必须是实现org. eclipse.ui.IViewPart的Java类的完全限定名称。在开发新视图时，子类化org.eclipse.ui.part.ViewPart是常见做法。

接口实现:

工作台提供了许多标准视图，包括导航器、属性、大纲和任务。从用户的角度来看，这些视图与插件提供的任何其他视图没有区别。所有视图都可以从“窗口”菜单的“显示视图”子菜单中显示。视图的位置是持久的：当视图关闭时保存，当视图在单个会话中重新打开时恢复。该位置也在工作台会话之间持久化。

org.eclipse.core.runtime.products

org.eclipse.core.runtime.products 是 Eclipse IDE 中的扩展点，用于定义和配置产品（Products）。产品是 Eclipse IDE 的一种打包和定制方式，允许开发者创建基于 Eclipse 平台的独立应用程序。

以下是 org.eclipse.core.runtime.products 扩展点的主要元素：

<product> 元素：

• 作用： 定义一个产品。
• 属性：
  • id: 产品的唯一标识符。
  • name: 产品的显示名称。
  • application: 产品关联的应用程序 ID。
  • version: 产品的版本号。
  • definitionFile: 产品的定义文件路径。
  • description: 产品的描述信息。

<configIni> 元素：

• 作用： 配置产品的 config.ini 文件。
• 属性：
  • use: 指定是否使用默认的 config.ini 文件。

<launcherArgs> 元素：

• 作用： 配置产品启动器的参数。

<launcher> 元素：

• 作用： 配置产品的启动器（launcher）。
• 子元素：
  • <solaris>: 针对 Solaris 操作系统的配置。
  • <win>: 针对 Windows 操作系统的配置。

<splash> 元素：

• 作用： 配置产品的启动时闪屏。
• 属性：
  • location: 闪屏图片的位置。
  • product: 与闪屏相关联的产品 ID。
  • foregroundColor: 闪屏前景色。
  • backgroundColor: 闪屏背景色。

示例：

<extension
     point="org.eclipse.core.runtime.products">
  <product
        id="com.example.myProduct"
        name="My Product"
        application="org.eclipse.ui.ide.workbench"
        version="1.0.0"
        definitionFile="product/plugin.xml"
        description="My Eclipse Product">
    <configIni
          use="default">
    </configIni>
    <launcherArgs>
    </launcherArgs>
    <launcher>
      <win
           useIco="false">
         <bmp/>
      </win>
    </launcher>
    <splash
        location="platform:/base/plugins/com.example.myProduct/splash.bmp"
        product="${eclipse.product}"
        foregroundColor="0,0,0"
        backgroundColor="255,255,255">
    </splash>
  </product>
</extension>

在上述示例中，<product> 元素定义了一个产品，具有唯一标识符 com.example.myProduct、显示名称 “My Product”，关联的应用程序为 org.eclipse.ui.ide.workbench，版本为 “1.0.0”，定义文件路径为 “product/plugin.xml”，描述为 “My Eclipse Product”。<configIni> 元素指定了使用默认的 config.ini 文件。<launcher> 元素配置了产品的启动器，其中 <win> 子元素指定了在 Windows 操作系统上的配置。<splash> 元素配置了产品的启动时闪屏，指定了图片位置、前景色和背景色。

通过使用 org.eclipse.core.runtime.products 扩展点，开发者可以在 Eclipse IDE 中定义和配置产品，以创建独立的 Eclipse 应用程序。这有助于定制化 Eclipse 平台，以满足特定应用场景的需求。

API Information:

此处提供的静态产品扩展在运行时由IProduct实例表示。动态产品扩展必须标识IProductProvider的实现者。有关EclipseUI定义的与品牌相关的产品属性的详细信息，请参阅org. eclipse.ui.brand.IProduct常量。