イベントについて

・	イベントについて
・	Event クラスについて
・	EventDispatcher クラスについて
・	イベントの通知を受け取る
・	イベントを発行する
・	コールバック関数にデータを渡す

前のページに戻る

イベントについて

■イベントについて

様々な任意の動作タイミングが、イベントとして定義されています。

例えば、「マウス操作」「キーボード操作」といったタイミングです。

■ EventDispatcher クラスについて

EventDispatcher は、「イベントの発送者」を意味します。

イベントディスパッチャーであれば、イベントを発行する事ができます。

イベントは、主にシステム側から発行されます。

自ら発送者として、イベントを供給することもできます。

■ DisplayObject における実装

DisplayObject は、EventDispatcher クラスを継承しています。

また、任意のクラスが、EventDispatcher を継承している場合、何らかのイベントが供給されているでしょう。

例えば、Timer クラスなどがあります。

■ EventDispatcher クラスの派生について

EventDispatcher クラスは、以下の様に派生しています。

ここで解説してない分は、リンク先に解説がありますので合わせてご覧下さい。

Object

↓派生

EventDispatcher

■供給されるイベントの種類について

供給されるイベントの種類については、公式リファレンスが参考になります。

http://help.adobe.com/ja_JP/FlashPlatform/reference/actionscript/3/flash/events/Event.html

■ EventListener について

EventListener は、「イベントを聞く人」を意味します。

ディスパッチャーから発行されるイベントの通知を、受け取りたい側に相当します。

EventListener というクラスはありません。

イベントリスナーという用語は、広い意味を持ちます。

■ディスパッチャーとリスナーの関係

リスナーについて

あなたは、イベント通知を受け取りたいプログラマです。

あなたは、EventDispatcher に、コールバック関数を登録する事ができます。

コールバック関数は、ハンドラ（処理部）と呼ばれます。

コールバック関数は、EventDispatcher のリスナーとなります。

１つの EventDispatcher に対して、複数のコールバック関数を登録する事もできます。

イベントのディスパッチについて

EventDispatcher は、イベントを送出する事ができます。

イベントの発行、イベントの発火とも呼ばれます。

EventDispatcher は、登録されたコールバック関数を実行します。

こうしてあなたは、EventDispatcher からのイベント通知を受け取る事ができます。

コールバック関数の引数から、Event オブジェクトが得られます。

■イベントフェーズについて

大抵のイベントは、表示リストと密接に関係しています。

■バブルズ（bubbles）について

大抵のイベントは、バブルズ（bubbles）に対応しています。

対象本人だけでなく、祖先にも通知されます。

バブルズに対応していないイベントは、対象本人にのみ通知されます。

例えば、MouseEvent.CLICK イベントは、バブルズに対応しています。

例えば、Event.ENTER_FRAME イベントは、バブルズに対応していません。

■イベントフェーズについて

イベント通知の伝達順序として、以下の段階があります。

１．キャプチャ段階

２．ターゲット段階

３．バブリング段階

バブルズに対応しているイベントは、キャプチャ段階 → ターゲット段階 → バブリング段階という順序で伝達されます。

バブルズに対応していないイベントは、ターゲット段階のみ実行されます。

１．キャプチャ段階

キャプチャ段階では、ステージから子孫に向かって順番に実行されます。

「ステージ」から「ターゲットの直前」まで実行されます。

任意のリスナーにとって、子孫にイベントが発生した事がわかります。

下の図であれば、１～５に登録したリスナーに相当します。

２．ターゲット段階

ターゲット段階は、対象となるオブジェクトに到達したときに実行されます。

「ターゲット」が実行されます。

任意のリスナーにとって、自身にイベントが発生した事がわかります。

３．バブリング段階

バブリング段階では、子孫からステージに向かって順番に実行されます。

「ターゲットの直後」から「ステージ」まで実行されます。

上に戻っていく流れが、バブル（泡）となります。

任意のリスナーにとって、子孫にイベントが発生した事がわかります。

下の図であれば、１～５に登録したリスナーに相当します。

■イベントフェーズの流れを確認する

マウスボタンを押した時のイベントフェーズの流れを確認する


import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.display.Graphics;
import flash.events.MouseEvent;

// ------------------------------------------------------------
// スプライトＡを作成して配置
// ------------------------------------------------------------
// スプライトＡを作成
var sprite_a:Sprite = new Sprite();
sprite_a.name = "スプライトＡ";

// ステージにスプライトＡを配置
stage.addChild(sprite_a);


// ------------------------------------------------------------
// スプライトＢを作成して配置
// ------------------------------------------------------------
// スプライトＢを作成
var sprite_b:Sprite = new Sprite();
sprite_b.name = "スプライトＢ";

// スプライトＡにスプライトＢを配置
sprite_a.addChild(sprite_b);

// スプライトＢに矩形をレンダリング
var g:Graphics;
g = sprite_b.graphics;
g.lineStyle (5, 0xAA0000, 1.0);
g.beginFill (0xFF4444, 1.0);
g.drawRect (0,0,300,300);


// ------------------------------------------------------------
// マウスボタンを押したときに実行される関数
// ------------------------------------------------------------
function MouseDownFunc(e:MouseEvent):void{
	var current:DisplayObject = e.currentTarget as DisplayObject;
	var target:DisplayObject = e.target as DisplayObject;
	trace("カレント:" + current + "(" + current.name + ")");
	trace("ターゲット:" + target + "(" + target.name + ")");
	trace("イベントフェーズ:" + e.eventPhase);
	trace("---");
}


// ------------------------------------------------------------
// すべてのフェーズでリッスンを開始
// ------------------------------------------------------------
stage.addEventListener(MouseEvent.MOUSE_DOWN,MouseDownFunc,true );
stage.addEventListener(MouseEvent.MOUSE_DOWN,MouseDownFunc,false );
sprite_a.addEventListener(MouseEvent.MOUSE_DOWN,MouseDownFunc,true );
sprite_a.addEventListener(MouseEvent.MOUSE_DOWN,MouseDownFunc,false );
sprite_b.addEventListener(MouseEvent.MOUSE_DOWN,MouseDownFunc,true );
sprite_b.addEventListener(MouseEvent.MOUSE_DOWN,MouseDownFunc,false );

上に戻る

Event クラスについて

■ Event クラスについて

■ Event クラスのプロパティについて

■ Event クラスのメソッドについて

■ Event クラスについて

Event クラスは、イベント関連の情報を格納するための入れ物です。

システム側からイベントが発行される場合、システムが、Event オブジェクトを生成します。

ディスパッチャーに登録したコールバック関数の引数から、Event オブジェクトを受け取る事ができます。

イベントの種類によっては、Event クラスから派生して、専用のプロパティやメソッドを持つものもあります。

