@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/text/engine/TextBlock.ts

@@ -0,0 +1,583 @@
+import { ASObject } from '@awayfl/avm2';
+import { Debug } from '@awayjs/core';
+import { TextFormat } from '@awayjs/scene';
+import { ContentElement } from './ContentElement';
+import { ElementFormat } from './ElementFormat';
+import { FontDescription } from './FontDescription';
+import { GroupElement } from './GroupElement';
+import { TextBaseline } from './TextBaseline';
+import { TextJustifier } from './TextJustifier';
+import { TextLine } from './TextLine';
+import { TextLineCreationResult } from './TextLineCreationResult';
+
+const enum CHAR_CODES {
+	TAB = 9,
+	LF = 10,
+	CR = 13,
+	SPACE = 32,
+	BS = 92,
+	N = 110,
+	R = 114,
+}
+export interface ITextData {
+	formats: TextFormat[],
+	elementFormats: ElementFormat[],
+	formatIndices: number[],
+	text: string,
+	processedIdx: number,
+	creationResult: string,
+	spaces: NumberMap<boolean>,
+	lineBreaks: NumberMap<number>,
+	charWidths: number[],
+}
+
+const noLogs = true;
+let textBlockIDs = 0;
+const textLinePool = [];
+export class TextBlock extends ASObject {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	private _content: ContentElement;
+	private _tabStops: any /*ASVector<TabStop>*/;
+	private _textJustifier: TextJustifier;
+	private _lineRotation: string;
+	private _baselineZero: string;
+	private _bidiLevel: number;
+	private _applyNonLinearFontScaling: boolean;
+	private _baselineFontDescription: FontDescription;
+	private _baselineFontSize: number;
+	private _userData: any;
+	private _textLines: TextLine[];
+	private _creationResult: string;
+	private _textData: ITextData;
+	private _id: number;
+
+	constructor(
+		content: ContentElement = null,
+		tabStops: any /*ASVector<TabStop>*/ = null,
+		textJustifier: TextJustifier = null,
+		lineRotation: string = 'rotate0',
+		baselineZero: string = 'roman',
+		bidiLevel: number /*int*/ = 0,
+		applyNonLinearFontScaling: boolean = true,
+		baselineFontDescription: FontDescription = null,
+		baselineFontSize: number = 12) {
+		super();
+		this._id = textBlockIDs++;
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - new textblock ',
+			content, tabStops, textJustifier,
+			lineRotation, baselineZero, bidiLevel, applyNonLinearFontScaling,
+			baselineFontDescription, baselineFontSize);
+		this._content = content;
+		if (content) {
+			this._content.setTextBlock(this);
+		}
+		this._tabStops = tabStops;
+		this._textJustifier = textJustifier;
+		this._lineRotation = lineRotation;
+		this._baselineZero = baselineZero;
+		this._bidiLevel = bidiLevel;
+		this._applyNonLinearFontScaling = applyNonLinearFontScaling;
+		this._baselineFontDescription = baselineFontDescription;
+		this._baselineFontSize = baselineFontSize;
+		this._textLines = [];
+		this._creationResult = null;
+	}
+
+	public setTextDataDirty() {
+		this._textData = null;
+	}
+
+	private _convertContentToTextData() {
+		if (this._textData) {
+			return this._textData;
+		}
+		this._textData = {
+			text: '',
+			formats: [],
+			elementFormats: [],
+			formatIndices: [],
+			processedIdx: 0,
+			creationResult: null,
+			spaces: {},
+			lineBreaks: {},
+			charWidths: []
+		};
+		this.resolveGroupElements(this._content);
+
+		if (this._textData.formatIndices[this._textData.formatIndices.length - 1] != this._textData.text.length)
+			this._textData.formatIndices.push(this._textData.text.length);
+
+		const formats = this._textData.formats;
+		const formatsIndicies = this._textData.formatIndices;
+		/*if (this._textData.text.charCodeAt(this._textData.text.length - 1) == 8233) {
+			this._textData.text = this._textData.text.substring(0, this._textData.text.length - 1);
+		}*/
+		const text = this._textData.text;
+		this._content.rawText = text;
+		const spaces = this._textData.spaces;
+		const lineBreaks = this._textData.lineBreaks;
+		const charWidths = this._textData.charWidths;
+
+		let c = 0;
+		const form_len = formats.length;
+		for (let f = 0; f < form_len; f++) {
+
+			const tf = formats[f];
+			tf.font_table.initFontSize(tf.size);
+			const lastChar = formatsIndicies[f];
+			for (c; c <= lastChar; c++) {
+				const char_code = text.charCodeAt(c);
+				const isLineBreak = char_code === CHAR_CODES.LF || char_code === 8233;
+				if (isLineBreak) {
+					lineBreaks[c] = 1;
+					charWidths[charWidths.length] = 0;
+				} else {
+					charWidths[charWidths.length] = tf.font_table.getCharWidth(char_code.toString());
+					const isSpace = char_code == CHAR_CODES.TAB || char_code == CHAR_CODES.SPACE;
+					if (isSpace) {
+						spaces[c] = true;
+					}
+				}
+			}
+		}
+	}
+
+	private resolveGroupElements(content: ContentElement) {
+
+		if (content.axClassName == 'flash.text.engine.TextElement') {
+			const text = content.text;
+			const elementFormat = content.elementFormat;
+			let tf;
+			if (elementFormat)
+				tf = elementFormat.createAwayTextformat();
+			else {
+				tf = new TextFormat();
+			}
+			this._textData.text += text ? text : '';
+			this._textData.formats.push(tf);
+			this._textData.elementFormats.push(elementFormat);
+			this._textData.formatIndices.push(this._textData.text.length);
+		}
+		if (content.axClassName == 'flash.text.engine.GroupElement') {
+			const group = <GroupElement><any>content;
+			//noLogs || console.log('resolve GroupElement', group.elementCount);
+			for (let i = 0; i < group.elementCount; i++) {
+				this.resolveGroupElements(group.getElementAt(i));
+			}
+		}
+	}
+
+	public createTextLine(
+		previousLine?: TextLine,
+		width?: number,
+		lineOffset?: number,
+		fitSomething?: boolean): TextLine {
+
+		if (!this._textData) {
+			this._textLines = [];
+			this._convertContentToTextData();
+		}
+
+		if (this._tabStops && this._tabStops.buffer.length > 0) {
+			console.warn('this._tabStops is not []', this._tabStops);
+		}
+		if (this._textJustifier && this._textJustifier.lineJustification != 'unjustified') {
+			console.warn('lineJustification is not unjustified', this._textJustifier.lineJustification);
+		}
+		if (this._textJustifier && (<any> this._textJustifier).letterSpacing != 0) {
+			console.warn('letterSpacing is not 0', (<any> this._textJustifier).letterSpacing);
+		}
+		if (this._baselineZero != TextBaseline.ROMAN) {
+			console.warn('_baselineZero is not "roman"', this._baselineZero);
+		}
+
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - text',
+			this._textData.text);
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - createTextLine',
+			'\n		width', width,
+			'\n		previousLine', previousLine,
+			'\n		lineOffset', lineOffset,
+			'\n		fitSomething', fitSomething,
+			'\n		processedIdx', this._textData.processedIdx);
+
+		const text = this._textData.text;
+		let processedIdx = this._textData.processedIdx;
+		if (processedIdx > text.length) {
+			this._creationResult = TextLineCreationResult.COMPLETE;
+			noLogs || console.log('[TextBlock]  ' + this._id + '   - all textlines already complete',
+				processedIdx, text.length);
+			return null;
+		}
+		const formats = this._textData.formats;
+		const elementFormats = this._textData.elementFormats;
+		const formatsIndicies = this._textData.formatIndices;
+		const spaces = this._textData.spaces;
+		const lineBreaks = this._textData.lineBreaks;
+		const charWidths = this._textData.charWidths;
+
+		const form_len = formats.length;
+		let c = processedIdx;
+		let newText = '';
+		let newWord = '';
+		let newCharCnt = 0;
+		const newFormats = [];
+		const newElementFormats = [];
+		const newFormatindices = [];
+		let result = TextLineCreationResult.EMERGENCY; // is valid if its a linebreak or at least one word that fits
+		let textWidth = 0;
+		let defaultFormat;
+		let defaultElementFormat;
+		loop1:
+		for (let f = 0; f < form_len; f++) {
+			if (processedIdx > formatsIndicies[f]) {
+				continue;
+			}
+			const format = formats[f];
+			defaultFormat = format;
+			newFormats[newFormats.length] = format;
+			newElementFormats[newElementFormats.length] = elementFormats[f];
+			defaultElementFormat = elementFormats[f];
+			newFormatindices[newFormatindices.length] = 0;
+			const lastChar = formatsIndicies[f];
+			for (c; c <= lastChar; c++) {
+				if (lineBreaks[c] === 1) {
+					noLogs || console.log('lineBreaks', result, c, text[c]);
+					newText += newWord;
+					newCharCnt += newWord.length + 1;
+					result = TextLineCreationResult.SUCCESS;
+					this._textData.processedIdx = c;
+					// remove the linebreak marker so we not stuck in infinite loop
+					lineBreaks[c] = 2;
+					break loop1;
+				}
+				if (spaces[c]) {
+					noLogs || console.log('space', result, c, text[c], newWord);
+					result = TextLineCreationResult.SUCCESS;
+					newText += newWord;
+					newCharCnt += newWord.length;
+					newWord = '';
+					this._textData.processedIdx = c;
+				}
+				if (newWord.length == 1 &&
+					(newWord.charCodeAt(0) == CHAR_CODES.SPACE || newWord.charCodeAt(0) == CHAR_CODES.TAB)) {
+					result = TextLineCreationResult.SUCCESS;
+					newText += newWord;
+					newCharCnt += newWord.length;
+					newWord = '';
+					this._textData.processedIdx = c;
+				}
+				textWidth += charWidths[c];
+				if (textWidth > width - 2) {
+					noLogs || console.log('text is to wide', 'textWidth', textWidth,
+						'width', width, newText, result, text[c], newWord);
+					if (result == TextLineCreationResult.SUCCESS) {
+						break loop1;
+					}
+					newText += newWord;
+					newCharCnt += newWord.length;
+					this._textData.processedIdx = c;
+					break loop1;
+
+				}
+				if (c == text.length) {
+					newText += newWord;
+					newCharCnt += newWord.length;
+					this._textData.processedIdx = c + 1;
+					break loop1;
+				}
+				if (!lineBreaks[c]) {
+					newWord += text[c];
+				} else {
+					newWord += text[c];
+					processedIdx++;
+				}
+			}
+			newFormatindices[newFormatindices.length - 1] = newText.length + newWord.length - 1;
+		}
+		newFormatindices[newFormatindices.length - 1] = newText.length;
+		if (this._textData.processedIdx >= text.length) {
+			noLogs || console.log('[TextBlock]  ' + this._id + '   - all text processed',
+				this._textData.processedIdx, text.length);
+			this._textData.processedIdx++;
+			result = TextLineCreationResult.COMPLETE;
+		}
+
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - textline prepared',
+			this._textData.processedIdx, `"${newText}"`);
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - all text length',
+			text.length, 'newCharCnt', newCharCnt, 'processedIdx', processedIdx);
+
+		//this._textData.processedIdx = text.length + 1;
+
+		if (newFormats.length == 0) {
+			newFormats[0] = defaultFormat;
+			newElementFormats[0] = defaultElementFormat;
+		}
+
+		let textLine: TextLine;
+		for (let c = 0; c < textLinePool.length; c++) {
+			if (!textLinePool[c].parent && textLinePool[c].free) {
+				textLine = textLinePool[c];
+				break;
+
+			}
+		}
+		if (textLine) {
+			textLine.setPreviousLine(null);
+			textLine.setNextLine(null);
+			textLine['$BguserData'] = null;
+			(<any> textLine).free = false;
+			textLine.reUseTextLine(
+				previousLine,
+				width,
+				lineOffset,
+				fitSomething,
+				newText, newFormats, newFormatindices,
+				processedIdx, newCharCnt, newElementFormats);
+		} else {
+			textLine = new (<any> this.sec).flash.text.engine.TextLine(
+				previousLine,
+				width,
+				lineOffset,
+				fitSomething,
+				newText, newFormats, newFormatindices,
+				processedIdx, newCharCnt, newElementFormats);
+		}
+
+		this._creationResult = result;
+		textLine.setTextBlock(this);
+		this._textLines.push(textLine);
+		return textLine;
+	}
+
+	public recreateTextLine(textLine: TextLine,
+		previousLine?: TextLine,
+		width?: number,
+		lineOffset?: number,
+		fitSomething?: boolean): TextLine {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'recreateTextLine', '');
+		return new (<any> this.sec).flash.text.engine.TextLine();
+	}
+
+	public get textLineCreationResult(): string {
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - textLineCreationResult', this._creationResult);
+		return this._creationResult;
+	}
+
+	public get applyNonLinearFontScaling(): boolean {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'get applyNonLinearFontScaling', '');
+		return this._applyNonLinearFontScaling;
+	}
+
+	public set applyNonLinearFontScaling(value: boolean) {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'set applyNonLinearFontScaling', '');
+		this._applyNonLinearFontScaling = value;
+	}
+
+	public get baselineFontDescription(): FontDescription {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'get baselineFontDescription', '');
+		return this._baselineFontDescription;
+	}
+
+	public set baselineFontDescription(value: FontDescription) {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'set baselineFontDescription', '');
+		this._baselineFontDescription = value;
+	}
+
+	public get baselineFontSize(): number {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'get baselineFontSize', '');
+		return this._baselineFontSize;
+	}
+
+	public set baselineFontSize(value: number) {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'set baselineFontSize', '');
+		this._baselineFontSize = value;
+	}
+
+	public get baselineZero(): string {
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - get baselineZero', this._baselineZero);
+		return this._baselineZero;
+	}
+
+	public set baselineZero(value: string) {
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - set baselineZero', value);
+		this._baselineZero = value;
+	}
+
+	public get content(): ContentElement {
+		//console.warn('[TextBlock]  ' + this._id + '   - get content not implemented');
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - get content', this._content);
+		return this._content;
+	}
+
+	public set content(value: ContentElement) {
+		//console.warn('[TextBlock]  ' + this._id + '   - set content not implemented');
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - set content', value);
+		this._textData = null;
+		if (this._content)
+			this._content.setTextBlock(null);
+		this._content = value;
+		if (this._content)
+			this._content.setTextBlock(this);
+	}
+
+	public get bidiLevel(): number /*int*/ {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'get bidiLevel', '');
+		return this._bidiLevel;
+	}
+
+	public set bidiLevel(value: number /*int*/) {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'set bidiLevel', '');
+		this._bidiLevel = value;
+	}
+
+	public get firstInvalidLine(): TextLine {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'firstInvalidLine', '');
+		return null;
+	}
+
+	public get firstLine(): TextLine {
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - get firstLine',
+			this._textLines.length > 0 ? this._textLines[0] : null);
+		return this._textLines.length > 0 ? this._textLines[0] : null;
+	}
+
+	public get lastLine(): TextLine {
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - get lastLine',
+			this._textLines.length > 0 ? this._textLines[this._textLines.length - 1] : null);
+		return this._textLines.length > 0 ? this._textLines[this._textLines.length - 1] : null;
+	}
+
+	public get lineRotation(): string {
+		return this._lineRotation;
+	}
+
+	public set lineRotation(value: string) {
+		this._lineRotation = value;
+	}
+
+	public findNextAtomBoundary(afterCharIndex: number /*int*/): number /*int*/ {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'findNextAtomBoundary', '');
+		return null;
+	}
+
+	public findPreviousAtomBoundary(beforeCharIndex: number /*int*/): number /*int*/ {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'findPreviousAtomBoundary', '');
+		return null;
+	}
+
+	public findNextWordBoundary(afterCharIndex: number /*int*/): number /*int*/ {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'findNextWordBoundary', '');
+		return null;
+	}
+
+	public findPreviousWordBoundary(beforeCharIndex: number /*int*/): number /*int*/ {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'findPreviousWordBoundary', '');
+		return null;
+	}
+
+	public getTextLineAtCharIndex(charIndex: number /*int*/): TextLine {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'getTextLineAtCharIndex', '');
+		return null;
+	}
+
+	public releaseLineCreationData(): void {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'releaseLineCreationData', '');
+	}
+
+	public releaseLines(firstLine: TextLine, lastLine: TextLine): void {
+		//console.warn('[TextBlock]  ' + this._id + '   - releaseLines not implemented');
+		if (this._textLines.length == 0)
+			return;
+		if (firstLine == this._textLines[0] && lastLine == this._textLines[this._textLines.length - 1]) {
+			if (textLinePool.length < 100) {
+				for (let i = 0; i < this._textLines.length; i++) {
+					(<any> this._textLines[i]).free = true;
+					if (textLinePool.indexOf(this._textLines[i]) <= 0)
+						textLinePool.push(this._textLines[i]);
+				}
+			}
+			this._textLines.length = 0;
+			return;
+		}
+		while (firstLine) {
+			const idx = this._textLines.indexOf(firstLine);
+			if (idx >= 0) {
+				this._textLines.splice(idx, 1);
+			}
+			(<any> firstLine).free = true;
+			if (textLinePool.indexOf(firstLine) <= 0)
+				textLinePool.push(firstLine);
+			if (firstLine != lastLine)
+				firstLine = firstLine.nextLine;
+			else
+				firstLine = null;
+		}
+	}
+
+	public dump(): string {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'dump', '');
+		return null;
+	}
+
+	public DoCreateTextLine(
+		previousLine: TextLine,
+		width: number,
+		lineOffset: number = 0,
+		fitSomething: boolean = false,
+		reuseLine: TextLine = null): TextLine {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextBlock', 'DoCreateTextLine', '');
+		return null;
+	}
+
+	public getTabStops(): any/*ASVector<flash.text.engine.TabStop>*/ {
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - getTabStops', this._tabStops);
+		return this._tabStops;
+	}
+
+	public setTabStops(value: any/*ASVector<flash.text.engine.TabStop>*/) {
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - setTabStops not implemented', value);
+		this._tabStops = value;
+	}
+
+	public getTextJustifier(): TextJustifier {
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - getTextJustifier', this._textJustifier);
+		return this._textJustifier;
+	}
+
+	public setTextJustifier(value: TextJustifier) {
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - setTextJustifier', value);
+		this._textJustifier = value;
+	}
+
+	public get userData(): any {
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - get userData', this._userData);
+		return this._userData;
+	}
+
+	public set userData(value: any) {
+		noLogs || console.log('[TextBlock]  ' + this._id + '   - set userData', value);
+		this._userData = value;
+	}
+}

