////////////////////////////////////////////////////////////////////////////////
//
//  Licensed to the Apache Software Foundation (ASF) under one or more
//  contributor license agreements.  See the NOTICE file distributed with
//  this work for additional information regarding copyright ownership.
//  The ASF licenses this file to You 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.
//
////////////////////////////////////////////////////////////////////////////////
package
{
	import flash.display.DisplayObject;
	import flash.display.DisplayObjectContainer;
	import flash.display.Graphics;
	import flash.display.Shape;
	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.system.Capabilities;
	import flash.text.TextField;
	import flash.text.TextFieldAutoSize;
	import flash.text.TextFormat;
	import flash.utils.getTimer;
	
	import flashx.textLayout.elements.Configuration;
	import flashx.textLayout.TextLayoutVersion;
	import flashx.textLayout.tlf_internal;
	
	import mx.core.FlexGlobals;
	
	
	[SWF(width="1024", height="768")]
	public class FTEGridTestAS extends Sprite
	{
		// embed the fonts - note also add code to embed the font
		public static const embedFonts:Boolean = false;
		// work off the display list
		public static const offDisplayList:Boolean = false;
		
		// supported tests
		public static const CREATE_TEST:String = "create";
		public static const UPDATE_TEST:String = "update";
		
		public const testTable:Array = [ 
			  { name:TextFieldTest.name, 		build:TextFieldTest.build, 		refresh:TextFieldTest.refresh }
			, { name:Rectangle.name, 			build:Rectangle.build, 			refresh:Rectangle.refresh }
			, { name:FTEField.name, 			build:FTEField.build, 			refresh:FTEField.refresh }
			, { name:FlexFTETextField.name, 	build:FlexFTETextField.build, 	refresh:FlexFTETextField.refresh }
			, { name:FlexFTETextField41.name, 	build:FlexFTETextField41.build, refresh:FlexFTETextField41.refresh }
			, { name:FlexFTETextFieldNew.name, 	build:FlexFTETextFieldNew.build, refresh:FlexFTETextFieldNew.refresh }
			, { name:TCM.name, 					build:TCM.build, 				refresh:TCM.refresh }
			, { name:TextFlowTest.name, 		build:TextFlowTest.build, 		refresh:TextFlowTest.refresh }
			, { name:TextFlowLinkTest.name, 	build:TextFlowLinkTest.build, 	refresh:TextFlowLinkTest.refresh }
		];
		
		
		// buttons
		public var createTestButton:TextField;
		public var updateTestButton:TextField;
		public var testNameButton:TextField;
		
		public function FTEGridTestAS()
		{
			stage.align = StageAlign.TOP_LEFT;
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.frameRate = 1000;
			
			var playerType:String = Capabilities.isDebugger ? " DEBUGGER" : "";
			var vellumType:String = Configuration.tlf_internal::debugCodeEnabled ? "DEBUG" : "RELEASE"

			// controls
			var b:TextField = addButton("FTEGridTestAS " + Capabilities.version + playerType + " TLF: " + TextLayoutVersion.tlf_internal::BUILD_NUMBER + " " + vellumType,10,10,0,0,null);
			b = createTestButton= addButton("CreateTest",b.x+b.width+10,10,0,0,runCreateTest);
			b = updateTestButton = addButton("UpdateTest",b.x+b.width+10,10,0,0,runUpdateTest);
			b = testNameButton = addButton(testTable[0].name,b.x+b.width+10,10,0,0,testSelectHandler);
			
			// enables this application to test Flex's FTETextField class
			FlexGlobals.topLevelApplication = this;
			
			SharedGlobals.initializeGlobals();
		}
		
		public function addButton(text:String,x:Number,y:Number,width:Number,height:Number,handler:Function):TextField
		{
			var f1:TextField = new TextField();
			f1.text = text;
			f1.x = x; f1.y = y; // f1.height = height; f1.width = width;
			f1.autoSize = TextFieldAutoSize.LEFT;
			addChild(f1);
			if (handler != null)
			{
				f1.border = true;
				f1.borderColor = 0xff;
				f1.addEventListener(MouseEvent.CLICK,handler);
			}
			f1.selectable = false;
			
			return f1;
		}
		
		// click through the list of possible tests
		public function testSelectHandler(e:Event):void
		{
			for (var currIndex:int = 0; currIndex < testTable.length; currIndex++)
				if (testTable[currIndex].name ==  testNameButton.text)
					break;
			
			currIndex = currIndex >= testTable.length-1 ? 0 : currIndex+1;
			testNameButton.text = testTable[currIndex].name;
		}
		
		// each test is parented by this sprite.
		public var lineHolder:Sprite;
		
		public const LINEHOLDER_YOFFSET:Number = 30;
		
		
		// data for the current run
		private var sampleText:String="";
		private var _currTestTableEntry:Object;
		
		// call before starting the test
		private function initNewTest(testName:String):void
		{
			testType = testName;
			totalCreationTime = 0;
			totalRenderTime = 0;
			
			// setup _currTestTableEntry for running the test
			for (var currIndex:int = 0; currIndex < testTable.length; currIndex++)
				if (testTable[currIndex].name ==  testNameButton.text)
					break;
			_currTestTableEntry = testTable[currIndex];
			
			if (lineHolder)
				removeChild(lineHolder);
			
			lineHolder = new Sprite();
			lineHolder.y = LINEHOLDER_YOFFSET;
			addChild(lineHolder);
			
			// hide the buttons
			createTestButton.visible = false;  
			updateTestButton.visible = false; 
			
			// set iteration to zero and add the handler
			currIteration = 0;
			addEventListener(Event.ENTER_FRAME, handleEnterFrame);
		}

		
		public function runCreateTest(e:Event):void
		{
			initNewTest(CREATE_TEST);
			sampleText="";
		}
		
		public function runUpdateTest(e:Event):void
		{	
			initNewTest(UPDATE_TEST);
			// populate the grid
			createGrid();
		}

		
		// number of times each test is repeated.  Could make a control for this
		private const numberOfIterations:int = 100;
		
		private var dataLengthVal:Number;
		
		private var minWidthVal:Number;
		private var maxWidthVal:Number;
		private var widthStepVal:Number;
		
		private var currIteration:int = -1;
		private var currWidthVal:Number;
		
		private var beginThisRender:int;
		private var timingRendering:Boolean = false;
		
		// timers
		private var beginTestTime:int;
		public var totalCreationTime:int;
		public var totalRenderTime:int;
		
		public var cols:int = 15;
		
		private var testType:String = "";
		
		private var desiredColSize:Number;
		
		private function Step():void
		{
			if (testType == CREATE_TEST)
			{
				while (lineHolder.numChildren)
					lineHolder.removeChildAt(0);
				
				var t1:Number = getTimer();
				createGrid();
				totalCreationTime = totalCreationTime + (getTimer() - t1);
			} 
			else if (testType == UPDATE_TEST)
			{
				t1 = getTimer();
				sampleText = "update_" + currIteration;
				updateGrid();
				totalCreationTime = totalCreationTime + (getTimer() - t1);
			}
		}
		
		
		/** generate a report at the next enter frame */
		public function handleEnterFrame(e:Event): void
		{
			if (currIteration == -1)
				return;
			
			if (timingRendering)
			{
				totalRenderTime += getTimer() - beginThisRender;
				timingRendering = false;
			}
			
			// report results if appropriate
			if (currIteration < numberOfIterations)
			{
				Step();
				
				// prepare for the next iteration
				currIteration++;
				
				// begin timing rendering
				timingRendering = true;
				beginThisRender = getTimer();
			}
			else
			{ 
				// force a garbage collect?????
				/*try {
				new LocalConnection().connect('dummy');
				new LocalConnection().connect('dummy');
				} catch (e:*) {}*/
				
				
				createTestButton.visible = true;  
				updateTestButton.visible = true;  
				currIteration = -1;
				reportResults();
				removeEventListener(Event.ENTER_FRAME, handleEnterFrame);
			}
			
		}
		
		static public const deltay:Number = 9;
		static public var cellCount:int = 0;
		
		
		// Grid generator.
		private function createGrid():void
		{
			var target:Sprite = new Sprite();
			target.x = target.y = 0;
			
			if (!offDisplayList)
				lineHolder.addChild(target);
			
			var cellWidth:Number = lineHolder.stage.stageWidth / cols;
			// var isFTE:Boolean = testTypeCombo.selectedLabel == "FTE";
			var curY:Number = 0;
			var cell:DisplayObject;
			var rowCount:Number = 0;
			cellCount = 0;
			
			var totalHeight:Number = this.stage.stageHeight-LINEHOLDER_YOFFSET;
			
			while (curY < totalHeight)
			{
				var curX:Number = 0;
				for (var c:int = 0; c < cols; c++)
				{
					var st:String = sampleText != "" ? sampleText : currIteration + ": " + int(c+1) + "," + int(rowCount+1);
					_currTestTableEntry.build(st, cellWidth, target, curX, curY);
					curX += cellWidth;
					cellCount++;
				}
				rowCount = rowCount + 1;
				curY += deltay ; // isFTE ? cell.height + 7: cell.height;
				
				if ((curY + deltay) >= totalHeight)
					break;
			}
			
			if (offDisplayList)
				lineHolder.addChild(target);
		}
		
		// Grid Updater
		private function updateGrid():void
		{
			var cellWidth:Number = lineHolder.width / cols;
			var target:Sprite = lineHolder.getChildAt(0) as Sprite;
			if (offDisplayList)
				lineHolder.removeChildAt(0);
			
			// var isFTE:Boolean = testTypeCombo.selectedLabel == "FTE";
			var curY:Number = 0;
			var rowCount:Number = 0;
			cellCount = 0;
			
			var totalHeight:Number = this.stage.stageHeight-LINEHOLDER_YOFFSET;
			
			while (curY < totalHeight)
			{
				var curX:Number = 0;
				for (var c:int = 0; c < cols; c++)
				{
					_currTestTableEntry.refresh(sampleText, cellWidth, target, cellCount, curX, curY);
					
					curX += cellWidth;
					cellCount++;
				}
				rowCount = rowCount + 1;
				curY += deltay ; // isFTE ? cell.height + 7: cell.height;
				
				if ((curY + deltay) >= totalHeight)
					break;
			}
			
			if (offDisplayList)
				lineHolder.addChild(target);
		}
		
		
		private function reportResults():void
		{
			var totalTestTime:int = totalRenderTime + totalCreationTime;
			flash.system.System.gc();	//mark
			flash.system.System.gc();	//sweep
			var memoryAllocated:Number = flash.system.System.totalMemory/1024;
			
			var vellumType:String = "Vellum Build: " + TextLayoutVersion.tlf_internal::BUILD_NUMBER + "\n";
			
			var resultText:TextField = new TextField();
			var format:TextFormat = new TextFormat;
			format.font = "Verdana";
			format.size = 18;
			resultText.defaultTextFormat = format;
			
			resultText.text = "CreationTime (msecs): " + totalCreationTime.toString() + "\nRenderTime (msec): " + totalRenderTime.toString() + "\nTotalTime (msec): " + totalTestTime.toString() 
				+ " \nmem (K): " + memoryAllocated.toString() + " cellCount: " + cellCount.toString() + "\n" + vellumType;
			resultText.x = 80; 
			resultText.y = 140;
			resultText.width = 400;
			resultText.height = 300;
			
			resultText.opaqueBackground = 0xFFFFFFFF;
			lineHolder.addChild(resultText);    
			this.dispatchEvent(new Event(Event.COMPLETE));
		}
	}
}

