Oracle® Fusion Middleware

Oracle JDeveloper拡張機能の開発

12c (12.2.1.2)

E82761-01(原本部品番号:E76674-01)

2016年9月

JDeveloperに対するダウンロード可能な拡張機能を、内部のチームをサポートするプラグイン機能を追加して、またはサード・パーティ製アプリケーションの一部として開発する方法について説明する、Oracle JDeveloperユーザーのためのドキュメントです。

Oracle Fusion Middleware Oracle JDeveloper拡張機能の開発、12c (12.2.1.2)

E82761-01

Copyright © 2014, 2016, Oracle and/or its affiliates All rights reserved.

原本著者: Akhilesh Swarnkaar

原本協力著者: Catherine Pickersgill

このソフトウェアおよび関連ドキュメントの使用と開示は、ライセンス契約の制約条件に従うものとし、知的財産に関する法律により保護されています。ライセンス契約で明示的に許諾されている場合もしくは法律によって認められている場合を除き、形式、手段に関係なく、いかなる部分も使用、複写、複製、翻訳、放送、修正、ライセンス供与、送信、配布、発表、実行、公開または表示することはできません。このソフトウェアのリバース・エンジニアリング、逆アセンブル、逆コンパイルは互換性のために法律によって規定されている場合を除き、禁止されています。

ここに記載された情報は予告なしに変更される場合があります。また、誤りが無いことの保証はいたしかねます。誤りを見つけた場合は、オラクル社までご連絡ください。

このソフトウェアまたは関連ドキュメントを、米国政府機関もしくは米国政府機関に代わってこのソフトウェアまたは関連ドキュメントをライセンスされた者に提供する場合は、次の通知が適用されます。

U.S. GOVERNMENT END USERS: Oracle programs, including any operating system, integrated software, any programs installed on the hardware, and/or documentation, delivered to U.S. Government end users are "commercial computer software" pursuant to the applicable Federal Acquisition Regulation and agency-specific supplemental regulations.As such, use, duplication, disclosure, modification, and adaptation of the programs, including any operating system, integrated software, any programs installed on the hardware, and/or documentation, shall be subject to license terms and license restrictions applicable to the programs.No other rights are granted to the U.S. Government.

このソフトウェアまたはハードウェアは様々な情報管理アプリケーションでの一般的な使用のために開発されたものです。このソフトウェアまたはハードウェアは、危険が伴うアプリケーション(人的傷害を発生させる可能性があるアプリケーションを含む)への用途を目的として開発されていません。このソフトウェアまたはハードウェアを危険が伴うアプリケーションで使用する際、このソフトウェアまたはハードウェアを安全に使用するために、適切な安全装置、バックアップ、冗長性(redundancy)、その他の対策を講じることは使用者の責任となります。このソフトウェアまたはハードウェアを危険が伴うアプリケーションで使用したことに起因して損害が発生しても、オラクル社およびその関連会社は一切の責任を負いかねます。

OracleおよびJavaはOracle およびその関連企業の登録商標です。その他の名称は、それぞれの所有者の商標または登録商標です。

Intel、Intel Xeonは、Intel Corporationの商標または登録商標です。すべてのSPARCの商標はライセンスをもとに使用し、SPARC International, Inc.の商標または登録商標です。AMD、Opteron、AMDロゴ、AMD Opteronロゴは、Advanced Micro Devices, Inc.の商標または登録商標です。UNIXはThe Open Groupの登録商標です。

このソフトウェアまたはハードウェア、そしてドキュメントは、第三者のコンテンツ、製品、サービスへのアクセス、あるいはそれらに関する情報を提供することがあります。適用されるお客様とOracle Corporationとの間の契約に別段の定めがある場合を除いて、Oracle Corporationおよびその関連会社は、第三者のコンテンツ、製品、サービスに関して一切の責任を負わず、いかなる保証もいたしません。適用されるお客様とOracle Corporationとの間の契約に定めがある場合を除いて、Oracle Corporationおよびその関連会社は、第三者のコンテンツ、製品、サービスへのアクセスまたは使用によって損失、費用、あるいは損害が発生しても一切の責任を負いかねます。

目次

タイトルおよび著作権情報

はじめに

- 対象読者

- 関連ドキュメント

- 表記規則

- ドキュメントのアクセシビリティについて

このガイドで説明する新機能

- 12c (12.2.1.2)の新機能と変更された機能

1 Oracle JDeveloper拡張機能の開発の概要

- 1.1 Oracle JDeveloper拡張機能の開発について

- 1.2 OSGiを使用した拡張機能の開発

- 1.2.1 サービス/コンポーネント・プラットフォーム

- 1.2.2 デプロイメント・インフラストラクチャ

- 1.3 JDeveloper拡張機能の仕組み

- 1.3.1 拡張機能の処理方法

- 1.3.2 拡張機能の登録とトリガー・フックの使用

- 1.3.3 遅延初期化の仕組み

- 1.4 以前のリリースからの拡張機能の移行

- 1.5 拡張機能開発のスタートガイド

- 1.5.1 拡張機能開発用のアプリケーションおよびプロジェクトの作成方法

- 1.5.2 異なるJDeveloperバージョンを考慮した開発方法

- 1.5.3 次のステップ

- 1.6 拡張機能マニフェストの操作

- 1.6.1 概要エディタでの拡張機能マニフェストの編集

- 1.6.2 ソース・エディタでの拡張機能マニフェストの編集

- 1.7 OSGiマニフェストの操作

- 1.7.1 依存関係について

- 1.7.1.1 拡張機能マニフェストでの依存関係の設定方法

- 1.7.1.2 OSGiバンドル・プロファイルでの依存関係の設定方法

2 Oracle JDeveloperでの拡張機能の開発

- 2.1 Oracle JDeveloperでの拡張機能の開発について

- 2.2 拡張機能開発のユースケース

- 2.2.1 ルール・ベースのメニュー秘密度について

- 2.2.1.1 複雑なController.update()の実装を回避する方法

- 2.2.2 動的メニュー・ラベルおよびアイコンの使用方法

- 2.2.2.1 メニュー・ラベルに短縮名を付加する方法

- 2.2.3 動的トップ・メニューの構築方法

- 2.2.4 ノード・レコグナイザについて

- 2.2.5 コンテンツ・セットについて

- 2.2.6 大規模な拡張機能について

- 2.2.7 テクノロジ・スコープについて

- 2.3 JDeveloperのルック・アンド・フィールの取得

- 2.4 JDeveloperの要素の作成

- 2.4.1 JDeveloperの要素を迅速に作成する方法

- 2.4.2 メニューの作成および変更方法

- 2.4.2.1 メニューについて

- 2.4.2.2 ポップアップ・メニューの作成方法

- 2.4.2.3 コンテキスト・メニュー・リスナーを登録してパフォーマンスを改善する方法

- 2.4.2.4 既存のJDeveloperメニューにメニュー・アイテムを追加する方法

- 2.4.2.5 ツールバーにドロップダウン・ボタンを追加する方法

- 2.4.3 ウィンドウとビューの操作

- 2.4.3.1 ドッキング可能ウィンドウについて

- 2.4.3.2 単純なドッキング可能ウィンドウの作成方法

- 2.4.3.3 ドッキング可能ウィンドウの配置方法

- 2.4.3.4 IDEリスナーをビューに追加する方法

- 2.4.3.5 アクティブ・ビューのリスニング方法

- 2.4.4 ウィザードの開発方法

- 2.4.4.1 ウィザード・プロジェクトの設定方法

- 2.4.4.2 ウィザード・インタフェースの実装方法

- 2.4.4.3 新規ギャラリにウィザードを追加する方法

- 2.4.5 コマンドの開発方法

- 2.4.5.1 Addinインタフェースの実装方法

- 2.4.5.2 コマンドの実装方法

- 2.4.5.2.1 イベントの処理

- 2.4.5.2.2 undoメソッドの定義方法

- 2.4.5.2.3 その他のメソッドの定義方法

- 2.4.5.3 アクションの定義方法

- 2.4.5.3.1 アクションの取得方法

- 2.4.5.3.2 アクション値の設定方法

- 2.4.5.3.3 アクションのコントローラの拡張方法

- 2.4.5.3.4 アクションのコマンド・クラスの拡張

- 2.4.5.4 メイン・ウィンドウ・メニューからアドインを呼び出す方法

- 2.4.5.5 コンテキスト・メニューからアドインを呼び出す方法

- 2.4.6 エディタの開発方法

- 2.4.6.1 非同期エディタの使用

- 2.4.6.1.1 非同期エディタの仕組み

- 2.4.7 エクスプローラの開発方法

- 2.4.7.1 エクスプローラの作成方法

- 2.4.7.2 構造エクスプローラの登録および初期化方法

- 2.4.7.3 構造エクスプローラ要素モデルの作成方法

- 2.4.7.4 構造エクスプローラの更新方法

- 2.4.8 新しい「コンポーネント」ウィンドウのページを追加する方法

- 2.4.8.1 「コンポーネント」ウィンドウのページについて

- 2.4.8.2 「コンポーネント」ウィンドウの静的コンテンツを宣言する方法

- 2.4.8.3 「コンポーネント」ウィンドウ・ページの動的コンポーネントを宣言する方法

- 2.4.8.4 「コンポーネント」ウィンドウ・ページのヘルプを用意する方法

- 2.4.8.5 「コンポーネント」ウィンドウ・アイテムの検索を補強する方法

- 2.4.9 プリファレンスについて

- 2.4.9.1 プリファレンスの実装方法

- 2.4.9.2 データ・モデルの実装方法

- 2.4.9.3 UIパネルの実装方法

- 2.4.9.4 UIペインの登録方法

- 2.4.9.5 プリファレンス・モデルの取得方法

- 2.4.9.6 変更のリスニング方法

- 2.4.10 プロジェクト・プロパティについて

- 2.4.10.1 プロジェクト・プロパティの共有方法

- 2.4.11 変更をUNDO可能にする方法

- 2.4.11.1 テキスト変更をUNDO可能にする方法

- 2.4.11.2 コマンドをUNDO可能にする方法

- 2.5 トリガー・フックの定義および使用

- 2.5.1 <trigger-hook-handler>の登録方法

- 2.5.2 拡張機能のトリガー・フックを定義する方法

- 2.5.3 ExtensionRegistryから解析済情報を取得する方法

- 2.5.4 ルールおよび条件トリガー・セクションの定義方法

- 2.5.4.1 ルールの定義方法

- 2.5.4.2 単純なルールの定義方法

- 2.5.4.3 暗黙に使用できるルール

- 2.5.4.4 ルールのガイドライン

- 2.5.4.5 複合ルールの定義方法

- 2.5.4.6 フックからルールを参照する方法

- 2.5.4.7 ルール参照の検証方法とルールの評価方法

- 2.6 オンライン・ヘルプ・サポートの追加

- 2.6.1 ヘルプ・システムの作成方法

- 2.6.2 ヘルプ・システムの登録方法

- 2.7 印刷サポートの追加

- 2.7.1 DocumentPrintFactoryの登録方法

- 2.7.2 ビュー・クラスを登録して印刷を有効化する方法

- 2.7.2.1 ノード処理のためのPageableFactory実装を登録する方法

- 2.8 アプリケーションまたはプロジェクト・テンプレートの作成

- 2.8.1 アプリケーションまたはプロジェクト・テンプレートの定義

- 2.8.1.1 テンプレート・フックの定義

- 2.8.1.2 プロジェクト・テンプレートを作成する方法

- 2.8.1.3 アプリケーション・テンプレートの作成方法

- 2.8.2 テンプレートの登録

- 2.8.2.1 作成リスナーの登録

- 2.8.3 新規アプリケーションまたはプロジェクト・ウィザードにテクノロジのページを追加するには

- 2.8.4 アプリケーション・テンプレートへのページの追加方法

3 Extension SDKを使用した開発

- 3.1 Extension SDKを使用した開発について

- 3.2 Extension SDKのダウンロードとインストール

- 3.2.1 Extension SDKインストール時の処理内容

- 3.2.2 Extension SDKのインストールに関するトラブルシューティング

- 3.3 サンプル拡張機能の使用

- 3.4 サンプル・プロジェクトの実行

4 拡張機能のテストとデバッグ

- 4.1 拡張機能のテストとデバッグについて

- 4.2 拡張機能コードのデバッグ

- 4.2.1 JDeveloper拡張機能の実行方法

- 4.2.2 JDeveloper拡張機能のデバッグ方法

- 4.3 デバッグのトラブルシューティング

5 拡張機能のパッケージ化とデプロイ

- 5.1 拡張機能のパッケージ化とデプロイについて

- 5.2 拡張機能のパッケージ化

- 5.2.1 デプロイメント・プロファイルの作成方法

- 5.2.2 OSGiバンドルの作成方法

- 5.3 拡張機能のデプロイ

- 5.4 更新センターで拡張機能を公開する方法

- 5.4.1拡張機能bundle.xml文書

- 5.4.2 更新センターXML文書

A Extension SDKとともにインストールされる要素

- A.1 ファイル・システムにインストールされる要素

- A.2 IDEにインストールされる要素

B Extension SDKのアンインストール

- B.1 Extension SDKのアンインストールについて

- B.2 Extension SDKを無効化する方法

- B.3 サンプル・アプリケーションの削除方法

- B.4 Extension SDKのアンインストール方法

はじめに

Oracle Fusion Middleware Oracle JDeveloper拡張機能の開発へようこそ。

対象読者

このドキュメントは、Oracle JDeveloper拡張機能を開発または使用する開発者を対象としています。

関連ドキュメント

- Oracle Fusion Middleware Oracle JDeveloperのインストール

- Oracle Fusion Middleware Oracle JDeveloperでのアプリケーションの開発

- Oracle Fusion Middleware Oracle Application Development FrameworkによるFusion Webアプリケーションの開発

- Oracle Fusion Middleware Oracle ADF FacesによるWebユーザー・インタフェースの開発

- Oracle JDeveloper 12cオンライン・ヘルプ

- Oracle JDeveloper 12cリリース・ノート(Oracle JDeveloperインストール内のリンクおよびOracle Technology Networkから入手)

表記規則

このマニュアルでは次の表記規則を使用します。

表記規則

意味

太字

太字は、操作に関連するGraphical User Interface要素、または本文中で定義されている用語および用語集に記載されている用語を示します。

イタリック体

イタリックは、ユーザーが特定の値を指定するプレースホルダ変数を示します。

固定幅フォント

固定幅フォントは、段落内のコマンド、URL、サンプル内のコード、画面に表示されるテキスト、または入力するテキストを示します。

ドキュメントのアクセシビリティについて

