@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/text/engine/DigitCase.ts

@@ -0,0 +1,19 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class DigitCase extends ASObject {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	constructor() {
+		super();
+	}
+
+	// JS -> AS Bindings
+	public static DEFAULT: string = 'default';
+	public static LINING: string = 'lining';
+	public static OLD_STYLE: string = 'oldStyle';
+
+	// AS -> JS Bindings
+
+}

package/lib/text/engine/DigitWidth.ts

@@ -0,0 +1,19 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class DigitWidth extends ASObject {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	constructor() {
+		super();
+	}
+
+	// JS -> AS Bindings
+	public static DEFAULT: string = 'default';
+	public static PROPORTIONAL: string = 'proportional';
+	public static TABULAR: string = 'tabular';
+
+	// AS -> JS Bindings
+
+}

package/lib/text/engine/EastAsianJustifier.ts

@@ -0,0 +1,50 @@
+import { axCoerceString } from '@awayfl/avm2';
+import { Debug } from '@awayjs/core';
+import { TextJustifier } from './TextJustifier';
+
+export class EastAsianJustifier extends TextJustifier {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	constructor(
+		locale: string = 'ja',
+		lineJustification: string = 'allButLast',
+		justificationStyle: string = 'pushInKinsoku') {
+		locale = axCoerceString(locale);
+		lineJustification = axCoerceString(lineJustification);
+		justificationStyle = axCoerceString(justificationStyle);
+		super(undefined, undefined);
+	}
+
+	// JS -> AS Bindings
+
+	public clone: () => TextJustifier;
+
+	// AS -> JS Bindings
+
+	// _justificationStyle: string;
+	// _composeTrailingIdeographicSpaces: boolean;
+	public get justificationStyle(): string {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/EastAsianJustifier', 'get justificationStyle', '');
+		return null;
+	}
+
+	public set justificationStyle(value: string) {
+		value = axCoerceString(value);
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/EastAsianJustifier', 'set justificationStyle', '');
+	}
+
+	public get composeTrailingIdeographicSpaces(): boolean {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/EastAsianJustifier', 'get composeTrailingIdeographicSpaces', '');
+		return null;
+	}
+
+	public set composeTrailingIdeographicSpaces(value: boolean) {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/EastAsianJustifier', 'set composeTrailingIdeographicSpaces', '');
+	}
+}

package/lib/text/engine/ElementFormat.ts