import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.display.Shape;
import flash.display.Sprite;
import flash.text.TextField;
import flash.text.TextFormat;
import flash.text.engine.*;

import flashx.textLayout.container.ContainerController;
import flashx.textLayout.container.TextContainerManager;
import flashx.textLayout.elements.LinkElement;
import flashx.textLayout.elements.ParagraphElement;
import flashx.textLayout.elements.SpanElement;
import flashx.textLayout.elements.TextFlow;
import flashx.textLayout.formats.TextLayoutFormat;

import mx.core.FTETextField;


class SharedGlobals
{
	// TextField Factory 
	static public var defaultTextFormat:TextFormat;
	
	static private function initDefaultTextFormat():void
	{
		defaultTextFormat = new TextFormat();
		defaultTextFormat.size = 10;
		defaultTextFormat.leading = 0;
		
		if (FTEGridTestAS.embedFonts)
			defaultTextFormat.font = "TFArial";
		else
			defaultTextFormat.font = "Verdana";
	}
	
	// FTE factory 
	static public var templateTextElement:TextElement = null;
	static public var templateTextBlock:TextBlock = null;
	
	static public function initializeTemplateText():void
	{
		var elementFormat:ElementFormat = new ElementFormat();
		var fontDescription:FontDescription = new FontDescription();
		if (FTEGridTestAS.embedFonts)
		{
			fontDescription.fontName = "FTEArial";
			fontDescription.fontLookup = FontLookup.EMBEDDED_CFF;
		}
		else
			fontDescription.fontName = "Verdana";
		elementFormat.fontSize = 10;
		elementFormat.fontDescription = fontDescription;
		templateTextElement = new TextElement();
		templateTextElement.elementFormat = elementFormat;
		templateTextBlock = new TextBlock(templateTextElement); 
		templateTextBlock.textJustifier = new SpaceJustifier("en",LineJustification.UNJUSTIFIED,false);         
	}
	
