20 Java Swingユーザー・インタフェースの実装

この章では、Java Swingインタフェースを開発するためにJDeveloperが提供するツールと機能の使用方法について説明します。ここでは、コンポーネントとJDeveloperのUI設計ツールを使用する際に実行する基本的なタスクについて説明します。これには、AWTおよびSwingベースのクライアント・アプリケーションおよびアプレット専用のユーザー・インタフェースのデバッグに使用されるUIデバッガの説明が含まれます。

この章では、次の項目について説明します。

• 第20.1項「Java Swingユーザー・インタフェースの実装について」

• 第20.2項「JDeveloperのユーザー・インタフェース設計ツールの理解」

• 第20.3項「Swingアプリケーションのルック・アンド・フィールの制御」

• 第20.4項「Java SwingおよびAWTコンポーネントの使用」

• 第20.5項「レイアウト・マネージャの使用」

• 第20.6項「レイアウト・プロパティを使用したUIのプロトタイプ作成」

• 第20.7項「コンテナおよびコンポーネントの使用」

• 第20.8項「コンテナ内のコンポーネントの使用」

• 第20.9項「メニューの使用」

• 第20.10項「イベント処理の使用」

• 第20.11項「アプレットの使用」

• 第20.12項「UIデバッガの使用」

20.1 Java Swingユーザー・インタフェースの実装について

JDeveloperのJavaビジュアル・エディタを使用すると、Swingコンポーネントを使用したJavaアプリケーションまたはアプレットのユーザー・インタフェース(UI)の要素を、迅速かつ容易に作成できます。UIは、コンポーネント・パレットから選択したJavaBeans(ボタン、テキスト領域、リスト、ダイアログ、メニューなど)を使用して作成します。次に、コンポーネント・プロパティの値を設定し、コンポーネント・イベントにイベント・ハンドラ・コードをアタッチします。

20.2 JDeveloperのユーザー・インタフェース設計ツールの理解

JDeveloperツールにより、Javaクラスを視覚的に設計およびプログラミングし、新規の複合コンポーネントまたは複雑なコンポーネントを生成できます。

JDeveloperのUI設計ツールには、次のものがあります。

• Javaビジュアル・エディタ。フレームまたはその他のUIコンテナ内でパネルおよびその他のUIコンポーネントを作成および配置します。Javaビジュアル・エディタにアクセスするには、ナビゲータでファイルを右クリックし、「開く」を選択します。ビジュアル・エディタを操作するには「設計」タブをクリックします。詳細は、第18.3.1項「Javaビジュアル・エディタでのコードの編集」を参照してください。

• メニュー・バー、メニュー、メニュー項目およびポップアップ・メニューのコンポーネントを作成し、編集します。メニュー・エディタは、Javaビジュアル・エディタを開いているときにコンポーネント・パレットからメニュー・コンポーネントをUIコンテナにドロップすると表示されます。また、構造ウィンドウでメニュー・コンポーネントをクリックしても、既存のメニュー・コンポーネントを編集できます。詳細は、第20.9.2項「メニュー・エディタの使用」を参照してください。

• コンポーネント・パレット: ビジュアル・コンポーネントおよび非ビジュアル・コンポーネントが格納されます。コンポーネント・パレットは、Javaビジュアル・エディタで選択しているコンポーネントに応じて表示されます。開いているファイルに対してコンポーネント・パレットを表示するには、「表示」→「コンポーネント・パレット」の順に選択します。詳細は、第11.1.4項「コンポーネント・パレットの使用方法」を参照してください。

• 構造ウィンドウ: このウィンドウには、ソース・ファイル内のすべてのコンポーネントとその関係が階層構造で表示されます。「構造」ウィンドウは、ナビゲータ・ウィンドウ下部、または、ドッキングされている場合は「表示」→「構造」の順に選択してアクセスします。詳細は、第3.11.6項「「構造」ウィンドウ」を参照してください。

• プロパティ・インスペクタ。コンポーネント・プロパティを確認および設定し、コンポーネント・イベントにメソッドを設定する際に使用します。プロパティ・インスペクタでの変更は、Javaビジュアル・エディタおよびソース・コードに視覚的に反映されます。Javaビジュアル・エディタで開いた特定のファイルに対してプロパティ・インスペクタを表示します。開いているファイルに対してプロパティ・インスペクタを表示するには、「表示」→「プロパティ・インスペクタ」の順に選択します。詳細は、第11.1.3項「プロパティ・インスペクタの使用方法」を参照してください。

ファイルに対してUI設計ツールを使用する場合、次の要件を満たす必要があります。

• Javaファイルである必要があります。

• 構文エラーが存在しない必要があります。

• publicクラスが含まれる必要があります(ファイル名がpublicクラス名と同じである必要があります)。

• 次のJDeveloperコーディング規則に従う必要があります。

  • すべてのUIコントロールがjbInit()内でクラス・メンバーまたはローカル変数として宣言されます。

  • すべてのUIプロパティ設定がjbInit()で実行されます。これは、JDeveloperのJavaビジュアル・エディタおよびプロパティ・インスペクタに設定を反映させるために必要です。

  • 式として設定されたすべてのプロパティ設定に、メンバーUIコントロールまたは静的な値のみが含まれます。

• デフォルトのコンストラクタが必要です。

前述の要件を満たすファイルはすべて、Javaビジュアル・エディタおよびプロパティ・インスペクタを使用して視覚的に設計できます。非UIクラスを視覚的に設計することもできます。

注意: JDeveloperダイアログでファイルを作成した場合、これらの要件は満たされています。

設計にコンポーネントを初めて追加する際に、JDeveloperのJavaビジュアル・エディタにより、クラスにデフォルトのコンストラクタであるprivate jbInit()メソッドが含まれ、このjbInit()メソッドがデフォルトのコンストラクタから正しくコールされることが確認されます。JDeveloperでこのコードが検出されない場合、追加されます。コンポーネントで必要とされるインポートも追加されます。

Javaビジュアル・エディタでファイルを開くと、JDeveloperにより構造ウィンドウ・ツリーが更新されます。たとえば、クラスにフレームおよびメニューが含まれる場合、UIおよびメニュー用のサブツリーが存在します。その他のJavaBeansコンポーネントを構造ウィンドウにドロップすると、「その他」フォルダが表示され、これらのコンポーネントをプロパティ・インスペクタで選択および編集できます。

20.3 Swingアプリケーションのルック・アンド・フィールの制御

JDeveloperには、SwingのGUIコンポーネントが組み込まれています。Swingクラスを使用すると、ユーザー・インタフェースのルック・アンド・フィールを指定できます。Javaのこの新しいプラガブルなルック・アンド・フィールを利用すると、ユーザーのWindowsまたはSolarisマシンのネイティブ・デスクトップのルック・アンド・フィールを持つアプリケーションを作成できます。また、Java Metalルック・アンド・フィールを使用して、プラットフォーム間でアプリケーションの均一なルック・アンド・フィールを保証することも可能です。

JDeveloperには、次の4つのルック・アンド・フィール・オプションが用意されています。

• Oracle

• Metal

• CDE/Motif

• Windows

UIマネージャを使用してルック・アンド・フィールを設定する場合は、次のような考慮事項もあります。

• ルック・アンド・フィール文のコード行はtry/catchブロック内にあります。コンパイルするには、この配置が必要です。

• このコードは、コンポーネントがインスタンス化される前に実行される必要があります。そのため、<Application>.java static main()メソッド内に置かれています。

• UIManagerクラスは、com.sun.java.swingパッケージ内にあります。

20.3.1 Oracleルック・アンド・フィールの変更方法

Oracleルック・アンド・フィールに変更する手順は、次のとおりです。

1. コード・エディタでアプリケーション・ファイルを開きます。

2. Mainメソッドに次のコードを追加します。

   try {
        UIManager.setLookAndFeel(new oracle.bali.ewt.olaf.OracleLookAndFeel());
   }
   catch (Exception e) {
   }
   

   Oracleルック・アンド・フィール(OLAF)のshare.jarおよびjewt4.jarファイルをクラスパスのjlibディレクトリから使用する必要があります。

20.3.2 Windowsルック・アンド・フィールの変更方法

Windowsルック・アンド・フィールに変更する手順は、次のとおりです。

1. コード・エディタでアプリケーション・ファイルを開きます。

2. Mainメソッドに次のコードを追加します。

   try {
        UIManager.setLookAndFeel(new 
         com.sun.java.swing.plaf.windows.WindowsLookAndFeel());
   }
   catch (Exception e) {
   }
   

   Oracleルック・アンド・フィール(OLAF)のshare.jarおよびjewt4.jarファイルをクラスパスのjlibディレクトリから使用する必要があります。

20.3.3 Metalルック・アンド・フィールの変更方法

Metalルック・アンド・フィールは、Swingコンポーネントのデフォルトです。Metalルック・アンド・フィールを使用する場合、コードを変更する必要はありません。

Metalルック・アンド・フィールに変更する手順は、次のとおりです。

1. コード・エディタでアプリケーション・ファイルを開きます。

2. Mainメソッドに次のコードを追加します。

   try {
        UIManager.setLookAndFeel(new 
         javax.swing.plaf.metal.MetalLookAndFeel());
   }
   catch (Exception e) {
   }
   

注意: Oracleルック・アンド・フィール(OLAF)のshare.jarおよびjewt4.jarファイルをクラスパスのjlibディレクトリから使用する必要があります。

20.4 Java SwingおよびAWTコンポーネントの使用

SwingおよびAWT JavaBeansコンポーネントを使用して、Javaアプリケーションまたはアプレットのユーザー・インタフェース(UI)をアセンブルします。Javaビジュアル・エディタで、ボタン、テキスト領域、リスト、ダイアログ、メニューなどのJavaBeansをコンポーネント・パレットから選択してUIを構成します。次に、コンポーネント・プロパティの値を設定し、コンポーネント・イベントにイベント・ハンドラ・コードをアタッチします。Javaクラスを視覚的に設計およびプログラミングして、新規の複合コンポーネントまたは複雑なコンポーネントを生成できます。

20.4.1 Swing JavaBeansコンポーネントの使用

Swingコンポーネントは自動的にレンダリングされる軽量コンポーネントで、AWTコンポーネントのようにWindowingリソースを使用しません。多くの場合、この種のコンポーネントには対応するAWTコンポーネントがありますが、Swingバージョンはプラットフォーム間で柔軟性および一貫性を向上できるように強化されています。

注意: SwingコンポーネントはSwingコンテナ内の基礎となる機能性に依存します。Swing JavaBeansを使用する場合は、JFrame、Jpanelまたは基本的なSwing機能を実装する他のコンテナを使用してプログラムを作成する必要があります。

表20-1には、Swing JavaBeansコンポーネントが含まれます。

表20-1 Swing JavaBeansコンポーネント

コンポーネント	説明
JButton	単純なプッシュ・ボタン。JButtonには埋込みアイコンを使用できます。
JCheckBox	ブール値(true/false)の表示に使用する正方形のボックス。値がtrueに設定されると、このボックスにはデフォルトでチェックマークが表示されます。独自のチェックマーク・グラフィックを設定するオプションがあります。
JComboBox	AWTのChoiceコントロールと同様に、ユーザーが実行時に選択できる値のリストを表示します。JComboBoxにはプロパティeditableがあり、ユーザーが実行時に新規の値を入力できるようにします。
JEditorPane	テキストをHTML 3.2またはRTFフォーマットで表示するように特化されたJTextComponent。アプリケーションまたはアプレットのヘルプ・ページを作成可能にするためのコンポーネントです。
JLabel	テキスト文字列およびオプションのアイコンを表示できるようにするテキスト・コンポーネント。追加のプロパティを使用すると、アイコンに対するテキストの相対位置を設定できます。
JList	オブジェクトのリストを表示します。 ヒント: AWTのListコンポーネントとは異なり、JListではコンポーネントに組込みのスクロール機能がありません。リストをスクロール可能にするには、リスト・コンポーネントをJScrollPaneコンテナにドロップする必要があります。
JPasswordField	デフォルトでユーザーが入力した文字の位置にアスタリスク(*)を表示するJTextField。
JProgressBar	プロセスの完了率をグラフィカルに示す進行状況バーを表示します。
JRadioButton	このコンポーネントは、ラジオ・ボタンとして動作するように特別に設計されています。他のJRadioButtonとともにButtonGroupにグループ化されている場合は、グループからボタンを一度に1つのみ選択できます。ButtonGroupは、非ビジュアル・コンポーネントです。
JScrollBar	ユーザーが整数値の設定に使用できるグラフィック・コントロール。このコンポーネントは、水平方向または垂直方向に表示できます。
JSeparator	直線を描画するコンポーネント。JMenuでコンポーネントとして使用することを意図していますが、実際のコンポーネントであるため、UI内でコントロール・セット間を区切る直線を描画するために使用できます。JSeparatorは、垂直方向または水平方向に表示できます。
JSlider	JScrollBarと同様に、このコントロールはユーザーがグラフィック・コントロールを使用して整数値を設定できるようにします。JSliderを使用すると、大小の目盛りを設定したり、コントロールを囲む枠を表示できます。
JTable	スプレッドシート・アプリケーションのように情報を2次元のグリッドに表示します。 ヒント: AWTのListコンポーネントとは異なり、JTableにはスクロール機能が組み込まれていません。表をスクロール可能にするには、リスト・コンポーネントをJScrollPaneコンテナにドロップする必要があります。
JTextArea	1つの文字列をそれぞれが改行文字で終わる複数行に表示する、編集可能なテキスト領域。 ヒント: JTextAreaをスクロール可能にするには、JScrollPaneコンテナ内に表示する必要があります。
JTextField	1つの文字列を1行に表示する、編集可能なテキスト領域。
JTextPane	ワード・ラップ、イメージ表示およびスタイル定義が可能な、すべての機能を持つテキスト・エディタ・コントロール。 ヒント: JTextPaneをスクロール可能にするには、JScrollPaneコンテナにドロップする必要があります。
JTree	ファイル・ディレクトリなどの階層情報をツリー形式で表示します。 ヒント: AWTのListコンポーネントとは異なり、JTreeにはスクロール機能が組み込まれていません。ツリーをスクロール可能にするには、リスト・コンポーネントをJScrollPaneコンテナにドロップする必要があります。
JToggleButton	トグル・ボタンはJCheckBoxコントロールに似ています。このボタンを押す(trueに設定する)と、再び押してfalseに設定するまでtrueになっています。JToggleButtonをButtonGroupに置くと、一度にtrueに設定できるJToggleButtonはグループ内で1つのみになります。トグル・ボタンは、ツールバーにツールをアクティブな状態で表示する際に役立ちます。コンポーネント・パレットのボタンは、トグル・ボタンの一例です。

20.4.2 AWT JavaBeansの使用

AWT JavaBeansコンポーネントは、基礎となるプラットフォームの標準コントロールを使用してユーザー・インタフェースを表示します。このアーキテクチャによりAWTコンポーネントの実装が単純でわかりやすくなりますが、UIの最終的な表示の管理が制限され、柔軟性が低下します。また、AWTコンポーネントの実行にはより多くのシステム・リソースが必要です。このため、重量コンポーネントと呼ばれることがあります。Swingコンポーネントは、Javaに実装され自己レンダリングされるため、使用するシステム・リソースは少なくなります。この理由から軽量コンポーネントと呼ばれます。Swingコンポーネントの実装はより複雑になる場合がありますが、ホスト・プラットフォーム間の柔軟性および一貫性が向上します。

表20-2には、AWT JavaBeansコンポーネントが含まれます。

表20-2 AWT JavaBeansコンポーネント

コンポーネント	説明
Button	単純なプッシュ・ボタンが表示されます。
CheckBox	true/false、オン/オフのブール・コントロールです。チェック・ボックスはスタンドアロン・コンポーネントであるため、値がtrueに設定されている場合はXを含む四角形として表示されます。チェック・ボックス・グループのメンバーとして設定されている場合、チェック・ボックスは円形(ラジオ・ボタン)となります。円の中に点が含まれる場合、値がtrueに設定されていることを示します。チェック・ボックス・コンポーネントをCheckboxGroupに追加するには、そのCheckboxGroupプロパティを、このコンポーネントが属するCheckboxGroupの名前に設定します。
CheckboxGroup	Checkboxコンポーネント・セットの動作を統合するために使用される非ビジュアル・コンポーネントです。一度にtrueに設定できるのは、チェック・ボックス・グループ内の1つの項目のみです。CheckboxGroupプロパティを対応するCheckboxGroupの名前に設定することで、CheckboxコンポーネントがCheckboxGroupに追加されます。CheckboxGroupのデフォルト値を設定するには、そのSelectedCheckboxプロパティをCheckboxコンポーネントの名前に設定します。 ヒント: CheckboxコンポーネントおよびCheckboxGroupを追加する順序によっては、CheckboxGroupがCheckboxより前にインスタンス化される場合があります。正しいデフォルトが設定されるようにするには、SelectedCheckboxおよび現在の初期化文をJbInitメソッドの最下部に移動し、デフォルトが設定される前にそのすべての構成要素がインスタンス化されるようにします。
Choice	ポップアップ・メニューが表示されます。Choiceコントロールのラベルは、現在選択されている項目です。これはコンボボックスに類似しています。
Label	アプリケーションに編集不可のテキスト・ラベルが表示されます。ただし、その値はプログラムによって変更される場合があります。
List	データ項目のスクロール・リストが表示されます。ユーザーは、Listのプロパティ設定に応じて1つ以上の項目を選択できます。
MenuBar	メニュー・バーが表示されます。すべてのコンテナでMenuBarコントロールを子として追加できますが、FrameにのみsetMenubar()メソッドがあります。このメソッドは特定の場所でMenuBarの親となり、他の子の場所は干渉しません。メニュー・バーはアプレットでは使用できません。
PopupMenu	コマンド・リストを含むポップアップ・メニューが表示されます。ポップアップ・メニューはパネルに設定でき、アプレットで使用できます。メニュー作成の詳細は、第20.9項「メニューの使用」を参照してください。
Panel	コントロールのグループの表示に使用されるコンテナです。各パネルに独自のレイアウトを設定し、コンポーネントの相互の配置を管理できます。
Scrollbar	ユーザーが整数値を設定できるスライダ・コントロールです。スクロール・バーを水平または垂直に表示するよう設定できます。
ScrollPane	水平および垂直スクロール・バーを使用できるパネルのタイプであり、ScrollPane自体より大きい子コンポーネントを表示できます。
TextArea	テキストの単一文字列を複数行で表示し、各行が改行文字で終わるテキスト・コンポーネントです。テキストは上下左右にスクロールできます。
TextField	テキストの単一文字列を単一行で表示する編集可能なテキスト・コンポーネントです。

20.5 レイアウト・マネージャの使用

JDeveloperのレイアウト・マネージャを使用して、コンテナ内のコンポーネントの配置とサイズを表示のたびに制御します。レイアウト・マネージャでは、そのレイアウト・マネージャ固有の特定のルール・セットに従ってコンテナ内のコンポーネントが自動的に配置されます。

Javaプログラムは複数のプラットフォームでデプロイできます。標準的なUI設計技術を使用してUIコンポーネントの絶対位置とサイズを指定する場合は、そのUIがすべてのプラットフォームで適切に表示されるとはかぎりません。開発システムでは適切な外観が得られていたUIが、別のプラットフォームでは使用できないこともあります。この問題を解決するために、Javaでは移植可能なレイアウト・マネージャのシステムが提供されています。レイアウト・マネージャを使用すると、UIのレイアウトに関するルールと制約を移植可能な方法で指定できます。

レイアウト・マネージャには、次のメリットがあります。

• フォント、画面の解像度およびプラットフォームの違いに関係なく、コンポーネントの位置を正確に設定できます。

• 実行時に動的にサイズが変わるコンテナに対応する、インテリジェントなコンポーネント配置ができます。

• 様々なサイズの文字列を容易に調整できます。文字列が長くなっても、コンポーネントの正しい位置合せが保たれます。

Java UIコンテナでは、レイアウト・マネージャという特殊なオブジェクトを使用して、表示されるたびにコンテナ内のコンポーネントの位置とサイズが制御されます。レイアウト・マネージャでは、そのレイアウト・マネージャ固有の特定のルール・セットに従ってコンテナ内のコンポーネントが自動的に配置されます。

レイアウト・マネージャでは、コンポーネントのサイズと位置が次のように様々なファクタに基づいて設定されます。

• レイアウト・マネージャのレイアウト・ルール

• レイアウト・マネージャのプロパティ設定(存在する場合)

• 各コンポーネントに関連付けられたレイアウト制約(詳細は、第20.5.24項「レイアウト制約の理解」を参照)。

• すべてのコンポーネントに共通する特定のプロパティ(preferredSize、minimumSize、maximumSize、alignmentXおよびalignmentYなど)

• コンテナのサイズ

Javaでは、特定タイプのコンテナにデフォルトで特定のレイアウト・マネージャを使用します。

• すべてのパネル(アプレットを含む)では、FlowLayoutを使用します。

• すべてのウィンドウ(フレームおよびダイアログ・ボックスを含む)では、BorderLayoutを使用します。

Javaプログラムでコンテナを作成する場合、そのコンテナ・タイプのデフォルトのレイアウト・マネージャを受け入れるか、別のタイプのレイアウト・マネージャを指定してデフォルトをオーバーライドできます。

通常、UIを手動でコーディングする場合は、コンテナにコンポーネントを追加する前にデフォルトのレイアウト・マネージャをオーバーライドします。Javaビジュアル・エディタを使用すると、いつでもレイアウトを変更できます。JDeveloperにより必要に応じてコードが調整されます。

JDeveloperのJavaビジュアル・エディタでは、各コンテナに対してデフォルトのレイアウト・マネージャが使用されます。通常はnullのレイアウトです。デフォルト以外のレイアウト・マネージャを使用する場合は、コンテナのソース・コードに明示的にレイアウト・マネージャを追加するか、またはインスペクタでコンテナのレイアウト・プロパティ・リストからレイアウトを選択します。

注意: Javaビジュアル・エディタを使用してレイアウト・マネージャのプロパティを変更する場合は、プロパティ・インスペクタでプロパティにアクセスできるように、コンテナのレイアウトを明示的に指定する必要があります。

コンテナに必要な設計全体に基づいてレイアウト・マネージャを選択します。レイアウトによっては、コンテナに追加した直後にコンポーネントの配置とサイズ変更を引き継ぐため、Javaビジュアル・エディタで操作しにくいものがあります。初期のレイアウト・プロトタイプ作成中にこの問題を軽減するため、JDeveloperにはnullというデフォルトのレイアウトが用意されています。このレイアウトでは、コンポーネントの配置と指定したサイズが正確に維持されます。nullを土台にすると、コンテナでのプロトタイプ作成が容易になります。その後、コンポーネントをコンテナに追加してから、設計に適した移植可能なレイアウトに切り替えることができます。

設計によっては、ネストしたパネルを使用してコンポーネントをメインのFrameにグループ化し、Frameと各パネルに各種の異なるレイアウトを使用できます。

注意: レイアウト・マネージャを使用せずにパネルを設計する場合は、ソース・コードでレイアウト・マネージャをnullに設定できます。ただし、デプロイ時にこの設定を残さないでください。

様々なレイアウトを試して、コンテナのコンポーネントに対する効果を確認してください。選択したレイアウト・マネージャでは必要な結果が得られないことがわかった場合は、別のレイアウト・マネージャを試すか、複数のパネルを異なるレイアウトでネストして、必要な効果を得るようにします。

20.5.1 サイズ設定プロパティの理解

レイアウト・マネージャでは、様々な情報を使用してコンテナ内のコンポーネントの配置とサイズが決定されます。コンポーネントには、レイアウト・マネージャがコンポーネントを適切にレイアウトできるように一連のメソッドが用意されています。これらの全メソッドにより、コンポーネントは必要なサイズ設定をレイアウト・マネージャに伝えることができます。

