@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/_shumway_flash/net/Socket.ts

@@ -0,0 +1,230 @@
+import { release, somewhatImplemented, notImplemented } from '../../base/utilities/Debug';
+import { axCoerceString } from '../../avm2/run/axCoerceString';
+import { ByteArray, IDataInput, IDataOutput } from '../../avm2/natives/byteArray';
+import { Errors } from '../../avm2/errors';
+import { EventDispatcher } from '../events/EventDispatcher';
+
+/**
+ * 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: Socket
+
+export class Socket extends EventDispatcher implements IDataInput, IDataOutput {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string [] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string [] = null; // ["timeout", "timeout", "connect", "close"];
+
+	constructor (host: string = null, port: number /*int*/ = 0) {
+		super(undefined);
+		host = axCoerceString(host); port = port | 0;
+	}
+
+	// JS -> AS Bindings
+
+	timeout: number /*uint*/;
+	connect: (host: string, port: number /*int*/) => void;
+	close: () => void;
+
+	// AS -> JS Bindings
+
+	// _timeout: number /*uint*/;
+	// _bytesAvailable: number /*uint*/;
+	// _connected: boolean;
+	// _objectEncoding: number /*uint*/;
+	// _endian: string;
+	// _bytesPending: number /*uint*/;
+	get bytesAvailable(): number /*uint*/ {
+		release || notImplemented('public flash.net.Socket::get bytesAvailable'); return;
+		// return this._bytesAvailable;
+	}
+
+	get connected(): boolean {
+		release || notImplemented('public flash.net.Socket::get connected'); return;
+		// return this._connected;
+	}
+
+	get objectEncoding(): number /*uint*/ {
+		release || notImplemented('public flash.net.Socket::get objectEncoding'); return;
+		// return this._objectEncoding;
+	}
+
+	set objectEncoding(version: number /*uint*/) {
+		version = version >>> 0;
+		release || notImplemented('public flash.net.Socket::set objectEncoding'); return;
+		// this._objectEncoding = version;
+	}
+
+	get endian(): string {
+		release || notImplemented('public flash.net.Socket::get endian'); return;
+		// return this._endian;
+	}
+
+	set endian(type: string) {
+		type = axCoerceString(type);
+		release || notImplemented('public flash.net.Socket::set endian'); return;
+		// this._endian = type;
+	}
+
+	get bytesPending(): number /*uint*/ {
+		release || notImplemented('public flash.net.Socket::get bytesPending'); return;
+		// return this._bytesPending;
+	}
+
+	readBytes(bytes: ByteArray, offset: number /*uint*/ = 0, length: number /*uint*/ = 0): void {
+		bytes = bytes; offset = offset >>> 0; length = length >>> 0;
+		release || notImplemented('public flash.net.Socket::readBytes'); return;
+	}
+
+	writeBytes(bytes: ByteArray, offset: number /*uint*/ = 0, length: number /*uint*/ = 0): void {
+		bytes = bytes; offset = offset >>> 0; length = length >>> 0;
+		release || notImplemented('public flash.net.Socket::writeBytes'); return;
+	}
+
+	writeBoolean(value: boolean): void {
+		value = !!value;
+		release || notImplemented('public flash.net.Socket::writeBoolean'); return;
+	}
+
+	writeByte(value: number /*int*/): void {
+		value = value | 0;
+		release || notImplemented('public flash.net.Socket::writeByte'); return;
+	}
+
+	writeShort(value: number /*int*/): void {
+		value = value | 0;
+		release || notImplemented('public flash.net.Socket::writeShort'); return;
+	}
+
+	writeInt(value: number /*int*/): void {
+		value = value | 0;
+		release || notImplemented('public flash.net.Socket::writeInt'); return;
+	}
+
+	writeUnsignedInt(value: number /*uint*/): void {
+		value = value >>> 0;
+		release || notImplemented('public flash.net.Socket::writeUnsignedInt'); return;
+	}
+
+	writeFloat(value: number): void {
+		value = +value;
+		release || notImplemented('public flash.net.Socket::writeFloat'); return;
+	}
+
+	writeDouble(value: number): void {
+		value = +value;
+		release || notImplemented('public flash.net.Socket::writeDouble'); return;
+	}
+
+	writeMultiByte(value: string, charSet: string): void {
+		value = axCoerceString(value); charSet = axCoerceString(charSet);
+		release || notImplemented('public flash.net.Socket::writeMultiByte'); return;
+	}
+
+	writeUTF(value: string): void {
+		value = axCoerceString(value);
+		release || notImplemented('public flash.net.Socket::writeUTF'); return;
+	}
+
+	writeUTFBytes(value: string): void {
+		value = axCoerceString(value);
+		release || notImplemented('public flash.net.Socket::writeUTFBytes'); return;
+	}
+
+	readBoolean(): boolean {
+		release || notImplemented('public flash.net.Socket::readBoolean'); return;
+	}
+
+	readByte(): number /*int*/ {
+		release || notImplemented('public flash.net.Socket::readByte'); return;
+	}
+
+	readUnsignedByte(): number /*uint*/ {
+		release || notImplemented('public flash.net.Socket::readUnsignedByte'); return;
+	}
+
+	readShort(): number /*int*/ {
+		release || notImplemented('public flash.net.Socket::readShort'); return;
+	}
+
+	readUnsignedShort(): number /*uint*/ {
+		release || notImplemented('public flash.net.Socket::readUnsignedShort'); return;
+	}
+
+	readInt(): number /*int*/ {
+		release || notImplemented('public flash.net.Socket::readInt'); return;
+	}
+
+	readUnsignedInt(): number /*uint*/ {
+		release || notImplemented('public flash.net.Socket::readUnsignedInt'); return;
+	}
+
+	readFloat(): number {
+		release || notImplemented('public flash.net.Socket::readFloat'); return;
+	}
+
+	readDouble(): number {
+		release || notImplemented('public flash.net.Socket::readDouble'); return;
+	}
+
+	readMultiByte(length: number /*uint*/, charSet: string): string {
+		length = length >>> 0; charSet = axCoerceString(charSet);
+		release || notImplemented('public flash.net.Socket::readMultiByte'); return;
+	}
+
+	readUTF(): string {
+		release || notImplemented('public flash.net.Socket::readUTF'); return;
+	}
+
+	readUTFBytes(length: number /*uint*/): string {
+		length = length >>> 0;
+		release || notImplemented('public flash.net.Socket::readUTFBytes'); return;
+	}
+
+	flush(): void {
+		release || notImplemented('public flash.net.Socket::flush'); return;
+	}
+
+	writeObject(object: any): void {
+
+		release || notImplemented('public flash.net.Socket::writeObject'); return;
+	}
+
+	readObject(): any {
+		release || notImplemented('public flash.net.Socket::readObject'); return;
+	}
+
+	internalGetSecurityErrorMessage(host, port): string {
+		host = axCoerceString(host); port |= 0;
+		release || somewhatImplemented('flash.net.Socket::internalGetSecurityErrorMessage');
+		return 'SecurityErrorEvent';
+	}
+
+	internalConnect(host, port) {
+		host = axCoerceString(host); port |= 0;
+		release || somewhatImplemented('flash.net.Socket::internalConnect');
+		this.sec.throwError('SecurityError', Errors.SocketConnectError, host, port);
+	}
+
+	didFailureOccur(): boolean {
+		release || somewhatImplemented('flash.net.Socket::didFailureOccur');
+		return true;
+	}
+}