■ Event クラスの種類

Event クラスの種類については、公式リファレンスが参考になります。

http://help.adobe.com/ja_JP/FlashPlatform/reference/actionscript/3/flash/events/package-detail.html

■ Event クラスのプロパティについて

Event クラスには、以下の読み取り専用のプロパティがあります。

プロパティ名	型	説明
type	String	イベント名
currentTarget	Object	イベント伝達中における現在の場所を意味する。イベントリスナー（現在呼び出されているコールバック関数自身）の登録時に指定した EventDispatcher オブジェクトを指す。
target	Object	イベントの発生場所を意味する。ターゲット段階で動作する EventDispatcher オブジェクトを指す。
eventPhase	uint	イベントフェーズの種類。
bubbles	Boolean	true の場合、バブリングイベントに対応している。
cancelable	Boolean	true の場合、デフォルトの動作のキャンセルに対応している。

■ eventPhase プロパティ（EventPhase 定数）

eventPhase プロパティからは、以下の EventPhase 定数が取得できます。

イベントフェーズについては、こちらで解説しています。

定数	番号	説明
EventPhase.CAPTURING_PHASE	1	キャプチャ段階
EventPhase.AT_TARGET	2	ターゲット段階
EventPhase.BUBBLING_PHASE	3	バブリング段階

■ Event クラスのメソッドについて

Event クラスには、以下のメソッドがあります。（一部抜粋）

メソッド名	説明
preventDefault()	デフォルトの動作をキャンセルします。
stopImmediatePropagation()	イベント通知の伝達を終了します。即時中止します。
stopPropagation()	イベント通知の伝達を終了します。同じイベントに他のリスナーが登録されている場合、それらの処理が終わるまで中断しません。

■デフォルトの動作をキャンセルする

イベントの種類によっては、キャンセルに対応している場合があります。

任意の動作が行われる直前に、イベントが発行されます。

リスナー側で、任意の動作をキャンセルするか選択する事ができます。

イベントがキャンセルに対応しているか調べるには、cancelable プロパティを使用します。

デフォルトの動作をキャンセルするには、preventDefault() メソッドを使用します。

リスナーがキャンセルしたかを知るには、isDefaultPrevented() メソッドを使用します。

テキストフィールドへの入力をキャンセルする


import flash.text.TextField;
import flash.text.TextFieldType;
import flash.events.TextEvent;

// テキストフィールドオブジェクトを作成する
var text_field:TextField = new TextField();

// ステージの表示リストに登録する
stage.addChild(text_field);

// テキストフィールドの設定
text_field.x = 10;
text_field.y = 10;
text_field.width  = stage.stageWidth  - 20;
text_field.height = stage.stageHeight - 20;
text_field.border = true;
text_field.type = TextFieldType.INPUT;

// テキスト入力時に呼び出されるイベント
text_field.addEventListener(TextEvent.TEXT_INPUT ,function (e:TextEvent):void{

	// キャンセルに対応しているか
	var cancelable:Boolean = e.cancelable;

	// デフォルトの動作をキャンセル
	e.preventDefault();

	// 出力テスト
	trace("キャンセルに対応しているか:" + cancelable);
	trace("入力される文字(予定):" + e.text);
});

■イベント通知の伝達を終了する（即時中止）

イベントフェーズの流れを終了するには、stopImmediatePropagation() メソッドを使用します。

このメソッドを呼び出すと、イベント通知の伝達を即時中断します。

イベントの伝達を即時終了する


import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.EventPhase;

// ------------------------------------------------------------
// スプライトＡ
// ------------------------------------------------------------
// スプライトを作成
var sprite_a:Sprite = new Sprite();
sprite_a.name = "スプライトＡ";

// ステージにスプライトＡを配置
stage.addChild(sprite_a);


// ------------------------------------------------------------
// スプライトＢ
// ------------------------------------------------------------
// スプライトを作成
var sprite_b:Sprite = new Sprite();
sprite_b.name = "スプライトＢ";

// スプライトＡにスプライトＢを配置
sprite_a.addChild(sprite_b);


// ------------------------------------------------------------
// スプライトＣ
// ------------------------------------------------------------
// スプライトを作成
var sprite_c:Sprite = new Sprite();
sprite_c.name = "スプライトＣ";

// スプライトＢにスプライトＣを配置
sprite_b.addChild(sprite_c);


// ------------------------------------------------------------
// 表示リストから外したときに実行される関数
// ------------------------------------------------------------
function EventRemovedFunc(e:Event):void{
	var current:DisplayObject = e.currentTarget as DisplayObject;
	trace("カレント:" + current + "(" + current.name + ")");
	trace("イベントフェーズ:" + e.eventPhase);
	trace("---");

	// ターゲットフェーズに到達した
	if (e.eventPhase == EventPhase.AT_TARGET) {
		// イベント通知の伝達を直ちに終了する
		e.stopImmediatePropagation();
	}
}


// ------------------------------------------------------------
// すべてのフェーズでリッスンを開始
// ------------------------------------------------------------
stage.addEventListener(Event.REMOVED,EventRemovedFunc,true );
stage.addEventListener(Event.REMOVED,EventRemovedFunc,false );
sprite_a.addEventListener(Event.REMOVED,EventRemovedFunc,true );
sprite_a.addEventListener(Event.REMOVED,EventRemovedFunc,false );
sprite_b.addEventListener(Event.REMOVED,EventRemovedFunc,true );
sprite_b.addEventListener(Event.REMOVED,EventRemovedFunc,false );
sprite_c.addEventListener(Event.REMOVED,EventRemovedFunc,true );
sprite_c.addEventListener(Event.REMOVED,EventRemovedFunc,false );


// ------------------------------------------------------------
// スプライトＣを表示リストから外す
// ------------------------------------------------------------
sprite_c.parent.removeChild(sprite_c);

■イベント通知の伝達を終了する

イベントフェーズの流れを終了するには、stopPropagation() メソッドを使用します。

同じイベントに他のリスナーが登録されている場合、それらの処理が終わるまでは中断しません。

イベントの伝達を終了する


import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.EventPhase;

// ------------------------------------------------------------
// スプライトＡ
// ------------------------------------------------------------
// スプライトを作成
var sprite_a:Sprite = new Sprite();
sprite_a.name = "スプライトＡ";

// ステージにスプライトＡを配置
stage.addChild(sprite_a);


// ------------------------------------------------------------
// スプライトＢ
// ------------------------------------------------------------
// スプライトを作成
var sprite_b:Sprite = new Sprite();
sprite_b.name = "スプライトＢ";

// スプライトＡにスプライトＢを配置
sprite_a.addChild(sprite_b);