表20-3のメソッドはプロパティのgetterメソッドであり、次のことを表します。

表20-3 サイズ設定プロパティ

方法	説明
getPreferredSize()	コンポーネントにより選択されるサイズ(コンポーネントを最も適切な外観で表示するための理想的なサイズ)。特定のレイアウト・マネージャのルールによっては、preferredSizeがコンテナのレイアウト時に考慮されない場合があります。
getMinimumSize()	コンポーネントを縮小しても使用可能な最小サイズ。コンポーネントのminimumSizeは、ラベルのサイズなどで制限されることがあります。ほとんどのコントロールの場合、minimumSizeはpreferredSizeと同じです。通常、レイアウト・マネージャではpreferredSizeよりもminimumSizeが考慮されます。
getMaximumSize()	このコンポーネントに使用可能な最大サイズ。これは、レイアウト・マネージャが効果的に使用できないコンポーネントにスペースを浪費しないようにするために使用されます。たとえば、BorderLayoutの場合、中央のコンポーネントのサイズを最大サイズに制限し、端のコンポーネントにスペースを与えるか、サイズ変更時に外側のウィンドウのサイズを制限できます。
getAlignmentX()	他のコンポーネントを基準とする、X軸上でのコンポーネントの相対的な位置合せ。
getAlignmentY()	他のコンポーネントを基準とする、Y軸上でのコンポーネントの相対的な位置合せ。

各レイアウト・マネージャによる前述の情報の使用方法については、第20.5.2項「JDeveloperで提供されるレイアウトの理解」に示す個別レイアウトの説明を参照してください。

20.5.2 JDeveloperで提供されるレイアウトの理解

JDeveloperには、Java AWTの標準であるBorderLayout、FlowLayout、GridLayout、CardLayoutおよびGridBagLayoutのレイアウト・マネージャが用意されています。Swingの場合は、BoxLayout2およびOverLayout2が含まれています。

JDeveloperでは、列および行のグリッドにコンポーネントを配置するグリッドベース・コンテナであるFormLayoutも提供しています。これにより、指定のコンポーネントの範囲を複数の列または行とすることができます。FormLayoutは、JDeveloperに組み込まれているオープン・ソース・フレームワークであるJGoodies Formsによって提供されます。

さらに、JDeveloperは次のカスタム・レイアウトを提供しています。

• XYLayout。コンテナに挿入したコンポーネントを元のサイズおよび位置(xy座標)に保持します。

• PaneLayout。SplitPanelコントロールで使用します。

• VerticalFlowLayout。FlowLayoutにきわめて類似していますが、コンポーネントを水平ではなく垂直に配置する点が異なります。

独自のカスタム・レイアウトを作成したり、sun.awtクラス内またはサード・パーティのレイアウト・マネージャなどにおけるその他のレイアウトを試すことができます。これらの多くはWebのパブリック・ドメインです。Javaビジュアル・エディタでカスタム・レイアウトを使用する場合、Javaヴィジュアル・エディタでレイアウトを使用できるように、Javaヘルパー・クラス・ファイルの提供が必要な場合があります。

20.5.3 BorderLayoutの使用

BorderLayoutは、上、下、右、左および中央の領域にコンテナのコンポーネントを配置します。

• 上および下のコンポーネントには高さの推奨値が指定され、コンテナの幅全体にわたって拡張されます。

• 右および左のコンポーネントには幅の推奨値が指定され、上および下の領域に挟まれた領域を埋めるよう垂直に拡張されます。

• 中央のコンポーネントは、残りのすべての領域を埋めるよう拡張されます。

図20-1 BorderLayout

図20-1に示すBorderLayoutは、コンテナの1つ以上の境界線にコンポーネントを適用し、コンテナの中央を1つのコンポーネントで埋める場合に効果的です。また、単一コンポーネントでコンテナを完全に埋めるために使用するレイアウトでもあります。

BorderLayoutは、UI内の大き目のコンテナに最も有用なレイアウト・マネージャであることがわかります。BorderLayoutの各領域内にパネルをネストしてから、これらの各パネルに各種レイアウトのその他のパネルを移入することで、非常に複雑なUI設計を実現できます。

コンポーネントは、constraintsプロパティに基づき、BorderLayout内の5つの領域のいずれかに配置されます。インスペクタにおいて、コンポーネントのconstraintsプロパティを、「上」、「下」、「右」、「左」または「中央」のいずれかの値に設定できます。

たとえば、BorderLayoutコンテナの最上部全体にツールバーを配置するには、ボタンのFlowLayoutパネルを作成し、これをコンテナの「上」領域に配置します。このためには、パネルを選択し、インスペクタでconstraintsプロパティに対し「上」を選択します。

constraintsプロパティを設定するには、次のようにします。

1. Javaビジュアル・エディタまたは構造ウィンドウのいずれかで、配置するコンポーネントを選択します。

2. インスペクタでconstraintsプロパティを選択し、その値フィールドをクリックします。

3. constraintsプロパティ・ドロップダウン・リストの下矢印をクリックし、コンポーネントを挿入する領域を選択します。

4. [Enter]を押すか、プロパティ・インスペクタ内の他の任意の場所をクリックし、コードに対する変更をコミットします。

Javaビジュアル・エディタを使用して、既存のコンテナのレイアウトをBorderLayoutに変更した場合、境界線近くのコンポーネントは最も近い境界線に接するよう自動的に移動します。中央に近いコンポーネントは「中央」に設定される場合があります。コンポーネントが意図しない場所に移動する場合、インスペクタでconstraintsプロパティを訂正するか、Javaビジュアル・エディタで新しい場所にコンポーネントをドラッグできます。

5つの各領域には任意の数のコンポーネント(またはコンポーネントのパネル)を含めることができますが、最上位のコンポーネントが不透明でない場合を除いて、同じ領域内にある下位コンポーネントはすべて最上位のコンポーネントによって覆われます。

複数のコンポーネントおよびBorderLayoutの使用に関する一般的なガイドラインを次に示します。

• コンテナ内に含まれるコンポーネントが5つ以下になるようにします。

• 最初にXYLayoutを使用し、コンポーネントを目的の場所付近に移動して、各境界線近くにはコンポーネントが1つのみとなるようにします。

• 1つの領域内の複数のコンポーネントを変換前にパネルにグループ化します。

注意: BorderLayoutでは、コンポーネントをコンテナに追加する順序は無視されます。

デフォルトにより、BorderLayoutが管理するコンポーネント間にギャップは挿入されません。ただし、インスペクタを使用して、コンテナに関連付けられたBorderLayoutに対し、水平または垂直のギャップをピクセル単位で指定できます。

BorderLayoutコンポーネントの周囲のギャップを変更するには、「構造」ウィンドウで、(BorderLayoutが管理するコンテナの真下に表示される) BorderLayoutオブジェクトを選択してから、プロパティ・インスペクタで、hgapおよびvgapプロパティのピクセル値を変更します。

20.5.4 BoxLayout2の使用

BoxLayout2では、コンテナのコンポーネントを垂直にも水平にも配置できます。コンポーネントをコンテナにネストすることで、複雑なレイアウトを実現できます。図20-2では、垂直に配置した3つのパネル(P1、P2、P3)を示しています。各パネルには2つのボタンが垂直に配置されています。

図20-2 BoxLayout2

コンポーネントにBoxLayout2を使用する場合、主軸がY軸(最上部に配置)とX軸(左から右への配置)のどちらであるかを指定します。コンポーネントは、左から右(または上から下)に、コンテナへの追加と同じ順序で配置されます。

BoxLayout2では、推奨される幅(左から右へのレイアウトの場合)または高さ(上から下へのレイアウトの場合)でコンポーネントが配置されます。コンテナがサイズ変更された場合、コンポーネントは折り返されません。

水平レイアウトですべてのコンポーネントの高さが同じでない場合、BoxLayout2では、すべてのコンポーネントが最も高いコンポーネントと同じ高さになります。特定のコンポーネントでこれが不可能である場合、BoxLayout2では、そのコンポーネントのY軸への位置合せに従ってコンポーネントが垂直に位置合せされます。

垂直の位置合せでコンポーネントがすべて同じ幅でない場合、BoxLayout2では、列内のすべてのコンポーネントが最も幅の広いコンポーネントと同じ幅になります。これに失敗した場合、X軸への位置合せに従ってコンポーネントが水平に位置合せされます。

20.5.5 CardLayoutの使用

CardLayoutでは、コンポーネント(通常はパネル)が1組のカードのようにスタック内に相互に重ねられます。一度に1つのコンポーネントのみが表示され、別のコントロールを使用してパネルを順にめくり、最上位にくるパネルを選択できます。

CardLayoutは、異なる時点で別のコンポーネントが含まれる可能性のある領域がある場合に使用すると効果的なレイアウトです。これによって、同じ表示領域を共有する必要がある2つ以上のパネルを管理できます。

20.5.5.1 CardLayoutコンテナの作成方法

CardLayoutの使用例は、JDeveloperのウィザードで参照できます。「取消」、「次へ」および「戻る」ボタンにより、次に表示されるパネルが制御されます。

CardLayoutコンテナを作成するには、次のようにします。

1. 新規アプリケーションを作成します。

2. ナビゲータでフレーム・ファイルを右クリックし、「開く」を選択します。

3. Javaビジュアル・エディタでUIにパネルを追加し、そのlayoutプロパティをCardLayoutに設定します。詳細は、第20.7.9項「パネルの作成方法」を参照してください。

4. CardLayoutパネルに新規パネルをドロップします。この新規パネルによってCardLayoutパネルが完全に埋まります。

   
   

   注意: CardLayoutパネルに追加した最初のコンポーネントによって、常にパネルが埋まります。

   
   

5. この新規パネルのlayoutプロパティをXYLayoutに設定し、必要なコンポーネントを追加します。

6. コンポーネント・パレットでパネルをクリックしてから、「構造」ウィンドウでコンポーネント・ツリー内のCardLayoutパネルをクリックし、これをCardLayoutパネルのスタックに追加します。

7. この2つ目のパネルをXYlayoutに設定し、これにコンポーネントを追加します。

8. スタックに追加する新規パネルごとにステップ6および7を繰り返します。

20.5.5.2 CardLayoutコンテナの周囲のギャップの指定方法

「構造」ウィンドウを使用して、CardLayout内のコンポーネント・スタックを囲む水平および垂直ギャップの量を指定できます。

CardLayoutコンテナの周囲のギャップを指定するには、次のようにします。

1. 構造ウィンドウで、cardLayoutが管理するコンテナの真下に表示されているcardLayoutオブジェクトを選択します。

   図20-3 cardLayout

   
   

2. インスペクタで、hgap(水平ギャップ)またはvgap(垂直ギャップ)プロパティをクリックします。

3. ギャップに必要なピクセル数を入力します。

4. [Enter]を押すか、インスペクタ内の他の任意の場所をクリックして変更を登録します。

20.5.6 FlowLayoutの使用

FlowLayoutでは、各コンポーネントのpreferredSizeを使用して、コンポーネントが行内に左から右へ、続いて上から下へ配置されます。FlowLayoutでは、1行にできるだけ多くのコンポーネントが並べられた後、新しい行に移動します。通常、FlowLayoutはパネル上にボタンを配置する際に使用します。

図20-4 FlowLayout

注意: 注意: コンポーネントを水平ではなく垂直に配置するパネルが必要である場合、第20.5.21項「VerticalFlowLayoutの使用」を参照してください。

FlowLayoutコンテナの行内にコンポーネントを配置する方法を選択するには、左、右または中央の位置合せの理由を指定します。また、コンポーネントと行の間のギャップの量(水平および垂直間隔)を指定できます。Javaビジュアル・エディタを使用している場合、alignmentおよびgapプロパティを両方とも変更するにはインスペクタを使用します。

位置合せ

• LEFT: コンテナの左端でコンポーネントをグループ化します。

• CENTER - コンテナの中央にコンポーネントを配置します。

• RIGHT: コンテナの右端でコンポーネントをグループ化します。FlowLayoutでのデフォルトの位置合せはCENTERです。

  位置合せを変更するには、「構造」ウィンドウでFlowLayoutオブジェクトを選択してから、プロパティ・インスペクタでalignmentプロパティの値を次のように指定します。

  • 0=LEFT

  • 1=CENTER

  • 2=RIGHT

ギャップ

FlowLayoutにおけるコンポーネント間のデフォルトのギャップは5ピクセルです。

水平または垂直のギャップを変更するには、構造ウィンドウでFlowLayoutオブジェクトを選択してから、インスペクタでhgap(水平ギャップ)またはvgap(垂直ギャップ)プロパティのピクセル値を変更します。

コンポーネントの順序

FlowLayoutコンテナ内のコンポーネントの順序を変更するには、コンポーネントを新しい場所にドラッグするか、コンポーネントを右クリックし、「最初へ移動」または「最後へ移動」を選択します。

20.5.7 FormLayoutの使用

FormLayoutでは、列および行のグリッドにコンポーネントが配置されます。これによって、指定のコンポーネントの範囲を複数の列または行とすることができます。列および行は、幅または高さが同じである必要はありません。

注意: FormLayoutは、JDeveloperに組み込まれているオープン・ソース・フレームワークであるJGoodies Formsによって提供されます。FormLayoutレイアウト・マネージャを追加するには、現在のプロジェクトのライブラリにJGoodies Formsライブラリを追加します。

次の列および行のプロパティを変更できます。列および行は、サイズ(必須)、デフォルトの位置合せ(オプション)およびサイズ変更の動作(オプション)の3つの部分で指定されます。これらのプロパティを編集するには、Javaビジュアル・エディタで、マウスをドラッグしてFormLayoutのグリッド全体を選択し、選択したグリッド内で右クリックして「列プロパティ」または「行プロパティ」を選択します。

位置合せ

列または行におけるコンポーネントのデフォルトの位置合せ。FormLayout内のデフォルトの位置合せは「最大サイズ化」です。

サイズ

列の幅または行の高さ。定数サイズ、コンポーネント・サイズ(最小値または推奨値)またはバインド・サイズ(最小値または最大値)を指定できます。定数サイズは、値および単位で指定します。コンポーネント・サイズは、列または行についてそこに含まれるコンポーネントの最大サイズを指定するものであり、コンポーネントの最小サイズまたは推奨サイズによって測定されます。バインド・サイズでは、(サイズ変更前の)列および行の開始サイズについて上限および下限を指定できます。これにより、列または行の最小または最大サイズが確保されます。列または行の拡張が可能である場合、最大サイズによって列または行のサイズが制限されることはない点に注意してください(サイズ変更の動作を参照)。

サイズ変更

サイズ変更を許可するかどうかを制御します。レイアウト・コンテナが推奨サイズより大きくなると、列および行は拡張可能です。デフォルトではサイズ変更は許可されません。

ギャップ

デフォルトでは、コンポーネント間にギャップが挿入されます。

注意: ギャップのサイズは現在固定されており、プロパティ・インスペクタで編集できません。

コンポーネントの順序

FormLayoutコンテナ内のコンポーネントの順序を変更するには、コンポーネントを新しい場所にドラッグします。

20.5.8 GridLayoutの使用

GridLayoutでは、行および列内のセルのグリッドにコンポーネントが配置されます。GridLayoutでは各コンポーネントが拡張され、セル内の使用可能な領域が埋まります。各セルはサイズが完全に同じであり、グリッドは均一です。GridLayoutコンテナをサイズ変更すると、コンテナに使用できる領域が与えられて、GridLayoutによりセルができるだけ大きくなるようセルのサイズが変更されます。

図20-5 GridLayout

テンキーまたはツールバーなど、コンポーネントを等しいサイズにする必要があるコンテナを設計している場合、GridLayoutを使用します。

グリッド内の列および行の数を指定できますが、ゼロにできるのは行または列の一方のみです。少なくともどちらか一方に値を指定し、GridLayoutマネージャがもう一方を計算できるようにする必要があります。

たとえば、15のコンポーネントが含まれるグリッドに対して4列およびゼロ行を指定した場合、GridLayoutでは4列および4行が作成され、最後の行には3つのコンポーネントが含められます。または、3行およびゼロ列を指定した場合、GridLayoutでは3行および5列が作成されます。

行および列の数だけでなく、水平ギャップ(hgap)および垂直ギャップ(vgap)プロパティを変更して、セル間のピクセル数を指定できます。デフォルトの水平および垂直ギャップはゼロです。

GridLayoutコンテナのプロパティ値を変更するには、「構造」ウィンドウでGridLayoutオブジェクトを選択してから、プロパティ・インスペクタで、rows、cols、hgap、またはvgapプロパティの値を編集します。

20.5.9 GridBagLayoutの使用

GridBagLayoutはきわめて柔軟かつ強力なレイアウトであり、グリッド内のコンポーネントのレイアウトをGridLayoutよりも厳密に制御します。GridBagLayoutでは、コンポーネントが動的な矩形グリッドに水平および垂直に配置されます。各コンポーネントのサイズが同じである必要はなく、複数のセルを埋めることもできます。

図20-6 GridBagLayout

GridBagLayoutでは、各コンポーネントの制約と最小サイズ、およびコンテナの優先サイズに基づいてコンポーネントの位置が決定されます。

このトピックで使用する用語の意味は次のとおりです。

• コンポーネントのセルは、コンポーネントが占めているグリッド・セルのセット全体を指します。

• コンポーネントの表示領域は、コンポーネントが占めているセルのうち、コンポーネントの外部余白(空間)に使用されていないすべてのスペースを指します。

GridBagLayoutは複合グリッドに対応できますが、コンポーネントを小さいパネルに編成してGridBagLayoutコンテナ内でネストする方が正常に(かつ予測どおりに)動作します。このようにネストしたパネルでは、他のレイアウトを使用したり、必要に応じてさらにコンポーネント・パネルを含めることができます。この方法には、次の2つのメリットがあります。

• ボタン・バーのような特定の領域に、より適切なレイアウトを使用できるため、コンポーネントの配置とサイズを個別に正確に制御できます。

• 使用するセルの数が少なくなり、GridBagLayoutが簡素化されて制御が容易になります。

一方、GridBagLayoutの方が使用するコンテナ数が多いため、他のレイアウト・マネージャを使用した場合に比べてプログラムのメモリー使用量が大きくなります。

20.5.9.1 GridBagLayout制約の理解

GridBagLayoutでは、GridBagConstraintsオブジェクトを使用してGridBagLayoutコンテナ内の各コンポーネントのレイアウト情報を指定します。各コンポーネントとGridBagConstraintsオブジェクトには1対1の関連があるため、GridBagConstraintsオブジェクトはコンテナのコンポーネントごとにカスタマイズする必要があります。

GridBagLayoutのコンポーネントには、次の制約があります。

• anchor

• fill

• gridx、gridy

• gridwidth、gridheight

• ipadx、ipady

• weightx、weighty

GridBagConstraintsを使用すると、次のことを制御できます。

• 各コンポーネントの位置(絶対または相対)。各コンポーネントのサイズ(絶対または相対)。

• 各コンポーネントがまたがるセルの数。

• 各セルの未使用の表示領域の埋め方。

• 各コンポーネントの内部余白と外部余白の大きさ。

• どのコンポーネントが使用可能な追加のスペースを利用するかを制御するための、各コンポーネントに対するスペース配分の割当て方法。これにより、コンテナのサイズを変更する際のコンポーネントの動作を制御します。

Javaビジュアル・エディタでの使用と設定に関するヒントなど、各制約の詳細は、それぞれの制約に関する各トピックを参照してください。

20.5.9.2 ソース・コードでのGridBagConstraintsの手動設定

Javaビジュアル・エディタを使用してGridBagLayoutコンテナを設計する場合、JDeveloperではコンテナに追加するコンポーネントごとに常に新規のGridBagConstraints2オブジェクトが作成されます。GridBagConstraintsはGridBagConstraintsから導出され、GridBagConstraintsの11のプロパティをすべて使用するコンストラクタを持つため、Javaビジュアル・エディタで生成されるコードを単純化できます。

次に例を示します。

bevelPanel1.add(textFieldControl3, new GridBagConstraints2(0, 5, 6, 2, 1.0, 0.0,
GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(0, 24, 0, 0), 150, 0));
bevelPanel1.add(checkboxControl1, new GridBagConstraints2(7, 5, 4, 1, 0.0, 0.0,
GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(8, 29, 0, 24), 18, -11)); 

GridBagConstraints2コンストラクタのパラメータは、ソース・コード内で直接変更するか、制約プロパティ・エディタを使用して値を変更できます。

GridBagLayoutコンテナを手動でコーディングして作成する場合は、単にGridBagLayoutコンテナごとにGridBagConstraintsオブジェクトを1つ作成します。GridBagLayoutでは、コンテナに追加したコンポーネントにGridBagConstraintsのデフォルト値が使用されるか、または最後に変更された値が再利用されます。コンテナに追加するコンポーネントで特定の制約に異なる値を使用する場合は、そのコンポーネントの新しい制約値を指定します。この新しい値は、以降のコンポーネントに対しても、再変更するまで有効となります。

注意: GridBagLayoutのこのコーディング方法は最も単純ですが(前に追加したコンポーネントの制約値が再利用されます)、そのコンテナをJavaビジュアル・エディタで視覚的に編集することはできません。

20.5.9.3 Javaビジュアル・エディタで使用する既存のGridBagLayoutコードの変更

前にGridBagConstraintsオブジェクトの1つを使用してGridBagLayoutコンテナを手動でコーディングしている場合、そのコンテナをJavaビジュアル・エディタで編集するにはコードを次のように変更する必要があります。

• コンテナに追加するコンポーネントごとにGridBagConstraints2オブジェクトを作成する必要があります。

• GridBagConstraints2オブジェクトには、前述した11の制約値それぞれのパラメータを含む大きいコンストラクタが必要です。

20.5.9.4 Javaビジュアル・エディタでのGridBagLayoutの視覚的な設計

GridBagLayoutは、複雑ですが便利なレイアウト・マネージャです。JDeveloperのJavaビジュアル・エディタには、GridBagLayoutを容易に設計および制御できるように、制約プロパティ・エディタ、グリッド、選択したコンポーネントのポップアップ・メニューなどの機能も用意されています。

Javaビジュアル・エディタでGridBagLayoutを設計するには2つの方法があります。つまり、GridBagLayoutパネルにコンポーネントを追加することで新規に設計する方法と、別のレイアウト(XYLayoutなど)を使用してJavaビジュアル・エディタでパネルのプロトタイプを作成し、必要に応じてコンポーネントの配列とサイズをすべて指定した後でGridBagLayoutに変換する方法です。この方法を使用すると、設計作業の所要時間を大幅に短縮できます。

どちらの方法を使用する場合でも、ネストしたパネルを利用して(詳細は、第20.5.33項「ネストしたコンテナおよびレイアウトの使用」を参照)、コンポーネントをグループ化し、これらを内から外へ構築することをお薦めします。これらのパネルを使用してGridBagLayoutコンテナの大部分を定義すると、GridBagLayout設計が簡素化され、グリッドのセル数とGridBagConstraintsを必要とするコンポーネントの数を減らすことができます。

20.5.10 GridBagLayoutへの変換

レイアウトのプロトタイプを最初に別のレイアウト内に作成する場合、最初に配置するときにパネルとコンポーネントを慎重に(特に左と上で)位置合せすれば、GridBagLayoutへの変換がはるかに明確かつ容易になります。実際にはグリッドを設計するため、コンポーネントを想像上のグリッド内に配置し、ネストしたパネルを使用して行数と列数を最小限に抑えるように注意してください。プロトタイプの作成にXYLayoutを使用すると、コンポーネントのポップアップ・メニュー(Javaビジュアル・エディタでコンポーネントを右クリックしてアクセス)でコンポーネント位置合せ機能を利用できます。

Javaビジュアル・エディタでは設計がGridBagLayoutに変換されるため、コンテナをGridBagLayoutに変更する前のコンポーネントの配置に基づいて、コンポーネントに制約値が割り当てられます。微調整が必要な場合があります。