package/lib/_shumway_flash/net/URLRequestHeader.ts

@@ -0,0 +1,22 @@
+import { ASObject } from '../../avm2/nat/ASObject';
+import { axCoerceString } from '../../avm2/run/axCoerceString';
+export class URLRequestHeader extends ASObject {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string [] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string [] = ['name!', 'value!'];
+
+	constructor (name: string = '', value: string = '') {
+		super();
+		this.name = axCoerceString(name);
+		this.value = axCoerceString(value);
+	}
+
+	name: string;
+	value: string;
+}

package/lib/_shumway_flash/net/URLStream.ts

@@ -0,0 +1,206 @@
+import { URLRequest } from '../../net/URLRequest';
+import { ProgressEvent } from '../../events/ProgressEvent';
+import { IOErrorEvent } from '../../events/IOErrorEvent';
+import { Event } from '../../events/Event';
+import { HTTPStatusEvent } from '../events/HTTPStatusEvent';
+import { URLRequestHeader } from './URLRequestHeader';
+import { EventDispatcher } from '../../events/EventDispatcher';
+import { IDataInput } from '../../utils/IDataInput';
+import { axCoerceString, ByteArray, Errors } from '@awayfl/avm2';
+import { FileLoadingService, FileLoadingSession } from '@awayfl/swf-loader';
+export class URLStream extends EventDispatcher implements IDataInput {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string [] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string [] = null; // [];
+
+	constructor () {
+		super();
+		this._buffer = new ByteArray();
+		this._writePosition = 0;
+		this._connected = false;
+	}
+
+	private _buffer: ByteArray;
+	private _writePosition: number;
+	private _session: FileLoadingSession;
+
+	private _connected: boolean;
+	// _diskCacheEnabled: boolean;
+	get connected(): boolean {
+		return this._connected;
+	}
+
+	get bytesAvailable(): number /*uint*/ {
+		return this._buffer.length - this._buffer.position;
+	}
+
+	get objectEncoding(): number /*uint*/ {
+		return this._buffer.objectEncoding;
+	}
+
+	set objectEncoding(version: number /*uint*/) {
+		version = version >>> 0;
+		this._buffer.objectEncoding = version;
+	}
+
+	get endian(): string {
+		return this._buffer.endian;
+	}
+
+	set endian(type: string) {
+		type = axCoerceString(type);
+		this._buffer.endian = type;
+	}
+
+	get diskCacheEnabled(): boolean {
+		return false;
+		// return this._diskCacheEnabled;
+	}
+
+	get position(): number {
+		return this._buffer.position;
+	}
+
+	set position(offset: number) {
+		offset = +offset;
+		this._buffer.position = offset;
+	}
+
+	get length(): number {
+		return this._buffer.length;
+	}
+
+	load(request: URLRequest): void {
+
+		const session = FileLoadingService.createSession();
+		const self = this;
+		session.onprogress = function (data, progressState) {
+			const readPosition = self._buffer.position;
+			self._buffer.position = self._writePosition;
+			self._buffer.writeRawBytes(data);
+			self._writePosition = self._buffer.position;
+			self._buffer.position = readPosition;
+
+			self.dispatchEvent(new ProgressEvent(ProgressEvent.PROGRESS, false, false,
+				progressState.bytesLoaded,
+				progressState.bytesTotal));
+		};
+		session.onerror = function (error) {
+			self._connected = false;
+			self.dispatchEvent(new IOErrorEvent(IOErrorEvent.IO_ERROR, false, false,
+				error));
+			//const isXDomainError = typeof error === 'string' && error.indexOf('XDOMAIN') >= 0;
+			/*Telemetry.instance.reportTelemetry({topic: 'loadResource',
+        resultType: isXDomainError ? Telemetry.LoadResource.StreamCrossdomain :
+                                      Telemetry.LoadResource.StreamDenied});*/
+		};
+		session.onopen = function () {
+			self._connected = true;
+			self.dispatchEvent(new Event(Event.OPEN, false, false));
+			/*Telemetry.instance.reportTelemetry({topic: 'loadResource',
+        resultType: Telemetry.LoadResource.StreamAllowed});*/
+		};
+		session.onhttpstatus = function (location: string, httpStatus: number, httpHeaders: any) {
+			const httpStatusEvent = new HTTPStatusEvent(HTTPStatusEvent.HTTP_STATUS, false,
+				false, httpStatus);
+			const headers = [];
+			httpHeaders.split(/(?:\n|\r?\n)/g).forEach(function (h) {
+				const m = /^([^:]+): (.*)$/.exec(h);
+				if (m) {
+					headers.push(new URLRequestHeader(m[1], m[2]));
+					if (m[1] === 'Location') { // Headers have redirect location
+						location = m[2];
+					}
+				}
+			});
+			const boxedHeaders = self.sec.createArray(headers);
+			httpStatusEvent.axSetPublicProperty('responseHeaders', boxedHeaders);
+			httpStatusEvent.axSetPublicProperty('responseURL', location);
+			self.dispatchEvent(httpStatusEvent);
+		};
+		session.onclose = function () {
+			self._connected = false;
+			self.dispatchEvent(new Event(Event.COMPLETE, false, false));
+		};
+		session.open(request._toFileRequest());
+		this._session = session;
+	}
+
+	public readBytes(bytes: ByteArray, offset: number /*uint*/ = 0, length: number /*uint*/ = 0): void {
+		offset = offset >>> 0; length = length >>> 0;
+		if (length < 0) {
+			this.sec.throwError('ArgumentError', Errors.InvalidArgumentError, 'length');
+		}
+
+		this._buffer.readBytes(bytes, offset, length);
+	}
+
+	public readBoolean(): boolean {
+		return;
+	}
+
+	public readByte(): number /*int*/ {
+		return this._buffer.readByte();
+	}
+
+	public readUnsignedByte(): number /*uint*/ {
+		return;
+	}
+
+	public readShort(): number /*int*/ {
+		return;
+	}
+
+	public readUnsignedShort(): number /*uint*/ {
+		return this._buffer.readUnsignedShort();
+	}
+
+	public readUnsignedInt(): number /*uint*/ {
+		return;
+	}
+
+	public readInt(): number /*int*/ {
+		return;
+	}
+
+	public readFloat(): number {
+		return;
+	}
+
+	public readDouble(): number {
+		return;
+	}
+
+	public readMultiByte(length: number /*uint*/, charSet: string): string {
+		length = length >>> 0; charSet = axCoerceString(charSet);
+		return;
+	}
+
+	public readUTF(): string {
+		return this._buffer.readUTF();
+	}
+
+	public readUTFBytes(length: number /*uint*/): string {
+		return this._buffer.readUTFBytes(length);
+	}
+
+	public close(): void {
+		if (this._session) {
+			this._session.close();
+		}
+	}
+
+	public readObject(): any {
+		return;
+	}
+
+	public stop(): void {
+		return;
+	}
+}