// ------------------------------------------------------------
// スプライトＣ
// ------------------------------------------------------------
// スプライトを作成
var sprite_c:Sprite = new Sprite();
sprite_c.name = "スプライトＣ";

// スプライトＢにスプライトＣを配置
sprite_b.addChild(sprite_c);


// ------------------------------------------------------------
// 表示リストから外したときに実行される関数
// ------------------------------------------------------------
// リスナーＡ
function EventRemovedFuncA(e:Event):void{
	var current:DisplayObject = e.currentTarget as DisplayObject;
	trace("リスナーＡ");
	trace("カレント:" + current + "(" + current.name + ")");
	trace("イベントフェーズ:" + e.eventPhase);
	trace("---");

	// ターゲットフェーズに到達した
	if (e.eventPhase == EventPhase.AT_TARGET) {
		// イベント通知の伝達を終了する
		e.stopPropagation();
	}
}

// リスナーＢ
function EventRemovedFuncB(e:Event):void{
	var current:DisplayObject = e.currentTarget as DisplayObject;
	trace("リスナーＢ");
	trace("カレント:" + current + "(" + current.name + ")");
	trace("イベントフェーズ:" + e.eventPhase);
	trace("---");
}


// ------------------------------------------------------------
// すべてのフェーズでリッスンを開始
// ------------------------------------------------------------
// リスナーＡ
stage.addEventListener(Event.REMOVED,EventRemovedFuncA,true );
stage.addEventListener(Event.REMOVED,EventRemovedFuncA,false );
sprite_a.addEventListener(Event.REMOVED,EventRemovedFuncA,true );
sprite_a.addEventListener(Event.REMOVED,EventRemovedFuncA,false );
sprite_b.addEventListener(Event.REMOVED,EventRemovedFuncA,true );
sprite_b.addEventListener(Event.REMOVED,EventRemovedFuncA,false );
sprite_c.addEventListener(Event.REMOVED,EventRemovedFuncA,true );
sprite_c.addEventListener(Event.REMOVED,EventRemovedFuncA,false );

// リスナーＢ
stage.addEventListener(Event.REMOVED,EventRemovedFuncB,true );
stage.addEventListener(Event.REMOVED,EventRemovedFuncB,false );
sprite_a.addEventListener(Event.REMOVED,EventRemovedFuncB,true );
sprite_a.addEventListener(Event.REMOVED,EventRemovedFuncB,false );
sprite_b.addEventListener(Event.REMOVED,EventRemovedFuncB,true );
sprite_b.addEventListener(Event.REMOVED,EventRemovedFuncB,false );
sprite_c.addEventListener(Event.REMOVED,EventRemovedFuncB,true );
sprite_c.addEventListener(Event.REMOVED,EventRemovedFuncB,false );


// ------------------------------------------------------------
// スプライトＣを表示リストから外す
// ------------------------------------------------------------
sprite_c.parent.removeChild(sprite_c);

上に戻る

EventDispatcher クラスについて

■ EventDispatcher クラスのメソッドについて

メソッド名	説明
addEventListener()	リスナーを登録して、イベントの通知を受け取る。
removeEventListener()	リスナーを除外して、イベントの通知を止める。
hasEventListener()	自身に１つ以上のリスナーが登録済みであるか調べる。
willTrigger()	自身か祖先に１つ以上のリスナーが登録済みであるか調べる。
dispatchEvent()	イベントを発行する。

■ hasEventListener() メソッドについて

自身に１つ以上のリスナーが登録済みであるか調べるには、 hasEventListener() メソッドを使用します。

EventDispatcher.hasEventListener ("イベント名" ) :Boolean

第01引数	String	イベント名を指定
戻り値	Boolean	自身に１つ以上のリスナーが登録済みであれば true が得られる

自身に１つ以上のリスナーが登録済みであるか調べる


import flash.display.Sprite;
import flash.events.Event;

// ------------------------------------------------------------
// スプライトＡ
// ------------------------------------------------------------
// スプライトを作成
var sprite_a:Sprite = new Sprite();

// ステージにスプライトＡを配置
stage.addChild(sprite_a);


// ------------------------------------------------------------
// スプライトＢ
// ------------------------------------------------------------
// スプライトを作成
var sprite_b:Sprite = new Sprite();

// スプライトＡにスプライトＢを配置
sprite_a.addChild(sprite_b);


// ------------------------------------------------------------
// スプライトＣ
// ------------------------------------------------------------
// スプライトを作成
var sprite_c:Sprite = new Sprite();

// スプライトＢにスプライトＣを配置
sprite_b.addChild(sprite_c);


// ------------------------------------------------------------
// 出力テスト
// ------------------------------------------------------------
// 自身に１つ以上のリスナーが登録済みであるか調べる
trace(sprite_a.hasEventListener(Event.ENTER_FRAME)); // false
trace(sprite_b.hasEventListener(Event.ENTER_FRAME)); // false
trace(sprite_c.hasEventListener(Event.ENTER_FRAME)); // false

// ------------------------------------------------------------
// リッスンを開始
// ------------------------------------------------------------
// スプライトＢにリスナーを登録
sprite_b.addEventListener(Event.ENTER_FRAME,function(e:Event):void {} );

// ------------------------------------------------------------
// 出力テスト
// ------------------------------------------------------------
// 自身に１つ以上のリスナーが登録済みであるか調べる
trace(sprite_a.hasEventListener(Event.ENTER_FRAME)); // false
trace(sprite_b.hasEventListener(Event.ENTER_FRAME)); // true
trace(sprite_c.hasEventListener(Event.ENTER_FRAME)); // false

■ willTrigger() メソッドについて

自身か祖先に１つ以上のリスナーが登録済みであるか調べるには、 willTrigger() メソッドを使用します。

EventDispatcher.willTrigger ("イベント名" ) :Boolean

第01引数	String	イベント名を指定
戻り値	Boolean	自身か祖先に１つ以上のリスナーが登録済みであれば true が得られる

自身か祖先に１つ以上のリスナーが登録済みであるか調べる


import flash.display.Sprite;
import flash.events.Event;

// ------------------------------------------------------------
// スプライトＡ
// ------------------------------------------------------------
// スプライトを作成
var sprite_a:Sprite = new Sprite();

// ステージにスプライトＡを配置
stage.addChild(sprite_a);


// ------------------------------------------------------------
// スプライトＢ
// ------------------------------------------------------------
// スプライトを作成
var sprite_b:Sprite = new Sprite();

// スプライトＡにスプライトＢを配置
sprite_a.addChild(sprite_b);


// ------------------------------------------------------------
// スプライトＣ
// ------------------------------------------------------------
// スプライトを作成
var sprite_c:Sprite = new Sprite();

