@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/text/engine/TextLine.ts

@@ -0,0 +1,434 @@
+import { ASObject } from '@awayfl/avm2';
+import { Debug } from '@awayjs/core';
+import {
+	TextField, DisplayObjectContainer as AwayDisplayObjectContainer,
+	TextFieldAutoSize, TextFormat
+} from '@awayjs/scene';
+import { DisplayObject } from '../../display/DisplayObject';
+import { DisplayObjectContainer } from '../../display/DisplayObjectContainer';
+import { EventDispatcher } from '../../events/EventDispatcher';
+import { Rectangle } from '../../geom/Rectangle';
+import { ContextMenu } from '../../ui/ContextMenu';
+import { ContentElement } from './ContentElement';
+import { ElementFormat } from './ElementFormat';
+import { TextBaseline } from './TextBaseline';
+import { TextBlock } from './TextBlock';
+import { TextLineMirrorRegion } from './TextLineMirrorRegion';
+import { TextLineValidity } from './TextLineValidity';
+
+const noLogs = true;
+
+export class TextLine extends DisplayObjectContainer {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	private _text: string;
+	private _focusRect: ASObject;
+	private _tabChildren: boolean;
+	private _tabEnabled: boolean;
+	private _tabIndex: number /*int*/;
+	private _textBlock: TextBlock;
+	private _hasGraphicElement: boolean;
+	private _hasTabs: boolean;
+	private _nextLine: TextLine;
+	private _previousLine: TextLine;
+	private _ascent: number;
+	private _descent: number;
+	private _textHeight: number;
+	private _textWidth: number;
+	private _totalAscent: number;
+	private _totalDescent: number;
+	private _totalHeight: number;
+	private _textBlockBeginIndex: number /*int*/;
+	private _rawText: string /*int*/;
+	private _textFormatsIndices: number[] /*int*/;
+	private _specifiedWidth: number;
+	private _unjustifiedTextWidth: number;
+	private _validity: string;
+	private _mirrorRegions: any /*ASVector<flash.text.engine.TextLineMirrorRegion>*/;
+
+	private _textFormats: TextFormat[];
+
+	private _width: number;
+	private _lineOffset: number;
+	private _fitSomething: boolean;
+	private _content: ContentElement;
+	private _textLength: number;
+	private _textfield: TextField;
+
+	constructor(
+		previousLine: TextLine,
+		width: number,
+		lineOffset: number,
+		fitSomething: boolean,
+		text: string,
+		formats: TextFormat[],
+		formatsIndices: number[],
+		textBlockBeginIndex: number,
+		textLength: number,
+		elementsFormats: ElementFormat[]) {
+		super();
+		const adaptee: AwayDisplayObjectContainer = new AwayDisplayObjectContainer();
+		this.adaptee = adaptee;
+		this._previousLine = previousLine;
+		if (previousLine) {
+			previousLine.setNextLine(this);
+		}
+		this._width = width;
+		this._textWidth = 0;
+		this._textHeight = 0;
+		this._lineOffset = lineOffset;
+		this._fitSomething = fitSomething;
+		this._rawText = text ? text : '';
+		this._textFormatsIndices = formatsIndices;
+		this._textFormats = formats;
+		this._textLength = textLength;
+		this._textBlockBeginIndex = textBlockBeginIndex;
+		this._specifiedWidth = this._width;
+
+		this._textfield = new TextField();
+		this.initTextline(elementsFormats);
+
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' textfield:', this._textfield,
+			'\n		previousLine', previousLine,
+			'\n		width', width,
+			'\n		lineOffset', lineOffset,
+			'\n		fitSomething', fitSomething,
+			'\n		text', text,
+			'\n		formats', formats,
+			'\n		formatsIndices', formatsIndices,
+			'\n		textBlockBeginIndex', textBlockBeginIndex,
+			'\n		textLength', textLength,
+			'\n		_ascent', this._ascent,
+			'\n		_descent', this._descent,
+			'\n		newTextField.textWidth', this._textfield.textWidth);
+	}
+
+	public initTextline(elementsFormats: ElementFormat[]) {
+		this._ascent = 0;
+		this._descent = Number.POSITIVE_INFINITY;
+		this._textfield.multiline = false;
+		this._textfield.border = false;
+		this._textfield.wordWrap = false;
+		const defaultFormat = this._textFormats[0];
+		const defaultElementFormat = elementsFormats[0];
+		const lastAlignmentBaseline = defaultElementFormat.getBaseline();
+		(<AwayDisplayObjectContainer> this.adaptee).addChild(this._textfield);
+		if (this._rawText !== '') {
+
+			this._textfield.autoSize = TextFieldAutoSize.LEFT;
+
+			this._textfield.text = this._rawText;
+			let startIdx = 0;
+			for (let i = 0; i < this._textFormatsIndices.length; i++) {
+				const textFormat = this._textFormats[i];
+				const elementFormat = elementsFormats[i];
+				if (lastAlignmentBaseline != elementFormat.getBaseline()) {
+					console.warn('[TextLine] - one Textline with different alignmentBaseline');
+				}
+				const endIdx = this._textFormatsIndices[i];
+				let ascent = (<any> textFormat).font_table.ascent;
+				let descent = (<any> textFormat).font_table.descent;
+				const em_size = (<any> textFormat).font_table.get_font_em_size();
+				ascent = (ascent / em_size) * textFormat.size;
+				descent = (descent / em_size) * textFormat.size;
+				/*console.log("em_size", em_size);
+				console.log("ascent", ascent);
+				console.log("descent", descent);
+				console.log("both", ascent + descent);*/
+
+				if (this._ascent < ascent) {
+					this._ascent = ascent;
+				}
+				if (this._descent > descent) {
+					this._descent = descent;
+				}
+				!this._textfield || this._textfield.setTextFormat(textFormat, startIdx, endIdx);
+				startIdx = endIdx;
+				this._textfield.height = this._ascent - this._descent;
+			}
+		} else {
+			this._textfield.autoSize = TextFieldAutoSize.NONE;
+			this._ascent = (<any> defaultFormat).font_table.ascent;
+			this._descent = (<any> defaultFormat).font_table.descent;
+			const em_size = (<any> defaultFormat).font_table.get_font_em_size();
+			this._ascent = (this._ascent / em_size) * defaultFormat.size;
+			this._descent = (this._descent / em_size) * defaultFormat.size;
+			this._textfield.width = 10;
+			this._textfield.height = this._ascent - this._descent;
+		}
+		this._textWidth = this._textfield ? this._textfield.textWidth + 4 : 10;
+		this._unjustifiedTextWidth = this._textWidth;
+		noLogs || console.log('[TextLine]', this._rawText.length, lastAlignmentBaseline, this._ascent, this._descent);
+		this._descent = Math.abs(this._descent);
+
+		this._ascent += 1;
+		if (lastAlignmentBaseline == TextBaseline.ROMAN) {
+			this._textfield.y = -(this._ascent);// - this._descent);
+		} else if (lastAlignmentBaseline == TextBaseline.ASCENT) {
+			this._textfield.y = -(this._ascent - this._descent) - this._ascent - this._descent;
+		} else {
+			console.warn('[TextLine] - unsupported alignmentBaseline', lastAlignmentBaseline);
+			this._textfield.y = -(this._ascent - this._descent) - this._ascent;
+		}
+		this._textfield.x = 0;
+		this._ascent = this._ascent - this._descent;
+
+		//this._forceWidth = this._ascent + this._descent;
+		//this._forceHeight = this._ascent - this._descent;
+		//this._forceHeight = 200;//Math.ceil(this._forceHeight * 20) / 20;
+		/*if (lineOffset == 0 && previousLine && previousLine._lineOffset) {
+			lineOffset = previousLine._lineOffset;
+		}*/
+
+		noLogs || console.log('[TextLine] ' + this.adaptee.id, '_rawText', this._rawText);
+
+		this._validity = TextLineValidity.VALID;
+	}
+
+	public static MAX_LINE_WIDTH: number /*int*/ = 1000000;
+
+	public reUseTextLine(
+		previousLine: TextLine,
+		width: number,
+		lineOffset: number,
+		fitSomething: boolean,
+		text: string,
+		formats: TextFormat[],
+		formatsIndices: number[],
+		textBlockBeginIndex: number,
+		textLength: number,
+		elementsFormats: ElementFormat[]) {
+
+		this.adaptee.x = 0;
+		this.adaptee.y = 0;
+		this._previousLine = previousLine;
+		if (previousLine) {
+			previousLine.setNextLine(this);
+		}
+		this._width = width;
+		this._textWidth = 0;
+		this._textHeight = 0;
+		this._lineOffset = lineOffset;
+		this._fitSomething = fitSomething;
+		this._rawText = text ? text : '';
+		this._textFormatsIndices = formatsIndices;
+		this._textFormats = formats;
+		this._textLength = textLength;
+		this._textBlockBeginIndex = textBlockBeginIndex;
+		this._specifiedWidth = this._width;
+
+		this._textfield.reset();
+		this._textfield.text = '';
+		this.initTextline(elementsFormats);
+	}
+
+	public getBaselinePosition(baseline: string): number {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - getBaselinePosition', baseline);
+		switch (baseline) {
+			case TextBaseline.ROMAN:
+				// does not seem to matter what we return here
+				// for each TLF it checks 2 times for this value,
+				// and than 1 time for the ASCENT value
+				return -(this._ascent + this._descent);
+			case TextBaseline.ASCENT:
+				return -(this._ascent);// + this._descent);
+		}
+		return 0;
+	}
+
+	public setNextLine(value: TextLine) {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - setNextLine',  value);
+		this._nextLine = value;
+	}
+
+	public setPreviousLine(value: TextLine) {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get previousLine',  this._previousLine);
+		this._previousLine = value;
+	}
+
+	public setTextBlock(value: TextBlock) {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - setTextBlock',  value);
+		this._textBlock = value;
+	}
+
+	public userData: any;
+	public getMirrorRegion(mirror: EventDispatcher): TextLineMirrorRegion {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - getMirrorRegion',  mirror);
+		return null;
+	}
+
+	public flushAtomData(): void {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - flushAtomData');
+	}
+
+	public get textBlock(): TextBlock {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get textBlock',  this._textBlock);
+		return this._textBlock;
+	}
+
+	public get hasGraphicElement(): boolean {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get hasGraphicElement');
+		return false;//this._hasGraphicElement;
+	}
+
+	public get hasTabs(): boolean {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get hasTabs',  this._hasTabs);
+		return false;//this._hasTabs;
+	}
+
+	public get nextLine(): TextLine {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get nextLine',  this._nextLine);
+		return this._nextLine;
+	}
+
+	public get previousLine(): TextLine {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get previousLine',  this._previousLine);
+		return this._previousLine;
+	}
+
+	public get ascent(): number {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get ascent',  this._ascent);
+		return 0;//this._ascent;
+	}
+
+	public get descent(): number {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get descent',  this._descent);
+		return 0;//this._descent;
+	}
+
+	public get textHeight(): number {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get textHeight',  this._ascent + this._descent);
+		return this._ascent + this._descent;
+	}
+
+	public get textWidth(): number {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get textWidth',  this._textWidth);
+		return this._textWidth;
+	}
+
+	public get totalAscent(): number {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get totalAscent',  this._ascent);
+		return this._ascent;
+	}
+
+	public get totalDescent(): number {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get totalDescent',  this._descent);
+		return this._descent;
+	}
+
+	public get totalHeight(): number {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get totalHeight',  this._ascent + this._descent);
+		return this._ascent + this._descent;
+	}
+
+	public get textBlockBeginIndex(): number /*int*/ {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get textBlockBeginIndex',
+			this._textBlockBeginIndex);
+		return this._textBlockBeginIndex;
+	}
+
+	public get rawTextLength(): number /*int*/ {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get rawTextLength',  this._textLength);
+		return this._textLength;
+	}
+
+	public get specifiedWidth(): number {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get specifiedWidth',  this._specifiedWidth);
+		return this._specifiedWidth;
+	}
+
+	public get unjustifiedTextWidth(): number {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get unjustifiedTextWidth',
+			this._unjustifiedTextWidth);
+		return this._unjustifiedTextWidth;
+	}
+
+	public get validity(): string {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get validity',  this._validity);
+		return this._validity;
+	}
+
+	public set validity(value: string) {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - set validity',  value);
+		this._validity = value;
+	}
+
+	public get atomCount(): number /*int*/ {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get atomCount',  this._textLength);
+		return this._textLength;
+	}
+
+	public get mirrorRegions(): any/*ASVector<TextLineMirrorRegion >*/ {
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - get mirrorRegions',  this._mirrorRegions);
+		return this._mirrorRegions;
+	}
+
+	public getAtomIndexAtPoint(stageX: number, stageY: number): number /*int*/ {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLine', 'getAtomIndexAtPoint', '');
+		return null;
+	}
+
+	public getAtomIndexAtCharIndex(charIndex: number /*int*/): number /*int*/ {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLine', 'getAtomIndexAtCharIndex', '');
+		return charIndex;
+	}
+
+	public getAtomBounds(atomIndex: number /*int*/): Rectangle {
+		const bounds = this._textfield.getCharBoundaries(atomIndex);
+		noLogs || console.log('[TextLine] ' + this.adaptee.id + ' - getAtomBounds',
+			'atomIndex', atomIndex, 'bounds', bounds);
+		return (<any> this.sec).flash.geom.Rectangle(bounds.x, bounds.y, bounds.width, this._ascent + this.descent);
+	}
+
+	public getAtomBidiLevel(atomIndex: number /*int*/): number /*int*/ {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLine', 'getAtomBidiLevel', '');
+		return null;
+	}
+
+	public getAtomTextRotation(atomIndex: number /*int*/): string {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLine', 'getAtomTextRotation', '');
+		return null;
+	}
+
+	public getAtomTextBlockBeginIndex(atomIndex: number /*int*/): number /*int*/ {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLine', 'getAtomTextBlockBeginIndex', '');
+		return null;
+	}
+
+	public getAtomTextBlockEndIndex(atomIndex: number /*int*/): number /*int*/ {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLine', 'getAtomTextBlockEndIndex', '');
+		return null;
+	}
+
+	public getAtomCenter(atomIndex: number /*int*/): number {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLine', 'getAtomCenter', '');
+		return null;
+	}
+
+	public getAtomWordBoundaryOnLeft(atomIndex: number /*int*/): boolean {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLine', 'getAtomWordBoundaryOnLeft', '');
+		return null;
+	}
+
+	public getAtomGraphic(atomIndex: number /*int*/): DisplayObject {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLine', 'getAtomGraphic', '');
+		return null;
+	}
+
+	public dump(): string {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLine', 'dump', '');
+		return null;
+	}
+}

