@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/events/EventDispatcher.ts

@@ -0,0 +1,283 @@
+import { Event } from './Event';
+import { IEventMapper } from './IEventMapper';
+import { EventDispatcherBase } from './EventDispatcherBase';
+
+import { UUID } from '@awayjs/core';
+import { release } from '@awayfl/swf-loader';
+import { assert } from '@awayjs/graphics';
+import { SecurityDomain } from '../SecurityDomain';
+
+import { MouseEvent } from '../events/MouseEvent';
+import { Settings } from '@awayfl/avm2';
+/**
+	 * [broadcast event] Dispatched when the Flash Player or AIR application operating
+	 * loses system focus and is becoming inactive.
+	 * @eventType	flash.events.Event.DEACTIVATE
+	[Event(name="deactivate", type="flash.events.Event")]
+
+	 * [broadcast event] Dispatched when the Flash Player or AIR application gains
+	 * operating system focus and becomes active.
+	 * @eventType	flash.events.Event.ACTIVATE
+	[Event(name="activate", type="flash.events.Event")]
+ */
+
+export class EventDispatcher extends EventDispatcherBase {
+
+	public static eventsThatBubbleInAwayJS: string[] = [
+		MouseEvent.MOUSE_WHEEL,
+		MouseEvent.MOUSE_UP,
+		MouseEvent.MOUSE_OVER,
+		MouseEvent.MOUSE_OUT,
+		MouseEvent.ROLL_OVER,
+		MouseEvent.ROLL_OUT,
+		MouseEvent.MOUSE_MOVE,
+		MouseEvent.MOUSE_DOWN,
+		MouseEvent.DOUBLE_CLICK,
+		MouseEvent.CLICK,
+		Event.ENTER_FRAME,
+		Event.EXIT_FRAME,
+		Event.FRAME_CONSTRUCTED,
+		Event.ADDED_TO_STAGE,
+		Event.RESIZE,
+		Event.REMOVED_FROM_STAGE,
+		//KeyboardEvent.KEY_DOWN,
+		//KeyboardEvent.KEY_UP,
+	]
+
+	public readonly id: number;
+
+	public toString(): string {
+		return '';
+	}
+
+	public hasEventListener(type: string, listener?: (event: Event) => void): boolean {
+		return super.hasEventListener(type, listener);
+
+	}
+
+	public willTrigger() {
+
+	}
+
+	public dispatchEvent(event: Event, comesFromAway: boolean = false): boolean {
+		(<any>event).currentTarget = this;
+		if (event.type == 'enterFrame') {//} || event.type=="scroll"){
+			(<any>event).target = this;
+		}
+		const returnVal = super.dispatchEvent(event);
+
+		// workaround for now.
+		// mousevents already bubble up the scenegraph in MouseMangager
+		// for all other events, we want to bubble them up here:
+		if (!comesFromAway && event.bubbles && EventDispatcher.eventsThatBubbleInAwayJS.indexOf(event.type) == -1) {
+			if ((<any> this).adaptee && (<any> this).adaptee.parent) {
+				(<any> this).adaptee.parent.adapter.dispatchEvent(event);
+			}
+		}
+		return returnVal;
+	}
+
+	protected eventMapping: Object;
+	protected eventMappingDummys: Object;
+	protected eventMappingExtern: Object;
+
+	protected eventMappingInvert: Object;
+
+	// for AVM1:
+	public _avm1Context: any;
+
+	constructor(target: any = null) {
+		super(target);
+
+		this.id = UUID.Next();
+
+		this.eventMapping || (this.eventMapping = {});
+		this.eventMappingDummys || (this.eventMappingDummys = {});
+		this.eventMappingExtern || (this.eventMappingExtern = {});
+		this.eventMappingInvert || (this.eventMappingInvert = {});
+
+		this._activateCallbackDelegate = (event: any) => this.activateCallback(event);
+		this.eventMapping[Event.ACTIVATE] = (<IEventMapper>{
+			adaptedType: '',
+			addListener: this.initActivateListener,
+			removeListener: this.removeActivateListener,
+			callback: this._activateCallbackDelegate
+		});
+
+		this._deactivateCallbackDelegate = (event: any) => this.deactivateCallback(event);
+		this.eventMapping[Event.DEACTIVATE] = (<IEventMapper>{
+			adaptedType: '',
+			addListener: this.initDeactivateListener,
+			removeListener: this.removeDeactivateListener,
+			callback: this._deactivateCallbackDelegate
+		});
+	}
+
+	// ---------- event mapping functions Event.ACTIVATE
+
+	private initActivateListener(type: string, callback: (event: any) => void): void {
+		window.onfocus = callback;
+	}
+
+	private removeActivateListener(type: string, callback: (event: any) => void): void {
+		window.onfocus = null;
+	}
+
+	private _activateCallbackDelegate: (event: any) => void;
+	private activateCallback(event: any = null): void {
+		this.dispatchEvent(new (<SecurityDomain> this.sec).flash.events.Event(Event.ACTIVATE));
+	}
+
+	// ---------- event mapping functions Event.DEACTIVATE
+
+	private initDeactivateListener(type: string, callback: (event: any) => void): void {
+		window.onblur = callback;
+	}
+
+	private removeDeactivateListener(type: string, callback: (event: any) => void): void {
+		window.onblur = null;
+	}
+
+	private _deactivateCallbackDelegate: (event: any) => void;
+	private deactivateCallback(event: any = null): void {
+		this.dispatchEvent(new (<SecurityDomain> this.sec).flash.events.Event(Event.DEACTIVATE));
+	}
+
+	/*overwrite*/
+	public addEventListener(type: string, listener: (event: Event) => void, useCapture: boolean = false,
+		priority: number /*int*/ = 0, useWeakReference: boolean = false): void {
+
+		if (!useCapture && Event.isBroadcastEventType(type)) {
+			BroadcastEventDispatchQueue.getInstance().add(type, this);
+		}
+
+		this.eventMapping || (this.eventMapping = {});
+		this.eventMappingDummys || (this.eventMappingDummys = {});
+		this.eventMappingExtern || (this.eventMappingExtern = {});
+		this.eventMappingInvert || (this.eventMappingInvert = {});
+
+		if (this.eventMappingDummys.hasOwnProperty(type)) {
+
+			// this is a dummy eventMapping
+			// this means that this is a event-type, that is not yet supported
+			// we do not need to register it on superclass
+			// for now we output a warning
+			//console.log("Warning - EventDispatcher:  trying to listen for unsupported event: :
+			//"+this.eventMappingDummys[type]);
+			return;
+		} else if (this.eventMapping.hasOwnProperty(type)) {
+
+			// a mapping exists for this event
+
+			//making sure standart behaviour still works (listener is tracked in list)
+			super.addEventListener(type, listener, useCapture, priority, useWeakReference);
+
+			// call the provided "addListener" function
+			this.eventMapping[type].addListener.call(
+				this, this.eventMapping[type].adaptedType, this.eventMapping[type].callback, listener);
+			return;
+		} else {
+			// this is a external eventMapping
+			// this means that we do not need to create any mapping, and will manually dispatch the event
+			// we still need to register it on superclass, so it will work if we dispatch it manually
+			super.addEventListener(type, listener, useCapture, priority, useWeakReference);
+			return;
+		}
+		// if we make it here, the event is not handled by this dispatcher
+		// lets output a Warning for now.
+		//console.log("EventDispatcher: trying to listen for unknown event: '"+type+"'")
+	}
+
+	/**
+	 * Remove an event listener
+	 * @method removeEventListener
+	 * @param {String} type of event to remove a listener for
+	 * @param {Function} listener function
+	 */
+	public removeEventListener(type: string, listener: (event: Event) => void): void {
+
+		this.eventMapping || (this.eventMapping = {});
+		this.eventMappingDummys || (this.eventMappingDummys = {});
+		this.eventMappingExtern || (this.eventMappingExtern = {});
+		this.eventMappingInvert || (this.eventMappingInvert = {});
+
+		super.removeEventListener(type, listener);
+		if (this.eventMapping.hasOwnProperty(type)) {
+			// a mapping exists
+			this.eventMapping[type].removeListener.call(
+				this, this.eventMapping[type].adaptedType, this.eventMapping[type].callback, listener);
+			if (!this.hasEventListener(type)) {
+
+				if (Event.isBroadcastEventType(type)) {
+					BroadcastEventDispatchQueue.getInstance().remove(type, this);
+				}
+			}
+		}
+	}
+}
+
+const USE_WEAK = ('WeakRef' in self) && Settings.USE_WEAK_REF;
+
+if (USE_WEAK) {
+	console.debug('[BroadcastEventDispatchQueue] `WeakRef` used for Broadcast Events!');
+}
+
+export class BroadcastEventDispatchQueue {
+	/**
+	 * The queues start off compact but can have null values if event targets are removed.
+	 * Periodically we compact them if too many null values exist.
+	 */
+	private _queues: Record<string,  Record<number, WeakRef<EventDispatcher>> | Record<number, EventDispatcher>> = {};
+	private static _instance: BroadcastEventDispatchQueue;
+	public static getInstance(): BroadcastEventDispatchQueue {
+		return BroadcastEventDispatchQueue._instance
+			|| (BroadcastEventDispatchQueue._instance = new BroadcastEventDispatchQueue());
+	}
+
+	add(type: string, target: EventDispatcher) {
+		// release || assert(Event.isBroadcastEventType(type), "Can only register broadcast events.");
+		const queue = this._queues[type] || (this._queues[type] = []);
+
+		if (queue[target.id])
+			return;
+
+		queue[target.id] = (USE_WEAK ? new self.WeakRef(target) : target);
+	}
+
+	remove(type: string, target: EventDispatcher) {
+		//release || assert (Event.isBroadcastEventType(type), "Can only unregister broadcast events.");
+		const queue = this._queues[type];
+		release || assert(queue, 'There should already be a queue for this.');
+		delete queue[target.id];
+	}
+
+	dispatchEvent(event: Event) {
+		//release || assert (event.isBroadcastEvent(), "Cannot dispatch non-broadcast events.");
+		const queue = this._queues[event._type];
+
+		//return if no listeners exist for event type
+		if (!queue)
+			return;
+
+		for (const key in queue) {
+			let target = queue[key];
+			if (USE_WEAK)
+				target = (<WeakRef<EventDispatcher>> target)?.deref();
+
+			if (target) {
+				const dispatchedEvent = new (<SecurityDomain> event.sec).flash.events.Event(
+					event.type, event.bubbles, event.cancelable
+				);
+				dispatchedEvent._isBroadcastEvent = event._isBroadcastEvent;
+				(<EventDispatcher> target).dispatchEvent(dispatchedEvent);
+			} else {
+				console.debug('[BroadcastEventDispatchQueue] Broadcast target was deleted by GC:', key);
+				delete queue[key];
+			}
+		}
+	}
+
+	getQueueLength(type: string) {
+		return this._queues[type] ? Object.getOwnPropertyNames(this._queues[type]).length : 0;
+	}
+}

