@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/events/MouseEvent.ts

@@ -0,0 +1,279 @@
+import { MouseButtons, MouseEvent as MouseEventAway } from '@awayjs/scene';
+import { Event } from './Event';
+import { notImplemented } from '@awayfl/swf-loader';
+import { InteractiveObject } from '../display/InteractiveObject';
+import { Point } from '../geom/Point';
+import { DisplayObject } from '../display/DisplayObject';
+import { SecurityDomain } from '../SecurityDomain';
+
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: MouseEvent
+export class MouseEvent extends Event {
+
+	static classInitializer: any = null;
+
+	static classSymbols: string [] = null;
+	static instanceSymbols: string [] = null;
+
+	constructor(type: string, bubbles: boolean = true, cancelable: boolean = false,
+		localX: number = undefined, localY: number = undefined,
+		relatedObject: InteractiveObject = null, ctrlKey: boolean = false,
+		altKey: boolean = false, shiftKey: boolean = false, buttonDown: boolean = false,
+		delta: number /*int*/ = 0) {
+		super(type, bubbles, cancelable);
+		this._localX = localX;
+		this._localY = localY;
+		this._relatedObject = relatedObject;
+		this._ctrlKey = ctrlKey;
+		this._altKey = altKey;
+		this._shiftKey = shiftKey;
+		this._buttonDown = buttonDown;
+		this._delta = delta;
+	}
+
+	// JS -> AS Bindings
+	static CLICK: string = 'click';
+	static DOUBLE_CLICK: string = 'doubleClick';
+	static MOUSE_DOWN: string = 'mouseDown';
+	static MOUSE_MOVE: string = 'mouseMove';
+	static MOUSE_OUT: string = 'mouseOut';
+	static MOUSE_OVER: string = 'mouseOver';
+	static MOUSE_UP: string = 'mouseUp';
+	static RELEASE_OUTSIDE: string = 'releaseOutside';
+	static MOUSE_WHEEL: string = 'mouseWheel';
+	static ROLL_OUT: string = 'rollOut';
+	static ROLL_OVER: string = 'rollOver';
+	static MIDDLE_CLICK: string = 'middleClick';
+	static MIDDLE_MOUSE_DOWN: string = 'middleMouseDown';
+	static MIDDLE_MOUSE_UP: string = 'middleMouseUp';
+	static RIGHT_CLICK: string = 'rightClick';
+	static RIGHT_MOUSE_DOWN: string = 'rightMouseDown';
+	static RIGHT_MOUSE_UP: string = 'rightMouseUp';
+	static CONTEXT_MENU: string = 'contextMenu';
+
+	/**
+   * AS3 mouse event names don't match DOM even names, so map them here.
+   */
+	static typeFromDOMType(name: string): string {
+		switch (name) {
+			case 'click':
+				return MouseEvent.CLICK;
+			case 'dblclick':
+				return MouseEvent.DOUBLE_CLICK;
+			case 'mousedown':
+				return MouseEvent.MOUSE_DOWN;
+			case 'mouseout':
+			case 'mouseover':
+			case 'mousemove':
+				return MouseEvent.MOUSE_MOVE;
+			case 'mouseup':
+				return MouseEvent.MOUSE_UP;
+			default:
+				notImplemented(name);
+        // return MouseEvent.RELEASE_OUTSIDE;
+        // return MouseEvent.MOUSE_WHEEL;
+        // return MouseEvent.ROLL_OUT;
+        // return MouseEvent.ROLL_OVER;
+        // return MouseEvent.MIDDLE_CLICK;
+        // return MouseEvent.MIDDLE_MOUSE_DOWN;
+        // return MouseEvent.MIDDLE_MOUSE_UP;
+        // return MouseEvent.RIGHT_CLICK;
+        // return MouseEvent.RIGHT_MOUSE_DOWN;
+        // return MouseEvent.RIGHT_MOUSE_UP;
+        // return MouseEvent.CONTEXT_MENU;
+		}
+	}
+
+	/* added to clone events from away to as3web. */
+	public fillFromAway (awayEvent: MouseEventAway) {
+		//console.log("cloneFromAway not implemented yet in flash/MouseEvent");
+
+		this.adaptee = awayEvent;
+
+		this.target = awayEvent.target.adapter || (<SecurityDomain> this.sec).flash.display.DisplayObject.axClass._activeStage;
+		this.currentTarget = awayEvent.currentTarget.adapter || (<SecurityDomain> this.sec).flash.display.DisplayObject.axClass._activeStage;
+
+		this.delta = awayEvent.delta;
+
+		this.ctrlKey = awayEvent.ctrlKey;
+		this.shiftKey = awayEvent.shiftKey;
+
+		this.buttonDown = Boolean(awayEvent.buttons & MouseButtons.PRIMARY_BUTTON);
+
+		//this._stageX = awayEvent.screenX;
+		//this._stageY = awayEvent.screenY;
+
+		//todo: translate more stuff from awayjs to as3
+
+		//result.screenX = this.screenX;
+		//result.screenY = this.screenY;
+		/*
+		result.view = awayEvent.view;
+		result.entity = awayEvent.entity;
+		result.renderable = awayEvent.renderable;
+		result.material = awayEvent.material;
+		result.uv = awayEvent.uv;
+		result.position = awayEvent.position;
+		result.normal = awayEvent.normal;
+		result.elementIndex = awayEvent.elementIndex;
+*/
+		//result._iParentEvent = awayEvent;
+		//result._iAllowedToPropagate = awayEvent._iAllowedToPropagate;
+
+	}
+
+	// AS -> JS Bindings
+	private _localX: number;
+	private _localY: number;
+	private _movementX: number;
+	private _movementY: number;
+	private _delta: number;
+	private _position: Point;
+
+	private _ctrlKey: boolean;
+	private _altKey: boolean;
+	private _shiftKey: boolean;
+
+	private _buttonDown: boolean;
+	private adaptee: MouseEventAway;
+
+	private _relatedObject: InteractiveObject;
+	private _isRelatedObjectInaccessible: boolean;
+
+	get localX(): number {
+		return (this._localX / 20) | 0;
+	}
+
+	set localX(value: number) {
+		this._localX = (value * 20) | 0;
+	}
+
+	get localY(): number {
+		return (this._localY / 20) | 0;
+	}
+
+	set localY(value: number) {
+		this._localY = (value * 20) | 0;
+	}
+
+	public get stageX(): Number {
+		if (isNaN(this.localX + this.localY)) {
+			return Number.NaN;
+		}
+
+		return (<DisplayObject> this.target).stage.mouseX;
+	}
+
+	public get stageY(): Number {
+		if (isNaN(this.localX + this.localY)) {
+			return Number.NaN;
+		}
+
+		return (<DisplayObject> this.target).stage.mouseY;
+	}
+
+	get movementX(): number {
+		return this._movementX || 0;
+	}
+
+	set movementX(value: number) {
+		this._movementX = +value;
+	}
+
+	get movementY(): number {
+		return this._movementY || 0;
+	}
+
+	set movementY(value: number) {
+		this._movementY = +value;
+	}
+
+	public get delta(): number {
+		return this._delta;
+	}
+
+	public set delta(value: number) {
+		this._delta = value;
+	}
+
+	public get ctrlKey(): boolean {
+		return this._ctrlKey;
+	}
+
+	public set ctrlKey(value: boolean) {
+		this._ctrlKey = value;
+	}
+
+	public get altKey(): boolean {
+		return this._altKey;
+	}
+
+	public set altKey(value: boolean) {
+		this._altKey = value;
+	}
+
+	public get shiftKey(): boolean {
+		return this._shiftKey;
+	}
+
+	public set shiftKey(value: boolean) {
+		this._shiftKey = value;
+	}
+
+	public get buttonDown(): boolean {
+		return this._buttonDown;
+	}
+
+	public set buttonDown(value: boolean) {
+		this._buttonDown = value;
+	}
+
+	public get relatedObject(): InteractiveObject {
+		return this._relatedObject;
+	}
+
+	public set relatedObject(value: InteractiveObject) {
+		this._relatedObject = value;
+	}
+
+	public get isRelatedObjectInaccessible(): boolean {
+		return this._isRelatedObjectInaccessible;
+	}
+
+	public set isRelatedObjectInaccessible(value: boolean) {
+		this._isRelatedObjectInaccessible = value;
+	}
+
+	updateAfterEvent(): void {
+		this.sec.player.requestRender();
+	}
+
+	clone(): Event {
+		return new MouseEvent(this.type, this.bubbles,
+			this.cancelable,
+			this.localX, this.localY,
+			this.relatedObject, this.ctrlKey,
+			this.altKey, this.shiftKey,
+			this.buttonDown, this.delta);
+	}
+
+	toString(): string {
+		return this.formatToString('MouseEvent', 'type', 'bubbles', 'cancelable', 'eventPhase',
+			'localX', 'localY', 'relatedObject', 'ctrlKey', 'altKey',
+			'shiftKey', 'buttonDown', 'delta');
+	}
+}