package/lib/text/engine/TextLineCreationResult.ts

@@ -0,0 +1,20 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class TextLineCreationResult extends ASObject {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	constructor() {
+		super();
+	}
+
+	// JS -> AS Bindings
+	public static SUCCESS: string = 'success';
+	public static EMERGENCY: string = 'emergency';
+	public static COMPLETE: string = 'complete';
+	public static INSUFFICIENT_WIDTH: string = 'insufficientWidth';
+
+	// AS -> JS Bindings
+
+}

package/lib/text/engine/TextLineMirrorRegion.ts

@@ -0,0 +1,62 @@
+import { ASObject } from '@awayfl/avm2';
+import { Debug } from '@awayjs/core';
+import { EventDispatcher } from '../../events/EventDispatcher';
+import { Rectangle } from '../../geom/Rectangle';
+import { ContentElement } from './ContentElement';
+import { TextLine } from './TextLine';
+
+export class TextLineMirrorRegion extends ASObject {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	constructor() {
+		super();
+	}
+
+	// JS -> AS Bindings
+
+	// AS -> JS Bindings
+
+	// _textLine: flash.text.engine.TextLine;
+	// _nextRegion: flash.text.engine.TextLineMirrorRegion;
+	// _previousRegion: flash.text.engine.TextLineMirrorRegion;
+	// _mirror: flash.events.EventDispatcher;
+	// _element: flash.text.engine.ContentElement;
+	// _bounds: flash.geom.Rectangle;
+	public get textLine(): TextLine {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLineMirrorRegion', 'get textLine', '');
+		return null;
+	}
+
+	public get nextRegion(): TextLineMirrorRegion {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLineMirrorRegion', 'get nextRegion', '');
+		return null;
+	}
+
+	public get previousRegion(): TextLineMirrorRegion {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLineMirrorRegion', 'get previousRegion', '');
+		return null;
+	}
+
+	public get mirror(): EventDispatcher {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLineMirrorRegion', 'get mirror', '');
+		return null;
+	}
+
+	public get element(): ContentElement {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLineMirrorRegion', 'get element', '');
+		return null;
+	}
+
+	public get bounds(): Rectangle {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextLineMirrorRegion', 'get textLine', '');
+		return null;
+	}
+}