// スプライトＢにスプライトＣを配置
sprite_b.addChild(sprite_c);


// ------------------------------------------------------------
// 出力テスト
// ------------------------------------------------------------
// 自身か祖先に１つ以上のリスナーが登録済みであるか調べる
trace(sprite_a.willTrigger(Event.ENTER_FRAME)); // false
trace(sprite_b.willTrigger(Event.ENTER_FRAME)); // false
trace(sprite_c.willTrigger(Event.ENTER_FRAME)); // false

// ------------------------------------------------------------
// リッスンを開始
// ------------------------------------------------------------
// スプライトＢにリスナーを登録
sprite_b.addEventListener(Event.ENTER_FRAME,function(e:Event):void {} );

// ------------------------------------------------------------
// 出力テスト
// ------------------------------------------------------------
// 自身か祖先に１つ以上のリスナーが登録済みであるか調べる
trace(sprite_a.willTrigger(Event.ENTER_FRAME)); // false
trace(sprite_b.willTrigger(Event.ENTER_FRAME)); // true
trace(sprite_c.willTrigger(Event.ENTER_FRAME)); // true

上に戻る

イベントの通知を受け取る

■コールバック関数を登録して、イベントの通知を受け取る

■イベントの通知の受け取りを止める

■コールバック関数を登録して、イベントの通知を受け取る

イベントの通知を受け取るには、 addEventListener メソッドを使用します。

EventDispatcher.addEventListener ("イベント名" , コールバック関数 , キャプチャ段階で受け取るか？ , 優先度 , 弱参照を使用するか？ ) :void

第01引数	String	イベント名を指定
第02引数	Function	コールバック関数を指定
第03引数(略可)	Boolean	true の場合、イベントの通知をキャプチャー段階で受け取る。false の場合、ターゲット段階やバブリング段階で受け取る。（デフォルトは false）
第04引数(略可)	int	優先度を指定。値が大きいほど先にイベントの通知を受け取る事ができる。
第05引数(略可)	Boolean	true の場合、弱参照。false の場合、強参照。
戻り値	void	なし

■第01引数イベント名

監視したいイベントの名称を指定します。

ActionScript3.0 では、すべてのイベント名が定数で用意されています。

■第02引数コールバック関数

ディスパッチャーがイベントを発行したときに、実行して欲しいコールバック関数を指定します。

コールバック関数の、第01引数から、Event オブジェクトが得られます。

Event クラスについては、こちらで解説しています。

毎フレーム実行されるイベント


import flash.events.Event;

// 毎フレーム実行される関数
function EventEnterFrameFunc(e:Event) :void{
	trace("実行中");
}

// イベントのリッスンを開始する
stage.addEventListener(Event.ENTER_FRAME,EventEnterFrameFunc);

■第03引数イベントフェーズ

true を指定すると、キャプチャ段階で、イベント通知を受け取ることができます。

false を指定すると、ターゲット段階やバブリング段階で、イベント通知を受け取ることができます。

デフォルトは、false です。

イベントフェーズについては、こちらで解説しています。

イベントの種類によっては、キャプチャ段階やバブリング段階で受け取れない場合があります。

イベントの仕様は、公式リファレンスで確認する事ができます。

キャプチャ段階と、バブリング段階の両方でイベントの通知を受け取りたい場合は、第03引数を変更して、2 回登録します。

マウスボタンをクリックしたか、すべてのフェーズで監視する


import flash.display.Sprite;
import flash.display.Graphics;
import flash.events.MouseEvent;

// ------------------------------------------------------------
// スプライトを作成して配置
// ------------------------------------------------------------
// スプライトを作成
var sprite:Sprite = new Sprite();

// ステージにスプライトを配置
stage.addChild(sprite);

// スプライトに矩形をレンダリング
var g:Graphics;
g = sprite.graphics;
g.lineStyle (5, 0xAA0000, 1.0);
g.beginFill (0xFF4444, 1.0);
g.drawRect (0,0,300,300);


// ------------------------------------------------------------
// マウスボタンをクリックしたときに実行される関数
// ------------------------------------------------------------
function MouseClickFunc(e:MouseEvent):void{
	trace("マウスボタンをクリックした");
	trace("イベントフェーズ:" + e.eventPhase);
	trace("---");
}


// ------------------------------------------------------------
// イベントのリッスンを開始する
// ------------------------------------------------------------
// キャプチャ段階でリッスンする
stage.addEventListener(MouseEvent.CLICK,MouseClickFunc,true );

// ターゲット段階やバブリング段階でリッスンする
stage.addEventListener(MouseEvent.CLICK,MouseClickFunc,false );

■第04引数優先度

優先度を設定します。

指定した値が大きいほど、先にイベントの通知を受け取ることができます。

同じ値の場合、後に登録したリスナーが先にイベントの通知を受け取ることができます。

ディスパッチャーとイベント名とイベントフェーズが、すべて同じである必要があります。

１つでも異なる場合、リスナー同士の優先度は変化しません。

優先度が異なるリスナーを複数登録する


import flash.display.Sprite;
import flash.events.Event;

// ------------------------------------------------------------
// スプライト
// ------------------------------------------------------------
// スプライトを作成
var sprite:Sprite = new Sprite();


// ------------------------------------------------------------
// イベントのリッスンを開始する
// ------------------------------------------------------------
// パラメータ
var listener_param:Array = [
	{ prio:4 , name : "ListenerA" },
	{ prio:0 , name : "ListenerB" },
	{ prio:2 , name : "ListenerC" },
	{ prio:5 , name : "ListenerD" },
	{ prio:1 , name : "ListenerE" }
];

var i:Number;
var num:Number = listener_param.length;
for(i=0;i < num;i++){

	// ------------------------------------------------------------
	// 無名関数内で実行
	// ------------------------------------------------------------
	(function () :void{

		// ローカル変数
		var param:Object = listener_param[i];
		var prio:int = param.prio;
		var name:String = param.name;

		// ------------------------------------------------------------
		// 毎フレーム実行されるイベント
		// ------------------------------------------------------------
		sprite.addEventListener(Event.ENTER_FRAME,function callee(e:Event) :void{

			// 出力テスト
			trace("name:" + name + " prio:" + prio);

			// イベントのリッスンを終了する
			e.currentTarget.removeEventListener(e.type,callee);

		},false,prio);
	})();
}

■第05引数コールバック関数の参照レベル

登録するコールバック関数の、参照レベルを指定します。

true を指定すると、弱参照となります。

false を指定すると、強参照となります。デフォルトは false です。

強参照の場合、ディスパッチャーが生存している限り、リスナーも存在し続けます。

