@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/system/Security.ts

@@ -0,0 +1,119 @@
+
+import { ASArray, ASObject, axCoerceString } from '@awayfl/avm2';
+import { notImplemented, release, somewhatImplemented, FileLoadingService } from '@awayfl/swf-loader';
+export class Security 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 REMOTE: string = 'remote';
+	static LOCAL_WITH_FILE: string = 'localWithFile';
+	static LOCAL_WITH_NETWORK: string = 'localWithNetwork';
+	static LOCAL_TRUSTED: string = 'localTrusted';
+	static APPLICATION: string = 'application';
+
+	// AS -> JS Bindings
+	private static _exactSettings: boolean = false;
+	// static _disableAVM1Loading: boolean;
+	private static _sandboxType: string = 'remote';
+	// static _pageDomain: string;
+	static get exactSettings(): boolean {
+		return Security._exactSettings;
+	}
+
+	static set exactSettings(value: boolean) {
+		value = !!value;
+		Security._exactSettings = value;
+	}
+
+	static get disableAVM1Loading(): boolean {
+		release || notImplemented('public flash.system.Security::get disableAVM1Loading'); return;
+		// return Security._disableAVM1Loading;
+	}
+
+	static set disableAVM1Loading(value: boolean) {
+		value = !!value;
+		release || notImplemented('public flash.system.Security::set disableAVM1Loading'); return;
+		// Security._disableAVM1Loading = value;
+	}
+
+	static get sandboxType(): string {
+		release || somewhatImplemented('public flash.system.Security::get sandboxType');
+		return Security._sandboxType;
+	}
+
+	static get pageDomain(): string {
+		release || somewhatImplemented('public flash.system.Security::get pageDomain');
+		// TODO: convert this to proper URI parsing.
+		const pageHost: string = FileLoadingService.resolveUrl('/');
+		const parts = pageHost.split('/'); parts.pop();
+		return parts.pop();
+	}
+
+	static allowDomain(): void {
+		release || somewhatImplemented('public flash.system.Security::static allowDomain ["' +
+      Array.prototype.join.call(arguments, '", "') + '"]');
+		/*var whitelist: ICrossDomainSWFLoadingWhitelist = this.sec.player;
+    for (var i = 0; i < arguments.length; i++) {
+      whitelist.addToSWFLoadingWhitelist(axCoerceString(arguments[i]) || '', false, false);
+    }*/
+	}
+
+	static allowInsecureDomain(): void {
+		release || somewhatImplemented('public flash.system.Security::static allowInsecureDomain');
+		/*var whitelist: ICrossDomainSWFLoadingWhitelist = this.sec.player;
+    for (var i = 0; i < arguments.length; i++) {
+      whitelist.addToSWFLoadingWhitelist(axCoerceString(arguments[i]) || '', true, false);
+    }*/
+	}
+
+	static loadPolicyFile(url: string): void {
+		url = axCoerceString(url);
+		release || somewhatImplemented('public flash.system.Security::static loadPolicyFile');
+	}
+
+	static showSettings(panel: string = 'default'): void {
+		panel = axCoerceString(panel);
+		release || notImplemented('public flash.system.Security::static showSettings'); return;
+	}
+
+	static duplicateSandboxBridgeInputArguments(toplevel: ASObject, args: ASArray): ASArray {
+		release || notImplemented('public flash.system.Security::static duplicateSandboxBridgeInputArguments'); return;
+	}
+
+	static duplicateSandboxBridgeOutputArgument(toplevel: ASObject, arg: any): any {
+		release || notImplemented('public flash.system.Security::static duplicateSandboxBridgeOutputArgument'); return;
+	}
+
+}
+
+export const enum CrossDomainSWFLoadingWhitelistResult {
+	/**
+   * The requested domain belongs to the same domain as SWF's.
+   */
+	OwnDomain = 0,
+	/**
+   * The requested domain belongs to the other domain than SWF's.
+   */
+	Remote = 1,
+	/**
+   * The requested domain is not whitelisted.
+   */
+	Failed = 2
+}
+
+export interface ICrossDomainSWFLoadingWhitelist {
+	addToSWFLoadingWhitelist(domain: string, insecure: boolean, ownDomain: boolean);
+	checkDomainForSWFLoading(domain: string): CrossDomainSWFLoadingWhitelistResult;
+}

package/lib/system/SecurityDomain.ts

@@ -0,0 +1,9 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class SecurityDomain extends ASObject {
+
+	//todo!
+	public static get currentDomain(): SecurityDomain {
+		return null;
+	}
+}

package/lib/system/System.ts