	static public var defaultTextLayoutFormat:TextLayoutFormat;
	
	static private function initDefaultTextLayoutFormat():void
	{
		defaultTextLayoutFormat = new TextLayoutFormat();
		defaultTextLayoutFormat.fontSize = 10;
		defaultTextLayoutFormat.lineHeight = 10;
		
		if (FTEGridTestAS.embedFonts)
			defaultTextLayoutFormat.fontFamily = "TFArial";
		else
			defaultTextLayoutFormat.fontFamily = "Verdana";
	}
	
	public static function initializeGlobals():void
	{
		initDefaultTextFormat();
		initializeTemplateText();
		initDefaultTextLayoutFormat();
	}
}

class TextFieldTest
{
	public static const name:String = "TextField";
	
	static public function build(text:String, width:Number, parent:DisplayObjectContainer, currX:Number, currY:Number):DisplayObject
	{   
		var a:TextField = new TextField();
		a.defaultTextFormat = SharedGlobals.defaultTextFormat;
		a.embedFonts = FTEGridTestAS.embedFonts;
		a.text = text;
		a.width = width;
		a.autoSize = "left";
		a.multiline = true;
		a.wordWrap = true;
		
		a.x = currX;
		a.y = currY;
		parent.addChild(a);
		
		return a;
	}
	