弱参照の場合、ディスパッチャーが生存していたとしても、コールバック関数への参照が絶たれていれば、コールバック関数はガベージコレクションの対象となります。

ガベージコレクションが発生すると、ディスパッチャーに登録しているリスナーは自動的に解除され、コールバック関数は消滅します。

マウスをクリックして、弱参照のイベントリスナーを消滅させる


import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.system.System;

// ------------------------------------------------------------
// スプライト
// ------------------------------------------------------------
// スプライトを作成
var sprite:Sprite = new Sprite();

// ステージに配置（スプライトは生存し続けている）
stage.addChild(sprite);


// ------------------------------------------------------------
// 毎フレーム実行される関数
// ------------------------------------------------------------
var enter_frame_func:Function = function (e:Event) :void{
	trace("イベントリスナーは登録中…");
};

// イベントのリッスンを開始する（弱参照で登録）
sprite.addEventListener(Event.ENTER_FRAME,enter_frame_func,false,0,true);


// ------------------------------------------------------------
// マウスボタンを押したときに実行されるイベント
// ------------------------------------------------------------
stage.addEventListener(MouseEvent.CLICK,function (e:MouseEvent):void{

	// コールバック関数への参照を絶つ
	enter_frame_func = null;

	// ガベージコレクションを実行 （Debug 版プレイヤーか Adobe AIR でのみ動作）
	System.gc();
});

■イベントリスナーの多重登録に注意

第01～03引数の指定がすべて同一である場合、リスナーの登録を試みても２重に登録されることはありません。

第01～03引数の指定に１つでも相違がある場合、リスナーの登録を試みるたびに多重に登録されていきます。

第02引数に、直接無名関数を渡している場合は、新規に関数を生成しているので注意します。

■イベントの通知の受け取りを止める

イベントの通知の受け取りを止めるには、removeEventListener を使用します。

addEventListener メソッドで使用した、第01～03引数と同じパラメータを指定します。

EventDispatcher.removeEventListener ("イベント名" , コールバック関数 , キャプチャ段階で受け取るか？ ) :void

第01引数	String	登録時に指定した、イベント名
第02引数	Function	登録時に指定した、コールバック関数
第03引数(略可)	Boolean	登録時に指定した、イベントフェーズ（デフォルトは false）
戻り値	void	なし

イベントの通知の受け取りを止める


import flash.events.Event;

// ------------------------------------------------------------
// 毎フレーム実行される関数
// ------------------------------------------------------------
function EnterFrameFunc(e:Event) :void{
	trace("イベントリスナーは登録中…");
}

// ------------------------------------------------------------
// イベントのリッスンを開始する
// ------------------------------------------------------------
stage.addEventListener(Event.ENTER_FRAME ,EnterFrameFunc);

// ------------------------------------------------------------
// イベントのリッスンを終了する
// ------------------------------------------------------------
stage.removeEventListener(Event.ENTER_FRAME ,EnterFrameFunc);

■無名関数を使ったイベントリスナーの登録を解除する

無名関数を使ったイベントリスナーの登録を解除するには、無名関数内でリムーブ処理を行う必要があります。

関数内から、自身の関数への参照を取得する為には、必ず関数名を記述します。

関数リテラルで指定した関数名は、関数リテラル内でのみ利用可能です。

arguments.callee プロパティから、自身の関数を取得する事もできます。

関数リテラルを使ったイベントのリッスンを終了する


import flash.events.Event;

// ------------------------------------------------------------
// 毎フレーム実行されるイベント
// ------------------------------------------------------------
stage.addEventListener(Event.ENTER_FRAME ,function callee(e:Event) :void{

	trace("イベントリスナーは登録中…");

	// イベントのリッスンを終了する
	stage.removeEventListener(Event.ENTER_FRAME , callee);
});

イベント名を取得するには、type プロパティを使用します。

イベントリスナー登録時に指定した、ディスパッチャーを取得するには、currentTarget プロパティを使用します。

イベントフェーズの取得はできないので、第03引数を指定している場合は注意します。

汎用的な記述方法で、イベントのリッスンを終了する


import flash.events.Event;

// ------------------------------------------------------------
// 毎フレーム実行されるイベント
// ------------------------------------------------------------
stage.addEventListener(Event.ENTER_FRAME ,function callee(e:Event) :void{

	trace("イベントリスナーは登録中…");

	// イベントのリッスンを終了する（第03引数に注意）
	e.currentTarget.removeEventListener(e.type , callee);
});

■イベントリスナーからの参照について

ディスパッチャーへの参照が絶たれた場合、イベントリスナーを登録したままの状態であっても、ガベージコレクションが発生するとディスパッチャーは消滅します。

ディスパッチャーが消滅すると、イベントリスナーの登録は、自動的に解除されます。

マウスをクリックして、リスナーを登録したままディスパッチャーを消滅させる


import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.system.System;

// ------------------------------------------------------------
// スプライト
// ------------------------------------------------------------
// スプライトを作成
var sprite:Sprite = new Sprite();

// ステージに配置（表示リストに登録されていれば、スプライトは生存し続ける）
stage.addChild(sprite);


// ------------------------------------------------------------
// 毎フレーム実行されるイベント
// ------------------------------------------------------------
sprite.addEventListener(Event.ENTER_FRAME,function (e:Event) :void{
	trace("イベントリスナーは登録中…");
});


// ------------------------------------------------------------
// マウスボタンを押したときに実行されるイベント
// ------------------------------------------------------------
stage.addEventListener(MouseEvent.CLICK,function (e:MouseEvent):void{

	// スプライトへの参照を絶つ
	stage.removeChild(sprite);
	sprite = null;

	// ガベージコレクションを実行 （Debug 版プレイヤーか Adobe AIR でのみ動作）
	System.gc();
});

上に戻る

イベントを発行する

■イベントを発行する

■イベントを実装する

■イベントディスパッチャーを実装する

■イベントを発行する

イベントディスパッチャーから、イベントを発行するには、dispatchEvent() メソッドを使用します。

EventDispatcher.dispatchEvent ( Event ) :Boolean

第01引数	Event	イベントオブジェクトを指定
戻り値	Boolean	true の場合送出に成功。イベントの伝達を中止した場合も true。 false の場合送出に失敗。リスナーがキャンセルを要求した場合も false。

イベントの実装については、こちらで解説しています。

イベントディスパッチャーの実装については、こちらで解説しています。

■既存イベントの発行について

既存イベントを発行して、システムを制御する事はできません。

例えば、Event.RESIZE イベントを発行して、実際に FlashPlayer をリサイズできるわけではありません。

例えば、MouseEvent.MOUSE_MOVE イベントを発行して、OS のマウスカーソルを移動できるわけではありません。

イベントを発行すると、任意の EventDispatcher に登録したコールバック関数が実行されるだけです。

