| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // 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 spark.transitions |
| { |
| |
| import flash.display.DisplayObject; |
| import flash.events.Event; |
| import flash.geom.Point; |
| import flash.geom.Rectangle; |
| |
| import mx.core.IVisualElement; |
| import mx.core.mx_internal; |
| import mx.effects.IEffect; |
| |
| import spark.components.ActionBar; |
| import spark.components.Group; |
| import spark.components.TabbedViewNavigator; |
| import spark.components.ViewNavigator; |
| import spark.components.supportClasses.ButtonBarBase; |
| import spark.components.supportClasses.ViewNavigatorBase; |
| import spark.effects.Animate; |
| import spark.effects.Move; |
| import spark.effects.animation.MotionPath; |
| import spark.effects.animation.SimpleMotionPath; |
| import spark.primitives.BitmapImage; |
| |
| use namespace mx_internal; |
| |
| /** |
| * The SlideViewTransition class performs a simple slide transition for views. |
| * The existing view slides out as the new view slides in. |
| * The slide transition supports several modes (push, cover, and |
| * uncover) as well as an optional direction (up, down, left, or right). |
| * |
| * <p><strong>Note:</strong>Create and configure view transitions in ActionScript; |
| * you cannot create them in MXML.</p> |
| * |
| * @see SlideViewTransitionMode |
| * @see ViewTransitionDirection |
| * |
| * @langversion 3.0 |
| * @playerversion AIR 2.5 |
| * @productversion Flex 4.5 |
| */ |
| public class SlideViewTransition extends ViewTransitionBase |
| { |
| //-------------------------------------------------------------------------- |
| // |
| // Constructor |
| // |
| //-------------------------------------------------------------------------- |
| |
| /** |
| * Constructor. |
| * |
| * @langversion 3.0 |
| * @playerversion AIR 2.5 |
| * @productversion Flex 4.5 |
| */ |
| public function SlideViewTransition() |
| { |
| super(); |
| |
| // Defaut duration of 300 yields a smooth result. |
| duration = 300; |
| } |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Variables |
| // |
| //-------------------------------------------------------------------------- |
| |
| /** |
| * @private |
| * Flag used to indicate whether the tab bar should animate in or out. |
| */ |
| private var animateTabBar:Boolean = false; |
| |
| /** |
| * @private |
| * Bitmap image of the action bar before it is updated with the properties |
| * of the new view. This snapshot is leveraged by this transition when |
| * doing a full screen animation. |
| */ |
| private var cachedActionBar:BitmapImage; |
| |
| /** |
| * @private |
| * Stores the location of the action bar in the global coordinate space |
| * so that the transition can properly position the cached actionbar |
| * when added to the display list. |
| */ |
| private var cachedActionBarGlobalPosition:Point = new Point(); |
| |
| /** |
| * @private |
| * Variable used to store the startView's initial global position to |
| * determine how much it needs to be shifted before a consolidated |
| * transition runs. |
| */ |
| private var cachedStartViewGlobalPosition:Point; |
| |
| /** |
| * @private |
| * Bitmap image of the tab bar before it is updated with the properties |
| * of the new view. This snapshot is leveraged by this transition when |
| * doing a full screen animation. |
| */ |
| private var cachedTabBar:BitmapImage; |
| |
| /** |
| * @private |
| * Stores the location of the action bar in the global coordinate space |
| * so that the transition can properly position the cached actionbar |
| * when added to the display list. |
| */ |
| private var cachedTabBarGlobalPosition:Point = new Point(); |
| |
| /** |
| * @private |
| * Property bag used to save any start view properties that |
| * are then restored after the transition is complete. |
| */ |
| private var startViewProps:Object; |
| |
| /** |
| * @private |
| * Property bag used to save any end view properties that |
| * are then restored after the transition is complete. |
| */ |
| private var endViewProps:Object; |
| |
| /** |
| * @private |
| * Property bag used to save any navigator centric properties that |
| * are then restored after the transition is complete. |
| */ |
| private var navigatorProps:Object; |
| |
| /** |
| * @private |
| */ |
| private var transitionGroup:Group; |
| |
| /** |
| * @private |
| * Indicates whether the end view needs explicit validations during the |
| * transition, which will be the case when the view is in advanced |
| * layout mode. |
| */ |
| private var endViewNeedsValidations:Boolean; |
| |
| /** |
| * @private |
| * Indicates whether the start view needs explicit validations during the |
| * transition, which will be the case when the view is in advanced |
| * layout mode. |
| */ |
| private var startViewNeedsValidations:Boolean; |
| |
| /** |
| * @private |
| */ |
| private var moveEffect:Move; |
| |
| /** |
| * @private |
| */ |
| private var consolidatedEffect:Animate; |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Properties |
| // |
| //-------------------------------------------------------------------------- |
| |
| //--------------------------------- |
| // direction |
| //--------------------------------- |
| |
| private var _direction:String = ViewTransitionDirection.LEFT; |
| |
| [Inspectable(category="General", enumeration="left,right,up,down", defaultValue="left")] |
| /** |
| * Specifies the direction of slide transition. |
| * |
| * @default ViewTransitionDirection.LEFT |
| * |
| * @langversion 3.0 |
| * @playerversion AIR 2.5 |
| * @productversion Flex 4.5 |
| */ |
| public function get direction():String |
| { |
| return _direction; |
| } |
| |
| /** |
| * @private |
| */ |
| public function set direction(value:String):void |
| { |
| _direction = value; |
| } |
| |
| //--------------------------------- |
| // mode |
| //--------------------------------- |
| |
| private var _mode:String = SlideViewTransitionMode.PUSH; |
| |
| [Inspectable(category="General", enumeration="push,cover,uncover", defaultValue="push")] |
| /** |
| * Specifies the type of slide transition to perform. |
| * |
| * @default SlideViewTransitionMode.PUSH |
| * |
| * @langversion 3.0 |
| * @playerversion AIR 2.5 |
| * @productversion Flex 4.5 |
| */ |
| public function get mode():String |
| { |
| return _mode; |
| } |
| |
| /** |
| * @private |
| */ |
| public function set mode(value:String):void |
| { |
| _mode = value; |
| } |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Methods |
| // |
| //-------------------------------------------------------------------------- |
| |
| override mx_internal function preInit():void |
| { |
| if (mode == SlideViewTransitionMode.UNCOVER) |
| setComponentChildIndex(endView, navigator, 0); |
| } |
| |
| /** |
| * @private |
| * |
| * @langversion 3.0 |
| * @playerversion AIR 2.5 |
| * @productversion Flex 4.5 |
| */ |
| override public function captureStartValues():void |
| { |
| var p:Point; |
| |
| super.captureStartValues(); |
| |
| // Initialize the property bag used to save some of our |
| // properties that are then restored after the transition is over. |
| navigatorProps = {}; |
| navigatorProps.initialHeight = navigator.height; |
| |
| // Determine if we will be animating the tabBar as part of the |
| // transition |
| animateTabBar = false; |
| |
| if (tabBar && startView) |
| { |
| // Animate the tabBar if its overlayControls or visible property is toggled. |
| animateTabBar = startView.overlayControls != endView.overlayControls || |
| startView.tabBarVisible != endView.tabBarVisible; |
| } |
| |
| // Generate initial bitmaps for the transition. If the transition will be |
| // a push type, we only need to cache the actionBar as we will animate the |
| // views in manually. If its cover or uncover, an entire image of the navigator |
| // is needed. |
| if (mode != SlideViewTransitionMode.PUSH) |
| { |
| var oldVisibility:Boolean = endView.visible; |
| endView.visible = false; |
| |
| if (tabBar && !animateTabBar) |
| cachedNavigator = getSnapshot(targetNavigator.contentGroup, 0, cachedNavigatorGlobalPosition); |
| else |
| cachedNavigator = getSnapshot(targetNavigator, 0, cachedNavigatorGlobalPosition); |
| |
| endView.visible = oldVisibility; |
| } |
| else |
| { |
| cachedActionBar = getSnapshot(navigator.actionBar, 4, cachedActionBarGlobalPosition); |
| } |
| |
| // If the tabBar exists, a bitmap image of it is created |
| if (tabBar) |
| { |
| cachedTabBar = getSnapshot(TabbedViewNavigator(parentNavigator).tabBar, 4, cachedTabBarGlobalPosition); |
| navigatorProps.tabBarIncludeInLayout = tabBar.includeInLayout; |
| navigatorProps.tabBarCacheAsBitmap = tabBar.cacheAsBitmap; |
| } |
| |
| if (startView) |
| { |
| startViewProps = { includeInLayout: startView.includeInLayout, |
| visible: startView.visible, |
| cacheAsBitmap: startView.cacheAsBitmap, |
| opaqueBackground: startView.opaqueBackground }; |
| |
| // Remove the startView from layout so that it doesn't resize as the |
| // contentGroups of each navigator is resized |
| startView.includeInLayout = false; |
| cachedStartViewGlobalPosition = getTargetNavigatorCoordinates(startView); |
| } |
| } |
| |
| /** |
| * @private |
| * |
| * @langversion 3.0 |
| * @playerversion AIR 2.5 |
| * @productversion Flex 4.5 |
| */ |
| override protected function createViewEffect():IEffect |
| { |
| // Prepare our start and end views by positioning them prior to |
| // the start of our transition, ensuring that they are cached as |
| // surfaces, and adjust z-order if necessary. |
| |
| var slideTargets:Array = []; |
| |
| endViewNeedsValidations = false; |
| startViewNeedsValidations = false; |
| |
| if (startView) |
| { |
| // Store the original x and y position of the view so that we can restore |
| // it after the animation |
| startViewProps.x = startView.x, |
| startViewProps.y = startView.y; |
| |
| startView.cacheAsBitmap = true; |
| |
| // If the startView has an opaque background color, set that as the |
| // opaqueBackground property to improve performance. |
| if (startView.getStyle("backgroundAlpha") >= 1) |
| startView.opaqueBackground = startView.getStyle("backgroundColor"); |
| |
| if (startView.contentGroup) |
| { |
| startViewProps.cgIncludeInLayout = startView.contentGroup.includeInLayout; |
| startView.contentGroup.includeInLayout = false; |
| } |
| |
| if (mode != SlideViewTransitionMode.COVER) |
| { |
| if (startView.transformRequiresValidations()) |
| startViewNeedsValidations = true; |
| slideTargets.push(startView); |
| } |
| } |
| |
| if (endView) |
| { |
| endViewProps = { cacheAsBitmap:endView.cacheAsBitmap, |
| opaqueBackground:endView.opaqueBackground}; |
| |
| endView.cacheAsBitmap = true; |
| |
| // If the endView has an opaque background color, set that as the |
| // opaqueBackground property to improve performance. |
| if (endView.getStyle("backgroundAlpha") >= 1) |
| endView.opaqueBackground = endView.getStyle("backgroundColor"); |
| |
| if (endView.contentGroup) |
| { |
| endViewProps.cgIncludeInLayout = endView.contentGroup.includeInLayout; |
| endView.contentGroup.includeInLayout = false; |
| } |
| |
| if (mode != SlideViewTransitionMode.UNCOVER) |
| { |
| if (endView.transformRequiresValidations()) |
| endViewNeedsValidations = true; |
| slideTargets.push(endView); |
| } |
| |
| // if (mode == SlideViewTransitionMode.UNCOVER) |
| // setComponentChildIndex(endView, navigator, 0); |
| } |
| |
| var slideDistance:Number; |
| var slideOffset:Number = 0; |
| var animatedProperty:String; |
| var verticalTransition:Boolean; |
| |
| // Predetermine slide direction and distance. |
| switch (direction) |
| { |
| case ViewTransitionDirection.DOWN: |
| animatedProperty = "$y"; |
| slideDistance = navigator.height; |
| slideOffset = -navigator.contentGroup[animatedProperty]; |
| verticalTransition = true; |
| break; |
| |
| case ViewTransitionDirection.UP: |
| animatedProperty = "$y"; |
| slideDistance = -navigator.height; |
| slideOffset = navigator.contentGroup[animatedProperty]; |
| verticalTransition = true; |
| break; |
| |
| case ViewTransitionDirection.RIGHT: |
| animatedProperty = "$x"; |
| slideDistance = navigator.width; |
| break; |
| |
| case ViewTransitionDirection.LEFT: |
| default: |
| animatedProperty = "$x"; |
| slideDistance = -navigator.width; |
| break; |
| } |
| |
| // Position the end view prior to start of transition. |
| if (mode != SlideViewTransitionMode.UNCOVER) |
| endView[animatedProperty] = -slideDistance - slideOffset; |
| |
| // Construction animation sequence. |
| var animation:Move = new Move(); |
| animation.targets = slideTargets; |
| animation.duration = duration; |
| animation.easer = easer; |
| if (verticalTransition) |
| animation.yBy = slideDistance + slideOffset; |
| else |
| animation.xBy = slideDistance + slideOffset; |
| if (startViewNeedsValidations || endViewNeedsValidations) |
| animation.addEventListener("effectUpdate", effectUpdateHandler); |
| moveEffect = animation; |
| return animation; |
| } |
| |
| private function effectUpdateHandler(e:Event):void |
| { |
| // Note that the calls to validateDisplayList here should |
| // really only result in validateMatrix, which is fairly |
| // lightweight. |
| if (startViewNeedsValidations) |
| startView.validateDisplayList(); |
| if (endViewNeedsValidations) |
| endView.validateDisplayList(); |
| } |
| |
| /** |
| * @private |
| * |
| * @langversion 3.0 |
| * @playerversion AIR 2.5 |
| * @productversion Flex 4.5 |
| */ |
| override protected function createConsolidatedEffect():IEffect |
| { |
| // Prepare our start and end view elements by positioning them prior to |
| // the start of our transition, ensuring that they are cached as |
| // surfaces, and adjust z-order if necessary. |
| var slideTargets:Array = []; |
| |
| endViewNeedsValidations = false; |
| startViewNeedsValidations = false; |
| |
| // Remove the navigator's contentGroup from layout |
| navigatorProps.navigatorContentGroupIncludeInLayout = navigator.contentGroup.includeInLayout; |
| navigator.contentGroup.includeInLayout = false; |
| |
| // Check if the navigator is a child of TabbedViewNavigator, if so |
| // remove the contentGroup from layout. |
| if (tabBar) |
| { |
| navigatorProps.topNavigatorContentGroupIncludeInLayout = targetNavigator.contentGroup.includeInLayout; |
| targetNavigator.contentGroup.includeInLayout = false; |
| } |
| |
| transitionGroup = new Group(); |
| transitionGroup.includeInLayout = false; |
| |
| // Add the necessary views to the slide targets array. When in PUSH mode, |
| // both start and end views are added. |
| if (startView && mode == SlideViewTransitionMode.PUSH) |
| { |
| if (startView.transformRequiresValidations()) |
| startViewNeedsValidations = true; |
| slideTargets.push(startView); |
| } |
| |
| if (mode != SlideViewTransitionMode.UNCOVER) |
| { |
| if (endView.transformRequiresValidations()) |
| endViewNeedsValidations = true; |
| slideTargets.push(endView); |
| } |
| |
| // Ensure the views are in the right stacking order based on our |
| // transition mode (cover vs. uncover for instance). |
| if (mode == SlideViewTransitionMode.COVER) |
| { |
| // When doing a cover animation, the transition group is added to the bottom |
| // of the main navigator's skin with a bitmap image of the previous state. The |
| // end view and ui controls will then animate on top of this image to create |
| // the cover effect. |
| addComponentToContainerAt(transitionGroup, targetNavigator.skin, 0); |
| addCachedElementToGroup(transitionGroup, cachedNavigator, cachedNavigatorGlobalPosition); |
| } |
| else if (mode == SlideViewTransitionMode.UNCOVER) |
| { |
| // When doing an uncover transition, we want the real tabBar to be under the cached |
| // bitmap of the original navigator when the tabBar visibility or overlayControls |
| // mode changes. When the tabBar isn't animating, we want the image to animate |
| // underneath the real tabBar. |
| if (animateTabBar) |
| addComponentToContainer(transitionGroup, targetNavigator.skin); |
| else |
| addComponentToContainer(transitionGroup, navigator.skin); |
| |
| startView.visible = false; |
| } |
| else |
| { |
| // Add the transition group to the top of the skin |
| addComponentToContainer(transitionGroup, targetNavigator.skin); |
| } |
| |
| if (actionBar) |
| { |
| if (mode != SlideViewTransitionMode.UNCOVER) |
| slideTargets.push(actionBar); |
| |
| navigatorProps.actionBarIncludeInLayout = actionBar.includeInLayout; |
| actionBar.includeInLayout = false; |
| |
| navigatorProps.actionBarCacheAsBitmap = actionBar.cacheAsBitmap; |
| actionBar.cacheAsBitmap = true; |
| } |
| |
| if (mode == SlideViewTransitionMode.COVER) |
| { |
| // Hide the start view since we have a cached image of the initial |
| // navigator state. |
| startViewProps = {visible: startView.visible}; |
| startView.visible = false; |
| } |
| else if (startView) |
| { |
| // Store the position of the startView |
| navigatorProps.startViewX = startView.x; |
| navigatorProps.startViewY = startView.y; |
| |
| var globalPoint:Point = getTargetNavigatorCoordinates(startView); |
| |
| var delta:int = globalPoint.x - cachedStartViewGlobalPosition.x; |
| if (delta != 0) |
| startView.x -= delta; |
| |
| delta = globalPoint.y - cachedStartViewGlobalPosition.y; |
| if (delta != 0) |
| startView.y -= delta; |
| |
| navigatorProps.startViewCacheAsBitmap = startView.contentGroup.cacheAsBitmap; |
| startView.contentGroup.cacheAsBitmap = true; |
| } |
| |
| if (endView) |
| { |
| navigatorProps.endViewCacheAsBitmap = endView.contentGroup.cacheAsBitmap; |
| endView.contentGroup.cacheAsBitmap = true; |
| } |
| |
| if (cachedActionBar) |
| { |
| cachedActionBar.includeInLayout = false; |
| addCachedElementToGroup(transitionGroup, cachedActionBar, cachedActionBarGlobalPosition); |
| } |
| |
| if (tabBar) |
| { |
| // Cache the tabBar as bitmap for performance |
| navigatorProps.tabBarCacheAsBitmap = tabBar.cacheAsBitmap; |
| tabBar.cacheAsBitmap = true; |
| |
| if (animateTabBar) |
| { |
| navigatorProps.tabBarIncludeInLayout = tabBar.includeInLayout; |
| tabBar.includeInLayout = false; |
| |
| if (mode != SlideViewTransitionMode.UNCOVER) |
| { |
| slideTargets.push(tabBar); |
| |
| // When Uncovering, the cachedTabBar is not needed because the transition |
| // animates a cachedBitamp |
| if (cachedTabBar) |
| { |
| cachedTabBar.includeInLayout = false; |
| addCachedElementToGroup(transitionGroup, cachedTabBar, cachedTabBarGlobalPosition); |
| } |
| } |
| } |
| } |
| |
| var slideDistance:Number; |
| var animatedProperty:String; |
| var verticalTransition:Boolean; |
| |
| // Predetermine slide direction and distance. |
| switch (direction) |
| { |
| case ViewTransitionDirection.RIGHT: |
| animatedProperty = "x"; |
| slideDistance = targetNavigator.width; |
| break; |
| |
| case ViewTransitionDirection.DOWN: |
| animatedProperty = "y"; |
| slideDistance = targetNavigator.height; |
| verticalTransition = true; |
| break; |
| |
| case ViewTransitionDirection.UP: |
| animatedProperty = "y"; |
| slideDistance = -targetNavigator.height; |
| verticalTransition = true; |
| break; |
| |
| case ViewTransitionDirection.LEFT: |
| default: |
| animatedProperty = "x"; |
| slideDistance = -targetNavigator.width; |
| break; |
| } |
| |
| // Position the elements of the animation |
| if (mode != SlideViewTransitionMode.UNCOVER) |
| { |
| endView[animatedProperty] = -slideDistance + endView[animatedProperty]; |
| |
| if (actionBar) |
| actionBar[animatedProperty] = -slideDistance + actionBar[animatedProperty]; |
| |
| if (animateTabBar) |
| tabBar[animatedProperty] = -slideDistance + tabBar[animatedProperty]; |
| } |
| else |
| { |
| if (cachedNavigator) |
| { |
| cachedNavigator.includeInLayout = false; |
| addCachedElementToGroup(transitionGroup, cachedNavigator, cachedNavigatorGlobalPosition); |
| } |
| } |
| |
| // Validate to ensure our snapshots are rendered. |
| transitionGroup.validateNow(); |
| |
| // Add the cached images to the display list. This has to occur after the validation |
| // so that the displayObjects for the bitmaps are created. Otherwise the displayObject |
| // property will be null. |
| if (cachedActionBar && mode != SlideViewTransitionMode.COVER) |
| slideTargets.push(cachedActionBar.displayObject); |
| |
| if (cachedTabBar && mode == SlideViewTransitionMode.PUSH) |
| slideTargets.push(cachedTabBar.displayObject); |
| |
| if (cachedNavigator && mode == SlideViewTransitionMode.UNCOVER) |
| slideTargets.push(cachedNavigator.displayObject); |
| |
| // Construct animation sequence. |
| var animate:Animate = new Animate(); |
| var vector:Vector.<MotionPath> = new Vector.<MotionPath>(); |
| vector.push(new SimpleMotionPath(animatedProperty, null, null, slideDistance)); |
| animate.motionPaths = vector; |
| animate.duration = duration; |
| animate.easer = easer; |
| animate.targets = slideTargets; |
| if (startViewNeedsValidations || endViewNeedsValidations) |
| animate.addEventListener("effectUpdate", effectUpdateHandler); |
| consolidatedEffect = animate; |
| return animate; |
| } |
| |
| /** |
| * @private |
| * |
| * @langversion 3.0 |
| * @playerversion AIR 2.5 |
| * @productversion Flex 4.5 |
| */ |
| override protected function cleanUp():void |
| { |
| // Clear the scrollRect that the transition applied to the navigator |
| if (navigatorProps.scrollRectSet) |
| navigator.scrollRect = null; |
| |
| if (startView) |
| { |
| startView.includeInLayout = startViewProps.includeInLayout; |
| startView.visible = startViewProps.visible; |
| startView.cacheAsBitmap = startViewProps.cacheAsBitmap; |
| startView.opaqueBackground = startViewProps.opaqueBackground; |
| } |
| |
| // Restore original saved properties for includeInLayout and cacheAsBitmap. |
| if (!consolidatedTransition) |
| { |
| if (startView) |
| { |
| startView.x = startViewProps.x; |
| startView.y = startViewProps.y; |
| |
| if (startView.contentGroup) |
| startView.contentGroup.includeInLayout = startViewProps.cgIncludeInLayout; |
| } |
| |
| if (endView) |
| { |
| endView.cacheAsBitmap = endViewProps.cacheAsBitmap; |
| endView.opaqueBackground = endViewProps.opaqueBackground; |
| |
| if (endView.contentGroup) |
| endView.contentGroup.includeInLayout = endViewProps.cgIncludeInLayout; |
| |
| endViewProps = null; |
| } |
| |
| if (moveEffect) |
| moveEffect.removeEventListener("effectUpdate", effectUpdateHandler); |
| moveEffect = null; |
| } |
| else |
| { |
| if (tabBar) |
| { |
| tabBar.includeInLayout = navigatorProps.tabBarIncludeInLayout; |
| tabBar.cacheAsBitmap = navigatorProps.tabBarCacheAsBitmap; |
| targetNavigator.contentGroup.includeInLayout = navigatorProps.topNavigatorContentGroupIncludeInLayout; |
| } |
| |
| if (actionBar) |
| { |
| actionBar.includeInLayout = navigatorProps.actionBarIncludeInLayout; |
| actionBar.cacheAsBitmap = navigatorProps.actionBarCacheAsBitmap; |
| } |
| |
| if (startView) |
| { |
| startView.contentGroup.cacheAsBitmap = navigatorProps.startViewCacheAsBitmap; |
| startView.setLayoutBoundsPosition(navigatorProps.startViewX, navigatorProps.startViewY); |
| startView.visible = true; |
| } |
| |
| if (endView) |
| { |
| endView.contentGroup.cacheAsBitmap = navigatorProps.endViewCacheAsBitmap; |
| } |
| |
| navigator.contentGroup.includeInLayout = navigatorProps.navigatorContentGroupIncludeInLayout; |
| |
| if (transitionGroup) |
| { |
| if (mode == SlideViewTransitionMode.UNCOVER) |
| { |
| if (animateTabBar) |
| removeComponentFromContainer(transitionGroup, targetNavigator.skin); |
| else |
| removeComponentFromContainer(transitionGroup, navigator.skin); |
| |
| } |
| else |
| { |
| removeComponentFromContainer(transitionGroup, targetNavigator.skin); |
| } |
| } |
| consolidatedEffect.removeEventListener("effectUpdate", effectUpdateHandler); |
| consolidatedEffect = null; |
| } |
| |
| transitionGroup = null; |
| cachedNavigator = null; |
| cachedActionBar = null; |
| cachedTabBar = null; |
| startViewProps = null; |
| |
| super.cleanUp(); |
| } |
| |
| /** |
| * @private |
| * |
| * @langversion 3.0 |
| * @playerversion AIR 2.5 |
| * @productversion Flex 4.5 |
| */ |
| override public function prepareForPlay():void |
| { |
| actionBarTransitionDirection = direction; |
| applyScrollRect(); |
| |
| super.prepareForPlay(); |
| } |
| |
| /** |
| * @private |
| * Utility function that converts a components position to the coordinate space |
| * of the targetNavigator. This method doesn't use stage coordinates because |
| * that would return inaccurate results when dpi scaling is enabled. |
| */ |
| private function getTargetNavigatorCoordinates(component:IVisualElement):Point |
| { |
| var stagePoint:Point = DisplayObject(component).localToGlobal(new Point()); |
| return targetNavigator.globalToLocal(stagePoint); |
| } |
| |
| /** |
| * @private |
| * This method sets the scrollRect of the navigator that is being animated. |
| * An mx_internal method was created to avoid any issues that may arise by |
| * adding this functionality in the Flex 4.5.1 dot release. Developers |
| * can override this method to do nothing to revert to previous implementations. |
| * This method was added to support clipping of Views during a view transition. |
| */ |
| // TODO (chiedozi): Eventually get rid of this method |
| mx_internal function applyScrollRect():void |
| { |
| // When the initial view of the animation has tabBarVisible set to false, |
| // and the end view has it set to true, the height of the navigator |
| // will be altered to fit the actionBar. Since the startView is not included in |
| // layout, its height will actually be larger than the navigator's. To prevent |
| // the start view from being incorrectly clipped, the scrollRect's height |
| // is set to the maximum of the navigator's initial and current height. |
| if (!navigator.scrollRect) |
| { |
| navigatorProps.scrollRectSet = true; |
| navigator.scrollRect = new Rectangle(0, 0, navigator.width, Math.max(navigator.height, navigatorProps.initialHeight)); |
| } |
| } |
| } |
| } |