@@ -0,0 +1,323 @@
+import { ASObject, axCoerceString } from '@awayfl/avm2';
+import { FontDescription } from './FontDescription';
+import { FontMetrics } from './FontMetrics';
+import { TextFormat, TextFormatAlign } from '@awayjs/scene';
+import { FontLookUpMode } from '@awayjs/scene';
+import { TextBaseline } from './TextBaseline';
+import { Debug } from '@awayjs/core';
+
+const noLogs = true;
+let elementFormatIDs = 0;
+export class ElementFormat extends ASObject {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	private _fontDescription: FontDescription;
+	private _fontSize: number;
+	private _color: number;
+	private _alpha: number;
+	private _textRotation: string;
+	private _dominantBaseline: string;
+	private _alignmentBaseline: string;
+	private _baselineShift;
+	private _kerning: string;
+	private _trackingRight: number;
+	private _trackingLeft: number;
+	private _locale: string;
+	private _breakOpportunity: string;
+	private _digitCase: string;
+	private _digitWidth: string;
+	private _ligatureLevel: string;
+	private _typographicCase: string;
+	private _locked: boolean;
+	private _id: number;
+
+	constructor(
+		fontDescription: FontDescription = null,
+		fontSize: number = 12,
+		color: number /*uint*/ = 0,
+		alpha: number = 1,
+		textRotation: string = 'auto',
+		dominantBaseline: string = 'roman',
+		alignmentBaseline: string = 'useDominantBaseline',
+		baselineShift: number = 0,
+		kerning: string = 'on',
+		trackingRight: number = 0,
+		trackingLeft: number = 0,
+		locale: string = 'en',
+		breakOpportunity: string = 'auto',
+		digitCase: string = 'default',
+		digitWidth: string = 'default',
+		ligatureLevel: string = 'common',
+		typographicCase: string = 'default') {
+
+		super();
+
+		this._id = elementFormatIDs++;
+		noLogs || console.log('[ElementFormat] ' + this._id + ' constructor',
+			'fontDescription', fontDescription,
+			'fontSize', fontSize,
+			'color', color,
+			'alpha', alpha,
+			'textRotation', textRotation,
+			'dominantBaseline', dominantBaseline,
+			'alignmentBaseline', alignmentBaseline,
+			'baselineShift', baselineShift,
+			'kerning', kerning,
+			'trackingRight', trackingRight,
+			'trackingLeft', trackingLeft,
+			'locale', locale,
+			'breakOpportunity', breakOpportunity,
+			'digitCase', digitCase,
+			'digitWidth', digitWidth,
+			'ligatureLevel', ligatureLevel,
+			'typographicCase', typographicCase,
+		);
+		this._fontDescription = fontDescription;
+		this._fontSize = +fontSize;
+		this._color = color >>> 0;
+		this._alpha = +alpha;
+		this._textRotation = axCoerceString(textRotation);
+		this._dominantBaseline = axCoerceString(dominantBaseline);
+		this._alignmentBaseline = axCoerceString(alignmentBaseline);
+		this._baselineShift = +baselineShift;
+		this._kerning = axCoerceString(kerning);
+		this._trackingRight = +trackingRight;
+		this._trackingLeft = +trackingLeft;
+		this._locale = axCoerceString(locale);
+		this._breakOpportunity = axCoerceString(breakOpportunity);
+		this._digitCase = axCoerceString(digitCase);
+		this._digitWidth = axCoerceString(digitWidth);
+		this._ligatureLevel = axCoerceString(ligatureLevel);
+		this._typographicCase = axCoerceString(typographicCase);
+
+	}
+
+	public createAwayTextformat(): TextFormat {
+		const awayTextFormat = new TextFormat();
+		awayTextFormat.size = this._fontSize;
+		awayTextFormat.color = this._color;
+		awayTextFormat.fontLookUpMode = <FontLookUpMode>(this._fontDescription ?
+			this._fontDescription.fontLookup : FontLookUpMode.DEVICE);
+		awayTextFormat.font_name = this._fontDescription?.fontName;
+		awayTextFormat.italic = this._fontDescription?.fontPosture == 'italic';
+		awayTextFormat.bold = this._fontDescription?.fontWeight == 'bold';
+		awayTextFormat.align = TextFormatAlign.LEFT;
+
+		if (this._baselineShift != 0) {
+			console.warn('baselineshift is not 0', this._baselineShift);
+		}
+		if (this._alignmentBaseline != TextBaseline.USE_DOMINANT_BASELINE) {
+			console.warn('_alignmentBaseline is not USE_DOMINANT_BASELINE', this._alignmentBaseline);
+		}
+		if (this._dominantBaseline != TextBaseline.ROMAN) {
+			console.warn('_dominantBaseline is not ROMAN', this._dominantBaseline);
+		}
+		if (this._trackingRight != 0) {
+			console.warn('_trackingRight is not 0', this._trackingRight);
+		}
+		if (this._trackingLeft != 0) {
+			console.warn('_trackingLeft is not 0', this._trackingLeft);
+		}
+		if (this._alpha != 1) {
+			console.warn('_alpha is not 1', this._alpha);
+		}
+		if (this._digitCase != 'default') {
+			console.warn('_digitCase is not "default"', this._digitCase);
+		}
+		if (this._digitWidth != 'default') {
+			console.warn('_digitWidth is not "default"', this._digitWidth);
+		}
+		if (this._typographicCase != 'default') {
+			console.warn('_typographicCase is not "default"', this._typographicCase);
+		}
+		if (this._ligatureLevel != 'common') {
+			console.warn('_ligatureLevel is not "common"', this._ligatureLevel);
+		}
+
+		noLogs || console.log('[ElementFormat] ' + this._id + ' createAwayTextformat', awayTextFormat.id,
+			'fontDescription', this._fontDescription,
+			'fontSize', this._fontSize,
+			'color', this._color,
+			'alpha', this._alpha,
+			'textRotation', this._textRotation,
+			'dominantBaseline', this._dominantBaseline,
+			'alignmentBaseline', this._alignmentBaseline,
+			'baselineShift', this._baselineShift,
+			'kerning', this._kerning,
+			'trackingRight', this._trackingRight,
+			'trackingLeft', this._trackingLeft,
+			'locale', this._locale,
+			'breakOpportunity', this._breakOpportunity,
+			'digitCase', this._digitCase,
+			'digitWidth', this._digitWidth,
+			'ligatureLevel', this._ligatureLevel,
+			'typographicCase', this._typographicCase,
+		);
+
+		return awayTextFormat;
+	}
+	// JS -> AS Bindings
+
+	public clone: () => ElementFormat;
+
+	// AS -> JS Bindings
+
+	public getBaseline(): string {
+		if (this._alignmentBaseline == TextBaseline.USE_DOMINANT_BASELINE) {
+			return this._dominantBaseline;
+		}
+		return this._alignmentBaseline;
+	}
+
+	public get alignmentBaseline(): string {
+		return this._alignmentBaseline;
+	}
+
+	public set alignmentBaseline(alignmentBaseline: string) {
+		this._alignmentBaseline = axCoerceString(alignmentBaseline);
+	}
+
+	public get alpha(): number {
+		return this._alpha;
+	}
+
+	public set alpha(value: number) {
+		this._alpha = +value;
+	}
+
+	public get baselineShift(): number {
+		return this._baselineShift;
+	}
+
+	public set baselineShift(value: number) {
+		this._baselineShift = +value;
+	}
+
+	public get breakOpportunity(): string {
+		return this._breakOpportunity;
+	}
+
+	public set breakOpportunity(opportunityType: string) {
+		this._breakOpportunity = axCoerceString(opportunityType);
+	}
+
+	public get color(): number /*uint*/ {
+		return this._color;
+	}
+
+	public set color(value: number /*uint*/) {
+		this._color = value >>> 0;
+	}
+
+	public get dominantBaseline(): string {
+		return this._dominantBaseline;
+	}
+
+	public set dominantBaseline(dominantBaseline: string) {
+		this._dominantBaseline = axCoerceString(dominantBaseline);
+	}
+
+	public get fontDescription(): FontDescription {
+		return this._fontDescription;
+	}
+
+	public set fontDescription(value: FontDescription) {
+		this._fontDescription = value;
+	}
+
+	public get digitCase(): string {
+		return this._digitCase;
+	}
+
+	public set digitCase(digitCaseType: string) {
+		this._digitCase = axCoerceString(digitCaseType);
+	}
+
+	public get digitWidth(): string {
+		return this._digitWidth;
+	}
+
+	public set digitWidth(digitWidthType: string) {
+		this._digitWidth = axCoerceString(digitWidthType);
+	}
+
+	public get ligatureLevel(): string {
+		return this._ligatureLevel;
+	}
+
+	public set ligatureLevel(ligatureLevelType: string) {
+		this._ligatureLevel = axCoerceString(ligatureLevelType);
+	}
+
+	public get fontSize(): number {
+		return this._fontSize;
+	}
+
+	public set fontSize(value: number) {
+		this._fontSize = +value;
+	}
+
+	public get kerning(): string {
+		return this._kerning;
+	}
+
+	public set kerning(value: string) {
+		this._kerning = axCoerceString(value);
+	}
+
+	public get locale(): string {
+		return this._locale;
+	}
+
+	public set locale(value: string) {
+		this._locale = axCoerceString(value);
+	}
+
+	public get textRotation(): string {
+		return this._textRotation;
+	}
+
+	public set textRotation(value: string) {
+		this._textRotation = axCoerceString(value);
+	}
+
+	public get trackingRight(): number {
+		return this._trackingRight;
+	}
+
+	public set trackingRight(value: number) {
+		this._trackingRight = +value;
+	}
+
+	public get trackingLeft(): number {
+		return this._trackingLeft;
+	}
+
+	public set trackingLeft(value: number) {
+		this._trackingLeft = +value;
+	}
+
+	public get typographicCase(): string {
+		return this._typographicCase;
+	}
+
+	public set typographicCase(typographicCaseType: string) {
+		this._typographicCase = axCoerceString(typographicCaseType);
+	}
+
+	public get locked(): boolean {
+		return this._locked;
+	}
+
+	public set locked(value: boolean) {
+		this._locked = value;
+	}
+
+	public getFontMetrics(): FontMetrics {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/ElementFormat', 'set getFontMetrics', '');
+		return null;
+	}
+}