package/lib/events/EventDispatcherBase.ts

@@ -0,0 +1,289 @@
+import { ASObject, AXClass } from '@awayfl/avm2';
+import { Event } from './Event';
+
+/**
+ * Base export class for dispatching events
+*
+* @export class away.events.EventDispatcher
+*
+*/
+export class EventDispatcherBase extends ASObject {
+	static axClass: typeof EventDispatcherBase & AXClass;
+
+	private _listenerObjects: Array<ListenerObject>;
+	private _t: any;
+
+	public toString(): string {
+		return '';
+	}
+
+	constructor(target: any = null) {
+		super();
+		this._t = target || this;
+		this._listenerObjects || (this._listenerObjects = []);
+	}
+
+	/**
+	 * Add an event listener
+	 * @method addEventListener
+	 * @param {String} Name of event to add a listener for
+	 * @param {Function} Callback function
+	 */
+	public addEventListener(type: string,
+		listener: (event: Event) => void,
+		useCapture: boolean = false,
+		priority: number /*int*/ = 0,
+		useWeakReference: boolean = false): void {
+
+		this._listenerObjects || (this._listenerObjects = []);
+
+		let l: ListenerObject = this._listenerObjects[type];
+
+		if (l === undefined)
+			l = this._listenerObjects[type] = new ListenerObject();
+
+		l.addEventListener(listener, priority);
+	}
+
+	/**
+	 * Remove an event listener
+	 * @method removeEventListener
+	 * @param {String} Name of event to remove a listener for
+	 * @param {Function} Callback function
+	 */
+	public removeEventListener(type: string, listener: (event: Event) => void): void {
+
+		this._listenerObjects || (this._listenerObjects = []);
+
+		const l: ListenerObject = this._listenerObjects[type];
+
+		if (l) {
+			l.removeEventListener(listener);
+
+			if (l.numListeners == 0)
+				delete this._listenerObjects[type];
+		}
+	}
+
+	/**
+	 * Dispatch an event
+	 * @method dispatchEvent
+	 * @param {Event} Event to dispatch
+	 */
+	public dispatchEvent(event: Event): boolean {
+
+		this._listenerObjects || (this._listenerObjects = []);
+		const l: ListenerObject = this._listenerObjects[event.type];
+
+		if (l) {
+			// Flash reports the aggregation target (EventDispatcher(target) constructor arg)
+			// as currentTarget during dispatch — e.g. GreenSock dispatches tween events via an
+			// internal aggregated dispatcher and handlers cast event.currentTarget to the tween.
+			if (this._t)
+				(<any> event).currentTarget = this._t;
+			if (!event.target)
+				event.target = this._t;
+			//console.log("dispatchEvent", event.type, (<any>this).adaptee?.id);
+			l.dispatchEvent(event);
+		}
+		return true;
+	}
+
+	/**
+	 * check if an object has an event listener assigned to it
+	 * @method hasListener
+	 * @param {String} Name of event to remove a listener for
+	 * @param {Function} Callback function
+	 */
+	public hasEventListener(type: string, listener?: (event: Event) => void): boolean {
+		if (this._listenerObjects[type] === undefined)
+			return false;
+
+		if (listener != null)
+			return this._listenerObjects[type].getEventListenerIndex(listener) !== -1;
+
+		return this._listenerObjects[type].numListeners > 0;
+	}
+}
+
+interface IListenerPriority{
+	priority: number,
+	listeners?: Array<(event: Event) => void>
+
+}
+function sortListenersByPriority(a: IListenerPriority, b: IListenerPriority) {
+	return a.priority < b.priority ? -1 : 1;
+}
+export class ListenerObject {
+	private _index: number = 0;
+	private _singlePriority: number = 0;
+
+	private _listeners: Array<(event: Event) => void> = new Array<(event: Event) => void>();
+
+	private _listenersByPriority: IListenerPriority[];
+
+	public numListeners: number = 0;
+
+	public addEventListener(listener: (event: Event) => void, priority: number = 0): void {
+
+		// if event already exists, it will not be added again, and old priority will remain
+
+		if (!this._listenersByPriority) {
+			// single priority mode:
+			if (this._listeners.indexOf(listener) !== -1) {
+				// the listener is already present - do nothing just return
+				return;
+			} else {
+				// its a new listener
+				if (this._listeners.length == 0 || priority == this._singlePriority) {
+					// same priority as existing listeners. just add it and return
+					this._listeners.push(listener);
+					this.numListeners++;
+					return;
+				} else {
+					// different priority - switch to multi-priority mode
+					if (this._singlePriority < priority) {
+						this._listenersByPriority = [
+							{
+								priority:this._singlePriority,
+								listeners:this._listeners.concat()
+							},
+							{
+								priority:priority,
+								listeners:[listener]
+							}
+						];
+					} else {
+						this._listenersByPriority = [
+							{
+								priority:priority,
+								listeners:[listener]
+							},
+							{
+								priority:this._singlePriority,
+								listeners:this._listeners.concat()
+							}
+						];
+					}
+					this.numListeners++;
+				}
+				return;
+			}
+		}
+		// multi-priority mode:
+		//check if a listener already exists
+		for (let i = 0; i < this._listenersByPriority.length; i++) {
+			if (this._listenersByPriority[i].listeners.indexOf(listener) !== -1) {
+				return;
+			}
+		}
+		// find priority item
+		let priorityItem = null;
+		for (let i = 0; i < this._listenersByPriority.length; i++) {
+			if (this._listenersByPriority[i].priority == priority) {
+				priorityItem = this._listenersByPriority[i];
+				break;
+			}
+		}
+		if (!priorityItem) {
+			priorityItem = {
+				priority:priority,
+				listeners:[]
+			};
+			this._listenersByPriority.push(priorityItem);
+			if (this._listenersByPriority.length > 1) {
+				this._listenersByPriority.sort(sortListenersByPriority);
+			}
+		}
+		priorityItem.listeners.push(listener);
+		this.numListeners++;
+	}
+
+	public removeEventListener(listener: (event: Event) => void): void {
+		let index: number = -1;
+		if (!this._listenersByPriority) {
+			index = this._listeners.indexOf(listener);
+
+			if (index === -1)
+				return;
+
+			this._listeners.splice(index, 1);
+
+			this.numListeners--;
+			return;
+		}
+		//check if listener exists
+		for (let i = 0; i < this._listenersByPriority.length; i++) {
+			index = this._listenersByPriority[i].listeners.indexOf(listener);
+			if (index !== -1) {
+				this.numListeners--;
+				this._listenersByPriority[i].listeners.splice(index, 1);
+				return;
+
+			}
+		}
+	}
+
+	public dispatchEvent(event: Event): void {
+		// when listeners do attach/remove new listeners the new listeners will be ignored during this dispatch,
+		// and listeners that got removed will still dispatch during this dispatch
+		// this means we need to concat the listener-array before we iterate it
+		if (!this._listenersByPriority) {
+			// single-priority mode:
+			const listeners = this._listeners.length > 1 ? this._listeners.concat() : this._listeners;
+			const numListeners = listeners.length;
+			let i = 0;
+			for (i = 0; i < numListeners; i++) {
+				if (listeners[i])
+					listeners[i].call(listeners[i], event);
+			}
+			return;
+		}
+		// multi-priority mode:
+		let p = this._listenersByPriority.length;
+		//console.log("multi-priority mode", p);
+		while (p > 0) {
+			p--;
+			//console.log("multi-priority mode next", p);
+			const listeners = this._listenersByPriority[p].listeners.length > 1 ?
+				this._listenersByPriority[p].listeners.concat() : this._listenersByPriority[p].listeners;
+			const numListeners = listeners.length;
+			let i = 0;
+			//let len=events.length;
+			//console.log("events", len);
+			for (i = 0; i < numListeners; i++) {
+				if (listeners[i])
+					listeners[i].call(listeners[i], event);
+			}
+		}
+		if (this._listenersByPriority.length == 1) {
+			// if only 1 priority exists, we can go back to single-priority-mode
+			this._listeners = this._listenersByPriority[0].listeners.concat();
+			this._singlePriority = this._listenersByPriority[0].priority;
+			this._listenersByPriority = null;
+		}
+	}
+
+	/**
+	 * get Event Listener Index in array. Returns -1 if no listener is added
+	 * @method getEventListenerIndex
+	 * @param {String} Name of event to remove a listener for
+	 * @param {Function} Callback function
+	 */
+	public getEventListenerIndex(listener: (event: Event) => void): number {
+		if (!this._listenersByPriority) {
+			// single-priority mode:
+			return this._listeners.indexOf(listener);
+		}
+		// multi-priority mode:
+		for (let i = 0; i < this._listenersByPriority.length; i++) {
+			for (let e = 0; e < this._listenersByPriority[i].listeners.length; e++) {
+				if (this._listenersByPriority[i].listeners[e] == listener) {
+					return i;
+				}
+			}
+		}
+		return -1;
+	}
+}
+export default EventDispatcherBase;