package/lib/events/NetDataEvent.ts

@@ -0,0 +1,22 @@
+import { Event } from './Event';
+import { ASObject } from '@awayfl/avm2';
+export class NetDataEvent extends Event {
+
+	static classInitializer: any = null;
+
+	static classSymbols: string [] = null;
+	static instanceSymbols: string [] = null;
+
+	timestamp: number;
+	info: ASObject;
+
+	constructor(type: string, bubbles: boolean = false, cancelable: boolean = false,
+		timestamp: number = 0, info: ASObject = null) {
+		super(type, bubbles, cancelable);
+		this.timestamp = +timestamp;
+		this.info = info;
+	}
+
+	// JS -> AS Bindings
+	static MEDIA_TYPE_DATA: string = 'mediaTypeData';
+}

package/lib/events/NetFilterEvent.ts

@@ -0,0 +1,20 @@
+import { ByteArray } from '@awayfl/avm2';
+import { Event } from './Event';
+export class NetFilterEvent extends Event {
+
+	static classInitializer: any = null;
+
+	static classSymbols: string [] = null;
+	static instanceSymbols: string [] = null;
+
+	header: ByteArray;
+	data: ByteArray;
+
+	constructor(type: string, bubbles: boolean = false, cancelable: boolean = false,
+		header: ByteArray = null, data: ByteArray = null) {
+		super(type, bubbles, cancelable);
+		// TODO: coerce
+		this.header = header;
+		this.data = data;
+	}
+}