package/lib/text/engine/FontDescription.ts

@@ -0,0 +1,114 @@
+import { ASObject, axCoerceString } from '@awayfl/avm2';
+import { Debug } from '@awayjs/core';
+
+export class FontDescription extends ASObject {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	private _renderingMode: string;
+	private _fontLookup: string;
+	private _fontName: string;
+	private _fontPosture: string;
+	private _fontWeight: string;
+	private _cffHinting: string;
+	private _locked: boolean;
+
+	constructor(
+		fontName: string = '_serif',
+		fontWeight: string = 'normal',
+		fontPosture: string = 'normal',
+		fontLookup: string = 'device',
+		renderingMode: string = 'cff',
+		cffHinting: string = 'horizontalStem') {
+		super();
+		this._fontName = axCoerceString(fontName);
+		this._fontWeight = axCoerceString(fontWeight);
+		this._fontPosture = axCoerceString(fontPosture);
+		this._fontLookup = axCoerceString(fontLookup);
+		this._renderingMode = axCoerceString(renderingMode);
+		this._cffHinting = axCoerceString(cffHinting);
+	}
+
+	// JS -> AS Bindings
+
+	public clone: () => FontDescription;
+
+	// AS -> JS Bindings
+	public static isFontCompatible(
+		fontName: string,
+		fontWeight: string,
+		fontPosture: string): boolean {
+		fontName = axCoerceString(fontName);
+		fontWeight = axCoerceString(fontWeight);
+		fontPosture = axCoerceString(fontPosture);
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/FontDescription', 'static isFontCompatible', '');
+		return null;
+	}
+
+	public static isDeviceFontCompatible(fontName: string, fontWeight: string, fontPosture: string): boolean {
+		fontName = axCoerceString(fontName);
+		fontWeight = axCoerceString(fontWeight);
+		fontPosture = axCoerceString(fontPosture);
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/FontDescription', 'static isDeviceFontCompatible', '');
+		return null;
+	}
+
+	public get renderingMode(): string {
+		return this._renderingMode;
+	}
+
+	public set renderingMode(value: string) {
+		this._renderingMode = axCoerceString(value);
+	}
+
+	public get fontLookup(): string {
+		return this._fontLookup;
+	}
+
+	public set fontLookup(value: string) {
+		this._fontLookup = axCoerceString(value);
+	}
+
+	public get fontName(): string {
+		return this._fontName;
+	}
+
+	public set fontName(value: string) {
+		this._fontName = axCoerceString(value);
+	}
+
+	public get fontPosture(): string {
+		return this._fontPosture;
+	}
+
+	public set fontPosture(value: string) {
+		this._fontPosture = axCoerceString(value);
+	}
+
+	public get fontWeight(): string {
+		return this._fontWeight;
+	}
+
+	public set fontWeight(value: string) {
+		this._fontWeight = axCoerceString(value);
+	}
+
+	public get cffHinting(): string {
+		return this._cffHinting;
+	}
+
+	public set cffHinting(value: string) {
+		this._cffHinting = axCoerceString(value);
+	}
+
+	public get locked(): boolean {
+		return this._locked;
+	}
+
+	public set locked(value: boolean) {
+		this._locked = value;
+	}
+}