package/lib/text/engine/TextElement.ts

@@ -0,0 +1,49 @@
+import { EventDispatcher } from '../../events/EventDispatcher';
+import { ContentElement } from './ContentElement';
+import { ElementFormat } from './ElementFormat';
+
+const noLogs = true;
+export class TextElement extends ContentElement {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	constructor(
+		text: string = null,
+		elementFormat: ElementFormat = null,
+		eventMirror: EventDispatcher = null,
+		textRotation: string = 'rotate0') {
+		super(elementFormat, eventMirror, textRotation);
+		this._text = text;
+		this._rawText = text;
+		noLogs || console.log('[TextElement] ' + this._id + ' constructor', 'text', text);
+	}
+
+	// JS -> AS Bindings
+
+	// AS -> JS Bindings
+
+	// _text: string;
+	public set text(value: string) {
+		noLogs || console.log('[TextElement] ' + this._id + ' set text', value);
+		this._text = value;
+		if (this._textBlock)
+			this._textBlock.setTextDataDirty();
+	}
+
+	public get text(): string {
+		noLogs || console.log('[TextElement] ' + this._id + ' get text', this._text);
+		return this._text;
+	}
+
+	public replaceText(beginIndex: number /*int*/, endIndex: number /*int*/, newText: string): void {
+		noLogs || console.log('[TextElement] ' + this._id + ' replaceText',
+			'beginIndex', beginIndex,
+			'endIndex', endIndex,
+			'newText', newText);
+		this._rawText = this._text.slice(0, beginIndex) + newText + this._text.slice(endIndex, this._text.length - 1);
+		this._text = this._rawText;
+		if (this._textBlock)
+			this._textBlock.setTextDataDirty();
+	}
+}