@@ -0,0 +1,225 @@
+//import { XML } from "../xml/XML";
+
+import { notImplemented } from '@awayfl/swf-loader';
+import { IME } from './IME';
+import { ASObject } from '@awayfl/avm2';
+
+/**
+ * The System class contains properties related to local settings and operations.
+ * Among these are <ph class="- topic/ph ">
+ * settings for camers and microphones, operations with shared objects and</ph> the use of the Clipboard.
+ *
+ *   <p class="- topic/p ">Additional properties and methods are in other classes within the flash.system package:
+ * the Capabilities class, <ph class="- topic/ph ">the IME class,</ph> and the
+ * Security class.</p><p class="- topic/p ">This class contains only static methods and properties. You cannot
+ * create new instances of the System class.</p>
+ */
+export class System extends ASObject {
+	static axClass: typeof System;
+	constructor () {
+		super();
+	}
+
+	/**
+	 * The amount of memory (in bytes) that is allocated to
+	 * Adobe® Flash® Player or
+	 * Adobe® AIR® and that is not in use. This unused portion of
+	 * allocated memory (System.totalMemory) fluctuates as garbage collection takes place.
+	 * Use this property to monitor garbage collection.
+	 */
+	public static get freeMemory (): number {
+		notImplemented('public flash.system.System::freeMemory');
+		return 0;
+	}
+
+	/**
+	 * The currently installed system IME.
+	 * To register for imeComposition events, call
+	 * addEventListener() on this instance.
+	 */
+	public static get ime (): IME {
+		notImplemented('public flash.system.System::ime');
+		return null;
+	}
+
+	/**
+	 * The entire amount of memory (in bytes) used by an application.
+	 * This is the amount of resident private memory for the entire process.
+	 *
+	 *   AIR developers should use this property to determine the entire memory consumption of an application.
+	 * For Flash Player, this includes the memory used by the container application,
+	 * such as the web browser.
+	 */
+	public static get privateMemory (): number {
+		notImplemented('public flash.system.System::privateMemory');
+		return 0;
+	}
+
+	public static get processCPUUsage (): number {
+		notImplemented('public flash.system.System::processCPUUsage');
+		return 0;
+	}
+
+	/**
+	 * The amount of memory (in bytes) currently in use that has been directly allocated by
+	 * Flash Player or AIR.
+	 *
+	 *   This property does not return all memory used by an Adobe AIR application or by
+	 * the application (such as a browser) containing Flash Player content. The browser or
+	 * operating system may consume other memory. The System.privateMemory property reflects all memory used by
+	 * an application.If the amount of memory allocated is greater than the maximum value for a uint object
+	 * (uint.MAX_VALUE,
+	 * or 4,294,967,295), then this property is set to 0. The System.totalMemoryNumber property allows
+	 * larger values.
+	 */
+	public static get totalMemory (): number {
+		notImplemented('public flash.system.System::totalMemory');
+		return 0;
+	}
+
+	/**
+	 * The amount of memory (in bytes) currently in use that has been directly allocated by
+	 * Flash Player or AIR.
+	 *
+	 *   This property is expressed as a Number, which allows higher values than the
+	 * System.totalMemory property, which is of type int.This property does not return all memory used by an Adobe AIR
+	 * application or by
+	 * the application (such as a browser) containing Flash Player content. The browser or
+	 * operating system may consume other memory. The System.privateMemory property reflects all memory used by
+	 * an application.
+	 */
+	public static get totalMemoryNumber (): number {
+		notImplemented('public flash.system.System::totalMemoryNumber');
+		return 0;
+	}
+
+	/**
+	 * A Boolean value that determines which code page to use to interpret external text files.
+	 * When the property is set to false, external text files are interpretted as Unicode.
+	 * (These files must be encoded as Unicode when you save them.) When the property is set to
+	 * true, external text files are interpretted using the traditional code page of the
+	 * operating system running the application. The default value of useCodePage is false.
+	 *
+	 *   Text that you load as an external file (using Loader.load(), the URLLoader class or
+	 * URLStream) must have been saved as Unicode in order for the application to recognize it
+	 * as Unicode. To encode external files as Unicode, save the files in an application that
+	 * supports Unicode, such as Notepad on Windows.If you load external text files that are not Unicode-encoded,
+	 * set useCodePage to true.
+	 * Add the following as the first line of code of the file that
+	 * is loading the data (for Flash Professional, add it to the first frame):System.useCodePage = true;
+	 * When this code is present, the application interprets external text
+	 * using the traditional code page of the operating system.
+	 * For example, this is generally CP1252 for an English Windows operating
+	 * system and Shift-JIS for a Japanese operating system.If you set useCodePage to true,
+	 * Flash Player 6 and later treat text as Flash Player 5 does. (Flash Player 5
+	 * treated all text as if it were in the traditional code page of the operating
+	 * system running the player.)If you set useCodePage to true, remember that the
+	 * traditional code page of the operating system running the application must include
+	 * the characters used in your external text file in order to display your text.
+	 * For example, if you load an external text file that contains Chinese characters,
+	 * those characters cannot display on a system that uses the CP1252 code page because
+	 * that code page does not include Chinese characters.To ensure that users on all platforms
+	 * can view external text files used in your
+	 * application, you should encode all external text files as Unicode and leave
+	 * useCodePage set to false. This way, the application
+	 * (Flash Player 6 and later, or AIR) interprets the text as Unicode.
+	 */
+	public static get useCodePage (): boolean {
+		notImplemented('public flash.system.System::useCodePage');
+		return false;
+	}
+
+	public static set useCodePage (value: boolean) {
+		notImplemented('public flash.system.System::useCodePage');
+	}
+
+	public static get vmVersion (): string {
+		notImplemented('public flash.system.System::vmVersion');
+		return '';
+	}
+
+	/**
+	 * Makes the specified XML object immediately available for garbage collection.
+	 * This method will remove parent and child connections between all the nodes
+	 * for the specified XML node.
+	 * @param	node	XML reference that should be made available for garbage collection.
+	 */
+	public static disposeXML (node: any/*XML*/) {
+		notImplemented('public flash.system.System::disposeXML');
+	}
+
+	/**
+	 * Closes Flash Player.
+	 *
+	 *   For the standalone Flash Player debugger version only.AIR applications
+	 * should call the NativeApplication.exit() method to exit the application.
+	 * @param	code	A value to pass to the operating system. Typically, if
+	 *   the process exits normally, the value is 0.
+	 */
+	public static exit (code: number) {
+		notImplemented('public flash.system.System::exit');
+	}
+
+	/**
+	 * Forces the garbage collection process.
+	 *
+	 *   For the Flash Player debugger version and AIR applications only.
+	 * In an AIR application, the System.gc() method is only enabled in content running in the AIR Debug Launcher
+	 * (ADL) or, in an installed applcation, in content in the application security sandbox.
+	 */
+	public static gc () {
+		notImplemented('public flash.system.System::gc');
+	}
+
+	/**
+	 * Pauses Flash Player or the AIR Debug Launcher (ADL).
+	 * After calling this method, nothing in the application continues except the delivery of Socket events.
+	 *
+	 *   For the Flash Player debugger version or the AIR Debug Launcher (ADL) only.
+	 */
+	public static pause () {
+		notImplemented('public flash.system.System::pause');
+	}
+
+	public static pauseForGCIfCollectionImminent (imminence: number = 0.75) {
+		notImplemented('public flash.system.System::pauseForGCIfCollectionImminent');
+	}
+
+	/**
+	 * Resumes the application after calling System.pause().
+	 *
+	 *   For the Flash Player debugger version or the AIR Debug Launcher (ADL) only.
+	 */
+	public static resume () {
+		notImplemented('public flash.system.System::resume');
+	}
+
+	/**
+	 * Replaces the contents of the Clipboard with a specified text string. This method works from any security
+	 * context when called as a result of a user event (such as a keyboard or input device event handler).
+	 *
+	 *   This method is provided for SWF content running in Flash Player 9. It allows only adding
+	 * String content to the Clipboard.Flash Player 10 content and content in the application security sandbox
+	 * in an AIR application can call
+	 * the Clipboard.setData() method.
+	 * @param	string	A plain-text string of characters to put on the system Clipboard,
+	 * replacing its current contents (if any).
+	 */
+	public static setClipboard (string: string) {
+
+		if (navigator.clipboard && navigator.clipboard.writeText) {
+			navigator.clipboard.writeText(string)
+				.then((_e) => {
+					console.log('[flash/System] Clipboard writed!');
+				})
+				.catch((e) => {
+					console.warn('[flash/System] Clipboard write rejected!', e);
+				});
+
+			return;
+		}
+
+		notImplemented('public flash.system.System::setClipboard');
+	}
+
+}