package/lib/text/engine/FontLookup.ts

@@ -0,0 +1,18 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class FontLookup extends ASObject {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	constructor() {
+		super();
+	}
+
+	// JS -> AS Bindings
+	public static DEVICE: string = 'device';
+	public static EMBEDDED_CFF: string = 'embeddedCFF';
+
+	// AS -> JS Bindings
+
+}

package/lib/text/engine/FontMetrics.ts

@@ -0,0 +1,47 @@
+import { ASObject } from '@awayfl/avm2';
+import { Rectangle } from '../../geom/Rectangle';
+
+export class FontMetrics extends ASObject {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	constructor(
+		emBox: Rectangle,
+		strikethroughOffset: number,
+		strikethroughThickness: number,
+		underlineOffset: number,
+		underlineThickness: number,
+		subscriptOffset: number,
+		subscriptScale: number,
+		superscriptOffset: number,
+		superscriptScale: number, lineGap: number = 0) {
+		super();
+		this.emBox = emBox;
+		this.strikethroughOffset = +strikethroughOffset;
+		this.strikethroughThickness = +strikethroughThickness;
+		this.underlineOffset = +underlineOffset;
+		this.underlineThickness = +underlineThickness;
+		this.subscriptOffset = +subscriptOffset;
+		this.subscriptScale = +subscriptScale;
+		this.superscriptOffset = +superscriptOffset;
+		this.superscriptScale = +superscriptScale;
+		this.lineGap = +lineGap;
+	}
+
+	// JS -> AS Bindings
+
+	public emBox: Rectangle;
+	public strikethroughOffset: number;
+	public strikethroughThickness: number;
+	public underlineOffset: number;
+	public underlineThickness: number;
+	public subscriptOffset: number;
+	public subscriptScale: number;
+	public superscriptOffset: number;
+	public superscriptScale: number;
+	public lineGap: number;
+
+	// AS -> JS Bindings
+
+}