package/lib/text/engine/TextJustifier.ts

@@ -0,0 +1,46 @@
+import { ASObject, axCoerceString } from '@awayfl/avm2';
+import { Debug } from '@awayjs/core';
+
+export class TextJustifier extends ASObject {
+
+	static forceNativeConstructor: boolean = true;
+	static forceNativeMethods: boolean = true;
+
+	private _locale: string;
+	private _lineJustification: string;
+
+	constructor(locale: string, lineJustification: string) {
+		super();
+		this._locale = axCoerceString(locale);
+		this._lineJustification = axCoerceString(lineJustification);
+	}
+
+	public static getJustifierForLocale(locale: string): TextJustifier {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextJustifier', 'getJustifierForLocale', '');
+		return null;
+
+	}
+
+	public clone(): TextJustifier {
+		// @todo
+		Debug.throwPIR('playerglobals/text/engine/TextJustifier', 'clone', '');
+		return null;
+	}
+
+	public get locale(): string {
+		return this._locale;
+	}
+
+	public get lineJustification(): string {
+		return this._lineJustification;
+	}
+
+	public set lineJustification(value: string) {
+		this._lineJustification = axCoerceString(value);
+	}
+
+	public setLocale(value: string): void {
+		this._locale = axCoerceString(value);
+	}
+}