package/lib/_shumway_flash/net/XMLSocket.ts

@@ -0,0 +1,32 @@
+import { axCoerceString } from '@awayjs/graphics';
+import { EventDispatcher } from '../../events/EventDispatcher';
+
+export class XMLSocket extends EventDispatcher {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string [] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string [] = null; // ["timeout", "timeout", "connected", "connect", "send", "close"];
+
+	constructor (host: string = null, port: number /*int*/ = 0) {
+		super();
+		host = axCoerceString(host); port = port | 0;
+	}
+
+	// JS -> AS Bindings
+
+	timeout: number /*int*/;
+	connected: boolean;
+	connect: (host: string, port: number /*int*/) => void;
+	send: (object: any) => void;
+	close: () => void;
+
+	// AS -> JS Bindings
+
+	// _timeout: number /*int*/;
+	// _connected: boolean;
+}

package/lib/_shumway_flash/printing/PrintJob.ts

@@ -0,0 +1,42 @@
+import { Sprite } from '../../display/Sprite';
+import { EventDispatcher } from '../../events/EventDispatcher';
+import { Rectangle } from '../../geom/Rectangle';
+import { PrintJobOptions } from './PrintJobOptions';
+
+export class PrintJob extends EventDispatcher {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string[] = null; // ["isSupported"];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string[] = null;
+
+	constructor() {
+		super();
+	}
+
+	// JS -> AS Bindings
+	static isSupported: boolean;
+
+	paperHeight: number /*int*/;
+	paperWidth: number /*int*/;
+	pageHeight: number /*int*/;
+	pageWidth: number /*int*/;
+	orientation: string;
+	start: () => boolean;
+	send: () => void;
+	addPage: (sprite: Sprite,
+		printArea: Rectangle, options: PrintJobOptions, frameNum: number /*int*/) => void;
+
+	// AS -> JS Bindings
+	// static _isSupported: boolean;
+
+	// _paperHeight: number /*int*/;
+	// _paperWidth: number /*int*/;
+	// _pageHeight: number /*int*/;
+	// _pageWidth: number /*int*/;
+	// _orientation: string;
+}