package/lib/system/TouchscreenType.ts

@@ -0,0 +1,37 @@
+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: TouchscreenType
+export class TouchscreenType 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 FINGER: string = 'finger';
+	static STYLUS: string = 'stylus';
+	static NONE: string = 'none';
+}

package/lib/text/AntiAliasType.ts

@@ -0,0 +1 @@
+export { AntiAliasType } from '@awayjs/scene';

package/lib/text/CSMSettings.ts

@@ -0,0 +1,25 @@
+
+import { ASObject } from '@awayfl/avm2';
+import { Debug } from '@awayjs/core';
+
+export class CSMSettings extends ASObject {
+
+	public static classInitializer: any = null;
+	public static classSymbols: string [] = null;
+	public static instanceSymbols: string [] = null; // ["fontSize", "insideCutoff", "outsideCutoff"];
+
+	// JS -> AS Bindings
+	public fontSize: number;
+	public insideCutoff: number;
+	public outsideCutoff: number;
+
+	constructor(fontSize: number, insideCutoff: number, outsideCutoff: number) {
+		super();
+		this.fontSize = +fontSize;
+		this.insideCutoff = +insideCutoff;
+		this.outsideCutoff = +outsideCutoff;
+		// @todo
+		Debug.throwPIR('playerglobals/text/CSMSettings', 'constructor', '');
+	}
+
+}