Oracleのアクセシビリティへの取り組みについては、Oracle Accessibility ProgramのWebサイト(http://www.oracle.com/pls/topic/lookup?ctx=acc&id=docacc)にアクセスしてください。

Oracleサポートへのアクセス

サポートを購入したオラクル社のお客様は、My Oracle Supportを介して電子的なサポートにアクセスできます。詳細は、http://www.oracle.com/pls/topic/lookup?ctx=acc&id=info、聴覚に障害があるお客様はhttp://www.oracle.com/pls/topic/lookup?ctx=acc&id=trsを参照してください。

このガイドで説明する新機能

次のトピックでは、Oracle JDeveloperの新機能や変更された機能について、およびこのガイドに記載されるその他の重要な変更について紹介し、詳細情報へのリンクを提供します。このドキュメントは、Oracle Fusion Middleware Oracle JDeveloper拡張機能の開発の新しいエディションです。

注意:

このバージョンのガイドに記載されている内容は、最新ではない場合があります。最新バージョンを表示するには、ライブラリdocs.oracle.com/middlewareから直接ガイドにアクセスします。より新しいバージョンに追加された内容を確認するには、各ガイドの新情報に関する項を参照してください。

12c (12.2.1.2)での新機能と変更された機能

Oracle JDeveloper 12c (12.2.1.2)には、このドキュメントで説明する次の新機能と変更された機能が含まれています。

- このリリースでは、大きな変更はありません。

1 Oracle JDeveloper拡張機能の開発の概要

JDeveloper統合開発環境(IDE)の拡張機能を開発することで、JDeveloperに追加機能を追加できます。

次の各項では、JDeveloper拡張機能の使用と開発の概要について説明します。

- Oracle JDeveloper拡張機能の開発について

- OSGiを使用した拡張機能の開発

- JDeveloper拡張機能の仕組み

- 以前のリリースからの拡張機能の移行

- 拡張機能開発のスタートガイド

- 拡張機能マニフェストの操作

- OSGiマニフェストの操作

1.1 Oracle JDeveloper拡張機能の開発について

Oracle JDeveloperは、Java、XML、WebサービスおよびSQLの最新の標準を使用してアプリケーションを構築するための統合開発環境(IDE)です。JDeveloperの基本機能の大半は拡張機能(基本のJDeveloper IDEに新機能を追加するソフトウェア・パッケージ)として実装されます。既存の拡張機能をJDeveloperに追加したり、JDeveloperのネイティブ機能をベースに拡張機能を作成したりすることで、自社の開発要件にあわせた新機能を提供できます。たとえば、次のような目的に使用できます。

- ワークフローを効率化する。

- サードパーティのチーム開発ツールを使用する。

- チーム固有のソフトウェア・パッケージを使用する。

- 監査拡張機能を使用して、開発上の標準やベスト・プラクティスへの準拠を強化する。

ダウンロードしてそのまま使用できる拡張機能も数多く提供されています。これには、Oracle製のものもあれば、サードパーティ製のものもあります。これらを使用することで、JDeveloperに新機能を提供し、その機能を独自の環境内で他のアプリケーションと統合できます。たとえば、JDeveloperで利用できるバージョン・コントロールやチーム作業システムの多くは、拡張機能として記述および配布されています。JDeveloperはオープン・アーキテクチャであるため、JDeveloperの「ヘルプ」メニューの「更新の確認」からダウンロードおよびインストールできます。または、次の場所から拡張機能をインストールすることもできます。

- Oracle Technology Network (OTN)のOracle JDeveloper Extensionsページ(http://www.oracle.com/technetwork/developer-tools/jdev/index-099997.html)。

- マシンからアクセス可能な場所にあるマニフェストを含む適切に構成されたZIPファイル

注意:

JDeveloperに拡張機能をインストールする際には、JDeveloperの「ヘルプ」メニューの「更新の確認」を使用することをお薦めします。これにより、使用しているJDeveloperのバージョンに一致する拡張機能バージョンのみが使用可能になります。

詳細は、Oracle Fusion Middleware Oracle JDeveloperによるアプリケーションの開発の拡張機能の操作を参照してください。

また、オープン・アーキテクチャであるため、固有のニーズに対応する必要がある場合や、自社の開発チームで使用している外部プロセスやツールにJDeveloperを統合する場合にも、独自の拡張機能を記述できます。メニュー・アイテムの追加、コンテキスト・メニューの作成、JDeveloperツールバーへの機能の組込み、データ・オブジェクトのビューを表示するドッキング可能なウィンドウの作成などを行うことができます。

注意:

JDeveloperによる拡張機能の処理方法は、Oracle JDeveloper 11.1.2.nnで変更されました。以前のバージョンのJDeveloperの拡張機能については、ご使用のバージョンのJDeveloperのオンライン・ヘルプを参照してください。

旧バージョンのJDeveloper用のOracle製拡張機能(Extension SDKを含む)および旧バージョンのJDeveloper用のサード・パーティ製拡張機能は、Oracle JDeveloper Extensionsページ(http://www.oracle.com/technetwork/developer-tools/jdev/index-099997.html)から入手できます。

旧バージョンのJDeveloper用に記述された拡張機能の移行については、「以前のリリースからの拡張機能の移行」で説明しています。

JDeveloperのネイティブ機能を使用して独自の拡張機能を開発することもできます。詳細は、「Oracle JDeveloperでの拡張機能の開発」を参照してください。

より高度な開発を行う場合には、JDeveloperの開発チームが開発した、JDeveloper Extension Software Development Kit (Extension SDK)を使用します。これには、サンプル・コードを含んだプロジェクトのコレクションや、拡張機能開発で使用されるクラスやその他の機能への参照を提供するExtension SDK APIについてのjavadoc生成ドキュメントが含まれています。より完全なドキュメントやサンプルが必要な場合には、JDeveloperの「ヘルプ」メニューの「更新の確認」から入手できます。内部チームに広範なサポートを提供する場合や、自社の顧客に提供する製品やサードパーティ製アプリケーションの一部として拡張機能を開発する場合など、高度な拡張機能開発を行う場合には、Extension SDKをダウンロードすることをお薦めします。詳細は、「Extension SDKを使用した開発」を参照してください。

OTNフォーラムのOracle JDeveloperページを使用すれば、拡張機能の開発について質問したり、ディスカッションに投稿したり、他のユーザーと情報を交換できます。OTNフォーラムのOracle JDeveloperページへは、https://forums.oracle.com/forums/forum.jspa?forumID=83からアクセスできます。

Extension SDKとは対照的に、JDeveloperではコーディングを必要としない外部ツールも使用可能です。次のことが可能です。

- コマンドライン・インタフェースを起動できます

- パラメータを渡すことができます

- JDeveloperにメニューを追加できます

外部ツールの詳細は、Oracle Fusion Middleware Oracle JDeveloperによるアプリケーションの開発のJDeveloperへの外部ツールの追加を参照してください。

1.2 OSGiを使用した拡張機能の開発

Open Services Gateway Initiative (OSGi)は、Javaランタイム環境上で実行されるサービス・プラットフォームの構築に関する仕様です。JDeveloperはOSGiに準拠する拡張機能のセットとして構築されているため、ユーザーが記述するすべての拡張機能もこの標準に準拠する必要があります。

OSGiの詳細は、http://www.osgi.orgから入手できる、OSGi Service Platform Core Specification Release 4, Version 4.2を参照してください。

OSGiフレームワークは、次の2つの主要な要素に分けられます。

- サービス/コンポーネント・プラットフォーム(サービス・プロバイダ、サービス・リクエスタおよびサービス・レジストリ)。

- デプロイメント・インフラストラクチャ(実装クラス、リソース、バンドル・メタデータおよびマニフェスト・ファイルを含んだサービス・バンドル)。

1.2.1 サービス/コンポーネント・プラットフォーム

サービス/コンポーネント・プラットフォームは、OSGi実装が既存のサービスをアクティブ化、非アクティブ化、更新およびアンインストールしたり、新しいサービスを動的にインストールできるようにするためのものです。

サービス/コンポーネント・プラットフォームは、次の3つのアクター間での対話をサポートしています。

1. サービス・プロバイダは、特定のサービスを提供し、サービス記述を公開します。

2. サービス・リクエスタは、サービスを検出し、サービス・プロバイダにバインドします。

3. サービス・レジストリは、登録されたサービス記述に基づいて、サービスの公開と検出を管理します。

OSGiサービスは、名前と値のペアで構成された可変数の属性(サービス・プロパティ)を持つ、Javaクラスまたはインタフェース(サービス・インタフェース)です。サービス・プロパティは、同じサービス・インタフェースを使用する複数のサービス・プロバイダを区別するのに使用されます。

サービス・レジストリがあることで、サービス・リクエスタはLDAPを使用してサービスを検出できるようになります。

サービス・リクエスタは、イベント・シグナルの変更(たとえば、サービス・レジストリ内にあるサービスの発行または取得)を、通知メカニズムを使用して受信できます。

1.2.2 デプロイメント・インフラストラクチャ

サービスは、サービス実装クラスおよびリソースを含んだサービス・バンドルにパッケージ化されます。これには、バンドル・メタデータを含んだマニフェスト・ファイルmanifest.mfも含められます。マニフェスト・ファイルには、サービス名、バージョンおよび依存性などの情報が含められます。

サービス・プロバイダとサービス・リクエスタは、論理エンティティでも物理エンティティでもあるサービス・バンドルの一部です。このバンドルにより、実行時のサービス依存性管理アクティビティが処理されます。アクティビティは次のとおりです。

- 公開

- 検出

- バインド

- バンドルにバインドされたサービスの動的可用性(受信または送信)に起因する変更への適応。

JDeveloperで作成された拡張機能は、OSGiサービス・バンドル内に含められます。

1.3 JDeveloper拡張機能の仕組み

この項では、拡張機能がJDeveloper内でどのように機能するかについて説明します。拡張機能のロード時には、ユーザーが使用している拡張機能のみがロードされます。これにより、起動時のパフォーマンス、全体的なメモリー使用およびJDeveloperの日常的動作が改善されます。次の説明には、ユーザーによってはあまり馴染みのない用語や概念が含まれています。

- JDeveloperユーザーは、自分が作業するロールを選択します。ロールには、そのロールに適用可能な拡張機能のセットが定義されているため、選択したロールによって、どのJDeveloper拡張機能がロードされるかが決定します。たとえば、JDeveloperのデフォルトのロールには、Studio Editionのすべての拡張機能が定義されています。

- 初期化とは、拡張機能初期化コードAddin.initialize()を呼び出す操作です。拡張機能の初期化によって、エンド・ユーザーが拡張機能の機能を実行しようとする際、拡張機能が適切に機能するためのあらゆる準備が整えられます。
初期化リストには、以前に初期化された拡張機能が記録されています。このリストを記録しているプロジェクトをユーザーが再度開くと、前回と同じ拡張機能のセットが初期化されます。

- トリガー・フックとは、拡張機能の初期化をトリガーするためのメカニズムを提供する、宣言的統合フックのセットです。これらは、拡張機能マニフェストextension.xmlの<trigger-hooks>セクションに定義されており、JDeveloperの起動時に処理されます。これは、使用する拡張機能が初期化されていない場合でも同様です。
JDeveloper IDEの起動時に必要となる、拡張機能のすべての情報(関与するギャラリ・アイテム、定義するJavaライブラリ、定義するノード・レコグナイザなど)は、トリガー・フック内に指定されている必要があります。

これに対し、拡張機能マニフェストの<hooks>セクションは、後で拡張機能が初期化される際に処理されます。

- 登録とは、拡張機能マニフェストのトリガー・フック・セクションを読み取ってキャッシュする操作です。

- 遅延初期化とは、トリガー・フックがアクティブ化されるまで初期化されない拡張機能について使用される用語です。

- 拡張機能のバージョニングは、OSGiによって管理されます。同じ拡張機能に2つ以上のバージョンがある場合、それらは同時にロードでき、その拡張機能がアクティブ化された際には、それに依存するすべての拡張機能もロードされます。OSGiは、特定のバージョンまたはバージョン範囲に応じて拡張機能の状況を処理します。

- 拡張機能は、自らのクラス・ローダーにロードされたクラスです。拡張機能には、他の拡張機能にエクスポートするパッケージのセットが定義されています。OSGiのバンドル・マニフェスト・ファイルには、他のバンドルから利用できるJavaパッケージが定義されています。制限されたクラスへは、リフレクションを使用してもアクセスできません。これは、OSGiが拡張機能のJavaクラス・ローダーを通じてこれらのクラスを保護しているためです。

- OSGiサービス・インフラストラクチャは、サービス・プロバイダおよびリクエスタを動的に管理します。

- 拡張機能には、他の拡張機能への依存性を持たせることができます。拡張機能のロード時には、OSGiバンドル・マニフェストで依存先としてマークされている他の拡張機能もすべてロードされます。これは、JDeveloperで機能のロードをクリックする際には常に起こりうる動作です。たとえば、「アプリケーション・プロパティ」、「プロジェクト・プロパティ」または「プリファレンス」ダイアログでは、以前にアクセスしたことのない機能を起動する場合、関連する拡張機能がロードされるのを待つ必要があります。

- JDeveloper拡張機能は、IDE用の標準拡張機能APIを提供する、JSR 198の仕様に準拠しています。詳細は、http://jcp.org/en/jsr/detail?id=198を参照。

1.3.1 拡張機能の処理方法

JDeveloperでの拡張機能の処理には、2つのフェーズがあります。

- 拡張機能の統合。これは、JDeveloperの起動時に実行されます。これは、選択されたロールで使用できるすべての拡張機能を登録する処理です。JDeveloperの起動に必要な拡張機能を除き、拡張機能コードは実行されません。

- 拡張機能の初期化。これは、拡張機能の登録フェーズ中に拡張機能によって登録された機能領域にユーザーがアクセスする際、毎回実行されます。そのため、JDeveloperの使用中に、拡張機能の初期化は随時実行されます。

1.3.2 拡張機能の登録とトリガー・フックの使用

拡張機能の登録は、JDeveloper IDEの起動時に実行されるフェーズです。このフェーズでは、利用可能なすべての拡張機能から拡張機能マニフェストextension.xmlの<trigger hooks>セクションが処理されます。この処理中、拡張機能固有のコードは一切実行されません。ただし、Javaリソース・バンドルなどの変化可能リソースについては例外です。

拡張機能には、<trigger-hook>統合フックを使用して、拡張機能固有のトリガー・フックが定義されている場合があります。その場合、その拡張機能にはoracle.ide.extension.HashStructureHookハンドラが使用される必要があります。なぜなら、IDEは拡張機能が初期化されないかぎり拡張機能固有のコードを実行しないからです。拡張機能固有のトリガー・フック・データは、拡張機能レジストリ内で取得できます。トリガー・フックを所有している拡張機能は、その拡張機能が初期化されたときにそのデータを取得できます。詳細は、「<trigger-hook-handler>の登録方法」を参照してください。

これに対し、拡張機能マニフェストextension.xmlの<trigger hooks>セクションに属さないその他のアイテムは、拡張機能の初期化フェーズで宣言的に初期化されます。

トリガー・フックには2つのタイプ(システムとカスタム)があり、すべての拡張機能は次のいずれかの方法で初期化されます。

- システム・トリガー・フックから呼び出される

- カスタム・トリガー・フックから呼び出される

- すでに初期化されている別の拡張機能によって明示的に初期化される

JDeveloper IDEによって定義されているトリガー・フックのタイプは次のとおりです。

- メニュー: 拡張機能へのエントリ・ポイントとして適格なメニューのみをメニュー・トリガー・フックとすることができ、すでに初期化された拡張機能をサポートするために使用されているメニューはトリガー・フックとすることはできません。たとえば、JDeveloperの表示メニューでは、メニュー・アイテム「ブレークポイント」はトリガー・フックです。これは、ユーザーがデバッガの実行前にブレークポイントを設定できるようにするためです。これに対し、表示メニューの「デバッガ」サブメニューは、その中のすべてのアイテムが拡張機能の初期化後にのみ使用されるため、トリガー・フックではありません。つまり、初期化されていない拡張機能のメニュー・アイテムは、JDeveloperでは表示されません。

- コンテキスト・メニュー: 拡張機能では、コンテキスト・メニューをトリガーとして使用するカスタム・トリガー・フックを作成できます。システムレベルのコンテキスト・メニュー・トリガー・フックはありません。

- IDEアクションおよびコントローラ: 登録できるのは、メニュー・トリガー・フックをサポートするためのアクションおよびコントローラのみです。その他すべてのアクションとコントローラは、初期化フェーズで実行する必要があります。トリガー・フック・メニューに登録されたすべてのコントローラでは、それらのメニューが無効化されているかどうかを確認するためのコードを実行できなくなります。メニューをいつ表示するかは、宣言的コントローラ・ロジックを使用して指定する必要があります。

- ギャラリ・アイテム: 拡張機能では、ギャラリ・アイテム・トリガー・フックを使用して、JDeveloperの「新規ギャラリ」内のアイテムをリストできます。ユーザーが「新規ギャラリ」からダイアログまたはウィザードを開くと、そのアイテムの拡張機能が初期化され、その拡張機能のOSGiバンドル・マニフェストで依存先としてマークされているすべての拡張機能もロードされます。

- テクノロジ・スコープ: プロジェクトにテクノロジ・スコープが追加されると、そのテクノロジ・スコープを登録した拡張機能が初期化され、OSGiバンドル・マニフェストで依存先としてマークされているその他すべての拡張機能も初期化されます。

- NodeFactoryレコグナイザ: これを使用することで、拡張機能は自身が所有するノードを識別できます。ノードが「アプリケーション」ウィンドウ内で可視状態になったとき、そのノードの拡張機能が登録されていれば、そのノードは初期化されます。NodeFactoryレコグナイザはまた、デスクトップからJDeveloperへのファイル・ドラッグなどといった操作も処理します。

- IDEプリファレンス/設定、アプリケーション・プリファレンス/設定、プロジェクト・プリファレンス/設定: 未初期化の拡張機能は、「プリファレンス」ダイアログ(「ツール」メニューから選択可能)のカテゴリ・リストとしてのみ表示されます。ユーザーがカテゴリをクリックすると、その時点で拡張機能を初期化するかどうかが尋ねられます。

- シングルトン登録: シングルトン・クラスは、トリガー・フックとして登録されます。クライアントがシングルトンからサービスをリクエストすると、フレームワークはそのシングルトンの拡張機能が初期化されているかどうかをチェックします。初期化されていない場合は、拡張機能の初期化が要求されます。この例としては、ログ・マネージャが該当します。

- 注釈: 拡張機能は、注釈トリガー・フックを必要とするように自身を登録できます。その場合、拡張機能には注釈クラス名が定義され、ユーザーがそれらのいずれかの注釈を入力すると、その時点で拡張機能が初期化されます。注釈トリガー・フックは、「アプリケーション」ウィンドウ・ノードの展開時にアイコンのオーバーレイを判断するために使用されます。親ノードが展開されると、フレームワークは登録されている注釈を検索し、見つかった場合は、そのノードに対する適切なアイコンを提供します。ノード・アイコンのオーバーレイが適用された場合、拡張機能は初期化されません。

- アプリケーションおよびプロジェクト・マイグレータ: これらのマイグレータは、宣言的に定義される必要があります。マイグレータは、サポートされている現行バージョンを指定します。アプリケーションまたはプロジェクト・ファイルに旧バージョンのマイグレータがリストされているか、いずれのバージョンもリストされていない場合、JDeveloperはその拡張機能のデータを移行するために、拡張機能の初期化をトリガーします。

- ライブラリおよびタグ・ライブラリ: ライブラリまたはタグ・ライブラリがプロジェクトに追加されると、関連付けられている拡張機能の初期化がトリガーされます。さらに、プロジェクトが(ロードではなく)開かれると、JDeveloperはそのプロジェクトのライブラリを検索し、それらがまだロードされていなければ、そのライブラリまたはタグ・ライブラリに関連付けられている拡張機能を自動的にロードします。

- カスタム・トリガー・フック: 拡張機能では、独自のトリガー・フックを定義できます。これは、クライアントがその拡張機能にプラグインできるようにする場合に便利です。拡張機能でのトリガー・フックの定義は、通常のフック定義と同様の方法で行えます。これを定義すると、クライアント拡張機能は自身の拡張機能マニフェスト内にトリガー・フック登録を追加できるようになります。トリガー・フックを登録する際、拡張機能には、どの拡張機能のロード時にトリガーが発効されるようにするかが指定されます。これらはフックの依存先と呼ばれます。JDeveloperは、フックの依存先としてリストされているすべての拡張機能が初期化されたときにのみ、そのフックを処理します。

1.3.3 遅延初期化の仕組み

拡張機能の遅延初期化は、JDeveloperが起動するたびにすべての拡張機能が初期化されるのを回避する目的で使用されます。

- JDeveloperの起動時、IDEは、現在開いているアプリケーションまたはプロジェクト内で、Addinを所有する拡張機能がエンド・ユーザーによって以前に使用されている場合にのみ、Addin.initialize()コードを実行します。詳細は、「ノード・レコグナイザについて」を参照してください。

- 各拡張機能は、自身のトリガー・フックに関連付けられているタイプを識別します。これにより、フックに対する次のような処理が可能になります。

- 開いているアプリケーション・ワークスペースがある場合にのみトリガーできます。

- 開いているプロジェクトがある場合にのみトリガーできます。

- HTTPアナライザなどと同様の方法でいつでも初期化できます。

- ユーザーがJDeveloper内のアプリケーションで作業する際、ユーザーによる拡張機能の使用は、プロジェクト固有の拡張機能初期化リストに記録されます。ユーザーがプロジェクトでの作業をやめてJDeveloperを終了し、その後再起動した際、JDeveloperはプロジェクトの初期化リストに記録された拡張機能のみを初期化します。
プロジェクトを必要としない拡張機能の場合、この情報はそのユーザーのIDEプリファレンス内に格納されます。

拡張機能を開発する際には、統合ポイントで遅延初期化がどのように処理されるかを考慮する必要があります。次に例を示します。

- 拡張機能では、統合ポイントが静的であることを前提にすることはできません。拡張機能は、そのライフサイクル中、自身の統合ポイントに関連付けられた新しいデータを、いつでも処理および統合できる必要があります。
たとえば、拡張機能Aに、他の拡張機能がリスナー・クラスを登録できるようにするためのAPIまたはカスタム拡張機能フックがあるとします。その場合、拡張機能Aでは、それらすべてのリスナーが拡張機能Aの初期化よりも早い時点で登録されることを前提にすることはできません。Aに依存する他の拡張機能は、ABCのライフサイクル内のより遅いタイミングで遅延初期化される可能性があります。したがって拡張機能Aは、それらのリスナーに関連付けられたイベント起動コードを更新して、拡張機能の遅延ロードの結果に対応する必要があります。これを行う具体的な方法については、次の点で説明します。

- 拡張機能では、oracle.ide.extension.HashStructureHookを使用してカスタム統合フックを実装する必要があります。このフック処理クラスには、新しい追加データがいつ登録されたかをクライアントがわかるようにするための、プロパティ変更リスナー・メカニズムがあります。拡張機能に、これらのプロパティ変更イベントをリスニングさせる必要があります。

- 深い依存関係ツリーを設定することは避ける必要があります。なぜなら、これによって依存先のすべての拡張機能が初期化され、拡張機能の遅延ロードによるパフォーマンス効果が弱まる可能性があるからです。拡張機能の依存関係ツリーが深いことに気づいた場合は、拡張機能をリファクタリングして、依存先の拡張機能の数を減らす必要があります。詳細は、「大規模な拡張機能について」を参照してください。

1.4 以前のリリースからの拡張機能の移行

旧バージョンのJDeveloper用に開発した拡張機能がある場合は、現行リリースのJDeveloperで実行できるように変更を加える必要があります。「拡張機能の仕組み」では、現行リリースのJDeveloperで拡張機能がどのように機能するかが説明されています。最初に、ここで説明されている概念について理解することをお薦めします。

考慮する必要があるコーディング領域は次のとおりです。

- Addin.initializeメソッドは、IDEの起動時に呼び出されなくなりました。トリガー・フックを使用して拡張機能を初期化する必要があります。トリガー・フックは、拡張機能マニフェストextension.xml内で定義されます。JDeveloper IDEによって定義されているトリガー・フック・タイプのいずれかを使用でき、カスタム・トリガー・フックも作成できます。詳細は、「トリガー・フックの定義および使用」を参照してください。

- 拡張機能マニフェストextension.xml内のほぼすべての<hooks>プロパティは、<trigger hooks>内に配置されるようになりました。

- 旧バージョンのJDeveloperでは、ロール・ファイルは排他的に使用されていたため、デフォルトではすべての拡張機能がロードされ、ロードしないものはロール・ファイルによってJDeveloperに伝えられていました。現行バージョンでは、ロール・ファイルは包含的に使用されるようになったため、ロールに定義されている拡張機能だけを、そのトリガー・フックのアクティベート時にロードできるようになりました。

- すべての拡張機能が個別のクラス・ローダーを持つようになりました。その結果、パッケージ保護されたメソッドを、同じパッケージ内の異なる拡張機能のクラスから呼び出すメソッドは機能しなくなりました。

- 拡張機能にカスタム統合ポイントがある場合は、それらに変更を加えて、オンデマンドの拡張機能初期化を処理できるようにする必要があります。詳細は、「遅延初期化の仕組み」を参照してください。

- リフレクションを使用して、明示的依存関係を持たない拡張機能内のクラスを初期化するコードは、機能しなくなりました。

「拡張機能開発のユースケース」には、拡張機能を変換して、遅延初期化をサポートする宣言的トリガー・フックを使用できるようにする場合の、よく起こる状況を示すユースケースが多数記載されています。

1.5 拡張機能開発のスタートガイド

JDeveloperのネイティブ機能を使用して拡張機能を作成する場合(「Oracle JDeveloperでの拡張機能の開発」を参照)も、Extension SDKをダウンロードして拡張機能を開発する場合(「Extension SDKを使用した開発」を参照)も、最初に行うことは、拡張機能開発用に構成された1つ以上のプロジェクトとアプリケーションをJDeveloperで作成することです。

1.5.1 拡張機能開発用のアプリケーションおよびプロジェクトの作成方法

アプリケーションは、1つ以上のプロジェクトに対する制御構造です。プロジェクトは、プログラムまたはプログラムの一部を定義する一連のファイルの論理コンテナです。詳細は、Oracle Fusion Middleware Oracle JDeveloperによるアプリケーションの開発のアプリケーションとプロジェクトの操作についてを参照してください。

アプリケーションとプロジェクトを作成するには、次のようにします。

1. 「ファイル」→「新規」を選択して「新規ギャラリ」を開きます。

2. 「新規ギャラリ」の「カテゴリ」ツリーで、「一般」の「アプリケーション」を選択します。

3. 「アイテム」リストで、「拡張機能アプリケーション」をダブルクリックします。拡張機能アプリケーションの作成ウィザードが開きます。ウィザードのヘルプを参照するには、[F1]を押すか「ヘルプ」をクリックします。

4. アプリケーションの名前を入力し、場所とアプリケーション・パッケージ接頭辞を選択して、「次へ」をクリックします。拡張機能開発用に構成されるプロジェクトは、Extensionというデフォルト名を持っています。必要に応じて、プロジェクト名を変更し、「次へ」をクリックします。

5. Java設定の構成ページで、デフォルト・パッケージ、Javaソース・パスおよび出力ディレクトリを設定できます。必要な変更加えて、「次へ」をクリックします。

6. 拡張機能設定の構成ページで、拡張機能のオプションを設定できます。

図1-1に示すように、「アプリケーション」ウィンドウ内に拡張機能プロジェクトが作成され、その中に各要素が含められます。

図1-1 「アプリケーション」ウィンドウの拡張機能プロジェクト

拡張機能プロジェクトは、拡張機能マニフェストextension.xmlおよびOSGiマニフェストmanifest.mfのコピーとともに作成されます。拡張機能マニフェストは概要エディタで開かれます。

なんらかの理由で、拡張機能アプリケーションを直接作成しない場合は、カスタム・アプリケーションを作成して、ウィザードの「プロジェクト」ページでプロジェクト機能として「拡張機能の開発」を選択することができます。

1.5.2 異なるJDeveloperバージョンを考慮した開発方法

異なるJDeveloperバージョン用の拡張機能を開発する場合は、拡張機能アプリケーションの作成時にプラットフォームを選択します。

注意:

JDeveloperの複数のリリースに対する拡張機能は、そのバージョンが両方とも同じメジャー・リリースのマイナー・リリースである場合にのみ開発できます。たとえば、JDeveloperバージョン11.1.2.nnは、他の11.1.2.nnバージョンで機能します。12.1.2.nnを使用している場合、他の12.1.2.nnリリースと連携する拡張機能のみを開発できます。

JDeveloperの拡張機能の記述方法は、JDeveloper 11gリリース11.1.2.nnで変更されました。以前のバージョンのJDeveloperの拡張機能を開発する場合は、そのバージョンのJDeveloperのドキュメントを参照してください。

拡張機能が対象とするJDeveloperバージョンを選択するには:

1. 拡張機能アプリケーションを作成します。「拡張機能開発用のアプリケーションおよびプロジェクトの作成方法」を参照してください。

2. 拡張機能設定の構成ページで、異なるターゲット・プラットフォームを選択します。必要に応じて、拡張機能プラットフォームの管理アイコンをクリックし、拡張機能プラットフォームの管理ダイアログでプラットフォームを選択します。詳細は、[F1]を押すか、ダイアログ内で「ヘルプ」をクリックしてください。

1.5.3 次の手順

アプリケーションとプロジェクトを作成したら、拡張機能の開発を開始できます。

- JDeveloper IDEでの開発を継続する場合(たとえば、拡張機能Addinを作成する場合など)は、「Oracle JDeveloperでの拡張機能の開発」を参照してください。

- Extension SDK内のサンプルを使用して拡張機能を作成する場合やExtension SDK APIを使用する場合は、「Extension SDKを使用した開発」を参照してください。

1.6 拡張機能マニフェストの操作

拡張機能マニフェストextension.xmlは、拡張機能の様々な性質を制御します。拡張機能をデプロイする前に、extension.xmlを完成させて、トリガー・フックの登録などを済ませる必要があります。extension.xmlは、1つのプロジェクトにつき1つのみ作成でき、常にMETA-INFというディレクトリ内に置く必要があります。

拡張機能マニフェストは、JSR-198仕様(http://jcp.org/aboutJava/communityprocess/final/jsr198/index.htmlから入手可能)に準拠しています。

フックおよびトリガー・フックは、拡張機能マニフェストの関連セクション内に設定されます。extension.xmlの<hooks>セクションは、拡張機能が初期化される際に処理されます。<trigger-hooks>セクションは、JDeveloperの起動時に処理されます。

JDeveloperには、extension.xml専用の概要エディタがあります(図1-2を参照)。

図1-2 概要エディタに表示されたextension.xml

extension.xmlの編集は、概要エディタを使用して行います。このエディタでは、依存関係などに関する詳細情報を各フィールドに入力したり、利用可能なオブジェクトのリストからオブジェクトを選択でき、また、「構造」ウィンドウや「プロパティ・インスペクタ」を使用することもできます。概要エディタでは操作できないextension.xmlの情報を編集するには、「構造」ウィンドウを使用するか、extension.xmlのソース内で作業します。ソースにアクセスするには、「ソース」タブをクリックします。

依存関係に関する詳細は、「依存関係について」を参照してください。

拡張機能プロジェクトの作成により作成されるextension.xmlのテンプレート・コードには、次の例に示すように、主要要素のプレースホルダが記述されます。

<extension id="extension" version="1.0.0" esdk-version="2.0" rsbundle-class="extension.Res"
xmlns="http://jcp.org/jsr/198/extension-manifest">
<name>${EXTENSION_NAME}</name>
<owner>${EXTENSION_OWNER}</owner>
<trigger-hooks xmlns="http://xmlns.oracle.com/ide/extension">
<!-- TODO Declare triggering functionality provided by extension: extension -->
<triggers/>
</trigger-hooks>
<hooks>
<!-- TODO Declare functionality provided by extension: extension -->
</hooks>
</extension>

1.6.1 概要エディタでの拡張機能マニフェストの編集

extension.xmlの概要エディタは、拡張機能マニフェストextension.xmlとOSGIマニフェストmanifest.mfを宣言的に更新します。

extension.xmlの概要エディタの「一般」タブでは、拡張機能に関する情報(拡張機能名、SDKバージョンなど)を入力したり、アイコンや著作権情報などの機能を指定します。これらの情報は、feature-hookおよびplatform-info要素に移入されます。

「ランタイム」タブはmanifest.mfを更新し、ランタイム値を指定できます。

「依存性」タブでは、その拡張機能を別の拡張機能の一部として指定したり、別の拡張機能の親として指定したりできます。これらの情報は、dependencies要素に移入されます。「フック」タブでは、拡張機能の機能に関連する、追加の拡張機能の詳細情報を入力します。詳細は、「依存関係について」を参照してください。

拡張機能のIDEへのバインド方法を指定するには、「フック」タブを使用します。

「フック・ハンドラ」タブを使用すると、他の拡張機能が統合ポイントとして使用できる、拡張機能のトリガー・フックを定義することができます。

各フィールドの内容に関する詳しいヘルプを参照するには、概要エディタの任意のタブから[F1]を押します。

1.6.2 ソース・エディタでの拡張機能マニフェストの編集

拡張機能マニフェストをソース・エディタで編集するには、XMLエディタを使用します。これは、コード・インサイトやXML検証など、様々な編集機能を備えた、スキーマ・ドリブンの専用エディタです。詳細は、Oracle Fusion Middleware Oracle JDeveloperによるアプリケーションの開発のXMLエディタの使用を参照してください。

1.7 OSGiマニフェストの操作

OSGiマニフェストMANIFEST.MFには、拡張機能バンドルがエクスポートするパッケージがリストされます。MANIFEST.MFは、1つのプロジェクトにつき1つのみ作成でき、常にMETA-INFというディレクトリ内に置く必要があります。

OSGiマニフェストはソース・エディタで編集できますが、概要エディタで宣言的に編集することをお薦めします。詳細は、「概要エディタでの拡張機能マニフェストの編集」を参照してください。

新しい拡張機能プロジェクトが作成されると、デフォルトのMANIFEST.MFが作成されます。初期コンテンツを次の例に示します。

Bundle-ManifestVersion: 2.0
Bundle-Version: 1.0.0
Bundle-SymbolicName: extension
Bundle-ClassPath: .
Require-Bundle: oracle.ide

OSGiマニフェストのコンテンツの詳細は、http://www.osgi.orgを参照してください。

JDeveloperは、パッケージ化プロセスの一部としてmanifest.mfを更新し、次のものを提供します。

- 必須バンドル: 自分の拡張機能に必要な、別のOSGiバンドルのクラスがリストされます。拡張機能マニフェスト内のrequire-bundles要素から取得されます。

- エクスポート・パッケージ: 拡張機能内のJavaパッケージを他の拡張機能から利用できるようにする場合に、それらのパッケージがリストされます。

- バンドル・クラスパス: 拡張機能から、OSGiバンドルではないJARのクラスを参照する必要がある場合に、それらがリストされます。拡張機能マニフェスト内の<dependencies>要素から取得されます。

これらの値は、OSGiバンドル・プロファイル・ダイアログで使用されます。詳細は、「デプロイメント・プロファイルの作成方法」を参照してください。

1.7.1 依存関係について

拡張機能は、他の拡張機能やJARファイルに依存できます。JDeveloper用の拡張機能を開発するには、拡張機能への依存と、拡張機能ツリーについて理解する必要があります。自分の拡張機能と他の拡張機能との間に、次のどの依存関係があるかを知る必要があります。

- 自分の拡張機能が別の拡張機能の一部になっている

- 1つ以上の拡張機能が自分の拡張機能の一部になっている

また、追加する必要があるライブラリおよびJARファイルも把握する必要があります。たとえば、oracle.jdeveloper.maven.jarへの依存関係を追加した場合は、外部Mavenモジュールを使用して提供されるJARファイルのライブラリも追加する必要があります。

これらが把握できたら、拡張機能マニフェスト内に依存関係を設定して、必要なライブラリと追加JARファイルが拡張機能バンドルの一部になるようにします。

1.7.1.1 拡張機能マニフェストでの依存関係の設定方法

拡張機能プロジェクトを作成すると、拡張機能マニフェストが作成され、概要エディタで開かれます。詳細は、「拡張機能マニフェストの操作」を参照してください。

拡張機能がロードされる順番は、拡張機能マニフェスト内のエントリによって決まります。

拡張機能マニフェストに依存関係を設定するには、次のようにします。

1. 必要であれば、「アプリケーション」ウィンドウでMETA-INFの下のextension.xmlをダブルクリックして、extension.xmlを概要エディタで開きます。「依存性」タブを選択します。

2. 他の拡張機能がこの拡張機能に依存するように指定するには、「インポートされたパッケージ」セクションを使用します。

作業中にヘルプを表示するには、[F1]を押すか、ダイアログから「ヘルプ」をクリックします。

選択した拡張機能が、拡張機能マニフェストの<dependencies>セクションに、<import>要素としてリストされます。

3. 拡張機能が他のOSGiバンドルのクラスを必要とするように指定するには、「必須バンドル」セクションを使用して、この拡張機能に依存する1つ以上のバンドルを指定します。

選択した拡張機能が、拡張機能マニフェストの<require-bundles>セクションに、<bundle>要素としてリストされます。クラスを検索する際、OSGiはそれらをリスト順に検索するので、バンドルは必ずバンドル・リスト内の適切な場所に追加してください。

1.7.1.2 OSGiバンドル・プロファイルでの依存関係の設定方法

拡張機能をパッケージ化する際には、生成されるバンドル・マニフェストの決定に使用される、OSGiバンドル・プロファイルを作成します。詳細は、「デプロイメント・プロファイルの作成方法」を参照してください。

OSGiバンドル・プロファイル・ダイアログで指定する重要なエントリは次のとおりです。

- パッケージ・エクスポート: ここでは、生成されるバンドル・マニフェストのExport-Packageセクションに影響するファイル・グループを指定します。たとえば、拡張機能内に、他の拡張機能からアクセスできるようにするJavaパッケージがある場合は、それらのパッケージをこのセクションにリストします。

- パッケージ・インポート: ここでは、生成されるバンドル・マニフェストのImport-Packageセクションに影響するファイル・グループ、ライブラリ依存関係およびプロファイル依存関係を指定します。

- 必須バンドル: ここでは、生成されるバンドル・マニフェストのRequire-Bundleセクションに影響するライブラリ依存関係とプロファイル依存関係を指定します。

ライブラリの依存性ページでは、バンドルのライブラリ依存関係をチェックできます。プロファイルの依存性ページでは、アプリケーション内の他のJARデプロイメント・プロファイルを調べたり、必要であればそれらを変更できます。

2 Oracle JDeveloperでの拡張機能の開発

この章では、JDeveloper拡張機能のライター、開発者およびユーザーが使用できる機能を紹介し、拡張機能の開発者からよく質問を受けるいくつかの機能についての例を示します。計画している拡張機能を開発するために、すぐに使用を開始できるJDeveloperのネイティブ機能について説明します。

この章の内容は次のとおりです。

- Oracle JDeveloperでの拡張機能の開発について

- 拡張機能開発のユースケース

- JDeveloperのルック・アンド・フィールの取得

- JDeveloperの要素の作成

- トリガー・フックの定義および使用

- オンライン・ヘルプ・サポートの追加

- 印刷サポートの追加

- アプリケーションまたはプロジェクト・テンプレートの作成

2.1 Oracle JDeveloperでの拡張機能の開発について

JDeveloperでは、オープン・アーキテクチャが使用されているため、特定のニーズがある場合、または開発チームが使用する外部のプロセスやツールにJDeveloperを統合する必要がある場合には、独自の拡張機能を作成できます。メニュー・アイテムの追加、コンテキスト・メニューの作成、JDeveloperツールバーへの機能の組込み、データ・オブジェクトのビューを表示するドッキング可能なウィンドウの作成などを行うことができます。

2.2 拡張機能開発のユースケース

この項では一連のユースケースを説明します。拡張機能を計画するとき、または宣言トリガー・フックを使用したり遅延初期化をサポートするために以前のバージョンのJDeveloper用に作成された既存の拡張機能を変換する場合に、このようなユースケースに直面することがあります。ロードおよび実行が迅速に実行される拡張機能を作成するためには、次に示す推奨事項に従ってください。

2.2.1 ルール・ベースのメニュー秘密度について

拡張機能では、メニュー・アイテムに関連付けられたアクションの有効状態を設定することで、メニュー秘密度を制御します。これは、そのアクションに関連付けられたoracle.ide.controller.Controllersの1つによって決定されます。アクションはトリガー・フックであるため、アクションに関連付けられたoracle.ide.controller.Controller実装は、そのコントローラを所有する拡張機能が初期化されるまでは呼び出されません。単純なルールの設定例は、「単純なルールの定義方法」を参照してください。

次の一般的な状況について考えてください。メニュー・アイテムM1はアクションA1に関連付けられています。また、このアクションはいくつかのコントローラに関連付けられています。これらのコントローラは、所定のコンテキストでアクションA1を処理するかどうかを示すことができます。選択されているアクションを処理する最初のコントローラは、アクションの有効状態を設定します。

具体的な例では、EditCopyがaction IdeConstants.COPY_CMD_IDに関連付けられており、これはテキストのコピー方法を認識するコントローラと、ビジュアル・オブジェクト(UIコンポーネントなど)のコピー方法を認識する別のコントローラに関連付けられています。

従来、このパターンのユースケースでは、メニューが表示されるときや、ツールバー・ボタンの有効状態が変化するときなど、JDeveloperによってコンテキストが変更される際に、パフォーマンスの問題が発生していました。たとえば、ユーザーが現在の選択の変更、現在のビューの変更、または現在のアクティブ・プロジェクトの変更を行う場合です。

こうした状況で処理に時間がかからないようにするには、ルールに基づくアクション秘密度制御を使用して拡張機能のメニューを開発します。コントローラは拡張機能のマニフェスト・ファイルで宣言によって定義されます。詳細は、「拡張機能マニフェストの操作」を参照してください。

コントローラ定義の中で、次のようなアクションの有効状態を制御するアクション更新ルールを指定します。

- 常に有効にする

- アクティブなアプリケーションが存在するときに有効にする

- アクティブなプロジェクトが存在するときに有効にする

- コンテキストにノードがあるときに有効にする

- コンテキストにタイプXのノードがあるときに有効にする

- コンテキストに選択内容があるときに有効にする

- コンテキストに1つの選択内容があるときに有効にする

- コンテキストに複数の選択内容があるときに有効にする

コントローラでは複数のルールを定義できます。最も具体的なルールをルール定義の最初に指定する必要があります。

JDeveloperがコントローラのルールに基づく秘密度を分析した後で、そのコントローラを所有する拡張機能が初期化されます。拡張機能が初期化されると、拡張機能のController.update()メソッドがアクションの有効状態を処理します。コントローラで処理が行われない場合、拡張機能の操作は定義されたルールに従います。GUIの応答に影響しないように、すべてのController.update()メソッドがfalseを返すことをお薦めします。

2.2.1.1 複雑なController.update()の実装を回避する方法

コントローラが指定するルールでは、アクションの有効状態が宣言によって決定されます。このとき、「ルール・ベースのメニュー秘密度について」で説明するアクション有効化ルールが使用されます。メニューが有効になり、ユーザーがそのメニューを実行すると、拡張機能が必要な処理を実行して、メニューの実行が正常に動作できるようにします。

Controller.update()の以前の実装は、アクションの有効状態を判別するために複雑で時間のかかるコードを実行していました。現在のメニュー秘密度モデルを使用すると、アクションの有効状態は宣言で決定することができ、実行する適切なアクションの選択にかかる時間が短縮されます。

コントローラの動作を制御するルールを次に示します。

拡張機能が初期化される場合:

- メニューがまもなく表示されます。

- ルール・ベース・コントローラの場合、ルールが評価されます。falseであれば、フレームワークによってメニューがグレー表示されます。trueの場合またはルールベース・コントローラでない場合は、次の項目を参照してください。

- Controller.update()が呼び出されます。これでtrueが返されると、他のコントローラは処理されません。コントローラは、アクションの有効状態または無効状態をupdate()メソッド内で設定する必要があります。

- ユーザーがアクティブ・アクションを選択します。Controller.update()が呼び出されます。これでtrueが返されると、他のコントローラは処理されません。コントローラは、アクションの有効状態または無効状態をupdate()メソッド内で設定する必要があります。

拡張機能が初期化されない場合:

- メニューがまもなく表示されます。コントローラのルールが評価されます。falseであれば、フレームワークによってメニューがグレー表示されます。trueの場合、フレームワークによってアクティブ化されます。

- ユーザーが、初期化されていない拡張機能のアクティブ・メニューを選択した場合:

- Controller.update()が呼び出されます。update()がfalseを返すと例外がスローされます。コントローラのルールがtrueに評価された場合はコントローラのupdate()メソッドもtrueを返す必要があることが通知され、注意を促すログ・メッセージが表示されます。update()からtrueが返された場合は、次の項目に進みます。

- アクションが有効か無効かが確認されます。アクションが有効な場合は、Controller.handleEvent()が呼び出されます。アクションが無効な場合は、次の項目に進みます。

- コントローラがTriggerControllerの場合、フレームワークによって、アクションが実行されない理由を知らせるメッセージがユーザーに表示されます。TriggerControllerでない場合は、例外がスローされ、このコントローラがTriggerControllerである必要があると通知されます。

つまり、1つ目または3つ目の条件が発生した場合は、宣言によって対処する必要があります。

図2-1 初期化されない拡張機能のフロー・ダイアグラム

2.2.2 動的メニュー・ラベルおよびアイコンの使用方法

動的なメニュー・ラベルおよびアイコンは、ユーザーが選択するアプリケーション、プロジェクトまたはノードによって変化するメニュー・アイテムです。拡張機能の内部では、動的メニュー・ラベルが選択されるとコードを実行します。これは、ユーザーがメニューを選択したときに表示されるメニュー・ラベル文字列またはアイコン(あるいは両方)を変更するためです。

2.2.2.1 メニュー・ラベルに短縮名を付加する方法

ユーザーが動的メニューを選択すると、JDeveloperによって、選択された要素のショート・ラベルがメニュー・アイテム・ラベルに付加されます。これは次のように表示されます。

Run > Run myproject.jpr

一般的にこれらのメニューは、選択されたアプリケーション、プロジェクト、ノードまたは要素によって異なります。拡張機能は、コントローラ・フックを使用して、アクション更新ルールに基づいてラベルを更新するようにJDeveloperに要求できます。詳細は、「ルール・ベースのメニュー秘密度について」を参照してください。

メニュー・ラベルが更新され、ルールに指定されているように要素に関連付けられている短縮名が追加されます。この要素は、アプリケーション、プロジェクトまたはノードです。

2.2.3 動的トップ・メニューの構築方法

ソース・トップ・レベル・メニューのような、動的トップ・レベル・メニューを構成するときは、トップ・レベル・メニューと同じトリガー・フックを使用して宣言的に定義します。詳細は、「メニューの作成および変更方法」を参照してください。

メニュー・アイテムが動的トップ・レベル・メニューに含まれるかどうかを決定するものとして、次の2つがあげられます。

- エディタ・タイプ

- メニュー・タイプ

これら2つの条件が満たされると、アクティブ・エディタや開いているノードに対して宣言的に定義された動的メニューが、トップ・レベル・メニューとして表示されます。拡張機能のユーザーがこのメニューを選択するとき、メニュー・アイテム秘密度は、メニュー・アイテムに関連付けられたアクションの有効状態を設定することで処理されます。詳細は、「ルール・ベースのメニュー秘密度について」を参照してください。

2.2.4 ノード・レコグナイザについて

ノード・レコグナイザが、特定のURLによってポイントされたリソースに関連付けられているoracle.ide.model.Nodeサブクラスを認識します。

JDeveloperでは次の2つの標準レコグナイザが提供されます。

- URLそのもので提供される情報に基づいてファイル拡張子などのノード・タイプを認識できるレコグナイザ。

- XMLファイルの内容に基づいてXMLノード・タイプを認識できるレコグナイザ。

以前のバージョンのJDeveloperでは、カスタム・レコグナイザ実装を登録することもできました。現在、この方法は非推奨になっています。

Addin.initialize()メソッドは、次のいずれかのメソッドを使用してoracle.ide.mode.Recognizerクラスのカスタム実装を登録します。

- Recognizer.registerRecognizer(String, Recognizer)

- Recognizer.registerRecognizer(String[], Recognizer)

- Recognizer.registerLowPriorityRecognizer(Recognizer)

カスタム・レコグナイザを提供する拡張機能は、JDeveloperのレコグナイザが処理できるように、ノード認識を調整する必要があります。

以前のJDeveloperバージョン用に開発した拡張機能(IDE標準レコグナイザ使用)を作成し直している場合は、Addin.initialize()メソッドからレコグナイザ登録コードを削除し、レコグナイザ・トリガー・フックを使用して、拡張機能マニフェスト・ファイルextension.xmlに認識ルールを登録する必要があります。詳細は、Oracle Fusion Middleware Oracle Extension SDK Java APIリファレンスのRecognizer、および拡張機能マニフェストの操作を参照してください。

2.2.5 コンテンツ・セットについて

JDeveloperはコンテンツ・セットを使用して、「アプリケーション」ウィンドウにノードとして表示されるカテゴリを定義します。JDeveloperに組み込まれているカテゴリは次のとおりです。

- アプリケーション・ソース

- Webソース

- リソース

コンテンツ・セットは宣言によって登録されますが、そのコンテンツ・セットを導入した拡張機能の初期化をトリガーすることはありません。コンテンツ・セットではカスタム動作は必要ないためです。拡張機能のどこにコンテンツがあるかを示すために、コンテンツ・セットのID、ラベルおよびデフォルトURLを指定する必要があります。

ContentLevelFilterのインスタンスがクライアント動作を指定し、これによりコンテンツ・セットに何が表示されるかが制御されます。

ContentLevelFilterは、ContentLevelクラスによって実装される横型トラバースをフィルタリングし、物理表現と異なる各レベルの仮想表現を提供します。ContentLevelFilterでは次の処理を行うことができます。

- 表示に新しい要素を追加します。

- 表示から要素を削除します。

- 表示からサブディレクトリを削除します。

- サブディレクトリを表示します(空の場合も)。

ContentLevelFilterのインスタンスは、クラスContentLevelの静的メソッドaddContentLevelFilter(ContentLevelFilter)によって静的に登録されます。

「アプリケーション」ウィンドウで新しいアプリケーションが作成されるか開かれた後、拡張機能ユーザーがプロジェクトのトップレベル・フォルダを展開すると、そのプロジェクトのすべてのフォルダやファイルが追加される前に(BaseTreeExplorerのopenメソッドが使用される)、クラスContentLevelのメソッドapplyContentLevelFilters(Context, List, List)が呼び出されます。このメソッドは次のように機能します。

1. すべてのソース・ルート・ディレクトリを取得します。

2. 登録されているContentLevelFilterのインスタンスごとに、所定のContextにフィルタを適用できるかどうかをチェックします。適用できる場合は、メソッドupdateDir(URLPath, String, List, List, Context context)を呼び出します。このメソッドは、要素やサブディレクトリが表示される前に各レベルの要素やサブディレクトリのリストを変更できます。同じレベルに変更を適用するContentLevelFilterのインスタンスが複数ある場合、後のフィルタは前のフィルタの効果を認識して、適切ならば、さらにフィルタリングします。

3. AsynchronousContentLevelFilter、ContentLevelのインスタンスについても前の手順と同じ処理をします。また、そのようなフィルタからCallableを取得します。これは、追加要素を取得するために非同期リクエストを実行します。

注意:

ContentLevelFilterをContextに適用できるかどうかを判別するために、ContentLevelがすべてのコンテンツ・セット・キーをそのフィルタから取り出し、コンテキストにプロパティとして少なくとも1つのキーが含まれるかどうかを確認します。

ContentLevelFilterには、宣言登録は必要ありません。フィルタリングが行われる前に、NodeFactoryを使用してノードが作成されます。これは、レコグナイザを使用してURLからノードを作成します。レコグナイザはトリガー・フックであるため、フィルタリングが発生するまでには、関連する拡張機能がすでに初期化されます。

一般的に、コンテンツ・レベル・フィルタを登録する拡張機能はレコグナイザ・ルールも登録します。したがって、登録したレコグナイザ・ルールによってノード・タイプが認識されると、拡張機能は常に初期化されます。たとえば、「アプリケーション」ウィンドウの場合、ユーザーが「アプリケーション」ウィンドウでフォルダを展開すると、そのフォルダの下にあるすべてのファイルに対するノードのインスタンスが作成され、それによって拡張機能の初期化がトリガーされるようになります。その時点で、JDeveloperがコンテンツ・レベル・フィルタを呼び出します。これで、フィルタによりノードの除外や、展開するフォルダ内に表示する他のノードの追加を行えるようになります。

2.2.6 大規模な拡張機能について

多様な機能を提供し、依存ツリーの階層が深い拡張機能は、大規模拡張機能とみなされます。通常、大規模拡張機能は依存ツリーの階層が深いため、他の多くの拡張機能の事前初期化を引き起こします。多くのケースで、拡張機能ユーザーは大規模拡張機能で提供される多様な機能の一部しか利用しませんが、このタイプの拡張機能の一体化された構造のために、意図せずに必要以上の機能を得ることがあります。

大規模拡張機能のパフォーマンスを改善するためには、次のいずれかのモデルに従い大規模拡張機能をリファクタすることをお薦めします。

- 拡張機能の主要な機能分野を識別して、特徴的な分野を個別の拡張機能としてリファクタします。

- 概念的な機能分野を、依存ツリーの階層が浅い1つの拡張機能に含めるようにし、機能実装の詳細部分を別の拡張機能に移します。

1つ目のモデルに適しているのは、機能分野の間に単純な依存関係がある場合です。たとえば、2つの機能分野XとYを含む拡張機能E1について考えます。単純な依存関係とは、拡張機能E1を拡張機能E2とE3にリファクタしても、E2とE3の間に双方向依存関係が生じないことを意味します。依存関係が発生する場合は、サポート・モジュール(たとえばモジュールM1)を導入して解決できます。このモジュールでは、E2とE3の両方が必要な機能が提供されます。M1の依存ツリーはE1と同じでないことが重要です。同じであれば、E1の機能を実行するために事前初期化する必要がある拡張機能の数を減らすというリファクタの目的に合いません。E2とE3が互いに依存せず、拡張機能E1の元の依存ツリーが拡張機能E2とE3で均等に分割されるのが、理想的な状態です。

2つ目のモデルでは、拡張機能E1のバージョンが維持されます。これには階層が非常に浅い依存ツリーが含まれます。依存ツリーを縮小するために、リファクタ処理によって、機能分野E2とE3の実装を拡張機能E2implとE3implに移す必要があります。このパターンが機能するためには、E1が拡張機能E2implまたはE3impl (あるいは両方)に依存しないことが非常に重要です。このパターンをサポートするには、正しい実装が保証するsingleton-service-hookを使用します。つまり、拡張機能E1で機能E2がアクセスされるとE2impl拡張機能が初期化されます。singleton-service-hookを使用することにより、E1が拡張機能E2implに依存していなくてもE2implが初期化されます。詳細は、「トリガー・フックの定義および使用」のシングルトン登録の項を参照してください。

2.2.7 テクノロジ・スコープについて

ユーザーがテクノロジ・スコープを選択すると、そのテクノロジ・スコープを導入した拡張機能が、依存している他のすべての拡張機能と一緒に初期化されます。デプロイメント依存は、プロジェクトのデプロイメント・プロファイルに記述されます。詳細は、Oracle Fusion Middleware Oracle JDeveloperによるアプリケーションの開発のデプロイメント・プロファイルを参照してください。

ユーザーの選択により、そのテクノロジ・スコープを導入している拡張機能の依存ツリーの外部で拡張機能を初期化する必要が生じた場合、お薦めする対処方法としては、拡張機能の初期化をトリガーする拡張機能内の機能をユーザーが使用するのを待機します。機能セットという概念を回避できます。機能セットのすべてのメンバーの初期化が必要になると、遅延初期化の目的に反します。

2.3 JDeveloperのルック・アンド・フィールの取得

この項のガイドラインに従うと、JDeveloperにシームレスに溶け込む拡張機能を開発できます。たとえば、oracle.javatools.ui.LayoutConstantsで公開されているUI定数を使用すると、共通のコンポーネントに関して標準の間隔や位置合せを使用でき、推奨の間隔を実現できます。間隔は、コンポーネントがダイアログ、ウィザードまたはモードレス概要エディタのどれに含まれるかにかかわらず、すべてのコンポーネントで使用できます。

図2-2に、JDeveloperダイアログの要素で使用される標準の間隔を示します。

図2-2 JDeveloperダイアログでの間隔表示

図2-3は、JDeveloperの概要エディタで使用される間隔を示します。

図2-3 概要エディタでの間隔表示

2.4 JDeveloperの要素の作成

この項では、様々なJDeveloper要素の使用方法と開発方法について説明します。

- メニュー

- ウィンドウおよびビュー

- 「新規ギャラリ」または「ツール」メニューから呼び出すことができるウィザード

- JDeveloperコマンド

- ソース・エディタ

- エクスプローラ

- ファイル・タイプ

- 「コンポーネント」ウィンドウ

- JDeveloperプリファレンス

- 変更のUNDO可能化

Extension SDKには、これらの要素だけでなくその他の要素の例も用意されています。 詳細は、「Extension SDKを使用した開発」を参照してください。

2.4.1 JDeveloperの要素を迅速に作成する方法

次のJDeveloper要素は「新規ギャラリ」ですぐに作成できます。

- アクション。拡張機能ユーザーがIDEで呼び出すことができる処理です。アクションの詳細は、「アクションの定義方法」を参照してください。

- アドイン。JDeveloperの起動中に拡張機能の初期化と登録をプログラミングによって実行できます。アドインの詳細は、「Addinインタフェースの実装方法」を参照してください。

- データ・モデル。サブクラスHashStructureAdapterが、プリファレンスまたはプロジェクト・プロパティの永続データ・モデルを格納します。データ・モデルの詳細は、「データ・モデルの実装方法」を参照してください。

- ウィザードは「新規ギャラリ」または「ツール」メニューから呼び出すことができます。ウィザードの詳細は、「ウィザードの開発方法」を参照してください。

- 「プリファレンス」ダイアログの新しいパネル。「プリファレンス」ダイアログの使用方法の詳細は、「プリファレンスについて」を参照してください。

- 「プロジェクト・プロパティ」ダイアログの新しいパネル。プロジェクト・プロパティの詳細は、「プロジェクト・プロパティについて」を参照してください。

- 拡張機能フック定義ファイル・テンプレートで使用できるFreemarkerファイル・テンプレート。

「新規ギャラリ」ですぐにJDeveloper要素を作成するには、次の手順を実行します。

1. 「拡張機能開発用のアプリケーションおよびプロジェクトの作成方法」の手順を実行して、アプリケーションおよび拡張機能プロジェクトを作成します。

2. 「ファイル」→「新規」を選択して「新規ギャラリ」を開きます。

3. 「新規ギャラリ」の「カテゴリ」ツリーで、「クライアント層」の下の「拡張機能の開発」を選択します。

4. 「アイテム」リストで、作成するJDeveloper要素をダブルクリックします。対応するダイアログが開きます。手順を確認するには、[F1]を押すか、ダイアログの「ヘルプ」をクリックします。

2.4.2 メニューの作成および変更方法

JDeveloperに対するユーザーの操作の多くはメニューを介して行われるため、JDeveloperでは既存のメニューを変更して新しいメニューを作成できます。JDeveloperのメニュー・バーのアイテムに選択したアイテムを追加するだけでなく、コンテキスト・メニューを追加して、拡張機能が提供する機能に対するユーザーの操作を細かく制御することもできます。

メニューが対話するコマンド拡張機能は、Addinインタフェースに依存します。詳細は、「コマンドの開発方法」を参照してください。

2.4.2.1 メニューについて

メニューは、拡張機能をJDeveloperに統合する重要な手段です。バージョニング・システムの選択や内部コード・スニペット・データベースへのアクセスなど、主要な機能をJDeveloperのメニュー・システムに追加して、メニューまたはツールバーで選択することで、拡張機能を利用または制御できるようにします。一方、拡張機能の一部の機能(社内のバージョニング・ソフトウェアでのファイルのチェックアウトや、社内でよく使用されるツールでのコードの確認)は、コンテキスト・メニューに含めることをお薦めします。コンテキスト・メニューは、該当する場所でユーザーがマウスの右ボタンをクリックすると表示されます。JDeveloperの拡張機能システムではどちらの方法も可能です。詳細は、「ポップアップ・メニューの作成方法」を参照してください。

JDeveloperには、コンテキスト・メニューの宣言的作成をサポートするクラスが含まれています。作成されたコンテキスト・メニューは、一連のリスナーやコントローラによってJDeveloperのメイン機能にフックできます。この方法で、JDeveloperの構造とユーザー・インタフェースに適合するメニューベースの拡張機能を作成すると同時に、基本的なIDEを超えた機能を追加できます。詳細は、「コンテキスト・メニューからアドインを呼び出す方法」を参照してください。

あるいは、拡張機能の機能はすでにJDeveloperの既存のメニュー構造に組み込まれていて、その現在の各メニューに対して、拡張機能によって特有の機能を付け加える場合もあります。この場合は、拡張機能によって、既存のメニューに固有の新オプションを追加する必要があります。詳細は、「既存のメニューにメニュー・アイテムを追加する方法」を参照してください。

これに似た方法を使用して、ツールバーに新しい選択肢を追加することもできます。詳細は、「ツールバーにドロップダウン・ボタンを追加する方法」を参照してください。

2.4.2.2 ポップアップ・メニューの作成方法

コンテキスト・メニュー・リスナー・クラスを使用したメニューの宣言的な作成では、標準クラスを使用できます。これにより、拡張機能の更新が容易になり、すべてのメニューに一貫性が加わり、拡張機能を迅速にロードできるようになります。また、カスタム・コードを開発する必要はありません。既存のコンテキスト・メニューのリスナー・クラスを使用できます。リスナー・クラスを登録し、拡張機能のメニューを追加できるコールバック・インタフェースを使用し、メニューが作成される特定のビューに関連付けられているコントローラを最後に使用します。詳細は、「コンテキスト・メニューからアドインを呼び出す方法」を参照してください。

複数の選択肢を含むメニューを作成するには、次の手順を実行します。

- 次のサンプル・コードを使用して、コンテキスト・メニューのリスナー・クラスを拡張機能マニフェストに登録します。

<extension xmlns="http://jcp.org/jsr/198/extension-manifest"
...
<!--
Define an action that will be used in various menus and toolbars.
You can set any Swing action property on the action. The controller
class implements oracle.ide.controller.Controller and determines
when the action is enabled and what it does.

You can use an ampersand (escaped as &amp;) in the Name property
to specify the mnemonic for any menu items containing the action.
-->
<actions xmlns="http://xmlns.oracle.com/jdeveloper/1013/extension">
<action id="oracle.ide.extsamples.first.invokeAction">
<properties>
<property name="Name">&amp;Extension SDK First Sample</property>
<!-- use an icon, stealing this one from predefined icons
make sure you have oracle.icon as a required bundle to
pick up this icon at run time from the icons module  -->
<property name="SmallIcon">${OracleIcons.LABEL}</property>
</properties>
</action>
</actions>

<controllers xmlns="http://xmlns.oracle.com/ide/extension">
<controller class="oracle.ide.extsamples.firstsample.SimpleController">
<update-rules>
<update-rule rule="always-enabled">
<action id="oracle.ide.extsamples.first.invokeAction">
<label>ESDK Sample Action</label>
</action>
</update-rule>
</update-rules>
</controller>
</controllers>
<!--
Install context menus in the navigator, editor, and structure pane (explorer)
which use the same action defined above.
-->
<context-menu-hook rule="always-enabled">
<site idref="navigator, editor, explorer"/>
<menu>
<!-- 'weight' is used to control where the section appears in
the menu. Weights are sorted in ascending order, each unique
value is its own section. -->
<!-- section element must be in namespace
http://jcp.org/jsr/198/extension-manifest. -->
<section xmlns="http://jcp.org/jsr/198/extension-manifest" id="MY_CUSTOM_MENU_SECTION_ONE" weight="1.0">
<!-- For menu items and submenus, weight determines the
order within a menu section. Items are sorted in ascending
order or in the order they are added if the weight is not
unique. -->
<item action-ref="oracle.ide.extsamples.first.invokeAction"></item>
</section>
</menu>
</context-menu-hook>

<menu-hook xmlns="http://jcp.org/jsr/198/extension-manifest">
<!--
Add the action in its own separator group at the top of the File
menu.
-->
<menus>
<menubar id="javax.ide.view.MAIN_WINDOW_MENUBAR_ID">
<menu id="javax.ide.FILE_MENU_ID">
<section id="esdksample.customsection" before="javax.ide.NEW_SECTION_ID">
<item action-ref="oracle.ide.extsamples.first.invokeAction"></item>
</section>
</menu>
</menubar>
</menus>

<!--
Add the action as toolbar button in its own separator group immediately after the
existing "save" toolbar buttons.
-->
<toolbars>
<toolbar id="javax.ide.view.MAIN_WINDOW_TOOLBAR_ID">
<!-- Add a new section after the first section in the toolbar. -->
<section id="javax.ide.tck.toolbar.testsection"
after="javax.ide.NEW_SECTION_ID">
<item action-ref="oracle.ide.extsamples.first.invokeAction"></item>
</section>
</toolbar>
</toolbars>
</menu-hook>

</triggers>
</trigger-hooks>

<hooks>
<!--
The feature hook controls the display of the extension on the
Extensions page of preferences.
-->
<feature-hook>
<description>Demonstrates installing menu, toolbar and gallery items.</description>
<optional>true</optional>
<part-of>oracle.ide.extsamples.allsamples</part-of>
</feature-hook>
</hooks>
</extension>

2.4.2.3 コンテキスト・メニュー・リスナーを登録してパフォーマンスを改善する方法

コンテキスト・メニュー・リスナーを登録すると、コンテキスト・メニューが迅速にポップアップ表示されるようになります。

コンテキスト・メニュー・リスナーは、コンテキスト・メニューのポップアップを遅延させないように最小限の処理を実行する必要があります。現在、「アプリケーション」ウィンドウのコンテキスト・メニューには250近いメニュー・リスナーがあります。したがって、コンテキスト・メニューのポップアップに1秒かからないようにするには、リスナーが平均してかけられる時間は4ミリ秒未満です。

パフォーマンスの向上に関するヒントを次に示します。

- 拡張機能が特定のノードだけに関係する場合は、その特定のノード・タイプに対してコンテキスト・メニュー・リスナーを登録する必要があります。拡張機能のユーザーがそのタイプのノードをクリックしたときだけ、リスナーが呼び出されるようになります。

- リスナーのmenuWillShowメソッドが呼び出されるとき、アクションはメニュー・アイテムの追加のみにする必要があります。メニュー・アイテムのアクションが実行されるときに、該当しないコンテキストから保護します。

- リスナーのmenuWillHideメソッドが処理を行わないようにする必要があります。

コンテキスト・メニューのパフォーマンスが悪影響を受けるものは次のとおりです。

- ファイルI/O処理。

- ファイルの内容の解析。

- 検索のためのリストの繰返し処理。

- ファイル・システムでの検索。

- コンテキスト・メニューに追加済のメニューの繰返し処理およびメニュー名変更やメニュー削除の試行。

2.4.2.4 既存のJDeveloperメニューにメニュー・アイテムを追加する方法

拡張機能について、1つのアイテムまたはアイテムのグループを既存のJDeveloperメニューまたはツールバーに追加するのみでよい場合もあります。

メニューを追加するには:

1. ウィンドウ、エディタまたはエクスプローラで新しいコンテキスト・メニューを追加するには(「構造」ウィンドウなど)、次の例に示すように、リスナーをインストールします。

<context-menu-hook rule="always-enabled">
<site idref="navigator, editor, explorer"/>
<menu>
<!-- 'weight' is used to control where the section appears in
the menu. Weights are sorted in ascending order, each unique
value is its own section. -->
<!-- section element must be in namespace
http://jcp.org/jsr/198/extension-manifest. -->
<section xmlns="http://jcp.org/jsr/198/extension-manifest" id="MY_CUSTOM_MENU_SECTION_ONE" weight="1.0">
<!-- For menu items and submenus, weight determines the
order within a menu section. Items are sorted in ascending
order or in the order they are added if the weight is not
unique. -->
<item action-ref="oracle.ide.extsamples.first.invokeAction"></item>
</section>
</menu>
</context-menu-hook>

2. 既存のメニュー・バーにメニューを追加する方法は、次の例を参照してください。

<menu-hook xmlns="http://jcp.org/jsr/198/extension-manifest">
<menus>
<menubar id="javax.ide.view.MAIN_WINDOW_MENUBAR_ID">
<menu id="MY_CUSTOM_MENU" weight="20.0">
<label>${TRANSLATED_MENU_LABEL}<\label>
</menu>
</menubar>
</menus>

3. メニューにメニュー・アイテムを追加する方法は、次の例を参照してください。

<menu-hook xmlns="http://jcp.org/jsr/198/extension-manifest">
<!--
Add the action in its own separator group at the top of the File menu.
-->
<menus>
<menubar id="javax.ide.view.MAIN_WINDOW_MENUBAR_ID">
<menu id="javax.ide.FILE_MENU_ID">
<section id="esdksample.customsection" weight="1.0">
<item action-ref="oracle.ide.extsamples.first.invokeAction"></item>
</section>
</menu>
</menubar>
</menus>

2.4.2.5 ツールバーにドロップダウン・ボタンを追加する方法

場合によっては、拡張機能がウィンドウで作動し、拡張機能に固有のオプションまたは拡張機能のウィンドウに表示される特定のデータ・オブジェクトに固有のオプションで構成されるツールバーが、そのウィンドウ自体に含まれることがあります。詳細は、「メイン・ウィンドウ・メニューからアドインを呼び出す方法」を参照してください。

ツールバーにドロップダウン・ボタンを追加するには、次の手順を実行します。

拡張機能に固有のウィンドウに、この次の例のコードをメソッドとして組み込むと、3つのアクションを含むドロップダウン・ボタンがツールバーに追加されます。ユーザーがこのボタンをクリックすると、表示されるメニューには3つのアクションが含まれます。

void doit(Toolbar toolbar, IdeAction dropDownIdeAction, IdeAction ideAction1, IdeAction ideAction2, IdeAction ideAction3) {
ActionMenuToolButton actionMenuToolButton = toolbar.addActionMenuButton(dropDownIdeAction);
Action[] actions = new Action[] {
ideAction1,
ideAction2,
ideAction3,
};
actionMenuToolButton.setMenuActions(actions);
}

2.4.3 ウィンドウとビューの操作

JDeveloperデータ・モデルでは、扱っている情報の内容を表示および監視するために2つの重要な概念、ウィンドウとビューを使用します。ウィンドウ(多くの場合、IDEフレームワークの特定の場所に表示されるドッキング可能ウィンドウ)は、情報を表示し、コマンド入力を受け取ります。ビューでは、拡張機能によって生成、処理または表示される情報オブジェクト(ファイルまたはデータベース・レコードなど)にJDeveloperがアクセスする方法が定義されます。

2.4.3.1 ドッキング可能ウィンドウについて

ドッキング可能ウィンドウを使用すると、JDeveloperの指定の場所に拡張機能専用の領域を作成できます。ドッキング可能ウィンドウを使用するときは主に次の2つの手順を実行します。

1. ドッキング可能ウィンドウを作成します。

2. ドッキング可能ウィンドウを配置します。

拡張機能で使用するウィンドウを作成して配置したら、拡張機能がそのウィンドウを認識するようにします。特に、ユーザーが入力のためにウィンドウを選択したときに認識されるようにする必要があります。JDeveloperが使用するメカニズムはIDEリスナーです。ウィンドウにIDEリスナーを追加すると、拡張機能と作成したウィンドウが結び付けられます。詳細は、「IDEリスナーをビューに追加する方法」を参照してください。

ドッキング可能ウィンドウを作成して配置し、IDEリスナーの割当てを行ったところで、ユーザーによるウィンドウの選択を拡張機能が認識するように設定できます。ウィンドウは、選択されるとアクティブ・ビューを保持します。アクティブ・ビューをリスニングするように追加したIDEリスナーに指示できます。詳細は、「アクティブ・ビューのリスニング方法」を参照してください。

2.4.3.2 単純なドッキング可能ウィンドウの作成方法

ドッキング可能ウィンドウの作成は3つの手順で行います。DockableFactoryを作成し、クラスMyDockableWindowを使用してドッキング可能ウィンドウを作成し、アドインの初期化時にDockableFactoryをインストールします。

ドッキング可能ウィンドウを作成するには、次の手順を実行します。

1. 次の例に示すように、DockableFactoryを作成します。

public class MyDockableFactory implements DockableFactory
{
static final String VIEW_TYPE = "MY_VIEW_TYPE";
public void install()
{
final DockingParam dockingParam = new DockingParam();
dockingParam.setPosition(IdeConstants.SOUTH);
DockStation.getDockStation().dock(
new MyDockableWindow(),
dockingParam);
}
public Dockable getDockable(ViewId viewId)
{
if (viewId.getName().equals(MyDockableWindow.VIEW_ID))
return new MyDockableWindow();
{
return null;
}
}

2. 次の例に示すように、DockableWindowを作成します。

public class MyDockableWindow extends DockableWindow
{
static final String VIEW_ID = "MY_VIEW_ID";
private JLabel _ui;
public MyDockableWindow()
{
super(MyDockableFactory.VIEW_TYPE + "." + VIEW_ID);
}
public String getTabName()
{
return "ShortName";
}
public String getTitleName()
{
return "The Long Name Comes Here";
}
public String getTitleName()
{
return "The Long Name Comes Here";
}
public Component getGUI()
{
if (_ui == null)
{
_ui = new JLabel("The UI is here");
}
return _ui;
}
public int getDefaultVisibility(Layout layout)
{
return DEFAULT_VISIBILITY_VISIBLE;
}
}

3. 次の例に示すように、アドイン初期化の際にファクトリをインストールします。

DockStation.getDockStation().registerDockableFactory(
MyDockableFactory.VIEW_TYPE,
new MyDockableFactory()
);

2.4.3.3 ドッキング可能ウィンドウの配置方法

次の例は、ドッキング可能ウィンドウを「アプリケーション」ウィンドウの中央に配置する方法を示します。「アプリケーション」ウィンドウ拡張機能がロードされない場合、ウィンドウは左側(WEST)にドッキングされます。

dockingParam = new DockingParam();
final NavigatorManager applicationNavigatorManager = NavigatorManager.getApplicationNavigatorManager();
final NavigatorWindow navigatorWindow = applicationNavigatorManager.getNavigatorWindow();
dockingParam.setPosition(
navigatorWindow,
IdeConstants.CENTER,
IdeConstants.WEST
);

2.4.3.4 IDEリスナーをビューに追加する方法

選択リスナーをアクティブ・ビューに追加するには、アクティブ・ビューの変更をリスニングする必要があります。リスナーを追加したビューがアクティブでなくなると、リスナーをそのビューから削除する必要があります。

アクティブ・リスナーを追加するには、次の手順を実行します。

次の例に基づいてコードを作成します。

import oracle.ide.view.ActiveViewListener;
import oracle.ide.view.ActiveViewEvent;
import oracle.ide.view.ViewSelectionListener;
class MyActiveViewListener implements ActiveViewListener
{
private ViewSelectionListener _selectionListener = new ViewSelectionListener()
{
public void viewSelectionChanged(ViewSelectionEvent e)
{
//Your code responding to view selection changes goes here.
{
};

アクティブ・リスナーを変更するには、次の手順を実行します。

次の例に基づいてコードを作成します。

public void activeViewChanged(ActiveViewEvent e)
{
View view = e.getOldView();

if (view != null) view.removeViewListener(_selectionListener);
view = e.getNewView();
//While this example adds a ViewSelectionListener to any active view,
//it is strongly recommended that you add your view selection listener
//to views your extension is interested in only.
view.addViewListener(_selectionListener);
}
}

2.4.3.5 アクティブ・ビューのリスニング方法

JDeveloper IDEアーキテクチャのモデル/ビュー/コントローラ・モデルでは、どのビューがアクティブか(つまり、所定のウィンドウにどのデータ表現が表示されているか)が拡張機能によって把握されていることが必要です。(ウィンドウ・システムでは入力フォーカスがあるアクティブ・ビューが参照されます。)JDeveloper IDEアーキテクチャでは、拡張機能がアクティブ・ビューをリスニングする必要があります。これは、ビューによって実行されるコマンドが適切なデータに確実に適用されるようにする仕組みです。

アクティブ・ビューをリスニングするには、次の手順を実行します。

次の例に基づいてコードを作成します。

Ide.getMainWindow().addActiveViewListener(new ActiveViewListener()
{
public void activeViewChanged(ActiveViewEvent e)
{
final View view = e.getNewView();
System.out.println(view.getId() + " has been activated");
}
});

2.4.4 ウィザードの開発方法

ウィザードは、タスクを実行するために呼び出される拡張機能です。典型的なウィザードはUIから呼び出され、1つまたは一連のダイアログ・ボックスで構成されるユーザー・インタフェースを開きます。ユーザーがこのインタフェースでタスクのパラメータを指定します。一般的なタスクは、ドキュメントまたは他のデータ・オブジェクトの作成です。「新規ギャラリ」またはツール・メニューにインストールされるウィザードのために、特別な起動メカニズムが提供されています。このようなケースでは、ウィザード・マネージャが起動の詳細を管理します。

2.4.4.1 ウィザード・プロジェクトの設定方法

ウィザード・プロジェクトのプロパティによって、ウィザード・プロジェクトのパス、ライブラリおよび他の設定が指定されます。プロジェクトをすでに設定している場合は、ソース・ファイルを追加してから、ウィザードをデバッグおよびデプロイできます。

ウィザード・プロジェクトには通常3つの主要コンポーネントがあります。

- ウィザード・クラス。このクラスは、ユーザー・インタフェースでのウィザードの外観および起動方法を処理します。このクラスはWizard インタフェースを実装する必要があります。

- モーダル・ダイアログ。このダイアログはユーザーと対話して、ウィザードの機能に必要なデータを収集します。

- データ・オブジェクト。ウィザードは、データ・オブジェクトを作成または変更するために、ダイアログによって収集されたデータを適用します。

Extension SDKに含まれるサンプル・プロジェクトであるHelloXは、直接ウィザードを実装し、そのユーザー・インタフェースとしてJDialogを使用します。JDeveloperのルック・アンド・フィールに準拠するウィザードは、JEWTウィザード・フレームワークを使用します。

Extension SDKの詳細は、「Extension SDKを使用した開発」を参照してください。

2.4.4.2 ウィザード・インタフェースの実装方法

モーダル・タスクを実行するためにユーザー・インタフェースから呼び出される拡張機能は、oracle.ide.wizard.Wizardインタフェースを実装する必要があります。このインタフェースは拡張機能のインストールに対応し、JDeveloperのユーザー・インタフェースにインストールを統合します。

ウィザード・インタフェースを実装するには、次の手順を実行します。

- invokeメソッドの定義

- getIconメソッドの定義

- 拡張機能マニフェストでのウィザードの定義

このメソッドによってウィザードの機能が具体化されます。通常、ウィザードはダイアログを開いてユーザーからパラメータを取得します。その後、それらのパラメータを使用してドキュメントや他のデータ・オブジェクトを作成または変更します。

このメソッドが呼び出されるのは、「新規ギャラリ」または「ツール」メニューでウィザードのUI要素がユーザーによって選択されたときです。ウィザードが影響を与える可能性がある、現在選択されているオブジェクトが、contextパラメータによって識別されます。

invokeメソッドを定義するには、次の手順を実行します。

次の例に基づいてコードを作成します。

public boolean invoke(Context ctx) {
if (!isAvailable(ctx))
return false;
String greetee = null;
greetee =
JOptionPane.showInputDialog(Ide.getMainWindow(), "Enter your name:",
WIZARD_NAME,
JOptionPane.OK_CANCEL_OPTION);]
if (greetee == null) // User canceled
return false;
JOptionPane.showMessageDialog(Ide.getMainWindow(),
"Hello " + greetee + "!", WIZARD_NAME,
JOptionPane.INFORMATION_MESSAGE);
return true;
}

このメソッドが呼び出されるのは、ウィザードの「新規ギャラリ」または「ツール」メニュー・アイコンを取得するためです。ウィザードでアイコンが必要ない場合、このメソッドはnullを返します。

getIconメソッドを定義するには、次の手順を実行します。

次の例に基づいてコードを作成します。

public Icon getIcon() {
if(image == null) {
image = new ImageIcon(HelloX.class.getResource(ICON_NAME));
}
return image;
}

2.4.4.3 新規ギャラリにウィザードを追加する方法

ウィザードは、拡張機能マニフェスト・ファイルにギャラリ・ウィザードの説明を指定すると、「新規ギャラリ」にインストールできます。ウィザードの登録やイベント処理の詳細すべては、ウィザード・マネージャによって処理されます。

ウィザードが呼び出されるのが「新規ギャラリ」だけの場合、ウィザード・クラスのコンストラクタは、拡張機能ユーザーがそのカテゴリを最初に開くまで呼び出されません。ギャラリ・マネージャは、カテゴリが最初に開かれるときに説明ファイルを読み取ります。次に、ウィザードをインスタンス化し、インスタンスから導出したアイコンとラベルを使用してアイテムを構成します。

拡張機能マニフェストでは、定義することが多数あります。次の例を参照してください。

<trigger-hooks xmlns="http://xmlns.oracle.com/ide/extension">
<triggers>
<gallery xmlns="http://xmlns.oracle.com/jdeveloper/1013/extension">
<folders>
<name label="ESDK-Gallery Example">ESDK-Gallery Example</name>
<category>General</category>
</folders>
<item rule="always-enabled">
<!-- name is the fully-qualified name of an oracle.ide.wizard.Invokable  -->
<name>oracle.ide.extsamples.hellox.HelloX</name>
<!-- id is optional, and if specified will be stored in the Context
so it can be retrieved when the wizard is invoked. -->
<id>oracle.ide.extsamples.hellox</id>
<!-- description is the short label of the gallery item -->
<description>Say Hello Wizard</description>
<!-- help is the long label for the gallery item -->
<help>Prompts the user to enter his name, and repeats it. Part of the Extension SDK, this is a trivial example.</help>
<icon>/oracle/ide/extsamples/hellox/HelloX.gif</icon>
<category>General</category>
<folder>ESDK-Gallery Example</folder>
</item>
</gallery>
</triggers>
</trigger-hooks>

<gallery>には、「新規ギャラリ」のウィザードに関する情報が含まれています。

- <name>は、ウィザードの解読可能な名前を提供します。

- <category>は、ウィザードの「新規ギャラリ」カテゴリを指定します。カテゴリ内のエントリは、アルファベット順になっています。

- <folder>は、カテゴリ内のフォルダを指定します。

- ruleは、ウィザードが使用可能な時期を指定します。

- ウィザード・クラスは、<id>で識別されます。

- <description>は、「新規ギャラリ」のウィザードの短い説明です。
<help>は、アイテムを選択した場合、または「新規ギャラリ」の「すべての説明を表示」を選択した場合に表示されるエントリの長い説明です。

- <icon>は、「新規ギャラリ」内のアイコンを指定します。

拡張機能アプリケーションextensionsdkを実行することで、前の例のコードが、「新規ギャラリ」に表示される内容にどのように影響を与えるかを確認できます。

図2-4 「新規ギャラリ」のHelloXウィザード

2.4.5 コマンドの開発方法

メニュー・アイテムまたはツールバー・アイコンとしてユーザー・インタフェース要素を追加する拡張機能や、新たな目的のために既存の要素をカスタマイズする拡張機能は、機能をコマンド拡張機能にカプセル化する必要があります。

2.4.5.1 Addinインタフェースの実装方法

ほとんどの拡張機能はAddinインタフェースを実装する必要があります。このインタフェースは、JDeveloperの起動時に拡張機能のインストールに対応します。

Addinインタフェースを実装するためには、最初にコンストラクタを定義します。コンストラクタはできるだけ何もしないようにしてください。初期化タスクはinitializeメソッドで実行します。

次に、initializeメソッドを定義します。このメソッドは、インスタンスが作成された後でアドイン・マネージャによって呼び出されます。初期化時に実行する必要があるタスクは次のとおりです。

- UI要素とコントローラを作成します。

- マネージャに登録します。

アドインが呼び出されるまで必要のない他のタスク(データ構造の作成など)は延期して、JDeveloperの起動が不必要に遅くならないようにします。

2.4.5.2 コマンドの実装方法

拡張機能がメニュー・アイテムまたはツールバー・アイコンを追加する場合は、その機能をコマンドとして実装する必要があります。

既存のコントロールに特別な動作を定義する拡張機能は、カスタム・アクションを定義したり、カスタム・コマンド・クラスを実装したりするのではなく、そのコントロールにすでに用意されているアクションとコマンド・クラスを使用する必要があります。Ideクラスに定義されているフィールドは、IDEの標準コマンドのクラス名とIDを提供します。

拡張機能のコマンドには、次のタスクが必要です。

- イベントの処理

- undoメソッドの定義

- その他のメソッドの定義

この項のコード例は、Extension SDKに含まれるFirstSampleサンプル・プロジェクトのものです。詳細は、「Extension SDKを使用した開発」を参照してください。

2.4.5.2.1 イベントの処理

次の例のコードは、コマンドを呼び出したときにトリガーされるイベントの処理方法を示します。

/**
* ContextMenuListeners add items to context menus.
*/
public final class SimpleContextMenuListener implements ContextMenuListener {
public void menuWillShow(ContextMenu contextMenu) {
// First, retrieve our action using the ID we specified in the
// extension manifest.
IdeAction action = IdeAction.find(SimpleController.SAMPLE_CMD_ID);
// Then add it to the context menu.
contextMenu.add(contextMenu.createMenuItem(action));
}
public boolean handleDefaultAction(Context context) {
// You can implement this method if you want to handle the default
// action (usually double click) for some context.
return false;
}
}

コードのブロックが長くなる場合は、doItメソッドを使用できます。

2.4.5.2.2 undoメソッドの定義方法

このメソッドを定義する必要があるのは、コンストラクタによってコントローラがNORMALタイプと指定される場合のみです。undoメソッドには通常次の2つのタスクが含まれます。

- doitメソッドの処理結果を元に戻します。getDataメソッドから取得した値でチェックポイントの状態に復元するか、doitメソッドの処理を逆に実行します。

- 変更が行われたことをオブザーバに通知します。

コマンドが正常に終了するとOKを返します。それ以外の場合は、CANCELまたは0以外の値を返します。デフォルト実装はCANCELを返し、悪影響はありません。

2.4.5.2.3 その他のメソッドの定義方法

次のメソッドのデフォルト実装はオーバーライドできます。

- getIdは、コンストラクタに渡されるコマンドIDを返します。

- getTypeは、コンストラクタに渡されるコマンド・タイプ定数を返します。または、この引数が指定されない場合はNO_CHANGEを返します。

- getNameは、コンストラクタに渡される名前文字列を返します。または、この引数が指定されない場合は空の文字列を返します。

- getAffectedNodesはデフォルトではnullを返します。

- setContextとgetContextは、保護されたContext変数の書込みと読取りをそれぞれ行います。デフォルト値はnullです。

- setDataとgetDataは、プライベートObject変数の書込みと読取りをそれぞれ行います。デフォルト値はnullです。

2.4.5.3 アクションの定義方法

新しいコマンド・クラスを実装する拡張機能は、それらを含むアクションを定義する必要があります。アクションは、メニュー・アイテム(または他のユーザー・インタフェース・コントロール)と、そのメニュー・アイテムが選択されたときに実行されるコマンドのリンクになります。アクションはIdeActionのインスタンスです。

既存のUI要素に特別な動作を定義する拡張機能は、カスタム・アクションを定義するのではなく、その要素にすでに用意されているアクションを使用する必要があります。Ideクラスに定義されているフィールドは、標準コマンドのクラス名とIDを提供します。たとえば、保存処理を提供するすべてのエディタは、事前定義済のIde.SAVE_CMD値およびIde.CUT_SAVE_ID値と、それらに関連付けられたアクションを使用する必要があります。

通常、アクションは、アクションに関連するメニュー・アイテムまたはツールバー・アイコンをインストールするAddinクラスのフィールドとして定義されます。拡張機能の初期化においてアクションを作成して構成します。

この項のコード例は、Extension SDKに含まれるFirstSampleサンプル・プロジェクトのものです。詳細は、「Extension SDKを使用した開発」を参照してください。

2.4.5.3.1 アクションの取得方法

アクションはコマンドID別にキャッシュされます。必要なコマンドのアクションがすでに存在する場合、通常は、新しいアクションを作成するかわりに既存のアクションを使用する必要があります。

アクションを作成するためにIdeActionコンストラクタを使用しないでください。かわりに、次の静的メソッドを使用して、キャッシュされたアクションを取り出すか、新しいアクションを作成します。

- findメソッドは、該当するアクションがキャッシュ済の場合、指定されたコマンドIDを含むアクションを返します。

- 様々なgetメソッドは、該当するアクションがキャッシュ済の場合、指定されたコマンドIDと一致するアクションを返します。ただし、そのアクションのプロパティは、指定されたパラメータと一致する場合としない場合があります。コマンドIDに対応するアクションが見つからない場合は、指定されたパラメータに基づいて新しいアクションが作成され、キャッシュ、そして返されます。

- createメソッドは、新しいアクションを作成し、それをキャッシュせずに返します。createで取得されるアクションは、後でロードされる拡張機能では使用できません。

2.4.5.3.2 アクション値の設定方法

アクションには、外観を決定するものなど様々なプロパティが含まれることがあります。これらには、putValueメソッドやgetValueメソッドで文字列キーを使用してアクセスします。一部のプロパティは、アクションが静的メソッドcreateまたはgetによって作成されるときに設定されます。IDEによって認識されるキーはToggleActionスーパークラスに定義されます。詳細は、Oracle Fusion Middleware Oracle Extension SDK Java APIリファレンスのToggleActionに関する項を参照してください。

2.4.5.3.3 アクションのコントローラの拡張方法

ビューに依存しないアクション(openなど)は、アクションを更新してイベントを処理するためにコントローラを指定する必要があります。ビューのコンテキストで呼び出されるアクションには、アクション・コントローラは必要ありません。

コマンドの動作を拡張すると、そのコマンドを使用するすべてのIDE機能で、カスタム操作を実行できます。これには、コマンドのアクションのコントローラを置き換えるか、アクションにまだコントローラがない場合にはコントローラを設定します。ただし、デフォルトの動作を損ねないように注意する必要があります。

既存のコントローラを置き換えるには、次の手順を実行します。

1. 古いクラスを拡張して、新しいコントローラ・クラスを実装します。

2. 新しいコントローラが拡張するコマンドを処理する際に、custom処理を実行し、そのコマンドに対して古いコントローラのhandleEventメソッドを呼び出します。こうすることで、元の動作が保持されます。

コントローラのないアクションにコントローラを追加するには、次の手順を実行します。

1. 新しいコントローラ・クラスを実装します。

2. 新しいコントローラが拡張するコマンドを処理する際に、custom処理を実行し、そのコマンドに対してスーパーバイザのhandleEventメソッドを呼び出します。こうすることで、元の動作が保持されます。

getControllerメソッドとaddControllerメソッドを使用してアクションのコントローラにアクセスします。

2.4.5.3.4 アクションのコマンド・クラスの拡張

getCommandメソッドは、アクションのコマンド・クラスの名前を返します。これを置き換えるためにsetCommandメソッドを使用できます。ただし、そうするとグローバルに置き換えられるため、そのアクションを処理するすべてのIDE機能に影響します。悪影響が生じないようにするには、元のコマンド・クラスだけを、それを拡張するクラスで置き換えます。

2.4.5.4 メイン・ウィンドウ・メニューからアドインを呼び出す方法

メイン・ウィンドウ・メニューからアドインを呼び出せるようにするには、アドインのメニュー・アイテムをメイン・ウィンドウ・メニューのいずれかに追加します。アイテムはどのメニューにも追加できますが、拡張機能を「ツール」メニューから呼び出す場合は、アドインとしてインストールするかわりに(または、アドインとしてのインストールに加えて)ウィザードとしてインストールする必要があります。「ツール」メニューでのメニュー・アイテムの追加と処理は、ウィザード・マネージャによって行われます。

IDEメニューは、Menubarのシングルトン・インスタンスによって表示されます。これはgetMenubarメソッドを使用してアクセスできます。

拡張機能は、IDEメニューにメニュー、サブメニューおよびメニュー・アイテムを追加できます。呼び出される拡張機能(ウィザードなど)は、インストール時に独自のアイテムをメニューに追加します。または、拡張機能が標準メニュー・アイテムの独自の動作を定義できます。たとえば、「編集」メニューのアイテムの処理内容は使用されるエディタによって異なります。

2.4.5.5 コンテキスト・メニューからアドインを呼び出す方法

「アプリケーション」ウィンドウやソース・エディタなどの一部のビューには、ユーザーがウィンドウを右クリックするとポップアップ表示されるコンテキスト・メニューがあります。拡張機能はコンテキスト・メニューにアイテムを追加できます。

ユーザーが右クリックすると、コンテキスト・メニューが再構成されます。選択されたコンテキスト・メニュー・リスナー(右クリックの対象に関連付けられているリスナー)がポーリングされ、コンテキスト・メニューにアイテムまたはサブメニューを付加する機会が与えられます。たとえば、ドキュメントを表すノードが右クリックされると、そのドキュメント・タイプのビューアとして登録されているエディタやデザイナのメニュー・アイテムをコンテキスト・メニューに追加できます。

次の例は、「アプリケーション」ウィンドウなどのウィンドウ内にコンテキスト・メニューをインストールする方法を示しています。このコードは、Oracle IDE Extension SDKの一部としてインストールされる拡張機能サンプル内のClassBrowserプロジェクトのものです。

<!--
Install context menus in the navigator, editor
which use the same action defined above. -->

<context-menu-hook rule="always-enabled">
<site idref="navigator,editor"/>
<menu>
<!-- 'weight' is used to control where the section appears in
the menu. Weights are sorted in ascending order, each unique
value is its own section. -->
<!-- section element must be in namespace
http://jcp.org/jsr/198/extension-manifest.  -->
<section xmlns="http://jcp.org/jsr/198/extension-manifest" id="MY_CUSTOM_MENU_SECTION_ONE" weight="1.0">
<!-- For menu items and submenus, weight determines the
order within a menu section. Items are sorted in ascending
order or in the order they are added if the weight is not
unique.  -->
<item action-ref="esdksample.showClassBrowser"></item>
</section>
</menu>
</context-menu-hook>

2.4.6 エディタの開発方法

エディタは、ユーザーが変更できるようにオブジェクトを表示するビューです。通常、エディタにはテキストが表示されます。デザイナはテキスト以外のエディタです。エディタは、ドキュメントのノードのコンテキスト・メニューまたは「表示」メニューを介して開かれます。ドキュメントで使用できるエディタは、そのドキュメントのタイプについてIDEのエディタ・マネージャに登録されたエディタです。エディタは、通常は構造エクスプローラと組み合せて使用されますが、これは必須ではありません。

Extension SDK内のCustomEditorプロジェクトは、oracle.ide.editor.Editorの拡張およびjava.beans.PropertyChangeListenerの実装を行う、カスタムのXMLQueryEditorを実装することでこれを実行する方法を示します。詳細は、「Extension SDKを使用した開発」を参照してください。

2.4.6.1 非同期エディタの使用

非同期エディタは、UIスレッド(Swingのイベント・ディスパッチ・スレッド)の外部のワーカー・スレッドにコンテンツをロードするため、ユーザーが操作する際の応答性が向上します。非同期エディタのコンテンツをロードするとき、エディタ・フレームワークでは次の処理が行われます。

- 「エディタのロード中」というメッセージとアニメーションを含むパネルを表示します。両方とも構成できます。

- 「コンポーネント」ウィンドウがUIをロードおよびブロックをしないようにします。

エディタのロードが開始するのはContextが設定されたときです。このアクションにより、エディタのUIがUIスレッドで必要とするモデルのロードがトリガーされます。このために、非同期エディタはワーカー・スレッドを作成してロードを実行します。モデルのロードが行われている間に、IDEはエディタのGUIコンポーネントを確認します。エディタの実際のUIがまだロードされていない場合、メッセージ(たとえば、「エディタのロード中」)を含むパネルが表示され、「コンポーネント」ウィンドウはロードされません。エディタの実際のUIが作成されると、非同期エディタが自動的に入れ替わります。

エディタ・フレームワークにより、エディタの実装方法の柔軟性が高くなります。詳細は、Oracle Fusion Middleware Oracle Extension SDK Java APIリファレンスのAsynchronousEditorに関する項を参照してください。

2.4.6.1.1 非同期エディタの仕組み

最初の手順としては、たとえばユーザーが「アプリケーション」ウィンドウでノードをダブルクリックすると、EditorManagerがエディタを作成して開きます。

1. EditorStateが新しい非同期エディタ(oracle.ide.editor.AsynchronousEditorのサブクラス)を作成します。

2. 非同期エディタは作成されるとプロパティを設定します。そのプロパティによって、エディタが非同期であり、実際のエディタはまだロードされていないことを、IDEの他のビューが認識します。このプロパティに関心を持つビューの例としては、「コンポーネント」ウィンドウがあります。「コンポーネント」ウィンドウは、エディタが完全にロードされた場合にのみそのコンテンツをロードします。

3. EditorStateによって、新しい非同期エディタ内のコンテキストが設定されます。

4. 非同期エディタは、コンテンツがまだロードされていないことが適切なフラグによって示されるのを待機し、その後で非同期エディタ・コンテンツ・モデルをロードします。これは非同期に実行されます(UIイベント・スレッド外)。

5. EditorManagerは、エディタの優先レイアウトを設定します。

6. EditorStateがエディタを開きます。これによって、getGUIの呼出しが行われます。

これを図2-5に示します。

図2-5 エディタのオープン

エディタがいったん開くと、エディタのメソッドgetGUIが呼び出されます。このとき、非同期エディタで「エディタのロード中」というメッセージが表示され、図2-6に示すように、コンテンツ・モデルを非同期にロードするタスクがUIイベント・スレッド外でスケジュールされます。

図2-6 エディタのGUIの取得

この時点でコンテンツ・モデルは非同期にロードされており、次の処理が行われます。

- AsynchronousEditorは、メソッドopenImpl、showImplおよびactivateImplを呼び出して、エディタのGUIのロード、表示およびアクティブ化します。

- AsynchronousEditorは待機中ページを実際のエディタGUIと切り替えます。

- AsynchronousEditorは、完全にロードされたことを「コンポーネント」ウィンドウなどのリスナーに通知します。リスナーはそれぞれのコンテンツをロードできるようになります。

通常のエディタを非同期エディタにするには、次の手順を実行します。

1. oracle.ide.editor.Editorではなくoracle.ide.editor.AsynchronousEditorを拡張します。

2. 抽象メソッドgetEditorContext(Context)を実装します。このメソッドは、エディタのUIが所定のContextで必要とするモデルをロードします。

3. 抽象メソッドdoSetContext(Context)を実装します。このメソッドは、Editorで元のメソッドsetContext(Context)と同じ機能を持つと想定されます。setContext(Context)はfinalになります(非同期機能の正しい動作を保証します)。

4. 抽象メソッドisContentModelLoaded()を実装します。このメソッドは、エディタによって使用されるモデルがロードされるかどうかにかかわらず、非同期エディタ・フレームワークを指定します。

5. 抽象メソッドopenImpl(boolean)を実装します。非同期エディタの正しい動作を保証するために、Editorの抽象メソッドopen()がfinalになります。openImplは、エディタのUIのモデルがロードされたかどうかを示すブール引数を渡します。ほとんどのケースで、与えられた引数がtrueの場合、必要となるのは既存のopen()の実装をopenImplに移すことだけです。

6. Editorライフサイクル・イベントのすべてのコードを新しいメソッドに移動します。非同期コンテンツのロードが正しく作動することを保証するために、AsynchronousEditorはエディタのライフサイクルをfinalにして、implメソッドでそれらを実装するサブクラスを提供します。
finalにするライフサイクル・メソッドは次のとおりです。

- open

- close

- editorShown

- editorHidden

- activate

- deactivate

AsynchronousEditorのサブクラスは次のメソッドを実装する必要があります。

- openImpl(boolean)

- closeImpl(boolean)

- editorShownImpl(boolean)

- editorHiddenImpl(boolean)

- activateImpl(boolean)

- deactivateImpl(boolean)

この場合、ブール引数はエディタのコンテンツ・モデルがロードされたかどうかを示します。

このタスクの複雑さは、特定のエディタのクラス階層の数のレベルに比例します(特にライフサイクル・メソッドをオーバーライドする場合)。一連のクラスがclose()をオーバーライドする場合、それらすべてがかわりにcloseImpl(boolean)をオーバーライドする必要があります。

2.4.7 エクスプローラの開発方法

構造エクスプローラでは、ドキュメントの編成が通常はツリーとして表示されます。JDeveloperでは、一般的な様々なドキュメント・タイプに対してエクスプローラが提供されます。カスタム・エクスプローラをインストールして、エクスプローラ・マネージャに登録することもできます。

2.4.7.1 エクスプローラの作成方法

構造エクスプローラでは、ドキュメントの編成が通常はツリーとして表示されます。

構造エクスプローラは、DocumentのViewです。エディタまたはデザイナにフォーカスが移ると、そのエクスプローラが構造ウィンドウに表示されます。エクスプローラは、本質的にはドキュメントの索引または目次です。ユーザーはエクスプローラを使用して、ドキュメント・ビューに表示されるコンテンツをナビゲートします。ドキュメントの階層は「構造」ウィンドウに表示され、ドキュメントが編集されると更新されます。

JDeveloperでは、一般的な様々なドキュメント・タイプに対してエクスプローラが提供されます。カスタム・エクスプローラをインストールして、エクスプローラ・マネージャに登録することもできます。ドキュメントがJDeveloperで開かれると、対応するエクスプローラがエクスプローラ・マネージャによって提供されます。エクスプローラはドキュメントを解析して、生成される構造を表示します。

エクスプローラ・アドインには次のコンポーネントが含まれます。

- 登録を実行するクラス。このクラスがAddinを実装します。JDeveloperが起動されると、このクラスの1つのインスタンスがアドイン・マネージャによって作成され、このインスタンスが登録を実行します。アドイン・クラスには他の目的は必要ありません。

- エクスプローラのユーザー・インタフェースを提供するクラス。このクラスは特別なビューアです。ドキュメントの構造がツリーで表示されるとき、必要な機能のほとんどは、TreeExplorerまたはそのサブクラスの1つを拡張することで提供されます。このクラスは、要素でのマウスのクリックを処理し、エディタでの変更を追跡し、必要な場合にツリーを再構築するパーサーを呼び出します。

- Elementの1つ以上のインスタンスを含む要素モデル。このモデルは、ドキュメントのエクスプローラ・ビューの構造表現です。要素は、ドキュメントのコンテンツの特定の場所に関連付けられています。選択されると、ビューアがその場所までスクロールします。

- ドキュメントの要素の構造を生成するパーサー。パーサーは、ドキュメントを、ビューア座標にマッピングされる要素の階層に単純化します。

エクスプローラを設計するときは次の点に注意してください。

- Explorerは、Documentに含まれるデータの構造化された視覚的表現を提供するビューです。

- 1つのドキュメントに対して複数のエクスプローラの実装が存在することが可能です。

- Explorerインタフェースを実装して、構造エクスプローラを作成します。

- ChildFilterは、TreeExplorerと組み合せて使用するオプション・インタフェースです。これは、ユーザーがコンテナ・ノードを展開したときに表示される子をフィルタリングします。

2.4.7.2 構造エクスプローラの登録および初期化方法

エクスプローラは、IDEのExplorerManagerに登録する必要があります。登録すると、エクスプローラがノード・クラスまたはノードとビューアのペアに関連付けられます。

ユーザーがノードについてビューアを選択するとき、IDEは、ノードとビューアに最適なエクスプローラのリクエストをExplorerManagerに送ります。ビューアは、そのノードとビューアについて登録されているものか、ノードのみについて登録されているものです。該当する登録が行われていない場合、ExplorerManagerは、リクエストのノード・クラスに互換されるノード・クラスに登録されているビューアを見つけようとします。

登録処理は、次の例に示すようにアドイン・クラスのinitializeメソッドで実行する必要があります。このコード例は、Extension SDKに含まれるサンプル・プロジェクトの1つ、StructurePaneプロジェクトのものです。詳細は、「Extension SDKを使用した開発」を参照してください。

public void initialize()
{
Class editorClass = PropFileEditor.class;
ExplorerManager.getExplorerManager().register(PropFileSourceNode.class,
PropFileExplorer.class,
PropFileEditor.class );
}

2.4.7.3 構造エクスプローラ要素モデルの作成方法

エクスプローラの要素モデルは、所定のドキュメントのデータを視覚的に示す構造表現です。

各モデルは、Elementの1つ以上のインスタンスで構成されます。通常、モデルはエクスプローラ内でツリーとしてレンダリングされますが、これは必須ではありません。要素モデルはビジュアル・オブジェクトではありませんが、グラフィカル・コントロールを使用して視覚的にレンダリングされます。たとえば、javax.swing.JTreeによってレンダリングされるjavax.swing.tree.TreeModelです。

エクスプローラの実装により、そのモデルと、さらにはそのモデルの視覚表現が、任意の方法でドキュメントのデータに加えられた変更を確実に受け取ります(たとえば、ソース・エディタ、プロパティ・インスペクタでは、JDeveloperの外部でドキュメントを編集します)。これはJDeveloperのイベント・メッセージング・メカニズムを使用して実現されます。

2.4.7.4 構造エクスプローラの更新方法

関連するドキュメントのコンテンツが変更されるときは常に、状態を更新できるように構造エクスプローラが通知を受ける必要があります。通知メカニズムを使用して、ビューアでの変更内容に関する情報をエクスプローラに送信します。構造エクスプローラは、updateメソッドを提供するObserverを実装して、ビューアのドキュメントを表すオブジェクトに登録する必要があります。

2.4.8 新しい「コンポーネント」ウィンドウのページを追加する方法

コンポーネント・マネージャを使用すると、個々のページを「コンポーネント」ウィンドウに追加できます。拡張機能のユーザーは、一貫性のあるユーザー・インタフェースの構築や、他の標準化されたタスクの実行のために、これらのページを利用できます。「コンポーネント」ウィンドウでは、コンポーネントのページが提供されます。ユーザーはここからコンポーネントを選択して、拡張機能を使用して構築しているコンテンツまたは拡張機能のために構築しているコンテンツに追加できます。

コンポーネント・ページの作成と管理の機能は、PaletteManagerインスタンスのメソッドを使用して、プログラミングで実行することもできます。詳細は、Oracle Fusion Middleware Oracle Extension SDK Java APIリファレンスのPaletteManagerに関する項を参照してください。

この項では、静的および動的コンポーネントを「コンポーネント」ウィンドウに宣言的に追加する例、追加のヘルプを提供する例、個々のコンポーネント・ページ内でユーザーが特定のアイテムを検索する機能を補強する例を示します。

2.4.8.1 「コンポーネント」ウィンドウのページについて

「コンポーネント」ウィンドウでは、ユーザーは、よく使用されるデータ構造をJDeveloperのプロジェクト、アプリケーションまたは他のコンテンツに追加できます。「コンポーネント」ウィンドウではページが提供されます。ユーザーはここから個別のコンポーネントを選択して、拡張機能を使用して構築しているコンテンツまたは拡張機能のために構築しているコンテンツに追加できます。具体的なコンポーネントには、著作権宣言文のように単純なものもあれば、リモート・リポジトリに接続するための設定のように複雑なものもあります。さらに、JDeveloperでは、所定の「コンポーネント」ウィンドウのページから使用できるコンポーネントは、選択されているファイルのタイプによって異なります。たとえば、HTMLファイルを編集している場合、「コンポーネント」ウィンドウのページには、アンカー、電子メール・リンク、他のよく使用されるHTMLコンポーネントなど、使用可能なHTMLコンポーネントのリストが表示されます。Javaページを編集している場合は、これとはまったく異なるコンポーネントが表示されます。

「コンポーネント」ウィンドウを表示するには、「表示」→「コンポーネント」を選択します。

拡張機能開発者のレベルでは、「コンポーネント」ウィンドウは、ページを宣言的に「コンポーネント」ウィンドウに追加する方法を提供します。これにより、拡張機能のユーザーが特定のコンポーネントを使用できるようになります。そのようなページで、提供を予定している標準コンポーネント(静的と動的の両方)をすべて表示できます。たとえば、一貫性のあるユーザー・インタフェースのユーザーによる構築を支援するために、またはJDeveloperのコンポーネント・マネージャで管理されるコンポーネントを利用する標準化タスクを実行するために、コンポーネント・マネージャを使用して、コンポーネントの1つ以上のページを「コンポーネント」ウィンドウに追加できます。

拡張機能を開発するとき、コンポーネント・ページ、静的コンポーネントと動的コンポーネントおよびそれらのサポートを、拡張機能に宣言によって組み込むことができます。次のことが可能です。

- 「コンポーネント」ウィンドウで静的コンポーネントを宣言します。

- 動的コンポーネントを宣言し、「コンポーネント」ウィンドウがロードされたときに組み込みます。

- ユーザーがコンポーネントを使用できるようにするのに役立ちます。

- ユーザーがコンポーネントを簡単に検索できるようにします。

このような宣言ツールを使用すると、拡張機能ユーザーが、よく使用される要素を拡張機能を使用してユーザー自身のプロジェクトやアプリケーションに追加できます。さらに、ヘルプや検索の機能により、ユーザーがそのような「コンポーネント」ウィンドウを簡単に見つけて適用できるようになります。

コンポーネント・マネージャを使用すると、コンポーネント・ページをプログラミングで追加することもできます。

2.4.8.2 「コンポーネント」ウィンドウの静的コンテンツを宣言する方法

多くのケースで、「コンポーネント」ウィンドウのコンテンツは変化しません。ソース・リポジトリに対する一連の接続パラメータまたは拡張機能での使用場所にかかわらず変化しない他の固定データです。このようなケースでは、この次の例に示すようにpalette-hookを使用して拡張機能マニフェスト・ファイルに静的コンテンツを定義できます。

「コンポーネント」ウィンドウの形状は、単純な4層の分類として定義されます。

- 最も上のレベルはページです。Swing、AWT、ADF Swing、ADF Faces、Java Server Faces (JSF)、JavaServer Pages (JSP)など、テクノロジに応じてコンポーネントをグループ化します。UIでページが表示されるのは、「コンポーネント」ウィンドウの最も上にあるコンボ・ボックスの選択肢です。

- 各ページにはグループがあります。グループには少数の機能カテゴリが含まれます。たとえば、ページSwingには、Common ControlsとLayoutというグループが含まれることがあります。グループは、「コンポーネント」ウィンドウのドッキング可能ウィンドウです。

- 各グループにはセクションがあります。セクションは、共通のコンポーネントをまとめて、メニュー・セパレータに似た区切り線をUIに表示し、コンポーネントを名前のアルファベット順に並べます。

- 最後は、各セクションにアイテム(またはコンポーネント)があります。アイテムは、「コンポーネント」ウィンドウにコンポーネントを表示するための属性(たとえば、名前、説明、アイコンなど)で構成されます。

次の例は、Extension SDKのCPPageProviderプロジェクトのものであり、1つのコンポーネントを含む「コンポーネント」ウィンドウ・ページを宣言する方法を示しています。Extension SDKの詳細は、「Extension SDKを使用した開発」を参照してください。

<?xml version="1.0" encoding="UTF-8" ?>
<extension xmlns="http://jcp.org/jsr/198/extension-manifest"
id="oracle.ide.extsamples.cppageprovider"
version="11.1.1"
esdk-version="1.0">
<name>ESDK Sample - Component Palette Page Provider</name>
<owner>Oracle</owner>
<feature-member id="esdk-samples"
xmlns="http://xmlns.oracle.com/ide/extension"/>
<hooks>
<palette-hook xmlns="http://xmlns.oracle.com/jdeveloper/1013/extension">
<pageProvider>
<providerClassName>oracle.ide.extsamples.pageprovider.SamplePageProvider</provider
ClassName>
</pageProvider>
<page>
<name>Sample Components (ESDK Sample)</name>
<pageId>SampleStatic</pageId>
<showForTypes>
<type>java</type>
</showForTypes>
<technologyScopes>
<technologyScope>Java</technologyScope>
</technologyScopes>
<type>java</type>
<group>
<name>Components</name>
<groupId>SampleStatic-Components</groupId>
<showForTypes>
<type>java</type>
</showForTypes>
<technologyScopes>
<technologyScope>Java</technologyScope>
</technologyScopes>
<type>java</type>
<section>
<sectionId>SampleStatic-Components-Section1</sectionId>
<name/>
<item>
<name>Table</name>
<description>Sample Table</description>
<icon>${OracleIcons.TABLE}</icon>
<info/>
<type>JavaBean</type>
<itemId>SampleStatic-Components-Section1-Item1</itemId>
<technologyScopes>
<technologyScope>Java</technologyScope>
</technologyScopes>
</item>
</section>
</group>
</page>
</palette-hook>
<feature-hook>
<part-of>oracle.ide.extsamples.allsamples</part-of>
<description>Demonstrates how to integrate a component palette page provider into the IDE.</description>
<optional>true</optional>
</feature-hook>
</hooks>
</extension>

2.4.8.3 「コンポーネント」ウィンドウ・ページの動的コンポーネントを宣言する方法

ロードする前に「コンポーネント」ウィンドウのコンテンツを識別できないことがあります。「コンポーネント」ウィンドウのコンテンツを事前に定義できない場合は、「コンポーネント」ウィンドウ・ページ・プロバイダを定義する必要があります。この方法によりクライアント開発の柔軟性が高くなります。つまり、「コンポーネント」ウィンドウが表示コンテキストをプロバイダに提供すると、プロバイダが、「コンポーネント」ウィンドウに表示するコンポーネントを返します。

「コンポーネント」ウィンドウ・ページ・プロバイダは、公開されている「コンポーネント」ウィンドウAPIを使用してクライアントの開発者によって開発され、ページ・プロバイダのクラス名は、拡張機能マニフェスト・ファイルの「コンポーネント」ウィンドウに提供されます。

「コンポーネント」ウィンドウAPIの詳細は、Oracle Fusion Middleware Oracle Extension SDK Java APIリファレンスのoracle.ide.palette2を参照してください。

拡張機能マニフェストのエントリはフックのelement pageProviderを使用します。

次の例は、「コンポーネント」ウィンドウ・ページ・プロバイダのクラス名を指定する拡張機能マニフェストです。

<?xml version="1.0" encoding="windows-1252" ?>
<extension xmlns="http://jcp.org/jsr/198/extension-manifest"
id="oracle.ide.samples.pageprovider"
version="1.0"
esdk-version="1.0">
<name>Component Palette Page Provider Sample</name>
<owner>Oracle</owner>
<dependencies>
<import>oracle.ide.palette2
</dependencies>
<hooks>
<palette-hook xmlns="http://xmlns.oracle.com/jdeveloper/1013/extension">
<pageProvider>
<providerClassName>oracle.ide.samples.pageprovider.SamplePageProvider</providerClassName>
</pageProvider>
</palette-hook>
</hooks>
</extension>

次の例は、「コンポーネント」ウィンドウに「コンポーネント」ウィンドウ・ページを追加する、「コンポーネント」ウィンドウ・ページ・プロバイダを示しています。このクラスはPalettePageProviderを拡張します。

extension.xmlの要素pageProvider.providerClassNameは、このクラスをページ・プロバイダとして「コンポーネント」ウィンドウに登録します。「コンポーネント」ウィンドウは、現在のコンテキストを使用してcreatePalettePages()を呼び出します。

PalettePagesを拡張するクラスSamplePagesは、現在のコンテキストで構成されます。つまり、このクラスがパレット・ページのリストを編成するために十分な情報を得るのは、getPages()が「コンポーネント」ウィンドウから呼び出されるときです。

package oracle.ide.samples.pageprovider;
SamplePageProvider.java
import oracle.ide.Context;
import oracle.ide.palette2.PalettePageProvider;
import oracle.ide.palette2.PalettePages;
/**
* SamplePageProvider
* <p>
* This is an example of a PalettePageProvider that adds a palette page to the
* Component Palette(CP).  As required this class extends PalettePageProvider.
* </p>
* <p>
* Element pageProvider.providerClassName in extension.xml registers
* this class with the CP as a page provider.
* </p>
* <p>
* The CP will call method createPalettePages() with the current Context.
* Class SamplePages which extends PalettePages is constructed with the current context.
* Using the current context SamplePages should have sufficient information to
* assemble a list of palette pages when method getPages() is called by the CP.
* </p>
*
* @see SamplePages
* @see SamplePalettePage
* @see SamplePaletteGroup
* @see SamplePaletteItem
*/
public class SamplePageProvider extends PalettePageProvider  {
/**
* Default constructor.
*
*/
public SamplePageProvider() {
}
/**
* Override the default, returns SamplePages if context applies.
*
* @param context
* @return PalettePages if context is relevant, otherwise null.
*/
public PalettePages createPalettePages(Context context) {
if ( checkRelevantContext( context ) )  {
SamplePages pages = SamplePages.getInstance();
pages.initialize(context);
return pages;
}
else
return null; // no pages to provide for this context.
}
}

次の例は、SamplePages.javaのインスタンスを示しています。このクラスは、pageTypeがjavaの場合に、1つのアイテムと1つのセクションを含む1つのグループで「コンポーネント」ウィンドウ・ページを作成します。必要に応じてこのクラスはPalettePagesを拡張します。

package oracle.ide.samples.pageprovider;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import oracle.ide.Context;
import oracle.ide.net.URLFileSystem;
import oracle.ide.palette2.DefaultPaletteSection;
import oracle.ide.palette2.PaletteItem;
import oracle.ide.palette2.PalettePage;
import oracle.ide.palette2.PalettePages;
import oracle.ide.palette2.PalettePagesListener;
/**
* SamplePages
* <p>
* This class creates a palette page with a single group that contains a
* single section that contains a single item when the pageType is "java".
* As required this class extends PalettePages.
* </p>
* <p>
* TODO: palettePagesListener
* </p>
*/
public class SamplePages extends PalettePages {
private final static String SAMPLEPROVIDER_ID =SamplePageProvider.class.getName();
/**
* Singleton
*/
private static SamplePages _singleton = new SamplePages();
/**
* Composite for PalettePagesListener
*/
protected List<PalettePagesListener> palettePagesListeners;
/**
* Composite for PalettePage
*/
protected List<PalettePage> palettePages;
// Default constructor
public SamplePages() {
}
/**
* Returns the singleton instance of SamplePages.
* @return the singleton instance of SamplePages
*/
public static SamplePages getInstance() {
return _singleton;
}
/**
* Initialize palettePages.
* @param context
*/
public void initialize(Context context) {
URL url = context.getNode().getURL();
final String pageType = getSuffix( url );
// Only interested in java.
if( pageType.equals("java") ) {
if( palettePages != null ) {
palettePages.clear();
}
// create a PalettePage
SamplePalettePage page = new SamplePalettePage "oracle.ide.samples.pageprovider.SampPage01" // pageId
, "My Sample Page Component"  // description
, null                   // icon
, "java"                 // type
, "java"                 // showForTypes
, "Java;JavaBeans" );    // technologyScope
// create a PaletteGroup
SamplePaletteGroup group = new SamplePaletteGroup "oracle.ide.samples.pageprovider.SampGroup01" // groupId
, "My Sample Group"         // name
, "My Sample Group Component"  // description
, "java" );                // type
// add group to page
page.addGroup(group);
// create a section. Make the name null since a separator is not neeeded.
DefaultPaletteSection section = new DefaultPaletteSection "oracle.ide.samples.pageprovider.SampSection01"  // sectionId
// add section to group
group.addSection(section);
// create an item. TODO: use SampleBean.java
SamplePaletteItem item = new SamplePaletteItem          ("oracle.ide.samples.pageprovider.SampItem01"  // itemId
, SAMPLEPROVIDER_ID  // provider id
, "My Sample Bean"    // name
, "My Sample Bean Description"  // description
, "/oracle/ide/samples/pageprovider/snapshot.png"   // icon
, "java");           // type
// add item to section
section.addItem(item);  // add item to section
// add page
addPage(page);
}
else {
palettePages.clear();
}
}
/**
* getPages
*/
public Collection<PalettePage> getPages() {
return Collections.unmodifiableList(palettePages);
}
/**
* Returns the PaletteItem identified by itemId.  providerId is used to
* determine whether this item is owned by this page provider.
* The provider returns the matching PaletteItem only if the PaletteItem
* is within the current context. Null is returned if the PaletteItem is
* within the current context or not recognized by this provider.
* </p>
* @return PaletteItem
*/
public PaletteItem getItem( String providerId, String itemId ) {
if( providerId == null || providerId.length() == 0
|| itemId == null || itemId.length() == 0 ) {
return null;
}
PaletteItem paletteItem = null;
if( providerId.equals(SAMPLEPROVIDER_ID)) {
for( PalettePage palettePage : palettePages ) {
SamplePalettePage sampPage = (SamplePalettePage) palettePag
paletteItem = sampPage.getItem(itemId);
if( paletteItem != null ) {
break;
}
}  // end of for
}
return paletteItem;
}
/**
* addPalettePagesListener
public void addPalettePagesListener(PalettePagesListener listener) {
if( palettePagesListeners == null ) {
palettePagesListeners = new ArrayList<PalettePagesListener>();
}
palettePagesListeners.add(listener)
}
/*
* add pages to palettePages.
/*
private void addPage( SamplePalettePage sampPage ) {
if (palettePages == null ) {
palettePages = new ArrayList<PalettePage>();
}
palettePages.add(sampPage);
}
*/
* Return suffix
* @param title Title of EditorFrame
*/
private String getSuffix( URL url )
(
final String suffix = URLFileSystem.getSuffix( url );
int period = suffix.lastIndexOf( "." );
if( period != -1 )
{
// Is a selected file
return suffix.substring( period + 1 );
}
return "";
}
}

次の例は、SamplePalettePage.javaのインスタンスを示しています。

package oracle.ide.samples.pageprovider;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import oracle.ide.palette2.DefaultPalettePage;
/**
* SamplePalettePage
* <p>
* This class extends DefaultPalettePage. DefaultPalettePage comprises
* the attributes and methods that this example requires. A constructor is added
* to accomodate the data values for this sample.
* </p>
*/
public class SamplePalettePage extends DefaultPalettePage {
public SamplePalettePage(String pageId, String pageName, String pageDescription
, String pageIcon, String pageType, String pageShowForTypes
, String pageTechnologyScope) {
setName( pageName );
setDescription( pageDescription );
setIcon( pageIcon );
setData(PAGE_PAGEID, pageId );
setData(PAGE_TYPE, pageType);
// make delimited string into a List of strings
List<String> showForTypes = new ArrayList<String>();
final StringTokenizer tknTypes = new StringTokenizer pageShowForTypes, ";" ); //NOTRANS
while( tknTypes.hasMoreTokens() )
{
String token = (String)tknScopes.nextToken();
technologyScope.add(token);
}
setData(PAGE_TECHNOLOGYSCOPES, technologyScope );
}
}

package oracle.ide.samples.pageprovider;
import oracle.ide.palette2.DefaultPaletteGroup;
/**
* SamplePaletteGroup
* <p>
* This sample extends DefaultPaletteGroup.DefaultPaletteGroup comprises the
* attributes and methods that this example requires. A constructor is added to
* accomodate the data values for this sample.
* </p>
*
*/
public class SamplePaletteGroup extends DefaultPaletteGroup {
public SamplePaletteGroup(String groupId, String groupName, String groupDescription, String groupType) {
setName( groupName );
setDescription( groupDescription );
setData(GROUP_GROUPID, groupId);
setData(GROUP_TYPE, groupType);
}
}

次の例は、SamplePaletteItem.javaのインスタンスを示しています。

package oracle.ide.samples.pageprovider;
import oracle.ide.palette2.DefaultPaletteItem;
* SamplePaletteItem
* <p>
* This example extends DefaultPaletteItem. DefaultPaletteItem comprises
* the attributes  and methods that this example requires. A constructor is
* added to accommodate the data values for this sample.
* </p>
*
*/
public class SamplePaletteItem extends DefaultPaletteItem
{
public SamplePaletteItem(String itemId, String itemProviderId, String itemName, String itemDescription,
String itemIcon, String itemType) {
setName( itemName );
setDescription( itemDescription );
setIcon( itemIcon );
setItemId( itemId );
setProviderId(itemProviderId);
setData(ITEM_TYPE, itemType);
)
)

2.4.8.4 「コンポーネント」ウィンドウ・ページのヘルプを用意する方法

コンポーネントにヘルプを用意する方法は2つあります。

- 「コンポーネント」ウィンドウ・アイテムの説明は、コンポーネントのツール・チップとして表示され、ユーザーが「コンポーネント」ウィンドウのコンポーネントの上にマウスを重ねると表示できます。説明を複数の行に分けるには改行文字\nを使用します。

- ユーザーは「コンポーネント」ウィンドウ・コンポーネントを右クリックして、コンテキスト・メニューからヘルプを選択できます。「ヘルプ」オプションがコンポーネントのコンテキスト・メニューに表示されるのは、そのコンポーネントにHelpableがある場合のみです。helpableクラスをインスタンス化できない場合は、その文字列がIDEヘルプ・システムのhelpIdとして使用されます。

次の例は、その方法を示しています。

<item>
<name>Table</name>
<description>Sample Table</description>
<icon>/oracle/ide/samples/pageprovider/table.png</icon
<info/>
<type>JavaBean</type>
<itemId>SampleStatic-Components-Section1-Item1</itemId>
<technologyScopes>
<technologyScopes>
<technologyScope>JavaBeans</technologyScope>
</technologyScopes>
<helpable>oracle.samples.SampleHelpable</helpable>
</item>

または、次の例のようにhelpidを直接指定できます。

<item>
<name>Table</name>
<description>Sample Table</description>
<icon>/oracle/ide/samples/pageprovider/table.png</icon>
<info/>
<type>JavaBean</type>
<itemId>SampleStatic-Components-Section1-Item1</itemId>
<technologyScopes>
<technologyScope>Java</technologyScope>
<technologyScope>JavaBeans</technologyScope>
</technologyScopes>
<helpable>help_topic_id</helpable>
</item>

これと同じ処理をプログラミングで行うには、getHelpable()をPaletteItemインタフェースに実装します。

2.4.8.5 「コンポーネント」ウィンドウ・アイテムの検索を補強する方法

デフォルトでは、ユーザーが「コンポーネント」ウィンドウの検索ボックスに語または語句を入力すると、JDeveloperは、名前か説明に検索文字列が含まれるアイテムを検索します。

ユーザーに対して表示されない他の埋込みデータ(タグ属性など)を「コンポーネント」ウィンドウによって検索するために、アイテムと一緒にsearchTextContextを指定できます。

次の例に示すように、「コンポーネント」ウィンドウの拡張機能フックでこれを宣言的に指定できます。

<item>
<name>Table</name>
<description>Sample Table</description>
<icon>/oracle/ide/samples/pageprovider/table.png</icon>
<info/>
<type>JavaBean</type>
<itemId>SampleStatic-Components-Section1-Item1</itemId>
<technologyScopes>
<technologyScope>Java</technologyScope>
<technologyScope>JavaBeans</technologyScope>
</technologyScopes>
<searchTextContext>MySearchContext</searchTextContext>
</item>

次の例に示すように、SearchContextがPaletteSearchインタフェースを実装します。

class MySearchContext implements PaletteSearch
{
boolean searchItemContainsText(String itemId, String searchString)
{
boolean found = false;
// Search internal data
return found;
}
}

2.4.9 プリファレンスについて

ユーザーが自らのプリファレンスを変更および保存できるようにすると、JDeveloperの拡張機能を使用するプロセスに生産性と柔軟性が付加されます。

2.4.9.1 プリファレンスの実装方法

製品レベルのプリファレンスはPreferencesクラスで管理します。詳細は、Oracle Fusion Middleware Oracle Extension SDK Java APIリファレンスのPreferencesに関する項を参照してください。

プリファレンスを保存するために使用されるデータ構造はHashStructureです。これもOracle Fusion Middleware Oracle Extension SDK Java APIリファレンスで説明されています。Preferencesクラスは、1つの拡張機能ディレクトリ(製品全体を表す拡張機能)のみにプリファレンスを保存します。たとえば、JDeveloperでは製品ディレクトリの形式はjdev-user-directory/system/oracle.JDeveloper.12.1.3.x.yとなります。12.1.3はバージョン番号、x.yはビルド番号です。プリファレンスを含むファイルの名前はpreferences.xmlです。

一連の新しいプリファレンスをIDEに組み込むには、次の手順を実行します。

1. プリファレンスを保存するためのデータ・モデルを実装します。詳細は、「データ・モデルの実装方法」を参照してください。

2. プリファレンスを保存するためのデータ・モデルを実装します。詳細は、「UIパネルの実装方法」を参照してください。

3. UIパネルを「プリファレンス」ダイアログに登録します。これは「ツール」メニューから選択できます。詳細は、「UIパネルの登録方法」を参照してください。

4. プリファレンス・モデルを取得します。詳細は、「プリファレンス・モデルの取得方法」を参照してください。

5. プリファレンスの変更をリスニングして、変更を保存できるようにします。詳細は、「変更のリスニング方法」を参照してください。

2.4.9.2 データ・モデルの実装方法

プリファレンス・データを表すクラスは、HashStructureAdapterのサブクラスである必要があります。詳細は、Oracle Fusion Middleware Oracle Extension SDK Java APIリファレンスのHashStructureAdapterに関する項を参照してください。

次の例には、詳細なコメントが付いた、標準的な実装パターンが含まれます。

package oracle.killerapp.coolfeature;
import oracle.javatools.data.HashStructure;
import oracle.javatools.data.;
import oracle.javatools.data.PropertyStorage;
// Start with class being final.  You can always remove final if subclassing ever
// proves useful.  In many cases, subclassing is actually unnecessary and may get
// you into an instanceof/typecast mess.  Consider defining a separate (not
// subclass) adapter class instead.
public final class CoolFeaturePrefs extends
{
// The DATA_KEY should be a hard-coded String to guarantee that its value stays
// constant across releases.  Specifically, do NOT
// constant across releases.  Specifically, do NOT use CoolFeaturePrefs.class.getName().
// The reason is that if CoolFeaturePrefs is ever renamed or moved,
// CoolFeaturePrefs.class.getName() will cause the DATA_KEY String to        change,which
// introduces a preferences migration issue (since this key is used in the persisted
// XML) that will require more code and testing to accommodate and open up your code to
// annoying little bugs.  Unknowing developers have been trapped by this problem before,
// so eliminate this cause of bugs by using a hard-coded String for DATA_KEY.
//
// By convention, DATA_KEY should be the fully qualified class name of the
// .  This helps ensure against name collisions. This also makes it
// easier to identify what piece of code is responsible for a preference when you're
// looking at the XML in the product-preferences.xml file.  Of course, that only works
// as long as the adapter class itself is never renamed or moved, so avoid renaming or
// moving this class once it's been released in production.
private static final String DATA_KEY = "oracle.killerapp.coolfeature.CoolFeaturePrefs";
// Private constructor enforces use of the public factory method below.
private CoolFeaturePrefs(HashStructure hash)
{
super(hash);
}

// Factory method should take a PropertyStorage (instead of HashStructure directly).
// This decouples the origin of the HashStructure and allows the future possibility
// of resolving preferences through multiple layers of HashStructure. Classes/methods
// that currently implement/return PropertyStorage:
// - oracle.ide.config.Preferences
// - oracle.ide.model.Project
// - oracle.ide.model.Workspace
// - oracle.ide.panels.TraversableContext.getPropertyStorage()
public static CoolFeaturePrefs getInstance(PropertyStorage prefs)
{
// findOrCreate makes sure the HashStructure is not null.  If it is null, a
// new empty HashStructure is created and the default property values will
// be determined by the getters below.
return new CoolFeaturePrefs(findOrCreate(prefs, DATA_KEY));
}
-----------------------
// Like DATA_KEY, all other keys also appear in the XML, so they should not be
// changed once released into production, or else you'll have some migration  issues
// to fix
private static final String MAX_NUMBER_OF_THINGIES = "maxNumberOfThingies";  //NOTRANS
private static final int DEFAULT_MAX_NUMBER_OF_THINGIES = 17;

public int getMaxNumberOfThingies()
{
// Specify default in the getInt call to take advantage of HashStructure's
// placeholder mechanism.  See HashStructure javadoc for details on placeholders.
return _hash.getInt(MAX_NUMBER_OF_THINGIES, DEFAULT_MAX_NUMBER_OF_THINGIES);
}
public void setMaxNumberOfThingies(int maxNumberOfThingies)
{
_hash.putInt(MAX_NUMBER_OF_THINGIES, maxNumberOfThingies);
}
//---------------------------------------------
private static final String THINGIE_NAME = "thingieName";   //NOTRANS
private static final String DEFAULT_THINGIE_NAME = "widget";  //NOTRANS
public String getThingieName()
{
return _hash.getString(THINGIE_NAME, DEFAULT_THINGIE_NAME);
}
public void setThingieName(String thingieName)
{
return _hash.putString(THINGIE_NAME, thingieName);
}
// etc..
}

2.4.9.3 UIパネルの実装方法

プリファレンス・パネルを実装するクラスは、DefaultTraversablePanelのサブクラスである必要があります。詳細は、Oracle Fusion Middleware Oracle Extension SDK Java APIリファレンスのDefaultTraversablePanelに関する項を参照してください。

次の例は、標準的な実装パターンを示します。

package oracle.killerapp.coolfeature;
import oracle.ide.panels.DefaultTraversablePanel;
// You should keep the panel class package-private and final unless there
// is a good reason to open it up.  In general, preferences panels are not
// supposed to be part of a published API, so the class modifiers should
// enforce that.
final class CoolFeaturePrefsPanel extends DefaultTraversablePanel
{
// But, the no-arg constructor still needs to be public.
public CoolFeaturePrefsPanel()
{
// Layout the controls on this panel.
}
public void onEntry(TraversableContext tc)
{
final CoolFeaturePrefs prefs = getCoolFeaturePrefs(tc);
// Load prefs into the panel controls' states.
}
public void onExit(TraversableContext tc)
{
final CoolFeaturePrefs prefs = getCoolFeaturePrefs(tc);
// Save the panel controls' states to prefs.
}
private static CoolFeaturePrefs getCoolFeaturePrefs(TraversableContext tc)
{
// If you've implemented CoolFeaturePrefs according to the typica
// implementation pattern given above, this is how you attach the
// adapter class to the defensive copy of the preferences being
// edited by the Tools->Preferences dialog.
return CoolFeaturePrefs.getInstance(tc.getPropertyStorage());
}
}

2.4.9.4 UIペインの登録方法

次の例は、拡張機能マニフェスト(extension.xml)のXMLフラグメントです。これは、前に説明したパネルを「プリファレンス」ダイアログ(「ツール」メニューから選択可能)に登録します。

<extension ...>
<hooks>
<settings-ui-hook xmlns="http://xmlns.oracle.com/ide/extension">
<page id="CoolFeaturePrefs" parent-idref="/preferences">
<label>${SOME_RES_KEY}</label>
<traversable-class>oracle.killerapp.coolfeature.CoolFeaturePrefsPanel
</traversable-class>
</page>
</settings-ui-hook>
</hooks>
</extension>

2.4.9.5 プリファレンス・モデルの取得方法

プリファレンス・ダイアログ・コード以外のコードでプリファレンスの読取りと書込みを行う必要がある場合は、oracle.ide.config.Preferencesクラスを使用してプリファレンスを取得します。この方法はプリファレンス・ページでは使用しないでください。このコードを使用してプリファレンス・オブジェクトに変更を加えると、すぐに有効になります。このため、常に取り消せるようにする必要がある「プリファレンス」ダイアログには適していません。

Preferences p = oracle.ide.config.Preferences.getPreferences();
CoolFeaturePrefs myPrefs = CoolFeaturePrefs.getInstance( p );

2.4.9.6 変更のリスニング方法

プリファレンス・モデル・オブジェクトの基礎になっているハッシュ構造にoracle.javatools.data.StructureChangeListenerをアタッチすると、プリファレンスの変更をリスニングできます。通常、適切な方法は、次の例に示すようにリスナーをモデル・オブジェクトにアタッチするためのメソッドを公開することです。

public final class CoolFeaturePrefs extends
{
//...
public void addStructureChangeListener( StructureChangeListener l )
{
_hash.addStructureChangeListener( l );
}
public void removeStructureChangeListener( StructureChangeListener l )
{
_hash.removeStructureChangeListener( l );
}
//...
}

2.4.10 プロジェクト・プロパティについて

プロジェクト・プロパティはプロジェクト・プリファレンスに似ています。「プリファレンスについて」を参照してください。

プロジェクト・プロパティはProjectクラスを使用して管理します。詳細は、Oracle Fusion Middleware Oracle Extension SDK Java APIリファレンスのProjectに関する項を参照してください。

2.4.10.1 プロジェクト・プロパティの共有方法

アプリケーションの作業をする際、アプリケーション内のプロジェクトがプロパティ設定を共有していると役立ちます。プロジェクト・プロパティの共有は、実行/デバッグ構成から設定するか、プロジェクト・テンプレートをカスタマイズしてプロジェクト作成リスナーを追加し、そのテンプレートで新規プロジェクトを作成するたびに呼び出されるように設定します。これは、拡張機能のライターがプロジェクトの実行構成やその他のプロパティを変更することを許可します。この項では、実行/デバッグ構成を設定して、アプリケーション内のプロジェクト間で共通する設定を使用できるようにする方法を説明します。テンプレートにプロジェクト作成リスナーを追加する方法の説明は、TBDを参照してください。

次のいずれかの時点で、共有された実行構成を使用するようにプロジェクトを構成できます。

- プロジェクトがプロジェクト・テンプレートを使用して作成される際に呼び出される作成リスナーを使用してプロジェクトを作成するとき。

- テクノロジがプロジェクトに追加されたとき

- プロジェクトの移行時

JDeveloperではSharedProjectPropertiesManager APIを提供しており、これを実行構成ファイルに追加して、実行構成プロパティの共有を有効化できます。

- SharedPropertiesManager: 共有プロパティを管理します。

- SharedPropertiesManager getInstance(): 共有プロパティのインスタンスを取得します。

- HashStructure getProperties(Project project、String propertyDataKey): ワークスペースまたはプロジェクトの適切なプロパティ・ハッシュを返します。

- propertiesAreShareable(String): 共有するプロジェクト・プロパティを指定します。

- isUsingSharedProperties(Project, String): プロジェクトで指定された共有プロパティが使用されているかを検証します。

- setUsesSharedProperties(Project, String, boolean): 共有されたプロパティがプロジェクトで使用されるかどうかを設定します。

次の例に示すように、SharedProjectPropertiesManagerを使用して、プロジェクトで共有実行構成プロパティを使用するように構成します。

if (SharedProjectPropertiesManager.getInstance().propertiesAreShareable( RunConfigurations.DATA_KEY ))
{
Project project = ...;
SharedProjectPropertiesManager.getInstance().setUsesSharedProperty( project, RunConfigurations.DATA_KEY, true );
}

または、IDEから、実行構成プロパティを使用するようプロジェクトを設定できます。

共有実行構成を使用するには:

1. 「プロジェクト」ウィンドウでプロジェクトを右クリックし、「プロジェクト・プロパティ」を選択します。

2. 「プロジェクト・プロパティ」ダイアログで実行/デバッグを選択します。

3. 実行/デバッグ・ページで共有設定の使用を選択します。

このオプションを選択すると、共有された実行構成がアプリケーションに保存されます(.jwsファイル)。アプリケーション内のすべてのプロジェクトがこれらのプロパティ設定を使用できます。

4. 実行構成リストで使用する実行構成を選択します。

新しい共有可能な実行構成を追加したり、既存のものを編集するには、共有設定の編集をクリックします(共有設定の使用が選択されている場合のみこのオプションを使用できます)。

2.4.11 変更をUNDO可能にする方法

急速に繰り返されるモデルに基づいてアプリケーション開発を進めるユーザーにとっては、ソリューションからソリューションへと移動する際に、変更を簡単に取り消すための機能が重要です。変更内容をUNDO可能にする機能を追加すると、ユーザーにこの機能が提供されます。

2.4.11.1 テキスト変更をUNDO可能にする方法

拡張機能でなんらかの形式のテキスト入力が使用される場合、たとえば、会社で使用される特定の機能を備えたカスタム・テキスト・エディタを実装する場合、ユーザーは、テキストを入力しているときに行った変更を元に戻せることを期待します。次の例に示すように、UndoableEditを使用すると、ユーザーがテキストに対して加えた変更が拡張機能による実行または取消しが可能になります。

import javax.swing.undo.UndoableEdit;
import oracle.ide.Context;
import oracle.ide.controller.Command;
import oracle.ide.controller.CommandProcessor;
import oracle.ide.model.TextNode;
import oracle.javatools.buffer.TextBuffer;
public class MyCommand extends Command
{
private UndoableEdit _undoableEdit;
public MyCommand(Context context)
{
super(-1, Command.NORMAL, "Insert Hello");
setContext(context);
}
public int doit() throws Exception
{
if (_undoableEdit == null)
{
final TextNode textNode = (TextNode) context.getNode();
final TextBuffer textBuffer = textNode.acquireTextBuffer();
textBuffer.beginEdit();
textBuffer.insert(0, "Hello World".toCharArray());
_undoableEdit = textBuffer.endEdit();
textNode.releaseTextBuffer();
} else
{
_undoableEdit.redo();
}
return OK;
}
public int undo() throws Exception
{
_undoableEdit.undo();
return OK;
}
}

2.4.11.2 コマンドをUNDO可能にする方法

UNDO可能な変更をドキュメントに加える場合は、次の例に示すように、変更内容を実行する方法と元に戻す方法を認識しているコマンドを実装する必要があります。

import oracle.ide.controller.Command;
import oracle.ide.Context;
import oracle.ide.model.Node;
public class MyCommand extends Command
{
public MyCommand(Context context, Node affectedNode)
{
super(-1, Command.NORMAL, "My Changes");
// The context usually already contains the node so this would not be necessary
final Context contextCopy = new Context(context);
contextCopy.setNode(affectedNode);
setContext(contextCopy);
}
public int doit() throws Exception
{
final Node affectedNode = context.getNode();
// Do the changes to the node here
return OK;
}
public int undo() throws Exception
final Node affectedNode = context.getNode();
// Undo the changes to the node here
return OK;
}
}

2.5 トリガー・フックの定義および使用

<trigger-hooks>要素はhttp://xmlns.oracle.com/ide/extensionネームスペースにあります。

<trigger-hooks>要素には次の3つの子要素が含まれます。

- <registry> - トリガー・フック・ハンドラを登録するために使用されます。

- <triggers> - ここにすべてのトリガー・フックが配置されます。

- <rules> - 一連のトリガーを条件付きで実行するときに使用できる条件を定義します。

IDEで提供されるトリガー・フックを次に示します。

- アクション

- コントローラ

- メニュー

- コンテキスト・メニュー

- 機能フック

- エディタ・メニュー

- アクセラレータ/ショートカット・キー

- ギャラリ・アイテム

- テクノロジ・スコープ

- エディタ

- NodeFactoryレコグナイザ

- IDEプリファレンス/設定

- アプリケーション・プリファレンス/設定

- プロジェクト・プリファレンス/設定

- コンテンツ・セット・プロバイダ

- シングルトン登録

- アプリケーションおよびプロジェクト・マイグレータ

- URLFileSystemフック

- ImportExportフック

- メニュー・カスタマイズ・フック

- ブリッジ拡張機能フック

- オン・プロジェクト・オープン・フック

- ヘルプ・コールバック・フック

- ヘルプ・フック

- ドッキング可能フック

- ヒストリアン・フック

- 外部ツール・フック

2.5.1 <trigger-hook-handler>の登録方法

独自のトリガー・フックを定義するには、次の例に示すようにトリガー・フック・ハンドラを登録します。

<trigger-hooks xmlns="http//xmlns.oracle.com/ide/extension/myExtension">
<registry>
<trigger-hook-handler
tag-name="my-hook"
handler-class="oracle.ide.extension.HashStructureHook"
namespace="http://xmlns.oracle.com/ide/extension"
schema-location="my-hook.xsd"
register-as-hook="true"/>
</registry>
</trigger-hooks>

register-as-hook属性は、拡張機能のフックを<hooks>セクションにも指定できるかどうかを制御します。デフォルト値はfalseです。同じ要素を<hooks>でサポートする意味がある場合だけtrueに設定します。

既存の宣言型フックがあり、それをトリガー・フックにする場合は、現在のフック・ハンドラの登録を削除して、かわりのトリガー・フック・ハンドラを登録する必要があります。

JDeveloperで使用されていた以前の標準に対して構築された既存の拡張機能を更新する場合は、下位互換性のために、前と同じネームスペースを使用できます。既存のフックが古いjdeveloper-hookの子で、これもトリガー・フックとしてサポートする場合は、属性register-as-jdeveloper-hookをtrueに設定します。

コアIDEの外部にある拡張機能は、コアIDEに含まれるhook-handlerクラスを使用する必要があります。次の2つの方法があります。

- ハンドラ・クラスとしてのoracle.ide.extension.HashStructureHook。トリガー・フックも<hooks>にある場合またはトリガー・フックが条件トリガー・セクションで使用できる場合、HashStructureを監視した後で新しい要素はHashStructureHookによって処理されます。この状況では、コードはHashStructureHookイベントをリスニングする必要があります。

- DeferredElementVisitorHookを使用すると、フックのXMLデータを処理するためにカスタムElementVisitorクラスを使用できます。したがって、すでにカスタム・フック・ハンドラを作成した場合は、コードを再利用できます。

2.5.2 拡張機能のトリガー・フックを定義する方法

トリガー・フックを使用するには、次の例のような構文を使用します。

<triggers>
<singleton-provider-hook>
<singleton base-class="oracle.bali.xml.addin.JDevXmlContextFactory"
impl-class="oracle.bali.xml.addin.JDevJavaXmlContextFactory" />
</singleton-provider-hook>
</triggers>
</trigger-hooks>

2.5.3 ExtensionRegistryから解析済情報を取得する方法

要素名にtrigger-hook-handlerを定義すると、そのExtensionHookハンドラ・クラスの1つのインスタンスが作成され、そのトリガー・フックが使用されるときは常に処理します。

ExtensionHookインスタンスを取得するには、ExtensionRegistry.getHook(elementName)を呼び出します。以前のバージョンのJDeveloperの拡張機能開発では、通常の宣言フックのExtensionHookを取得するためにこのAPIが使用されていました。処理されたすべてのトリガー・フックと、現在ロードされているすべてのフック・セクションは、ExtensionHookインスタンスの同じバケットに加えられます。

trigger-hook-handlerがHashStructureHookの場合、返されるHashStructureHookインスタンスからHashStructureを取得できます。これには、HashStructureでの要素名のすべての使用箇所のXML情報や、HashStructureの異なるセクションがどの拡張機能のものかを示す格納情報が含まれます。HashStructureAdapterサブクラスを使用すると、HashStructureから情報を抽出できます。

2.5.4 ルールおよび条件トリガー・セクションの定義方法

この項では、拡張機能マニフェストでルールや条件を定義する方法について説明します。

2.5.4.1 ルールの定義方法

ルールやルールのタイプが、拡張機能マニフェストextension.xmlの<trigger-hooks>の<rules>セクションで定義されます。

rule-typeは、Javaに実装されるルール関数を表し、関数が受け取るパラメータを指定します(メソッドのシグネチャなど)。IDEによって提供される組込みのルール・タイプのセットがあります。

ルールは、パラメータの特定の値を渡す、ルール関数の呼出しを表します。各ルールにはグローバルに一意のIDが付けられ、ルールをサポートするフックからIDで参照されます。

ルール・フレームワークは、IDEモジュールのoracle.ide.extension.rulesです。

ルール・タイプを定義するには、次の項目を指定する必要があります。

- 参照のためのID

- oracle.ide.extension.rules.RuleFunctionのサブクラスであり、サポートされるパラメータをリストする実装クラス。パラメータがオプションと必須のどちらかを指定できます。

IDEモジュールのextension.xmlによって、次の例に示すようにいくつかの組込みルール・タイプが定義されます。

<trigger-hooks xmlns="http://xmlns.oracle.com/ide/extension">
<rules>
<rule-type id="always-enabled" class="oracle.ide.extension.rules.functions.AlwaysEnabled" />

<rule-type id="any-selection-has-attribute" class="oracle.ide.extension.rules.functions.AnySelectionHasAttribute">
<supported-parameters>
<param name="element-attribute" required="true"/>
</supported-parameters>
</rule-type>
<rule-type id="context-has-element" class="oracle.ide.extension.rules.functions.ContextHasElement">
<supported-parameters>
<param name="element-class" required="true"/>
</supported-parameters>
</rule-type>
<rule-type id="context-has-node" class="oracle.ide.extension.rules.functions.ContextHasNode">
<supported-parameters>
<param name="node-class" required="true"/>
</supported-parameters>
</rule-type>
<rule-type id="context-has-project" class="oracle.ide.extension.rules.functions.ContextHasProject" />
<rule-type id="context-has-view" class="oracle.ide.extension.rules.functions.ContextHasView">
<supported-parameters>
<param name="view-class" required="true"/>
</supported-parameters>
</rule-type>
<rule-type id="context-has-workspace" class="oracle.ide.extension.rules.functions.ContextHasWorkspace" />
<rule-type id="element-has-attribute" class="oracle.ide.extension.rules.functions.ElementHasAttribute">
<supported-parameters>
<param name="element-attribute" required="true"/>
</supported-parameters>
</rule-type>
<rule-type id="on-extension-init" class="oracle.ide.extension.rules.functions.ExtensionInitialized">
<supported-parameters>
<param name="extension-id" required="true"/>
</supported-parameters>
</rule-type>
<rule-type id="extension-is-enabled" class="oracle.ide.extension.rules.functions.ExtensionEnabled">
<supported-parameters>
<param name="extension-id" required="true"/>
</supported-parameters>
</rule-type>
<rule-type id="on-single-selection" class="oracle.ide.extension.rules.functions.SingleSelection">
<supported-parameters>
<param name="element-class" required="false"/>
</supported-parameters>
</rule-type>
<rule-type id="on-multiple-selection" class="oracle.ide.extension.rules.functions.MultipleSelection">
<supported-parameters>
<param name="element-class" required="false"/>
</supported-parameters>
</rule-type>
<rule-type id="node-is-dirty" class="oracle.ide.extension.rules.functions.NodeIsDirty" />
<rule-type id="project-has-techscope" class="oracle.ide.extension.rules.functions.ProjectHasTechScope">
<supported-parameters>
<!-- Comma-separated list of technology keys -->
<param name="technology-keys" required="true" />
<!-- Specify 'all' or 'any' for match, to specify if all keys should exist or any one key suffices -->
<param name="match" required="false" />
</supported-parameters>
</rule-type>
</rules>
</trigger-hooks>

<rule-type>のハンドラは、<rule>の解析中に使用するために、またルールの実行時評価のためにこの情報を保存します。ルール・クラスは、ルールを評価する必要が生じる最後の瞬間までロードされません。

独自のルール・タイプを導入できますが、いくつかの制限事項を理解することが重要です。

- IDEは、完全にロードされていない拡張機能からはルール・タイプ・クラスをロードしません。

- ルール評価は、拡張期のロードをトリガーしません。

拡張機能E1がR1-rule-typeとT1-trigger-hookを導入するケースについて考えてみます。T1-trigger-hookではルールの使用がサポートされるとします。拡張機能E1が完全にロードされたときだけ、T1-trigger-hookのデータを使用して、そこで参照されているルールを評価します。したがって、R1-rule-typeのルールをT1-trigger-hookで使用するのは適切です。

ただし、R1-rule-typeのルールをide-coreトリガー・フック(galleryなど)で使用しようとすると、そのルールが評価されるときに拡張機能E1がロードされている保証はありません。その場合にはエラーが記録されます。

2.5.4.2 単純なルールの定義方法

ルールは、<trigger-hooks>の<rules>セクションで定義されます。ルール・タイプを定義するには、参照のためのID、ルール・タイプを特定するタイプ属性およびルール・タイプで必要なパラメータの値を指定する必要があります。

この次の例に示すように、<rule>のハンドラによって次の項目が確認されます。

- IDが一意かどうか。

- タイプの値が、extension.xml(または依存関係のextension.xml)に定義されたルール・タイプのIDと一致するか。

- 必須パラメータのすべてに値があるか。

- 指定されているすべてのパラメータが、ルール・タイプに定義されたパラメータ名と一致するか。

<rules>
<rule id="context-has-text-node" type="context-has-node">
<parameters>
<param name="node-class" value="oracle.ide.model.TextNode" />
</parameters>
</rule>
<rule id="context-has-source-node-1" type="context-has-node">
<parameters>
<param name="node-class" value="org.product.SourceNode1" />
</parameters>
</rule>
<rule id="context-has-source-node-2" type="context-has-node">
<parameters>
<param name="node-class" value="org.product.SourceNode2" />
</parameters>
</rule>
<rule id="on-xxx-init" type="on-extension-init">
<parameters>
<param name="extension-id" value="org.product.MyXxxExtension"/>
</parameters>
</rule>
<rule id="on-yyy-init" type="on-extension-init">
<parameters>
<param name="extension-id" value="org.product.MyYyyExtension"/>
</parameters>
</rule>
<rule id="on-text-node-single-selection" type="on-single-selection">
<parameters>
<param name="element-class" value="oracle.ide.model.TextNode" />
</parameters>
</rule>
</rules>
</trigger-hooks>

2.5.4.3 暗黙に使用できるルール

必須パラメータのない各ルール・タイプは、自動的にルールとして登録されます(ルール・タイプIDがルールIDとして使用されます)。たとえば、context-has-projectとnode-is-dirtyは、必須パラメータのないルール・タイプの例です。これらのIDは、ルールが参照される場所であればどこでも使用できます。<rule>をextension.xmlに明示的に追加する必要はありません。

2.5.4.4 ルールのガイドライン

ルールを含めるextension.xmlとルール名を注意深く選択することにより、IDの重複を回避して、最大限に再利用できます。

経験則としては、パラメータとして渡すクラス名を含む拡張機能を見つけて、ルールをその拡張機能のextension.xmlに含めます。たとえば、「単純なルールの定義方法」の例の中のcontext-has-source-node-1ルールを定義するには、SourceNode1クラスを含む拡張機能を探して、ニーズを満たす既存のルールがあるかどうかを確認します。存在しない場合は、ルールをそのextension.xmlに追加します。

IDは、次のように、わかりやすく、ルール・タイプIDに基づくように設定する必要があります。

- context-has-xxx-node

- context-has-xxx-node

- context-has-xxx-element

- context-has-xxx-view

- on-xxx-single-selection

- on-xxx-init

2.5.4.5 複合ルールの定義方法

他のルールとブール演算子で構成されるルールを定義できます。サポートされるブール演算子は、<or>、<and>および<not>です。<and>および<or>ブール演算子要素は、任意の数の子を受け入れます。<not>要素は1つの子を受け入れます。ブール演算子の子のそれぞれは、次の例に示すように、ルールの参照か別のブール演算子である必要があります。

<trigger-hooks xmlns="http://xmlns.oracle.com/ide/extension">
<rules>
<composite-rule id="context-has-xxx-or-yyy-node">
<or>
<rule-reference id="context-has-jsp-node" />
<rule-reference id="context-has-zzz-node" />
</or>
</composite-rule>
<composite-rule id="on-aaa-and-bbb-init">
<and>
<rule-reference id="on-aaa-init" />
<rule-reference id="on-bbb-init /">
</and>
</composite-rule>
<composite-rule id="more-complicated-composite-rule">
<or>
<rule-reference id="rule-a" />
<and>
<rule-reference id="rule-b" />
<not>
<rule-reference id="rule-c" />
</not>
</and>
</or>
</composite-rule>
</rules>
</trigger-hooks>

2.5.4.6 フックからルールを参照する方法

すべてのルールはextension.xmlの<rules>セクションに定義され、ルールをサポートするフックでIDによって参照されます。

トリガー・フックでルールをサポートする場合に必要となるのは、ルールのIDを受け入れるための構文の変更だけです。規約では、ルールIDをruleという名前の属性に指定する必要があります。これらを、この次の3つの例に示します。

例1

...
<item rule="always-enabled">
<name>oracle.jdeveloper.template.wizard.TemplateWizard</name>
<id>Application</id>
<description>${NEW_APPLICATION_TEMPLATE_GALLERY_ITEM}</description>
<help>${MANAGE_TEMPLATES_WIZARD_DESCRIPTION}</help>
<folder>Applications</folder>
<technologyKey>General</technologyKey>
<icon>/oracle/javatools/icons/apptemplate.jpg</icon>
</item>
</gallery>

例2

<controllers xmlns="http://xmlns.oracle.com/ide/extension">
<controller class="com.random.FooController">
<update-rules>
<update-rule rule="on-text-node-selected">
<action id="some.action.id1">
<label>Perform Action on {0}</label>
<label-param>${node.name}</label-param>
</action>
</update-rule>
</update-rules>
</controller>
<controller class="com.random.BarController">
<update-rules>
<update-rule rule="on-jsp-node-selected">
<action id="some.action.id3" />
<action id="some.action.id4" />
<action id="some.action.id5" />
</update-rule>
</update-rules>
</controller>
</controllers>

例3

<context-menu-hook rule="context-has-xxx-or-yyy-node">
<site ref-id="navigator"/>
<menu>
<section xmlns="http://jcp.org/jsr/198/extension-manifest" id="MY_CUSTOM_MENU_SECTION_ONE" weight="1.0">
<item action-ref="myTriggerActionId" weight="1.0" />
<item action-ref="myOtherTriggerActionId" weight="2.0" />
</section>
</menu>
</context-menu-hook>

2.5.4.7 ルール参照の検証方法とルールの評価方法

トリガー・フックを実装しているときに、フックでルールをサポートする場合は、ルールのIDを受け入れるルール属性をXML構文に追加します(ルール属性のXMLスキーマ・タイプはxsd:NCNameにする必要があります)。

フック・ハンドラの実装で、ルール属性の値を取得するときは、次のメソッドをRuleEngineで呼び出して、ルール参照の解析時評価を実行します。

public static boolean validateRuleReference(String id, Set<String> expectedRuleTypes, ElementContext referenceContext

このメソッドは、そのIDの既知のルールが(同一extension.xmlまたは依存関係に)存在することを検証します。また、オプションのexpectedRuleTypesを渡すと、ルールがそれらのタイプの1つかどうかを検証します(複合ルールの場合は、すべてのパーティクルが予期されるタイプであることが必要です)。オプションのreferenceContextパラメータが渡されると、すべての問題はElementContextのロガーでログをとります。

ルールを実際に評価するときには、ルール・エンジンでルールIDをIDEコンテキスト(ある場合)と一緒にメソッドに渡します。ルール・エンジンは、ルール・タイプ・クラスをインスタンス化し、ルール定義のパラメータをコンテキストと一緒に渡して、trueまたはfalseを返します。

public static boolean evaluateRule(String id, Context ideContext)

最初のメソッドは、ルール評価時に発生する例外のログをとり、ルールの評価に問題がある場合はfalseを返します。後のメソッドは、すべての例外のログをとりますが、呼出し元に例外をスローします(呼出し元が別のアクションを実行する場合)。

2.6 オンライン・ヘルプ・サポートの追加

JDeveloperによって使用されるヘルプ・システムでは、コンテキスト依存の[F1]キーのトピックをIDEの構造に統合して提供しています。ユーザーがヘルプにアクセスするには、ウィザード・パネルまたはダイアログの「ヘルプ」ボタンをクリックするか、[F1]キーを押します。

拡張機能でもコンテキスト依存の[F1]ヘルプ・トピックを提供すると、拡張機能のユーザーが拡張機能を理解して効果的に使用できるようになります。

2.6.1 ヘルプ・システムの作成方法

ヘルプ・システムを作成するにはhelpsetを用意します。これは多数のHTMLヘルプ・トピックを含むJavaアーカイブです。

ヘルプ・システムの作成の詳細は、次を参照してください。その他の資料およびOracle Help for Java Developer's Kitのダウンロードは、http://www.oracle.com/technetwork/developer-tools/help/index-083946.htmlを参照してください。

ヘルプ・システムを作成するには、次の手順を実行します。

1. ウィザードの各パネルまたは各ウィンドウや各エディタで、パネルについて説明するHTMLトピック・ファイルを作成します。

2. helpsetのマップ制御ファイルを作成します。

3. helpset (.HS)制御ファイルを作成します。

4. トピックと制御ファイルをJavaアーカイブにアセンブルします。アーカイブのルート名はHSファイルと同じにして、HSファイルはアーカイブのルート・ディレクトリに配置する必要があります。

5. コンポーネントとヘルプ・トピックを関連付けます。各パネルに、registerTopicへの呼出しを指定して、トピックIDを登録します。たとえば、panelがウィザード・パネルの名前で、topicがドキュメントのトピックIDの場合、呼出しは次のようになります。

HelpSystem.getHelpSystem().registerTopic((JComponent)panel, topic);

6. helpsetのJavaアーカイブをデプロイのために拡張機能に組み込みます。これで、拡張機能がロードされるとユーザーがヘルプ・トピックを使用できるようになります。

2.6.2 ヘルプ・システムの登録方法

拡張機能のヘルプ・システムは、拡張機能がロードされる前にユーザーが使用する必要があります。これは、ユーザーが機能分野を把握できるようにするためです。このため、次の例に示すようにヘルプ・システムを登録する必要があります。

<trigger-hooks xmlns="http://xmlns.oracle.com/ide/extension">
<triggers>
<help xmlns="http://xmlns.oracle.com/jdeveloper/1013/extension">
<item>
<helpName>ejb</helpName>
<helpURL>../doc/$edition/ohj/helpset.jar!/helpset.hs</helpURL>
<relativeTo>using_diagrams</relativeTo>
<relativePosition>after</relativePosition>
</item>
</help>
</triggers>
</trigger-hooks>

2.7 印刷サポートの追加

JDeveloperでは、ComponentまたはTextNodeに基づいてPageableオブジェクトを作成できるDocumentPrintFactoryのデフォルト実装が提供されます。

2.7.1 DocumentPrintFactoryの登録方法

次の例に示すように、DocumentPrintFactoryをextension.xmlに宣言的に登録することで印刷がサポートされます。

<hooks>
<print-hook xmlns="http://xmlns.oracle.com/ide/extension">
<documentPrintFactory id="oracle.jdevimpl.help.HelpTopicDocumentPrintFactory"
class="oracle.jdevimpl.help.HelpTopicDocumentPrintFactory" />
</print-hook>
</hooks>

2.7.2 ビュー・クラスを登録して印刷を有効化する方法

ビューから印刷できるようにするには、ビュー・クラスと、印刷がビューで呼び出されたときにPageableオブジェクトを作成するDocumentPrintFactoryを登録する必要があります。

次の例は、oracle.ide.navigator.NavigatorWindowのprintHelperを登録する方法を示し、oracle.ide.print.DocumentPrintFactoryというIDで登録されたDocumentPrintFactoryを、Pageableオブジェクトの作成で使用することを指定します。

<hooks>
<print-hook xmlns="http://xmlns.oracle.com/ide/extension">
<printHelper documentPrintFactoryId="oracle.ideri.navigator.NavigatorPrintFactory"
view-class="oracle.ide.navigator.NavigatorWindow" />
</print-hook>
</hooks>

別のものを印刷するか、デフォルトの印刷機能を拡張する場合は、DocumentPrintFactoryを拡張して、ビューのPageableオブジェクトを作成し、DocumentPrintFactoryの実装を登録します。次の例は、複数のビューで同じDocumentPrintFactoryを使用する方法を示します。

<print-hook xmlns="http://xmlns.oracle.com/ide/extension">
<documentPrintFactory id="oracle.jdevimpl.help.HelpTopicDocumentPrintFactory"
class="oracle.jdevimpl.help.HelpTopicDocumentPrintFactory" />
<printHelper documentPrintFactoryId="oracle.jdevimpl.help.HelpTopicDocumentPrintFactory"
view-class="oracle.jdevimpl.help.HelpTopicEditor" />
<printHelper documentPrintFactoryId="oracle.jdevimpl.help.HelpTopicDocumentPrintFactory"
view-class="oracle.jdevimpl.help.HelpWindow" />
<printHelper documentPrintFactoryId="oracle.jdevimpl.help.HelpTopicDocumentPrintFactory"
view-class="oracle.jdevimpl.help.HelpContentPanel" />
<printHelper documentPrintFactoryId="oracle.jdevimpl.help.HelpTopicDocumentPrintFactory"
view-class="oracle.jdevimpl.help.HelpCenterWindow$HelpCenterView" />
</print-hook>
</hooks>

2.7.2.1 ノード処理のためのPageableFactory実装を登録する方法

JDeveloperでは、印刷するTextNodeデータを扱うためにデフォルトのPageableFactory実装が提供されます。

場合によっては、必要な出力が提供される実装で標準のPageableFactory実装をオーバーライドします。たとえば、NavigatorWindowに登録されているDocumentPrintFactoryはNavigatorPrintFactoryです。印刷するためにPageableオブジェクトを作成する必要がある場合は、PrintManager.createPageableForObject()を呼び出します。これが、選択された要素に最適なPageableFactoryを見つけようとします。ノード・クラスの処理に使用されるPageableFactoryを登録できます。

<print-hook xmlns="http://xmlns.oracle.com/ide/extension">
<textNodePageableFactory node-class="oracle.mypackage.MyNodeClass"
weight="0.5">oracle.mypackage.MyPageableFactory</textNodePageableFactory>
</print-hook>

次の例では、ノード・クラスは、指定されたPageableFactoryで処理する必要があるノード(この場合はoracle.mypackage.MyPageableFactory)を指定します。現在の要素との一致をチェックするとき、登録されたPageableFactory実装のリストを順序付けるために重みが使用されます。

2.8 アプリケーションまたはプロジェクト・テンプレートの作成

JDeveloper付属のアプリケーションまたはプロジェクト・テンプレートが自分の独自のニーズを満たさない場合は、自分でアプリケーションまたはプロジェクト・テンプレートを定義できます。アプリケーションおよびプロジェクト・テンプレートは、モジュールのextension.xmlファイル内で宣言によって定義され、それぞれ自動的に「一般」 > 「アプリケーション」および「一般」 > 「プロジェクト」内の新規ギャラリにロードされます。テンプレート定義から動的ウィザードが生成され、アプリケーションまたはプロジェクトの定義ページと、オプションでプロジェクトのテクノロジごとに1つの追加構成ページが表示されます。

2.8.1 アプリケーションまたはプロジェクト・テンプレートの定義

アプリケーションまたはプロジェクト・ギャラリ・テンプレートは、extension.xmlファイル内のテンプレート・フックを使用して定義します。

2.8.1.1 テンプレート・フックの定義

テンプレート・フックを使用して、プロジェクトおよびアプリケーション・テンプレートを作成します。<template-hook>要素には子要素<projectTemplate>および<applicationTemplate>が含まれ、http://xmlns.oracle.com/ide/extensionネームスペースにあります。

<projectTemplate>要素を使用してプロジェクト・ギャラリに表示されるプロジェクト・テンプレートを定義します。<projectTemplate>には次の子要素が含まれます。

- <name> - ギャラリに表示されるプロジェクト名を指定します。

- <templateId> - 一意のプロジェクトIDを指定します。

- <unsorted> - (オプション)ギャラリのリストでこのアイテムを先頭にしてテンプレート・リストをソートします。この要素は、デフォルト・テンプレートをリストの先頭に置くために使用するよう意図されているため、推奨しません。

- <galleryFolder> - プロジェクトに加え、フォルダにギャラリ・アイテムを追加します。

- <description> - プロジェクトの簡潔な説明。

- <packageName> - デフォルトのパッケージ名を表示します。

- <toolTip> - (オプション)IDEのプロジェクト・ウィンドウで、カーソルがプロジェクト名またはアイコンの上に置かれたときに、プロジェクトのパスを表示します。

- <icon> - (オプション)ギャラリ内のプロジェクトのアイコンを指定します。

- <projectName> - プロジェクトのファイル名を指定します。名前が指定されなかった場合は、デフォルト名(Project1、Project2、...)が使用されます。

- <creationListener> - 作成リスナー要素を指定します。

- <excludeFromGallery> - このプロジェクト・テンプレートが、そのアプリケーション・テンプレートのコンテキストのみで使用されるかどうかを指定します。この要素をtrueに設定すると、ギャラリ内の使用可能なプロジェクトのリストにこのプロジェクトが表示されません。

<applicationTemplate>要素を使用して、アプリケーション・ギャラリに表示されるアプリケーション・テンプレートを定義します。<applicationTemplate>には、次の子要素が含まれます。

- <name> - ギャラリに表示されるアプリケーション名を指定します。

- <templateId> - 一意のアプリケーションIDを指定します。

- <unsorted> - (オプション)ギャラリのリストでこのアイテムを先頭にしてテンプレート・リストをソートします。この要素は、デフォルト・テンプレートをリストの先頭に置くために使用するよう意図されているため、推奨しません。

- <galleryFolder> - アプリケーションに加え、フォルダにギャラリ・アイテムを追加します。

- <description> - アプリケーションの簡潔な説明。

- <packageName> - デフォルトのパッケージ名を表示します。

- <toolTip> - (オプション)IDEのアプリケーション・ウィンドウで、カーソルがアプリケーション名またはアイコンの上に置かれたときに、アプリケーションのパスを表示します。

- <icon> - (オプション)ギャラリ内のアプリケーションのアイコンを指定します。

- <applicationName> - アプリケーションのファイル名を指定します。名前が指定されなかった場合は、デフォルト名(Application1、Application2、...)が使用されます。

- <projectTemplates> - アプリケーション内のプロジェクトを指定する<projectTemplate>要素が含まれます。

2.8.1.2 プロジェクト・テンプレートを作成する方法

プロジェクト・テンプレートは、モジュールのextension.xmlファイル内で宣言によって定義します。テンプレートは自動的に「一般」 > 「アプリケーション」または「一般」 > 「プロジェクト」内の新規ギャラリにロードされます。テンプレート定義から動的ウィザードが生成され、プロジェクトの定義ページと、オプションでプロジェクトのテクノロジごとに1つの追加構成ページが表示されます。

次の例に、Javaプロジェクト・テンプレートのテンプレート定義を示します。

<projectTemplate>
<name>${TEMPLATE_JAVA_PROJECT}</name>
<description>${TEMPLATE_JAVA_PROJECT_DESC}</description>
<packageName>${TEMPLATE_JAVA_PROJECT_PACKAGE}</packageName>
<projectName>${TEMPLATE_JAVA_PROJECT_JPR_NAME}</projectName>
<templateId>javaProjectTemplate</templateId>
<technologyScope>
<technologyKey>Java</technologyKey>
<technologyKey>Swing/AWT</technologyKey>
<technologyKey>JavaBeans</technologyKey>
</technologyScope>
</projectTemplate>

2.8.1.3 アプリケーション・テンプレートの作成方法

同様に、アプリケーション・テンプレートは、モジュールのextension.xmlファイル内で宣言によって定義します。アプリケーション・テンプレートも、自動的に新規ギャラリにロードされます。テンプレート定義から動的ウィザードが生成され、アプリケーションの定義ページが表示されます。

次の例に、Javaアプリケーション・テンプレートのテンプレート定義を示します。

<applicationTemplate>
<name>${TEMPLATE_JAVA_APP}</name>
<templateId>javaAppTemplate</templateId>
<unsorted>true</unsorted>
<galleryFolder>General</galleryFolder>
<description>${TEMPLATE_JAVA_APP_DESC}</description>
<projectTemplates>
<projectTemplate>
<templateId>javaProjectTemplate</templateId>
</projectTemplate>
</projectTemplates>
</applicationTemplate>

2.8.2 テンプレートの登録

一部の拡張機能を使用する場合、プロジェクトにすでに含まれているテクノロジから独立して、プロジェクトがあるテクノロジをサポートするようカスタマイズする必要がある場合があります。プロジェクトをカスタマイズするには、プロジェクト・テンプレートを変更して作成リスナーを登録し、変更されたテンプレートからプロジェクトが作成されると通知を受けるようにできます。

2.8.2.1 作成リスナーの登録

creationListener要素を登録すると、リスナーが定義されているテンプレート(IDによって識別)からプロジェクトが作成されると、作成リスナーが呼び出されます。

creationListener要素はオプションです。リスナーはテンプレートに登録されていなければ、呼び出されません。呼び出される場合、次の例に示すように、リスナーはプロジェクトの作成後に呼び出されます。

<template-hook>
<projectTemplate>
<templateId>testCallbackProjectTemplate</templateId>
<name>Creation Listener Test Project</name>
<description>A project for testing creation listener callbacks.</description>
<projectName>sylvia</projectName>
<creationListener>oracle.myfeature.wizard.MyWizardCallback</creationListener>
<excludeFromGallery>true</excludeFromGallery>
</projectTemplate>
<applicationTemplate>
<templateId>testCallbackAppTemplate</templateId>
<name>Creation Listener Test App</name>
<description>Creates an application for testing wizard creation listener implementation.</description>
<applicationName>WizardCallbackApp</applicationName>
<projectTemplates>
<projectTemplate>
<templateId>testCallbackProjectTemplate</templateId>
</projectTemplate>
</projectTemplates>
</applicationTemplate>
</template-hook>

2.8.3 新規アプリケーションまたはプロジェクト・ウィザードにテクノロジのページを追加するには

プロジェクト・テンプレートには、ユーザーがプロジェクトに特定のテクノロジを含められるようにするページを使用できます。オプションで、これらの各テクノロジにつき、テンプレート作成ウィザードに表示される構成ページを定義できます。

特定のテクノロジ・スコープのウィザード・ページを定義するには、そのページをテクノロジ・スコープの宣言に追加する必要があります。次の例に、Javaテクノロジ・スコープの定義を示します。このテクノロジ・スコープにより、ページがプロジェクト作成ウィザードに追加されます。これらのウィザード・ページは、oracle.ide.panels.DefaultTraversablePanelを拡張し、oracle.jdeveloper.wizard.template.WizardTraversableを実装する必要があります。

<technology-hook xmlns="http://xmlns.oracle.com/ide/extension">
<technology>
<key>Java</key>
<name>${JAVA_TECH}</name>
<description>${JAVA_TECH_DESC}</description>
<wizard-pages>
<page>
<traversable-class>oracle.jdevimpl.wizard.project.JavaTechnologyPanel         </traversable-class>
</page>
</wizard-pages>
</technology>
</technology-hook>

2.8.4 アプリケーション・テンプレートへのページの追加方法

アプリケーション・テンプレートを作成した後、ページを追加する必要がある場合があります。たとえば、ユーザーがビルド構成を指定できるページを提供するよう、テンプレートにページを追加する場合があります。アプリケーションの作成ウィザードにページを追加するには、<applicationAddonPage>要素をテンプレート定義に含めます。

アプリケーション・テンプレートでは、サブスクライブしているアドオン・ページ・グループのリストを定義する必要があります。複数のグループにサブスクライブすることが可能です。アドオン・ページは、公開先のアドオン・ページ・グループを定義する必要があります。これは1つのグループである必要があります。複数のアドオン・ページが同じグループに公開できます。同じページを複数のグループに公開する必要がある場合、アドオン・ページ・テンプレート・フックをもう1つ作成し、同じクラス名を返します。

アドオン・ページは、アプリケーション・テンプレートAPIの強化機能です。その機能は次のとおりです。

- パネルをすべてのアプリケーション・テンプレートまたは特定のアプリケーション・テンプレートに追加する機能

- アプリケーション・テンプレートがアドオン・ページの使用を選択できるようにする機能

- パネルを既存のアプリケーション・テンプレートの最初、アプリケーション定義の直後に追加する機能

- パネルを既存のアプリケーション・テンプレートの最後に追加する機能

注意:

アドオン・ページは、どうしても必要で、任意の理由でアプリケーション・テンプレートを変更できない場合のみ使用してください。

次の例では、アプリケーション・テンプレートを定義するextension.xmlファイルにある、テンプレートがアドオン・ページ・グループの使用を選択できるようにする<addonPageGroups>フィールドが含まれている既存のテンプレート・フックを示しています。

<applicationTemplate>
<name>${TEMPLATE_JAVA_APP}</name>
<templateId>javaAppTemplate</templateId>
<unsorted>true</unsorted>
<galleryFolder>General</galleryFolder>
<description>${TEMPLATE_JAVA_APP_DESC}</description>
<projectTemplates>
<projectTemplate>
<templateId>javaProjectTemplate</templateId>
</projectTemplate>
</projectTemplates>
<addonPageGroups>
<addonPageGroup>testGroup</addonPageGroup>
</addonPageGroups>
</applicationTemplate>

<addonPage>要素は、次の例で示されている、アドオン・ページを定義するテンプレート・フックのextension.xmlの一部です。

<template-hook>
<applicationAddonPage>
<name>${TEMPLATE_TEST_ADDON_PAGE_NAME}</name>

<pageId>testPage</pageId>

<label>${TEMPLATE_TEST_ADDON_PAGE_LABEL}</label>

Needs to be translated so reference a key in a resource bundle.-->
<title>${TEMPLATE_TEST_ADDON_PAGE_TITLE}</title>

<class>oracle.jdeveloper.MyPanel</class>

<location>beginning</location>

<addonPageGroup>testGroup</addonPageGroup>
</applicationAddonPage>
</template-hook>

<applicationAddonPage>要素には、次の子要素が含まれます。

- <name> - ページ名を指定します。

- <pageID> - ページの一意のIDを指定します。

- <label> - ウィザードでの進行状態を示す、ウィザード・ダイアログの左側に表示される名前を指定します。

- <title> - ウィザード・ページの詳細を説明する、ウィザード上部に表示される内容を指定します。

- <class> - インスタンスを作成するパネルを宣言します。WizardTraversableおよびTraversableを実装する必要があります。

- <location> - (オプション)ページを挿入する位置を、ウィザードの最初または最初と指定します。この要素が指定されていない場合、デフォルトの値はendです。

- <addonPageGroup> - このアドオン・ページ・テンプレートが追加されるアドオン・ページ・グループを指定します。

ページをアプリケーション・テンプレートに追加するには、次の基本手順に従ってください。

1. <addonPageGroup>要素をextension.xmlファイルのテンプレート・フックに追加します。

<template-hook>
<applicationAddonPage>
<name>testPage</name>
<pageId>testPage</pageId>
<label>dude</label>
<title>yo dude</title>
<class>oracle.jdeveloper.MyPanel</class>
<addonPageGroup>testGroup</addonPageGroup>
</applicationAddonPage>
</template-hook>

2. WizardTraversable、TraversableおよびAddonPageインタフェースを実装するコンポーネントを作成します。

public class MyPanel extends JPanel implements WizardTraversable, Traversable, AddonPage
{
public MyPanel() // The default constructor is the constructor that is called.
{
//...
}

//...
}

3. アプリケーション・テンプレートでアドオンが使用可能になっていることを確認します。

<applicationTemplate>
<!-- ... -->
<addonPageGroups>
<addonPageGroup>testGroup</addonPageGroup>
</addonPageGroups>
</applicationTemplate>

3 Extension SDKを使用した開発

この章では、JDeveloperにダウンロードできるExtension SDKと、それを使用した独自の拡張機能の開発方法について説明します。

この章の内容は次のとおりです。

- Extension SDKを使用した開発について

- Extension SDKのダウンロードとインストール

- サンプル拡張機能の使用

- サンプル・プロジェクトの実行

3.1 Extension SDKを使用した開発について

JDeveloper Extension Software Developer Kit (SDK)には、サンプル・コードを含んだプロジェクトのコレクションや、Extension SDK APIについてのJavadoc生成ドキュメントが含まれています。

各サンプル・プロジェクトには、サンプルを適切なディレクトリにワンクリックでデプロイするためのデプロイメント・プロファイルが含まれています。すべてのプロジェクトを一度にデプロイすることもできます。

各種拡張機能を提供するコードをテンプレートとして使用することで、類似する複数の機能を効率よく開発できます。

3.2 Extension SDKのダウンロードとインストール

Extension SDKは「更新の確認」ウィザードを使用してダウンロードおよびインストールできます(ダウンロードはOracle Webサイトからも可能です)。

「更新の確認」を使用してExtension SDKをインストールするには、次のようにします。

1. Oracle Fusion Middleware Oracle JDeveloperによるアプリケーションの開発の「更新の確認」を使用して拡張機能をインストールする方法にある情報に従って操作し、ソース・ページでOfficial Oracle Extensions and Updates更新センターを選択します。

2. 更新ページで、利用可能な拡張機能のリストからExtension SDKを選択し、「次へ」をクリックします。拡張機能のサイズによっては、インターネットの接続状況に応じてダウンロードに数分かかることがあります。

3. ウィザードが完了すると、JDeveloperが再起動してExtension SDKがインストールされます。再起動の際、この章で説明したサンプル・プロジェクトを含むサンプル・アプリケーションをJDeveloperにインストールするかどうかをたずねられます。「はい」を選択すると、「アプリケーション」ウィンドウでextensionsdkアプリケーションが開き、サンプル・プロジェクトがリストされます。

ファイアウォール内で作業している場合、JDeveloperはプロキシ・サーバーの詳細情報を入力するまで更新センターに接続できません。この操作は、Webブラウザまたは「プリファレンス」ダイアログ・ボックス(「ツール」メニューから選択可能)のプロキシ・ページで行えます。行わない場合は、「更新の確認」ウィザードがタイムアウトし、Webブラウザとプロキシ・ページが表示されます。

ファイルを使用してExtension SDKをインストールするには、次のようにします。

1. Oracle Fusion Middleware Oracle JDeveloperによるアプリケーションの開発のOTNからの拡張機能の直接インストール方法にある情報に従って操作し、Official Oracle JDeveloper Extensionsのページに移動します。

2. Extension SDKをローカルの場所にダウンロードし、「ヘルプ」メニューから「更新の確認」ウィザードを開きます。

3. ソース・ページで、「ローカル・ファイルからインストール」を選択し、esdk_bundle.zipファイルの場所を入力して、ウィザードを完了します。

4. JDeveloperが再起動してExtension SDKがインストールされます。再起動の際、この章で説明したサンプル・プロジェクトを含むサンプル・アプリケーションをJDeveloperにインストールするかどうかをたずねられます。「はい」を選択すると、「アプリケーション」ウィンドウでextensionsdkアプリケーションが開き、サンプル・プロジェクトがリストされます。

3.2.1 Extension SDKインストール時の処理内容

Extension SDKを正常にインストールすると、オプションによってサンプル・アプリケーションが「アプリケーション」ウィンドウ内で開き、JDeveloperの各種機能を説明するサンプル・プロジェクトにアクセスできるようになります。これらのコードを使用することで、独自の拡張機能を効率よく開発できます。

Oracle Fusion Middleware Oracle Extension SDK Java APIリファレンスへは、オンライン・ヘルプ(「ヘルプ」メニューからアクセス)の「目次」リストにある「参照」からアクセスできます。

3.2.2 Extension SDKのインストールに関するトラブルシューティング

ファイアウォール内で作業していて、Extension SDKを正常にダウンロードできない場合は、Webブラウザおよび「プリファレンス」ダイアログ・ボックス(「ツール」メニューから選択可能)のプロキシ・ページで、プロキシ・サーバー設定が設定されていることを確認してください。

「更新の確認」ウィザードによって更新センターの場所が特定された際、接続の速度によっては、利用可能な拡張機能のリストが表示されるまでに数分かかることがあります。

ウィザードでExtension SDKを選択すると、ウィザードの起動中にダウンロードが実行されますが、接続の速度によっては、これにも数分かかることがあります。拡張機能のダウンロードが完了したら、それをインストールするためにJDeveloperを再起動する必要があります。その後、結果を示すメッセージが表示されます。

3.3 サンプル拡張機能の使用

Extension SDKをインストールすると、アプリケーションextensionsdkがインストールされ、これには、様々な種類のJDeveloper要素を作成および使用する方法の例を示す多数のプロジェクトが含まれています。

サンプルの実行に関する詳細は、「サンプル・プロジェクトの実行」を参照してください。

大部分の拡張機能のサンプルの説明は、次を参照してください。

http://www.oracle.com/technetwork/developer-tools/jdev/samples-083838.html

次のリストは、一部のサンプル拡張機能プロジェクトと、その主な機能の簡略な解説を抜き出したものです。

- ApplicationOverview.jpr: 「アプリケーション概要」ウィンドウへのプラグイン方法を示します。「アプリケーション」および「プロジェクト」の両方のコンテキスト・メニューに、「概要の表示」メニュー・アイテムを追加します。次に方法を示します。

- AuditRefactor.jpr: 監査フレームワークを使用してJavaコード内の問題を検出する方法と、リファクタAPIを使用して問題を自動的に修正するための変換を記述する方法を示します。

- Balloon.jpr: JDeveloperのステータス・バーにバルーン通知をインストールする方法を示します。

- ClassBrowser.jpr: JDeveloperのClassBrowserの使用方法を示します。

- ClassGenerator.jpr: プロジェクト内にjavaファイルを生成するためのJOT (Java Object Tool)の基本を示します。また、有限ステート・マシン(FSM)ウィザード・ユーティリティを使用してマルチ・ステップのウィザードを作成する方法も示します。

- ClassSpy.jpr: 「アプリケーション」ウィンドウ内の特定ノードのクラスを識別する最も簡単な方法と、その名前をログ・ウィンドウに書き込む方法を示します。

- ClickableURL.jpr: 「ログ」ウィンドウ内にクリック可能なURLを生成する方法を示します。

- CodeInteraction.jpr: コード・エディタからテキストを取得し、現在選択されているテキストについてのGoogle検索を起動する方法を示します。

- ConfigPanel.jpr: プリファレンスを格納および取得する方法と、「プリファレンス」ダイアログ内にパネルをインストールする方法を示します。

- CPPageProvider.jpr: palette2 APIを使用してコンポーネント・パレット内にプラグインする方法を示します。

- CreateDialog.jpr: ギャラリから呼び出されるシンプルな作成ダイアログの例です。

- CreateStructure.jpr: 空の新規アプリケーション(.jwsファイル)を作成し、その中に空の新規プロジェクト(.jprファイル)を追加する方法を示します。

- CustomEditor.jpr: 特定のファイル用に使用する、独自エディタの実装方法を示します。動作中のツールを参照するには、任意のXMLファイルを開き、問合せページに切り替えます。

- CustomExtensionHook.jpr: カスタム拡張機能フックを使用して、他の拡張機能が自分の拡張機能にプラグインできるようにする方法を示します。

- CustomNavigator.jpr: カスタムの「アプリケーション」ウィンドウをインストールする方法を示します。よくアクセスされるファイルを格納するために使用できる、「お気に入り」ウィンドウをインストールします。

- DebugObjectPreferences.jpr: デバッガの「データ」ウィンドウに対する、カスタム・オブジェクト・プリファレンス・レンダラのインストール方法を示します。

- DockableWindow.jpr: カスタムのドッキング可能ウィンドウを実装する方法を示します。

- ExternalToolCreation.jpr: 外部プログラム用の外部ツール・ショートカットをインストールするアドインの記述方法を示します。この機能は、実際にはJDeveloper IDEの一部であり、ウィザードを使用して外部アプリケーションを設定します。外部ツールの詳細は、Oracle Fusion Middleware Oracle JDeveloperによるアプリケーションの開発のJDeveloperへの外部ツールの追加の項を参照してください。

- ExternalToolImportExport.jpr: 外部ツールのリストに関連付けられたプロパティをインポートおよびエクスポートします。

- ExternalToolMacros.jpr: 外部ツールで使用するためのカスタム・マクロをインストールするアドインの記述方法を示します。

- ExternalToolScanner.jpr: ユーザーが「外部ツール」ダイアログ(「ツール」メニューから選択可能)の「ツールの検索」ボタンをクリックしたときに、外部プログラムのショートカットを自動的にインストールできる、外部ツール用スキャナの記述方法を示します。

- FirstSample.jpr: JDeveloperの拡張機能の記述に関わる主要な概念を説明するサンプルです。

- FlatEditor.jpr: extension.xmlに使用されるものと同様の、フォームベースの概要エディタの実装方法を示します。

- HelloX.jpr: これは、新規ギャラリ・アイテム、アクションおよびメニュー・アイテムなどのコア・コンセプトを説明するサンプルです。

- LayoutMenuFilter.jpr: レイアウトが変更されたときにIDE内のトップ・レベルのメニューをフィルタリングする方法を示します。

- MethodCallCounter.jpr: JOT (Java Object Tool)を使用して、特定のコード内での名前付きメソッドの発生件数をカウントします。

- OpenNodes.jpr: NodeFactory内で開いているノードを示すドッキング可能ウィンドウを実装し、ノードの開閉時を追跡します。
このサンプルの実行時には、表示→ESDKSample: オープン・ノードを選択して、オープン・ノード・トラッカ・ウィンドウを開きます。これは、NodeFactory内で開いているノードを表示し、ノードの開閉時を追跡するものです。

- Overlay.jpr: バージョン・コントロール拡張機能によって使用されるものと同様のオーバーレイを「アプリケーション」ウィンドウ内で使用する方法を示します。

- ProgressBar.jpr: 長いタスクを実行する際の進行状況バーの実装方法を示します。

- ProjectSettings.jpr: プロジェクト・プロパティの格納および取得方法と、カスタム・プロジェクト設定UIの追加方法を示します。

- StructurePane.jpr: 構造ウィンドウに独自のコンテンツを表示する方法を示します。

- UpdateCenter.jpr: カスタム更新センターを拡張機能の一部としてインストールする方法を示します。

3.4 サンプル・プロジェクトの実行

JDeveloper内でサンプル・プロジェクトを実行して、それらの動作内容を確認できます。

サンプル・プロジェクトを実行するには、次のようにします。

1. サンプル・プロジェクト拡張機能を最初に実行する際には、いずれかを右クリックし、「ターゲット・プラットフォームへのデプロイ」を選択する必要があります。

2. 拡張機能を実行するには、それを右クリックし、「拡張機能の実行」を選択します。

これにより、サンプル・プロジェクトがインストールされた、JDeveloperの2つ目のコピーが実行されます。

4 拡張機能のテストとデバッグ

この章では、JDeveloperで提供されるツールや機能を使用して、Javaプログラムを実行およびデバッグする方法について説明します。

この章の内容は次のとおりです。

- 拡張機能のテストとデバッグについて

- 拡張機能コードのデバッグ

- デバッグのトラブルシューティング

4.1 拡張機能のテストとデバッグについて

拡張機能をテストおよびデバッグするには、その拡張機能をJDeveloperのデバッグ・インスタンス内にインストールして実行します。

4.2 拡張機能コードのデバッグ

JDeveloperには、コードをテストするための包括的なデバッガが用意されています。JDeveloperでのデバッグの詳細は、Oracle Fusion Middleware Oracle JDeveloperによるアプリケーションの開発のアプリケーションのデバッグを参照してください。

拡張機能をデバッグするには、その拡張機能をJDeveloper内で実行します。拡張機能をインストールされたJDeveloperの新しいインスタンスがデバッグ・モードで開きます。動作に異常がある場合は、拡張機能コード内にブレークポイントを設定して、コードをデバッグできます。

4.2.1 JDeveloper拡張機能の実行方法

拡張機能のコードを開発したら、通常はそれをテストします。これを行うには、拡張機能をインストールした後、JDeveloperを実行します。JDeveloperの新規インスタンスがデバッグ・モードで実行されるため、それによって拡張機能をテストできます。

拡張機能をJDeveloperで実行するには、次のようにします。

- 「アプリケーション」ウィンドウのプロジェクトのコンテキスト・メニューから、またはソース・エディタで、拡張機能の実行を選択します。

新しいバージョンのJDeveloperが起動し、拡張機能が実行されます。

4.2.2 JDeveloper拡張機能のデバッグ方法

開発者は、JDeveloperのデバッグ・バージョン内で拡張機能を実行し、機能のテストを行い、JDeveloperのデバッグ機能を使用して問題の検出および修正ができます。詳細は、Oracle Fusion Middleware Oracle JDeveloperによるアプリケーションの開発のアプリケーションのデバッグを参照してください。

拡張機能をJDeveloperでデバッグするには、次のようにします。

1. コード内に適切なブレークポイントを入力します。

2. 「アプリケーション」ウィンドウのプロジェクトのコンテキスト・メニューから、またはソース・エディタで、「拡張機能のデバッグ」を選択します。

新しいバージョンのJDeveloperがデバッグ・モードで起動し、拡張機能が実行されます。

4.3 デバッグのトラブルシューティング

以下に示すのは、拡張機能に関する問題の症状と解決方法です。

- 症状: 起動時に例外が発生する。
解決方法: スタックト・レースをチェックし、デバッグします。

- 症状: 拡張機能がロードされない。
解決方法: 「機能」ダイアログ(「ツール」メニューから選択可能)をチェックして、JDeveloperの起動時に拡張機能が有効化されることを確認します。詳細は、Oracle Fusion Middleware Oracle JDeveloperによるアプリケーションの開発のJDeveloper機能の管理方法を参照してください。

- 症状: クラスのキャスト例外が発生する。
解決方法: 旧バージョンのJDeveloper用に記述された拡張機能の場合は、一部のコードが移行されていないか、拡張機能が旧バージョンのJDeveloper向けにコンパイルされています。拡張機能が移行されていることを確認してください。詳細は、「以前のリリースからの拡張機能の移行」を参照してください。

5 拡張機能のパッケージ化とデプロイ

この章では、拡張機能を配布するためのパッケージの作成方法について説明します。

この章の内容は次のとおりです。

- 拡張機能のパッケージ化とデプロイについて

- 拡張機能のパッケージ化

- 拡張機能のデプロイ

- 更新センターで拡張機能を公開する方法

5.1 拡張機能のパッケージ化とデプロイについて

拡張機能をパッケージ化してデプロイする手順は次のとおりです。

1. まず、拡張機能バンドル・アーカイブとしてパッケージ化されたJARで構成される、拡張機能パッケージを作成します。拡張機能バンドル・アーカイブとは、拡張機能によって使用される拡張機能JARとすべてのサポート・ファイルを含んだJARファイルです。

拡張機能JARファイルには次のものが含まれます。

- 拡張機能マニフェスト・ファイルextension.xml。

- 開発時と同じディレクトリ構造で配置された、コンパイル済のクラス・ファイルとリソース。

拡張機能バンドル・アーカイブには次のものが含まれます。

- 1つ以上の拡張機能JARファイル。

- すべてのサポート・ファイル(ライブラリJARファイルなど)。

2. 次に、拡張機能JARファイルを、配布用の.zipファイルへとパッケージ化します。

3. JDeveloperで今回初めて開いたプロジェクトの場合(たとえば、旧バージョンのJDeveloper用に記述された拡張機能を移行しようとしている場合など)は、「アプリケーション」ウィンドウでプロジェクトを右クリックし、「ターゲット・プラットフォームへのデプロイ」を選択します。これにより、バンドル・マニフェストmanifest.mfが生成されます(まだ生成されていない場合)。「アプリケーション」ウィンドウをリフレッシュすることが必要になる場合があります。

4. 拡張機能が外部ライブラリを参照する場合は、「アプリケーション」ウィンドウでMETA-INFノードの下のバンドル・マニフェストmanifest.mfを探して開き、次の行を変更します。

Bundle-ClassPath: .

変更後:

Bundle-ClassPath: .,external:jdev-install/jdeveloper/jdev/extensions/library

5. Oracleホームの下の別のディレクトリに拡張機能をインストールする必要がある場合は、このメカニズムを使用して、記述されている機能拡張を登録する必要があります。

5.2 拡張機能のパッケージ化

拡張機能プロジェクトを作成すると、OSGiバンドルを作成するための拡張機能デプロイメント・プロファイルも作成されます。詳細は、Oracle Fusion Middleware Oracle JDeveloperによるアプリケーションの開発のデプロイメント・プロファイルを参照してください。

5.2.1 デプロイメント・プロファイルの作成方法

OSGiバンドル・プロファイルのパラメータは、「プロジェクト・プロパティ」ダイアログから設定します。

デプロイメント・プロファイルを編集する手順は、次のとおりです。

1. 「アプリケーション」ウィンドウで、プロジェクトを右クリックして「プロパティ」を選択します。または、「アプリケーション」メニューから「プロジェクト・プロパティ」を選択します。

2. 「プロジェクト・プロパティ」ダイアログの左側のパネルで、「デプロイメント」を選択します。拡張機能プロファイルExtension (Extension JAR)が選択されます。「編集」をクリックします。

3. OSGiバンドル・プロファイル・ダイアログのバンドル・オプション・ページで、バンドル名、バージョン、アクティベータなどの詳細方法を入力できます。作業中にヘルプを表示するには、[F1]を押すか、ダイアログから「ヘルプ」をクリックします。

ダイアログ内の他のページを選択すると、依存関係を設定したり、含めるライブラリを設定できます。詳細は、「依存関係について」を参照してください。

「デプロイメント・プロファイルのプロパティ」の編集が終了したら、「OK」をクリックします。

5.2.2 OSGiバンドルの作成方法

デプロイメント・プロファイルを編集したら、OSGiバンドルを作成できます。

OSGiバンドルを作成するには、次のようにします。

1. 「アプリケーション」ウィンドウで、拡張機能プロジェクトを右クリックし、「デプロイ」→「extension-profile」を選択して、拡張機能のデプロイ・ダイアログを開きます。

2. 「OSGiバンドルにデプロイ」オプションが選択されます。「次へ」をクリックし、サマリー・ページで、作成されるバンドルの詳細情報を確認します。問題なければ、「終了」をクリックします。

Oracle-home/jdeveloper/jdev/extensionsディレクトリに、拡張機能を含んだOSGiバンドルが作成されます。

OSGiバンドルの実行とデバッグは、この場所から自動的に行えます。詳細は、「拡張機能のテストとデバッグ」を参照してください。

5.3 拡張機能のデプロイ

拡張機能をチームに配布するには、拡張機能をファイル・システム上で利用可能にした後、「更新の確認」ウィザード(「ヘルプ」メニューからアクセス)を使用して拡張機能をインストールするようユーザーに指示します。詳細は、Oracle Fusion Middleware Oracle JDeveloperによるアプリケーションの開発の拡張機能の操作を参照してください。

なお、拡張機能をWeb上の場所でホストして、より広範囲のユーザーがその拡張機能にアクセスできるようにすることもでき、オープンソース・プロジェクトとしてホストすれば、他のユーザーがその拡張機能にさらなる開発を加えて、機能の強化に協力できるようにすることもできます。

オラクル社では、複数のサード・パーティ製JDeveloper拡張機能をホストしています。これらは、http://www.oracle.com/technetwork/developer-tools/jdev/index-099997.htmlから利用できます。このサイトに自作の拡張機能をアップロードする場合は、JDeveloperおよびADFフォーラム(https://forums.oracle.com/forums/forum.jspa?forumID=83)にメッセージを投稿してください。

5.4 更新センターで拡張機能を公開する方法

JDeveloper拡張機能の作成とテストが終われば、その拡張機能をJDeveloper更新センターに登録できます。ユーザーは、拡張機能を更新センターからダウンロードし、拡張機能が既存のJDeveloperに自働的に追加されるようにすることができます。

JDeveloper拡張機能を入手するための更新センターは、http://www.oracle.com/technetwork/developer-tools/jdev/index-099997.htmlからアクセスできます。サード・パーティおよび個人によって開発された拡張機能の一覧が掲載されている『Oracle JDeveloperサード・パーティ拡張機能入手ページ』にも、ここからアクセスできます。

ユーザーがJDeveloper更新センターで入手した内容をインストールする方法は、Oracle Fusion Middleware Oracle JDeveloper拡張機能の開発の拡張機能マニフェストの操作を参照してください。

開発した拡張機能をユーザーがJDeveloperの「更新のチェック」機能を使ってインストールできるようにするには次のようにします。

1. 対象とする拡張機能用のbundle.xmlファイルを作成します。「拡張機能bundle.xml文書」を参照してください。

2. 「プロジェクト・プロパティ」で、Jarデプロイメント・プロファイルを作成します。この時、ファイル拡張子は.zipではなく.jarを使用します。

3. 「プロファイルの依存性」の選択で、拡張機能プロジェクトが選択されていることを確認します。

4. 「ファイル・グループ」の選択で、bundle.xml用に新規ファイルグループを作成し、そのターゲットディレクトリをMETA-INFとして指定します。
新規のデプロイメント・プロファイルでプロジェクトをデプロイすると、ZIPファイルが作成されます。このZIPファイルは単独で拡張機能の配布に使用できます。ただし、拡張機能を更新センターから配布したい場合には、更新センター用のXMLファイルを作成する必要があります。「更新センターXML文書」を参照してください。

5. 拡張機能を更新センターから配布したい場合には、更新センター用のXMLファイルを作成する必要があります。「更新センターXML文書」を参照してください。これにより、更新のチェック・ダイアログ(「ヘルプ」メニューにあります)を開いたときに更新センターXMLファイルに記述したURLで参照されるような新規の更新センターが作成されます。

作成された拡張機能をユーザーがダウンロードしインストールできるように、ユーザーがその新規更新センターをJDeveloperのインスタンスに加えるようにすることができます。

5.4.1 拡張機能bundle.xml文書

ここでは、拡張機能のデプロイと配布に必要なbundle.xml文書について述べます。

bundle.xml

次の例に示すようなbundle.xmlという名前の文書を作成します。

注意:
bundle.xmlのメタデータには、ここで示す例のようにuネームスペースが含まれている必要があります。

<?xml version = '1.0' encoding = 'UTF-8'?>
<update-bundle version="1.0"
xmlns="http://xmlns.oracle.com/jdeveloper/updatebundle"
xmlns:u="http://xmlns.oracle.com/jdeveloper/update">
<u:update id=" organization.dev.extension ">
<u:name>Name of Extension</u:name>
<u:version>1.0</u:version>
<u:author>YourOrganization</u:author>
<u:author-url> http://www.organization.com/dev/index.html/</u:author-url>
<u:description>Provides support for a feature.
</u:description>
<u:requirements>
<u:requires-extension id="oracle.jdeveloper"
minVersion="12.1.2"
maxVersion="12.2.1" />
</u:requires-agreement url="META-INF/agreement.html" />
</u:requirements>
<u:destination>${oracle.home}</u:destination>
</u:update>
</update-bundle>

重要な要素および属性

要素または属性

説明

Update Id

拡張機能はそれぞれ一意のIDで識別されます。更新センターで拡張機能が参照される際にはそのIDが使用されます。

Destination

このオプション属性でインストール先を指定します。使用可能なマクロ値は2つあります。

- oracle.home (デフォルト)。JDeveloperディレクトリで、たとえばC:\oracle\middleware\jdeveloperです。

- oracle.mw.home。拡張機能やパッチを、JDeveloperディレクトリより上位のミドルウェア・ディレクトリ(たとえば、C:\oracle\middleware)にインストールしたい場合に使用できます。

Requires Agreement

このオプション属性を指定すると、指定したURLがデフォルト・ブラウザに表示され、ユーザーは特定のテクノロジを使用することについて同意を求められます。

Requires Extension minVersionおよびmaxVersion

拡張機能で対応しているJDeveloperのバージョンを指定するために使用します。

5.4.2 更新センターXML文書

ここでは、更新センターXML文書について説明します。このXML文書は、拡張機能をJDeveloperの更新のチェック機能を利用して更新センターから配布する場合に必要となるものです。

更新センターXMLファイル

更新センター・ファイルはbundle.xmlと似ていますが、拡張機能ZIPファイルが置かれている場所を指定するbundle-urlという要素が追加されています。bundle-urlの詳細は、を参照してください。

<?xml version = '1.0' encoding = 'UTF-8'?>
<update-bundle version="1.0"
xmlns="http://xmlns.oracle.com/jdeveloper/updatebundle"
xmlns:u="http://xmlns.oracle.com/jdeveloper/update">
<u:update id=" organization.dev.extension ">
<u:name>Name of Extension</u:name>
<u:version>1.0</u:version>
<u:author>YourOrganization</u:author>
<u:author-url> http://www.organization.com/dev/index.html/</u:author-url>
<u:description>
</u:description>
<u:requirements>
<u:requires-extension id="oracle.jdeveloper"
minVersion="12.1.2"
maxVersion="12.2.1" />
</u:requires-agreement url="META-INF/agreement.html" />
</u:requirements>
<u:destination>${oracle.home}</u:destination>
<u:bundle-url> http://www.organization.com/dev/extension.zip/</u:bundle-url>
</u:update>
</update-bundle>

A Extension SDKとともにインストールされる要素

この付録では、Extension SDKとともにインストールされる要素に関する情報を提供します。

この付録の内容は次のとおりです。

- ファイル・システムにインストールされる要素

- IDEにインストールされる要素

A.1 ファイル・システムにインストールされる要素

Extension SDKをインストールすると、次のものがインストールされます。

- Extension SDK APIドキュメントが、jdev_install/jdeveloper/jdev/extensions/oracle.jdeveloper.esdk/docにインストールされます。

- サンプル・プロジェクトが含まれている拡張機能サンプル・アプリケーションextensionsdk.jwsは、jdev_install/jdeveloper/mywork/extension-samples-12.1.3.0.nn.nnnnnn.nnnn (nの値はラベル番号で、extension-samples-12.1.3.0.41.131204.1931のようになります)にインストールされます。

A.2 IDEにインストールされる要素

Extension SDKをダウンロードしてインストールした後、JDeveloperを再起動すると、IDE内に次の要素が表示されます。

- サンプルをインストールするよう選択した場合は、アプリケーションextensionsdk.jwsが「アプリケーション」ウィンドウで開かれます。JDeveloperの再起動時にサンプルをインストールしないよう選択した場合、Extension SDKサンプル・アプリケーションは、後で「ヘルプ」→「拡張機能サンプルを開く」から開くことができます。

- Studio開発者ロールの機能の管理ダイアログ(「ツール」メニューの「機能」からアクセス)で、IDEノードの下にESDKサンプルがリストされます。

- JDeveloperオンライン・ヘルプ・コンテンツの「参照」ノードに、Oracle Fusion Middleware Oracle Extension SDK Java APIリファレンスが追加されます。

B Extension SDKのアンインストール

この付録では、Extension SDKの無効化とアンインストールに関する情報を提供します。

この付録の内容は次のとおりです。

- Extension SDKのアンインストールについて

- Extension SDKを無効化する方法

- サンプル・アプリケーションの削除方法

- Extension SDKのアンインストール方法

B.1 Extension SDKのアンインストールについて

Extension SDKは、JDeveloperのパフォーマンスを最適化するために無効化できます。これは後で再度有効化できるため、Extension SDKを改めてダウンロードして、インストールしなおす必要はありません。なお、サンプル・アプリケーション(extensionsdk.jws)とそのプロジェクトをアンインストールしたり、Extension SDKをマシンから完全に削除することもできます。

B.2 Extension SDKを無効化する方法

JDeveloperを操作する際には、作業に使用するロールを選択します。選択したロールにより、どのJDeveloper拡張機能がロードされるかが決まります。通常、ロールを変更すると、不要なJDeveloper拡張機能が削除され、JDeveloperのパフォーマンスが最適化されます。使用しない拡張機能を無効化するために独自のJDeveloperロールを作成して、IDEの起動時にロードされるメニューを変更することもできます。詳細は、Oracle Fusion Middleware Oracle JDeveloperによるアプリケーションの開発のJDeveloperロールの操作を参照してください。

Extension SDKを無効化する場合は、他のJDeveloper拡張機能を無効化するのと同じ方法で無効化できます。

Extension SDKを無効化するには、次のようにします。

1. 「ツール」メニューから「機能」を選択して、Studio開発者ロールの機能の管理ダイアログを開きます。これにより、現在作業しているロールで利用できるすべての拡張機能が表示されます。

作業中に詳細を参照するには、[F1]を押すか、ダイアログ内から「ヘルプ」をクリックします。

2. 必要であれば、IDEノードを展開し、ESDKサンプルの選択を解除します。

Extension SDKを再度有効化する場合は、同じダイアログに移動し、ESDKサンプルを選択することで有効化できます。

B.3 サンプル・アプリケーションの削除方法

サンプル・アプリケーション(extensionsdk.jws)とそれに含まれているプロジェクトは、その他のJDeveloperアプリケーションを削除するのと同じ方法で削除できます。

サンプル・アプリケーションを削除するには、次のようにします。

1. 「アプリケーション」ウィンドウで、(アプリケーションextensionsdkの横にある)「アプリケーション・メニュー」ドロップダウン・リストをクリックします。

2. 「アプリケーションの削除」を選択します。

3. 「アプリケーションの削除の確認」ダイアログで、「はい」を選択します。

なお、「アプリケーション」ウィンドウ・ツールバーでextensionsdkを右クリックし、「アプリケーションの削除」を選択することもできます。

JDeveloperにより、extensionsdkアプリケーションと、そのすべてのプロジェクトおよびディレクトリが削除されます。

B.4 Extension SDKのアンインストール方法

Extension SDKをインストールすると、Extension SDK APIドキュメントがjdev_install/jdeveloper/jdev/extensions(jdev_installはJDeveloperがインストールされているディレクトリ)に置かれ、サンプル・プロジェクトを含む拡張機能サンプル・アプリケーションextensionsdk.jwsがjdev_install/jdeveloper/myworkに置かれます。

Extension SDKをローカル・ドライブから完全に削除するには、次のものを削除します。

- jdev_install/jdeveloper/jdev/extensions/oracle.jdeveloper.esdk

- jdev_install/jdeveloper/mywork/extension-samples-11.1.2.0.nn.nn.nn