package/lib/events/NetMonitorEvent.ts

@@ -0,0 +1,20 @@
+import { Event } from './Event';
+export class NetMonitorEvent extends Event {
+
+	static classInitializer: any = null;
+
+	static classSymbols: string [] = null;
+	static instanceSymbols: string [] = null;
+
+	netStream: NetStream;
+
+	constructor(type: string, bubbles: boolean = false, cancelable: boolean = false,
+		netStream: NetStream = null) {
+		super(type, bubbles, cancelable);
+		// TODO: coerce
+		this.netStream = netStream;
+	}
+
+	// JS -> AS Bindings
+	static NET_STREAM_CREATE: string = 'netStreamCreate';
+}

package/lib/events/NetStatusEvent.ts

@@ -0,0 +1,53 @@
+import { Event } from './Event';
+
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: NetStatusEvent
+export class NetStatusEvent extends Event {
+
+	static classInitializer: any = null;
+
+	static classSymbols: string [] = null;
+	static instanceSymbols: string [] = null;
+
+	constructor(type: string, bubbles: boolean = false, cancelable: boolean = false,
+		info: Object = null) {
+		super(type, bubbles, cancelable);
+		this._info = info;
+	}
+
+	private _info: Object;
+
+	get info(): Object {
+		return this._info;
+	}
+
+	set info(value: Object) {
+		this._info = value;
+	}
+
+	// JS -> AS Bindings
+	public static NET_STATUS: string = 'netStatus';
+
+	clone(): Event {
+		return new NetStatusEvent(this.type, this.bubbles,
+			this.cancelable, this.info);
+	}
+
+	toString(): string {
+		return this.formatToString('NetStatusEvent', 'type', 'bubbles', 'cancelable', 'eventPhase', 'info');
+	}
+}

package/lib/events/OutputProgressEvent.ts