package/lib/text/engine/TextLineValidity.ts

@@ -0,0 +1,20 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class TextLineValidity extends ASObject {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	constructor() {
+		super();
+	}
+
+	// JS -> AS Bindings
+	public static VALID: string = 'valid';
+	public static POSSIBLY_INVALID: string = 'possiblyInvalid';
+	public static INVALID: string = 'invalid';
+	public static STATIC: string = 'static';
+
+	// AS -> JS Bindings
+
+}

package/lib/text/engine/TextRotation.ts

@@ -0,0 +1,21 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class TextRotation extends ASObject {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	constructor() {
+		super();
+	}
+
+	// JS -> AS Bindings
+	public static ROTATE_0: string = 'rotate0';
+	public static ROTATE_90: string = 'rotate90';
+	public static ROTATE_180: string = 'rotate180';
+	public static ROTATE_270: string = 'rotate270';
+	public static AUTO: string = 'auto';
+
+	// AS -> JS Bindings
+
+}

package/lib/text/engine/TypographicCase.ts

@@ -0,0 +1,22 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class TypographicCase extends ASObject {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	constructor() {
+		super();
+	}
+
+	// JS -> AS Bindings
+	public static DEFAULT: string = 'default';
+	public static TITLE: string = 'title';
+	public static CAPS: string = 'caps';
+	public static SMALL_CAPS: string = 'smallCaps';
+	public static UPPERCASE: string = 'uppercase';
+	public static LOWERCASE: string = 'lowercase';
+	public static CAPS_AND_SMALL_CAPS: string = 'capsAndSmallCaps';
+
+	// AS -> JS Bindings
+}