	static public function refresh(text:String, width:Number, parent:DisplayObjectContainer, idx:int, currX:Number, currY:Number):DisplayObject
	{
		var a:TextField = parent.getChildAt(idx) as TextField;
		
		if (text)
			a.text = text;
		/* a.width = width;
		a.autoSize = "left";
		a.multiline = true;
		a.wordWrap = true; */
		return a;
	}
}

class Rectangle
{
	public static const name:String = "Rectangles";
	
	public static var nextColor:uint = 0;
	
	// Rectangle Factory 
	static public function build(text:String, width:Number, parent:DisplayObjectContainer, currX:Number, currY:Number):DisplayObject
	{
		var s:Shape = new Shape();
		s.x = currX;
		s.y = currY;
		s.graphics.beginFill(nextColor);
		nextColor += 0x010101;
		s.graphics.lineStyle(1, 0xFFFFFF);
		s.graphics.drawRect(0,0,width,15);
		s.graphics.endFill();
		parent.addChild(s);
		return s;
	}
	
	static public function refresh(text:String, width:Number, parent:DisplayObjectContainer, idx:int, currX:Number, currY:Number):void
	{
		if (idx == 0)
			while (parent.numChildren)
				parent.removeChildAt(0);
		build(text,width,parent,currX,currY);
	}
}

class FTEField
{
	public static const name:String = "FTE TextLine";
	
	
	static private function fillinFTEField(text:String, width:Number, rslt:DisplayObjectContainer):void
	{
		
		if (text)
			SharedGlobals.templateTextElement.text = text;
		
		var textLine:TextLine = null;
		var y:Number = 10.5;
		
		var textBlock:TextBlock = SharedGlobals.templateTextBlock;
		var textLength:int = textBlock.content.text.length;
		var lenUsed:int = 0;
		
		// more efficient use of FTE is to track the length used and stop after all text is consumed
		while (lenUsed < textLength)
		{
			textLine = SharedGlobals.templateTextBlock.createTextLine(textLine,width,0,true);
			textLine.x = 2;
			textLine.y = y;
			y += 12.2;
			rslt.addChild(textLine);
			lenUsed += textLine.rawTextLength;
		}
		
		textBlock.releaseLines(textBlock.firstLine,textBlock.lastLine);
	}
	