@@ -0,0 +1,20 @@
+import { Event } from './Event';
+export class OutputProgressEvent extends Event {
+
+	static classInitializer: any = null;
+
+	static classSymbols: string [] = null;
+	static instanceSymbols: string [] = null;
+	bytesPending: number;
+	bytesTotal: number;
+
+	constructor(type: string, bubbles: boolean = false, cancelable: boolean = false,
+		bytesPending: number = 0, bytesTotal: number = 0) {
+		super(type, bubbles, cancelable);
+		this.bytesPending = +bytesPending;
+		this.bytesTotal = +bytesTotal;
+	}
+
+	// JS -> AS Bindings
+	static OUTPUT_PROGRESS: string = 'outputProgress';
+}

package/lib/events/PressAndTapGestureEvent.ts

@@ -0,0 +1,24 @@
+import { GestureEvent } from './GestureEvent';
+
+export class PressAndTapGestureEvent extends GestureEvent {
+
+	static classInitializer: any = null;
+
+	static classSymbols: string [] = null;
+	static instanceSymbols: string [] = null;
+
+	tapLocalX: number;
+	tapLocalY: number;
+
+	constructor(type: string, bubbles: boolean = true, cancelable: boolean = false,
+		phase: string = null, localX: number = 0, localY: number = 0, tapLocalX: number = 0,
+		tapLocalY: number = 0, ctrlKey: boolean = false, altKey: boolean = false,
+		shiftKey: boolean = false) {
+		super(type, bubbles, cancelable, phase, localX, localY, ctrlKey, altKey, shiftKey);
+		this.tapLocalX = +tapLocalX;
+		this.tapLocalY = +tapLocalY;
+	}
+
+	// JS -> AS Bindings
+	static GESTURE_PRESS_AND_TAP: string = 'gesturePressAndTap';
+}

package/lib/events/ProgressEvent.ts

@@ -0,0 +1,66 @@
+import { Event } from './Event';
+
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Class: ProgressEvent
+export class ProgressEvent extends Event {
+
+	static classInitializer: any = null;
+
+	static classSymbols: string [] = null;
+	static instanceSymbols: string [] = null;
+
+	constructor(type: string, bubbles: boolean = false, cancelable: boolean = false,
+		bytesLoaded: number = 0, bytesTotal: number = 0) {
+		super(type, bubbles, cancelable);
+		this._bytesLoaded = bytesLoaded;
+		this._bytesTotal = bytesTotal;
+	}
+
+	// JS -> AS Bindings
+	static PROGRESS: string = 'progress';
+	static SOCKET_DATA: string = 'socketData';
+
+	private _bytesLoaded: number;
+	private _bytesTotal: number;
+
+	public get bytesLoaded(): number {
+		return this._bytesLoaded;
+	}
+
+	public set bytesLoaded(value: number) {
+		this._bytesLoaded = value;
+	}
+
+	public get bytesTotal(): number {
+		return this._bytesTotal;
+	}
+
+	public set bytesTotal(value: number) {
+		this._bytesTotal = value;
+	}
+
+	public clone(): Event {
+		return new ProgressEvent(this._type, this._bubbles,
+			this._cancelable, this._bytesLoaded,
+			this._bytesTotal);
+	}
+
+	public toString(): string {
+		return this.formatToString('ProgressEvent', 'bubbles', 'cancelable', 'eventPhase',
+			'bytesLoaded', 'bytesTotal');
+	}
+}

package/lib/events/SampleDataEvent.ts

