////////////////////////////////////////////////////////////////////////////////
//
//  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.components.supportClasses
{
import flash.geom.Point;

import mx.core.IUIComponent;
import mx.core.InteractionMode;
import mx.core.ScrollPolicy;
import mx.core.mx_internal;
import mx.utils.MatrixUtil;

import spark.components.Scroller;
import spark.core.IViewport;
import spark.layouts.supportClasses.LayoutBase;

use namespace mx_internal;

[ExcludeClass]

/**
 *  @private
 */
public class ScrollerLayout extends LayoutBase
{
    //--------------------------------------------------------------------------
    //
    //  Class constants
    //
    //--------------------------------------------------------------------------
    
    /**
     *  @private
     *  SDT - Scrollbar Display Threshold.  If the content size exceeds the
     *  viewport's size by SDT, then we show a scrollbar.  For example, if the 
     *  contentWidth >= viewport width + SDT, show the horizontal scrollbar.
     */
    mx_internal static const SDT:Number = 1.0;
    
    //--------------------------------------------------------------------------
    //
    //  Constructor
    //
    //--------------------------------------------------------------------------
    
    public function ScrollerLayout()    
    {
        super();
    }
    
    //--------------------------------------------------------------------------
    //
    //  Variables
    //
    //--------------------------------------------------------------------------   

	/**
	 *  @private
	 *  Used by updateDisplayList() to prevent looping.
	 */
	private var invalidationCount:int = 0;
	
	/**
	 *  @private
	 *  Used by updateDisplayList() to prevent looping.
	 */
	private var removeCount:int = 0;
	
    /**
     *  @private
     */
    private function getScroller():Scroller
    {
        var g:Skin = target as Skin;
        return (g && ("hostComponent" in g)) ? Object(g).hostComponent as Scroller : null;
    }

    /**
     *  @private
     *  Returns the viewport's content size transformed into the Scroller's coordiante
     *  system.   This makes it possible to compare the viewport size (also reported
     *  relative to the Scroller) and the content size when a transform has been applied
     *  to the viewport.  See http://bugs.adobe.com/jira/browse/SDK-19702
     */
    private function getLayoutContentSize(viewport:IViewport):Point
    {
        // TODO(hmuller):prefer to do nothing if transform doesn't change size, see UIComponent/nonDeltaLayoutMatrix()
        var cw:Number = viewport.contentWidth;
        var ch:Number = viewport.contentHeight;
        if (((cw == 0) && (ch == 0)) || (isNaN(cw) || isNaN(ch)))
            return new Point(0,0);
        return MatrixUtil.transformSize(cw, ch, viewport.getLayoutMatrix());
    }
    
    //----------------------------------
    //  canScrollHorizontally
    //----------------------------------  
    
    /**
     *  @private
     */
    private var _canScrollHorizontally:Boolean;
    
    /**
     *  @private
     *  Helper function to determine whether the viewport scrolls horizontally.
     * 
     *  <p>This is used for touch scrolling purposes to 
     *  determine if one can scroll horizontally.</p>
     * 
     *  <p>The value is set in updateDisplayList()</p>
     */
    mx_internal function get canScrollHorizontally():Boolean
    {
        return _canScrollHorizontally;
    }
    
    //----------------------------------
    //  canScrollVertically
    //----------------------------------  
    
    /**
     *  @private
     */
    private var _canScrollVertically:Boolean;
    
    /**
     *  @private
     *  Helper function to determine whether the viewport scrolls vertically.
     * 
     *  <p>This is used for touch scrolling purposes to 
     *  determine if one can scroll vertically.</p>
     * 
     *  <p>The value is set in updateDisplayList()</p>
     */
    mx_internal function get canScrollVertically():Boolean
    {
        return _canScrollVertically;
    }

    //----------------------------------
    //  hsbVisible
    //----------------------------------    
    
    private var hsbScaleX:Number = 1;
    private var hsbScaleY:Number = 1;

    /**
     *  @private
     */
    private function get hsbVisible():Boolean
    {
        var hsb:ScrollBarBase = getScroller().horizontalScrollBar;
        return hsb && hsb.visible;
    }

    /**
     *  @private 
     *  To make the scrollbars invisible to methods like getRect() and getBounds() 
     *  as well as to methods based on them like hitTestPoint(), we set their scale 
     *  to 0.  More info about this here: http://bugs.adobe.com/jira/browse/SDK-21540
     */
    private function set hsbVisible(value:Boolean):void
    {
        var hsb:ScrollBarBase = getScroller().horizontalScrollBar;
        if (!hsb || hsb.visible == value)
            return;

        hsb.includeInLayout = hsb.visible = value;
        if (value)
        {
            if (hsb.scaleX == 0) 
                hsb.scaleX = hsbScaleX;
            if (hsb.scaleY == 0) 
                hsb.scaleY = hsbScaleY;
        }
        else 
        {
            if (hsb.scaleX != 0)
                hsbScaleX = hsb.scaleX;
            if (hsb.scaleY != 0)
                hsbScaleY = hsb.scaleY;
            hsb.scaleX = hsb.scaleY = 0;            
        }
        
        // TODO (rfrishbe) (or hmuller): perhaps rather than setting scale to 0,
        // we should be adding/removing it from the display list
    }

    /**
     *  @private
     *  Returns the vertical space required by the horizontal scrollbar.   
     *  That's the larger of the minViewportInset and the hsb's preferred height.   
     * 
     *  Computing this value is complicated by the fact that if the HSB is currently 
     *  hsbVisible=false, then it's scaleX,Y will be 0, and it's preferred size is 0.  
     *  For that reason we specify postLayoutTransform=false to getPreferredBoundsHeight() 
     *  and then multiply by the original scale factor, hsbScaleY.
     */
    private function hsbRequiredHeight():Number 
    {
        var scroller:Scroller = getScroller();
        var minViewportInset:Number = scroller.minViewportInset;
        var hsb:ScrollBarBase = scroller.horizontalScrollBar;
        var sy:Number = (hsbVisible) ? 1 : hsbScaleY;
        return Math.max(minViewportInset, hsb.getPreferredBoundsHeight(hsbVisible) * sy);
    }
    
    /**
     *  @private
     *  Return true if the specified dimensions provide enough space to layout 
     *  the horizontal scrollbar (hsb) at its minimum size.   The HSB is assumed 
     *  to be non-null and visible.
     * 
     *  If includeVSB is false we check to see if the HSB would fit if the 
     *  VSB wasn't visible.
     */
    private function hsbFits(w:Number, h:Number, includeVSB:Boolean=true):Boolean
    {
        if (vsbVisible && includeVSB)
        {
            var vsb:ScrollBarBase = getScroller().verticalScrollBar;            
            w -= vsb.getPreferredBoundsWidth();
            h -= vsb.getMinBoundsHeight();
        }
        var hsb:ScrollBarBase = getScroller().horizontalScrollBar;        
        return (w >= hsb.getMinBoundsWidth()) && (h >= hsb.getPreferredBoundsHeight());
    }
    
    //----------------------------------
    //  vsbVisible
    //----------------------------------    

    private var vsbScaleX:Number = 1;
    private var vsbScaleY:Number = 1;

    /**
     *  @private
     */
    private function get vsbVisible():Boolean
    {
        var vsb:ScrollBarBase = getScroller().verticalScrollBar;
        return vsb && vsb.visible;
    }
    
    /**
     *  @private
     *  The logic here is the same as for the horizontal scrollbar, see above.
     */
    private function set vsbVisible(value:Boolean):void
    {
        var vsb:ScrollBarBase = getScroller().verticalScrollBar;
        if (!vsb || vsb.visible == value)
            return;
        
        vsb.includeInLayout = vsb.visible = value;
        if (value)
        {
            if (vsb.scaleX == 0) 
                vsb.scaleX = vsbScaleX;
            if (vsb.scaleY == 0) 
                vsb.scaleY = vsbScaleY;
        }
        else 
        {
            if (vsb.scaleX != 0)
                vsbScaleX = vsb.scaleX;
            if (vsb.scaleY != 0)
                vsbScaleY = vsb.scaleY;
            vsb.scaleX = vsb.scaleY = 0;            
        }
    }

    /**
     *  @private
     *  Returns the vertical space required by the horizontal scrollbar.   
     *  That's the larger of the minViewportInset and the hsb's preferred height.  
     *  
     *  Computing this value is complicated by the fact that if the HSB is currently 
     *  hsbVisible=false, then it's scaleX,Y will be 0, and it's preferred size is 0.  
     *  For that reason we specify postLayoutTransform=false to getPreferredBoundsWidth() 
     *  and then multiply by the original scale factor, vsbScaleX.
     */
    private function vsbRequiredWidth():Number 
    {
        var scroller:Scroller = getScroller();
        var minViewportInset:Number = scroller.minViewportInset;
        var vsb:ScrollBarBase = scroller.verticalScrollBar;
        var sx:Number = (vsbVisible) ? 1 : vsbScaleX;
        return Math.max(minViewportInset, vsb.getPreferredBoundsWidth(vsbVisible) * sx);
    }
    
    /**
     *  @private
     *  Return true if the specified dimensions provide enough space to layout 
     *  the vertical scrollbar (vsb) at its minimum size.   The VSB is assumed 
     *  to be non-null and visible.
     * 
     *  If includeHSB is false, we check to see if the VSB would fit if the 
     *  HSB wasn't visible.
     */
    private function vsbFits(w:Number, h:Number, includeHSB:Boolean=true):Boolean
    {
        if (hsbVisible && includeHSB)
        {
            var hsb:ScrollBarBase = getScroller().horizontalScrollBar;            
            w -= hsb.getMinBoundsWidth();
            h -= hsb.getPreferredBoundsHeight();
        }
        var vsb:ScrollBarBase = getScroller().verticalScrollBar;  
        return (w >= vsb.getPreferredBoundsWidth()) && (h >= vsb.getMinBoundsHeight());
    }
    
	
    //--------------------------------------------------------------------------
    //
    //  Overidden Methods
    //
    //--------------------------------------------------------------------------
    
    /**
     * @private
     *  Computes the union of the preferred size of the visible scrollbars 
     *  and the viewport if target.measuredSizeIncludesScrollbars=true, otherwise
     *  it's just the preferred size of the viewport.
     * 
     *  This becomes the ScrollerSkin's measuredWidth,Height.
     *    
     *  The viewport does not contribute to the minimum size unless its
     *  explicit size has been set.
     */
    override public function measure():void
    {
        const scroller:Scroller = getScroller();
        if (!scroller) 
            return;
		
		removeCount = 0;
            
        const minViewportInset:Number = scroller.minViewportInset;
        const measuredSizeIncludesScrollBars:Boolean = scroller.measuredSizeIncludesScrollBars && (scroller.getStyle("interactionMode") == InteractionMode.MOUSE);

        var measuredW:Number = minViewportInset;
        var measuredH:Number = minViewportInset;
        
        const hsb:ScrollBarBase = scroller.horizontalScrollBar;
        var showHSB:Boolean = false;
        var hAuto:Boolean = false;
        if (measuredSizeIncludesScrollBars)
            switch(scroller.getStyle("horizontalScrollPolicy")) 
            {
                case ScrollPolicy.ON: 
                    if (hsb) showHSB = true; 
                    break;
                case ScrollPolicy.AUTO: 
                    if (hsb) showHSB = hsb.visible;
                    hAuto = true;
                    break;
            } 

        const vsb:ScrollBarBase = scroller.verticalScrollBar;
        var showVSB:Boolean = false;
        var vAuto:Boolean = false;
        if (measuredSizeIncludesScrollBars)
            switch(scroller.getStyle("verticalScrollPolicy")) 
            {
               case ScrollPolicy.ON: 
                    if (vsb) showVSB = true; 
                    break;
                case ScrollPolicy.AUTO: 
                    if (vsb) showVSB = vsb.visible;
                    vAuto = true;
                    break;
            }
        
        measuredH += (showHSB) ? hsbRequiredHeight() : minViewportInset;
        measuredW += (showVSB) ? vsbRequiredWidth() : minViewportInset;

        // The measured size of the viewport is just its preferredBounds, except:
        // don't give up space if doing so would make an auto scrollbar visible.
        // In other words, if an auto scrollbar isn't already showing, and using
        // the preferred size would force it to show, and the current size would not,
        // then use its current size as the measured size.  Note that a scrollbar
        // is only shown if the content size is greater than the viewport size 
        // by at least SDT.

        var viewport:IViewport = scroller.viewport;
        if (viewport)
        {
            if (measuredSizeIncludesScrollBars)
            {
                var contentSize:Point = getLayoutContentSize(viewport);
    
                var viewportPreferredW:Number =  viewport.getPreferredBoundsWidth();
                var viewportContentW:Number = contentSize.x;
                var viewportW:Number = viewport.getLayoutBoundsWidth();  // "current" size
                var currentSizeNoHSB:Boolean = !isNaN(viewportW) && ((viewportW + SDT) > viewportContentW);
                if (hAuto && !showHSB && ((viewportPreferredW + SDT) <= viewportContentW) && currentSizeNoHSB)
                    measuredW += viewportW;
                else
                    measuredW += Math.max(viewportPreferredW, (showHSB) ? hsb.getMinBoundsWidth() : 0);
    
                var viewportPreferredH:Number = viewport.getPreferredBoundsHeight();
                var viewportContentH:Number = contentSize.y;
                var viewportH:Number = viewport.getLayoutBoundsHeight();  // "current" size
                var currentSizeNoVSB:Boolean = !isNaN(viewportH) && ((viewportH + SDT) > viewportContentH);
                if (vAuto && !showVSB && ((viewportPreferredH + SDT) <= viewportContentH) && currentSizeNoVSB)
                    measuredH += viewportH;
                else
                    measuredH += Math.max(viewportPreferredH, (showVSB) ? vsb.getMinBoundsHeight() : 0);
            }
            else
            {
                measuredW += viewport.getPreferredBoundsWidth();
                measuredH += viewport.getPreferredBoundsHeight();
            }
        }

        var minW:Number = minViewportInset * 2;
        var minH:Number = minViewportInset * 2;

        // If the viewport's explicit size is set, then 
        // include that in the scroller's minimum size

        var viewportUIC:IUIComponent = viewport as IUIComponent;
        var explicitViewportW:Number = viewportUIC ? viewportUIC.explicitWidth : NaN;
        var explicitViewportH:Number = viewportUIC ? viewportUIC.explicitHeight : NaN;

        if (!isNaN(explicitViewportW)) 
            minW += explicitViewportW;

        if (!isNaN(explicitViewportH)) 
            minH += explicitViewportH;
        
        var g:GroupBase = target;
        g.measuredWidth = Math.ceil(measuredW);
        g.measuredHeight = Math.ceil(measuredH);
        g.measuredMinWidth = Math.ceil(minW); 
        g.measuredMinHeight = Math.ceil(minH);
    }


    /** 
     *  @private
     *  Arrange the viewport and scrollbars conventionally within
     *  the specified width and height: vertical scrollbar on the 
     *  right, horizontal scrollbar along the bottom.
     * 
     *  Scrollbars for which the corresponding scrollPolicy=auto 
     *  are made visible if the viewport's content size is bigger 
     *  than the actual size.   This introduces the possibility of
     *  validateSize,DisplayList() looping because the measure() 
     *  method computes the size of the viewport and the currently
     *  visible scrollbars. 
     * 
     */
    override public function updateDisplayList(w:Number, h:Number):void
    {  
        var scroller:Scroller = getScroller();
        if (!scroller) 
            return;

        var viewport:IViewport = scroller.viewport;
        var hsb:ScrollBarBase = scroller.horizontalScrollBar;
        var vsb:ScrollBarBase = scroller.verticalScrollBar;
        var minViewportInset:Number = scroller.minViewportInset;
        
        var contentW:Number = 0;
        var contentH:Number = 0;
        if (viewport)
        {
            var contentSize:Point = getLayoutContentSize(viewport);
            contentW = contentSize.x;
            contentH = contentSize.y;
        }
    
        // If the viewport's size has been explicitly set (not typical) then use it
        // The initial values for viewportW,H are only used to decide if auto scrollbars
        // should be shown. 
 
        var viewportUIC:IUIComponent = viewport as IUIComponent;
        var explicitViewportW:Number = viewportUIC ? viewportUIC.explicitWidth : NaN;
        var explicitViewportH:Number = viewportUIC ? viewportUIC.explicitHeight : NaN;
        
        var viewportW:Number = isNaN(explicitViewportW) ? (w - (minViewportInset * 2)) : explicitViewportW;
        var viewportH:Number = isNaN(explicitViewportH) ? (h - (minViewportInset * 2)) : explicitViewportH;
                        
        // Decide which scrollbars will be visible based on the viewport's content size
        // and the scroller's scroll policies.  A scrollbar is shown if the content size 
        // greater than the viewport's size by at least SDT.
        
        var oldShowHSB:Boolean = hsbVisible;
        var oldShowVSB:Boolean = vsbVisible;
        
        var hAuto:Boolean = false;
        var hsbTakeUpSpace:Boolean = true; // if visible
        switch(scroller.getStyle("horizontalScrollPolicy")) 
        {
            case ScrollPolicy.ON: 
				_canScrollHorizontally = true;
                hsbVisible = true;
                break;

            case ScrollPolicy.AUTO: 
                if (viewport)
                {
                    hAuto = true;
					_canScrollHorizontally = (contentW >= (viewportW + SDT));
                    hsbVisible = (hsb && _canScrollHorizontally);
                } 
                break;
            
            default:
				_canScrollHorizontally = false;
                hsbVisible = false;
        }

        var vAuto:Boolean = false;
        var vsbTakeUpSpace:Boolean = true; // if visible
        switch(scroller.getStyle("verticalScrollPolicy")) 
        {
           case ScrollPolicy.ON: 
                _canScrollVertically = true;
                vsbVisible = true;
                break;

            case ScrollPolicy.AUTO: 
                if (viewport)
                { 
                    vAuto = true;
					_canScrollVertically = (contentH >= (viewportH + SDT));
                    vsbVisible = (vsb && _canScrollVertically);
                }                        
                break;
            
            default:
                _canScrollVertically = false;
                vsbVisible = false;
        }
        
        // if in touch mode, only show scrollbars if a scroll is currently in progress
        if (scroller.getStyle("interactionMode") == InteractionMode.TOUCH)
        {
            hsbTakeUpSpace = false;
            hsbVisible = scroller.horizontalScrollInProgress;
            
            vsbTakeUpSpace = false;
            vsbVisible = scroller.verticalScrollInProgress;
        }

        // Reset the viewport's width,height to account for the visible scrollbars, unless
        // the viewport's size was explicitly set, then we just use that. 
        
        if (isNaN(explicitViewportW))
            viewportW = w - ((vsbVisible && vsbTakeUpSpace) ? (minViewportInset + vsbRequiredWidth()) : (minViewportInset * 2));
        else 
            viewportW = explicitViewportW;
        
        if (isNaN(explicitViewportH))
            viewportH = h - ((hsbVisible && hsbTakeUpSpace) ? (minViewportInset + hsbRequiredHeight()) : (minViewportInset * 2));
        else 
            viewportH = explicitViewportH;

        // If the scrollBarPolicy is auto, and we're only showing one scrollbar, 
        // the viewport may have shrunk enough to require showing the other one.
        
        var hsbIsDependent:Boolean = false;
        var vsbIsDependent:Boolean = false;
        
        if (vsbVisible && !hsbVisible && hAuto && (contentW >= (viewportW + SDT)))
            hsbVisible = hsbIsDependent = _canScrollHorizontally = true;
        else if (!vsbVisible && hsbVisible && vAuto && (contentH >= (viewportH + SDT)))
            vsbVisible = vsbIsDependent = _canScrollVertically = true;

        // If the HSB doesn't fit, hide it and give the space back.   Likewise for VSB.
        // If both scrollbars are supposed to be visible but they don't both fit, 
        // then prefer to show the "non-dependent" auto scrollbar if we added the second
        // "dependent" auto scrollbar because of the space consumed by the first.
        
        if ((hsbVisible && hsbTakeUpSpace) && (vsbVisible && vsbTakeUpSpace)) 
        {
            if (hsbFits(w, h) && vsbFits(w, h))
            {
                // Both scrollbars fit, we're done.
            }
            else if (!hsbFits(w, h, false) && !vsbFits(w, h, false))
            {
                // Neither scrollbar would fit, even if the other scrollbar wasn't visible.
                hsbVisible = false;
                vsbVisible = false;
            }
            else
            {
                // Only one of the scrollbars will fit.  If we're showing a second "dependent"
                // auto scrollbar because the first scrollbar consumed enough space to
                // require it, if the first scrollbar doesn't fit, don't show either of them.

                if (hsbIsDependent)
                {
                    if (removeCount < 2 && vsbFits(w, h, false))  // VSB will fit if HSB isn't shown
					{
						removeCount++;
                        hsbVisible = false;
					}
                    else
					{
                        vsbVisible = hsbVisible = false;
					}
  
                }
                else if (vsbIsDependent)
                {
                    if (removeCount < 2 && hsbFits(w, h, false)) // HSB will fit if VSB isn't shown
					{
						removeCount++;
                        vsbVisible = false;
					}
                    else
					{
                        hsbVisible = vsbVisible = false; 
					}	
                }
                else if (vsbFits(w, h, false)) // VSB will fit if HSB isn't shown
                    hsbVisible = false;
                else // hsbFits(w, h, false)   // HSB will fit if VSB isn't shown
                    vsbVisible = false;
            }
        }
        else if (hsbVisible && hsbTakeUpSpace && !hsbFits(w, h))  // just trying to show HSB, but it doesn't fit
            hsbVisible = false;
        else if (vsbVisible && vsbTakeUpSpace && !vsbFits(w, h))  // just trying to show VSB, but it doesn't fit
            vsbVisible = false;
        
        // if the only reason for showing one particular scrollbar was because the 
        // other scrollbar was visible, and we're now not showing the other scrollbar, 
        // then there's no need to allow scrolling in that direction anymore.
        if (hsbIsDependent && !vsbVisible)
            _canScrollHorizontally = false;
        if (vsbIsDependent && !hsbVisible)
            _canScrollVertically = false;
        
        // Reset the viewport's width,height to account for the visible scrollbars, unless
        // the viewport's size was explicitly set, then we just use that.
        
        if (isNaN(explicitViewportW))
            viewportW = w - ((vsbVisible && vsbTakeUpSpace) ? (minViewportInset + vsbRequiredWidth()) : (minViewportInset * 2));
        else 
            viewportW = explicitViewportW;

        if (isNaN(explicitViewportH))
            viewportH = h - ((hsbVisible && hsbTakeUpSpace) ? (minViewportInset + hsbRequiredHeight()) : (minViewportInset * 2));
        else 
            viewportH = explicitViewportH;
        
		// Layout the viewport and scrollbars.
		if (viewport)
		{
			viewport.setLayoutBoundsSize(viewportW, viewportH);
			viewport.setLayoutBoundsPosition(minViewportInset, minViewportInset);
		}
		
        if (hsbVisible)
        {
			var hsbH:Number = hsb.getPreferredBoundsHeight();
            var hsbW:Number = vsbVisible ? w - vsb.getPreferredBoundsWidth() : w;
            hsb.setLayoutBoundsSize(Math.max(hsb.getMinBoundsWidth(), hsbW), hsbH);           
			hsb.setLayoutBoundsPosition(0, h - hsbH);
        }

        if (vsbVisible)
        {
            var vsbW:Number = vsb.getPreferredBoundsWidth(); 
            var vsbH:Number = hsbVisible ? h - hsb.getPreferredBoundsHeight() : h;
			vsb.setLayoutBoundsSize(vsbW, Math.max(vsb.getMinBoundsHeight(), vsbH));		
			vsb.setLayoutBoundsPosition(w - vsbW, 0);
        }

        // If we've added an auto scrollbar, then the measured size is likely to have been wrong.
        // There's a risk of looping here, so we count.  
        if ((invalidationCount < 2) && (((vsbVisible != oldShowVSB) && vAuto) || ((hsbVisible != oldShowHSB) && hAuto)))
        {
            target.invalidateSize();
            
            // If the viewport's layout is virtual, it's possible that its
            // measured size changed as a consequence of laying it out,
            // so we invalidate its size as well.
            var viewportGroup:GroupBase = viewport as GroupBase;
            if (viewportGroup && viewportGroup.layout && viewportGroup.layout.useVirtualLayout)
                viewportGroup.invalidateSize();
            
            invalidationCount++; 
        }
        else
            invalidationCount = 0;
        
        target.setContentSize(w, h);
    }

}

}