package/lib/_shumway_flash/printing/PrintJobOptions.ts

@@ -0,0 +1,25 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class PrintJobOptions extends ASObject {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string[] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string[] = null; // ["printAsBitmap"];
+
+	constructor(printAsBitmap: boolean = false) {
+		super();
+		this.printAsBitmap = !!printAsBitmap;
+	}
+
+	// JS -> AS Bindings
+
+	printAsBitmap: boolean;
+
+	// AS -> JS Bindings
+
+}

package/lib/_shumway_flash/printing/PrintJobOrientation.ts

@@ -0,0 +1,24 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class PrintJobOrientation extends ASObject {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string[] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string[] = null; // [];
+
+	constructor() {
+		super();
+	}
+
+	// JS -> AS Bindings
+	static LANDSCAPE: string = 'landscape';
+	static PORTRAIT: string = 'portrait';
+
+	// AS -> JS Bindings
+
+}

package/lib/_shumway_flash/profiler/Telemetry.ts

@@ -0,0 +1,48 @@
+import { ASObject } from '@awayfl/avm2';
+//import { ASFunction } from '@awayfl/avm2';
+import { axCoerceString } from '@awayjs/graphics';
+
+export class Telemetry extends ASObject {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string[] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string[] = null; // [];
+
+	constructor() {
+		super();
+	}
+
+	// static _spanMarker: number;
+	// static _connected: boolean;
+	get spanMarker(): number {
+		return 0;
+	}
+
+	get connected(): boolean {
+		return false;
+	}
+
+	static sendMetric(metric: string, value: any): void {
+		metric = axCoerceString(metric);
+	}
+
+	static sendSpanMetric(metric: string, startSpanMarker: number, value: any = null): void {
+		metric = axCoerceString(metric); startSpanMarker = +startSpanMarker;
+	}
+
+	static registerCommandHandler(commandName: string, handler: ASFunction): boolean {
+		commandName = axCoerceString(commandName);
+		return false;
+	}
+
+	static unregisterCommandHandler(commandName: string): boolean {
+		commandName = axCoerceString(commandName);
+		return false;
+	}
+
+}

