| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // 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.TestSuiteExtended; |
| import UnitTest.ExtendedClasses.VellumTestCase; |
| import UnitTest.Fixtures.TestConfig; |
| |
| import flash.text.FontStyle; |
| |
| import flashx.textLayout.elements.ParagraphElement; |
| import flashx.textLayout.elements.SpanElement; |
| import flashx.textLayout.formats.TextAlign; |
| import flashx.textLayout.formats.TextLayoutFormat; |
| |
| import org.flexunit.asserts.assertTrue; |
| |
| public class StyleTest extends VellumTestCase |
| { |
| private var formatResolver:TestFormatResolver; |
| |
| public function StyleTest(methodName:String, testID:String, testConfig:TestConfig, testCaseXML:XML=null) |
| { |
| super(methodName, testID, testConfig, testCaseXML); |
| |
| // Note: These must correspond to a Watson product area (case-sensitive) |
| metaData.productArea = "Text Attributes"; |
| metaData.productSubArea = "CSS - Styling"; |
| } |
| |
| public static function suiteFromXML(testListXML:XML, testConfig:TestConfig, ts:TestSuiteExtended):void |
| { |
| var testCaseClass:Class = StyleTest; |
| VellumTestCase.suiteFromXML(testCaseClass, testListXML, testConfig, ts); |
| } |
| |
| public override function setUpTest():void |
| { |
| super.setUpTest(); |
| |
| formatResolver = new TestFormatResolver(); |
| TestFrame.textFlow.formatResolver = formatResolver; |
| } |
| |
| public override function tearDownTest():void |
| { |
| TestFrame.textFlow.formatResolver = null; |
| |
| super.tearDownTest(); |
| } |
| |
| public function basicStyleTest():void |
| { |
| // Set up style resolver |
| var testFormat:TextLayoutFormat = new TextLayoutFormat(); |
| testFormat.textAlign = TextAlign.CENTER; |
| formatResolver.addStyle( "flowStyle", testFormat, TestFormatResolver.NAME_STYLE ); |
| |
| // Assign style and check for result |
| TestFrame.textFlow.getChildAt(0).styleName = "flowStyle"; |
| TestFrame.flowComposer.updateAllControllers(); |
| |
| var testPara:ParagraphElement = TestFrame.textFlow.getChildAt(0) as ParagraphElement; |
| assertTrue( "Format 'flowStyle' was not applied to the first paragraph", |
| testPara.computedFormat.textAlign == TextAlign.CENTER ); |
| } |
| |
| public function styleNameInheritTest():void |
| { |
| // Set up style resolver |
| var testFormat:TextLayoutFormat = new TextLayoutFormat(); |
| testFormat.fontStyle = FontStyle.ITALIC; |
| formatResolver.addStyle( "fontStyle", testFormat, TestFormatResolver.NAME_STYLE ); |
| |
| // Assign style and check for result |
| TestFrame.textFlow.getChildAt(0).styleName = "fontStyle"; |
| TestFrame.flowComposer.updateAllControllers(); |
| |
| var testSpan:SpanElement = (TestFrame.textFlow.getChildAt(0) as ParagraphElement).getChildAt(0) as SpanElement; |
| assertTrue( "Format 'fontStyle' was not inherited by the first span", |
| testSpan.computedFormat.fontStyle == FontStyle.ITALIC ); |
| } |
| |
| public function styleInvalidateTest():void |
| { |
| // Set up style resolver |
| var testFormat:TextLayoutFormat = new TextLayoutFormat(); |
| testFormat.textAlign = TextAlign.CENTER; |
| formatResolver.addStyle( "flowStyle", testFormat, TestFormatResolver.NAME_STYLE ); |
| |
| // Assign style and check for result |
| TestFrame.textFlow.getChildAt(0).styleName = "flowStyle"; |
| TestFrame.flowComposer.updateAllControllers(); |
| |
| var testPara:ParagraphElement = TestFrame.textFlow.getChildAt(0) as ParagraphElement; |
| assertTrue( "Format 'flowStyle' was not applied to the first paragraph", |
| testPara.computedFormat.textAlign == TextAlign.CENTER ); |
| |
| testPara.styleName = "otherStyle"; |
| |
| assertTrue( "Format 'flowStyle' was still applied after being invalidated", |
| testPara.computedFormat.textAlign != TextAlign.CENTER ); |
| } |
| |
| public function styleInvalidateAllTest():void |
| { |
| // Set up style resolver |
| var testFormat:TextLayoutFormat = new TextLayoutFormat(); |
| testFormat.textAlign = TextAlign.CENTER; |
| formatResolver.addStyle( "flowStyle", testFormat, TestFormatResolver.NAME_STYLE ); |
| |
| // Assign style and check for result |
| TestFrame.textFlow.getChildAt(0).styleName = "flowStyle"; |
| TestFrame.flowComposer.updateAllControllers(); |
| |
| var testPara:ParagraphElement = TestFrame.textFlow.getChildAt(0) as ParagraphElement; |
| assertTrue( "Format 'flowStyle' was not applied to the first paragraph", |
| testPara.computedFormat.textAlign == TextAlign.CENTER ); |
| |
| testFormat.textAlign = TextAlign.RIGHT; |
| assertTrue( "Format 'flowStyle' updated without being invalidated", |
| testPara.computedFormat.textAlign != TextAlign.RIGHT ); |
| |
| TestFrame.textFlow.invalidateAllFormats(); |
| assertTrue( "Format 'flowStyle' was still applied after being invalidated", |
| testPara.computedFormat.textAlign == TextAlign.RIGHT ); |
| } |
| |
| public function basicIdTest():void |
| { |
| // Set up resolver |
| var testFormat:TextLayoutFormat = new TextLayoutFormat(); |
| testFormat.textAlign = TextAlign.CENTER; |
| formatResolver.addStyle( "flowid", testFormat, TestFormatResolver.ID_STYLE); |
| |
| // Assign id and check for result |
| TestFrame.textFlow.getChildAt(0).id = "flowid"; |
| TestFrame.flowComposer.updateAllControllers(); |
| |
| var testPara:ParagraphElement = TestFrame.textFlow.getChildAt(0) as ParagraphElement; |
| assertTrue( "Format 'flowid' was not applied to the first paragraph", |
| testPara.computedFormat.textAlign == TextAlign.CENTER ); |
| } |
| |
| public function idInheritTest():void |
| { |
| // Set up resolver |
| var testFormat:TextLayoutFormat = new TextLayoutFormat(); |
| testFormat.fontStyle = FontStyle.ITALIC; |
| formatResolver.addStyle( "FontStyle", testFormat, TestFormatResolver.ID_STYLE ); |
| |
| // Assign id and check for result |
| TestFrame.textFlow.getChildAt(0).id = "FontStyle"; |
| TestFrame.flowComposer.updateAllControllers(); |
| |
| var testSpan:SpanElement = (TestFrame.textFlow.getChildAt(0) as ParagraphElement).getChildAt(0) as SpanElement; |
| assertTrue( "Format 'FontStyle' was not inherited by the first span", |
| testSpan.computedFormat.fontStyle == FontStyle.ITALIC ); |
| } |
| |
| public function idInvalidateTest():void |
| { |
| // Set up resolver |
| var testFormat:TextLayoutFormat = new TextLayoutFormat(); |
| testFormat.textAlign = TextAlign.CENTER; |
| formatResolver.addStyle( "flowid", testFormat, TestFormatResolver.ID_STYLE ); |
| |
| // Assign id and check for result |
| TestFrame.textFlow.getChildAt(0).id = "flowid"; |
| TestFrame.flowComposer.updateAllControllers(); |
| |
| var testPara:ParagraphElement = TestFrame.textFlow.getChildAt(0) as ParagraphElement; |
| assertTrue( "Format 'flowid' was not applied to the first paragraph", |
| testPara.computedFormat.textAlign == TextAlign.CENTER ); |
| |
| testPara.id = "otherid"; |
| |
| assertTrue( "Format 'flowid' was still applied after being invalidated", |
| testPara.computedFormat.textAlign != TextAlign.CENTER ); |
| } |
| |
| public function idInvalidateAllTest():void |
| { |
| // Set up resolver |
| var testFormat:TextLayoutFormat = new TextLayoutFormat(); |
| testFormat.textAlign = TextAlign.CENTER; |
| formatResolver.addStyle( "flowid", testFormat, TestFormatResolver.ID_STYLE ); |
| |
| // Assign id and check for result |
| TestFrame.textFlow.getChildAt(0).id = "flowid"; |
| TestFrame.flowComposer.updateAllControllers(); |
| |
| var testPara:ParagraphElement = TestFrame.textFlow.getChildAt(0) as ParagraphElement; |
| assertTrue( "Format 'flowid' was not applied to the first paragraph", |
| testPara.computedFormat.textAlign == TextAlign.CENTER ); |
| |
| testFormat.textAlign = TextAlign.RIGHT; |
| assertTrue( "Format 'flowid' updated without being invalidated", |
| testPara.computedFormat.textAlign != TextAlign.RIGHT ); |
| |
| TestFrame.textFlow.invalidateAllFormats(); |
| assertTrue( "Format 'flowid' was still applied after being invalidated", |
| testPara.computedFormat.textAlign == TextAlign.RIGHT ); |
| } |
| |
| public function basicUserStyleTest():void |
| { |
| var formatObject:Object = new Object(); |
| var styleObject:Object = new Object(); |
| |
| formatResolver.addStyle( "myStyle", formatObject, TestFormatResolver.USER_STYLE ); |
| assertTrue( "UserStyle failed to return correct format object", |
| TestFrame.textFlow.getStyle( "myStyle" ) == formatObject ); |
| |
| TestFrame.textFlow.setStyle( "myStyle", styleObject ); |
| assertTrue( "UserStyle failed to return correct format object", |
| TestFrame.textFlow.getStyle( "myStyle" ) == styleObject ); |
| } |
| } |
| } |
| |
| import flashx.textLayout.elements.IFormatResolver; |
| import flashx.textLayout.elements.FlowElement; |
| import flashx.textLayout.elements.FlowGroupElement; |
| |
| import flashx.textLayout.formats.TextLayoutFormat; |
| import flashx.textLayout.formats.ITextLayoutFormat; |
| |
| import flash.utils.Dictionary; |
| import flashx.textLayout.elements.TextFlow; |
| |
| class TestFormatResolver implements IFormatResolver |
| { |
| private var _styleCache:Dictionary; |
| private var _nameStyles:Dictionary; |
| private var _idStyles:Dictionary; |
| |
| private var _userStyles:Dictionary; |
| private var _userCache:Dictionary; |
| public var userStyleReference:Dictionary; |
| |
| public static const ID_STYLE:String = "id"; |
| public static const NAME_STYLE:String = "class"; |
| public static const USER_STYLE:String = "user"; |
| |
| public var getResolverCalled:Boolean = false; |
| public var lastOldFlow:TextFlow; |
| public var lastNewFlow:TextFlow; |
| |
| public function TestFormatResolver() |
| { |
| _styleCache = new Dictionary(); |
| _nameStyles = new Dictionary(); |
| _idStyles = new Dictionary(); |
| |
| _userStyles = new Dictionary(); |
| _userCache = new Dictionary(); |
| userStyleReference = new Dictionary(); |
| } |
| |
| /** Adds a new style to the resolver. The resolve methods will return styleValue for styleName |
| * styleType can be one of TestFormatResolver.ID_STYLE, TestFormatResolver.NAME_STYLE, or |
| * TestFormatResolver.USER_STYLE */ |
| public function addStyle( styleName:String, styleValue:Object, styleType:String ):void |
| { |
| if ( styleType == TestFormatResolver.ID_STYLE ) |
| { |
| _idStyles[styleName] = styleValue; |
| } |
| else if ( styleType == TestFormatResolver.NAME_STYLE ) |
| { |
| _nameStyles[styleName] = styleValue; |
| } |
| else if ( styleType == USER_STYLE ) |
| { |
| _userStyles[styleName] = styleValue; |
| } |
| else throw new Error( "TEST ERROR: TestStyleResolver.addStyle() called with unknown styleType" ); |
| |
| invalidateAll(null); |
| } |
| |
| public function resolveFormat(elem:Object):ITextLayoutFormat |
| { |
| // Add to the cache if it's not already there |
| if ( !_styleCache[elem] ) |
| { |
| _styleCache[elem] = new TextLayoutFormat(); |
| |
| // If we have an ContainerController, give up |
| if ( !(elem is FlowElement) ) |
| { |
| return undefined; |
| } |
| |
| if ( _nameStyles[elem.styleName] ) |
| { |
| _styleCache[elem].concat( _nameStyles[elem.styleName] ); |
| } |
| |
| if ( _idStyles[elem.id] ) |
| { |
| _styleCache[elem].concat( _idStyles[elem.id] ); |
| } |
| } |
| |
| return _styleCache[elem]; |
| } |
| |
| /** any cached styling information is now invalid and need recomputing */ |
| public function invalidateAll(tf:TextFlow):void |
| { |
| _styleCache = new Dictionary(); |
| _userCache = new Dictionary(); |
| } |
| |
| /** cached information on this element is now invalid (e.g. parent changed, id changed, styleName changed) */ |
| public function invalidate(target:Object):void |
| { |
| delete _styleCache[target]; |
| |
| var blockElem:FlowGroupElement = target as FlowGroupElement; |
| if (blockElem) |
| { |
| for (var idx:int = 0; idx < blockElem.numChildren; idx++) |
| invalidate(blockElem.getChildAt(idx)); |
| } |
| } |
| |
| /** Given a FlowElement or ContainerController and the name of a style property return a style value or undefined*/ |
| public function resolveUserFormat(elem:Object,userStyle:String):* |
| { |
| if ( _userCache[userStyle] ) |
| return _userCache[userStyle]; |
| else if ( !_userStyles[userStyle] ) |
| return undefined; |
| else |
| _userCache[userStyle] = _userStyles[userStyle]; |
| |
| return _userCache[userStyle]; |
| } |
| |
| /** Called when the owning TextFlow is copied. One TestStyleResolver is used for all instances. */ |
| public function getResolverForNewFlow(oldFlow:TextFlow,newFlow:TextFlow):IFormatResolver |
| { |
| getResolverCalled = true; |
| lastOldFlow = oldFlow; |
| lastNewFlow = newFlow; |
| |
| return this; |
| } |
| } |