	static public function build(text:String, width:Number, target:DisplayObjectContainer, currX:Number, currY:Number):DisplayObject
	{
		var rslt:Sprite = new Sprite();
		
		fillinFTEField(text,width,rslt);
		
		rslt.x = currX;
		rslt.y = currY;
		target.addChild(rslt);
		
		return rslt; 
	}
	
	static public function refresh(text:String, width:Number, parent:DisplayObjectContainer, idx:int, currX:Number, currY:Number):DisplayObject
	{
		var target:Sprite = parent.getChildAt(idx) as Sprite;
		
		while (target.numChildren)
			target.removeChildAt(0);
		
		fillinFTEField(text, width, target);
		
		return target;
	}
}

// FTETextField is a Flex wrapper for FTE
class FlexFTETextField
{
	public static const name:String = "Flex FTETextField";
	
	static public function build(text:String, width:Number, parent:DisplayObjectContainer, currX:Number, currY:Number):DisplayObject
	{	
		var a:FTETextField = new FTETextField();
		a.defaultTextFormat = SharedGlobals.defaultTextFormat;
		a.text = text;
		a.width = width;
		a.autoSize = "left";
		a.multiline = true;
		a.wordWrap = true;
		
		a.x = currX;
		a.y = currY;
		parent.addChild(a);
		
		return a;
	}
	
	static public function refresh(text:String, width:Number, parent:DisplayObjectContainer, idx:int, currX:Number, currY:Number):DisplayObject
	{
		var a:FTETextField = parent.getChildAt(idx) as FTETextField;
		
		if (text)
			a.text = text;
		/* a.width = width;
		a.autoSize = "left";
		a.multiline = true;
		a.wordWrap = true; */
		return a;
	}
}

class TCM
{
	public static const name:String = "TCM";
	
	static public function build(text:String, width:Number, parent:DisplayObjectContainer, currX:Number, currY:Number):DisplayObject
	{	
		var s:TCMSprite = new TCMSprite();
		var tcm:TextContainerManager = new TextContainerManager(s);
		s.tcm = tcm;
		tcm.compositionHeight = NaN; tcm.compositionWidth = width;
		tcm.setText(text);
		tcm.hostFormat = SharedGlobals.defaultTextLayoutFormat;
		tcm.updateContainer();
		
		s.x = currX;
		s.y = currY;
		parent.addChild(s);
		
		return s;
	}
	
	static public function refresh(text:String, width:Number, parent:DisplayObjectContainer, idx:int, currX:Number, currY:Number):DisplayObject
	{
		var a:TCMSprite = parent.getChildAt(idx) as TCMSprite;
		var tcm:TextContainerManager = a.tcm;
		
		if (text)
		{
			tcm.setText(text);
			tcm.updateContainer();
		}
		
		return a;
	}
}

class TCMSprite extends Sprite
{
	public var tcm:TextContainerManager;
}

class TextFlowTest
{
	public static const name:String = "TextFlow";
	
	static public function build(text:String, width:Number, parent:DisplayObjectContainer, currX:Number, currY:Number):DisplayObject
	{	
		var s:TextFlowSprite = new TextFlowSprite();
		var textFlow:TextFlow = new TextFlow();
		textFlow.hostFormat = SharedGlobals.defaultTextLayoutFormat;
		var p:ParagraphElement = new ParagraphElement();
		var span:SpanElement = new SpanElement();
		span.text = text;
		
		// no links case - remove when doing links test
		p.addChild(span);
		
		// alternate for above to test a link
//		var link:LinkElement = new LinkElement;
//		link.addChild(span);
//		p.addChild(link);
		
		// put p in the TextFlow
		textFlow.addChild(p);
		
		textFlow.flowComposer.addController(new ContainerController(s,NaN,NaN));
		textFlow.flowComposer.updateAllControllers();
		s.textFlow = textFlow;
		
		s.x = currX;
		s.y = currY;
		parent.addChild(s);
		
		return s;
	}
	