@@ -0,0 +1,140 @@
+import { Event } from './Event';
+import { ByteArray } from '../utils/ByteArray';
+
+/**
+ /// @eventType	flash.events.SampleDataEvent.SAMPLE_DATA
+ [Event(name="sampleData", type="flash.events.SampleDataEvent")]
+ * Dispatched when a Sound object requests new audio data or when a Microphone object
+ * has new audio data to provide.
+ *
+ *   <p class="- topic/p ">This event has two uses:</p><ul class="- topic/ul "><li class="- topic/li ">
+ * To provide dynamically generated audio data for a Sound object</li><li class="- topic/li ">
+ * To get audio data for a Microphone object</li></ul><p class="- topic/p "><b class="+ topic/ph hi-d/b ">
+ * Dynamically generating audio using the Sound object</b> Use the
+ * <codeph class="+ topic/ph pr-d/codeph ">sampleData</codeph> event to play dynamically generated audio.
+ * In this environment,
+ * the Sound object doesn't actually contain sound data. Instead, it acts as a socket for
+ * sound data that is being streamed to it through the use of the function
+ * you assign as the handler for the <codeph class="+ topic/ph pr-d/codeph ">sampleData</codeph> event.
+ * </p><p class="- topic/p ">In your function, you use the <codeph class="+ topic/ph pr-d/codeph ">
+ * ByteArray.writeFloat()</codeph> method to write to
+ * the event's <codeph class="+ topic/ph pr-d/codeph ">data</codeph>) property, which contains the sampled data you
+ * want to play.</p><p class="- topic/p ">If a Sound object has not loaded an MP3 file,
+ * when you call its <codeph class="+ topic/ph pr-d/codeph ">play()</codeph> method
+ * the object starts dispatching <codeph class="+ topic/ph pr-d/codeph ">sampleData</codeph> events,
+ * requesting sound samples.
+ * The Sound object continues to send events as the sound plays back until you stop providing data,
+ * or until the <codeph class="+ topic/ph pr-d/codeph ">stop()</codeph> method of the SoundChannel object is called.
+ * </p><p class="- topic/p ">Thes latency of the event varies from platform to platform, and it could change in future
+ * versions of <ph class="- topic/ph ">Flash Player or </ph>AIR. Don't depend on a specific latency.
+ * Instead calculate it using <codeph class="+ topic/ph pr-d/codeph ">
+ * ((SampleDataEvent.position/44.1) - SoundChannelObject.position)</codeph>.</p><p class="- topic/p ">
+ * Provide between 2048 and 8192 samples to the <codeph class="+ topic/ph pr-d/codeph ">data</codeph> property of
+ * the SampleDataEvent object. For best performance, provide as many samples as possible.
+ * The fewer samples you provide, the more likely it is
+ * that clicks and pops will occur during playback. This behavior can differ on various platforms
+ * and can occur in various situations - for example, when resizing the browser.
+ * You might write code that works on one platform when you provide only 2048 samples, but that same code
+ * might not work as well when run on a different platform. If you require the lowest latency possible,
+ * consider making the amount of data user-selectable.</p><p class="- topic/p ">
+ * If you provide fewer than 2048 samples, tha Sound object plays the remaining samples
+ * and then stops the sound as if the end of a sound file was reached, generating
+ * a <codeph class="+ topic/ph pr-d/codeph ">complete</codeph> event.</p><p class="- topic/p ">
+ * You can use the <codeph class="+ topic/ph pr-d/codeph ">extract()</codeph> method of a Sound object
+ *  to extract its sound data,
+ * which you can then write to the dynamic stream for playback.</p><p class="- topic/p ">
+ * When you use the <codeph class="+ topic/ph pr-d/codeph ">sampleData</codeph> event with a Sound object,
+ * the only Sound methods that
+ * are enabled are <codeph class="+ topic/ph pr-d/codeph ">extract()</codeph>
+ * and <codeph class="+ topic/ph pr-d/codeph ">play()</codeph>. Calling any other methods or properties
+ * results in an "invalid call" exception. All methods and properties of the SoundChannel object
+ * are still enabled.</p><p class="- topic/p "><b class="+ topic/ph hi-d/b ">
+ * Capturing Microphone audio</b> Use the <codeph class="+ topic/ph pr-d/codeph ">sampleData</codeph> event
+ * to capture audio data from a microphone. When you add an event listener for the
+ * <codeph class="+ topic/ph pr-d/codeph ">sampleData</codeph> event,
+ * the Microphone dispatches the event as audio samples
+ * become available.</p><p class="- topic/p ">In the event handler function,
+ * use the <codeph class="+ topic/ph pr-d/codeph ">ByteArray.readFloat()</codeph> method to read
+ * the event's <codeph class="+ topic/ph pr-d/codeph ">data</codeph>) property,
+ * which contains the sampled data. The event will contain
+ * multiple samples, so you should use a <codeph class="+ topic/ph pr-d/codeph ">while</codeph>
+ * loop to read the available data:</p><codeblock xml:space="preserve"
+ * class="+ topic/pre pr-d/codeblock ">var soundBytes:ByteArray = new ByteArray();
+ * while(event.data.bytesAvailable)
+ * {
+	 * var sample:Number = event.data.readFloat();
+	 * soundBytes.writeFloat(sample);
+	 * }</codeblock>
+ */
+export class SampleDataEvent extends Event {
+	/**
+	 * Defines the value of the type property of a SampleDataEvent event object.
+	 * This event has the following properties:PropertyValuebubblesfalsecancelablefalse;
+	 * there is no default behavior to cancel.positionThe point from which audio data is provided.
+	 */
+	public static SAMPLE_DATA: string = 'sampleData';
+
+	/**
+	 * The data in the audio stream.
+	 */
+	public get data (): ByteArray {
+		console.log('data not implemented yet in flash/SampleDataEvent');
+		return null;
+
+	}
+
+	public set data (thedata: ByteArray) {
+		console.log('data not implemented yet in flash/SampleDataEvent');
+
+	}
+
+	/**
+	 * The position of the data in the audio stream.
+	 */
+	public get position (): number {
+		console.log('position not implemented yet in flash/SampleDataEvent');
+		return 0;
+
+	}
+
+	public set position (theposition: number) {
+		console.log('position not implemented yet in flash/SampleDataEvent');
+
+	}
+
+	/**
+	 * Creates an event object that contains information about audio data events.
+	 * Event objects are passed as parameters to event listeners.
+	 * @param	type	The type of the event. This value is:Event.SAMPLE_DATA.
+	 * @param	bubbles	Determines whether the Event object participates in the bubbling stage of the event flow.
+	 * @param	cancelable	Determines whether the Event object can be canceled.
+	 * @param	theposition	The position of the data in the audio stream.
+	 * @param	thedata	A byte array of data.
+	 */
+	constructor (type: string, bubbles: boolean = false, cancelable: boolean = false,
+		theposition: number = 0, thedata: ByteArray = null) {
+		super(type, bubbles, cancelable);
+	}
+
+	/**
+	 * Creates a copy of the SampleDataEvent object and sets each property's value to match that of the original.
+	 * @return	A new SampleDataEvent object with property values that match those of the original.
+	 */
+	public clone (): Event {
+		console.log('clone not implemented yet in flash/SampleDataEvent');
+		return null;
+
+	}
+
+	/**
+	 * Returns a string that contains all the properties of the SampleDataEvent object.
+	 * The string is in the following format:
+	 * [SampleDataEvent type=value bubbles=value cancelable=value theposition=value thedata=value]
+	 * @return	A string that contains all the properties of the SampleDataEvent object.
+	 */
+	public toString (): string {
+		console.log('toString not implemented yet in flash/SampleDataEvent');
+		return '';
+
+	}
+}