GridBagLayoutへの変換により、特定のタイプのコンポーネント(テキスト領域、フィールド、グループ・ボックスまたはリストなど、通常は実行時にコンテナが拡大されるにつれてサイズが大きくなると予想されるコンポーネント)にweight制約が割り当てられます。GridBagLayoutに変換した後で設計の調整が必要になった場合は、最初にコンポーネントからweight制約をすべて削除(すべてを0に設定)すると、タスクが容易になります。

コンテナ内のすべてのコンポーネント間には複雑な相互作用があるため、0より大きいweight制約値を持つコンポーネントが1つでも存在すると、Javaビジュアル・エディタでサイズ変更動作を予測するのは困難です。

weight制約付きのコンポーネントを含むGridBagLayoutを見つけるのは簡単です。これは、コンポーネントがコンテナの中央に集まることはないためです。かわりに、コンポーネントがコンテナの端まで最大化されます。

ヒント: GridBagLayout内のコンポーネントからweightをすべて削除すると、次のいずれかの動作が発生します。 コンテナが大きくてグリッドが十分に収まる場合は、すべてのコンポーネントがコンテナの中央に集まり、グリッドの端の周囲に余分なスペースができます。 コンテナが小さすぎてコンポーネントが収まらない場合、グリッドはコンテナの端を超えて拡張され、コンテナの端からはみ出したコンポーネントは参照できなくなります。コンポーネントがすべて収まるまで、コンテナのサイズを拡大してください。設計中のGridBagLayoutコンテナがメインUI frameの中央にある単一パネルの場合は、frameのサイズを拡大します。このコンテナのサイズは、すべてのコンポーネントの制約を設定し終わった後で最終的なサイズに変更できます。

20.5.11 GridBagLayoutコンテナへのコンポーネントの追加

GridBagLayoutの作成時に新規GridBagLayoutコンテナにすべてのコンポーネントを追加する方法をとる場合は、次のように特定の動作を予想する必要があります。

• すべてのコンポーネントのデフォルトのweight制約は0 (ゼロ)であるため、コンテナに最初のコンポーネントを追加すると、コンテナ中央にminimumSizeで配置されます。1行および1列で構成されるグリッドができます。

• 次に追加するコンポーネントは、クリックした場所に応じて隣接するセルに配置されます。最初のコンポーネントの下をクリックすると、その列の次の行に移動します。コンポーネントの右側をクリックすると、同じ行の次の列に移動します。以降のコンポーネントもすべて同じ方法で追加され、1つ追加するたびにセルの数が1つずつ増加します。

• コンポーネントまたはコンポーネントを含むセルをいくつか配置した後、マウスでコンポーネントを新規のセル位置にドラッグするか、制約プロパティ・エディタでgridxおよびgridy制約を変更できます。

• グリッド数がコンテナ数よりも少なければ、追加するコンポーネントは数に関係なくすべてがコンテナ中央に集まります。より大きいコンテナが必要な場合は、単にJavaビジュアル・エディタで拡大します。

• 数行を追加し、設計が特定数の列に適切に収まった後、コンポーネント数が奇数である必要のある1行に気づいた場合は、1行全体を占めている行にパネルをドロップし、そのパネル内で別のレイアウトを使用して必要な外観にすることを検討してください。

20.5.12 制約プロパティ・エディタでのGridBagConstraintsの設定方法

GridBagLayoutの「制約」プロパティ・エディタを使用すると、Javaビジュアル・エディタで一部のGridBagConstraintsを指定でき、ソース・コードを編集する必要がありません。

図20-7 制約エディタ

「制約」プロパティ・エディタを制約の設定に使用する大きなメリットの1つは、複数のコンポーネントの制約を同時に変更できることです。たとえば、GridBagLayoutコンテナ内のすべてのボタンに同じ内部余白を使用する場合は、[Shift]キーを押しながらボタンを1つずつ選択し、「制約」プロパティ・エディタを開いて制約を編集できます。

「制約」プロパティ・エディタを使用する手順は、次のとおりです。

1. 「構造」ウィンドウまたはJavaビジュアル・エディタで、GridBagLayoutコンテナ内で変更するコンポーネントを選択します。

2. プロパティ・インスペクタでconstraintsプロパティを選択し、「値」フィールドをクリックします。

3. プロパティ・エディタで必要な制約を設定して「OK」をクリックします。

20.5.13 グリッドの表示

Javaビジュアル・エディタにはオプションのグリッドが表示され、レイアウトに含まれる各セルおよびコンポーネントの操作結果を正確に確認できます。

• このグリッドを表示するには、GridBagLayoutコンテナ内でコンポーネントを右クリックして「グリッドの表示」を選択します。

• 「グリッドの表示」の選択時にグリッドを一時的に非表示にするには、GridBagLayoutコンテナに含まれていないコンポーネント(GridBagLayoutコンテナ自体を含む)をクリックします。これにより、グリッドが表示されなくなります。グリッドが表示されるのは、GridBagLayoutコンテナ内のコンポーネントが選択されている場合のみです。

• グリッドを永続的に非表示にするには、コンポーネントを右クリックして再度「グリッドの表示」を選択します。

20.5.14 マウスによる制約の変更

Javaビジュアル・エディタでは、マウスを使用してコンポーネント全体をドラッグするか、コンポーネントの各種サイズ変更ニブを操作して一部の制約を設定できます。制約を視覚的に設定する手順は、制約に関する以降の各トピックを参照してください。

20.5.15 GridBagLayoutのポップアップ・メニューの使用

GridBagLayoutコンポーネントを右クリックするとポップアップ・メニューが表示されます。このメニューから制約プロパティ・エディタの一部のプロパティに容易にアクセスし、特定の制約をすばやく設定または削除できます。

表20-4 GridBagLayoutのポップアップ・メニュー・コマンド

メニュー・コマンド	アクション
余白の削除	選択したコンポーネントのサイズ・パディング値(ipadxおよびipady)が0 (ゼロ)に設定されます。
制約	選択したGridBagLayoutコンポーネントの「制約」ポップアップ・エディタが表示されます。
水平方向に最大サイズ化	コンポーネントのfill制約の値がHORIZONTALに設定(OR)されます。コンポーネントが拡張され、セルが水平方向に最大化されます。fillがVERTICALだった場合、制約はBOTHに設定されます。
垂直方向に最大サイズ化	コンポーネントのfill制約の値がVERTICALに設定(OR)されます。コンポーネントが拡張され、セルが垂直方向に最大化されます。fillがHORIZONTALだった場合、制約はBOTHに設定されます。
最大サイズ化の削除	コンポーネントのfill制約の値がNONEに変更されます。
水平方向のスペース配分	コンポーネントのweightx制約の値が1.0に設定されます。
垂直方向のスペース配分	コンポーネントのweighty制約の値が1.0に設定されます。
スペース配分の削除	コンポーネントのweighty制約とweighty制約の値が両方とも0.0に設定されます。

20.5.16 GridBagConstraints

この項では、各GridBagConstraintsについて個別に説明します。各制約の定義、有効な値とデフォルトの値、その制約をJavaビジュアル・エディタで視覚的に設定する方法について説明します。

anchor

コンポーネントが表示領域よりも小さい場合は、anchor制約を使用し、レイアウト・マネージャに対して領域内のコンポーネントの配置場所を指示します。

anchor制約は、表示領域内のコンポーネントにのみ、そのコンポーネントのfill制約に応じて影響します。たとえば、コンポーネントのfill制約値がGridBagConstraints.BOTH (表示領域を水平方向と垂直方向に塗りつぶす)の場合、コンポーネントは使用可能な領域全体を使用するため、anchor制約は無効です。anchor制約を有効にするには、fill制約の値をGridBagConstraints.NONE、GridBagConstraints.HORIZONTALまたはGridBagConstraints.VERTICALに設定します。

有効な値は次のとおりです。

GridBagConstraints.CENTER

GridBagConstraints.NORTH

GridBagConstraints.NORTHEAST

GridBagConstraints.EAST

GridBagConstraints.SOUTHEAST

GridBagConstraints.SOUTH

GridBagConstraints.WESTGridBagConstraints.SOUTHWEST

GridBagConstraints.NORTHWEST

デフォルト値: GridBagConstraints.CENTER

Javaビジュアル・エディタでanchor制約を設定するには、次のようにします。

セルよりも小さいコンポーネントのanchorは、マウスを使用して設定できます。移動可能なツールバーをドッキングする場合と同様に、単にコンポーネントをクリックし、表示領域の端にある目的の場所へドラッグします。たとえば、ボタンをセルの左上隅に配置指定するには、ボタンの中央でマウスをクリックし、ボタンの左上隅がセルの左上隅に接するまでドラッグします。これにより、anchor制約の値がNorthWestに設定されます。

anchor制約は、制約プロパティ・エディタでも次の手順で指定できます。

1. Javaビジュアル・エディタでコンポーネントを選択します。

2. プロパティ・インスペクタで、「constraints」プロパティをクリックして「制約エディタ」を表示します。

3. アンカー領域で、anchor制約に必要な値を選択して「OK」をクリックします。

fill

コンポーネントの表示領域がコンポーネントに必要なサイズよりも大きい場合は、fill制約を使用し、レイアウト・マネージャに対して表示領域でコンポーネントに使用する部分を指示します。anchor制約の場合と同様に、fill制約は独自の表示領域内のコンポーネントにのみ影響します。fillはレイアウト・マネージャに対し、コンポーネントを拡張して与えられた領域全体を埋めるように指示します。

有効な値は次のとおりです。

GridBagConstraints.NONE

(コンポーネントのサイズは変更されません。)

GridBagConstraints.BOTH

(コンポーネントはサイズ変更され、水平方向と垂直方向の両方で領域全体に収まるように最大サイズ化されます。)

GridBagConstraints.HORIZONTAL

(コンポーネントはサイズ変更され、領域に収まるように水平方向でのみ最大サイズ化されます。)

GridBagConstraints.VERTICAL

(コンポーネントはサイズ変更され、領域に収まるように垂直方向でのみ最大サイズ化されます。)

デフォルト値: GridBagConstraints.NONE

Javaビジュアル・エディタでfill制約を指定するには、次のようにします。

コンポーネントのfill制約を最も短時間で指定する方法は、Javaビジュアル・エディタでコンポーネントのポップアップ・メニューを使用することです。

1. Javaビジュアル・エディタでコンポーネントを右クリックしてポップアップ・メニューを表示します。

2. 次のいずれか1つを実行します。

   • 「水平方向に最大サイズ化」を選択して値をHORIZONTALに設定します。

   • 「垂直方向に最大サイズ化」を選択して値をVERTICALに設定します。

   • 「水平方向に最大サイズ化」と「垂直方向に最大サイズ化」の両方を選択し、値をBOTHに設定します。

   • 「最大サイズ化の削除」を選択して値をNONEに設定します。

   fill制約は制約エディタでも指定できます。

   1. プロパティ・インスペクタで、「constraints」プロパティをクリックして「制約エディタ」を表示します。

   2. 「最大サイズ化」領域で、fill制約に必要な値を選択して「OK」をクリックします。

gridwidth、gridheight

この2つの制約を使用して、コンポーネントで使用する1行のセル数(gridwidth)または1列のセル数(gridheight)を指定します。この制約の値は、ピクセルではなくセル数で表されます。

有効な値は次のとおりです。

gridwidth=nn、gridheight=nn

(nnは、セルの列数または行数を表す整数です。)

GridBagConstraints.RELATIVE (-1)

このコンポーネントを行(gridwidth)または列(gridheight)の最後のコンポーネントの横に配置するように指定します。GridBagConstraints.RELATIVEがあるコンポーネントが、最後のセルを除く残りすべてのセルを占めます。たとえば、6列で構成される行では、コンポーネントが第3列から始まる場合、gridwidthがRELATIVEであれば第3、第4および第5列を占めることになります。

GridBagConstraints.REMAINDER (0)

このコンポーネントが行(gridwidth)または列(gridheight)の最後のコンポーネントになるように指定します。

デフォルト値: gridwidth=1, gridheight=1

Javaビジュアル・エディタでgridwidthおよびgridheight制約を指定するには、次のようにします。

gridwidthおよびgridheight制約の値は、制約プロパティ・エディタで指定できます。

1. プロパティ・インスペクタで、「constraints」プロパティをクリックして「制約エディタ」を表示します。

2. 「グリッド位置」領域で、「幅」フィールドにgridwidthの値を入力するか、「高さ」フィールドにgridheightの値を入力します。コンポーネントが行または列に占めるセルの数を指定します。

   • 値をRELATIVEにする場合は、-1を入力します。

   • 値をREMAINDERにする場合は、0を入力します。

マウスを使用してコンポーネントのサイズを隣接する空のセルにあわせて調整すると、gridwidthまたはgridheightを変更できます。

gridx、gridy

この2つの制約を使用して、コンポーネントの左上隅のグリッド・セルの位置を指定します。たとえば、gridx=0は左端の列、gridy=0は先頭の行になります。したがって、制約gridx=0およびgridy=0を持つコンポーネントは、グリッドの第1セル(左最上部)に配置されます。

GridBagConstraints.RELATIVEでは、次のように、コンポーネントを直前のコンポーネントに対する相対位置に配置するように指定します。

• gridxとともに使用すると、このコンポーネントを最後に追加したコンポーネントの右隣に配置するように指定できます。

• gridyとともに使用すると、このコンポーネントを最後に追加したコンポーネントの直下に配置するように指定できます。

有効な値は次のとおりです。

gridx=nn、gridy=nn

GridBagConstraints.RELATIVE (-1)

GridBagLayoutがサポートする行数と列数の最大値は512です。したがって、XおよびYには512以下の値を指定する必要があります。

デフォルト値:

gridx=0、gridy=0

Javaビジュアル・エディタでグリッド・セル位置を指定するには、次のようにします。

マウスを使用して、コンポーネントの左上隅が占めるセルを指定できます。コンポーネントの左上隅の付近をクリックし、新規セルにドラッグします。複数のセルを占めるコンポーネントを移動する場合は、コンポーネントを選択するときに必ず左上のセルをクリックしてください。そのコンポーネントの他の制約に指定されている値が原因で、コンポーネントをマウスで新規セルに移動すると、他の制約の値が変化することがあります。たとえば、コンポーネントが占めるセルの数が変化することがあります。他の制約を誤って変更することなくgridxおよびgridy制約を正確に指定するには、制約プロパティ・エディタを使用します。

1. プロパティ・インスペクタで、「constraints」プロパティをクリックして「制約エディタ」を表示します。

2. 「グリッド位置」領域で、「X」フィールドにgridx値の列番号を入力するか、「Y」フィールドにgridy値の行番号を入力します。値をRELATIVEにする場合は、-1を入力します。

注意: マウスを使用してコンポーネントを使用セルに移動する場合、Javaビジュアル・エディタでは、2つのコンポーネントがオーバーラップしないように、セルの新規の1行と1列が挿入されます。そのため、各コンポーネントが他のコンポーネントの上に重なることはありません。「制約」プロパティ・エディタを使用してコンポーネントの配置を変更する場合、Javaビジュアル・エディタではコンポーネントがオーバーラップするかどうかがチェックされません。

insets

insetsを使用して、コンポーネントと表示領域の端の間の外部スペース(余白)の最小量をピクセル単位で指定します。insetでは、コンポーネントの端およびセルの対応する端の間に常に指定のギャップを保つ必要があることを指定します。したがって、insetsはコンポーネントをセルの端から離しておくためのブレーキのような役割を果たします。たとえば、左右のinsetsを持つコンポーネントの幅をセルよりも広くなるように増やすと、セルはコンポーネントとinsetsが収まるように拡張されます。fillおよびpadding制約によりinsetsからスペースが借用されることはありません。

有効な値:

insets = new Insets(n,n,n,n)

上、左、下、右(各パラメータは表示領域とセルの一方の端の間隔をピクセル数で表します)。

デフォルト値:

insets = new Insets(0,0,0,0)

Javaビジュアル・エディタでinset値を設定するには、次のようにします。

Javaビジュアル・エディタでは、選択したGridBagLayoutコンポーネント上に、insetsの位置とサイズを示す青いサイズ変更ニブが表示されます。青いニブ(サイズ変更ハンドル)をマウスで選択してドラッグし、insetのサイズを増減させます。

inset値がゼロである場合、図20-8に示すように、セルの1辺には青いニブが1つのみ表示されます。

図20-8 inset値が0に設定されたGridBagLayout

図20-9に示すように、inset値が0よりも大きければ、Javaビジュアル・エディタでは、そのinset用の青いニブがセルの端に1つと表示領域の端に1つ、ペアとして表示されます。insetのサイズは、2つのニブの間隔(ピクセル数)です。ニブを選択してinsetのサイズを変更します。

図20-9 inset値が0より大きい値に設定されたGridBagLayout

insetの値をより正確に制御するには、制約プロパティ・エディタを使用して正確なピクセル数を指定します。

1. プロパティ・インスペクタで、「constraints」プロパティをクリックして「制約エディタ」を表示します。

2. 「外枠までの空間」領域で、各inset (上、左、下または右)のピクセル数を指定します。

注意: 負のinset値は有効ですが、指定するとコンポーネントが隣のコンポーネントにオーバーラップすることがあるためお薦めしません。

ipadx、ipady

この2つの制約では、コンポーネントの内部余白を指定します。ipadxおよびipadyを使用し、コンポーネントの最小サイズに内部余白用として追加するスペースの大きさ(ピクセル単位)を指定します。たとえば、コンポーネントの幅は、最小幅とipadx (ピクセル単位)の合計以上になります。コードでは1度のみ追加され、コンポーネントの両側で均等に分割されます。同様に、コンポーネントの高さは、最小の高さとipadyのピクセル数の合計以上になります。

1. ipadxでは、コンポーネントの最小幅に追加するピクセル数を指定します。

2. ipadyでは、コンポーネントの最小の高さに追加するピクセル数を指定します。

たとえば、優先サイズが幅30ピクセル、高さ20ピクセルのコンポーネントに追加するとします。

• ipadx= 4の場合、コンポーネントの幅は34ピクセルになります。

• ipadx= 2,の場合、コンポーネントの高さは22ピクセルになります。

有効な値は次のとおりです。

ipadx=nn、ipadx=nn

デフォルト値:

ipadx=0、ipady=0

Javaビジュアル・エディタで内部余白サイズの制約を設定するには、次のようにします。

Javaビジュアル・エディタでの内部余白サイズの制約の設定。サイズ変更ニブを、セルの端を超えて空の隣接セルへとドラッグすると、コンポーネントは両方のセルを占めることになります(gridwidthまたはgridheightの値が1セルずつ増えます)。

図20-10 サイズ変更ニブをセルの端を超えてドラッグする前

図20-11 サイズ変更ニブをセルの端を超えてドラッグした後

余白値をより正確に制御するには、「制約」プロパティ・エディタを使用して値に使用する正確なピクセル数を指定します。

1. プロパティ・インスペクタで、「constraints」プロパティをクリックして「制約エディタ」を表示します。

2. 「サイズ・パディング」領域で、「幅」と「高さ」にピクセル数を入力して「OK」をクリックします。

余白をすばやく削除(0に設定)するには、Javaビジュアル・エディタでコンポーネントを右クリックして「余白の削除」を選択します。複数のコンポーネントを選択し、同じ手順で一度にすべてのコンポーネントから余白を削除することもできます。

負の値は有効です。負の値を指定すると、コンポーネントが優先サイズよりも小さくなります。

注意: パディングはXYLayoutに似ていますが、コンピュータ・システムや言語によっては正確でない場合があります。

weightx、weighty

weight制約を使用して、GridBagLayoutコンテナの余分なスペースをサイズ変更時に水平方向(weightx)および垂直方向(weighty)にどのように配分するかを指定します。weightにより、コンテナをデフォルト・サイズより大きく拡大した場合に、各セルおよびコンポーネントに配分される余分なスペースの割合が決定されます。

「スペース配分」の値はdouble型で、0.0から1.0の範囲の数値で指定します。ゼロは、コンポーネントにはスペースを設定できないことを示し、1.0は、コンポーネントがスペースを完全に共有することを示します。

• 行のスペース配分は、その行に含まれる全コンポーネントの最大weightxとして計算されます。

• 列のスペース配分は、その列に含まれる全コンポーネントの最大weightyとして計算されます。

有効な値:

weightx=n.n、weighty=n.n

デフォルト値:

weightx=0.0、weighty=0.0

Javaビジュアル・エディタでのweightxおよびweighty制約の設定

Javaビジュアル・エディタでコンポーネントのweight制約を指定するには、コンポーネントを右クリックして「水平方向のスペース配分」(weightx)または「垂直方向のスペース配分」(weighty)を選択します。これにより、値が1.0に設定されます。weightを削除(0に設定)するには、コンポーネントを右クリックして「スペース配分の削除」を選択します。この操作を複数のコンポーネントに対して実行できます。[Shift]キーを押しながら各コンポーネントを選択し、右クリックして適切なメニュー項目を選択します。

weight制約を0.0または1.0以外の値に設定する場合は、制約エディタで値を設定できます。

1. プロパティ・インスペクタで、「constraints」プロパティをクリックして「制約エディタ」を表示します。

2. 「スペース配分」領域で、「X」(weightx)または「Y」(weighty)に0.0から1.0の値を入力して「OK」をクリックします。

注意: weight制約を使用すると、Javaビジュアル・エディタでのサイズ変更動作を予想するのが難しくなることがあるため、これらの制約はGridBagLayout設計の最終ステップで設定してください。

weight制約がコンポーネントの動作に及ぼす影響の例

• 図20-12に示すように、すべてのコンポーネントのweight制約が1方向で0に設定されている場合、コンポーネントはそのディメンションでコンテナの中央に集まり、優先サイズを超えて広がることはありません。GridBagLayoutは、セルのグリッドとコンテナの端の間にスペースを挿入します。

  図20-12 0に設定されたweight制約

  
  

• 図20-13に示すように、weightx制約がそれぞれ0.0、0.3および0.2に設定されている3つのコンポーネントがある場合、コンテナを拡大しても最初のコンポーネントには追加のスペースが配分されず、3/5が第2コンポーネントに、2/5が第3コンポーネントに配分されます。

  図20-13 weight制約が0.0、0.3および0.2に設定された3つのコンポーネント

  
  

• コンポーネントを拡大する場合は、weight制約とfill制約の両方を設定する必要があります。たとえば、コンポーネントにweightx制約を設定しても、水平方向のfill制約を設定しなければ、コンポーネントの左端および右端とセルの端の間の空間に追加のスペースが配分されます。コンポーネントのサイズは変更されず、セルの幅が大きくなります。コンポーネントにweight制約とfill制約の両方を設定すると、セルに追加のスペースが追加されるのみでなく、コンポーネントが拡張され、新規セル・ディメンション内でfill制約の方向(この場合は水平)に最大化されます。

  図20-14では、GridBagLayoutパネルの全コンポーネントについてweight制約が値0に設定されています。この制約のため、コンポーネントはGridBagLayoutパネルの中央に集まっており、パネル上の余分なスペースはすべてグリッドの外枠とパネルの間に配分されています。グリッドのサイズは、コンポーネントの優先サイズとinsetsおよび余白(ipadxまたはipady)の合計により決定されます。

  図20-14 weight制約値がゼロに設定されたすべてのコンポーネント

  
  

  図20-15では、ListControlに対して水平方向のweight制約として1.0が指定されています。1つのコンポーネントにweightが割り当てられると同時に、パネル内でUI設計は中央に揃えられなくなります。水平方向のweightが使用されているため、GridBagLayoutマネージャにより、パネル内で以前はグリッドの両側にあった余分なスペースがListControlを含むセルに配分されます。また、ListControlのサイズが変化していないこともわかります。

  図20-15 ListControlに対して1.0に設定された水平方向のweight制約

  
  
  
  

  ヒント: コンポーネントにweightを追加した後もセル内に必要以上のスペースが残る場合は、余分なスペースの大きさが適正になるまでUIのframeのサイズを小さくしてください。フレームのサイズを小さくするには、Javaビジュアル・エディタでframeを選択するか、「構造」ウィンドウでthis(BorderLayout)を選択し、黒のサイズ変更ニブをクリックして、frameを必要なサイズになるまでドラッグします。

  
  

  図20-16に示すように、ListControlに水平方向のfillを追加すると、コンポーネントが拡張され、セルの新しい水平方向のディメンションに収まるように最大サイズ化されます。

  図20-16 ListControlに追加された水平方向のfill

  
  