package/lib/text/Font.ts

@@ -0,0 +1,60 @@
+import { ASObject } from '@awayfl/avm2';
+import { Debug } from '@awayjs/core';
+import { DefaultFontManager, Font as AwayFont } from '@awayjs/scene';
+
+export class Font extends ASObject {
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+	static classInitializer: any = null;
+	static classSymbols: string[] = null;
+	static instanceSymbols: string[] = null;
+
+	public isAVMFont: boolean = true;
+
+	private _adaptee: AwayFont;
+
+	constructor() {
+		super();
+		this.isAVMFont = true;
+		if (this.axClassName != 'Font') {
+			this._adaptee = DefaultFontManager.getFont(this.axClassName);
+			// Also alias under Font.fontName for TextFormat lookup / embedFonts.
+			if (this._adaptee?.name) {
+				DefaultFontManager.registerFontForClassName(this._adaptee, this._adaptee.name);
+			}
+		}
+	}
+
+	public get fontName(): string {
+		return this._adaptee?.name;
+	}
+
+	public get fontStyle(): string {
+		// @todo
+		Debug.throwPIR('playerglobals/text/Font', 'get fontStyle', '');
+		return 'regular';
+	}
+
+	public get fontType(): string {
+		// @todo
+		Debug.throwPIR('playerglobals/text/Font', 'get fontType', '');
+		return 'embedded';
+	}
+
+	static enumerateFonts(enumerateDeviceFonts: Boolean = false): [] {
+		// @todo
+		Debug.throwPIR('playerglobals/text/Font', 'enumerateFonts', '');
+		return [];
+	}
+
+	static registerFont(font: any): void {
+		// this is not needed for AwayJS, because fonts are already registered after parsing
+		//console.warn('`Font.registerFont` not implement yet');
+	}
+
+	public hasGlyphs(str: String): Boolean {
+		// @todo
+		Debug.throwPIR('playerglobals/text/Font', 'hasGlyphs', '');
+		return false;
+	}
+}

package/lib/text/FontStyle.ts

@@ -0,0 +1,18 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class FontStyle extends ASObject {
+
+	static classInitializer: any = null;
+	static classSymbols: string [] = null;
+	static instanceSymbols: string [] = null;
+
+	constructor() {
+		super();
+	}
+
+	// JS -> AS Bindings
+	static REGULAR: string = 'regular';
+	static BOLD: string = 'bold';
+	static ITALIC: string = 'italic';
+	static BOLD_ITALIC: string = 'boldItalic';
+}

package/lib/text/FontType.ts

@@ -0,0 +1,18 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class FontType extends ASObject {
+
+	public static classInitializer: any = null;
+	public static classSymbols: string [] = null;
+	public static instanceSymbols: string [] = null;
+
+	// JS -> AS Bindings
+	public static EMBEDDED: string = 'embedded';
+	public static EMBEDDED_CFF: string = 'embeddedCFF';
+	public static DEVICE: string = 'device';
+
+	constructor () {
+		super();
+	}
+
+}

package/lib/text/GridFitType.ts

@@ -0,0 +1 @@
+export { GridFitType } from '@awayjs/scene';

package/lib/text/StaticText.ts

@@ -0,0 +1,41 @@
+import { Debug } from '@awayjs/core';
+import { DisplayObject } from '../display/DisplayObject';
+
+export class StaticText extends DisplayObject {
+
+	public static classInitializer: any = null;
+	public static classSymbols: string [] = null;
+	public static instanceSymbols: string [] = null;
+
+	private _textContent: any/*TextContent*/;
+
+	//_symbol: TextSymbol;
+	public applySymbol() {
+		// @todo
+		Debug.throwPIR('playerglobals/text/StaticText', 'applySymbol', '');
+	}
+
+	constructor () {
+		super();
+		// @todo
+		Debug.throwPIR('playerglobals/text/StaticText', 'constructor', '');
+	}
+
+	public _canHaveTextContent(): boolean {
+		// @todo
+		Debug.throwPIR('playerglobals/text/StaticText', '_canHaveTextContent', '');
+		return true;
+	}
+
+	public _getTextContent(): any/*TextContent*/ {
+		// @todo
+		Debug.throwPIR('playerglobals/text/StaticText', '_getTextContent', '');
+		return this._textContent;
+	}
+
+	public get text(): string {
+		// @todo
+		Debug.throwPIR('playerglobals/text/StaticText', 'text', '');
+		return this._textContent.plainText;
+	}
+}