	static public function refresh(text:String, width:Number, parent:DisplayObjectContainer, idx:int, currX:Number, currY:Number):DisplayObject
	{
		var a:TextFlowSprite = parent.getChildAt(idx) as TextFlowSprite;
		var textFlow:TextFlow = a.textFlow;
		
		if (text)
		{
			(textFlow.getFirstLeaf() as SpanElement).text = text;
			textFlow.flowComposer.updateAllControllers();
		}
		
		return a;
	}
}

class TextFlowLinkTest
{
	public static const name:String = "TextFlow with Link";
	
	static public function build(text:String, width:Number, parent:DisplayObjectContainer, currX:Number, currY:Number):DisplayObject
	{	
		var s:TextFlowSprite = new TextFlowSprite();
		var textFlow:TextFlow = new TextFlow();
		textFlow.hostFormat = SharedGlobals.defaultTextLayoutFormat;
		var p:ParagraphElement = new ParagraphElement();
		var span:SpanElement = new SpanElement();
		span.text = text;
		
		// no links case - remove when doing links test
		// p.addChild(span);
		
		// alternate for above to test a link
		var link:LinkElement = new LinkElement;
		link.addChild(span);
		p.addChild(link);
		
		// put p in the TextFlow
		textFlow.addChild(p);
		
		textFlow.flowComposer.addController(new ContainerController(s,NaN,NaN));
		textFlow.flowComposer.updateAllControllers();
		s.textFlow = textFlow;
		
		s.x = currX;
		s.y = currY;
		parent.addChild(s);
		
		return s;
	}
	
	static public function refresh(text:String, width:Number, parent:DisplayObjectContainer, idx:int, currX:Number, currY:Number):DisplayObject
	{
		var a:TextFlowSprite = parent.getChildAt(idx) as TextFlowSprite;
		var textFlow:TextFlow = a.textFlow;
		
		if (text)
		{
			(textFlow.getFirstLeaf() as SpanElement).text = text;
			textFlow.flowComposer.updateAllControllers();
		}
		
		return a;
	}
}

class TextFlowSprite extends Sprite
{
	public var textFlow:TextFlow;
}

import helpers.FTETextField41;

class FlexFTETextField41
{
	public static const name:String = "Flex41 FTETextField";
	
	static public function build(text:String, width:Number, parent:DisplayObjectContainer, currX:Number, currY:Number):DisplayObject
	{	
		var a:FTETextField41 = new FTETextField41();
		a.defaultTextFormat = SharedGlobals.defaultTextFormat;
		a.text = text;
		a.width = width;
		a.autoSize = "left";
		a.multiline = true;
		a.wordWrap = true;
		
		a.x = currX;
		a.y = currY;
		parent.addChild(a);
		
		return a;
	}
	
	static public function refresh(text:String, width:Number, parent:DisplayObjectContainer, idx:int, currX:Number, currY:Number):DisplayObject
	{
		var a:FTETextField41 = parent.getChildAt(idx) as FTETextField41;
		
		if (text)
			a.text = text;
		/* a.width = width;
		a.autoSize = "left";
		a.multiline = true;
		a.wordWrap = true; */
		return a;
	}
}

import helpers.FTETextFieldNew;

class FlexFTETextFieldNew
{
	public static const name:String = "FlexNew FTETextField";
	
	static public function build(text:String, width:Number, parent:DisplayObjectContainer, currX:Number, currY:Number):DisplayObject
	{	
		var a:FTETextFieldNew = new FTETextFieldNew();
		a.defaultTextFormat = SharedGlobals.defaultTextFormat;
		a.text = text;
		a.width = width;
		a.autoSize = "left";
		a.multiline = true;
		a.wordWrap = true;
		
		a.x = currX;
		a.y = currY;
		parent.addChild(a);
		
		return a;
	}
	
	static public function refresh(text:String, width:Number, parent:DisplayObjectContainer, idx:int, currX:Number, currY:Number):DisplayObject
	{
		var a:FTETextFieldNew = parent.getChildAt(idx) as FTETextFieldNew;
		
		if (text)
			a.text = text;
		/* a.width = width;
		a.autoSize = "left";
		a.multiline = true;
		a.wordWrap = true; */
		return a;
	}
}