package/lib/events/SecurityErrorEvent.ts

@@ -0,0 +1,16 @@
+import { ErrorEvent } from './ErrorEvent';
+export class SecurityErrorEvent extends ErrorEvent {
+
+	static classInitializer: any = null;
+
+	static classSymbols: string [] = null;
+	static instanceSymbols: string [] = null;
+
+	constructor(type: string, bubbles: boolean = false, cancelable: boolean = false,
+		text: string = '', id: number /*int*/ = 0) {
+		super(type, bubbles, cancelable, text, id);
+	}
+
+	// JS -> AS Bindings
+	static SECURITY_ERROR: string = 'securityError';
+}

package/lib/events/ShaderEvent.ts

@@ -0,0 +1,19 @@
+import { Event } from './Event';
+import { BitmapData } from '../display/BitmapData';
+import { ByteArray } from '@awayfl/avm2';
+export class ShaderEvent extends Event {
+
+	static classInitializer: any = null;
+
+	static classSymbols: string [] = null;
+	static instanceSymbols: string [] = null;
+
+	constructor(type: string, bubbles: boolean = false, cancelable: boolean = false,
+		bitmap: BitmapData = null, array: ByteArray = null,
+		vector: any /*Vector>*/ = null) {
+		super(type, bubbles, cancelable);
+	}
+
+	// JS -> AS Bindings
+	static COMPLETE: string = 'complete';
+}