■使用例

Event.RESIZE イベントを手動的に発行する


import flash.events.Event;

// ------------------------------------------------------------
// リサイズ時に実行されるイベント
// ------------------------------------------------------------
stage.addEventListener(Event.RESIZE,function (e:Event) :void{
	trace("イベントの通知を受け取った");
});


// ------------------------------------------------------------
// イベントオブジェクト
// ------------------------------------------------------------
// 基本イベントオブジェクトを作成
var event:Event = new Event(Event.RESIZE);


// ------------------------------------------------------------
// ステージのディスパッチャーから送出
// ------------------------------------------------------------
stage.dispatchEvent(event);

MouseEvent.CLICK イベントを手動的に発行する


import flash.events.MouseEvent;

// ------------------------------------------------------------
// マウスボタンをクリックしたときに実行されるイベント
// ------------------------------------------------------------
stage.addEventListener(MouseEvent.CLICK,function (e:MouseEvent) :void{
	trace("イベントの通知を受け取った");
});


// ------------------------------------------------------------
// イベントオブジェクト
// ------------------------------------------------------------
// マウスイベントオブジェクトを作成
var mouse_event:MouseEvent = new MouseEvent(MouseEvent.CLICK);

// マウスイベントに関する情報を設定（一部抜粋）
mouse_event.localX = 123;
mouse_event.localY = 456;
mouse_event.buttonDown = true;
mouse_event.ctrlKey = false;


// ------------------------------------------------------------
// ステージのディスパッチャーから送出
// ------------------------------------------------------------
stage.dispatchEvent(mouse_event);

■イベントを実装する

■イベントオブジェクトを作成する

イベントオブジェクトを作成するには、Event クラスを使用します。

new 演算子を使って、Event クラスをインスタンス化します。

new Event ( "イベント名" , バブリングイベントに対応するか？ , キャンセルに対応するか？ ) :Event

第01引数	String	イベント名を指定
第02引数(略可)	Boolean	バブリングイベントに対応する場合 true を指定（デフォルトは、false）
第03引数(略可)	Boolean	キャンセルに対応する場合、true を指定（デフォルトは、false）
戻り値	Event	Event オブジェクト

■第01引数イベント名

発行したいイベント名を指定します。

カスタムイベント "myCustomEvent" を発行する例です。

カスタムイベントを発行する


import flash.events.Event;

// カスタムイベントをリッスンする
stage.addEventListener("myCustomEvent",function (e:Event) :void{
	trace("イベントの通知を受け取った");
});

// イベントオブジェクトを作成
var event:Event = new Event("myCustomEvent");

// ステージのディスパッチャーから送出
stage.dispatchEvent(event);

■第02引数バブリングイベントの対応

バブリングイベントに対応する場合、true を指定します。

デフォルトは、false です。

バブリングイベントについては、こちらで解説しています。

バブリングイベントの流れを確認する


import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.MouseEvent;


// ------------------------------------------------------------
// スプライトＡ
// ------------------------------------------------------------
// スプライトを作成
var sprite_a:Sprite = new Sprite();
sprite_a.name = "スプライトＡ";

// ステージにスプライトＡを配置
stage.addChild(sprite_a);


// ------------------------------------------------------------
// スプライトＢ
// ------------------------------------------------------------
// スプライトを作成
var sprite_b:Sprite = new Sprite();
sprite_b.name = "スプライトＢ";

// スプライトＡにスプライトＢを配置
sprite_a.addChild(sprite_b);


// ------------------------------------------------------------
// スプライトＣ
// ------------------------------------------------------------
// スプライトを作成
var sprite_c:Sprite = new Sprite();
sprite_c.name = "スプライトＣ";

// スプライトＢにスプライトＣを配置
sprite_b.addChild(sprite_c);


// ------------------------------------------------------------
// マウスボタンをクリックしたときに実行される関数
// ------------------------------------------------------------
function MouseClickFunc(e:MouseEvent):void{
	var current:DisplayObject = e.currentTarget as DisplayObject;
	trace("カレント:" + current + "(" + current.name + ")");
	trace("イベントフェーズ:" + e.eventPhase);
	trace("---");
}


// ------------------------------------------------------------
// すべてのフェーズでリッスンを開始
// ------------------------------------------------------------
stage.addEventListener(MouseEvent.CLICK,MouseClickFunc,true );
stage.addEventListener(MouseEvent.CLICK,MouseClickFunc,false );
sprite_a.addEventListener(MouseEvent.CLICK,MouseClickFunc,true );
sprite_a.addEventListener(MouseEvent.CLICK,MouseClickFunc,false );
sprite_b.addEventListener(MouseEvent.CLICK,MouseClickFunc,true );
sprite_b.addEventListener(MouseEvent.CLICK,MouseClickFunc,false );
sprite_c.addEventListener(MouseEvent.CLICK,MouseClickFunc,true );
sprite_c.addEventListener(MouseEvent.CLICK,MouseClickFunc,false );


// ------------------------------------------------------------
// マウスイベント
// ------------------------------------------------------------
// マウスイベントオブジェクトを作成（バブリングイベントに対応する）
var mouse_event:MouseEvent = new MouseEvent(MouseEvent.CLICK,true);


// ------------------------------------------------------------
// スプライトＣのディスパッチャーから送出
// ------------------------------------------------------------
sprite_c.dispatchEvent(mouse_event);

■第03引数キャンセルの対応

キャンセルに対応する場合、true を指定します。

デフォルトは、false です。

イベントリスナー側のキャンセルについては、こちらで解説しています。

キャンセルの流れを確認する


import flash.text.TextField;
import flash.events.TextEvent;

// ------------------------------------------------------------
// テキストフィールド
// ------------------------------------------------------------
// テキストフィールドオブジェクトを作成する
var text_field:TextField = new TextField();

// ステージに配置
stage.addChild(text_field);

// テキスト入力時に呼び出されるイベント
text_field.addEventListener(TextEvent.TEXT_INPUT ,function (e:TextEvent):void{

	// キャンセルに対応している
	if(e.cancelable){

		// デフォルトの動作をキャンセル
		e.preventDefault();

	}
});


// ------------------------------------------------------------
// テキストイベント
// ------------------------------------------------------------
// テキストイベントオブジェクトを作成（キャンセルに対応する）
var text_event:TextEvent = new TextEvent(TextEvent.TEXT_INPUT,false,true);

// 変更予定の文字列
text_event.text = "表示テスト";


// ------------------------------------------------------------
// テキストフィールドのディスパッチャーから送出
// ------------------------------------------------------------
var result:Boolean = text_field.dispatchEvent(text_event);
if(result){
	text_field.text = text_event.text;
}else{
	trace("リスナーがキャンセルした:" + text_event.isDefaultPrevented());
}