• 列のコンポーネントの1つにweightx値が設定されている場合、GridBagLayoutによりそのweightが列全体に割り当てられます。反対に、行のコンポーネントの1つにweighty値が設定されている場合は、そのスペース配分が行全体に割り当てられます。

20.5.17 OverlayLayout2の使用

OverlayLayout2を使用すると、コンポーネントを相互に重ねて配置できます。コンテナに必要なサイズは子に必要な最大サイズで、位置合せを考慮する必要があります。位置合せは、子を割当て領域に適切に配置するために必要な操作に基づきます。子は、位置合せのポイントがすべて相互に重なり合うように配置されます。BorderLayoutによる中央揃えとは異なり、OverlayLayout2では使用可能なスペースに収まるようにコンポーネントが拡張されるのではなく、優先サイズが保たれます。

20.5.18 PaneLayoutの使用

図20-17に示すように、PaneLayoutを使用すると、コンポーネントのサイズを兄弟コンポーネントとの相対で指定できます。パネルまたはフレームにPaneLayoutを適用すると、コンポーネントがコンテナに占める割合を相互の相対パーセントで制御できますが、ペイン間に移動可能なスプリッタ・バーは作成されません。

図20-17 PaneLayout

PaneLayoutでは、各コンポーネントの配置とサイズをコンテナに追加済のコンポーネントとの相対で指定します。各コンポーネントでは、PaneConstraintsオブジェクトを指定します。このオブジェクトは、コンポーネントがスペースを使用しているレイアウト・マネージャと、既存のスペースの使用量を指定します。各コンポーネントのPaneConstraintsオブジェクトは、コンポーネントをコンテナに追加する時点で存在していたコンテナに適用されます。コンポーネントをコンテナに追加する順序が重要になります。

コンテナに追加するPaneConstraintsコンポーネントに対する制約は、次の4つの変数で構成されます。

• String name

  このコンポーネントの名前(CardLayoutの場合と同様に、コンテナ内の全コンポーネントに対して一意であることが必須)。

• String splitComponentName

  このコンポーネント用の余地を確保するためにスペースが使用されるコンポーネントの名前

• String position

  このコンポーネントが配置指定されるsplitComponentNameの端。

  表20-5は、有効な値を示しています。

  表20-5 String positionの有効な値

  オプション	操作
  PaneConstraints.TOP	このコンポーネントはsplitComponentNameの上に配置されます。
  PaneConstraints.BOTTOM	このコンポーネントはsplitComponentNameの下に配置されます。
  PaneConstraints.RIGHT	このコンポーネントはsplitComponentNameの右側に配置されます。
  PaneConstraints.LEFT	このコンポーネントはsplitComponentNameの左側に配置されます。
  PaneConstraints.ROOT	このコンポーネントは最初に追加されたコンポーネントです。

  
  

• float proportion

  splitComponentNameのうち、このコンポーネントに割り当てられる割合。0と1の間の数値です。

20.5.19 PaneLayoutへのコンポーネントの追加方法

コンポーネントはPaneLayoutに次のように追加されます。

• 第1コンポーネントは、常にコンテナの領域全体を占めます。第1コンポーネントのPaneConstraintで重要な変数は、nameのみです。この値は他のコンポーネントでsplitComponentNameとして指定されて使用されます。

• 第2コンポーネントでは、splitComponentNameとして第1コンポーネントのnameを指定する必要があります。

• 以降のコンポーネントのsplitComponentNameでは、すでにコンテナに追加した任意のコンポーネントのnameを指定できます。

20.5.20 Javaビジュアル・エディタでのPaneLayoutコンテナの作成方法

Javaビジュアル・エディタでPaneLayoutコンテナを作成できます。

PaneLayoutコンテナを作成するには、次のようにします。

1. Javaビジュアル・エディタでUIにコンテナを追加します。これには、図20-18に示すように、任意のフレームまたはパネルを使用できます。

   図20-18 Javaビジュアル・エディタでのUIコンテナ

   
   

2. コンテナのlayoutプロパティをPaneLayoutに変更します。これにより、インスペクタでPaneLayoutプロパティにアクセスできます。

3. コンポーネント・パレットで、第1コンポーネントを選択してPaneLayoutコンテナにドロップします。このコンポーネントは、別のコンポーネントを追加するまでコンテナ内で完全に最大化されます。

   図20-19 PaneLayoutコンテナにドロップされたコンポーネント

   
   

4. 第2コンポーネントを選択し、必要な位置で必要なサイズになるようにドラッグします。

   図20-20 PaneLayoutにドラッグされた第2コンポーネント

   
   
   
   

   注意: PaneLayoutコンテナに追加した第1コンポーネント自体がコンテナだった場合、Javaビジュアル・エディタでは第2コンポーネントをPaneLayoutコンテナではなく外側のコンテナに追加しようとしているものとみなされます。コンポーネント・ツリーを使用して、コンポーネントの配置先コンテナを指定してください。

   
   

5. 第3コンポーネントをPaneLayoutに追加するには、同様の手順で描画して、他のコンポーネントとの相対位置を定義します。

   たとえば、コンテナの右半分を分割するには、パネルの右端中央から第1コンポーネントの右下隅へと第3コンポーネントを描画します。

   図20-21 PaneLayoutにドラッグされた第3コンポーネント

   
   

6. 同じ方法で以降のコンポーネントを追加します。

20.5.21 VerticalFlowLayoutの使用

VerticalFlowLayoutでは、各コンポーネントのpreferredSizeを使用して、コンポーネントを上から下へ、左から右へと各列に配置します。VerticalFlowLayoutは、1列に収まる数のコンポーネントを配置すると、新規の列に移動します。通常、VerticalFlowLayoutを使用するのはパネルにボタンを配置する場合です。

図20-22 VerticalFlowLayout

上詰め、中央揃えまたは下詰めを指定して、VerticalFlowLayoutコンテナの各列におけるコンポーネントの配置方法を選択できます。コンポーネントと列とのギャップ(水平方向と垂直方向の間隔)も指定できます。さらに、コンポーネントを列の幅まで最大化するか、または最後のコンポーネントをコンテナの残りの高さまで最大化するかを指定できるプロパティも用意されています。これらのプロパティを変更するには、Javaビジュアル・エディタからインスペクタを使用します。

位置合せ

• 上詰め - コンポーネントをコンテナの上部でグループ化します。

• 中央揃え - コンポーネントをコンテナ内で垂直方向の中央に配置します。

• 下詰め - 最後のコンポーネントがコンテナの最下部に位置するようにコンポーネントをグループ化します。

VerticalFlowLayoutのデフォルトの位置合せは「中央揃え」です。

位置合せを変更するには、「構造」ウィンドウでverticalFlowLayoutオブジェクトを選択し、インスペクタで位置合せプロパティの値を次のように指定します。

• 0=TOP

• 1=Middle

• 2=BOTTOM

ギャップ

VerticalFlowLayout内のコンポーネントのデフォルトのギャップは5ピクセルです。

水平方向または垂直方向のギャップを変更するには、「構造」ウィンドウでVerticalFlowLayoutオブジェクトを選択し、インスペクタでhgapプロパティ(水平方向のギャップ)またはvgapプロパティ(垂直方向のギャップ)のピクセル値を変更します。

コンポーネントの順序

VerticalFlowLayoutコンテナ内のコンポーネントの順序を変更するには、コンポーネントを新しい位置にドラッグします。

水平方向の最大サイズ化

horizontalFillを使用すると、すべてのコンポーネントがコンテナの幅まで拡張されるように、端まで最大サイズ化することを示すフラグを指定できます。

図20-23 horizontalFill

警告: メイン・パネルの空白が必要量よりも少ないと、プログラムが不安定になることがあります。このプロパティでは、複数列の出力も禁止されます。

垂直方向の最大サイズ化

verticalFillを使用すると、最後のコンポーネントがコンテナの残りの高さまで最大化されるように、垂直方向の最大サイズ化フラグを指定できます。

図20-24 verticalFill

verticalFillのデフォルト値はFalseです。

20.5.22 XYLayoutの使用

XYLayoutは、JDeveloperのカスタム・レイアウト・マネージャです。XYLayoutにより、コンテナ内のコンポーネントがコンテナの左上隅に対する特定の相対座標(x,y)に配置されます。コンテナにより、表示タイプに関係なく常にコンポーネントの相対(x,y)位置が保持されます。ただし、XYLayoutを使用してコンテナをサイズ変更しても、コンポーネントの配置やサイズは変更されません。

XYLayoutコンテナのpreferredSizeは、XYLayoutのwidthおよびheightプロパティの指定値で定義されます。たとえば、コンテナの初期化中に次のコード行があるとします。

xYLayoutN.setWidth(400);

xYLayoutN.setHeight(300);

この場合、xYLayoutNがコンテナのレイアウト・マネージャであれば、そのpreferredSizeは400 x 300ピクセルとなります。

UI内のネストしたパネルの1つにXYLayoutが使用されている場合、そのパネルのpreferredSizeはレイアウトのsetWidth()コールとsetHeight()コールによって決定されます。この値は、次(外側)のコンテナのpreferredSizeを計算する際にパネルに使用されます。

図20-25 XYLayout

XYLayoutは、ユーザー・インタフェースのプロトタイプを作成する際に使用すると便利です。複数のネストしたパネルを使用して、より複雑なユーザー・インタフェースを設計する場合は、XYLayoutをパネルとコンポーネントの初期レイアウトに使用し、その後、標準レイアウトの1つから最終設計に使用するものを選択できます。

注意: XYLayoutでは、画面にオブジェクトを配置するときに絶対x,y値が使用され、様々な画面解像度にあわせた調整は行われません。レイアウトが他の解像度にあわせて確実に調整されるように、最終設計ではコンテナをXYLayoutに残さないでください。

UI設計ツールを使用すると、コンテナのサイズおよびコンポーネントのx,y座標を指定できます。

• XYLayoutを使用してコンテナのサイズを指定するには、「構造」ウィンドウでXYLayoutオブジェクトを選択し、プロパティ・インスペクタでheightおよびwidthプロパティにピクセル・ディメンションを入力します。この設定により、XYLayoutコンテナのサイズを指定します。

• XYLayoutを使用してコンテナの(x,y)値を変更するには、次のようにします。

  • Javaビジュアル・エディタで、コンポーネントを新しいサイズになるようにドラッグします。JDeveloperにより、プロパティ・インスペクタ内の制約値が自動的に更新されます。

  • 「構造」ウィンドウでコンポーネントを選択し、constraintsプロパティ編集フィールドをクリックして、そのコンポーネントの座標を入力します。

  ポップアップ・メニューから使用可能な位置合せオプション

  表20-6 位置合せオプション

  オプション	操作
  最初へ移動	選択したコンポーネントをZ順序(左上→右上→左下→右下)の最初に移動します。
  最後へ移動	選択したコンポーネントをZ順序の最後に移動します。
  左に揃える	選択したコンポーネントの左端を、最初に選択したコンポーネントの左端にあわせます。
  左右中央に揃える	選択したコンポーネントの水平方向の中央を、最初に選択したコンポーネントの水平方向の中央にあわせます。
  右に揃える	選択したコンポーネントの右端を、最初に選択したコンポーネントの右端にあわせます。
  上に揃える	選択したコンポーネントの上端を、最初に選択したコンポーネントの上端にあわせます。
  上下中央に揃える	選択したコンポーネントの垂直方向の中央を、最初に選択したコンポーネントの垂直方向の中央にあわせます。
  下に揃える	選択したコンポーネントの下端を、最初に選択したコンポーネントの下端にあわせます。
  横間隔を均等にする	最初に選択したコンポーネントと最後に選択したコンポーネントの間で、選択した各コンポーネントを水平に等間隔で配置します。
  縦間隔を均等にする	最初に選択したコンポーネントと最後に選択したコンポーネントの間で、選択した各コンポーネントを垂直に等間隔で配置します。
  横サイズを同一にする	選択した全コンポーネントの幅を、最初に選択したコンポーネントと同じにします。
  縦サイズを同一にする	選択した全コンポーネントの高さを、最初に選択したコンポーネントと同じにします。

  
  

  XYLayoutを使用するには、レイアウトをnullに設定してJavaビジュアル・エディタでUIのプロトタイプを直接作成する方が簡単です。UIコンポーネントは、配置する場所に作成時のサイズで設定されます。詳細は、第20.6項「レイアウト・プロパティを使用したUIのプロトタイプ作成」を参照してください。

20.5.23 レイアウト・プロパティの理解

各コンテナのレイアウト・プロパティには、通常、なんらかのタイプのレイアウト・マネージャがアタッチされています。レイアウト・マネージャには、コンテナに追加される全コンポーネントのサイズ設定と位置に影響する可能性を持つプロパティがあります。これらのプロパティは、「構造」ウィンドウでレイアウト・マネージャを選択すると、インスペクタで表示して編集できます。「構造」ウィンドウでは、レイアウト・マネージャはアタッチ先コンテナの直下に項目として表示されます。

図20-26 レイアウト・プロパティ

20.5.24 レイアウト制約の理解

JDeveloperでは、コンテナに追加するコンポーネントごとに、制約オブジェクトがインスタンス化されるか、制約値が生成される場合があります。制約値は、レイアウト・マネージャがこの特定のコンポーネントをサイズ設定および配置する方法に関する追加情報を提供します。作成される制約オブジェクトまたは値のタイプは、使用中のレイアウト・マネージャのタイプによって決まります。インスペクタには、各コンポーネントの制約がコンポーネント自体のプロパティであるかのように表示され、これらの制約は編集できます。

20.5.25 実行時のUIウィンドウのサイズと位置の決定

UIクラスがFrameまたはDialogの場合は、サイズと位置を実行時に制御できます。サイズと位置は、UIウィンドウ作成時のコードの内容と、ユーザーがサイズ変更または再配置のために実行する操作によって決定されます。

UIウィンドウを作成して各種コンポーネントを追加すると、追加した各コンポーネントがウィンドウ全体のpreferredSizeに影響し、通常はコンポーネントを追加するたびにウィンドウ・コンテナのpreferredSizeが大きくなります。このpreferredSizeに対する効果は、外側のコンテナのレイアウト・マネージャおよびネストしたコンテナのレイアウトによって異なります。各種レイアウトのpreferredLayoutSizeの計算方法の詳細は、このドキュメントの各レイアウト・タイプの項を参照してください。

UIウィンドウのサイズはプログラムにより(ユーザーが追加のサイズ変更を行う前に)設定され、次のコンテナ・メソッドのうちコードで最後にコールされるメソッドにより決定されます。

• pack()

• setsize()

実行時のUIの位置は、コンテナのlocationプロパティを(たとえば参照可能にする前にsetLocation()をコールして)設定してオーバーライドしなければ、0,0になります。

20.5.26 pack()による自動的なウィンドウ・サイズ設定

pack()メソッドでは、中に含まれているコンポーネントに基づいてウィンドウのpreferredSizeが計算され、計算結果に従ってウィンドウ自体のサイズが設定されます。pack()では中に配置されたコンポーネントのpreferredSizeも考慮した上で、可能な範囲内で最小のウィンドウが作成されます。

注意: 「新規アプリケーション」ダイアログで作成されるApplication.javaファイルでは、pack()がコールされ、フレームは参照可能になる前にpreferredSizeまで圧縮されます。

20.5.27 コンテナのpreferredSizeの計算方法

preferredSizeの計算方法は、コンテナとレイアウトによって異なります。

20.5.28 移植性のあるレイアウト

移植性のあるレイアウト(FlowLayoutやBorderLayoutなど)のpreferredSizeは、レイアウト・ルールとコンテナに追加された各コンポーネントのpreferredSizeの組合せに基づいて計算されます。コンポーネントのいずれかがコンテナ(Panelなど)の場合、そのPanelのpreferredSizeはレイアウトおよびコンポーネントに従って計算されます。レイアウトの計算は、必要に応じてネストしたコンテナのレイヤーの数だけ再帰的に繰り返されます。特定のレイアウトに関するpreferredSizeの計算の詳細は、そのレイアウトの説明を参照してください。

20.5.29 setSize()によるウィンドウ・サイズの明示的な設定

コンテナに対して(pack()または以降のpack()のコールではなく) setSize()をコールすると、コンテナのサイズはピクセル単位で特定のサイズに設定されます。setSize()により、コンテナに対するpack()およびpreferredSizeの効果がオーバーライドされます。

注意: ピクセル・サイズは画面ごとに異なるため、setSize()を使用する場合は、子コンテナが正しくレイアウトされるようにvalidate()をコールする必要があります。pack()が自動的にvalidate()をコールすることに注意してください。

20.5.30 各種プラットフォームに移植可能にするためのUIのサイズ設定

UIを移植可能にするには、pack()を使用するか、アプリケーションがデプロイされる各種画面のピクセル・サイズに基づいてsetSize()で使用する適切なサイズを計算します。

たとえば、UIを画面の幅と高さの75%で表示するとします。UIがこのサイズで表示されるように、pack()をコールするかわりにアプリケーション・クラスに次のコード行を追加できます。

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
frame.setSize(screenSize.width * 3 / 4, screenSize.height * 3 / 4); 

注意: 移植性を保証するために、すべてのXYLayoutコンテナをプロトタイプ作成後に移植可能なレイアウトに変更します。詳細は、第20.6項「レイアウト・プロパティを使用したUIのプロトタイプ作成」を参照してください。

20.5.31 画面上のウィンドウ配置

UIを明示的に配置しなければ、画面の左上隅に表示されます。

UIを画面中央に表示するには、画面の幅と高さを取得し、UIの幅と高さを減算して差を2で除算し(UIの上下と左右に均等の余白を作成するため)、これらの値をUIの左上隅の位置に使用します。

「新規アプリケーション」ダイアログで「フレームを画面の中央に配置」オプションを選択すると、この計算が実行されて例20-1のコードが生成されます。

例20-1 「フレームを画面の中央に配置」オプションを選択したときに生成されるコード

//Center the window
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); 
Dimension frameSize = frame.getSize(); 
if (frameSize.height > screenSize.height) 
  frameSize.height = screenSize.height;
if (frameSize.width > screenSize.width) 
  frameSize.width = screenSize.width; 
frame.setLocation((screenSize.width- frameSize.width) / 2, 
(screenSize.height - frameSize.height) /2); 

20.5.32 コードへのサイズ設定メソッド・コールと配置メソッド・コールの挿入

pack()、validate()、setSize()またはsetLocation()は、UIコンテナ・クラス(this.pack()など)の内側からコールできます。これらのコールは、コンテナを作成するクラス(frame.pack()など)から、コンストラクタの起動後、setVisible()の前に実行することもできます。後者は、「新規アプリケーション」ダイアログで生成されたコードの動作です。pack()またはvalidate()およびsetLocation()は、フレームの作成後(jbInit()のコール後)にApplicationクラスに配置されます。

アプリケーション内の様々な場所からUIを作成し、そのUIのサイズと位置を同じにする場合は、コールをUIコンテナ・クラスのコンストラクタ(jbInit()のコールの後)に挿入します。「新規アプリケーション」ダイアログで生成されたアプリケーションのように、アプリケーションで1箇所からのみUIがインスタンス化される場合は、サイズ設定コードと配置コードをUIの作成場所(この場合はApplicationクラス)に挿入します。

20.5.33 ネストされたコンテナおよびレイアウトの使用

JavaにおけるほとんどのUI設計では、複数タイプのレイアウトを使用し、複数のパネルをメイン・コンテナ内で様々なレイアウトでネストして、必要なコンポーネント配置を取得します。複合設計を作成し、各パネルに適切なレイアウト・マネージャを使用することで、機能と移植性の両面を考慮した上でコンポーネントをグループ化して配置できます。

たとえば、図20-27は様々なレイアウトでネストしたパネルの使用を示しています。グレーに塗りつぶされたオブジェクトはUI内のボタンおよび他の参照可能なコンポーネントで、様々なレベルのパネルにネストされています。

図20-27 ネストしたパネル

20.5.33.1 ネストしたパネルの作成方法

パネルを他のパネル内でネストして、より厳密にコンポーネント配置を制御できます。

ネストしたパネルを作成する手順は、次のとおりです。

1. アプリケーションのUI設計にパネルを追加します。詳細は、第20.7.9項「パネルの作成方法」を参照してください。

2. プロパティ・インスペクタで、Layoutプロパティをnullに変更します。

   UI設計にパネルを追加すると、FlowLayoutが使用されます。設計プロセスでの操作が最も容易なため、最初にレイアウトをnullに変更してください。すべてのパネルや他のコンポーネントをUIに配置した後、最終的なレイアウトに設定します。

   Javaビジュアル・エディタで特定のパネルを探すには、そのパネルを「構造」ウィンドウで選択します。

3. パネルを他のパネル内に配置して、コンポーネントを論理的にグループ化します。

   • コンポーネントがパネルの内側で完全にネストしていることを確認します。「構造」ウィンドウを調べて、各コンポーネントがツリーのアウトライン内で正しいパネルの下にインデント表示されていることを確認します。

   • コンポーネントは正しいサイズと形状になっていません。パネルのレイアウトを変更するとレイアウト・マネージャによりコンポーネントの位置合せが変更されるため、この時点では完全な外観でなくても構いません。

4. 適切なレイアウトにあわせて各パネルのlayoutプロパティを設定します。詳細は、第20.5.23項「レイアウト・プロパティの理解」を参照してください。

   • あるパネルのレイアウト・マネージャを変更すると、そのパネルを保持しているパネルのレイアウト・マネージャを変更したときに、効果が再び変化することに注意してください。

   • 「構造」ウィンドウでレイアウト・オブジェクトを選択して設定を変更します。

20.5.34 カスタム・レイアウト・マネージャの追加

JDeveloperは、Javaビジュアル・エディタと他のレイアウト・マネージャの統合をサポートしています。ユーザーは、次の場合にJavaビジュアル・エディタおよびプロパティ・インスペクタの両方を使用してレイアウト・マネージャを操作できます。

1. LayoutManagerに関連付けるoracle.jdevimpl.uieditor.LayoutAssistant実装を記述する場合。

2. LayoutAssistant実装をIDEに登録する場合。

3. (オプション) java.beans.PropertyEditorをIDEに登録して特殊な制約タイプを処理する場合。

カスタム・レイアウト・マネージャ・アシスタントを作成するには、次のようにします。

各LayoutManagerをLayoutAssistant実装に関連付ける必要があります。oracle.jdevimpl.uieditor.assistant.BasicLayoutAssistantクラスは、インタフェースoracle.jdevimpl.uieditor.LayoutAssistantの最小限の実装を提供し、明示的に登録されていないLayoutManagerに使用されます。インタフェースには複数の必須メソッドがありますが、このトピックの対象範囲を超えているため、ここでは説明しません。統合担当は、この最小限の実装からLayoutAssistant実装をサブクラス化できます。詳細は、LayoutAssistantインタフェースのJavadocを参照してください。

レイアウト・アシスタントを登録するには、次のようにします。

新規のレイアウト・アシスタントを登録するには、JDeveloper¥lib¥addins.xmlファイルのoracle.jdevimpl.uieditor.UIEditorAddinセクションに次のようにキー値の定義を追加する必要があります。

<property>
  <key>PREFIX.LAYOUT_MANAGER_CLASS_NAME</key>
  <value>LAYOUT_ASSISTANT_CLASS_NAME</value> 