package/lib/_shumway_flash/sampler/ClassFactory.ts

@@ -0,0 +1,22 @@
+import { ASClass, ASObject } from '@awayfl/avm2';
+export class ClassFactory extends ASObject {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string[] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string[] = null; // [];
+
+	constructor() {
+		super();
+	}
+
+	// JS -> AS Bindings
+	static StackFrameClass: ASClass = undefined;
+	static SampleClass: ASClass = undefined;
+	static DeleteObjectSampleClass: ASClass = undefined;
+	static NewObjectSampleClass: ASClass = undefined;
+}

package/lib/_shumway_flash/sampler/DeleteObjectSample.ts

@@ -0,0 +1,20 @@
+import { Sample } from '../../sampler/Sample';
+
+export class DeleteObjectSample extends Sample {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string[] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string[] = null; // [];
+
+	constructor() {
+		super();
+	}
+
+	id: number = undefined;
+	size: number = undefined;
+}

package/lib/_shumway_flash/sampler/StackFrame.ts

@@ -0,0 +1,22 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class StackFrame extends ASObject {
+
+	// Called whenever the class is initialized.
+	static classInitializer: any = null;
+
+	// List of static symbols to link.
+	static classSymbols: string[] = null; // [];
+
+	// List of instance symbols to link.
+	static instanceSymbols: string[] = null; // ["toString"];
+
+	constructor() {
+		super();
+	}
+
+	name: string = undefined;
+	file: string = undefined;
+	line: number /*uint*/ = undefined;
+	scriptID: number = undefined;
+}