| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // 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 UnitTest.Tests |
| { |
| import UnitTest.ExtendedClasses.TestDescriptor; |
| import UnitTest.ExtendedClasses.TestSuiteExtended; |
| import UnitTest.ExtendedClasses.VellumTestCase; |
| import UnitTest.Fixtures.TestConfig; |
| |
| import flash.display.Graphics; |
| import flash.display.Sprite; |
| import flash.errors.IOError; |
| import flash.events.*; |
| import flash.geom.Point; |
| import flash.geom.Rectangle; |
| import flash.net.URLRequest; |
| import flash.text.engine.FontWeight; |
| import flash.text.engine.Kerning; |
| import flash.text.engine.TextLine; |
| |
| import flashx.textLayout.compose.IFlowComposer; |
| import flashx.textLayout.compose.StandardFlowComposer; |
| import flashx.textLayout.compose.TextFlowLine; |
| import flashx.textLayout.container.ContainerController; |
| import flashx.textLayout.container.ScrollPolicy; |
| import flashx.textLayout.conversion.ITextImporter; |
| import flashx.textLayout.conversion.TextConverter; |
| import flashx.textLayout.edit.*; |
| import flashx.textLayout.elements.FlowElement; |
| import flashx.textLayout.elements.FlowLeafElement; |
| import flashx.textLayout.elements.InlineGraphicElement; |
| import flashx.textLayout.elements.InlineGraphicElementStatus; |
| import flashx.textLayout.elements.LinkElement; |
| import flashx.textLayout.elements.ParagraphElement; |
| import flashx.textLayout.elements.SpanElement; |
| import flashx.textLayout.elements.TextFlow; |
| import flashx.textLayout.elements.TextRange; |
| import flashx.textLayout.events.StatusChangeEvent; |
| import flashx.textLayout.events.UpdateCompleteEvent; |
| import flashx.textLayout.formats.*; |
| import flashx.textLayout.operations.FlowOperation; |
| import flashx.textLayout.tlf_internal; |
| import flashx.textLayout.utils.GeometryUtil; |
| use namespace tlf_internal; |
| |
| import mx.utils.LoaderUtil; |
| import flashx.textLayout.conversion.ITextLayoutImporter; |
| |
| public class FETest extends VellumTestCase |
| { |
| private var data:Array; |
| private var callback:Boolean = false; |
| private var src:String; |
| private var baseImageURL:String; |
| private var indx1:int; |
| private var indx2:int; |
| private var indx3:int; |
| private var img1:InlineGraphicElement; |
| private var img2:InlineGraphicElement; |
| private var img3:InlineGraphicElement; |
| |
| public function FETest(methodName:String, testID:String, data:Array, testConfig:TestConfig, testXML:XML=null) |
| { |
| super(methodName, testID, testConfig, testXML); |
| this.data = data; |
| |
| this.TestID = this.TestID + ":"; |
| for each (var url:String in data) |
| { |
| this.TestID = this.TestID + ":" + url; |
| |
| if(url.search(".swf") != -1){ |
| TestData["bitmapSnapshot"] = "false"; |
| } |
| } |
| baseImageURL = LoaderUtil.createAbsoluteURL(baseURL, "../../test/testFiles/assets/"); |
| |
| // Note: These must correspond to a Watson product area (case-sensitive) |
| metaData.productArea = "Graphics"; |
| } |
| |
| public static function suiteFromXML(testListXML:XML, testConfig:TestConfig, ts:TestSuiteExtended):void |
| { |
| var writingDirection:String = testConfig.writingDirection[0] + "_" + testConfig.writingDirection[1]; |
| for each (var testCaseXML:XML in testListXML.*) |
| { |
| if (testCaseXML.localName() == "TestCase" && |
| testCaseXML.TestData.(@name == writingDirection).toString() != "false") |
| { |
| var fe:XMLList = testCaseXML.TestData.(@name == "foreignElement"); |
| |
| for each (var battery:String in fe.toString().split(",")) |
| { |
| var array:Array = new Array(); |
| |
| if(battery.indexOf("+") != -1){ |
| for each (var element:String in battery.split("+")) |
| { |
| for each (var group:* in fe.@dataGroup.toString().split(",")) |
| { |
| var dg:XMLList = |
| testListXML.DataGroup.(@group == group.toString()); |
| for each (var url:XML in dg.*) |
| { |
| if(battery.indexOf(url.@name.toString()) != -1) |
| { |
| array.push(url.@url.toString()); |
| } |
| } |
| } |
| } |
| }else{ |
| for each (var group2:* in fe.@dataGroup.toString().split(",")) |
| { |
| var dg2:XMLList = |
| testListXML.DataGroup.(@group == group2.toString()); |
| for each (var url2:XML in dg2.*) |
| { |
| if(battery.indexOf(url2.@name.toString()) != -1) |
| { |
| array.push(url2.@url.toString()); |
| break; |
| } |
| } |
| } |
| } |
| var testID:String = testCaseXML.@functionName.toString(); |
| for each (var urlStr:String in array) |
| { |
| testID = testID + "-" + urlStr; |
| } |
| var tempXML:XML = testCaseXML.copy(); |
| tempXML.appendChild (<TestData name="id">{testID}</TestData>); |
| ts.addTestDescriptor(new TestDescriptor (FETest, tempXML.@functionName, testConfig, tempXML, null, array)); |
| } |
| } |
| } |
| } |
| |
| /* |
| * This method is included, commented out, as an example of how to |
| * set up a FE test in such a way that the images are recorded |
| * in the snapshotting process. |
| public function insertImageTest(callBack:Object = null):void |
| { |
| if(!callback){ |
| callback = true; |
| TestFrame.container.addEventListener(Event.ENTER_FRAME,addAsync(insertImageTest,2500,null),false,0,true); |
| |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| |
| src = data[data.length-1].toString(); |
| var width:int = 20; |
| var height:int = 20; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertImage(src,width,height,false,"insert image"); |
| }else{ |
| // examine the results |
| var index:int = SelManager.textFlow.textLength/2; |
| var elem:LeafElement = SelManager.textFlow.findLeaf(index); |
| var img:InlineGraphic; |
| |
| assertTrue("inserted image element not found",elem is InlineGraphic); |
| if (elem is InlineGraphic) |
| { |
| img = InlineGraphic(elem); |
| |
| if(img.loadStatus != InlineGraphic.LOAD_COMPLETE){ |
| SelManager.textFlow.addEventListener(Event.ENTER_FRAME,addAsync(insertImageTest,2500,null),false,0,true); |
| }else{ |
| assertTrue("inserted image is the wrong width",img.width == 20); |
| assertTrue("inserted image is the wrong height",img.height == 20); |
| assertTrue("inserted image has the wrong uri",img.src == src); |
| assertTrue("inserted image has the wrong length",img.textLength == 1); |
| } |
| } |
| } |
| } */ |
| |
| /** |
| * Select halfway through the flow and insert an image using a string source |
| */ |
| public function insertImageAsString(callBack:Object = null):void |
| { |
| if(!callback) |
| { |
| callback = true; |
| TestFrame.container.addEventListener(Event.ENTER_FRAME,addAsync(insertImageAsString,2500,null),false,0,true); |
| |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| var flowLength:int = SelManager.textFlow.textLength; |
| |
| var src:String = data[data.length-1].toString(); |
| var width:int = 20; |
| var height:int = 20; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| var inlineGraphicElement:InlineGraphicElement = SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| |
| // examine the results |
| var elem:FlowLeafElement = SelManager.textFlow.findLeaf(startIndx); |
| assertTrue("Return value of insertInlineGraphic doesn't match what is found", inlineGraphicElement == elem); |
| assertTrue("inserted InlineGraphicElement element not found",elem is InlineGraphicElement); |
| assertTrue("unexpected flow textLength after replacing text with graphic", (flowLength + 1) - (endIndx - startIndx)); |
| assertTrue("unexpected range selection after replacing text with graphic", SelManager.anchorPosition == SelManager.activePosition); |
| assertTrue("unexpected selection position after replacing text with graphic", SelManager.anchorPosition == startIndx + 1); |
| if (elem is InlineGraphicElement) |
| { |
| var img:InlineGraphicElement = InlineGraphicElement(elem); |
| assertTrue("inserted image is the wrong width",img.width == width); |
| assertTrue("inserted image is the wrong height",img.height == height); |
| assertTrue("inserted image has the wrong source",img.source == LoaderUtil.createAbsoluteURL(baseImageURL,src)); |
| assertTrue("inserted image has the wrong length",img.textLength == 1); |
| } |
| } |
| else // Make sure the image is ready before we let the snapshot go |
| { |
| elem = SelManager.textFlow.findLeaf(SelManager.textFlow.textLength/2); |
| img = InlineGraphicElement(elem); |
| if(img.status != InlineGraphicElementStatus.READY) |
| { |
| SelManager.textFlow.addEventListener(Event.ENTER_FRAME,addAsync(insertImageAsString,2500,null),false,0,true); |
| } |
| } |
| } |
| |
| private function createFilledSprite(width:Number, height:Number, color:int):Sprite |
| { |
| var sprite:Sprite = new Sprite(); |
| sprite.graphics.beginFill(color); // red |
| sprite.graphics.drawRect(0,0,width,height); |
| sprite.graphics.endFill(); |
| return sprite; |
| } |
| |
| /** |
| * Select a quarter of the way through the flow and insert an image using a DisplayObject source |
| */ |
| public function insertImageAsDisplayObject(callBack:Object = null):void |
| { |
| if(!callback) |
| { |
| callback = true; |
| TestFrame.container.addEventListener(Event.ENTER_FRAME,addAsync(insertImageAsDisplayObject,2500,null),false,0,true); |
| |
| var startIndx:int = SelManager.textFlow.textLength/4; |
| var endIndx:int = startIndx + 5; // replace existing text |
| var flowLength:int = SelManager.textFlow.textLength; |
| |
| var sprite:Sprite = createFilledSprite(100, 100, 0xff0000); |
| |
| var src:Object = sprite; |
| var width:int = 100; |
| var height:int = 100; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(src,width,height); |
| |
| // examine the results |
| var elem:FlowLeafElement = SelManager.textFlow.findLeaf(startIndx); |
| assertTrue("inserted InlineGraphicElement element not found",elem is InlineGraphicElement); |
| assertTrue("unexpected flow textLength after replacing text with graphic", (flowLength + 1) - (endIndx - startIndx)); |
| assertTrue("unexpected range selection after replacing text with graphic", SelManager.anchorPosition == SelManager.activePosition); |
| assertTrue("unexpected selection position after replacing text with graphic", SelManager.anchorPosition == startIndx + 1); |
| if (elem is InlineGraphicElement) |
| { |
| var img:InlineGraphicElement = InlineGraphicElement(elem); |
| assertTrue("inserted image is the wrong width",img.width == width); |
| assertTrue("inserted image is the wrong height",img.height == height); |
| assertTrue("inserted image has the wrong source",img.source == src); |
| assertTrue("inserted image has the wrong length",img.textLength == 1); |
| } |
| } |
| else // Make sure the image is ready before we let the snapshot go |
| { |
| elem = SelManager.textFlow.findLeaf((SelManager.textFlow.textLength+5)/4); |
| img = InlineGraphicElement(elem); |
| if(img.status != InlineGraphicElementStatus.READY) |
| { |
| SelManager.textFlow.addEventListener(Event.ENTER_FRAME,addAsync(insertImageAsDisplayObject,2500,null),false,0,true); |
| } |
| } |
| } |
| |
| /** |
| * Select a third of the way through the flow and insert an image using a URLRequest Source |
| */ |
| public function insertImageAsURLRequest(callBack:Object = null):void |
| { |
| try |
| { |
| if(!callback) |
| { |
| callback = true; |
| TestFrame.container.addEventListener(Event.ENTER_FRAME,addAsync(insertImageAsURLRequest,2500,null),false,0,true); |
| |
| var startIndx:int = SelManager.textFlow.textLength/3; |
| var endIndx:int = startIndx + 5; // replace existing text |
| var flowLength:int = SelManager.textFlow.textLength; |
| |
| var url:URLRequest = new URLRequest("http://www.adobe.com/images/shared/download_buttons/get_adobe_flash_player.png"); |
| |
| var src:Object = url; |
| var width:int = 106; |
| var height:int = 32; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(src,width,height); |
| |
| // examine the results |
| var elem:FlowLeafElement = SelManager.textFlow.findLeaf(startIndx); |
| assertTrue("inserted InlineGraphicElement element not found", elem is InlineGraphicElement); |
| assertTrue("unexpected flow textLength after replacing text with graphic", (flowLength + 1) - (endIndx - startIndx)); |
| assertTrue("unexpected range selection after replacing text with graphic", SelManager.anchorPosition == SelManager.activePosition); |
| assertTrue("unexpected selection position after replacing text with graphic", SelManager.anchorPosition == startIndx + 1); |
| if (elem is InlineGraphicElement) |
| { |
| var img:InlineGraphicElement = InlineGraphicElement(elem); |
| assertTrue("inserted image is the wrong width",img.width == width); |
| assertTrue("inserted image is the wrong height",img.height == height); |
| assertTrue("inserted image has the wrong source",img.source == src); |
| assertTrue("inserted image has the wrong length",img.textLength == 1); |
| } |
| } |
| else // Make sure the image is ready before we let the snapshot go |
| { |
| elem = SelManager.textFlow.findLeaf((SelManager.textFlow.textLength+2)/3); |
| img = InlineGraphicElement(elem); |
| if(img.status != InlineGraphicElementStatus.READY) |
| { |
| SelManager.textFlow.addEventListener(Event.ENTER_FRAME,addAsync(insertImageAsURLRequest,2500,null),false,0,true); |
| } |
| } |
| } |
| catch ( err:IOError ) |
| { |
| fail( "Test error while loading image from URL: " + err.message ); |
| } |
| } |
| |
| /** |
| * Test for Watson 2609303 |
| */ |
| public function insertAtEndAndUndo(callBack:Object = null):void |
| { |
| var elem:FlowLeafElement; |
| var startIndx:int; |
| if(!callback) |
| { |
| callback = true; |
| TestFrame.container.addEventListener(Event.ENTER_FRAME,addAsync(insertAtEndAndUndo,2500,null),false,0,true); |
| |
| var textFlow:TextFlow = SelManager.textFlow; |
| |
| startIndx = SelManager.textFlow.textLength - 1; |
| |
| var width:int = 100; |
| var height:int = 100; |
| var src:String = data[data.length-1].toString(); |
| |
| SelManager.selectRange(startIndx, startIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),FormatValue.AUTO,FormatValue.AUTO); |
| |
| // examine the results |
| elem = SelManager.textFlow.findLeaf(startIndx); |
| assertTrue("inserted InlineGraphicElement element not found",elem is InlineGraphicElement); |
| |
| } |
| else // Make sure the image is ready before we try the undo |
| { |
| elem = SelManager.textFlow.findLeaf(SelManager.textFlow.textLength - 2); |
| var img:InlineGraphicElement = InlineGraphicElement(elem); |
| if(img.status != InlineGraphicElementStatus.READY) |
| { |
| SelManager.textFlow.addEventListener(Event.ENTER_FRAME,addAsync(insertAtEndAndUndo,2500,null),false,0,true); |
| return; |
| } |
| // SelManager.textFlow.flowComposer.updateAllControllers(); |
| SelManager.undo(); |
| |
| assertTrue("expected inline to be removed by undo",elem.parent == null); |
| } |
| } |
| |
| public function modifyImageSourceTest():void |
| { |
| try |
| { |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| var flowLength:int = SelManager.textFlow.textLength; |
| |
| var src:Object = data[data.length-1].toString(); |
| var width:int = 20; |
| var height:int = 20; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,String(src)),width,height); |
| |
| // examine the results |
| var elem:FlowLeafElement = SelManager.textFlow.findLeaf(startIndx); |
| assertTrue("inserted InlineGraphicElement element not found",elem is InlineGraphicElement); |
| assertTrue("unexpected flow textLength after replacing text with graphic", (flowLength + 1) - (endIndx - startIndx)); |
| assertTrue("unexpected range selection after replacing text with graphic", SelManager.anchorPosition == SelManager.activePosition); |
| assertTrue("unexpected selection position after replacing text with graphic", SelManager.anchorPosition == startIndx + 1); |
| if (elem is InlineGraphicElement) |
| { |
| var img:InlineGraphicElement = InlineGraphicElement(elem); |
| assertTrue("inserted image is the wrong width",img.width == width); |
| assertTrue("inserted image is the wrong height",img.height == height); |
| assertTrue("inserted image has the wrong source",img.source == LoaderUtil.createAbsoluteURL(baseImageURL,String(src))); |
| assertTrue("inserted image has the wrong length",img.textLength == 1); |
| } |
| |
| // Modify from string to GraphicsObject |
| |
| var sprite:Sprite = new Sprite(); |
| sprite.graphics.beginFill(0xff0000); // red |
| sprite.graphics.drawRect(0,0,100,100); |
| sprite.graphics.endFill(); |
| |
| src = sprite; |
| width = 100; |
| height = 100; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.modifyInlineGraphic(src,width,height); |
| |
| // examine the results |
| elem = SelManager.textFlow.findLeaf(startIndx); |
| assertTrue("inserted InlineGraphicElement element not found",elem is InlineGraphicElement); |
| if (elem is InlineGraphicElement) |
| { |
| img = InlineGraphicElement(elem); |
| assertTrue("inserted image is the wrong width",img.width == width); |
| assertTrue("inserted image is the wrong height",img.height == height); |
| assertTrue("inserted image has the wrong source",img.source == src); |
| assertTrue("inserted image has the wrong length",img.textLength == 1); |
| } |
| |
| // Modify from DisplayObject to URLRequest |
| |
| var url:URLRequest = new URLRequest("https://bugs.corp.adobe.com/WTSNPROD/images/Watson_Adobe_Logo.gif"); |
| |
| src = url; |
| width = 106; |
| height = 32; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.modifyInlineGraphic(src,width,height); |
| |
| // examine the results |
| elem = SelManager.textFlow.findLeaf(startIndx); |
| assertTrue("inserted InlineGraphicElement element not found", elem is InlineGraphicElement); |
| if (elem is InlineGraphicElement) |
| { |
| img = InlineGraphicElement(elem); |
| assertTrue("inserted image is the wrong width",img.width == width); |
| assertTrue("inserted image is the wrong height",img.height == height); |
| assertTrue("inserted image has the wrong source",img.source == src); |
| assertTrue("inserted image has the wrong length",img.textLength == 1); |
| } |
| } |
| catch ( err:IOError ) |
| { |
| fail( "Test error while loading image from URL: " + err.message ); |
| } |
| } |
| |
| public function copyMultipleImageTest(callBack:Object = null):void |
| { |
| if (!callBack) |
| { |
| // Insert 3 images |
| callBack = true; |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(copyMultipleImageTest,2500,null),false,0,true); |
| var indx:int = SelManager.textFlow.textLength/2; |
| var origFlowLength:int = SelManager.textFlow.textLength; |
| |
| var width:int = 20; |
| var height:int = 20; |
| SelManager.selectRange(indx, indx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,"smiling.png"),width,height); |
| var firstIndx:int = indx; |
| |
| width = 30; |
| height = 30; |
| SelManager.selectRange(indx, indx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,"gremlin.jpg"),width,height); |
| var secondIndx:int = indx; |
| |
| indx = SelManager.textFlow.textLength/3; |
| width = 40; |
| height = 40; |
| SelManager.selectRange(indx, indx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,"smiley.gif"),width,height); |
| var thirdIndx:int = indx; |
| |
| SelManager.selectRange(thirdIndx, |
| firstIndx+3 ); |
| |
| var copy:TextScrap = TextScrap.createTextScrap(SelManager.getSelectionState()); |
| SelManager.deleteNextCharacter(); |
| SelManager.selectRange(thirdIndx, |
| thirdIndx ); |
| SelManager.pasteTextScrap(copy); |
| |
| // examine the results |
| var elem:FlowLeafElement = SelManager.textFlow.findLeaf(firstIndx+1); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| assertTrue("unexpected flow textLength after replacing text with graphic", |
| SelManager.textFlow.textLength == origFlowLength + 3); |
| assertTrue("unexpected range selection after replacing text with graphic", |
| SelManager.anchorPosition == SelManager.activePosition); |
| assertTrue("unexpected selection position after replacing text with graphic", |
| SelManager.activePosition == firstIndx+3); |
| elem = SelManager.textFlow.findLeaf(secondIndx+2); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| elem = SelManager.textFlow.findLeaf(thirdIndx); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| |
| SelManager.undo(); // Undo the paste |
| SelManager.undo(); // Undo the delete |
| |
| elem = SelManager.textFlow.findLeaf(firstIndx+1); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| assertTrue("unexpected flow textLength after replacing text with graphic", |
| SelManager.textFlow.textLength == origFlowLength + 3); |
| elem = SelManager.textFlow.findLeaf(secondIndx+2); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| elem = SelManager.textFlow.findLeaf(thirdIndx); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| |
| SelManager.redo(); // Redo the delete |
| SelManager.redo(); // Redo the paste |
| |
| indx1 = firstIndx+1; |
| elem = SelManager.textFlow.findLeaf(firstIndx+1); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| assertTrue("unexpected flow textLength after replacing text with graphic", |
| SelManager.textFlow.textLength == origFlowLength + 3); |
| assertTrue("unexpected range selection after replacing text with graphic", |
| SelManager.anchorPosition == SelManager.activePosition); |
| assertTrue("unexpected selection position after replacing text with graphic", |
| SelManager.activePosition == firstIndx+3); |
| indx2 = secondIndx+2; |
| elem = SelManager.textFlow.findLeaf(secondIndx+2); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| indx3 = thirdIndx; |
| elem = SelManager.textFlow.findLeaf(thirdIndx); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| } |
| else // Make sure the image is ready before we let the snapshot go |
| { |
| img1 = SelManager.textFlow.findLeaf(indx1) as InlineGraphicElement; |
| img2 = SelManager.textFlow.findLeaf(indx2) as InlineGraphicElement; |
| img3 = SelManager.textFlow.findLeaf(indx3) as InlineGraphicElement; |
| |
| if(img1.status != InlineGraphicElementStatus.READY || img2.status != InlineGraphicElementStatus.READY || img3.status != InlineGraphicElementStatus.READY) |
| { |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(copyMultipleImageTest,2500,null),false,0,true); |
| } |
| } |
| } |
| |
| public function cutMultipleImageTest(callBack:Object = null):void |
| { |
| if (!callBack) |
| { |
| callBack = true; |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(cutMultipleImageTest,2500,null),false,0,true); |
| // Insert 3 images |
| var indx:int = SelManager.textFlow.textLength/2; |
| var origFlowLength:int = SelManager.textFlow.textLength; |
| |
| var width:int = 20; |
| var height:int = 20; |
| SelManager.selectRange(indx, indx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,"smiling.png"),width,height); |
| var firstIndx:int = indx; |
| |
| width = 30; |
| height = 30; |
| SelManager.selectRange(indx, indx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,"gremlin.jpg"),width,height); |
| var secondIndx:int = indx; |
| |
| indx = SelManager.textFlow.textLength/3; |
| width = 40; |
| height = 40; |
| SelManager.selectRange(indx, indx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,"smiley.gif"),width,height); |
| var thirdIndx:int = indx; |
| |
| SelManager.selectRange(thirdIndx, |
| firstIndx+3 ); |
| |
| var copy:TextScrap = SelManager.cutTextScrap(); |
| SelManager.selectRange(thirdIndx, |
| thirdIndx ); |
| SelManager.pasteTextScrap(copy); |
| |
| // examine the results |
| var elem:FlowLeafElement = SelManager.textFlow.findLeaf(firstIndx+1); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| assertTrue("unexpected flow textLength after replacing text with graphic", |
| SelManager.textFlow.textLength == origFlowLength + 3); |
| assertTrue("unexpected range selection after replacing text with graphic", |
| SelManager.anchorPosition == SelManager.activePosition); |
| assertTrue("unexpected selection position after replacing text with graphic", |
| SelManager.activePosition == firstIndx+3); |
| elem = SelManager.textFlow.findLeaf(secondIndx+2); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| elem = SelManager.textFlow.findLeaf(thirdIndx); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| |
| SelManager.undo(); // Undo the paste |
| |
| elem = SelManager.textFlow.findLeaf(firstIndx+1); |
| assertTrue("inserted InlineGraphicElement element should not be found", |
| !(elem is InlineGraphicElement)); |
| assertTrue("unexpected flow textLength after undo multi-image cut", |
| SelManager.textFlow.textLength == (origFlowLength - (firstIndx-thirdIndx)) ); |
| elem = SelManager.textFlow.findLeaf(secondIndx+2); |
| assertTrue("inserted InlineGraphicElement element should not be found", |
| !(elem is InlineGraphicElement)); |
| elem = SelManager.textFlow.findLeaf(thirdIndx); |
| assertTrue("inserted InlineGraphicElement element should not be found", |
| !(elem is InlineGraphicElement)); |
| |
| SelManager.undo(); // Undo the cut |
| elem = SelManager.textFlow.findLeaf(firstIndx+1); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| assertTrue("unexpected flow textLength after replacing text with graphic", |
| SelManager.textFlow.textLength == origFlowLength + 3); |
| assertTrue("unexpected range selection after replacing text with graphic", |
| SelManager.anchorPosition != SelManager.activePosition); |
| assertTrue("unexpected selection position after replacing text with graphic", |
| SelManager.anchorPosition == thirdIndx && |
| SelManager.activePosition == firstIndx+3); |
| elem = SelManager.textFlow.findLeaf(secondIndx+2); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| elem = SelManager.textFlow.findLeaf(thirdIndx); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| |
| SelManager.redo(); // Redo the cut |
| |
| elem = SelManager.textFlow.findLeaf(firstIndx+1); |
| assertTrue("inserted InlineGraphicElement element should not be found", |
| !(elem is InlineGraphicElement)); |
| assertTrue("unexpected flow textLength after undo multi-image cut", |
| SelManager.textFlow.textLength == (origFlowLength - (firstIndx-thirdIndx)) ); |
| elem = SelManager.textFlow.findLeaf(secondIndx+2); |
| assertTrue("inserted InlineGraphicElement element should not be found", |
| !(elem is InlineGraphicElement)); |
| elem = SelManager.textFlow.findLeaf(thirdIndx); |
| assertTrue("inserted InlineGraphicElement element should not be found", |
| !(elem is InlineGraphicElement)); |
| |
| SelManager.redo(); // Redo the paste |
| |
| indx1 = firstIndx+1; |
| elem = SelManager.textFlow.findLeaf(firstIndx+1); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| assertTrue("unexpected flow textLength after replacing text with graphic", |
| SelManager.textFlow.textLength == origFlowLength + 3); |
| assertTrue("unexpected range selection after replacing text with graphic", |
| SelManager.anchorPosition == SelManager.activePosition); |
| assertTrue("unexpected selection position after replacing text with graphic", |
| SelManager.activePosition == firstIndx+3); |
| indx2 = secondIndx+2; |
| elem = SelManager.textFlow.findLeaf(secondIndx+2); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| indx3 = thirdIndx; |
| elem = SelManager.textFlow.findLeaf(thirdIndx); |
| assertTrue("inserted InlineGraphicElement element not found", |
| elem is InlineGraphicElement); |
| } |
| else // Make sure the image is ready before we let the snapshot go |
| { |
| img1 = SelManager.textFlow.findLeaf(indx1) as InlineGraphicElement; |
| img2 = SelManager.textFlow.findLeaf(indx2) as InlineGraphicElement; |
| img3 = SelManager.textFlow.findLeaf(indx3) as InlineGraphicElement; |
| |
| if(img1.status != InlineGraphicElementStatus.READY || img2.status != InlineGraphicElementStatus.READY || img3.status != InlineGraphicElementStatus.READY) |
| { |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(cutMultipleImageTest,2500,null),false,0,true); |
| } |
| } |
| } |
| |
| /** |
| * Testing undo/redo of image insertion |
| */ |
| public function undoRedoInsertImageTest(callBack:Object = null):void |
| { |
| if (!callback) |
| { |
| callback = true; |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(undoRedoInsertImageTest,2500,null),false,0,true); |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| indx1 = startIndx; |
| |
| var src:String = data[data.length-1].toString(); |
| var width:int = 20; |
| var height:int = 20; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| var elem:FlowLeafElement = SelManager.textFlow.findLeaf(startIndx); |
| assertTrue("inserted image element not found",elem is InlineGraphicElement); |
| |
| SelManager.undo(); |
| |
| elem = SelManager.textFlow.findLeaf(startIndx); |
| assertTrue("inserted image element not deleted by undo",!(elem is InlineGraphicElement)); |
| |
| SelManager.redo(); |
| elem = SelManager.textFlow.findLeaf(startIndx); |
| assertTrue("inserted image element not recreated by redo",elem is InlineGraphicElement); |
| } |
| else // Make sure the image is ready before we let the snapshot go |
| { |
| img1 = SelManager.textFlow.findLeaf(indx1) as InlineGraphicElement; |
| |
| if(img1.status != InlineGraphicElementStatus.READY) |
| { |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(undoRedoInsertImageTest,2500,null),false,0,true); |
| } |
| } |
| } |
| |
| /** |
| * Test for Watson 2512062 |
| */ |
| public function insertStyleNameTest(callBack:Object = null):void |
| { |
| SelManager.selectRange(0, 5); |
| var format:TextLayoutFormat = new TextLayoutFormat(); |
| format.fontWeight = FontWeight.BOLD; |
| SelManager.applyFormat(format, null, null); |
| var leaf:FlowLeafElement = SelManager.textFlow.getFirstLeaf(); |
| leaf.styleName = "foo"; |
| |
| var sprite:Sprite = new Sprite(); |
| sprite.graphics.beginFill(0xff0000); // red |
| sprite.graphics.drawRect(0,0,100,100); |
| sprite.graphics.endFill(); |
| SelManager.selectRange(5, 5); |
| SelManager.insertInlineGraphic(sprite, 100, 100); |
| |
| var inlineGraphic:FlowLeafElement = leaf.getNextLeaf(); |
| assertTrue("Expected styleName to be propagated to inline graphic", inlineGraphic.styleName == "foo"); |
| |
| SelManager.undo(); // undo inline graphic insert |
| |
| var pointFormat:PointFormat = new PointFormat(); |
| pointFormat.setStyle("styleName", "bar"); |
| SelManager.setSelectionState(new SelectionState(SelManager.textFlow, 25, 25, pointFormat)); |
| inlineGraphic = SelManager.insertInlineGraphic(sprite, 100, 100); |
| |
| assertTrue("Expected styleName from pointFormat to be propagated to inserted inline graphic", inlineGraphic.styleName == "bar"); |
| } |
| |
| /** |
| * Select halfway through the flow and insert an image .. and then change it |
| */ |
| public function changeImageTest(callback:Object = null):void |
| { |
| if (!callback) |
| { |
| callback = true; |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(changeImageTest,2500,null),false,0,true); |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| indx1 = startIndx; |
| |
| var src:String = data[data.length-1].toString(); |
| var width:int = 20; |
| var height:int = 20; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| |
| // examine the results |
| var elem:FlowLeafElement = SelManager.textFlow.findLeaf(startIndx); |
| var img:InlineGraphicElement; |
| |
| assertTrue("inserted image element not found",elem is InlineGraphicElement); |
| if (elem is InlineGraphicElement) |
| { |
| img = InlineGraphicElement(elem); |
| assertTrue("inserted image is the wrong width",img.width == width); |
| assertTrue("inserted image is the wrong height",img.height == height); |
| assertTrue("inserted image has the wrong uri",img.source == LoaderUtil.createAbsoluteURL(baseImageURL,src)); |
| assertTrue("inserted image has the wrong length",img.textLength == 1); |
| } |
| |
| // block select the image and change it |
| var chgSrc:String = data[data.length-1].toString(); |
| var chgWidth:int = 40; |
| var chgHeight:int = 40; |
| |
| SelManager.selectRange(startIndx, endIndx+1); |
| SelManager.modifyInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,chgSrc),chgWidth,chgHeight); |
| |
| // examine the results |
| elem = SelManager.textFlow.findLeaf(startIndx); |
| assertTrue("inserted image element not found",elem is InlineGraphicElement); |
| if (elem is InlineGraphicElement) |
| { |
| img = InlineGraphicElement(elem); |
| assertTrue("inserted image is the wrong width",img.width == chgWidth); |
| assertTrue("inserted image is the wrong height",img.height == chgHeight); |
| assertTrue("inserted image has the wrong uri",img.source == LoaderUtil.createAbsoluteURL(baseImageURL,chgSrc)); |
| assertTrue("inserted image has the wrong length",img.textLength == 1); |
| } |
| } |
| else // Make sure the image is ready before we let the snapshot go |
| { |
| img1 = SelManager.textFlow.findLeaf(indx1) as InlineGraphicElement; |
| |
| if(img1.status != InlineGraphicElementStatus.READY) |
| { |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(changeImageTest,2500,null),false,0,true); |
| } |
| } |
| } |
| |
| /** |
| * Select halfway through the flow and insert an image .. and then change it .. and then undo and redo the change |
| */ |
| public function undoRedoChangeImageTest(callback:Object = null):void |
| { |
| if (!callback) |
| { |
| callback = true; |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(undoRedoChangeImageTest,2500,null),false,0,true); |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| indx1 = startIndx; |
| |
| var src:String = data[data.length-1].toString(); |
| var width:int = 20; |
| var height:int = 20; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| |
| // examine the results |
| var elem:FlowLeafElement; |
| var img:InlineGraphicElement; |
| |
| elem = SelManager.textFlow.findLeaf(startIndx); |
| assertTrue("inserted image element not found",elem is InlineGraphicElement); |
| if (elem is InlineGraphicElement) |
| { |
| img = InlineGraphicElement(elem); |
| assertTrue("inserted image is the wrong width",img.width == width); |
| assertTrue("inserted image is the wrong height",img.height == height); |
| assertTrue("inserted image has the wrong uri",img.source == LoaderUtil.createAbsoluteURL(baseImageURL,src)); |
| assertTrue("inserted image has the wrong length",img.textLength == 1); |
| } |
| |
| // block select the image and change it |
| var chgSrc:String = data[data.length-1].toString(); |
| var chgWidth:int = 40; |
| var chgHeight:int = 40; |
| |
| SelManager.selectRange(startIndx, endIndx+1); |
| SelManager.modifyInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,chgSrc),chgWidth,chgHeight); |
| |
| // examine the results |
| elem = SelManager.textFlow.findLeaf(startIndx); |
| assertTrue("inserted image element not found",elem is InlineGraphicElement); |
| if (elem is InlineGraphicElement) |
| { |
| img = InlineGraphicElement(elem); |
| assertTrue("inserted image is the wrong width",img.width == chgWidth); |
| assertTrue("inserted image is the wrong height",img.height == chgHeight); |
| assertTrue("inserted image has the wrong uri",img.source == LoaderUtil.createAbsoluteURL(baseImageURL,chgSrc)); |
| assertTrue("inserted image has the wrong length",img.textLength == 1); |
| } |
| |
| // undo the change image operation |
| SelManager.undo(); |
| |
| // examine the results |
| elem = SelManager.textFlow.findLeaf(startIndx); |
| assertTrue("inserted image element not found",elem is InlineGraphicElement); |
| if (elem is InlineGraphicElement) |
| { |
| img = InlineGraphicElement(elem); |
| assertTrue("inserted image is the wrong width",img.width == width); |
| assertTrue("inserted image is the wrong height",img.height == height); |
| assertTrue("inserted image has the wrong uri",img.source == LoaderUtil.createAbsoluteURL(baseImageURL,src)); |
| assertTrue("inserted image has the wrong length",img.textLength == 1); |
| } |
| |
| // redo the change image operation |
| SelManager.redo(); |
| |
| // examine the results |
| elem = SelManager.textFlow.findLeaf(startIndx); |
| assertTrue("inserted image element not found",elem is InlineGraphicElement); |
| if (elem is InlineGraphicElement) |
| { |
| img = InlineGraphicElement(elem); |
| assertTrue("inserted image is the wrong width",img.width == chgWidth); |
| assertTrue("inserted image is the wrong height",img.height == chgHeight); |
| assertTrue("inserted image has the wrong uri",img.source == LoaderUtil.createAbsoluteURL(baseImageURL,chgSrc)); |
| assertTrue("inserted image has the wrong length",img.textLength == 1); |
| } |
| } |
| else // Make sure the image is ready before we let the snapshot go |
| { |
| img1 = SelManager.textFlow.findLeaf(indx1) as InlineGraphicElement; |
| |
| if(img1.status != InlineGraphicElementStatus.READY) |
| { |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(undoRedoChangeImageTest,2500,null),false,0,true); |
| } |
| } |
| |
| } |
| |
| /** |
| * Ensure that you can't make the image wider than the TestFrame. |
| */ |
| public function nestedForeignElementsTest():void |
| { |
| /*var subTC:LayoutScrollableFlashTextContainer = new LayoutScrollableFlashTextContainer(); |
| subTC.verticalScrollPolicy = ScrollPolicy.OFF |
| subTC.horizontalScrollPolicy = ScrollPolicy.OFF*/ |
| var subTC:Sprite = new Sprite(); |
| var subController:ContainerController = new ContainerController(subTC); |
| var subTF:TextFlow = SelManager.textFlow.deepCopy() as TextFlow; |
| subTF.flowComposer = new StandardFlowComposer(); |
| var controller:ContainerController = new ContainerController(subTC); |
| subTF.flowComposer.addController(controller); |
| subTF.interactionManager = new EditManager(null); |
| |
| var src:String = data[data.length-1].toString(); |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| |
| var width:int = 20; |
| var height:int = 20; |
| |
| subTF.interactionManager.selectRange(startIndx, endIndx); |
| IEditManager(subTF.interactionManager).insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| |
| var image:InlineGraphicElement = SelManager.textFlow.findLeaf(startIndx) as InlineGraphicElement; |
| image.source = subTC; |
| } |
| |
| /** |
| * Make sure that changing the baseline changes the image position. |
| */ |
| public function changeBaselineTest(callback:Object = null):void |
| { |
| if (!callback) |
| { |
| callback = true; |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(changeBaselineTest,2500,null),false,0,true); |
| var tb:Boolean = TestFrame.rootElement.computedFormat.blockProgression == |
| BlockProgression.RL; |
| var src:String = data[data.length-1].toString(); |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| indx1 = startIndx; |
| |
| var width:int = 20; |
| var height:int = 20; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| |
| var image:InlineGraphicElement = SelManager.textFlow.findLeaf(startIndx) as InlineGraphicElement; |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| var init:int = tb ? |
| image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)).x: |
| image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)).y; |
| |
| SelManager.selectRange(startIndx, endIndx+1); |
| image.alignmentBaseline = flash.text.engine.TextBaseline.IDEOGRAPHIC_CENTER; |
| SelManager.flushPendingOperations(); |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| var end:int = tb ? |
| image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)).x: |
| image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)).y; |
| |
| |
| if(tb){ |
| assertTrue("Changing the baseline of the graphic did not " + |
| "accurately change the image's position. " + |
| end + " !> " + init + ".", |
| end > init |
| ); |
| }else{ |
| assertTrue("Changing the baseline of the graphic did not " + |
| "accurately change the image's position. " + |
| end + " !< " + init + ".", |
| end < init |
| ); |
| } |
| } |
| else // Make sure the image is ready before we let the snapshot go |
| { |
| img1 = SelManager.textFlow.findLeaf(indx1) as InlineGraphicElement; |
| |
| if(img1.status != InlineGraphicElementStatus.READY) |
| { |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(changeBaselineTest,2500,null),false,0,true); |
| } |
| } |
| } |
| |
| /** |
| * Make sure that shifting the baseline changes the image position. |
| */ |
| public function baselineShiftTest(callback:Object = null):void |
| { |
| if (!callback) |
| { |
| callback = true; |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(baselineShiftTest,2500,null),false,0,true); |
| var tb:Boolean = TestFrame.rootElement.computedFormat.blockProgression == |
| BlockProgression.RL; |
| |
| var src:String = data[data.length-1].toString(); |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| indx1 = startIndx; |
| |
| var width:int = 20; |
| var height:int = 20; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| |
| var image:InlineGraphicElement = SelManager.textFlow.findLeaf(startIndx) as InlineGraphicElement; |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| var init:int = tb ? |
| image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)).x: |
| image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)).y; |
| |
| SelManager.selectRange(startIndx, endIndx+1); |
| image.baselineShift = 20; |
| SelManager.flushPendingOperations(); |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| var end:int = tb ? |
| image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)).x: |
| image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)).y; |
| |
| if(tb){ |
| assertTrue("Changing the baseline of the graphic did not " + |
| "accurately change the image's position. " + |
| end + " != " + (init+20) + ".", |
| end == init + 20 |
| ); |
| }else{ |
| assertTrue("Changing the baseline of the graphic did not " + |
| "accurately change the image's position. " + |
| end + " != " + (init-20) + ".", |
| end == init - 20 |
| ); |
| } |
| } |
| else // Make sure the image is ready before we let the snapshot go |
| { |
| img1 = SelManager.textFlow.findLeaf(indx1) as InlineGraphicElement; |
| |
| if(img1.status != InlineGraphicElementStatus.READY) |
| { |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(baselineShiftTest,2500,null),false,0,true); |
| } |
| } |
| } |
| |
| /** |
| * Make sure that shifting the baseline changes the image position. |
| */ |
| public function breakOpportunityTest(callback:Object = null):void |
| { |
| // TODO: Matt this is a better way to figure out if we are TB |
| // The way you are doing it is not reliable |
| if (!callback) |
| { |
| callback = true; |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(breakOpportunityTest,2500,null),false,0,true); |
| SelManager.selectAll(); |
| var ca:TextLayoutFormat = new TextLayoutFormat(); |
| ca.fontFamily = "Times New Roman"; |
| SelManager.applyLeafFormat(ca); |
| SelManager.flushPendingOperations(); |
| |
| var tb:Boolean = TestFrame.rootElement.computedFormat.blockProgression == BlockProgression.RL; |
| |
| var src:String = data[data.length-1].toString(); |
| |
| var startIndx:int = SelManager.textFlow.flowComposer.getLineAt(1).absoluteStart; |
| var endIndx:int = startIndx + SelManager.textFlow.flowComposer.getLineAt(1).textLength; |
| SelManager.selectRange(endIndx, endIndx); |
| indx1 = endIndx; |
| |
| var width:int = 20; |
| var height:int = 20; |
| |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| |
| var image:InlineGraphicElement = SelManager.textFlow.findLeaf(endIndx) as InlineGraphicElement; |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| var init:Point = |
| image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)); |
| |
| SelManager.selectRange(endIndx, endIndx+1); |
| image.breakOpportunity = flash.text.engine.BreakOpportunity.NONE; |
| SelManager.flushPendingOperations(); |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| var mid:Point = |
| image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)); |
| |
| // TODO: top to bottom test |
| if (!tb) |
| { |
| assertTrue("The x position of the image is less than or equal to" + |
| " the initial position of the image: The image has not obeyed the" + |
| " BreakOpportunity.NONE designation. " + init.x + " !<= " + mid.x |
| , init.x <= mid.x); |
| assertTrue("The y position of the image is greater than or equal to" + |
| " the initial position of the image: The image has not obeyed the" + |
| " BreakOpportunity.NONE designation. " + init.y + " !>= " + mid.y |
| , init.y >= mid.y); |
| } |
| |
| SelManager.selectRange(endIndx, endIndx+1); |
| image.breakOpportunity = flash.text.engine.BreakOpportunity.AUTO; |
| SelManager.flushPendingOperations(); |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| var end:Point = |
| image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)); |
| |
| /*assertTrue("The x position of the image is greater than or equal to" + |
| " the midpoint position of the image: The image has not obeyed the" + |
| " BreakOpportunity.ALL designation.", mid.x >= end.x); |
| assertTrue("The y position of the image is less than or equal to" + |
| " the midpoint position of the image: The image has not obeyed the" + |
| " BreakOpportunity.ALL designation.", mid.y <= end.y);*/ |
| |
| // TODO: top to bottom test |
| if (!tb) |
| { |
| assertTrue("The x position of the image is not equal to" + |
| " the initial position of the image: The image's x position has not been" + |
| " restored by setting BreakOpportunity.AUTOMATIC.", init.x == end.x); |
| assertTrue("The y position of the image is not equal to" + |
| " the initial position of the image: The image's y position has not been" + |
| " restored by setting BreakOpportunity.AUTOMATIC.", init.y == end.y); |
| } |
| } |
| else // Make sure the image is ready before we let the snapshot go |
| { |
| img1 = SelManager.textFlow.findLeaf(indx1) as InlineGraphicElement; |
| |
| if(img1.status != InlineGraphicElementStatus.READY) |
| { |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(breakOpportunityTest,2500,null),false,0,true); |
| } |
| } |
| } |
| |
| /** |
| * Make sure that kerning doesn't change the image position. |
| */ |
| public function kerningTest():void |
| { |
| var src:String = data[data.length-1].toString(); |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| |
| var width:int = 20; |
| var height:int = 20; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| |
| var image:InlineGraphicElement = SelManager.textFlow.findLeaf(endIndx) as InlineGraphicElement; |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| var init:Point = |
| image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)); |
| |
| SelManager.selectRange(endIndx, endIndx+1); |
| image.kerning = image.computedFormat.kerning != Kerning.OFF ? Kerning.OFF : Kerning.ON; |
| SelManager.flushPendingOperations(); |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| var end:Point = |
| image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)); |
| |
| assertTrue("Changing the kerning value effected the placement of the image.", |
| Point.distance(init,end) == 0); |
| } |
| /** |
| * Make sure that changing the tracking changes the image position. |
| */ |
| public function trackingTest():void |
| { |
| var src:String = data[data.length-1].toString(); |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| |
| var width:int = 20; |
| var height:int = 20; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| |
| var image:InlineGraphicElement = SelManager.textFlow.findLeaf(endIndx) as InlineGraphicElement; |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| var init:Point = |
| image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)); |
| |
| SelManager.selectRange(endIndx-1, endIndx); |
| image.trackingRight = image.computedFormat.trackingRight + 20; |
| SelManager.flushPendingOperations(); |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| var end:Point = |
| image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)); |
| |
| // assertTrue("Changing the trackingRight value by twenty did not effect the " + |
| // "placement of the image.", Point.distance(init,end) != 0); |
| |
| SelManager.selectRange(endIndx-1, endIndx); |
| image.trackingLeft = image.computedFormat.trackingLeft + 20; |
| SelManager.flushPendingOperations(); |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| |
| // this test is not right for RTL - the image is treated as a RTL character and end is now the character before |
| // removed this test as a workaround for bug 2467357 - QE can revisit for the RTL case |
| if (this.writingDirection[1] == Direction.LTR) |
| { |
| end = image.graphic.localToGlobal(new Point(image.graphic.x,image.graphic.y)); |
| assertTrue("Changing the trackingLeft value by twenty did not effect the " + |
| "placement of the image.", Point.distance(init,end) != 0); |
| } |
| } |
| |
| /** |
| * Make sure that inserting a FE in a link applies the link properties to the FE. |
| */ |
| public function insertFEInLink(callBack:Object = null):void |
| { |
| if (!callBack) |
| { |
| callBack = true; |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(insertFEInLink,2500,null),false,0,true); |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| indx1 = startIndx; |
| |
| var site:String = "http://www.google.com"; |
| var ref:String = "_self"; |
| |
| SelManager.selectRange(startIndx-5,endIndx+5); |
| SelManager.applyLink(site,ref ,false); |
| |
| var src:String = data[data.length-1].toString(); |
| |
| var width:int = 20; |
| var height:int = 20; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| |
| var image:InlineGraphicElement = SelManager.textFlow.findLeaf(endIndx) as InlineGraphicElement; |
| SelManager.flushPendingOperations(); |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| var link:LinkElement = image.getParentByType(LinkElement) as LinkElement; |
| |
| assertTrue("Foreign Element does not point to the correct" + |
| "site.", link.href == site); |
| |
| assertTrue("Foreign Element does not have the correct " + |
| "href.", link.target == ref); |
| } |
| else // Make sure the image is ready before we let the snapshot go |
| { |
| img1 = SelManager.textFlow.findLeaf(indx1) as InlineGraphicElement; |
| |
| if(img1.status != InlineGraphicElementStatus.READY) |
| { |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(insertFEInLink,2500,null),false,0,true); |
| } |
| } |
| } |
| |
| /** |
| * Make sure that adding a link to a FE works. |
| */ |
| public function foreignElementToLink(callBack:Object = null):void |
| { |
| if (!callBack) |
| { |
| callBack = true; |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(foreignElementToLink,2500,null),false,0,true); |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| indx1 = startIndx; |
| |
| var src:String = data[data.length-1].toString(); |
| |
| var width:int = 20; |
| var height:int = 20; |
| |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| |
| var site:String = "http://www.google.com"; |
| var ref:String = "_self"; |
| |
| SelManager.selectRange(startIndx, endIndx+1); |
| SelManager.applyLink(site,ref ,false); |
| |
| var image:InlineGraphicElement = SelManager.textFlow.findLeaf(endIndx) as InlineGraphicElement; |
| SelManager.flushPendingOperations(); |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| var link:LinkElement = image.getParentByType(LinkElement) as LinkElement; |
| |
| assertTrue("Foreign Element does not point to the correct" + |
| "site.", link.href == site); |
| |
| assertTrue("Foreign Element does not have the correct " + |
| "href.", link.target == ref); |
| } |
| else // Make sure the image is ready before we let the snapshot go |
| { |
| img1 = SelManager.textFlow.findLeaf(indx1) as InlineGraphicElement; |
| |
| if(img1.status != InlineGraphicElementStatus.READY) |
| { |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(foreignElementToLink,2500,null),false,0,true); |
| } |
| } |
| } |
| |
| /** |
| * Resize the foreign element proportionally and see that it has the right |
| * dimensions. |
| */ |
| |
| public function proportionalSize(callBack:Object = null):void |
| { |
| if(!callback) |
| { |
| callback = true; |
| TestFrame.container.addEventListener(Event.ENTER_FRAME,addAsync(proportionalSize,2500,null),false,0,true); |
| |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| indx1 = endIndx; |
| |
| var src:String = data[data.length-1].toString(); |
| |
| var width:String = "100%"; |
| var height:String = "100%"; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| |
| var image:InlineGraphicElement = SelManager.textFlow.findLeaf(SelManager.textFlow.textLength/2) as InlineGraphicElement; |
| |
| var initWidth:int = image.width as int; |
| var initHeight:int = image.height as int; |
| |
| startIndx = startIndx + 5; |
| endIndx = startIndx; |
| indx2 = endIndx; |
| |
| width = "50%"; |
| height = "50%"; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| |
| image = SelManager.textFlow.findLeaf(indx2) as InlineGraphicElement; |
| |
| var midWidth:int = image.actualWidth as int; |
| var midHeight:int = image.actualHeight as int; |
| |
| assertTrue("Final width is not half of initial width!", initWidth/2 == midWidth); |
| assertTrue("Final height is not half of initial height!", initHeight/2 == midHeight); |
| |
| startIndx = startIndx + 5; |
| endIndx = startIndx; |
| indx3 = endIndx; |
| |
| width = "200%"; |
| height = "200%"; |
| |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| |
| image = SelManager.textFlow.findLeaf(indx3) as InlineGraphicElement; |
| |
| var endWidth:int = image.actualWidth as int; |
| var endHeight:int = image.actualHeight as int; |
| |
| assertTrue("Final width is not half of initial width!", initWidth*2 == endWidth); |
| assertTrue("Final height is not half of initial height!", initHeight*2 == endHeight); |
| |
| } |
| else // Make sure the image is ready before we let the snapshot go |
| { |
| img1 = SelManager.textFlow.findLeaf(indx1) as InlineGraphicElement; |
| img2 = SelManager.textFlow.findLeaf(indx2) as InlineGraphicElement; |
| img3 = SelManager.textFlow.findLeaf(indx3) as InlineGraphicElement; |
| |
| if(img1.status != InlineGraphicElementStatus.READY || img2.status != InlineGraphicElementStatus.READY || img3.status != InlineGraphicElementStatus.READY) |
| { |
| SelManager.textFlow.addEventListener(Event.ENTER_FRAME,addAsync(proportionalSize,2500,null),false,0,true); |
| } |
| } |
| } |
| |
| private function updateCompletionHandler(event:Event):void |
| { |
| assertTrue("Operation must be on stack",SelManager.undoManager.canUndo()); |
| var op:FlowOperation = SelManager.undoManager.peekUndo() as FlowOperation; |
| assertTrue("FlowOperation not found",op != null); |
| assertTrue("FlowManager generation mismatch",op.endGeneration == SelManager.textFlow.generation); |
| this.callback = false; |
| } |
| |
| /** |
| * Size the FE at 50% height, then verify that the width is set proportionally. |
| */ |
| public function proportionalAutoWidth(callBack:Object = null):void |
| { |
| if(!callback){ |
| callback = true; |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(proportionalAutoWidth,2500,null),false,0,true); |
| |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| |
| var src:String = data[data.length-1].toString(); |
| |
| var width:String = "auto"; |
| var height:String = "50%"; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| } |
| else |
| { |
| assertTrue("unexected event",callBack is StatusChangeEvent); |
| var event:StatusChangeEvent = StatusChangeEvent(callBack); |
| assertTrue("unexpected StatusChangeEvent received",event.element is InlineGraphicElement); |
| var image:InlineGraphicElement = InlineGraphicElement(event.element); |
| switch (event.status) |
| { |
| case InlineGraphicElementStatus.LOADING: |
| case InlineGraphicElementStatus.SIZE_PENDING: |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(proportionalAutoWidth,2500,null),false,0,true); |
| break; |
| case InlineGraphicElementStatus.READY: |
| var effWidth:Number = image.actualWidth as Number; |
| var effHeight:Number = image.actualHeight as Number; |
| |
| var nomWidth:Number = image.measuredWidth as Number; |
| var nomHeight:Number = image.measuredHeight as Number; |
| |
| assertTrue("Final width is not half of initial width!", nomWidth/2 == effWidth); |
| assertTrue("Final height is not half of initial height!", nomHeight/2 == effHeight); |
| SelManager.textFlow.addEventListener(UpdateCompleteEvent.UPDATE_COMPLETE,addAsync(updateCompletionHandler,2500,null),false,0,true); |
| break; |
| default: |
| assertTrue("unexpected StatusChangeEvent status: "+event.status,false); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Size the FE at 50% height, then verify that the width is set proportionally. |
| */ |
| public function proportionalAutoHeight(callBack:Object = null):void |
| { |
| if(!callback) |
| { |
| callback = true; |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(proportionalAutoHeight,2500,null),false,0,true); |
| |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| |
| var src:String = data[data.length-1].toString(); |
| |
| var width:String = "50%"; |
| var height:String = "auto"; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| } |
| else |
| { |
| assertTrue("unexected event",callBack is StatusChangeEvent); |
| var event:StatusChangeEvent = StatusChangeEvent(callBack); |
| assertTrue("unexpected StatusChangeEvent received",event.element is InlineGraphicElement); |
| var image:InlineGraphicElement = InlineGraphicElement(event.element); |
| switch (event.status) |
| { |
| case InlineGraphicElementStatus.LOADING: |
| case InlineGraphicElementStatus.SIZE_PENDING: |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(proportionalAutoHeight,2500,null),false,0,true); |
| break; |
| case InlineGraphicElementStatus.READY: |
| var effWidth:Number = image.actualWidth as Number; |
| var effHeight:Number = image.actualHeight as Number; |
| |
| var nomWidth:Number = image.measuredWidth as Number; |
| var nomHeight:Number = image.measuredHeight as Number; |
| |
| assertTrue("Final width is not half of initial width!", nomWidth/2 == effWidth); |
| assertTrue("Final height is not half of initial height!", nomHeight/2 == effHeight); |
| SelManager.textFlow.addEventListener(UpdateCompleteEvent.UPDATE_COMPLETE,addAsync(updateCompletionHandler,2500,null),false,0,true); |
| break; |
| default: |
| assertTrue("unexpected StatusChangeEvent status: "+event.status,false); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Size the FE at 50 width, then verify that the height is set proportionally. |
| */ |
| public function proportionalFixedWidth(callBack:Object = null):void |
| { |
| if(!callback) |
| { |
| callback = true; |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(proportionalFixedWidth,2500,null),false,0,true); |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| |
| var src:String = data[data.length-1].toString(); |
| |
| var width:String = "50"; |
| var height:String = "auto"; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| } |
| else |
| { |
| assertTrue("unexected event",callBack is StatusChangeEvent); |
| var event:StatusChangeEvent = StatusChangeEvent(callBack); |
| assertTrue("unexpected StatusChangeEvent received",event.element is InlineGraphicElement); |
| var image:InlineGraphicElement = InlineGraphicElement(event.element); |
| |
| switch (event.status) |
| { |
| case InlineGraphicElementStatus.LOADING: |
| case InlineGraphicElementStatus.SIZE_PENDING: |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(proportionalFixedWidth,2500,null),false,0,true); |
| break; |
| case InlineGraphicElementStatus.READY: |
| var effWidth:Number = image.actualWidth as Number; |
| var effHeight:Number = image.actualHeight as Number; |
| |
| var nomWidth:Number = image.measuredWidth as Number; |
| var nomHeight:Number = image.measuredHeight as Number; |
| |
| assertTrue( |
| "Ratio of width to height is not correct!", |
| nomWidth/effWidth == nomHeight/effHeight |
| ); |
| SelManager.textFlow.addEventListener(UpdateCompleteEvent.UPDATE_COMPLETE,addAsync(updateCompletionHandler,2500,null),false,0,true); |
| break; |
| default: |
| assertTrue("unexpected StatusChangeEvent status: "+event.status,false); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Size the FE at 50 height, then verify that the width is set proportionally. |
| */ |
| public function proportionalFixedHeight(callBack:Object = null):void |
| { |
| if(!callback) |
| { |
| callback = true; |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(proportionalFixedHeight,2500,null),false,0,true); |
| |
| var startIndx:int = SelManager.textFlow.textLength/2; |
| var endIndx:int = startIndx; |
| |
| var src:String = data[data.length-1].toString(); |
| |
| var width:String = "auto"; |
| var height:String = "50"; |
| |
| SelManager.selectRange(startIndx, endIndx); |
| SelManager.insertInlineGraphic(LoaderUtil.createAbsoluteURL(baseImageURL,src),width,height); |
| } |
| else |
| { |
| assertTrue("unexected event",callBack is StatusChangeEvent); |
| var event:StatusChangeEvent = StatusChangeEvent(callBack); |
| assertTrue("unexpected StatusChangeEvent received",event.element is InlineGraphicElement); |
| var image:InlineGraphicElement = InlineGraphicElement(event.element); |
| switch (event.status) |
| { |
| case InlineGraphicElementStatus.LOADING: |
| case InlineGraphicElementStatus.SIZE_PENDING: |
| SelManager.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(proportionalFixedHeight,2500,null),false,0,true); |
| break; |
| case InlineGraphicElementStatus.READY: |
| var effWidth:Number = image.actualWidth as Number; |
| var effHeight:Number = image.actualHeight as Number; |
| |
| var nomWidth:Number = image.measuredWidth as Number; |
| var nomHeight:Number = image.measuredHeight as Number; |
| |
| assertTrue( |
| "Ratio of width to height is not correct!", |
| nomWidth/effWidth == nomHeight/effHeight |
| ); |
| SelManager.textFlow.addEventListener(UpdateCompleteEvent.UPDATE_COMPLETE,addAsync(updateCompletionHandler,2500,null),false,0,true); |
| break; |
| default: |
| assertTrue("unexpected StatusChangeEvent status: "+event.status,false); |
| break; |
| } |
| } |
| } |
| |
| private function graphicStatusChangeEvent(e:StatusChangeEvent):void |
| { |
| try |
| { |
| if (e.status == InlineGraphicElementStatus.READY) |
| { |
| e.element.getTextFlow().flowComposer.updateAllControllers(); |
| } |
| } |
| catch ( re:RangeError ) |
| { |
| TestFrame.textFlow.removeEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,graphicStatusChangeEvent); |
| TestFrame.textFlow.dispatchEvent(new Event(Event.SOUND_COMPLETE)); |
| return; |
| } |
| } |
| |
| private function nullFunction( param:Object = null ):void { return; } |
| private function failEvent(e:Event):void { fail( "InlineGraphics not correcty updating - See Watson #2298043" ); } |
| |
| private function rect(color:int):Sprite |
| { |
| var sp:Sprite = new Sprite(); |
| sp.graphics.beginFill(color); |
| sp.graphics.drawRect(0,0,200, 5); |
| sp.graphics.endFill(); |
| sp.width = 200; |
| sp.height = 5; |
| return sp; |
| } |
| |
| // Test for Watson #2298043 |
| public function statusChangedEventTest():void |
| { |
| TestFrame.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE, graphicStatusChangeEvent); |
| |
| TestFrame.textFlow.addEventListener(Event.SOUND_COMPLETE, addAsync(failEvent,2500, null, nullFunction)); |
| |
| SelManager.selectAll(); |
| SelManager.deleteText(); |
| |
| var p:ParagraphElement = new ParagraphElement(); |
| TestFrame.textFlow.addChild(p); |
| |
| var inlineGraphic:InlineGraphicElement = new InlineGraphicElement(); |
| inlineGraphic.source = "http://www.adobe.com/shockwave/download/images/flashplayer_100x100.jpg"; |
| p.addChild(inlineGraphic); |
| |
| var inlineGraphicElement:InlineGraphicElement = new InlineGraphicElement(); |
| var sprite:Sprite = rect(0xff0000); |
| inlineGraphicElement.width = sprite.width+10; |
| inlineGraphicElement.height = sprite.height+10; |
| inlineGraphicElement.source = sprite; |
| p.addChild(inlineGraphicElement); |
| |
| var p2:ParagraphElement = new ParagraphElement(); |
| var sp:SpanElement = new SpanElement(); |
| sp.text = "xyz"; |
| inlineGraphicElement = new InlineGraphicElement(); |
| sprite = rect(0x0000ff); |
| inlineGraphicElement.width = sprite.width+9; |
| inlineGraphicElement.height = sprite.height+9; |
| inlineGraphicElement.source = sprite; |
| p2.addChild(inlineGraphicElement); |
| p2.addChild(sp); |
| TestFrame.textFlow.addChild(p2); |
| |
| SelManager.selectAll(); |
| |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| } |
| |
| // Test for Watson #2374243 |
| public function nullSourceExplicitWHTest():void |
| { |
| var p:ParagraphElement = new ParagraphElement(); |
| TestFrame.textFlow.addChild(p); |
| |
| var span:SpanElement = new SpanElement(); |
| span.text = "BEFORE"; |
| p.addChild(span); |
| |
| var inlineGraphic:InlineGraphicElement = new InlineGraphicElement(); |
| inlineGraphic.height = 48; |
| inlineGraphic.width = 48; |
| p.addChild(inlineGraphic); |
| |
| span = new SpanElement(); |
| span.text = "AFTER"; |
| p.addChild(span); |
| |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| } |
| |
| // Watson # 2695825, Copying and pasting the first character in a text block results in a carriage return at the beginning. |
| public function copyFirstCharacterTest():void |
| { |
| // create a paragraph |
| SelManager.selectAll(); |
| SelManager.deleteText(); |
| SelManager.insertText("AAAAAAAA"); |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| //select first character |
| SelManager.selectRange(0, 1); |
| var copy:TextScrap = TextScrap.createTextScrap(SelManager.getSelectionState()); |
| //paste to 3rd position |
| SelManager.selectRange(3, 3 ); |
| SelManager.pasteTextScrap(copy); |
| TestFrame.textFlow.flowComposer.updateAllControllers(); |
| |
| //check if there is second paragraph after paste |
| var elem:FlowLeafElement = SelManager.textFlow.getFirstLeaf(); |
| var para:ParagraphElement = elem.getParagraph(); |
| para = para.getNextParagraph(); |
| assertTrue ("there should be only one paragraph after paste.", para ==null); |
| } |
| |
| // Watson 2724144, inline graphic is visible only if the TextLine it is on is visible |
| public function inlineIsVisible():void |
| { |
| var textFlow:TextFlow = SelManager.textFlow; |
| var controller:ContainerController = textFlow.flowComposer.getControllerAt(0); |
| controller.columnCount = 1; |
| controller.verticalScrollPolicy = ScrollPolicy.ON; |
| controller.horizontalScrollPolicy = ScrollPolicy.ON; |
| |
| SelManager.selectAll(); |
| var scrap:TextScrap = TextScrap.createTextScrap(SelManager.getSelectionState()); |
| SelManager.selectRange(textFlow.textLength - 1, textFlow.textLength - 1); |
| SelManager.pasteTextScrap(scrap); |
| SelManager.selectRange(textFlow.textLength - 1, textFlow.textLength - 1); |
| SelManager.pasteTextScrap(scrap); |
| var thirdPara:FlowElement = SelManager.textFlow.getChildAt(2) as FlowElement; |
| var pos:int = thirdPara.getAbsoluteStart(); |
| SelManager.selectRange(pos, pos); |
| SelManager.insertInlineGraphic(createFilledSprite(15, 15, 0x00ff00), 15, 15, Float.NONE); |
| var s:Sprite = createFilledSprite(50, 400, 0xff0000); |
| SelManager.insertInlineGraphic(s, 50, 400); |
| SelManager.selectRange(0, 0); |
| SelManager.updateAllControllers(); |
| assertTrue("Expected inline to be visible even if its line is scrolled down", s.stage == TestFrame.container.stage); |
| |
| } |
| |
| // Test that the controller's protected methods for adding and removing graphic elements are being called. |
| public function addRemoveInlineGraphicElement():void |
| { |
| var textFlow:TextFlow = SelManager.textFlow; |
| var flowComposer:IFlowComposer = textFlow.flowComposer; |
| var oldController:ContainerController = flowComposer.getControllerAt(0); |
| flowComposer.removeAllControllers(); |
| var controller:TestContainerController = new TestContainerController(oldController.container); |
| flowComposer.addController(controller); |
| flowComposer.updateAllControllers(); |
| assertTrue("No inlines yet", controller.inlineCount == 0); |
| var s:Sprite = createFilledSprite(50, 400, 0xff0000); |
| SelManager.selectRange(0, 0); |
| SelManager.allowDelayedOperations = false; |
| SelManager.insertInlineGraphic(createFilledSprite(15, 15, 0x00ff00), 15, 15, Float.NONE); |
| assertTrue("Inline added", controller.inlineCount == 1); |
| SelManager.selectRange(0, 1); |
| SelManager.deleteText(); |
| assertTrue("Inline removed", controller.inlineCount == 0); |
| } |
| |
| //test for Bug # 2563434 - Importers resolve relative image paths from the swf, not the HTML file |
| public function imgSourceFilterFunctionTest(callback:Object = null):void |
| { |
| var tf:TextFlow; |
| |
| if(!callback) |
| { |
| callback = true; |
| tf = SelManager.textFlow; |
| tf.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(imgSourceFilterFunctionTest,2500,null),false,0,true); |
| var textImporter:ITextImporter; |
| |
| SelManager.selectAll(); |
| SelManager.deleteText(); |
| SelManager.insertText("AAAAAAA"); |
| SelManager.textFlow.flowComposer.updateAllControllers(); |
| |
| //get relative path for img |
| var replacedSource:String = LoaderUtil.createAbsoluteURL(baseURL, "../../test/testFiles/assets/"); |
| |
| textImporter = TextConverter.getImporter(TextConverter.TEXT_LAYOUT_FORMAT); |
| (textImporter as ITextLayoutImporter).imageSourceResolveFunction = function (source:String):String { replacedSource += source; return replacedSource; }; |
| textImporter.importToFlow("<TextFlow xmlns='http://ns.adobe.com/textLayout/2008'><img source='smiley.gif'/></TextFlow>"); |
| |
| SelManager.selectRange(2,2); |
| //insert inline graphic |
| SelManager.insertInlineGraphic( replacedSource, 100, 100 ); |
| SelManager.textFlow.flowComposer.updateAllControllers(); |
| } |
| else // Make sure the image is ready before we let the snapshot go |
| { |
| var img:InlineGraphicElement = callback.element; |
| tf = img.getTextFlow(); |
| if(img.status != InlineGraphicElementStatus.READY) |
| { |
| tf.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE,addAsync(imgSourceFilterFunctionTest,2500,null),false,0,true); |
| } |
| } |
| } |
| |
| public function imgSourceSecurityError():void |
| { |
| var tf:TextFlow = SelManager.textFlow; |
| SelManager.selectRange(0,0); |
| // don't need all the data after base64, - this throws in player and TLF needs to catchit |
| SelManager.insertInlineGraphic("data:image/jpg;base64,/9j",100,100); |
| } |
| } |
| } |
| |
| import flash.display.DisplayObject; |
| import flash.display.DisplayObjectContainer; |
| import flash.display.Sprite; |
| |
| import flashx.textLayout.container.ContainerController; |
| |
| class TestContainerController extends ContainerController |
| { |
| public var inlineCount:int; |
| |
| public function TestContainerController(container:Sprite,compositionWidth:Number=100,compositionHeight:Number=100) |
| { |
| super(container, compositionWidth, compositionHeight); |
| inlineCount = 0; |
| } |
| |
| override protected function addInlineGraphicElement(parent:DisplayObjectContainer, inlineGraphicElement:DisplayObject, index:int):void |
| { |
| super.addInlineGraphicElement(parent, inlineGraphicElement, index); |
| ++inlineCount; |
| } |
| |
| override protected function removeInlineGraphicElement(parent:DisplayObjectContainer, inlineGraphicElement:DisplayObject):void |
| { |
| super.removeInlineGraphicElement(parent, inlineGraphicElement); |
| --inlineCount; |
| } |
| } |