</property> 

これらの意味は、次のとおりです。

• PREFIXはjdeveloper.uiassistantです。

• LAYOUT_MANAGER_CLASS_NAMEは、アシスタントを登録するレイアウト・マネージャの完全修飾クラス名です。

• LAYOUT_ASSISTANT_CLASS_NAMEは、登録するレイアウト・マネージャ・アシスタントの完全修飾クラス名です。

たとえば、java.awt.GridBagLayoutレイアウト・マネージャのLayoutAssistant実装oracle.jdevimpl.uieditor.assistant.GridBagLayoutAssistantを登録する場合、追加するプロパティは次のようになります。

<property>
  <key>jdeveloper.uiassistant.java.awt.GridBagLayout</key>
  <value>oracle.jdevimpl.uieditor.assistant.GridBagLayoutAssistant</value>
</property>

レイアウト・アシスタントがプロパティ・インスペクタのlayoutプロパティ・リストに表示されるようにIDEから使用可能にするには、レイアウト・アシスタントをJDeveloper¥bin¥jdev.confファイル内でIDEClasspathにディレクティブとして追加する必要があることに注意してください。次に例を示します。

AddJavaLibFile <myAssistant.jar>

これらの意味は、次のとおりです。

myAssistant.jarは、LayoutAssistant実装のコンパイル済クラス・ファイルが含まれているjarです。

レイアウト・マネージャの制約プロパティ・エディタを登録するには、次のようにします。

カスタム・レイアウト・マネージャで制約クラスを使用する場合は、制約の編集に使用するjava.beans.PropertyEditorの実装クラスを登録できます。プロパティ・エディタ・クラスを、ide.propertiesファイル内でInspector.PropertyEditorの下で登録します。各項目の意味は次のとおりです。

• Inspector.PropertyEditor.count=#では、ide.propertiesに登録するプロパティ・エディタの合計数を指定します。新規に追加するプロパティ・エディタごとにカウントを増やす必要があります。

• <#>は登録済エディタ・リスト内の0ベース索引で、登録するエディタに対応します。

• <fully qualified type>は、PropertyEditorを登録する制約の完全修飾タイプです。

• <Fully qualified class>は、指定した制約タイプのインスタンス編集用に登録するjava.beans.PropertyEditor実装の完全修飾クラス名です。

たとえば、GridBagLayoutレイアウト・マネージャのGridBagConstraints用のプロパティ・エディタを登録する場合、ide.propertiesファイル内のエントリは次のようになります。

Inspector.PropertyEditor.count=1

Inspector.PropertyEditor.editor1.type=java.awt.GridBagConstraints
Inspector.PropertyEditor.editor1.editor=oracle.jdevimpl.uieditor.assistant.GridBagConstraintsEditor 

注意: プロパティ・エディタ・クラスも、レイアウト・マネージャ・アシスタントについて前述したIDEClasspathに追加する必要があります。

20.6 レイアウト・プロパティを使用したUIのプロトタイプ作成

UIの作成を開始する前に、UI設計を書き留めて各種のパネルとコンポーネントの配置とレイアウトの割当てに関する全般的な方針をまとめておくと便利です。UIのプロトタイプはJavaビジュアル・エディタで直接作成することもできます。JDeveloperにはnullというレイアウトが用意されているため、この作業は容易になります。このレイアウトでは、コンポーネントは元の配置場所および作成時のサイズから変化しません。

20.6.1 プロトタイプ作成におけるnullレイアウトの使用

このアプローチを単純化するために、JDeveloperにはnullレイアウトが用意されています。「新規アプリケーション」ダイアログを使用してプロジェクトを開始すると、JDeveloperによりnullを使用するUIコンテナ・クラス(通常はFrameまたはJFrameの拡張クラス)が生成されます。Javaビジュアル・エディタでフレームを開き、フレーム上で設計作業を直接行うことができます。

最初にJavaビジュアル・エディタにいずれかのタイプの新規パネルを追加すると、インスペクタではlayoutプロパティが<default layout>となっていることがわかります。これは、Javaビジュアル・エディタではそのコンテナに自動的にデフォルトのレイアウトが使用されることを意味します。ただし、layoutプロパティは使用するレイアウト・マネージャに変更できます。これにより、プロパティが「構造」ウィンドウで参照可能になり、そのコンポーネントの制約をプロパティ・インスペクタで変更できるようになります。<default layout>のレイアウト・プロパティは編集できません。

20.6.2 大きいリージョンから順番に設計

まずUIのうち大きいリージョンを設計した後、nullを使用して各リージョン内の詳細を操作していきます。設計が適切であれば、内側のリージョンから外側へと系統的に作業を進め、パネルをより移植性の高いレイアウト(FlowLayout、BorderLayoutまたはGridLayoutなど)に変換し、必要に応じて軽微な調整を行います。

ほとんどの場合、まずコンテナを設計に含めた後、そこにコンポーネントを追加します。既存のコンポーネントを囲む新規コンテナを描画することもできます。ただし、この種のコンポーネントが新規パネル内で自動的にネストされることはありません。コンテナを描画した後、各コンポーネントをコンテナ内で移動する必要があります。また、コンテナの外へとコンポーネントを移動してから戻す操作が必要になることもあります。「構造」ウィンドウで、各コンポーネントが正しくネストしていることを確認してください。コンテナ内の各コンポーネントは、ツリーでコンテナの下にインデント表示されている必要があります。

20.6.3 テストの前に保存

JDeveloperで設計する場合、特にレイアウトを変更する際には試行錯誤を繰り返すことになります。レイアウトを変更してテストする前に、作業内容を保存してください。

使用しようとした特定のレイアウトが予想どおり機能しないことが判明する場合があります。設計プロセスを見直し、コンテナ、コンポーネントおよびレイアウトの異なる構成を使用する必要が出てくることもあります。このため、重要なポイントでコンテナ・ファイル(Frame1.javaなど)に別の名前を付けて安全な場所にコピーしておきます。これにより、作業のバックアップが必要になった場合にも、最初からやりなおす必要がなくなります。

20.6.4 最終的なレイアウト・マネージャの選択

nullまたはXYLayoutマネージャを使用してJavaプログラムを設計した場合は、レイアウト・マネージャを様々なプラットフォーム間でサポートされている標準レイアウト・マネージャの1つに変更する必要があります。

レイアウト・マネージャを変更するには、第20.8.3項「コンテナのレイアウトの変更方法」を参照してください。

20.7 コンテナおよびコンポーネントの使用

JDeveloperには、コンテナの生成に役立つ簡単なツールが用意されています。コンテナでは、その他のコンポーネントが保持および管理されます。JDeveloperでフォームをレイアウトしてUIを設計する場合、コンテナを使用します。一般的なコンテナのクラスには次の2つがあります。

• 重量Swingコンテナ。AWTコンテナを拡張したものであるため、重量実装であり、JFrame、JDialogおよびJAppletが含まれます。

• 軽量Swingコンテナ。オペレーティング・システム固有のコードは含まれず、JTabbedPane、JPanel、JSplitPaneおよびJScrollPaneなどが含まれます。

コンテナもコンポーネントです。つまり、プロパティを取得して設定し、メソッドをコールし、その他のコンポーネントと同様にイベントに応答して、コンテナと対話します。

20.7.1 ウィンドウの使用

ウィンドウは、枠線、タイトル・バーまたはメニュー・バーが含まれない、スタンドアロンのトップレベル・コンテナ・コンポーネントです。ウィンドウを使用してポップアップ・ウィンドウを実装できますが、通常は表20-7に示すいずれかのようなウィンドウのサブクラスをUIで使用します。

表20-7 ウィンドウのサブクラス

ウィンドウ	説明
フレーム	枠線およびタイトルが含まれるトップレベル・ウィンドウ。フレームには、コントロール・メニュー、ウィンドウを最小化および最大化するボタン、ウィンドウをサイズ変更するコントロールなどの標準ウィンドウ・コントロールが含まれます。メニュー・バーが含まれる場合もあります。
ダイアログ・ボックス	フレームに類似したポップアップ・ウィンドウですが、親が必要です。ダイアログ・ボックスは、ユーザーから入力データを取得したり、警告メッセージを表示する際に使用されます。メニュー・バーが含まれる場合もあります。ダイアログ・ボックスは通常一時的なものであり、次のいずれかのタイプになります。 モーダル: そのダイアログ・ボックスが閉じられるまで、アプリケーション内の他のウィンドウに対するユーザー入力が不可となります。 モードレス: ユーザーがダイアログ・ボックスおよびアプリケーションの両方に情報を入力できます。

20.7.2 パネルの使用

パネルは、枠線またはキャプションが含まれない単純なUIコンテナであり、ボタン、チェック・ボックスおよびテキスト・フィールドなどの他のコンポーネントをグループ化するために使用されます。パネルは、フレームまたはダイアログなどの他の一部のUI内に埋め込まれています。他のパネル内にネストすることもできます。

表20-8 パネル

Panel	説明
Applet	パネルのサブクラスであり、HTMLページに埋め込んでインターネット・ブラウザまたはアプレット・ビューアで実行するプログラムを構築するために使用されます。アプレットはパネルのサブクラスであるため、コンポーネントを含めることはできますが、枠線やキャプションは持てません。

20.7.3 軽量Swingコンテナの使用

JDeveloperのコンポーネント・パレット・ページから使用できる軽量Swingコンテナには、JMenuBar、JPopupMenu、JSplitPane、JScrollPane、JTabbedPaneおよびJToolbarが含まれます。これらはすべてJComponentのサブクラスです。これらのコンテナに他のコンテナおよびコンポーネントを追加し、コンポーネントとそのコンテナを様々な方法で結合して、必要なインタフェースを作成できます。

表20-9 軽量Swingコンテナ

軽量コンテナ	説明
メニュー・バー	「コンポーネント・パレット」ページから使用できる軽量Swingコンテナには、JMenuBar、JPopupMenu、JSplitPane、JScrollPane、JTabbedPaneおよびJToolbarが含まれます。これらはすべてJComponentのサブクラスです。これらのコンテナに他のコンテナおよびコンポーネントを追加し、コンポーネントとそのコンテナを様々な方法で結合して、必要なインタフェースを作成できます。
ポップアップ・メニュー	一連の選択肢をポップアップ表示する小さなウィンドウであり、メニュー・エディタを使用してJDeveloperで作成します。ユーザーがメニュー・バー上の項目を選択したときに表示されるメニューには、JPopupMenuが使用されます。JPopupMenuは、プルライト・メニューにも使用されます。プルライト・メニューは、これをアクティブにするメニュー項目をユーザーが選択したときに表示されます。最後に、ユーザーが指定エリア内を右クリックしたときなど、メニューの表示が必要な他のあらゆる状況でも、JPopupMenuを使用することができます。
分割ペイン	ユーザーが再配置できるディバイダによって水平または垂直に区切られている2つのペインを管理します。コンポーネントを追加するペインを選択できます。プロパティleftComponentおよびrightComponent、またはtopComponentおよびbottomComponentによってコンポーネントを指定できます。これらのプロパティで、「Left」は「Top」に相当し、「Right」は「Bottom」に相当します。したがって、配置を変更する場合、既存のコードが機能します。同じペインに対する後続の追加によって、ペインの内容が新規オブジェクトで置き換えられます。
スクロール・ペイン	ユーザーが再配置できるディバイダによって水平または垂直に区切られている2つのペインを管理します。コンポーネントを追加するペインを選択できます。プロパティleftComponentおよびrightComponent、またはtopComponentおよびbottomComponentによってコンポーネントを指定できます。これらのプロパティで、「Left」は「Top」に相当し、「Right」は「Bottom」に相当します。したがって、配置を変更する場合、既存のコードが機能します。同じペインに対する後続の追加によって、ペインの内容が新規オブジェクトで置き換えられます。 JScrollPaneには、スクロール・バーおよびビューポートとともに、列ヘッダーおよび行ヘッダーを含めることができます。各ヘッダーは、rowHeaderおよびcolumnHeaderプロパティによって指定するJViewportオブジェクトです。列ヘッダーviewportは自動的に左右にスクロールされ、メイン・ビューポートの左右のスクロールが追跡されます。(ただし垂直にはスクロールされません。)行ヘッダーも同様に機能します。
タブ・ペイン	相互に完全に重なる複数のパネルを管理します。ユーザーは、パネルに添付されたタブ(ファイル・フォルダ上のタブなど)をクリックし、表示するパネルを選択できます。JDeveloperにタブを追加するには、コンポーネント・パレットからタブ・ペインにJPanelをドロップします。tabPlacementプロパティを使用して、コンテナの上下左右にタブを配置できます。
ツールバー	一般的に使用されるアクションまたはコントロールの表示に役立つコンポーネントを提供します。ユーザーによって別のウィンドウにドラッグアウトできます(floatableプロパティがfalseに設定されている場合を除きます)。ドラッグアウトが正しく機能するために、JToolBarインスタンスを、レイアウト・マネージャがBorderLayoutであるコンテナの4つの側面のいずれかに追加することをお薦めします。他の4つの側面のいずれにも子を追加しないでください。

20.7.4 プロパティ・インスペクタでのコンポーネント・プロパティの理解

プロパティは、外観や動作に影響する可能性のあるクラスの名前付き属性です。次のようなプロパティがあります。

• 読取り可能: この種のプロパティにはgetメソッドがあり、プロパティの値を読み取ることができます。ブール・プロパティの場合は、isを使用して値を読み取ることも可能です。

• 書込み可能: この種のプロパティにはsetメソッドがあり、プロパティの値を変更できます。

• 読取り可能と書込み可能の両方: この種のプロパティにはgetメソッドとsetメソッドの両方があります。

20.7.5 プロパティ・インスペクタでのプロパティ値の設定

プロパティは、コンポーネントの外観と実行時のレスポンスを定義する属性です。JDeveloperでは、設計時にコンポーネントの初期プロパティを設定します。このプロパティは、実行時にコードで変更できます。

「プロパティ・インスペクタ」ウィンドウには、選択したコンポーネントのプロパティが表示されます。このウィンドウで設計に含まれるコンポーネントの設計時のプロパティ値を設定します。設計時にプロパティを設定することで、実行時にUIがインスタンス化されるときのコンポーネントの初期状態を定義します。

注意: 実行時に初期プロパティ値を変更するために、メソッドまたはイベント・ハンドラの本体にコードを挿入できます。これは、プロパティ・インスペクタの「イベント」セクションで作成可能です。

20.7.6 複数コンポーネントの共有プロパティの設定

Javaビジュアル・エディタで複数のコンポーネントを選択してプロパティ・インスペクタを開くと、デフォルトでは選択したコンポーネントのすべての共通プロパティが表示されます。

Javaビジュアル・エディタでは複数のコンポーネントを選択できますが、プロパティ・インスペクタに表示されるのは一度に1コンポーネントのプロパティ値のみです。選択したコンポーネント間でプロパティが共有されており、値が同一の場合と異なる場合があると、プロパティ値がコンポーネント間で異なる可能性があります。プロパティ・インスペクタでは、値がイタリックで表示されるため、異なる値を持つ共有プロパティを識別できます。

選択したコンポーネント間で共有プロパティの値が異なっている場合は、アンカー選択項目に属しているプロパティ値が常に表示されます。アンカー選択項目とは、Javaビジュアル・エディタに中空のハンドル付きで表示される選択項目です。アンカー選択項目を変更するには、[Shift]キーを押しながら、現在選択されている他のコンポーネントの1つをクリックします。アンカー選択項目を変更すると、インスペクタに表示されるコンポーネントのプロパティが変わり、Javaビジュアル・エディタのポップアップ・メニュー操作が適用されるコンポーネント(「位置合せ」ポップアップ・メニュー項目など)も変わります。

プロパティ・インスペクタで共有プロパティのいずれかを変更すると、そのプロパティ値は選択したすべてのコンポーネント内で新規の値に変更されます。

20.7.7 ユーザー・インタフェースのレイアウト

この項では、コンポーネントとJDeveloperのUI設計ツールを使用してユーザー・インタフェースを作成する際に実行する基本的なタスクについて説明します。GUI環境でコントロールを使用することに慣れていれば、ここで説明する内容の大部分(コンポーネントの選択、サイズ設定および削除など)は目新しいものではありません。

実際にUIを作成する前に、UIのプロトタイプを作成する必要があります。詳細は、第20.6項「レイアウト・プロパティを使用したUIのプロトタイプ作成」を参照してください。

JDeveloperでユーザー・インタフェースを設計するには、次のようにします。

• コンテナ(フレーム、パネルまたはダイアログなど)を作成します。これらのコンテナでは、特定のタイプのコンポーネントが保持されます。

• コンテナ内のコンポーネントを追加および配置します。コンポーネントをコンテナに追加してから、レイアウト・マネージャを使用して配置できます。詳細は、第20.8.1項「ユーザー・インタフェースへのコンポーネントの追加方法」を参照してください。

• コンポーネント・プロパティを設定します。プロパティ・インスペクタを使用して各コンポーネントのプロパティを設定できます。詳細は、第20.7.4項「プロパティ・インスペクタでのコンポーネント・プロパティの理解」を参照してください。

• コンポーネント・イベントにイベント処理コードをアタッチします。イベントは、ユーザーまたは他のコンポーネントによりトリガーされたときにコンポーネントにより実行されるアクションです。詳細は、第20.10.2項「コンポーネント・イベントへのイベント処理コードのアタッチ方法」を参照してください。

• コンテナのレイアウトとコンポーネントの制約を設定します。レイアウト制約により、レイアウト・マネージャに対してコンポーネントのサイズと位置の設定方法を指示します。詳細は、第20.8.4項「コンポーネントのレイアウト制約の変更方法」を参照してください。

プロジェクトを開始するには、次のようにします。

次の手順は、設計可能なコンテナ・クラスを含むプロジェクトの作成を完了していることを前提としています。まだ完了していない場合は、次の操作を実行する必要があります。

1. JDeveloperプロジェクトを作成または開きます。

2. アプレットまたはアプリケーションを作成します。

20.7.8 フレームの作成方法

フレームは、枠線とタイトルを持つトップレベル・ウィンドウです。フレームには、コントロール・メニュー、ウィンドウの最小化と最大化のボタン、ウィンドウのサイズ変更用のコントロールなどの標準ウィンドウ・コントロールがあります。

「新規のフレーム」ダイアログは、アクティブなプロジェクトに新規クラスを追加します。必要なインポート文が追加され、デフォルト・コンストラクタが作成され、jbInit()メソッドが作成されます。このメソッド内で、JDeveloperによりJavaビジュアル・エディタで使用されるプロパティと他の初期化コードが設定されます。

フレームを追加する手順は、次のとおりです。

1. プロジェクトを開くか、作成します。

2. 「ファイル」→「新規」を選択して、「新規ギャラリ」で「新規のフレーム」ダイアログを探します。

3. 「カテゴリ」リストで「クライアント層」を開き、「Swing/AWT」を選択します。

4. 「項目」リストで「フレーム」を選択し、「OK」をクリックして「新規のフレーム」ダイアログを起動します。

5. 「新規のフレーム」ダイアログで、パッケージ名とクラス名を入力します。

6. 拡張するフレーム・タイプを選択します。

7. フレーム・タイトルを入力します。

8. オプション(「メニュー・バー」など)が存在する場合は、適切と思われるオプションを選択します。

9. 「OK」をクリックして、フレームとそのソース・コードを作成します。

   フレームは、ナビゲータに.javaソース・ファイルとして表示されます。

JDeveloperでフレームを表示するには、次のようにします。

• ナビゲータでファイルを右クリックして「開く」を選択し、「設計」タブをクリックして対話型のUI設計ツール(コンポーネント・パレットやプロパティ・インスペクタなど)を使用します。

• 「ソース」タブをクリックして、ソース・コードを直接編集する作業を開始します。

20.7.9 パネルの作成方法

パネルは、ボタン、チェック・ボックスおよびテキスト・フィールドなどのコンポーネントをグループ化するUIコンテナです。パネルには枠線があり、選択した枠線がTitledBorderの場合はタイトルも使用できます。通常、パネルはダイアログ・ボックスまたはフレームに埋め込まれています。

「新規のパネル」ダイアログでは、選択したパネルを開くためにオープンしているプロジェクトに新規クラスを追加します。これにより、デフォルト・コンストラクタが作成されます。Javaビジュアル・エディタで使用されるプロパティのsetterや他の初期化コードを挿入するjbInit()メソッドも作成されます。

パネルを作成する手順は、次のとおりです。

1. プロジェクトを開くか、作成します。

2. 「ファイル」→「新規」を選択して、「新規ギャラリ」で「新規のパネル」ダイアログを探します。

3. 「カテゴリ」リストで「クライアント層」を開き、「Swing/AWT」を選択します。

4. 「項目」リストで「パネル」を選択し、「OK」をクリックして「新規のパネル」ダイアログを起動します。

5. 「新規のパネル」ダイアログで、パネルのクラス名とパッケージ名を入力します。

6. パネルの導出元となるベース・クラスを選択します。

   JDeveloperとともにインストールされているベース・クラスから任意に選択できます。必要な場合は、「参照」ボタンを使用して、インストール済パッケージにない別のクラスを検索できます。デフォルトでは、選択対象はコアJ2SE (Java2、Standard Edition)とSwingのクラスで提供されるパネル・コンテナに限定されます。

7. 「OK」をクリックしてパネルとソース・コードを作成します。

   パネルは、ナビゲータに.javaソース・ファイルとして表示されます。

JDeveloperでパネルを表示するには、次のようにします。

1. ナビゲータでファイルを右クリックして「開く」を選択し、「設計」タブをクリックして対話型のUI設計ツール(コンポーネント・パレットやプロパティ・インスペクタなど)を使用します。

2. 「ソース」タブをクリックして、ソース・コードを直接編集する作業を開始します。

20.7.10 ダイアログ・ボックスの作成方法

ダイアログ・ボックスとは、枠線とタイトルがあるポップアップ・ウィンドウのことです。通常、ダイアログ・ボックスは、ユーザーからの入力を取得するために使用します。

「新規のダイアログ」ダイアログでは、DialogまたはJDialogを拡張する新規クラスを作成し、現行のプロジェクトに追加します。必要なimport文が追加されます。また、JDeveloperのJavaビジュアル・エディタで使用するプロパティのsetterや他の初期化コードを入れるjbInit()メソッドも作成されます。jbInit()メソッドは、いずれかのコンストラクタの使用時に起動されます。

ダイアログ・ボックスを追加した後、Javaビジュアル・エディタを使用してダイアログを直接設計できます。この方法で、新規ダイアログ・ボックスにボタンや他のコントロールを追加します。

ダイアログ・ボックスを作成する手順は、次のとおりです。

1. プロジェクトを開くか、作成します。

2. 「ファイル」→「新規」を選択して、「新規ギャラリ」で「新規のパネル」ダイアログを探します。

3. 「カテゴリ」リストで「クライアント層」を開き、「Swing/AWT」を選択します。

4. 「項目」リストで「ダイアログ」を選択し、「OK」をクリックして「新規のダイアログ」ダイアログを起動します。

5. 「新規のダイアログ」ダイアログで、ダイアログ・ボックスのパッケージ名とクラス名を入力します。ファイル名は自動的に入力されます。ファイルにはクラスと同じ名前が割り当てられ、パッケージ・ディレクトリに保存されます。

6. java.awt.Dialogとjavax.swing.JDialogのどちらを開くかを選択します。

7. 「OK」をクリックしてダイアログ・ボックスとソース・コードを作成します。

   ダイアログ・ボックスは、「移動」ウィンドウに.javaソース・ファイルとして表示されます。

JDeveloperでダイアログ・ボックスを表示するには、次のようにします。

• ナビゲータでファイルを右クリックして「開く」を選択し、「設計」タブをクリックして対話型のUI設計ツール(コンポーネント・パレットやプロパティ・インスペクタなど)を使用します。

• 「ソース」タブをクリックして、ソース・コードを直接編集する作業を開始します。