package/lib/text/ime/CompositionAttributeRange.ts

@@ -0,0 +1,29 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class CompositionAttributeRange extends ASObject {
+
+	// Called whenever the class is initialized.
+	public static classInitializer: any = null;
+
+	// List of static symbols to link.
+	public static classSymbols: string[] = null; // [];
+
+	// List of instance symbols to link.
+	public static instanceSymbols: string[] = null; // ["relativeStart", "relativeEnd", "selected", "converted"];
+
+	public relativeStart: number /*int*/;
+
+	public relativeEnd: number /*int*/;
+
+	public selected: boolean;
+
+	public converted: boolean;
+
+	constructor(relativeStart: number /*int*/, relativeEnd: number /*int*/, selected: boolean, converted: boolean) {
+		relativeStart = relativeStart | 0;
+		relativeEnd = relativeEnd | 0;
+		selected = !!selected;
+		converted = !!converted;
+		super();
+	}
+}

package/lib/text/ime/IIMEClient.ts

@@ -0,0 +1,31 @@
+import { Rectangle } from '../../geom/Rectangle';
+
+export interface IIMEClient {
+
+	// JS -> AS Bindings
+
+	compositionStartIndex: number /*int*/;
+	compositionEndIndex: number /*int*/;
+	verticalTextLayout: boolean;
+	selectionAnchorIndex: number /*int*/;
+	selectionActiveIndex: number /*int*/;
+	updateComposition: (
+		text: string,
+		attributes: any,//ASVector<any>,
+		compositionStartIndex: number /*int*/,
+		compositionEndIndex: number /*int*/) => void;
+	confirmComposition: (
+		text: string,
+		preserveSelection: boolean) => void;
+	getTextBounds: (startIndex: number /*int*/, endIndex: number /*int*/) => Rectangle;
+	selectRange: (anchorIndex: number /*int*/, activeIndex: number /*int*/) => void;
+	getTextInRange: (startIndex: number /*int*/, endIndex: number /*int*/) => string;
+
+	// AS -> JS Bindings
+
+	// _compositionStartIndex: number /*int*/;
+	// _compositionEndIndex: number /*int*/;
+	// _verticalTextLayout: boolean;
+	// _selectionAnchorIndex: number /*int*/;
+	// _selectionActiveIndex: number /*int*/;
+}