■イベントの派生クラスを作成する

イベントの種類によっては、独自のプロパティを持たせたい場合があります。

Event クラスを拡張するには、Event の派生クラスを作成します。

Event クラスを継承した、MyEvent クラスの作成例です。

Event を継承した MyEvent クラス


package  {
	import flash.events.Event;

	// Event を継承したクラス
	public class MyEvent extends Event {

		// パブリックなプロパティ
	   	public var myWork:Object;

		// コンストラクタ
		public function MyEvent(type:String, bubbles:Boolean = false, cancelable:Boolean = false) {

			// 親のコンストラクタを実行
			super(type,bubbles,cancelable);

		}
	}
}

派生イベントクラスを使ってカスタムイベントを発行する


import flash.events.Event;

// ------------------------------------------------------------
// カスタムイベントをリッスンする
// ------------------------------------------------------------
stage.addEventListener("myCustomEvent",function (e:MyEvent) :void{
	trace("イベントの通知を受け取った");
	trace(e.myWork);
});


// ------------------------------------------------------------
// 派生イベント
// ------------------------------------------------------------
// 派生イベントオブジェクトを作成
var event:MyEvent = new MyEvent("myCustomEvent");

// 派生イベントオブジェクトにデータをセット
event.myWork = "テスト";


// ------------------------------------------------------------
// ステージのディスパッチャーから送出
// ------------------------------------------------------------
stage.dispatchEvent(event);

■イベントディスパッチャーを実装する

イベント駆動の仕組みを、自ら供給するには、EventDispatcher クラスを使用します。

■イベントディスパッチャーオブジェクトを作成する

new 演算子を使って、EventDispatcher クラスをインスタンス化します。

この方法は、あまり使うことは無さそうです。

イベントディスパッチャーオブジェクトを作成し、イベントを送出する


import flash.events.Event;
import flash.events.EventDispatcher;

// ------------------------------------------------------------
// イベントディスパッチャー
// ------------------------------------------------------------
// イベントディスパッチャーオブジェクトを作成する
var event_dispatcher:EventDispatcher = new EventDispatcher();

// カスタムイベントをリッスンする
event_dispatcher.addEventListener("myCustomEvent",function (e:Event) :void{
	trace("イベントの通知を受け取った");
});


// ------------------------------------------------------------
// イベントオブジェクト
// ------------------------------------------------------------
// イベントオブジェクトを作成
var event:Event = new Event("myCustomEvent");


// ------------------------------------------------------------
// イベントディスパッチャーから送出
// ------------------------------------------------------------
event_dispatcher.dispatchEvent(event);

■EventDispatcher のクラスを継承する

自前のクラスに、EventDispatcher の機能を内包するには、EventDispatcher クラスを継承します。

EventDispatcher クラスを継承した、MyEventDispatcher クラスの作成例です。

EventDispatcher を継承した MyEventDispatcher クラス


package  {
	import flash.events.EventDispatcher;
	import flash.events.IEventDispatcher;

	// EventDispatcher を継承したクラス
	public class MyEventDispatcher extends EventDispatcher {

		// コンストラクタ
		public function MyEventDispatcher(target:IEventDispatcher = null) {

			// 親のコンストラクタを実行
			super(target);

		}
	}
}

派生イベントディスパッチャーオブジェクトを作成し、イベントを送出する


import flash.events.Event;
import flash.events.EventDispatcher;

// ------------------------------------------------------------
// 派生イベントディスパッチャー
// ------------------------------------------------------------
// 派生イベントディスパッチャーオブジェクトを作成する
var event_dispatcher:MyEventDispatcher = new MyEventDispatcher();

// カスタムイベントをリッスンする
event_dispatcher.addEventListener("myCustomEvent",function (e:Event) :void{
	trace("イベントの通知を受け取った");
});


// ------------------------------------------------------------
// イベントオブジェクト
// ------------------------------------------------------------
// イベントオブジェクトを作成
var event:Event = new Event("myCustomEvent");


// ------------------------------------------------------------
// イベントディスパッチャーから送出
// ------------------------------------------------------------
event_dispatcher.dispatchEvent(event);

■IEventDispatcher インターフェースを実装する

EventDispatcher クラスを継承できない場合、IEventDispatcher インターフェースを実装します。

IEventDispatcher インターフェースを実装した、MyClass クラスの作成例です。

IEventDispatcher インターフェースを実装した MyClass クラス


package  {
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.IEventDispatcher;

	// IEventDispatcher インターフェースを実装したクラス
	public class MyClass implements IEventDispatcher {

		private var event_dispatcher:EventDispatcher;

		// コンストラクタ
		public function MyClass() {

			// イベントディスパッチャーオブジェクトを作成
			event_dispatcher = new EventDispatcher(this);
		}

		// ------------------------------------------------------------
		// IEventDispatcher インターフェース
		// ------------------------------------------------------------
		public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void {
			event_dispatcher.addEventListener(type,listener,useCapture,priority,useWeakReference);
		}
		public function removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void {
			event_dispatcher.removeEventListener(type,listener,useCapture);
		}
		public function dispatchEvent(event:Event):Boolean {
			return event_dispatcher.dispatchEvent(event);
		}
		public function hasEventListener(type:String):Boolean {
			return event_dispatcher.hasEventListener(type);
		}
		public function willTrigger(type:String):Boolean {
			return event_dispatcher.willTrigger(type);
		}
	}
}

派生イベントディスパッチャーオブジェクトを作成し、イベントを送出する


import flash.events.Event;
import flash.events.EventDispatcher;

// ------------------------------------------------------------
// 派生イベントディスパッチャー
// ------------------------------------------------------------
// 派生イベントディスパッチャーオブジェクトを作成する
var event_dispatcher:MyClass = new MyClass();

// カスタムイベントをリッスンする
event_dispatcher.addEventListener("myCustomEvent",function (e:Event) :void{
	trace("イベントの通知を受け取った");
});


// ------------------------------------------------------------
// イベントオブジェクト
// ------------------------------------------------------------
// イベントオブジェクトを作成
var event:Event = new Event("myCustomEvent");


// ------------------------------------------------------------
// イベントディスパッチャーから送出
// ------------------------------------------------------------
event_dispatcher.dispatchEvent(event);

上に戻る

コールバック関数にデータを渡す

■クロージャを使ってデータを渡す

■派生クラスを使ってデータを渡す

■Dictionary を使ってデータを渡す

■コールバック関数にデータを渡す

■クロージャとは？

クロージャについては、こちらで解説しています。

■クロージャを使ってデータを渡す

クロージャを使うと、イベントリスナーごとに隠匿性のある環境を構築することができます。