20.7.11 Beanでないダイアログ・ボックスの使用方法

ダイアログ・ボックスを作成してUIを設計した後、そのダイアログ・ボックスをプログラム内のなんらかのUIからテストまたは使用する必要があります。

ダイアログ・ボックスをテストまたは使用するには、次のようにします。

1. コード内で、ダイアログ・コンストラクタの親Frameパラメータとして機能するFrameにアクセスできる場所から、ダイアログ・クラスをインスタンス化します。この代表例は、UIの設計対象であり、ダイアログ・ボックスを表示するためのButtonまたはMenuItemを含んだFrameです。アプレットでは、getParent()をコールしてFrameを取得できます。

   モードレスなダイアログ・ボックス(この例ではdialog1)の場合、次のようにパラメータを1つ(親Frame)をとるコンストラクタの形式を使用できます。

   Dialog1 dialog1=new Dialog1(this);

   モーダル・ダイアログ・ボックスの場合は、次の例のように、boolean modalパラメータをtrueに設定しているコンストラクタの形式を使用する必要があります。

   Dialog1 dialog1=new Dialog1(this, true);

   この行をクラスの先頭にインスタンス変数として置く方法(ダイアログ・ボックスはFrameの作成中にインスタンス化され、再利用可能です)、およびダイアログ・ボックスを起動するボタンのactionPerformedイベント・ハンドラ内に置く方法(その場合、ボタンが押されるたびにダイアログ・ボックスの新規インスタンスが初期化されます)があります。どちらの場合も、この行によりダイアログ・ボックスが初期化されますが、まだ参照可能にはなりません。

   (ダイアログがBeanの場合は、frameをコンストラクタに対して指定するのではなく、frameプロパティをshow()のコール前に親frameに設定する必要があります。)

2. インスタンス化されたダイアログ・ボックスを参照可能にする前に、ダイアログ・ボックスのフィールドに表示するデフォルト値を設定する必要があります。ダイアログをBeanにする予定の場合は、これらのダイアログ・ボックスのフィールドをプロパティとしてアクセス可能にしてください。そのためには、ダイアログ・クラスでgetterメソッドとsetterメソッドを定義します。

3. 次に、イベント・ハンドラに次のようなコード行を入力して、actionPerformedイベント中にダイアログ・ボックスを参照可能にする必要があります。

   dialog1.show();

4. ユーザーが「OK」ボタン(またはモードレス・ダイアログ・ボックスの場合は「適用」ボタン)をクリックしたときに、このダイアログ・ボックスを使用中のコードでダイアログのプロパティのgetterをコールして、ユーザーが入力した情報をダイアログから読み取り、その情報を使用してなんらかの操作を実行する必要があります。

   • モーダル・ダイアログ・ボックスの場合、この操作はshow()メソッド・コールの直後に実行できます。これは、show()はモーダル・ダイアログ・ボックスが消えるまで値を戻さないためです。resultプロパティを使用すると、「OK」ボタンが押されたのか「取消」ボタンが押されたのかを判別できます。

   • モードレス・ダイアログ・ボックスの場合、show()は即時に値を戻します。このため、ボタンを押す各操作のイベントをダイアログ・クラス自体で公開する必要があります。ダイアログ・ボックスを使用する場合は、リスナーをダイアログのイベントに登録し、コードをイベント処理メソッドに挿入し、プロパティのgetterを使用してダイアログ・ボックスから情報を取得します。

20.7.12 タブ付きペインの作成方法

タブ付きペインは、複数のパネルのコンポーネント(ボタン、チェック・ボックスおよびテキスト・フィールドなど)をグループ化するUIコンテナです。各パネルにはタイトルとタブがあり、エンド・ユーザーはタブをクリックしてパネルのコンテンツを表示します。

タブ付きペインを作成する手順は、次のとおりです。

1. フレームまたは他のコンテナを作成します。詳細は、第20.7.8項「フレームの作成方法」を参照してください。

2. コンポーネント・パレットのSwingコンテナ・ページで、「JTabbedPane」コンポーネントをクリックします。

3. Javaビジュアル・エディタでコンテナ内をクリックし、タブ付きペインをデフォルトのサイズでドロップします。

4. 必要に応じてタブ付きペインをサイズ変更します。

5. タブ付きペインに最初のタブを追加するには、コンポーネント・パレットのSwingコンテナ・ページで「JPanel」コンポーネントをクリックし、Javaビジュアル・エディタで「JTabbedPane」をクリックします。

6. タブ付きペインに2番目以降のタブを追加するには、コンポーネント・パレットで「JPanel」コンポーネントをクリックした後、前に追加したタブ・パネルのタブ自体をクリックする必要があります。

7. タブ付きペインのいずれかのタブにレイアウト・パネル(タブのないパネル)を追加するには、コンポーネント・パレットのSwingコンテナ・ページで「JPanel」コンポーネントをクリックし、Javaビジュアル・エディタで「JTabbedPane」のコンテンツ領域をクリックします(この場合は、タブ自体をクリックしないでください)。

   現在Javaビジュアル・エディタで最前面のタブになっていないパネルを操作するには、そのタブを直接クリックします。タブを選択すると、そのパネルもスタック順の最前面に移動します。また、タブ・パネルを選択するには、「構造」ウィンドウで目的のパネルを選択する方法もあります。タブ付きペインに追加したパネルを表示するには、「UI」フォルダを開き、「dataPanel」ノードを開き、最後に「JTabbedPane」ノードを開いてJPanelのリストを表示します。

20.8 コンテナ内のコンポーネントの使用

JDeveloperツールを使用してコンテナ・コンポーネントを作成および管理できます。

20.8.1 ユーザー・インタフェースへのコンポーネントの追加方法

作成したUIコンテナにJDeveloperのコンポーネント・パレットからコンポーネントを挿入する方法は複数あります。

• マウスを使用してコンポーネントを選択、挿入および配置します。

• キーボード・バインディングを使用してコンポーネントを選択し、挿入します。

Javaビジュアル・エディタでコンポーネントを視覚的に追加すると、JDeveloperによりコンポーネントのインスタンス変数が生成されてソース・コードに追加されます。コンポーネントを削除すると、関連する行がJavaビジュアル・エディタによりコードから削除されます。

マウスを使用してUIにコンポーネントを追加する手順は、次のとおりです。

1. コンテナ・コンポーネントを作成します。

2. 「コンポーネント・パレット」ドロップダウン・メニューから必要なコンポーネント・リストを選択します。

3. パレット内で必要なコンポーネントをクリックします。

4. 選択したコンポーネントをコンテナに挿入するには、次の操作のいずれかを実行します。

   • コンテナ内をクリックしてコンポーネントをデフォルト・サイズで挿入します。

   • Javaビジュアル・エディタでマウスをドラッグし、1回目にクリックした位置から作成するオブジェクトに必要なサイズを表す最終位置までをバインドするボックスを描画します。特定のサイズまでドラッグする操作が該当するのは、コンテナのレイアウトで個別コンポーネントのサイズが考慮される場合のみです。最終的には、コンポーネントのサイズおよび位置はUI内の各コンテナのレイアウト・マネージャにより決定されます。

   • コンポーネントを「構造」ウィンドウ内で必要なコンテナにドロップします。この方法では、コンテナ内のコンポーネントの表示位置を制御できないことに注意してください。

キーストロークのみを使用してコンテナにコンポーネントを追加する手順は、次のとおりです。

1. コンテナ・コンポーネントを作成します。詳細は、第20.8項「コンテナ内のコンポーネントの使用」を参照してください。

2. 「コンポーネント・パレット」ドロップダウン・メニューから必要なコンポーネント・リストを選択します。

3. パレットからコンポーネントを選択するには、[Tab]キーを押して必要なコンポーネントにフォーカスを設定し、[spacebar]を押して選択します。

4. 選択したコンポーネントをコンテナに挿入するには、[Enter]キーを押します。

   挿入したコンポーネントは、UIコンテナの左上隅に表示されます。プロパティ・インスペクタを使用すると、挿入したコンポーネントのサイズおよび位置を設定できます。

コンポーネントの複数インスタンスを追加する手順は、次のとおりです。

コンポーネント・パレットで、[Shift]キーを押しながらコンポーネントをクリックします。[Shift]キーを放しても、パレットは複数作成モードのままになっています。

複数オブジェクト作成モードをオフにするには、コンポーネント・パレットで矢印ツールをクリックします。

20.8.2 設計時のコンポーネント・プロパティの設定方法

「プロパティ・インスペクタ」ウィンドウには、Javaビジュアル・エディタで選択したコンポーネントのプロパティが表示されます。「プロパティ・インスペクタ」ウィンドウを使用して、設計時にUI設計内の任意のコンポーネントのプロパティ値を設定します。

コンポーネントのプロパティを設計時に設定するには、次のようにします。

1. Javaビジュアル・エディタまたは「構造」ウィンドウでコンポーネントを選択します。

2. 選択したコンポーネントの値を含むプロパティ・インスペクタを表示するには、「表示」→「プロパティ・インスペクタ」を選択するか、Javaビジュアル・エディタでコンポーネントを右クリックして「プロパティ・インスペクタ」を選択します。「プロパティ・インスペクタ」ウィンドウが強調表示されます。

3. 選択したコンポーネントの値を含むプロパティ・インスペクタを表示するには、「プロパティ・インスペクタの表示」を選択するか、Javaビジュアル・エディタでコンポーネントを右クリックして「プロパティ・インスペクタ」を選択します。「プロパティ・インスペクタ」ウィンドウが強調表示されます。または

   プロパティ・インスペクタのツールバーで、「検索」テキスト・フィールドにプロパティ名を入力し、[Enter]キーを押してインスペクタにプロパティを表示します。名前の一部を入力したか、複数のプロパティが同じ名前で存在する場合、上矢印または下矢印ボタンを使用して、入力した名前と一致するプロパティにジャンプできます。

4. 次のいずれかの方法で右側の列に値を入力します。

   • テキスト・フィールドのみが表示されている場合は、単にそのプロパティの文字列値(テキスト値または数値など)を入力して[Enter]キーを押します。

   • 値フィールドに下向き矢印が表示されている場合は、矢印をクリックし、リストから値を選択して[Enter]キーを押します。

   • 値フィールドに省略記号(...)ボタンが表示されている場合は、このアイコンをクリックして、そのプロパティのプロパティ・エディタ(カラー・セレクタやフォント・セレクタなど)を表示します。プロパティ・エディタで値を設定し、「OK」をクリックします。

複数コンポーネントのプロパティを設定するには、次のようにします。

1. [Ctrl]キーまたは[Shift]キーを押しながら目的のコンポーネントを選択します。

2. プロパティ・インスペクタに、選択したコンポーネントによって共有されているプロパティが表示されます。プロパティ・インスペクタで、必要なプロパティを選択して編集します。共有プロパティの値を編集すると、選択した全コンポーネントの値が同じになります。値がイタリックで表示される場合、アンカー・コンポーネントの値に属している値が、選択した他のコンポーネントと異なることを意味します。

注意: [Ctrl]キーを使用すると、選択したオブジェクトの選択状態が(非選択から選択済へ、または選択済から非選択へ)切り替わります。[Shift]キーを使用して選択すると、オブジェクトのアンカー使用も次のように変化します。 オブジェクトが選択されていない場合は、選択状態になり、アンカーになります。 オブジェクトが選択されている場合は、単にアンカーになります。

[Ctrl]キーまたは[Shift]キーを使用する場合、コントロールが選択されていない状態から選択状態になると、ユーザーが[Shift]選択アクションを使用してアンカーを変更するまで、新規アンカーになっています。

20.8.3 コンテナのレイアウトの変更方法

JDeveloperのインスペクタにはlayoutプロパティが用意されており、Javaビジュアル・エディタでコンテナの新規レイアウトを選択できます。

新規レイアウトを選択する手順は、次のとおりです。

1. 「構造」ウィンドウでコンテナを選択します。

2. インスペクタの「プロパティ」タブをクリックし、layoutプロパティを選択して値フィールドをクリックします。

3. layoutプロパティの値フィールドで下矢印をクリックし、ドロップダウン・リストからレイアウトを選択します。

JDeveloperにより次の操作が実行されます。

• 「構造」ウィンドウ内で新規レイアウト・マネージャが置換されます。

• ソース・コードが変更され、新規レイアウト・マネージャが追加され、setLayoutへのコンテナのコールが更新されます。

• Javaビジュアル・エディタでコンポーネントのレイアウトが変更されます。

• インスペクタおよびソース・コード内でコンテナのコンポーネントのレイアウト制約が更新されます。

20.8.4 コンポーネントのレイアウト制約の変更方法

コンポーネントをコンテナにドロップすると、JDeveloperにより、そのコンテナのレイアウト・マネージャに適した制約オブジェクトまたは値が作成されます。この制約値またはオブジェクトは、プロパティ・インスペクタでそのコンポーネントのconstraintプロパティに自動的に挿入されます。また、ソース・コードにもjbInit()メソッド内のadd()メソッド・コールのパラメータとして追加されます。

コンポーネントのレイアウト制約を編集する手順は、次のとおりです。

1. Javaビジュアル・エディタまたは「構造」ウィンドウでコンポーネントを選択します。

2. プロパティ・インスペクタでconstraintsプロパティを選択し、「値」フィールドをクリックします。

   nullレイアウト・マネージャを使用する場合に、子にconstraintsプロパティがなければ、かわりにboundsプロパティにレイアウト制約を設定します。

3. プロパティ・エディタを使用して制約を変更します。または

   Javaビジュアル・エディタで必要なツールバーの制約ボタンをクリックし、使用可能な場合はドロップダウン・リストから値を選択します。

20.8.5 ユーザー・インタフェースでのコンポーネントの選択方法

UIの既存のコンポーネントを選択する前に、コンポーネント・パレットの選択矢印が選択されていないことを確認してください。この矢印が選択されていると、コンポーネントを意図せずにUIに配置してしまうことがあります。

単一コンポーネントを選択するには、次のいずれかの操作を実行します。

• Javaビジュアル・エディタでコンポーネントをクリックします。

• Javaビジュアル・エディタにフォーカスを置き、[Tab]を使用してコンポーネントに移動します([Tab]を押すと正方向へ移動し、[Shift]を押しながら[Tab]を押すと逆方向へ移動します)。

• 「構造」ウィンドウでコンポーネントを選択します。

複数のコンポーネントを選択するには、[Ctrl]キーを押しながら次のいずれかの操作を実行します。

• Javaビジュアル・エディタでコンポーネントを一度に1つずつクリックします。

• 選択するコンポーネントの範囲の外側をクリックしてドラッグします。

注意: 複数選択の場合、[Shift]キーを使用すると選択したオブジェクトのうち選択アンカーとなっているオブジェクトが変わるため、[Ctrl]キーを使用することをお薦めします。選択アンカーは、プロパティ・インスペクタにプロパティ値が表示されるオブジェクトであり、ポップアップ・メニュー・アクション(位置合せなど)もこのオブジェクトに適用されます。 ドラッグして複数コンポーネントを(投げ縄で囲むように)方形で囲みます。選択するコンポーネントがすべてこの方形で囲まれた時点で、マウス・ボタンを放します。必要な場合は、[Ctrl]キーを押しながらクリックして、選択したグループのコンポーネントを個別に追加または削除できます。 「構造」ウィンドウで、[Ctrl]キーを押しながら各コンポーネントを選択します。

20.8.6 コンポーネントのサイズ設定および移動方法

多くのレイアウトの場合、コンポーネントのサイズはレイアウト・マネージャにより制約に従って決定され、Javaビジュアル・エディタでのサイズ設定は無効です。ただし、null、XYLayoutまたはGridBagLayoutを使用している場合は、最初にUIに配置するときにコンポーネントのサイズを設定したり、後でコンポーネントをサイズ変更して移動できます。

注意: 現在、GridBagLayoutでは作成時のサイズが無視されますが、作成後にコンポーネントをサイズ変更できます。

コンポーネントを追加時にサイズ設定する手順は、次のとおりです。

1. コンポーネント・パレットでコンポーネントを選択します。

2. UIにおけるコンポーネントの表示位置にカーソルを置きます。

3. マウス・ポインタをドラッグしてからマウス・ボタンを放します。ドラッグするにつれて、コントロールのサイズと位置を示すアウトラインが表示されます。

4. アウトラインが目的のサイズになった時点でマウス・ボタンを放します。

コンポーネントを一度に1ピクセルずつ移動する手順は、次のとおりです。

1. 「グリッドに合せる」機能がオフになっていることを確認します(「ツール」→「プリファレンス」、「Javaビジュアル・エディタ」を表示)。

2. コンポーネント・パレットでコンポーネントを選択します。

3. [Ctrl]キーを押しながら[Shift]キーを押し、矢印キーを使用してオブジェクトを一度に1ピクセルずつ移動します。

選択したコンポーネントをサイズ変更または移動する手順は、次のとおりです。

1. Javaビジュアル・エディタまたは「構造」ウィンドウで、コンポーネントをクリックして選択します。

   コンポーネントを選択すると、コンポーネントの外枠にサイズ変更ハンドルまたはニブが表示されます。コンテナによっては、コンポーネント中央に移動ハンドルが表示されます。

2. 該当する外側のハンドルをクリックし、ドラッグしてサイズを変更します。

3. コンポーネント内をクリックし、必要な方向へドラッグして移動します。コンポーネントが他のコンポーネントの背面にあるコンテナの場合は、中央の移動ハンドルを使用してドラッグします。

選択したコンポーネントのグループをサイズ変更または移動する手順は、次のとおりです。

1. 変更するコンポーネントのグループを次のいずれかの方法で選択します。

   • [Ctrl]キーを押しながら各コンポーネントを選択します。

   • マウスの左ボタンを押しながら、変更するコンポーネントのグループを囲む方形を描きます。

   コンポーネントを選択すると、コンポーネントの外枠にサイズ変更ハンドルまたはニブが表示されます。コンテナによっては、コンポーネント中央に移動ハンドルが表示されます。

2. 該当する外側のハンドルをクリックし、ドラッグしてサイズを変更します。

3. コンポーネント内をクリックし、必要な方向へドラッグして移動します。コンポーネントが他のコンポーネントの背面にあるコンテナの場合は、中央の移動ハンドルを使用してドラッグします。

4. 右クリックして「サイズおよび領域」を選択し、必要な操作を選択します。

   または

   Javaビジュアル・エディタのツールバーで目的のサイズ・ボタンをクリックします。現在選択しているコンポーネントに無効な操作は、ツールバーとポップアップ・メニューに無効状態で表示されます。

20.8.7 コンポーネントのグループ化方法

JDeveloperには、設計時に単一コンポーネントとして動作するように、コンポーネントをグループ化するためのコンテナ・コンポーネントが多数用意されています。

たとえば、1行のボタンをPanelにグループ化してツールバーを作成できます。また、コンテナ・コンポーネントを使用して、カスタマイズした背景、ステータス・バーまたはチェック・ボックスのグループを作成できます。

コンポーネントをコンテナ内に置くときに、コンテナと中のコンポーネントの関連を作成します。移動、コピーまたは削除など、コンテナに対して実行する設計時操作は、中でグループ化されているコンポーネントにも影響します。

コンポーネントをコンテナ内に置いてグループ化する手順は、次のとおりです。

1. コンテナをUIに追加します。

   GridBagLayout、nullレイアウトまたはXYLayoutなど、サイズを考慮するレイアウトで作業している場合は、ドラッグしてサイズを設定できます。

2. 各コンポーネントをコンテナに追加し、マウス・ポインタがコンテナの境界内にあることを確認します。(JDeveloper下部のステータス・バーに、マウスが置かれているコンテナが表示されます。)コンポーネント・パレットから新規コンポーネントを追加するか、既存のコンポーネントを新規コンテナにドラッグできます。

   コンポーネントを追加すると、Javaビジュアル・エディタでは選択したコンテナの中に表示され、「構造」ウィンドウではそのコンテナの下に表示されます。

ヒント: コンポーネントを最初に置いた位置に残しておく場合は、コンテナのレイアウトをnullに変更してからコンポーネントを追加します。先にレイアウトを変更しないと、コンポーネントのサイズと位置は、コンテナで使用されているレイアウト・マネージャに従って変化します。コンポーネントの追加を終了した後、最終的なレイアウトに変更できます。

20.8.8 コンポーネントのZ順序の変更方法

JDeveloperでは、UI設計に視覚的に相互に重なっているコンポーネントの順序を変更できます。Z順序で指定されている最前面のコンポーネントが、デフォルトで実行時に表示されます。

注意: Javaビジュアル・エディタに表示されるのはスタックの最前面のコンポーネントのみですが、スタックのZ順序は「構造」ウィンドウで確認できます。最前面のコンポーネントがノード・リストの先頭に表示され、その後にスタックの次のコンポーネントが続きます。Z順序を変更すると、「構造」ウィンドウが更新されて新しい順序が表示されます。

最前面のコンポーネントのZ順序を変更する手順は、次のとおりです。

1. Javaビジュアル・エディタで、スタックの最前面にあるコンポーネントを選択します。

2. 右クリックし、「順序」→「最背面へ移動」を選択します。

視覚的に最前面にないコンポーネントのZ順序を変更する手順は、次のとおりです。

1. 「構造」ウィンドウで、順序を変更するスタック・コンポーネントを選択します。

2. Javaビジュアル・エディタで、右クリックして「順序」を選択し、「最前面へ移動」または「最背面へ移動」を選択します。

20.8.9 コンポーネントの切取り、コピー、貼付けおよび削除方法

JDeveloperでは、Javaビジュアル・エディタで「切取り」、「コピー」、「貼付け」および「削除」機能を使用できます。これらの操作を、同じプロジェクトまたは異なるプロジェクトのファイル間で実行できます。

注意: あるファイルと別のプロジェクトのファイル間で切取り、コピーおよび貼付けを行うには、ターゲット・プロジェクトのプロジェクト・プロパティを更新して追加ライブラリを組み込む操作が必要になることがあります。貼り付けるオブジェクト用の適切なライブラリがターゲット・プロジェクトで定義されていないと、Javaビジュアル・エディタでそのオブジェクトのクラスが認識されないため、貼付けに失敗します。

20.8.10 コンポーネントのコピー方法

Javaビジュアル・エディタでコピーしたビジュアル・コンポーネントはシステムのクリップボードにはコピーされず、他のアプリケーションには転送できません。スクリーン・キャプチャ・ユーティリティを使用してコントロールのイメージを作成するか、ソース・テキストをコピーして別のJava開発環境でJavaコードを使用します。

イベント・メソッドが定義されているコンポーネントをコピーすると、イベント・ハンドラではなくイベント・リスナーがコンポーネントとともにコピーされます。これは、ほとんどの場合、コピー対象が動作ではなくコントロールのフォーマットであるためです。コントロールと動作を異なるJavaクラス・ファイルにコピーすることが目的の場合は、ハンドラを個別にコピーする必要があります。そのためには、コード・エディタでファイルを開き、ハンドラ・コードを探して選択し、「編集」→「コピー」を選択します。

1つ以上のコンポーネントをコピーするには、次のようにします。

1. コピーするコンポーネントを選択します。詳細は、第20.8.5項「ユーザー・インタフェースでのコンポーネントの選択方法」を参照してください。

2. 「編集」→「コピー」を選択します。

コンポーネントがJDeveloperのローカル・クリップボードにコピーされます。

20.8.11 コンポーネントの切取り方法

コンポーネントを切り取る前に、前に切り取ったオブジェクトを必ず貼り付けてください。これは、イベント・コードを切り取るとクリップボードの内容が上書きされるためです。

ユーザー・インタフェースからコンポーネントを切り取るには、次のようにします。

1. 切り取るコンポーネントを選択します。

2. 「編集」→「切取り」を選択します。

コンポーネントがJavaビジュアル・エディタから削除され、(システム・クリップボードではなく)JDeveloperからのみアクセス可能なローカル・クリップボードに置かれます。コントロールをコンテナに貼り付けずにJDeveloperを終了した場合、切り取ったバージョンのコントロールは失われます。