package/lib/text/engine/FontPosture.ts

@@ -0,0 +1,18 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class FontPosture extends ASObject {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	constructor() {
+		super();
+	}
+
+	// JS -> AS Bindings
+	public static NORMAL: string = 'normal';
+	public static ITALIC: string = 'italic';
+
+	// AS -> JS Bindings
+
+}

package/lib/text/engine/FontWeight.ts

@@ -0,0 +1,18 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class FontWeight extends ASObject {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	constructor() {
+		super();
+	}
+
+	// JS -> AS Bindings
+	public static NORMAL: string = 'normal';
+	public static BOLD: string = 'bold';
+
+	// AS -> JS Bindings
+
+}

package/lib/text/engine/GraphicElement.ts

@@ -0,0 +1,69 @@
+import { axCoerceString } from '@awayfl/avm2';
+import { Debug } from '@awayjs/core';
+import { DisplayObject } from '../../display/DisplayObject';
+import { EventDispatcher } from '../../events/EventDispatcher';
+import { ContentElement } from './ContentElement';
+import { ElementFormat } from './ElementFormat';
+
+export class GraphicElement extends ContentElement {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	constructor(
+		graphic: DisplayObject = null,
+		elementWidth: number = 15,
+		elementHeight: number = 15,
+		elementFormat: ElementFormat = null,
+		eventMirror: EventDispatcher = null,
+		textRotation: string = 'rotate0') {
+		super(undefined, undefined, undefined);
+		this.graphic = graphic;
+		this.elementWidth = +elementWidth;
+		this.elementHeight = +elementHeight;
+		this.elementFormat = elementFormat;
+		this.eventMirror = eventMirror;
+		this.textRotation = axCoerceString(textRotation);
+	}
+
+	// JS -> AS Bindings
+
+	// AS -> JS Bindings
+
+	// _graphic: flash.display.DisplayObject;
+	// _elementHeight: number;
+	// _elementWidth: number;
+	public get graphic(): DisplayObject {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/GraphicElement', 'get graphic', '');
+		return null;
+	}
+
+	public set graphic(value: DisplayObject) {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/GraphicElement', 'set graphic', '');
+	}
+
+	public get elementHeight(): number {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/GraphicElement', 'get elementHeight', '');
+		return null;
+	}
+
+	public set elementHeight(value: number) {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/GraphicElement', 'set elementHeight', '');
+	}
+
+	public get elementWidth(): number {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/GraphicElement', 'get elementWidth', '');
+		return null;
+	}
+
+	public set elementWidth(value: number) {
+		value = +value;
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/GraphicElement', 'set elementWidth', '');
+	}
+}