外部から渡したいデータや作業用の領域は、すべてローカル変数として用意すればいいので、外側の環境が汚染しません。

無名関数を使って、イベントごとに小規模な環境を動的に構築する


import flash.display.Sprite;
import flash.display.Graphics;
import flash.events.MouseEvent;

// スプライト用のパラメータ
var sprite_param:Array = [
	{ name : "SpriteA" },
	{ name : "SpriteB" },
	{ name : "SpriteC" },
	{ name : "SpriteD" },
	{ name : "SpriteE" }
];

var i:Number;
var num:Number = sprite_param.length;

for(i=0;i < num;i++){

	// ------------------------------------------------------------
	// スプライト
	// ------------------------------------------------------------
	// スプライトを作成
	var sprite:Sprite = new Sprite();

	// スプライトに矩形をレンダリング
	var g:Graphics;
	g = sprite.graphics;
	g.lineStyle (5, 0xAA0000, 1.0);
	g.beginFill (0xFF4444, 1.0);
	g.drawRect (-50,-50,100,100);

	// ステージにスプライトを表示する
	stage.addChild(sprite);

	// ランダムに配置
	sprite.x = Math.random() * stage.stageWidth;
	sprite.y = Math.random() * stage.stageHeight;


	// ------------------------------------------------------------
	// 無名関数内で実行（リスナーごとにアクセスできる小規模な環境）
	// ------------------------------------------------------------
	(function () :void{

		// ローカル変数（外部から渡したいデータがあればローカル変数に格納しておく）
		var param:Object = sprite_param[i];
		var name:String = param.name;
		var count:int = 0;

		// マウスボタンをクリックしたときに実行されるイベント
		sprite.addEventListener(MouseEvent.CLICK,function (e:MouseEvent) :void{

			// 出力テスト
			trace("name:" + name + " count:" + count);

			// カウンタを更新
			count ++;

		});
	})();
}

■派生クラスを使ってデータを渡す

■派生クラスを作成する

イベントを利用したいクラス（EventDispatcher を継承しているクラス）の、派生クラスを作成します。

外部からデータを渡すための、パブリックなプロパティを追加します。

Sprite クラスを継承した、MySprite クラスの作成例です。

パブリックなプロパティ myWork を追加しています。

Sprite クラスを継承した MySprite クラスを用意する


package  {
	import flash.display.Sprite;

	// Sprite を継承したクラス
	public class MySprite extends Sprite {

		// パブリックなプロパティ
	   	public var myWork:Object;

		// コンストラクタ
		public function MySprite() {
			super();
		}
	}
}

■使用例

派生スプライトにデータをセットし、リスナーから取り出す


import flash.display.Sprite;
import flash.display.Graphics;
import flash.events.MouseEvent;

// スプライト用のパラメータ
var sprite_param:Array = [
	{ name : "SpriteA" },
	{ name : "SpriteB" },
	{ name : "SpriteC" },
	{ name : "SpriteD" },
	{ name : "SpriteE" }
];

var i:Number;
var num:Number = sprite_param.length;

for(i=0;i < num;i++){

	// ------------------------------------------------------------
	// 派生スプライト
	// ------------------------------------------------------------
	// 派生スプライトを作成
	var sprite:MySprite = new MySprite();

	// スプライトに矩形をレンダリング
	var g:Graphics;
	g = sprite.graphics;
	g.lineStyle (5, 0xAA0000, 1.0);
	g.beginFill (0xFF4444, 1.0);
	g.drawRect (-50,-50,100,100);

	// ステージにスプライトを表示する
	stage.addChild(sprite);

	// ランダムに配置
	sprite.x = Math.random() * stage.stageWidth;
	sprite.y = Math.random() * stage.stageHeight;


	// ------------------------------------------------------------
	// 外部から渡したいデータをパブリックな変数にセット
	// ------------------------------------------------------------
	if(!sprite.myWork){
		sprite.myWork = sprite_param[i];
	}


	// ------------------------------------------------------------
	// マウスボタンをクリックしたときに実行されるイベント
	// ------------------------------------------------------------
	sprite.addEventListener(MouseEvent.CLICK,function (e:MouseEvent) :void{

		// 派生スプライトを取得
		var sprite:MySprite = e.currentTarget as MySprite;

		// 外部から渡されたデータを取得
		var param:Object = sprite.myWork;

		// 出力テスト
		trace("name:" + param.name);
	});

}

■Dictionary を使ってデータを渡す

■Dictionary クラスについて

Dictionary クラスについては、こちらで解説しています。

引数に true を指定して、弱参照で作成します。

キーとして使用した EventDispatcher オブジェクトが消滅すると、プロパティも自動的に消滅します。

■使用例

辞書にデータをセットし、リスナーから取り出す


import flash.display.Sprite;
import flash.display.Graphics;
import flash.utils.Dictionary;
import flash.events.MouseEvent;

// 辞書を作成
var dictionary:Dictionary = new Dictionary(true);

// スプライト用のパラメータ
var sprite_param:Array = [
	{ name : "SpriteA" },
	{ name : "SpriteB" },
	{ name : "SpriteC" },
	{ name : "SpriteD" },
	{ name : "SpriteE" }
];

var i:Number;
var num:Number = sprite_param.length;

for(i=0;i < num;i++){

	// ------------------------------------------------------------
	// スプライト
	// ------------------------------------------------------------
	// スプライトを作成
	var sprite:Sprite = new Sprite();

	// スプライトに矩形をレンダリング
	var g:Graphics;
	g = sprite.graphics;
	g.lineStyle (5, 0xAA0000, 1.0);
	g.beginFill (0xFF4444, 1.0);
	g.drawRect (-50,-50,100,100);

	// ステージにスプライトを表示する
	stage.addChild(sprite);

	// ランダムに配置
	sprite.x = Math.random() * stage.stageWidth;
	sprite.y = Math.random() * stage.stageHeight;


	// ------------------------------------------------------------
	// 外部から渡したいデータを辞書にセット
	// ------------------------------------------------------------
	if(!dictionary[sprite]){
		dictionary[sprite] = {
			name:sprite_param[i].name,
			count:0
		};
	}


	// ------------------------------------------------------------
	// マウスボタンをクリックしたときに実行されるイベント
	// ------------------------------------------------------------
	sprite.addEventListener(MouseEvent.CLICK,function (e:MouseEvent) :void{

		// スプライトを取得
		var sprite:Sprite = e.currentTarget as Sprite;

		// 辞書からデータを取得
		var param:Object = dictionary[sprite];

		// 出力テスト
		trace("name:" + param.name + " count:" + param.count);

		param.count += 1;
	});

}

上に戻る

前のページに戻る