切取りコマンドは、切取り/貼付け操作の最初のステップです。コンポーネントの削除のみをする場合は、後述の「コンポーネントの削除」を参照してください。コンポーネントの削除では、クリップボードの内容を変更せずにコンポーネントが削除されます。切取りコマンドを使用してアイテムを永久に削除する習慣がある場合、間違ってクリップボードの保存しておきたい内容を置換してしまう可能性があります。

イベント・メソッドが定義されているコンポーネントを切り取ると、コンポーネントとともにイベント・リスナーが切り取られます。イベント・ハンドラはソース・コードから削除されず、クリップボードに置かれることもありません。これには、次の2つの理由があります。

• ほとんどの場合、切り取るのはコントロールの動作ではなく、保持しておく必要のあるフォーマットです。

• 複数のコンポーネントで同じイベント・ハンドラが使用されていることがあるため、コードから削除するとプログラムの他の部分に影響する可能性があります。

コード・エディタでイベント・ハンドラを切り取るには、ハンドラ・コードを探して選択し、「編集」→「切取り」を選択します。

20.8.12 コンポーネントの貼付け方法

JDeveloperの「設計」ウィンドウからコピーするか切り取ったコンポーネントを、設計可能な他のクラス・ファイルに貼り付けることができます。

コンポーネントを貼り付けるには、次のようにします。

1. Javaビジュアル・エディタで、コンポーネントを貼り付けるファイルを開きます。

2. コンポーネントを貼り付けるコンテナを選択します。

3. 「編集」→「貼付け」を選択します。

貼り付けたJavaBeansコンポーネントにより、元のコンポーネントからソース・コードに既存のイベント・リスナー・コードが追加されます。イベント・ハンドラ・コードがコンポーネントとともにコピーされたり切り取られることはありません。同じイベント・ハンドラを使用するには、コード・エディタを使用してハンドラを個別にコピーして貼り付ける必要があります。

20.8.13 UIからのコンポーネントの削除方法

クリップボードの内容に影響を与えずにJavaプログラムからコンポーネントを削除する場合は、そのコンポーネントを削除します。

コンポーネントを削除するには、次のようにします。

1. Javaビジュアル・エディタまたは「構造」ウィンドウでコンポーネントを選択します。

2. [Del]キーを押します。

Javaビジュアル・エディタからJavaBeansコンポーネントを削除すると、イベント・リスナー・メソッド(存在する場合)がソース・コードから削除されますが、イベント・ハンドラ・メソッドは削除されません。イベント・ハンドラ・メソッドを削除する場合は、コード・エディタで削除する必要があります。

20.9 メニューの使用

次の用語は、メニューの基本的な各部を指しています。

• メニュー・バーは、フレームの最上部に表示されます。「ファイル」、「編集」または「ヘルプ」など、1つ以上のトップレベル・メニューで構成されます。JMenuBarは、コンポーネント(JComboBoxまたはJToggleButtonなど)を子として持つことができます。

• メニューはメニュー・バーの子で、メニュー項目、サブメニューおよびセパレータの集合を含みます。

• サブメニューは、メニュー・バーではなく別のメニューを親に持つメニューです。

• メニュー項目は、コマンドを起動できるメニュー上の個別要素です。メニュー項目には、属性(許可されない場合は無効化(グレー表示)する、選択状態を切り替えることができるようにチェック可能にするなど)を割り当てることができます。

• アクセラレータはキーボード・ショートカットと呼ぶこともあり、メニュー項目の代替起動方法を提供します。メニュー項目にアクセラレータがある場合は、メニュー項目の右側に表示されます。

• セパレータ・バーを使用すると、関連項目を視覚的にグループ化できます。コマンドを起動することはありません。

20.9.1 メニュー・コンポーネントの理解

コンポーネント・パレットには、MenuBar、JMenuBar、PopupMenuおよびJPopupMenuという4タイプのメニュー・コンポーネントがあります。

• MenuBarまたはJMenuBarはメインUIのFrameにアタッチされ、フレームの上部に表示されます。

• PopupMenuまたはJPopupMenuは、ユーザーがUIで右クリックすると表示されます。実行時にはポップアップ・メニューはメニュー・バーに表示されず、ユーザーが起動した場合に表示されます。

この4つのコントロールは、すべてプロパティ・インスペクタで編集可能です。

UIコンテナに最初にドロップしたMenuBarまたはJMenuBarコントロールは、UIの現在のメニュー・バーとみなされます。ただし、アプリケーション用に複数のメニュー・バーを作成できます。作成したメニュー・バーは、インスペクタでフレームのMenuBarプロパティに表示されます。MenuBarプロパティのドロップダウン・リストからメニューを選択すると、そのメニューがアクティブになります。

注意: メニュー・コンポーネントは、設計時にメニュー・エディタでのみ編集可能であり、Javaビジュアル・エディタでは編集できません。メニュー・バーおよびトップレベル・メニューはJavaビジュアル・エディタに表示されますが、選択も編集もできません。ただし、「構造」ウィンドウではいつでも表示および選択できます。UIでのメニューの外観を確認するには、アプリケーションを実行します。

20.9.2 メニュー・エディタの使用

メニュー・エディタにアクセスするには、Javaビジュアル・エディタでJavaファイルを開きます。これにより、「構造」ウィンドウが参照可能になります。次に、「構造」ウィンドウでメニュー、メニュー項目またはメニュー・ルート・ノードをクリックすると、メニュー・エディタが表示されます。

メニュー・エディタでメニューを作成するには、次のように複数の方法があります。

• キーボードの矢印キー、[Esc]キーおよび[Enter]キーを使用して、編集可能なメニュー・コンポーネントのフォーカスを変更できます。

• ドラッグ・アンド・ドロップ操作により、メニューまたはメニュー項目を移動できます。

• メニュー・エディタのツールバーまたはメニュー項目のポップアップ・メニューを使用して、メニュー・コンポーネントを挿入できます。

たとえば、メニュー・エディタで現在フォーカスが設定されているメニュー・コンポーネント(ハイライトされているボックスとして表示)に、ラベルを直接入力できます。[Enter]を押すとラベルが検証され、次のメニュー・コンポーネントのラベルを入力できます。また、キーボードの矢印キーを使用すると、メニュー・エディタ内の現在のフォーカスを、編集対象のメニュー内の別の位置に移動できます。[Esc]キーを押すと、メニュー内の他の場所にあるフォーカスがメニュー・バーに切り替わります。

指定したラベルのみでなく、様々なメニュー・コンポーネントも挿入できます。その場合、メニュー・エディタのツールバーを使用する方法、またはメニュー・コンポーネントを右クリックして複製されるコマンドを使用する方法があります。ツールバーおよびポップアップ・メニューでは、次の操作がサポートされています。

• メニュー項目の挿入

• セパレータの挿入

• サブメニューの挿入

• メニュー項目の有効化またはメニュー項目の無効化

• メニュー項目のチェック可能化

また、メニュー・バー内のメニューまたはメニュー内のメニュー項目をクリックし、ドラッグ・アンド・ドロップ操作を使用して、メニュー全体またはメニュー項目の1つを再配置することもできます。

20.9.3 コード・エディタとプロパティ・インスペクタの相互作用

JDeveloperでは、作業中に行った変更内容が同期化されます。メニュー・エディタでメニュー項目を編集すると、すべての変更内容がコード・エディタまたはプロパティ・インスペクタによりソース・コードに反映されます。ソース・コード内またはプロパティ・インスペクタでメニューを変更すると、変更内容はメニュー・エディタに反映されます。

たとえば、MenuBarコンポーネントにMenuを追加すると、このMenuが「構造」ウィンドウにMenuBarの子として表示されます。また、MenuまたはMenuItemのプロパティ(textやenabledなど)を変更すると、これらの変更はコード、メニュー・エディタおよびプロパティ・インスペクタに反映されます。

JDeveloperではコード・エディタとの同期も維持されるため、メニュー設計を手動で保存する必要はありません。JDeveloperによりコードが生成され、メニュー・エディタを使用する場合と同様にコード・エディタで表示して編集できます。Javaソース・ファイルを保存すると、生成されたコードも保存されます。次回にJavaファイルを開いて「構造」ウィンドウでMenuBarコンポーネントを選択すると、メニュー・エディタが開き、そのコンポーネントのすべての情報がリロードされます。

UI設計にメニュー・コンポーネントを追加した後、メニュー・エディタを使用してメニュー構造を設計できます。ユーザー・インタフェースでメニューをアクティブ化するには、プロパティ・インスペクタを使用してメニュー項目をイベントにアタッチするか、コード・エディタでコードを手動で入力する必要があります。

20.9.4 フレームへのメニュー・コンポーネントの追加方法

非ポップアップ・メニューのアタッチ先はJFrameまたはJDialogなどのコンテナのみであるため、最初にコンテナ・ファイルを開く必要があります。次のいずれかの方法でファイルを開くことができます。

• 既存のFrameまたはDialogファイルを開きます。

• 「新規ギャラリ」を使用して、新規フレームを作成するか、ダイアログを作成します。詳細は、第20.7.8項「フレームの作成方法」を参照してください。

UIにメニュー・コンポーネントを追加する手順は、次のとおりです。

1. ナビゲータでUIフレーム・ファイルを右クリックして「開く」を選択します。

2. Javaビジュアル・エディタまたは「構造」ウィンドウでメインUIフレームを選択します。

3. 「コンポーネント・パレット」でメニュー・コンポーネントをクリックし、Javaビジュアル・エディタの任意の場所にドロップします。

   メニュー・バーまたはポップアップ・メニューを選択できます。

   • メニュー・バーはメインUIフレームまたはダイアログにアタッチされており、アプリケーションの最上部に表示されます。

   • ポップアップ・メニューは、ユーザーがUIで右クリックしたときに表示されます。ポップアップ・メニューにはメニュー・バーがありません。

   また、すでにメニュー・コンポーネントを含んでいるファイルを開くこともできます。

   この時点で、UIには何も表示されません。追加したメニュー・コンポーネントは「構造」ウィンドウに表示され、メニュー・エディタで開きます。

20.9.5 ポップアップ・メニューの追加方法

ポップアップ・メニューは、特定のUIコンテナ上で開くように作成できます。コンテナにポップアップ・メニューを追加し、イベント・ハンドラを作成して、ポップアップをトリガーするユーザー操作を指定します。

ポップアップ・メニューを追加する手順は、次のとおりです。

1. Javaビジュアル・エディタでUIクラスを開きます。

2. AWTまたはSwingコンテナのコンポーネント・パレットから、ポップアップ・メニューを「構造」ウィンドウにドロップします。メニュー・エディタが表示されます。

3. ポップアップ・メニューにメニュー項目を1つ以上追加します。詳細は、第20.9.8項「メニュー項目の追加方法」を参照してください。

4. 「構造」ウィンドウで「UI」フォルダを開き、ポップアップ・メニューの添付先となるイベントがあるパネルまたは他のコンポーネントを選択します。これにより、そのコンポーネントをプロパティ・インスペクタで参照できるようになります。次の例では、panel1が選択されています。

5. プロパティ・インスペクタで「イベント」タブをクリックし、必要なイベントの「値」フィールドをクリックします。

6. イベントの「値」フィールドにイベントのスタブ名を入力し、[Enter]キーを押して、イベント処理メソッド・スタブを指定の名前でソース・コードに作成します。次の例では、MouseClickedイベントが選択され、panel1_mouseClickedという名前が入力されています。

7. イベント・ハンドラ・スタブを次のように編集します。

   例20-2 イベント・ハンドラ・スタブ

   void panel1_mouseClicked(java.awt.event.MouseEvent e) { 
     panel1.add(popupMenu1); 
      if (e.isPopupTrigger()) {   
       // Make the PopupMenu visible relative to the current mouse  
       // position in the container.  
      opupMenu1.show(panel1, e.getX(), e.getY());
      }
   }
   

8. アプリケーションでの必要性に応じて、ポップアップ・メニューのメニュー項目にイベント・ハンドラを追加します。

20.9.6 サブメニューの作成方法

サブメニューをメニューに表示して、追加の関連コマンドを提供できます。このようにネストしたリストは、メニュー・テキストと後続の矢印で示されます。JDeveloperでは、メニューに組み込む必要のあるレベル数のサブメニューがサポートされています。

サブメニューを使用してメニュー構造を編成すると、垂直方向の画面領域を節約できます。ただし、最適な設計にするには、UI設計に使用するメニュー・レベルを2または3レベルに抑えることになります。

メニューをメニュー・バーから別のメニューに移動すると、サブメニューになります。同様に、メニューを既存のサブメニューに移動すると、サブメニューの下の別のサブメニューとなります。

サブメニューを作成するには:

1. サブメニューの追加先となるメニュー項目を選択します。

2. 右クリックして「サブメニューの挿入」を選択します。

   または、メニュー項目を選択し、[Ctrl]キーを押しながら[→]キーを押してサブメニューを作成する方法もあります。

3. 新規のサブメニュー項目をクリックし、ネストしたメニュー項目の名前を入力するか、このプレースホルダに既存のメニュー項目をドラッグします。

4. [Enter]キーまたは[↓]キーを押して次のプレースホルダを作成します。

5. サブメニューに作成する項目ごとに手順3および4を繰り返します。

6. [Esc]キーを押して直前のメニュー・レベルに戻ります。

20.9.7 メニュー・エディタでのメニューのカスタマイズ

JDeveloperのメニュー・エディタを使用して、メニュー項目をカスタマイズおよび管理します。

20.9.8 メニュー項目の追加方法

メニュー・エディタを初めて開くと、定義済のメニュー項目を使用して開いたメニュー・バーまたはポップアップ・メニューが表示されます。メニュー・バーの最後のメニューの右側には空白のメニューもあり、各メニューの最後にはプレースホルダが破線の矩形として表示されます。

既存のメニューにメニュー項目を追加する手順は、次のとおりです。

1. メニュー・エディタで、新規メニューを追加するメニュー・バー上の位置を選択するか、または新規のメニュー項目、セパレータまたはサブメニューを追加するメニュー上の位置を選択します。

2. 右クリックして「メニュー項目の挿入」を選択します。

3. メニュー・エディタにメニュー項目がハイライト状態で表示されている間に、新規メニュー・コンポーネントのラベルに使用するテキストを入力します。

   入力を開始すると、ハイライトされている破線の矩形が、カーソルを含んだ通常のテキスト編集フィールドに変わります。このテキスト・フィールドは、編集フィールドよりも長いラベルに対応するために、入力するにつれてスクロールされます。

4. 入力の完了後に[Enter]を押します。

   リストにすべてのラベルを表示する必要がある場合は、リストの幅が拡大され、次のメニュー項目のプレースホルダが自動的に選択されます。

5. リストに作成する各新規項目のラベルを入力し、[Esc]を押してメニュー・バーに戻ります。

   メニュー・エディタで項目を直接選択するのみでなく、矢印キーを使用してメニュー・バーからメニューに移動し、リスト内の項目間で移動し、[Enter]を押してアクションを完了することもできます。

20.9.9 メニュー項目の無効化方法

コマンドをメニューから削除せずに、現行のプログラム条件に基づいてユーザーによる特定のメニュー・コマンドへのアクセスを防止できます。たとえば、ドキュメントでテキストが選択されていない場合、「編集」メニューの「切取り」、「コピー」および「削除」項目は無効化され、グレー表示されます。

メニュー項目を無効化するにはenabledプロパティを使用します。ほとんどのプロパティと同様に、インスペクタを使用してenabledの初期値を指定できます。メニュー項目のデフォルトの有効化状態はTrueですが、これはイベントの発生時に変更できます。

メニュー項目を無効化する手順は、次のとおりです。

1. メニュー・エディタまたは「構造」ウィンドウでメニュー項目を選択します。

2. 右クリックして「有効」を選択します。

3. または、プロパティ・インスペクタで、メニュー項目のenabledプロパティをfalseに設定します。

   visibleプロパティとは異なり、enabledプロパティは項目を参照可能なままにします。値falseに設定すると、メニュー項目はグレー表示されます。

20.9.10 アクセラレータの指定方法

アクセラレータを使用すると、ユーザーはアクセラレータ・キーの組合せを入力することで、メニューに直接アクセスせずにアクションを実行できます。たとえば、一般に「ファイル」→「保存」に使用されるアクセラレータは[Ctrl]+[S]です。

メニュー項目のアクセラレータを指定する手順は、次のとおりです。

1. 設計ビューまたは「構造」ウィンドウで、メニュー項目を選択します。

2. 「プロパティ・インスペクタ」ウィンドウで、「モデル」セクションからacceleratorプロパティを選択してドロップダウン・メニューから「KeyStroke」を選択します。「アクセラレータ」ダイアログを使用してキーの組合せを入力します。

20.9.11 セパレータ・バーの挿入方法

セパレータ・バーは、メニュー項目間または兄弟であるメニュー・コンポーネント(メニュー項目やサブメニューなど)間に直線として挿入されます。セパレータ・バーを使用して、メニュー内のグループを示すことができます。

メニューにセパレータ・バーを挿入する手順は、次のとおりです。

1. セパレータ挿入位置の前にあるメニュー項目を選択するか、メニューの最後にある空白の項目を選択します。

2. 右クリックして「セパレータの挿入」を選択します。

   選択したメニュー項目の上にセパレータ・バーが挿入されます。

3. または、メニュー項目のラベルにハイフン(-)を1つ入力する方法もあります。

   右クリック・メニューを使用してセパレータを挿入するとaddSeparator()行が生成されますが、ラベルにハイフンを使用すると、ラベルがハイフンになっている追加のクラス・メンバーが、よりメモリー集中型の方法で作成されます。

20.9.12 チェック可能なメニュー項目の作成方法

メニュー項目をチェック可能にするには、そのメニュー項目を標準のMenuItemコンポーネントからCheckboxMenuItemに変更する必要があります。CheckboxMenuItemにはStateプロパティ(ブール)があり、このプロパティによりイベント・ハンドラは関連イベント(動作)の実行方法を判別できます。

• 選択されたメニュー項目のstateプロパティは、trueに設定されます。

• 選択解除されているメニュー項目のstateプロパティは、falseに設定されます。

標準メニュー項目をCheckboxMenuItemに変更するには、次のようにします。

1. メニュー項目を選択します。

2. 右クリックして「チェック可能」を選択します。

20.9.13 メニューとメニュー項目の挿入および削除方法

新しい空のメニューまたはメニュー項目を挿入するには、カーソルを既存のメニュー項目に置いて右クリックし、「メニューの挿入」または「メニュー項目の挿入」を選択します。

メニューはメニュー・バー上で選択した項目の左側に挿入され、メニュー項目はメニュー上で選択した項目の上に挿入されます。

メニュー項目を削除するには、削除対象を選択して[Del]キーを押します。

注意: メニュー・バーでは最後のメニューの後、メニューでは最後の項目の下に、デフォルトのプレースホルダ(削除不可)が表示されます。このプレースホルダは、実行時にはメニューに表示されません。

20.9.14 メニュー項目の移動方法

メニュー・エディタでは、メニューとメニュー項目をドラッグ・アンド・ドロップして移動できます。サブメニュー項目のあるメニュー項目を移動すると、サブメニュー項目も移動します。

メニュー項目とサブメニュー項目を次のように移動できます。

• メニュー内

• 他のメニューへ

メニュー全体をメニュー・バーに沿って移動します。

メニュー項目を移動するには:

1. メニュー項目またはサブメニュー項目をクリックして新しい位置へドラッグします。

   メニュー項目を別のメニューにドラッグする場合は、カーソルが新規メニューを指すまでメニュー・バーに沿ってドラッグします。このアクションにより、メニューが開いて項目を新しい位置へドラッグできるようになります。

2. メニュー項目またはサブメニュー項目を新しい位置にドロップします。

メニューを移動するには:

1. メニュー・バーのメニュー・ラベルをクリックし、カーソルがメニューの表示位置を指すまでメニュー・バー上の新しい位置へドラッグします。

2. メニューを新しい位置にドロップします。

20.10 イベント処理の使用

JDeveloperのUI設計ツールを使用して、コンポーネント・イベントとメニュー・イベントにイベント・ハンドラ・コードをアタッチします。

Javaプログラムの構築時は、コードを初期化コードおよびイベント処理コードの2つのカテゴリに分けられるものとみなすことができます。

• 初期化コードは、UIコンポーネントの作成時に実行されます。これは主にコンポーネントの起動コードとみなすことができます。この初期化コードには、JDeveloperで設計されたすべてのGUIクラスに含まれるjbInit()メソッド内のすべての要素が含まれます。JDeveloperでは、UI設計に基づいてこのコードが生成されます。たとえば、インスペクタを使用してボタンのlabelプロパティを「OK」に設定したため、JDeveloperではbutton1.setLabel("OK")メソッドのコールが生成されます。

• イベント処理コードは、ユーザーがボタンを押したりメニュー項目を使用するなどのアクションを実行したときに実行されるコードです。そのコンポーネントのイベント名をインスペクタに入力し、[Enter]を押すと、JDeveloperではスタブ(空)イベント処理メソッドが自動的に作成されます。そのスタブにおいて、イベントにより引き起こされる実際のアクションを処理するコードを記述します。

プログラム全体は、要素が最初に表示されたときの外観を示す初期化コードと、ユーザー入力に応じた処理内容を示すイベント処理コードで構成されています。

ダイアログなどの一部のJDeveloperコンポーネントは、通常はイベント処理コードの実行時にのみ表示されます。たとえば、ダイアログはJavaビジュアル・エディタで設計しているUIの一部ではなく、ユーザーがメニュー項目を選択したりボタンを押したりすると一時的に表示される独立したUI部分です。したがって、show()メソッドのコールなど、ダイアログの使用に関連付けられたコードの一部は、イベント処理メソッドに配置される場合があります。

20.10.1 メニュー・イベントへのイベント処理コードのアタッチ方法

Swingでは、メニュー項目にactionPerformedイベントがあり、CheckboxMenuItemsにはitemStateChangedイベントがあります。メニュー項目のactionPerformedイベントに追加するコードは、ユーザーがそのメニュー項目を選択するか、対応するアクセラレータ・キーを使用するたびに実行されます。

メニュー項目のイベントにコードを追加する手順は、次のとおりです。

1. UIフレームのJavaビジュアル・エディタを開きます。

2. UIフレームにメニュー・バーを追加し、メニュー・バーにメニューとメニュー項目を挿入します。または、すでにメニューが含まれているファイルを開く方法もあります。

3. メニュー・エディタまたは「構造」ウィンドウでメニュー項目を選択します。

4. プロパティ・インスペクタで「イベント」タブをクリックし、必要なイベントの「値」フィールドをクリックします。

5. イベントの「値」フィールドにイベントのスタブ名を入力し、[Enter]を押して、イベント処理メソッド・スタブを指定の名前でソース・コードに作成します。

   イベントの「値」フィールドに名前を入力すると、コード・エディタが開いて「構造」ウィンドウにソース・コードが表示されます。カーソルは新規に作成したイベント処理メソッドの本体に置かれており、コードを入力できます。

6. 左カッコと右カッコの間に、ユーザーがこのメニュー・コマンドをクリックしたときに実行させるコードを入力します。

20.10.2 コンポーネント・イベントへのイベント処理コードのアタッチ方法

インスペクタのイベント・ページを使用すると、コンポーネント・イベントにハンドラをアタッチしたり、既存のイベント・ハンドラを削除できます。

コンポーネント・イベントにイベント処理コードをアタッチする手順は、次のとおりです。

1. Javaビジュアル・エディタまたは「構造」ウィンドウでコンポーネントを選択します。

2. プロパティ・インスペクタで、「イベント」タブを選択し、そのコンポーネントに対するイベントを表示して、必要なイベントの「値」フィールドをクリックします。