package/lib/events/EventPhase.ts

@@ -0,0 +1,34 @@
+import { ASObject } from '@awayfl/avm2';
+
+/**
+ * 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: EventPhase
+export class EventPhase extends ASObject {
+
+	static classInitializer: any = null;
+
+	static classSymbols: string [] = null;
+	static instanceSymbols: string [] = null;
+
+	constructor () {
+		super();
+	}
+
+	// JS -> AS Bindings
+	static CAPTURING_PHASE: number /*uint*/ = 1;
+	static AT_TARGET: number /*uint*/ = 2;
+	static BUBBLING_PHASE: number /*uint*/ = 3;
+}

package/lib/events/FocusEvent.ts

@@ -0,0 +1,97 @@
+import { FocusEvent as FocusEventAway } from '@awayjs/scene';
+
+import { Event } from './Event';
+import { InteractiveObject } from '../display/InteractiveObject';
+export class FocusEvent extends Event {
+
+	public static FOCUS_IN='focusIn';
+	public static FOCUS_OUT='focusOut';
+	public static KEY_FOCUS_CHANGE='keyFocusChange';
+	public static MOUSE_FOCUS_CHANGE='mouseFocusChange';
+
+	private adaptee: FocusEventAway;
+
+	/**
+	 * If true, the relatedObject property is set to null for
+	 * reasons related to security sandboxes.  If the nominal value of relatedObject is a reference to a
+	 * DisplayObject in another sandbox, relatedObject is set to
+	 * null unless there is permission in both directions across this sandbox boundary.  Permission is
+	 * established by calling Security.allowDomain() from a SWF file, or by providing
+	 * a policy file from the server of an image file, and setting the LoaderContext.checkPolicyFile
+	 * property when loading the image.
+	 * @langversion	3.0
+	 * @playerversion	Flash 10
+	 * @playerversion	Lite 4
+	 */
+	public get isRelatedObjectInaccessible (): boolean {
+		console.log('isRelatedObjectInaccessible not implemented yet in flash/FocusEvent');
+		return false;
+	}
+
+	public set isRelatedObjectInaccessible (value: boolean) {
+		console.log('isRelatedObjectInaccessible not implemented yet in flash/FocusEvent');
+	}
+
+	/**
+	 * The key code value of the key pressed to trigger a keyFocusChange event.
+	 */
+	public get keyCode (): number {
+		console.log('keyCode not implemented yet in flash/FocusEvent');
+		return 0;
+	}
+
+	public set keyCode (value: number) {
+		console.log('keyCode not implemented yet in flash/FocusEvent');
+	}
+
+	/**
+	 * A reference to the complementary InteractiveObject instance that is affected by the
+	 * change in focus. For example, when a focusOut event occurs, the
+	 * relatedObject represents the InteractiveObject instance that has gained focus.
+	 * The value of this property can be null in two circumstances: if there no related object,
+	 * or there is a related object, but it is in a security sandbox to which you don't have access.
+	 * Use the isRelatedObjectInaccessible() property to determine which of these reasons applies.
+	 */
+	public get relatedObject (): InteractiveObject {
+		console.log('relatedObject not implemented yet in flash/FocusEvent');
+		return null;
+	}
+
+	public set relatedObject (value: InteractiveObject) {
+		console.log('relatedObject not implemented yet in flash/FocusEvent');
+	}
+
+	/**
+	 * Indicates whether the Shift key modifier is activated, in which case the value is
+	 * true. Otherwise, the value is false. This property is
+	 * used only if the FocusEvent is of type keyFocusChange.
+	 */
+	public get shiftKey (): boolean {
+		console.log('shiftKey not implemented yet in flash/FocusEvent');
+		return false;
+	}
+
+	public set shiftKey (value: boolean) {
+		console.log('shiftKey not implemented yet in flash/FocusEvent');
+	}
+
+	public clone(): Event {
+		console.log('clone not implemented yet in flash/IOErrorEvent');
+		return null;
+	}
+
+	public toString(): string {
+		console.log('toString not implemented yet in flash/FocusEvent');
+		return '';
+	}
+
+	/* added to clone events from away to as3web. */
+	public fillFromAway (awayEvent: FocusEventAway) {
+		//console.log("cloneFromAway not implemented yet in flash/MouseEvent");
+
+		this.adaptee = awayEvent;
+		// todo: set targets correctly
+		this.target = awayEvent.target;
+		//this.currentTarget = awayEvent.currentTarget;
+	}
+}