3. イベントの「値」フィールドにイベントのスタブ名を入力し、[Enter]を押して、イベント処理メソッド・スタブを指定の名前でソース・コードに作成します。

   イベント・ハンドラが新しい名前で作成され、ソース・コード内でそのイベント・ハンドラにフォーカスが移ります。また、イベントからイベント処理メソッドへの接続を確立するために、Adapterクラスに追加のコードも挿入されます。

4. イベント・ハンドラのスタブ内でコードを記述して、そのコンポーネント・イベントに対するレスポンスを指定します。

   
   

   注意: コンポーネントのサポート対象となるメソッドとイベントを検索するには、そのコンポーネントをコード・エディタで右クリックし、「宣言に移動」を選択してコード・エディタでクラスを開きます。また、コンポーネントを右クリックして「Javadocの参照」を選択すると、そのクラスに関するドキュメントを参照できます。

   
   

コンポーネントのデフォルト・イベントに対するイベント・ハンドラをすばやく作成する手順は、次のとおりです。

1. コンポーネント・パレットでコンポーネントを選択してUIに追加します。

2. Javaビジュアル・エディタでコンポーネントをダブルクリックします。イベント・スタブが作成され、ソース・コード内でそのイベント・ハンドラにフォーカスが移ります。

3. イベント・ハンドラに必要なコードを追加して完成します。

注意: デフォルト・イベントはbeanInfoで定義されるか、未指定の場合はactionPerformedとして定義されます。

20.11 アプレットの使用

JDeveloperのUI設計ツールを使用して、アプレット・クラスとアプレットHTMLファイルを作成します。アプレットを含むHTMLファイルをJavaプラグインで使用可能なフォーマットに変換することもできます。

20.11.1 アプレットの作成方法

JDeveloperでは、容易にスケルトンのJavaアプレットを作成してコード・エディタで編集できます。

Javaアプレットを作成する手順は、次のとおりです。

1. ナビゲータで、新しいアプレットを作成するプロジェクトを選択します。

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

3. 「カテゴリ」ツリーで、「Web層」を開いて「アプレット」を選択します。

4. 「項目」リストで、「アプレット」をダブルクリックして「アプレットの作成」ダイアログを開きます。

   これにより、「アプレットの作成」ダイアログが開き、指定した情報(名前、パッケージおよび拡張するクラスなど)に基づいてアプレットが作成されます。

操作を完了すると、入力した詳細に基づいてアプレット・クラスを含むスケルトン.javaファイルが生成されます。このファイルをコード・エディタで編集できます。JDeveloperを使用すると、「アプレットHTMLファイル・ウィザード」でHTMLページを作成し、そのページにアプレットを埋め込むこともできます。また、JDeveloperからテストするためにアプレットをスタンドアロンで実行することも可能です。

20.11.2 アプレットHTMLファイルの作成方法

JDeveloperでは、アプレットのコンテナとして機能するJavaアプレットHTMLファイルを容易に作成できます。

JavaアプレットHTMLファイルを作成する手順は、次のとおりです。

1. ナビゲータで、アプレットを含むプロジェクトを選択します。

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

3. 「カテゴリ」ツリーで「クライアント層」を開き、「Swing/AWT」を選択します。

4. 「項目」リストで、「アプレットHTMLページ」をダブルクリックして「アプレットHTMLファイル・ウィザード」を開きます。

「アプレットHTMLファイル・ウィザード」では、指定した情報(ファイルの場所、コード属性、配置属性およびアプレット・パラメータなど)に基づいてファイルが作成されます。オプションのデプロイメント・プロファイルを作成することもできます。

20.11.3 アプレットを含んだHTMLページの変換方法

JDeveloperにはJavaプラグインHTMLコンバータが組み込まれており、アプレットを含んだHTMLファイルを、Javaプラグインで使用可能なフォーマットに変換できます。

アプレットを含んだHTMLファイルを変換する手順は、次のとおりです。

1. 「ツール」→「HTMLの変換」を選択して、JavaプラグインHTMLコンバータを開きます。

2. 変換するファイルまたはファイルのディレクトリ・パスを指定します。

3. ディレクトリ・パスを入力した場合は一致するファイル名を指定し、オプションで「サブフォルダも含める」を選択します。

4. バックアップ・ファイル用のデフォルト・フォルダを変更するか、受け入れます。

5. ドロップダウン・リストから、使用するテンプレート・ファイルを選択します。

6. 「変換」をクリックします。

   このプラグインでは、元のファイルのコピーがバックアップ・フォルダに置かれ、指定した全ファイルが元の場所で変換されます。コンバータの実行が完了すると、ファイルはJavaプラグインを使用するように設定されます。

7. 「進行状況」ウィンドウに全ファイルの処理が完了したことが示された時点で、「終了」をクリックします。

20.11.4 アプレットのデプロイ

Oracle Application ServerでJDeveloperを使用してアプレットまたは他のJava EE Webモジュールをデプロイするプロセスは、完全に自動化されたプロセスです。

20.11.4.1 デプロイ用のアプレットの構成方法

スタンドアロン・アプレットは、Webアーカイブ(WAR)ファイルとしてパッケージ化されます。このファイルには、そのアプレット、アプレットHTMLファイル、標準のJava EE Webデプロイメント・ディスクリプタweb.xml、および場合によっては、ターゲット固有のデプロイメント・ディスクリプタも含まれています。デプロイメント・プロファイルと適切なデプロイメント・ディスクリプタ・ファイルを作成した後は、アプリケーションを、アプリケーション・サーバーにデプロイしたり、アーカイブ・ファイルとしてデプロイすることができます。

Webアプリケーションをデプロイ用に構成するには、次の手順を実行します。

1. プロジェクト用のWARファイル・デプロイメント・プロファイルを作成します。

   プロジェクトに、すでにプロファイルが作成されている場合があります。複数のターゲットにデプロイする場合は、ターゲットごとに個別のプロファイルを作成します。

2. プロジェクトに、web.xmlデプロイメント・ディスクリプタを追加します(存在しない場合)。

   通常、このファイルはWARファイル・デプロイメント・プロファイルとともに作成されます。

注意: 「クラスが見つかりません」というエラーの表示など、Swingアプレット(JApplet)をデプロイしているときに問題が発生する場合、JDeveloperがSwingライブラリを検出できないことを意味している可能性があります。場合によっては、クライアントでSun社のJava SEブラウザ・プラグインを使用するか、JVMバージョン1.1のSwingライブラリをアプレットにバンドルする必要があります。 デプロイされるアプレット・ファイルは、デプロイ済の他のWebアプリケーション・ファイルとは別の場所に配置する必要があります。

20.11.4.2 WARファイルとしてのアプレットのデプロイ方法

アプレットを含むWebアプリケーション・コンポーネントは、WARファイルまたはEARファイルとしてターゲット・アプリケーション・サーバーにデプロイできます。

アプレットをWARファイルとしてデプロイするには、次の手順を実行します。

1. まだ構成していない場合は、アプレットをデプロイ用に構成します。

2. まだ作成していない場合は、アプリケーション・サーバー接続を作成します。

3. アプリケーション・ナビゲータで、プロジェクトを右クリックし、「デプロイ」→デプロイメント・プロファイルを選択します。

4. 「デプロイ」ダイアログで、次のいずれかのデプロイメント・オプションを選択します。

   • アプリケーション・サーバー接続にデプロイ。デプロイメント・プロファイルで指定されたアーカイブ・タイプを作成し、「デプロイ」ダイアログの「サーバーの選択」ページで選択または作成したアプリケーション・サーバー接続にデプロイします。

   • EARファイルにデプロイ。プロジェクトとその依存性(デプロイメント・プロファイルに指定)をEARにデプロイします。JDeveloperでは、EARファイルはデプロイメント・プロファイルに指定されているデフォルト・ディレクトリに置かれます。

   • WARファイルへデプロイ。プロジェクトをWARにデプロイします。JDeveloperでは、WARファイルはデプロイメント・プロファイルに指定されているデフォルト・ディレクトリに置かれます。

   
   

   注意: デプロイされるアプレット・ファイルは、デプロイ済の他のWebアプリケーション・ファイルとは別の場所に配置する必要があります。 「クラスが見つかりません」というエラーの表示など、Swingアプレット(JApplet)をデプロイしているときに問題が発生する場合、JDeveloperがSwingライブラリを検出できないことを意味している可能性があります。場合によっては、クライアントでSun社のJava SEブラウザ・プラグインを使用するか、JVMバージョン1.1のSwingライブラリをアプレットにバンドルする必要があります。

   
   

20.12 UIデバッガの使用

JDeveloperでは、標準的なJavaおよびPL/SQLデバッガ機能のみでなく、AWTおよびSwingベースのクライアント・アプリケーションおよびアプレット専用のグラフィカル・ユーザー・インタフェース(GUI)のデバッグをサポートしています。

UIデバッガには、GUIアプリケーションのデバッグについて代替方法が用意されています。従来のデバッガでは、データ構造を調べてプログラム・フローをトラッキングしていました。UIデバッガでは、かわりにGUI構造とイベントの順序を調べることができます。UIデバッガを使用すると、画面に表示されるUIコンポーネントと実際のデータの関係を確認できます。また、UIコンポーネントにより起動されるイベントとイベントを受信するリスナーも表示されます。

UIデバッガを使用するには、「ヘルプ」→「更新のチェック」を選択し、ウィザードの指示に従い、最初にUIデバッガをダウンロードする必要があります。Oracle JDeveloper拡張機能のインストール方法の詳細は、『Oracle Fusion Middleware Oracle JDeveloperインストレーション・ガイド』を参照してください。

UIデバッガの使用に特別な追加前提条件はなく、JDeveloperデバッガを使用する場合と同じですが、「プロジェクト・プロパティ - ライブラリ」ページでJDeveloperランタイム・ライブラリjdev-remote.jarを選択する必要があります。

従来のほとんどのデバッガでは、GUIアプリケーションのツリー構造を調べるのが容易ではなく、アプリケーションに表示される内容の詳細も表示されないため、GUIアプリケーションのデバッグは困難な場合がありました。

デバッグを開始するには、プロジェクトを選択して「実行」→「UIデバッグ<projectname>.jpr」を選択することで、デバッグを開始できます。

20.12.1 「UIデバッガ」ウィンドウの使用

JDeveloperで公開されるUIデバッガ機能は、3つのドッキング可能ウィンドウを介して使用できます。「UIツリー」ウィンドウと「UIアウトライン」ウィンドウは、UIデバッガの起動時に自動的に表示されます。「イベント」ウィンドウは、イベントを初めてトラッキングする際に表示されます。この3つのウィンドウはいずれも、「表示」→「UIデバッガ - <UI_debugger_window>」を選択することでトグルできます。

注意: 「UIデバッガ」ウィンドウには、スナップショットを生成するまでは情報が表示されません。「スナップショット」ボタン([F5])をクリックすると、「UIツリー」ウィンドウと「UIアウトライン」ウィンドウに移入されます。

• UIツリー: アプリケーションのコンポーネント、サブコンポーネントおよびその親子関係を表す階層構造が表示されます。ツリーからコンポーネントを選択し、右クリックしてポップアップ・メニューのオプションを表示します。そのコンポーネントが「UIアウトライン」ウィンドウでも選択されていることがわかります。

• UIアウトライン: アプリケーションのGUIのイメージまたはアウトライン・イメージが表示されます。GUIアプリケーションのグラフィカル表現からコンポーネントを選択し、右クリックしてポップアップ・メニューのオプションを表示します。

  
  

  注意: AWTコンポーネントが正しくペイントされない可能性があるため、Swingベース以外のアプリケーション場合はアウトライン・モードを使用することをお薦めします。

  
  

• イベント: 「リスナー」ダイアログでリスニング対象として選択したイベントに関する情報が表示されます。「リスナー」ダイアログは、「UIツリー」ウィンドウまたは「UIアウトライン」ウィンドウで「イベント」ポップアップ・メニューのオプションを選択すると表示されます。このウィンドウでイベントを選択すると、そのソース・コンポーネントが「UIツリー」ウィンドウと「UIアウトライン」ウィンドウで選択されます。

20.12.2 UIデバッガの起動方法

UIデバッガ・タスクを実行する前に、まずUIデバッガを起動する必要があります。

UIデバッガを起動する手順は、次のとおりです。

1. ナビゲータでデバッグ対象のプロジェクトを選択します。

2. 実行構成を選択します。詳細は、第19.3項「プロジェクトを実行用に設定する方法」を参照してください。

3. 「実行」→「UIデバッグ<projectname>.jpr」を選択し、プロジェクトのデフォルト・ターゲットを起動してアプリケーションを実行します。

   JDeveloperによって、UIデバッガが起動します。アプリケーションが起動し、「UIツリー」ウィンドウと「UIアウトライン」ウィンドウが自動的に表示されます。ただし、UIデバッガのウィンドウにはまだ情報が表示されません。

4. アプリケーションが完全に起動した後、デバッグ対象のダイアログまたはウィンドウに移動して選択します。

5. 一方のUIデバッガ・ウィンドウで「スナップショット」([F5])ボタンをクリックします。

   「UIツリー」ウィンドウにアプリケーションの階層構造が表示され、「UIアウトライン」ウィンドウにアプリケーションのユーザー・インタフェースのグラフィカル表現が表示されます。

20.12.3 アプリケーション・コンポーネント階層の検査

「UIツリー」に表示される情報、「UIアウトライン」ウィンドウに表示される情報、および両者間の関係は、常に同期化されています。この2つのウィンドウには(表示方法が異なるのみで)同じ情報が表示されるため、「UIツリー」階層でコンポーネントを選択すると、「UIアウトライン」ウィンドウ内で同じオブジェクトが検索されてハイライトされ、その逆も同じです。

アプリケーション・コンポーネント階層を調べる前に、UIデバッガを起動してスナップショットを生成する必要があります。アプリケーションのUIが更新されるたびに、「スナップショット」を再度クリックして、UIデバッガのウィンドウに表示される情報を更新する必要があります。

アプリケーション・コンポーネント階層の検査方法は、次のとおりです。

• 「UIツリー」ウィンドウのツリーを使用してコンポーネントの階層構造を調べるか、「UIアウトライン」ウィンドウを使用してコンポーネントを目視で探します。

• 「UIアウトライン」ウィンドウの上部にある「イメージ」および「アウトライン」チェック・ボックスを使用して、それぞれコンポーネントのイメージと枠線をトグルします。

• 「UIアウトライン」ウィンドウの下部にあるアイコンを使用すると、アプリケーションのイメージをズームインまたはズームアウトできます。イメージがウィンドウよりも大きい場合は、イメージをクリックしてドラッグすると必要な部分を表示できます。

• 「UIアウトライン」ウィンドウで選択されていないコンポーネントは、赤い網掛け付きで表示されます。

• 非表示のコンポーネントは、「UIツリー」にグレーのテキストで表示されます。

• どちらのウィンドウでも、コンポーネントを右クリックしてポップアップ・メニューのオプションを表示できます。詳細は、「UIツリー」または「UIアウトライン」を参照してください。

20.12.4 「監視」ウィンドウでのコンポーネント情報の表示方法

コンポーネントに関連付けられているデータを調べるために、JDeveloperの「監視」ウィンドウで監視対象のコンポーネントを選択できます。監視式を使用すると、プログラムの実行に従って変化する、変数および式の値を監視できます。

「監視」ウィンドウにコンポーネント情報を表示する手順は、次のとおりです。

1. まだ実行していない場合は、UIデバッガを起動してスナップショットを生成します。

2. 「UIツリー」または「UIアウトライン」ウィンドウでコンポーネントを右クリックし、ポップアップ・メニューから「監視」を選択します。

   「監視」ウィンドウが「スマート・データ」ウィンドウのタブとして開き(まだ開いていない場合)、このタブにコンポーネントの構造を表すツリーが表示されます。

20.12.5 「インスペクタ」ウィンドウでのUIコンポーネントのインスペクト方法

JDeveloperの「インスペクタ」ウィンドウで、UIコンポーネントの状態を確認できます。

「インスペクタ」ウィンドウにUIコンポーネントを表示する手順は、次のとおりです。

1. まだ実行していない場合は、UIデバッガを起動してスナップショットを生成します。

2. 「UIツリー」または「UIアウトライン」ウィンドウでコンポーネントを右クリックし、ポップアップ・メニューから「インスペクト」を選択します。

   「インスペクト」ウィンドウが「スマート・データ」ウィンドウのタブとして開き(まだ開いていない場合)、このタブにコンポーネントの構造を表すツリーが表示されます。

20.12.6 コンポーネントにより生成されるイベントのトレース方法

イベント・トレース機能を使用して、UIコンポーネントにより生成されたイベントのうち、選択したイベントの起動を監視できます。この情報を使用して、イベントの内容と順序を判別します。

コンポーネントにより生成されるイベントをトレースする手順は、次のとおりです。

1. まだ実行していない場合は、UIデバッガを起動してスナップショットを生成します。

2. 「UIツリー」または「UIアウトライン」ウィンドウでコンポーネントを右クリックし、ポップアップ・メニューから「イベントのトレース」を選択します。

   「イベントのトレース」ダイアログが開き、コンポーネントにより起動されたイベント・タイプを受信するリスナーのリストが表示されます。

   
   

   注意: 表示されるのは、スナップショットの生成時に参照可能だったUIコンポーネントのイベント・リスナーのみです。以降の実行によりUIコンポーネントが追加または削除されていても、その変更はリストに表示されません。

   
   

3. (オプション)「子を含める」を選択します。これにより、選択したコンポーネントの子により起動されるイベント・タイプも追加表示されます。

4. 「リスナー」ダイアログで、トレース対象のイベント・リスナーを選択します(複数選択可)。たとえば、「FocusListener」を選択すると、すべてのフォーカス・イベントがトレースされます。

5. 「OK」をクリックします。

6. 選択したリスナーにより起動されたイベントが「イベント」ウィンドウに表示されます。ウィンドウを右クリックしてウィンドウの内容を消去するか、または特定のリスナーを削除します。

20.12.7 イベント・リスナーの表示方法

「リスナーの表示」機能を使用すると、UIコンポーネントにより起動されたイベントの受信者を検索できます。この情報を使用してUIイベントのエクステントを判別します。

警告: 表示されるのは、スナップショットの生成時に参照可能だったUIコンポーネントのイベント・リスナーのみです。以降の実行によりUIコンポーネントが追加または削除されていても、その変更はリストに表示されません。

コンポーネントにより生成されるイベントをトレースする手順は、次のとおりです。

1. まだ実行していない場合は、UIデバッガを起動してスナップショットを生成します。

2. 「UIツリー」または「UIアウトライン」ウィンドウでコンポーネントを右クリックし、ポップアップ・メニューから「リスナーの表示」を選択します。

   選択したコンポーネントの「リスナー」ダイアログが開き、コンポーネントにより通知されたリスナー・タイプ、各リスナー・タイプの登録済リスナーのクラスおよび各クラスで実装されているイベント・メソッドのリストが表示されます。

   
   

   注意: リスナーのリストにはデバッガのトレーシング・フィルタが適用されます。フィルタによりクラスが除外されたリスナーは、リストに表示されません。

   
   

3. メソッドを選択します。

4. 「ソースに移動」をクリックします。

   編集ウィンドウが開き、選択したメソッドのソース・コードが表示されます。

20.12.8 GUIアプリケーションのリモート・デバッグ方法

JDeveloperでは、コマンドラインを介したGUIアプリケーションのリモート・デバッグをサポートしています。そのためには、デバッグ対象のプログラムを手動で起動する必要があります。プログラムが開始し、JDeveloperのデバッガがアタッチされた後は、リモート・デバッグとローカル・デバッグの動作はよく似ています。

UIのリモート・デバッグの実行方法は、アプリケーションのリモート・デバッグに似ています。最初に、次の要件が満たされていることを確認してください。

• ライブラリにJDeveloperランタイムjdev-remote.jarを追加すること。

• UIデバッガ・エージェントのメイン・クラスをアプリケーションのメイン・クラスの前に指定すること。

GUIアプリケーションのリモート・デバッグを実行するには、次のようにします。

1. デバッグ用のプロジェクトを構成して、リモート・デバッグに使用可能であることを確認します。

2. 次のコマンドを実行してアプリケーションを手動で起動します。

   java -XXdebug -cp ...\jdev\lib\jdev-remote.jar 
   oracle.jdevimpl.runner.uidebug.debuggee.Debuggee <MainClass>
   

   意味は次のとおりです。

   • ...¥jdev¥lib¥jdev-remote.jarは、JDeveloperランタイム・ライブラリのクラスパスです。これをコマンドに追加する必要があります。

   • oracle.jdevimpl.runner.uidebug.debuggee.Debuggeeは、UIデバッガのエージェントのメイン・クラスの名前です。

3. コマンド・ウィンドウに次のようなメッセージが出力されます。

   *** Port is 4000 ***
   *** Waiting for JVM debugger connection. ***
   

4. UIデバッガはソケットを使用してアプリケーションと相互作用します。ソケットのデフォルトのポート番号は4030ですが、次のようにアプリケーションのメイン・クラスの前に-uidport,<port>を挿入すると、別のポート番号を指定できます。

   java -XXdebug -cp ...\jdev\lib\jdev-remote.jar
   oracle.jdevimpl.runner.uidebug.debuggee.Debuggee -uidport,5678 
   mypackage1.Application1
   

   この場合、JDeveloper IDEでUIデバッガを起動するときにもポート番号を指定する必要があります。

UIのリモート・デバッグのためにJDeveloper IDEを起動するには、次のようにします。

1. リモート・デバッグ用に設定した実行構成を選択します(「実行」→「アクティブな実行構成を選択」)。

2. 「デバッグ」→「UIデバッグ<project_name>.jpr」を選択します。

   Javaアプリケーションのメイン・メソッドが起動します。

3. 「JPDAにアタッチ」ダイアログが表示され、ホスト名とUIデバッガ・ポートを指定するように要求されます。

   -uidportオプションを使用しなかった場合は、この値をデフォルトの4030のままにする必要があります。

4. UIのローカル・デバッグを実行しているかのようにUIデバッグ・セッションが動作します。任意のUIデバッガ・タスクの実行を開始できます。

20.12.9 リスナーの自動検出

UIデバッガによりトラッキングできるイベントのリストはハード・コード化されていませんが、実行時に動的に検出されます。したがって、次のガイドラインに従っていれば、すべてのリスナーにより起動されたイベントをトラッキングできます。

• コンポーネント・クラスに、リスナーを追加および削除するためのパブリック・メソッドが必要です。

• メソッド名がaddまたはremoveで始まってListenerで終わる必要があります。

• 戻り型がvoidである必要があります。

• メソッドの引数が1つのみである必要があります。

• 引数のタイプがjava.util.EventListenerを拡張するインタフェースである必要があります。

• メソッド名がaddまたはremoveで始まるインタフェース名と同じである必要があります。

• 指定したインタフェース内の各メソッドの戻り型がvoidである必要があります。

• メソッドに使用できる引数は1つのみ(イベント)です。

• 引数のタイプがBeanとしてアクセス可能なクラスである必要があります。

• getterの戻り値はvoid以外の値でもかまいません。プリミティブ型でない場合、UIデバッガに表示される値はオブジェクトのtoString()メソッドをコールすることで取得された文字列になります。

例

• たとえば、Xxx型の新規イベント・リスナーを定義する場合、コンポーネントには次のシグネチャを持つメソッドが必要です。

  public void addXxxListener(XxxListener); 
  public void removeXxxListener(XxxListener);
  

• XxxListenerインタフェースの例を次に示します。

  public interface XxxListener extends java.util.EventListener
  {
     public void methodOne(XxxEvent xxxEvent);
     public void methodTwo(XxxEvent xxxEvent);
     public void methodThree(XxxEvent xxxEvent);
  }
  

• XxxEventクラスの例を次に示します。

  public class XxxEvent 
  {
     public int getA(){...} 
     public String getB(){...} 
     public OtherType getC(){...}