royale-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From alinak...@apache.org
Subject [royale-asjs] branch feature/MXRoyale updated: VerticalLayout, as Added
Date Mon, 21 May 2018 07:34:38 GMT
This is an automated email from the ASF dual-hosted git repository.

alinakazi pushed a commit to branch feature/MXRoyale
in repository https://gitbox.apache.org/repos/asf/royale-asjs.git


The following commit(s) were added to refs/heads/feature/MXRoyale by this push:
     new aa51acf  VerticalLayout,as Added
aa51acf is described below

commit aa51acff8b193d796fcd166620f6fa831012f84d
Author: alinakazi <ALINAKAZI1990@GMAIL.COM>
AuthorDate: Mon May 21 00:34:36 2018 -0700

    VerticalLayout,as Added
---
 .../main/royale/spark/layouts/VerticalLayout.as    | 2385 ++++++++++++++++++++
 1 file changed, 2385 insertions(+)

diff --git a/frameworks/projects/SparkRoyale/src/main/royale/spark/layouts/VerticalLayout.as b/frameworks/projects/SparkRoyale/src/main/royale/spark/layouts/VerticalLayout.as
new file mode 100644
index 0000000..ba1fcd2
--- /dev/null
+++ b/frameworks/projects/SparkRoyale/src/main/royale/spark/layouts/VerticalLayout.as
@@ -0,0 +1,2385 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+//  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.layouts
+{
+/* import flash.events.Event;
+import flash.geom.Point;
+import flash.geom.Rectangle;
+
+import mx.containers.utilityClasses.Flex;
+import mx.core.FlexVersion;
+import mx.core.ILayoutElement;
+import mx.core.IVisualElement;
+import mx.core.mx_internal;
+import mx.events.PropertyChangeEvent;
+
+import spark.components.DataGroup;
+import spark.components.supportClasses.GroupBase;
+import spark.core.NavigationUnit;
+import spark.layouts.supportClasses.DropLocation;
+import spark.layouts.supportClasses.LayoutBase;
+import spark.layouts.supportClasses.LayoutElementHelper;
+import spark.layouts.supportClasses.LinearLayoutVector;
+
+use namespace mx_internal; */
+
+/**
+ *  The VerticalLayout class arranges the layout elements in a vertical sequence,
+ *  top to bottom, with optional gaps between the elements and optional padding
+ *  around the sequence of elements.
+ *
+ *  <p>The vertical position of the elements is determined by arranging them
+ *  in a vertical sequence, top to bottom, taking into account the padding
+ *  before the first element and the gaps between the elements.</p>
+ *
+ *  <p>The horizontal position of the elements is determined by the layout's
+ *  <code>horizontalAlign</code> property.</p>
+ *
+ *  <p>During the execution of the <code>measure()</code> method, 
+ *  the default size of the container is calculated by
+ *  accumulating the preferred sizes of the elements, including gaps and padding.
+ *  When <code>requestedRowCount</code> is set, only the space for that many elements
+ *  is measured, starting from the first element.</p>
+ *
+ *  <p>During the execution of the <code>updateDisplayList()</code> method, 
+ *  the height of each element is calculated
+ *  according to the following rules, listed in their respective order of
+ *  precedence (element's minimum height and maximum height are always respected):</p>
+ *  <ul>
+ *    <li>If <code>variableRowHeight</code> is <code>false</code>, 
+ *    then set the element's height to the
+ *    value of the <code>rowHeight</code> property.</li>
+ *
+ *    <li>If the element's <code>percentHeight</code> is set, then calculate the element's
+ *    height by distributing the available container height between all
+ *    elements with a <code>percentHeight</code> setting. 
+ *    The available container height
+ *    is equal to the container height minus the gaps, the padding and the
+ *    space occupied by the rest of the elements. The element's <code>precentHeight</code>
+ *    property is ignored when the layout is virtualized.</li>
+ *
+ *    <li>Set the element's height to its preferred height.</li>
+ *  </ul>
+ *
+ *  <p>The width of each element is calculated according to the following rules,
+ *  listed in their respective order of precedence (element's minimum width and
+ *  maximum width are always respected):</p>
+ *  <ul>
+ *    <li>If <code>horizontalAlign</code> is <code>"justify"</code>, 
+ *    then set the element's width to the container width.</li>
+ *
+ *    <li>If <code>horizontalAlign</code> is <code>"contentJustify"</code>,
+ *    then set the element's width to the maximum between the container's width 
+ *    and all elements' preferred width.</li>
+ *
+ *    <li>If the element's <code>percentWidth</code> is set, then calculate the element's
+ *    width as a percentage of the container's width.</li>
+ *
+ *    <li>Set the element's width to its preferred width.</li>
+ *  </ul>
+ *
+ *  @mxml 
+ *  <p>The <code>&lt;s:VerticalLayout&gt;</code> tag inherits all of the tag 
+ *  attributes of its superclass and adds the following tag attributes:</p>
+ *
+ *  <pre>
+ *  &lt;s:VerticalLayout 
+ *    <strong>Properties</strong>
+ *    gap="6"
+ *    horizontalAlign="left"
+ *    padding="0"
+ *    paddingBottom="0"
+ *    paddingLeft="0"
+ *    paddingRight="0"
+ *    paddingTop="0"
+ *    requestedMaxRowCount="-1"
+ *    requestedMinRowCount="-1"
+ *    requestedRowCount="-1"
+ *    rowHeight="<i>calculated</i>"
+ *    variableRowHeight="true"
+ *    verticalAlign="top"
+ *  /&gt;
+ *  </pre>
+ *
+ *  @langversion 3.0
+ *  @playerversion Flash 10
+ *  @playerversion AIR 1.5
+ *  @productversion Flex 4
+ */
+public class VerticalLayout
+{ // extends LayoutBase
+    //include "../core/Version.as";
+    
+    /**
+     *  @private
+     *  Cached row heights, max column width for virtual layout.   Not used unless
+     *  useVirtualLayout=true.   See updateLLV(), resetCachedVirtualLayoutState(),
+     *  etc.
+     */
+    /* private var llv:LinearLayoutVector; */
+    
+    //--------------------------------------------------------------------------
+    //
+    //  Class methods
+    //
+    //--------------------------------------------------------------------------
+    
+   /*  private static function calculatePercentWidth(layoutElement:ILayoutElement, width:Number):Number
+    {
+        var percentWidth:Number;
+        if (FlexVersion.compatibilityVersion < FlexVersion.VERSION_4_6)
+        {
+            percentWidth = LayoutElementHelper.pinBetween(Math.round(layoutElement.percentWidth * 0.01 * width),
+                                                          layoutElement.getMinBoundsWidth(),
+                                                          layoutElement.getMaxBoundsWidth() );
+            return percentWidth < width ? percentWidth : width;
+        }
+        else
+        {
+            percentWidth = LayoutElementHelper.pinBetween(Math.min(Math.round(layoutElement.percentWidth * 0.01 * width), width),
+                                                          layoutElement.getMinBoundsWidth(),
+                                                          layoutElement.getMaxBoundsWidth() );
+            return percentWidth;
+        }
+    } */
+    
+   /*  private static function sizeLayoutElement(layoutElement:ILayoutElement, 
+                                              width:Number, 
+                                              horizontalAlign:String, 
+                                              restrictedWidth:Number, 
+                                              height:Number, 
+                                              variableRowHeight:Boolean, 
+                                              rowHeight:Number):void
+    {
+        var newWidth:Number = NaN;
+        
+        // if horizontalAlign is "justify" or "contentJustify", 
+        // restrict the width to restrictedWidth.  Otherwise, 
+        // size it normally
+        if (horizontalAlign == HorizontalAlign.JUSTIFY ||
+            horizontalAlign == HorizontalAlign.CONTENT_JUSTIFY)
+        {
+            newWidth = restrictedWidth;
+        }
+        else
+        {
+            if (!isNaN(layoutElement.percentWidth))
+               newWidth = calculatePercentWidth(layoutElement, width);
+        }
+        
+        if (variableRowHeight)
+            layoutElement.setLayoutBoundsSize(newWidth, height);
+        else
+            layoutElement.setLayoutBoundsSize(newWidth, rowHeight);
+    } */
+        
+    //--------------------------------------------------------------------------
+    //
+    //  Constructor
+    //
+    //--------------------------------------------------------------------------
+
+    /**
+     *  Constructor. 
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 1.5
+     *  @productversion Flex 4
+     */    
+    public function VerticalLayout():void
+    {
+       // super();
+
+        // Don't drag-scroll in the horizontal direction
+       // dragScrollRegionSizeHorizontal = 0;
+    }
+
+    //--------------------------------------------------------------------------
+    //
+    //  Properties
+    //
+    //--------------------------------------------------------------------------
+
+    //----------------------------------
+    //  gap
+    //----------------------------------
+    
+    private var _gap:int = 6;
+    
+    [Inspectable(category="General")]
+
+    /**
+     *  The vertical space between layout elements, in pixels.
+     * 
+     *  Note that the gap is only applied between layout elements, so if there's
+     *  just one element, the gap has no effect on the layout.
+     * 
+     *  @default 6
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 1.5
+     *  @productversion Flex 4
+     */
+    public function get gap():int
+    {
+        return _gap;
+    }
+
+    /**
+     *  @private
+     */
+    public function set gap(value:int):void
+    {
+        if (_gap == value) 
+            return;
+
+        _gap = value;
+      //  invalidateTargetSizeAndDisplayList();
+    }
+
+    //----------------------------------
+    //  rowCount
+    //----------------------------------
+
+   /*  private var _rowCount:int = -1;
+
+    [Bindable("propertyChange")]
+    [Inspectable(category="General")] */
+    
+    /**
+     *  The current number of visible elements.
+     * 
+     *  @default -1
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 1.5
+     *  @productversion Flex 4
+     */
+    /* public function get rowCount():int
+    {
+        return _rowCount;
+    } */
+    
+    /**
+     *  @private
+     * 
+     *  Sets the <code>rowCount</code> property and dispatches a
+     *  PropertyChangeEvent.
+     */
+   /*  mx_internal function setRowCount(value:int):void
+    {
+        if (_rowCount == value)
+            return;
+        var oldValue:int = _rowCount;
+        _rowCount = value;
+        dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "rowCount", oldValue, value));
+    } */
+    
+    //----------------------------------
+    //  horizontalAlign
+    //----------------------------------
+
+    /**
+     *  @private
+     */
+    private var _horizontalAlign:String = "left"; // HorizontalAlign.LEFT;
+
+    [Inspectable(category="General", enumeration="left,right,center,justify,contentJustify", defaultValue="left")]
+
+    /** 
+     *  The horizontal alignment of layout elements.
+     *  If the value is <code>"left"</code>, <code>"right"</code>, or <code>"center"</code> then the 
+     *  layout element is aligned relative to the container's <code>contentWidth</code> property.
+     * 
+     *  <p>If the value is <code>"contentJustify"</code>, then the layout element's actual
+     *  width is set to the <code>contentWidth</code> of the container.
+     *  The <code>contentWidth</code> of the container is the width of the largest layout element. 
+     *  If all layout elements are smaller than the width of the container, 
+     *  then set the width of all layout elements to the width of the container.</p>
+     * 
+     *  <p>If the value is <code>"justify"</code> then the layout element's actual width
+     *  is set to the container's width.</p>
+     *
+     *  <p>This property does not affect the layout's measured size.</p>
+     *  
+     *  @default "left"
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 1.5
+     *  @productversion Flex 4
+     */
+    public function get horizontalAlign():String
+    {
+        return _horizontalAlign;
+    }
+
+    /**
+     *  @private
+     */
+    public function set horizontalAlign(value:String):void
+    {
+        if (value == _horizontalAlign) 
+            return;
+        
+        _horizontalAlign = value;
+
+        /* var layoutTarget:GroupBase = target;
+        if (layoutTarget)
+            layoutTarget.invalidateDisplayList(); */
+    }
+    
+    //----------------------------------
+    //  verticalAlign
+    //----------------------------------
+    
+    /**
+     *  @private
+     */
+    private var _verticalAlign:String = "top"; //VerticalAlign.TOP;
+    
+    [Inspectable(category="General", enumeration="top,bottom,middle", defaultValue="top")]
+    
+    /** 
+     *  The vertical alignment of the content relative to the container's height.
+     * 
+     *  <p>If the value is <code>"bottom"</code>, <code>"middle"</code>, 
+     *  or <code>"top"</code> then the layout elements are aligned relative 
+     *  to the container's <code>contentHeight</code> property.</p>
+     *
+     *  <p>This property has no effect when <code>clipAndEnableScrolling</code> is true
+     *  and the <code>contentHeight</code> is greater than the container's height.</p>
+     *
+     *  <p>This property does not affect the layout's measured size.</p>
+     *  
+     *  @default "top"
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 1.5
+     *  @productversion Flex 4
+     */
+    public function get verticalAlign():String
+    {
+        return _verticalAlign;
+    }
+    
+    /**
+     *  @private
+     */
+    public function set verticalAlign(value:String):void
+    {
+        if (value == _verticalAlign) 
+            return;
+        
+        _verticalAlign = value;
+        
+       /*  var layoutTarget:GroupBase = target;
+        if (layoutTarget)
+            layoutTarget.invalidateDisplayList(); */
+    }
+	
+	//----------------------------------
+	//  padding
+	//----------------------------------
+	
+	private var _padding:Number = 0;
+	
+	[Inspectable(category="General")]
+	
+	/**
+	 *  The minimum number of pixels between the container's edges and
+	 *  the edges of the layout element.
+	 * 
+	 *  @default 0
+	 *  
+	 *  @langversion 3.0
+	 *  @playerversion Flash 10
+	 *  @playerversion AIR 1.5
+	 *  @productversion Flex 4
+	 */
+	public function get padding():Number
+	{
+		return _padding;
+	}
+	
+	/**
+	 *  @private
+	 */
+	public function set padding(value:Number):void
+	{
+		if (_padding == value)
+			return;
+		
+		_padding = value;
+		
+		paddingBottom = _padding;
+		paddingLeft = _padding;
+		paddingRight = _padding;
+		paddingTop = _padding;
+		
+		//invalidateTargetSizeAndDisplayList();
+	}    
+    
+    //----------------------------------
+    //  paddingLeft
+    //----------------------------------
+
+    private var _paddingLeft:Number = 0;
+    
+    [Inspectable(category="General")]
+
+    /**
+     *  The minimum number of pixels between the container's left edge and
+     *  the left edge of the layout element.
+     * 
+     *  @default 0
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 1.5
+     *  @productversion Flex 4
+     */
+    public function get paddingLeft():Number
+    {
+        return _paddingLeft;
+    }
+
+    /**
+     *  @private
+     */
+    public function set paddingLeft(value:Number):void
+    {
+        if (_paddingLeft == value)
+            return;
+                               
+        _paddingLeft = value;
+       // invalidateTargetSizeAndDisplayList();
+    }    
+    
+    //----------------------------------
+    //  paddingRight
+    //----------------------------------
+
+    private var _paddingRight:Number = 0;
+    
+    [Inspectable(category="General")]
+
+    /**
+     *  The minimum number of pixels between the container's right edge and
+     *  the right edge of the layout element.
+     * 
+     *  @default 0
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 1.5
+     *  @productversion Flex 4
+     */
+    public function get paddingRight():Number
+    {
+        return _paddingRight;
+    }
+
+    /**
+     *  @private
+     */
+    public function set paddingRight(value:Number):void
+    {
+        if (_paddingRight == value)
+            return;
+                               
+        _paddingRight = value;
+       // invalidateTargetSizeAndDisplayList();
+    }    
+    
+    //----------------------------------
+    //  paddingTop
+    //----------------------------------
+
+    private var _paddingTop:Number = 0;
+    
+    [Inspectable(category="General")]
+
+    /**
+     *  Number of pixels between the container's top edge
+     *  and the top edge of the first layout element.
+     * 
+     *  @default 0
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 1.5
+     *  @productversion Flex 4
+     */
+    public function get paddingTop():Number
+    {
+        return _paddingTop;
+    }
+
+    /**
+     *  @private
+     */
+    public function set paddingTop(value:Number):void
+    {
+        if (_paddingTop == value)
+            return;
+                               
+        _paddingTop = value;
+       // invalidateTargetSizeAndDisplayList();
+    }    
+    
+    //----------------------------------
+    //  paddingBottom
+    //----------------------------------
+
+    private var _paddingBottom:Number = 0;
+    
+    [Inspectable(category="General")]
+
+    /**
+     *  Number of pixels between the container's bottom edge
+     *  and the bottom edge of the last layout element.
+     * 
+     *  @default 0
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 1.5
+     *  @productversion Flex 4
+     */
+    public function get paddingBottom():Number
+    {
+        return _paddingBottom;
+    }
+
+    /**
+     *  @private
+     */
+    public function set paddingBottom(value:Number):void
+    {
+        if (_paddingBottom == value)
+            return;
+                               
+        _paddingBottom = value;
+      //  invalidateTargetSizeAndDisplayList();
+    }    
+    
+    //----------------------------------
+    //  requestedMaxRowCount
+    //----------------------------------
+    
+   /*  private var _requestedMaxRowCount:int = -1;
+    
+    [Inspectable(category="General", minValue="-1")] */
+    
+    /**
+     *  The measured height of this layout is large enough to display 
+     *  at most <code>requestedMaxRowCount</code> layout elements. 
+     * 
+     *  <p>If <code>requestedRowCount</code> is set, then
+     *  this property has no effect.</p>
+     *
+     *  <p>If the actual size of the container has been explicitly set,
+     *  then this property has no effect.</p>
+     *
+     *  @default -1
+     *  @see #requestedRowCount
+     *  @see #requestedMinRowCount
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 2.5
+     *  @productversion Flex 4.5
+     */
+   /*  public function get requestedMaxRowCount():int
+    {
+        return _requestedMaxRowCount;
+    } */
+    
+    /**
+     *  @private
+     */
+   /*  public function set requestedMaxRowCount(value:int):void
+    {
+        if (_requestedMaxRowCount == value)
+            return;
+        
+        _requestedMaxRowCount = value;
+        
+        if (target)
+            target.invalidateSize();
+    }    */ 
+    
+    //----------------------------------
+    //  requestedMinRowCount
+    //----------------------------------
+
+    private var _requestedMinRowCount:int = -1;
+    
+    [Inspectable(category="General", minValue="-1")]
+
+    /**
+     *  The measured height of this layout is large enough to display 
+     *  at least <code>requestedMinRowCount</code> layout elements. 
+     * 
+     *  <p>If <code>requestedRowCount</code> is set, then
+     *  this property has no effect.</p>
+     *
+     *  <p>If the actual size of the container has been explicitly set,
+     *  then this property has no effect.</p>
+     *
+     *  @default -1
+     *  @see #requestedRowCount
+     *  @see #requestedMaxRowCount
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 2.5
+     *  @productversion Flex 4.5
+     */
+    public function get requestedMinRowCount():int
+    {
+        return _requestedMinRowCount;
+    }
+
+    /**
+     *  @private
+     */
+    public function set requestedMinRowCount(value:int):void
+    {
+        if (_requestedMinRowCount == value)
+            return;
+                               
+        _requestedMinRowCount = value;
+
+        /* if (target)
+            target.invalidateSize(); */
+    }    
+
+    //----------------------------------
+    //  requestedRowCount
+    //----------------------------------
+    
+    /* private var _requestedRowCount:int = -1;
+    
+    [Inspectable(category="General", minValue="-1")] */
+    
+    /**
+     *  The measured size of this layout is tall enough to display 
+     *  the first <code>requestedRowCount</code> layout elements. 
+     * 
+     *  <p>If <code>requestedRowCount</code> is -1, then the measured
+     *  size will be big enough for all of the layout elements.</p>
+     * 
+     *  <p>If the actual size of the container has been explicitly set,
+     *  then this property has no effect.</p>
+     *
+     *  @default -1
+     *  @see #requestedMinRowCount
+     *  @see #requestedMaxRowCount
+     *
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 1.5
+     *  @productversion Flex 4
+     */
+    /* public function get requestedRowCount():int
+    {
+        return _requestedRowCount;
+    } */
+    
+    /**
+     *  @private
+     */
+    /* public function set requestedRowCount(value:int):void
+    {
+        if (_requestedRowCount == value)
+            return;
+        
+        _requestedRowCount = value;
+        
+        if (target)
+            target.invalidateSize();
+    }    */ 
+
+    //----------------------------------
+    //  rowHeight
+    //----------------------------------
+    
+    /* private var _rowHeight:Number;
+
+    [Inspectable(category="General", minValue="0.0")] */
+
+    /**
+     *  If <code>variableRowHeight</code> is <code>false</code>, then 
+     *  this property specifies the actual height of each child, in pixels.
+     * 
+     *  <p>If <code>variableRowHeight</code> is <code>true</code>, 
+     *  the default, then this property has no effect.</p>
+     * 
+     *  <p>The default value of this property is the preferred height
+     *  of the <code>typicalLayoutElement</code>.</p>
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 1.5
+     *  @productversion Flex 4
+     */
+    /* public function get rowHeight():Number
+    {
+        if (!isNaN(_rowHeight))
+            return _rowHeight;
+        else 
+        {
+            var elt:ILayoutElement = typicalLayoutElement
+            return (elt) ? elt.getPreferredBoundsHeight() : 0;
+        }
+    } */
+
+    /**
+     *  @private
+     */
+    /* public function set rowHeight(value:Number):void
+    {
+        if (_rowHeight == value)
+            return;
+            
+        _rowHeight = value;
+        invalidateTargetSizeAndDisplayList();
+    } */
+    
+    //----------------------------------
+    //  variableRowHeight
+    //----------------------------------
+
+    /**
+     *  @private
+     */
+    /* private var _variableRowHeight:Boolean = true;
+
+    [Inspectable(category="General", enumeration="true,false")] */
+
+    /**
+     *  Specifies whether layout elements are allocated their 
+     *  preferred height.
+     *  Setting this property to <code>false</code> specifies fixed height rows.
+     * 
+     *  <p>If <code>false</code>, the actual height of each layout element is 
+     *  the value of <code>rowHeight</code>.
+     *  Setting this property to <code>false</code> causes the layout to ignore 
+     *  the layout elements' <code>percentHeight</code> property.</p>
+     * 
+     *  @default true
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 1.5
+     *  @productversion Flex 4
+     */
+    /* public function get variableRowHeight():Boolean
+    {
+        return _variableRowHeight;
+    } */
+
+    /**
+     *  @private
+     */
+    /* public function set variableRowHeight(value:Boolean):void
+    {
+        if (value == _variableRowHeight) 
+            return;
+        
+        _variableRowHeight = value;
+        invalidateTargetSizeAndDisplayList();
+    } */
+    
+    //----------------------------------
+    //  firstIndexInView
+    //----------------------------------
+
+    /**
+     *  @private
+     */
+    /* private var _firstIndexInView:int = -1;
+
+    [Inspectable(category="General")]
+    [Bindable("indexInViewChanged")]    */ 
+
+    /**
+     *  The index of the first layout element that is part of the 
+     *  layout and within the layout target's scroll rectangle, or -1 
+     *  if nothing has been displayed yet.
+     *  
+     *  <p>"Part of the layout" means that the element is non-null
+     *  and that its <code>includeInLayout</code> property is <code>true</code>.</p>
+     * 
+     *  <p>Note that the layout element may only be partially in view.</p>
+     * 
+     *  @see fractionOfElementInView()
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 1.5
+     *  @productversion Flex 4
+     */
+    /* public function get firstIndexInView():int
+    {
+        return _firstIndexInView;
+    } */
+    
+    
+    //----------------------------------
+    //  lastIndexInView
+    //----------------------------------
+
+    /**
+     *  @private
+     */
+    /* private var _lastIndexInView:int = -1;
+    
+    [Inspectable(category="General")]
+    [Bindable("indexInViewChanged")]   */  
+
+    /**
+     *  The index of the last row that's part of the layout and within
+     *  the container's scroll rectangle, or -1 if nothing has been displayed yet.
+     * 
+     *  <p>"Part of the layout" means that the child is non-null
+     *  and that its <code>includeInLayout</code> property is <code>true</code>.</p>
+     * 
+     *  <p>Note that the row may only be partially in view.</p>
+     * 
+     *  @see firstIndexInView
+     *  @see fractionOfElementInView
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 1.5
+     *  @productversion Flex 4
+     */
+    /* public function get lastIndexInView():int
+    {
+        return _lastIndexInView;
+    } */
+
+    /**
+     *  Sets the <code>firstIndexInView</code> and <code>lastIndexInView</code>
+     *  properties and dispatches a <code>"indexInViewChanged"</code>
+     *  event.  
+     * 
+     *  @param firstIndex The new value for firstIndexInView.
+     *  @param lastIndex The new value for lastIndexInView.
+     * 
+     *  @see firstIndexInView
+     *  @see lastIndexInview
+     *  
+     *  @private
+     */
+    /* mx_internal function setIndexInView(firstIndex:int, lastIndex:int):void
+    {
+        if ((_firstIndexInView == firstIndex) && (_lastIndexInView == lastIndex))
+            return;
+            
+        _firstIndexInView = firstIndex;
+        _lastIndexInView = lastIndex;
+        dispatchEvent(new Event("indexInViewChanged"));
+    } */
+    
+    //--------------------------------------------------------------------------
+    //
+    //  Methods
+    //
+    //--------------------------------------------------------------------------
+    
+    /**
+     *  @private
+     */
+    /* override public function set clipAndEnableScrolling(value:Boolean):void
+    {
+        super.clipAndEnableScrolling = value;
+        var vAlign:String = verticalAlign;
+        if (vAlign == VerticalAlign.MIDDLE || vAlign == VerticalAlign.BOTTOM)
+        {
+            var g:GroupBase = target;
+            if (g)
+                g.invalidateDisplayList();
+        }
+    } */
+
+    /**
+     * @private
+     */
+    /* override public function clearVirtualLayoutCache():void
+    {
+        llv = null;
+
+        var g:GroupBase = GroupBase(target);
+        if (!g)
+            return;
+        
+        target.invalidateSize();
+        target.invalidateDisplayList();
+    }   */   
+
+    /**
+     *  @private
+     */
+    /* override public function getElementBounds(index:int):Rectangle
+    {
+        if (!useVirtualLayout)
+            return super.getElementBounds(index);
+
+        var g:GroupBase = GroupBase(target);
+        if (!g || (index < 0) || (index >= g.numElements) || !llv) 
+            return null;
+
+        // We need a valid LLV for this function
+        updateLLV(g);
+		
+        return llv.getBounds(index);
+    } */
+	
+    /**
+     *  Returns 1.0 if the specified index is completely in view, 0.0 if
+     *  it's not, or a value between 0.0 and 1.0 that represents the percentage 
+     *  of the if the index that is partially in view.
+     * 
+     *  <p>An index is "in view" if the corresponding non-null layout element is 
+     *  within the vertical limits of the container's <code>scrollRect</code>
+     *  and included in the layout.</p>
+     *  
+     *  <p>If the specified index is partially within the view, the 
+     *  returned value is the percentage of the corresponding
+     *  layout element that's visible.</p>
+     *
+     *  @param index The index of the row.
+     * 
+     *  @return The percentage of the specified element that's in view.
+     *  Returns 0.0 if the specified index is invalid or if it corresponds to
+     *  null element, or a ILayoutElement for which 
+     *  the <code>includeInLayout</code> property is <code>false</code>.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 1.5
+     *  @productversion Flex 4
+     */
+    /* public function fractionOfElementInView(index:int):Number 
+    {
+        var g:GroupBase = GroupBase(target);
+        if (!g)
+            return 0.0;
+            
+        if ((index < 0) || (index >= g.numElements))
+           return 0.0;
+           
+        if (!clipAndEnableScrolling)
+            return 1.0;
+
+           
+        var r0:int = firstIndexInView;  
+        var r1:int = lastIndexInView;
+        
+        // outside the visible index range
+        if ((r0 == -1) || (r1 == -1) || (index < r0) || (index > r1))
+            return 0.0;
+
+        // within the visible index range, but not first or last            
+        if ((index > r0) && (index < r1))
+            return 1.0;
+
+        // get the layout element's Y and Height
+        var eltY:Number;
+        var eltHeight:Number;
+        if (useVirtualLayout)
+        {
+            if (!llv)
+                return 0.0;
+            eltY = llv.start(index);
+            eltHeight = llv.getMajorSize(index);
+        }
+        else 
+        {
+            var elt:ILayoutElement = g.getElementAt(index);
+            if (!elt || !elt.includeInLayout)
+                return 0.0;
+            eltY = elt.getLayoutBoundsY();
+            eltHeight = elt.getLayoutBoundsHeight();
+        }
+            
+        // So, index is either the first or last row in the scrollRect
+        // and potentially partially visible.
+        //   y0,y1 - scrollRect top,bottom edges
+        //   iy0, iy1 - layout element top,bottom edges
+        var y0:Number = g.verticalScrollPosition;
+        var y1:Number = y0 + g.height;
+        var iy0:Number = eltY;
+        var iy1:Number = iy0 + eltHeight;
+        if (iy0 >= iy1)  // element has 0 or negative height
+            return 1.0;
+        if ((iy0 >= y0) && (iy1 <= y1))
+            return 1.0;
+        return (Math.min(y1, iy1) - Math.max(y0, iy0)) / (iy1 - iy0);
+    }
+     */
+    /**
+     *  @private
+     * 
+     *  Binary search for the first layout element that contains y.  
+     * 
+     *  This function considers both the element's actual bounds and 
+     *  the gap that follows it to be part of the element.  The search 
+     *  covers index i0 through i1 (inclusive).
+     *  
+     *  This function is intended for variable height elements.
+     * 
+     *  Returns the index of the element that contains y, or -1.
+     */
+    /* private static function findIndexAt(y:Number, gap:int, g:GroupBase, i0:int, i1:int):int
+    {
+        var index:int = (i0 + i1) / 2;
+        var element:ILayoutElement = g.getElementAt(index);     
+        var elementY:Number = element.getLayoutBoundsY();
+        var elementHeight:Number = element.getLayoutBoundsHeight();
+        // TBD: deal with null element, includeInLayout false.
+        if ((y >= elementY) && (y < elementY + elementHeight + gap))
+            return index;
+        else if (i0 == i1)
+            return -1;
+        else if (y < elementY)
+            return findIndexAt(y, gap, g, i0, Math.max(i0, index-1));
+        else 
+            return findIndexAt(y, gap, g, Math.min(index+1, i1), i1);
+    }  */
+    
+    /**
+     *  @private
+     * 
+     *  Returns the index of the first non-null includeInLayout element, 
+     *  beginning with the element at index i.  
+     * 
+     *  Returns -1 if no such element can be found.
+     */
+    /* private static function findLayoutElementIndex(g:GroupBase, i:int, dir:int):int
+    {
+        var n:int = g.numElements;
+        while((i >= 0) && (i < n))
+        {
+           var element:ILayoutElement = g.getElementAt(i);
+           if (element && element.includeInLayout)
+           {
+               return i;      
+           }
+           i += dir;
+        }
+        return -1;
+    } */
+
+    /**
+     *  @private
+     * 
+     *  Updates the first,lastIndexInView properties per the new
+     *  scroll position.
+     *  
+     *  @see setIndexInView
+     */
+    /* override protected function scrollPositionChanged():void
+    {
+        super.scrollPositionChanged();
+        
+        var g:GroupBase = target;
+        if (!g)
+            return;     
+
+        var n:int = g.numElements - 1;
+        if (n < 0) 
+        {
+            setIndexInView(-1, -1);
+            return;
+        }
+        
+        var scrollR:Rectangle = getScrollRect();
+        if (!scrollR)
+        {
+            setIndexInView(0, n);
+            return;    
+        }
+        
+        // We're going to use findIndexAt to find the index of 
+        // the elements that overlap the top and bottom edges of the scrollRect.
+        // Values that are exactly equal to scrollRect.bottom aren't actually
+        // rendered, since the top,bottom interval is only half open.
+        // To account for that we back away from the bottom edge by a
+        // hopefully infinitesimal amount.
+        
+        var y0:Number = scrollR.top;
+        var y1:Number = scrollR.bottom - .0001;
+        if (y1 <= y0)
+        {
+            setIndexInView(-1, -1);
+            return;
+        }
+        
+        if (useVirtualLayout && !llv)
+        {
+            setIndexInView(-1, -1);
+            return;
+        }
+
+        var i0:int;
+        var i1:int;
+        if (useVirtualLayout)
+        {
+            i0 = llv.indexOf(y0);
+            i1 = llv.indexOf(y1);
+        }
+        else
+        {
+            i0 = findIndexAt(y0 + gap, gap, g, 0, n);
+            i1 = findIndexAt(y1, gap, g, 0, n);
+        }
+        
+        // Special case: no element overlaps y0, is index 0 visible?
+        if (i0 == -1)
+        {   
+            var index0:int = findLayoutElementIndex(g, 0, +1);
+            if (index0 != -1)
+            {
+                var element0:ILayoutElement = g.getElementAt(index0); 
+                var element0Y:Number = element0.getLayoutBoundsY();
+                var elementHeight:Number = element0.getLayoutBoundsHeight();                 
+                if ((element0Y < y1) && ((element0Y + elementHeight) > y0))
+                    i0 = index0;
+            }
+        }
+
+        // Special case: no element overlaps y1, is index n visible?
+        if (i1 == -1)
+        {
+            var index1:int = findLayoutElementIndex(g, n, -1);
+            if (index1 != -1)
+            {
+                var element1:ILayoutElement = g.getElementAt(index1); 
+                var element1Y:Number = element1.getLayoutBoundsY();
+                var element1Height:Number = element1.getLayoutBoundsHeight();                 
+                if ((element1Y < y1) && ((element1Y + element1Height) > y0))
+                    i1 = index1;
+            }
+        }
+        
+        if (useVirtualLayout)
+        {
+            var firstElement:ILayoutElement = g.getElementAt(_firstIndexInView);
+            var lastElement:ILayoutElement = g.getElementAt(_lastIndexInView);
+            var scrollRect:Rectangle = getScrollRect();
+            
+            /* If the scrollRect is within the bounds of the elements, we do
+               not need to call invalidateDisplayList(). This considerably speeds
+               up small scrolls. */
+          /*  if (!firstElement || !lastElement || 
+                scrollRect.top < firstElement.getLayoutBoundsY() || 
+                scrollRect.bottom >= (lastElement.getLayoutBoundsY() + lastElement.getLayoutBoundsHeight()))
+            {
+                g.invalidateDisplayList();
+            }
+        }
+        
+        setIndexInView(i0, i1);
+    } */
+    
+    /**
+     *  @private
+     * 
+     *  Returns the actual position/size Rectangle of the first partially 
+     *  visible or not-visible, non-null includeInLayout element, beginning
+     *  with the element at index i, searching in direction dir (dir must
+     *  be +1 or -1).   The last argument is the GroupBase scrollRect, it's
+     *  guaranteed to be non-null.
+     * 
+     *  Returns null if no such element can be found.
+     */
+    /* private function findLayoutElementBounds(g:GroupBase, i:int, dir:int, r:Rectangle):Rectangle
+    {
+        var n:int = g.numElements;
+
+        if (fractionOfElementInView(i) >= 1)
+        {
+            // Special case: if we hit the first/last element, 
+            // then return the area of the padding so that we
+            // can scroll all the way to the start/end.
+            i += dir;
+            if (i < 0)
+                return new Rectangle(0, 0, 0, paddingTop);
+            if (i >= n)
+                return new Rectangle(0, getElementBounds(n-1).bottom, 0, paddingBottom);
+        }
+
+        while((i >= 0) && (i < n))
+        {
+           var elementR:Rectangle = getElementBounds(i);
+           // Special case: if the scrollRect r _only_ contains
+           // elementR, then if we're searching up (dir == -1),
+           // and elementR's top edge is visible, then try again
+           // with i-1.   Likewise for dir == +1.
+           if (elementR)
+           {
+               var overlapsTop:Boolean = (dir == -1) && (elementR.top == r.top) && (elementR.bottom >= r.bottom);
+               var overlapsBottom:Boolean = (dir == +1) && (elementR.bottom == r.bottom) && (elementR.top <= r.top);
+               if (!(overlapsTop || overlapsBottom))             
+                   return elementR;
+           }
+           i += dir;
+        }
+        return null;
+    } */
+
+    /**
+     *  @private 
+     */
+    /* override protected function getElementBoundsAboveScrollRect(scrollRect:Rectangle):Rectangle
+    {
+        return findLayoutElementBounds(target, firstIndexInView, -1, scrollRect);
+    }  */
+
+    /**
+     *  @private 
+     */
+    /* override protected function getElementBoundsBelowScrollRect(scrollRect:Rectangle):Rectangle
+    {
+        return findLayoutElementBounds(target, lastIndexInView, +1, scrollRect);
+    }  */
+    
+    /**
+     *  @private
+     *  Fills in the result with preferred and min sizes of the element.
+     */
+    /* private function getElementWidth(element:ILayoutElement, justify:Boolean, result:SizesAndLimit):void
+    {
+        // Calculate preferred width first, as it's being used to calculate min width
+        var elementPreferredWidth:Number = Math.ceil(element.getPreferredBoundsWidth());
+        
+        // Calculate min width
+        var flexibleWidth:Boolean = !isNaN(element.percentWidth) || justify;
+        var elementMinWidth:Number = flexibleWidth ? Math.ceil(element.getMinBoundsWidth()) : 
+                                                     elementPreferredWidth;
+        result.preferredSize = elementPreferredWidth;
+        result.minSize = elementMinWidth;
+    }
+     */
+    /**
+     *  @private
+     *  Fills in the result with preferred and min sizes of the element.
+     */
+    /* private function getElementHeight(element:ILayoutElement, fixedRowHeight:Number, result:SizesAndLimit):void
+    {
+        // Calculate preferred height first, as it's being used to calculate min height below
+        var elementPreferredHeight:Number = isNaN(fixedRowHeight) ? Math.ceil(element.getPreferredBoundsHeight()) :
+                                                                    fixedRowHeight;
+        // Calculate min height
+        var flexibleHeight:Boolean = !isNaN(element.percentHeight);
+        var elementMinHeight:Number = flexibleHeight ? Math.ceil(element.getMinBoundsHeight()) : 
+                                                       elementPreferredHeight;
+        result.preferredSize = elementPreferredHeight;
+        result.minSize = elementMinHeight;
+    } */
+
+    /**
+     *  @private
+     *  @return rows to measure based on elements in layout and any requested/min/max rowCount settings. 
+     */
+    /* mx_internal function getRowsToMeasure(numElementsInLayout:int):int
+    {
+        var rowsToMeasure:int;
+        if (requestedRowCount != -1)
+            rowsToMeasure = requestedRowCount;
+        else
+        {
+            rowsToMeasure = numElementsInLayout;
+            if (requestedMaxRowCount != -1)
+                rowsToMeasure = Math.min(requestedMaxRowCount, rowsToMeasure);
+            if (requestedMinRowCount != -1)
+                rowsToMeasure = Math.max(requestedMinRowCount, rowsToMeasure);
+        }
+        return rowsToMeasure;
+    } */
+
+    /**
+     *  @private
+     * 
+     *  Compute exact values for measuredWidth,Height and measuredMinWidth,Height.
+     * 
+     *  Measure each of the layout elements.  If requestedRowCount >= 0 we 
+     *  consider the height and width of as many layout elements, padding with 
+     *  typicalLayoutElement if needed, starting with index 0. We then only 
+     *  consider the width of the elements remaining.
+     * 
+     *  If requestedRowCount is -1, we measure all of the layout elements.
+     */
+    /* private function measureReal(layoutTarget:GroupBase):void
+    {
+        var size:SizesAndLimit = new SizesAndLimit();
+        var justify:Boolean = horizontalAlign == HorizontalAlign.JUSTIFY;
+        var numElements:int = layoutTarget.numElements; // How many elements there are in the target
+        var numElementsInLayout:int = numElements;      // How many elements have includeInLayout == true, start off with numElements.
+        var requestedRowCount:int = this.requestedRowCount;
+        var rowsMeasured:int = 0;                       // How many rows have been measured
+        
+        var preferredHeight:Number = 0; // sum of the elt preferred heights
+        var preferredWidth:Number = 0;  // max of the elt preferred widths
+        var minHeight:Number = 0;       // sum of the elt minimum heights
+        var minWidth:Number = 0;        // max of the elt minimum widths
+        
+        var fixedRowHeight:Number = NaN;
+        if (!variableRowHeight)
+            fixedRowHeight = rowHeight;  // may query typicalLayoutElement, elt at index=0
+        
+        // Get the numElementsInLayout clamped to requested min/max
+        var rowsToMeasure:int = getRowsToMeasure(numElementsInLayout);
+        var element:ILayoutElement;
+        for (var i:int = 0; i < numElements; i++)
+        {
+            element = layoutTarget.getElementAt(i);
+            if (!element || !element.includeInLayout)
+            {
+                numElementsInLayout--;
+                continue;
+            }
+            
+            // Can we measure this row height?
+            if (rowsMeasured < rowsToMeasure)
+            {
+                getElementHeight(element, fixedRowHeight, size);
+                preferredHeight += size.preferredSize;
+                minHeight += size.minSize;
+                rowsMeasured++;
+            }
+            
+            // Consider the width of each element, inclusive of those outside
+            // the requestedRowCount range.
+            getElementWidth(element, justify, size);
+            preferredWidth = Math.max(preferredWidth, size.preferredSize);
+            minWidth = Math.max(minWidth, size.minSize);
+        }
+        
+        // Calculate the total number of rows to measure again, since numElementsInLayout may have changed
+        rowsToMeasure = getRowsToMeasure(numElementsInLayout);
+
+        // Do we need to measure more rows?
+        if (rowsMeasured < rowsToMeasure)
+        {
+            // Use the typical element
+            element = typicalLayoutElement;
+            if (element)
+            {
+                // Height
+                getElementHeight(element, fixedRowHeight, size);
+                preferredHeight += size.preferredSize * (rowsToMeasure - rowsMeasured);
+                minHeight += size.minSize * (rowsToMeasure - rowsMeasured);
+    
+                // Width
+                getElementWidth(element, justify, size);
+                preferredWidth = Math.max(preferredWidth, size.preferredSize);
+                minWidth = Math.max(minWidth, size.minSize);
+                rowsMeasured = rowsToMeasure;
+            }
+        }
+
+        // Add gaps
+        if (rowsMeasured > 1)
+        { 
+            var vgap:Number = gap * (rowsMeasured - 1);
+            preferredHeight += vgap;
+            minHeight += vgap;
+        }
+        
+        var hPadding:Number = paddingLeft + paddingRight;
+        var vPadding:Number = paddingTop + paddingBottom;
+        
+        layoutTarget.measuredHeight = preferredHeight + vPadding;
+        layoutTarget.measuredWidth = preferredWidth + hPadding;
+        layoutTarget.measuredMinHeight = minHeight + vPadding;
+        layoutTarget.measuredMinWidth  = minWidth + hPadding;
+    } */
+    
+    /**
+     *  @private
+     *  Syncs the LinearLayoutVector llv with typicalLayoutElement and
+     *  the target's numElements.  Calling this function accounts
+     *  for the possibility that the typicalLayoutElement has changed, or
+     *  something that its preferred size depends on has changed.
+     */
+    /* private function updateLLV(layoutTarget:GroupBase):void
+    {
+        if (!llv)
+        {
+            llv = new LinearLayoutVector();
+            // Virtualization defaults for cases
+            // where there are no items and no typical item.
+            // The llv defaults are the width/height of a Spark Button skin.
+            llv.defaultMinorSize = 71;
+            llv.defaultMajorSize = 22;
+        }
+
+        var typicalElt:ILayoutElement = typicalLayoutElement;
+        if (typicalElt)
+        {
+            var typicalWidth:Number = typicalElt.getPreferredBoundsWidth();
+            var typicalHeight:Number = typicalElt.getPreferredBoundsHeight();
+            llv.defaultMinorSize = typicalWidth;
+            llv.defaultMajorSize = typicalHeight; 
+        }
+
+        if (!isNaN(_rowHeight))
+            llv.defaultMajorSize = _rowHeight;
+        
+        if (layoutTarget)
+            llv.length = layoutTarget.numElements;
+
+        llv.gap = gap;
+        llv.majorAxisOffset = paddingTop;
+    } */
+     
+    /**
+     *  @private
+     */
+     /* override public function elementAdded(index:int):void
+     {
+         if (llv && (index >= 0) && useVirtualLayout)
+            llv.insert(index);  // insert index parameter is uint
+     }*/ 
+
+    /**
+     *  @private
+     */
+    /* override public function elementRemoved(index:int):void
+     {
+        if (llv && (index >= 0) && useVirtualLayout)
+            llv.remove(index);  // remove index parameter is uint
+     }    */  
+
+    /**
+     *  @private
+     * 
+     *  Compute potentially approximate values for measuredWidth,Height and 
+     *  measuredMinWidth,Height.
+     * 
+     *  This method does not get layout elements from the target except
+     *  as a side effect of calling typicalLayoutElement.
+     * 
+     *  If variableRowHeight="false" then all dimensions are based on 
+     *  typicalLayoutElement and the sizes already cached in llv.  The 
+     *  llv's defaultMajorSize, minorSize, and minMinorSize 
+     *  are based on typicalLayoutElement.
+     */
+    /* private function measureVirtual(layoutTarget:GroupBase):void
+    {
+        var eltCount:int = layoutTarget.numElements;
+        var measuredEltCount:int = getRowsToMeasure(eltCount);
+        
+        var hPadding:Number = paddingLeft + paddingRight;
+        var vPadding:Number = paddingTop + paddingBottom;
+        
+        if (measuredEltCount <= 0)
+        {
+            layoutTarget.measuredWidth = layoutTarget.measuredMinWidth = hPadding;
+            layoutTarget.measuredHeight = layoutTarget.measuredMinHeight = vPadding;
+            return;
+        }        
+        
+        updateLLV(layoutTarget);     
+        if (variableRowHeight)
+        {
+            // Special case: fewer elements than requestedRowCount, so temporarily
+            // make llv.length == requestedRowCount.
+            var oldLength:int = -1;
+            if (measuredEltCount > llv.length)
+            {
+                oldLength = llv.length;
+                llv.length = measuredEltCount;
+            }   
+
+            // paddingTop is already taken into account as the majorAxisOffset of the llv   
+            // Measured size according to the cached actual size:
+            var measuredHeight:Number = llv.end(measuredEltCount - 1) + paddingBottom;
+            
+            // For the live ItemRenderers use the preferred size
+            // instead of the cached actual size:
+            var dataGroupTarget:DataGroup = layoutTarget as DataGroup;
+            if (dataGroupTarget)
+            {
+                var indices:Vector.<int> = dataGroupTarget.getItemIndicesInView();
+                for each (var i:int in indices)
+                {
+                    var element:ILayoutElement = dataGroupTarget.getElementAt(i);
+                    if (element)
+                    {
+                        measuredHeight -= llv.getMajorSize(i);
+                        measuredHeight += element.getPreferredBoundsHeight();
+                    }
+                }
+            }
+            
+            layoutTarget.measuredHeight = measuredHeight;
+            
+            if (oldLength != -1)
+                llv.length = oldLength;
+        }
+        else
+        {
+            var vgap:Number = (measuredEltCount > 1) ? (measuredEltCount - 1) * gap : 0;
+            layoutTarget.measuredHeight = (measuredEltCount * rowHeight) + vgap + vPadding;
+        }
+        layoutTarget.measuredWidth = llv.minorSize + hPadding;
+                
+        layoutTarget.measuredMinWidth = (horizontalAlign == HorizontalAlign.JUSTIFY) ? 
+                llv.minMinorSize + hPadding : layoutTarget.measuredWidth;
+        layoutTarget.measuredMinHeight = layoutTarget.measuredHeight;
+    } */
+
+    /**
+     *  @private
+     * 
+     *  If requestedRowCount is specified then as many layout elements
+     *  or "rows" are measured, starting with element 0, otherwise all of the 
+     *  layout elements are measured.
+     *  
+     *  If requestedRowCount is specified and is greater than the
+     *  number of layout elements, then the typicalLayoutElement is used
+     *  in place of the missing layout elements.
+     * 
+     *  If variableRowHeight="true", then the layoutTarget's measuredHeight 
+     *  is the sum of preferred heights of the layout elements, plus the sum of the
+     *  gaps between elements, and its measuredWidth is the max of the elements' 
+     *  preferred widths.
+     * 
+     *  If variableRowHeight="false", then the layoutTarget's measuredHeight 
+     *  is rowHeight multiplied by the number or layout elements, plus the 
+     *  sum of the gaps between elements.
+     * 
+     *  The layoutTarget's measuredMinHeight is the sum of the minHeights of 
+     *  layout elements that have specified a value for the percentHeight
+     *  property, and the preferredHeight of the elements that have not, 
+     *  plus the sum of the gaps between elements.
+     * 
+     *  The difference reflects the fact that elements which specify 
+     *  percentHeight are considered to be "flexible" and updateDisplayList 
+     *  will give flexible components at least their minHeight.  
+     * 
+     *  Layout elements that aren't flexible always get their preferred height.
+     * 
+     *  The layoutTarget's measuredMinWidth is the max of the minWidths for 
+     *  elements that have specified percentWidth (that are "flexible") and the 
+     *  preferredWidth of the elements that have not.
+     * 
+     *  As before the difference is due to the fact that flexible items are only
+     *  guaranteed their minWidth.
+     */
+    /* override public function measure():void
+    {
+        var layoutTarget:GroupBase = target;
+        if (!layoutTarget)
+            return;
+            
+        if (useVirtualLayout)
+            measureVirtual(layoutTarget);
+        else 
+            measureReal(layoutTarget);
+            
+        // Use Math.ceil() to make sure that if the content partially occupies
+        // the last pixel, we'll count it as if the whole pixel is occupied.
+        layoutTarget.measuredWidth = Math.ceil(layoutTarget.measuredWidth);    
+        layoutTarget.measuredHeight = Math.ceil(layoutTarget.measuredHeight);    
+        layoutTarget.measuredMinWidth = Math.ceil(layoutTarget.measuredMinWidth);    
+        layoutTarget.measuredMinHeight = Math.ceil(layoutTarget.measuredMinHeight);    
+    } */
+    
+    /**
+     *  @private 
+     */  
+    /* override public function getNavigationDestinationIndex(currentIndex:int, navigationUnit:uint, arrowKeysWrapFocus:Boolean):int
+    {
+        if (!target || target.numElements < 1)
+            return -1; 
+
+        var maxIndex:int = target.numElements - 1;
+
+        // Special case when nothing was previously selected
+        if (currentIndex == -1)
+        {
+            if (navigationUnit == NavigationUnit.UP)
+                return arrowKeysWrapFocus ? maxIndex : -1;
+            if (navigationUnit == NavigationUnit.DOWN)
+                return 0;    
+        }    
+            
+        // Make sure currentIndex is within range
+        currentIndex = Math.max(0, Math.min(maxIndex, currentIndex));
+
+        var newIndex:int; 
+        var bounds:Rectangle;
+        var y:Number;
+
+        switch (navigationUnit)
+        {
+            case NavigationUnit.UP:
+            {
+               if (arrowKeysWrapFocus && currentIndex == 0)
+                   newIndex = maxIndex;
+               else
+                   newIndex = currentIndex - 1;  
+               break;
+            } 
+
+            case NavigationUnit.DOWN: 
+            {
+               if (arrowKeysWrapFocus && currentIndex == maxIndex)
+                   newIndex = 0;
+               else
+                   newIndex = currentIndex + 1;  
+               break;
+            }
+             
+            case NavigationUnit.PAGE_UP:
+            {
+                // Find the first fully visible element
+                var firstVisible:int = firstIndexInView;
+                var firstFullyVisible:int = firstVisible;
+                if (fractionOfElementInView(firstFullyVisible) < 1)
+                    firstFullyVisible += 1;
+                 
+                // Is the current element in the middle of the viewport?
+                if (firstFullyVisible < currentIndex && currentIndex <= lastIndexInView)
+                    newIndex = firstFullyVisible;
+                else
+                {
+                    // Find an element that's one page up
+                    if (currentIndex == firstFullyVisible || currentIndex == firstVisible)
+                    {
+                        // currentIndex is visible, we can calculate where the scrollRect top
+                        // would end up if we scroll by a page                    
+                        y = getVerticalScrollPositionDelta(NavigationUnit.PAGE_UP) + getScrollRect().top;
+                    }
+                    else
+                    {
+                        // currentIndex is not visible, just find an element a page up from currentIndex
+                        y = getElementBounds(currentIndex).bottom - getScrollRect().height;
+                    }
+
+                    // Find the element after the last element that spans above the y position
+                    newIndex = currentIndex - 1;
+                    while (0 <= newIndex)
+                    {
+                        bounds = getElementBounds(newIndex);
+                        if (bounds && bounds.top < y)
+                        {
+                            // This element spans the y position, so return the next one
+                            newIndex = Math.min(currentIndex - 1, newIndex + 1);
+                            break;
+                        }
+                        newIndex--;    
+                    }
+                }
+                break;
+            }
+
+            case NavigationUnit.PAGE_DOWN:
+            {
+                // Find the last fully visible element:
+                var lastVisible:int = lastIndexInView;
+                var lastFullyVisible:int = lastVisible;
+                if (fractionOfElementInView(lastFullyVisible) < 1)
+                    lastFullyVisible -= 1;
+                
+                // Is the current element in the middle of the viewport?
+                if (firstIndexInView <= currentIndex && currentIndex < lastFullyVisible)
+                    newIndex = lastFullyVisible;
+                else
+                {
+                    // Find an element that's one page down
+                    if (currentIndex == lastFullyVisible || currentIndex == lastVisible)
+                    {
+                        // currentIndex is visible, we can calculate where the scrollRect bottom
+                        // would end up if we scroll by a page                    
+                        y = getVerticalScrollPositionDelta(NavigationUnit.PAGE_DOWN) + getScrollRect().bottom;
+                    }
+                    else
+                    {
+                        // currentIndex is not visible, just find an element a page down from currentIndex
+                        y = getElementBounds(currentIndex).top + getScrollRect().height;
+                    }
+
+                    // Find the element before the first element that spans below the y position
+                    newIndex = currentIndex + 1;
+                    while (newIndex <= maxIndex)
+                    {
+                        bounds = getElementBounds(newIndex);
+                        if (bounds && bounds.bottom > y)
+                        {
+                            // This element spans the y position, so return the previous one
+                            newIndex = Math.max(currentIndex + 1, newIndex - 1);
+                            break;
+                        }
+                        newIndex++;    
+                    }
+                }
+                break;
+            }
+
+            default: return super.getNavigationDestinationIndex(currentIndex, navigationUnit, arrowKeysWrapFocus);
+        }
+        return Math.max(0, Math.min(maxIndex, newIndex));  
+    } */
+    
+    /**
+     *  @private
+     * 
+     *  Used only for virtual layout.
+     */
+    /* private function calculateElementWidth(elt:ILayoutElement, targetWidth:Number, containerWidth:Number):Number
+    {
+       // If percentWidth is specified then the element's width is the percentage
+       // of targetWidth clipped to min/maxWidth and to (upper limit) targetWidth.
+       var percentWidth:Number = elt.percentWidth;
+       if (!isNaN(percentWidth))
+       {
+          var width:Number = percentWidth * 0.01 * targetWidth;
+          return Math.min(targetWidth, Math.min(elt.getMaxBoundsWidth(), Math.max(elt.getMinBoundsWidth(), width)));
+       }
+       switch(horizontalAlign)
+       {
+           case HorizontalAlign.JUSTIFY: 
+               return targetWidth;
+           case HorizontalAlign.CONTENT_JUSTIFY: 
+               return Math.max(elt.getPreferredBoundsWidth(), containerWidth);
+       }
+       return NaN;  // not constrained
+    } */
+    
+    /**
+     *  @private
+     * 
+     *  Used only for virtual layout.
+     */
+    /* private function calculateElementX(elt:ILayoutElement, eltWidth:Number, containerWidth:Number):Number
+    {
+       switch(horizontalAlign)
+       {
+           case HorizontalAlign.CENTER: 
+               return Math.round((containerWidth - eltWidth) * 0.5);
+           case HorizontalAlign.RIGHT: 
+               return containerWidth - eltWidth;
+       }
+       return 0;  // HorizontalAlign.LEFT
+    } */
+
+
+    /**
+     *  @private
+     * 
+     *  Update the layout of the virtualized elements that overlap
+     *  the scrollRect's vertical extent.
+     *
+     *  The height of each layout element will be its preferred height, and its
+     *  y will be the bottom of the previous item, plus the gap.
+     * 
+     *  No support for percentHeight, includeInLayout=false, or null layoutElements,
+     * 
+     *  The width of each layout element will be set to its preferred width, unless
+     *  one of the following is true:
+     * 
+     *  - If percentWidth is specified for this element, then its width will be the
+     *  specified percentage of the target's actual (unscaled) width, clipped 
+     *  the layout element's minimum and maximum width.
+     * 
+     *  - If horizontalAlign is "justify", then the element's width will
+     *  be set to the target's actual (unscaled) width.
+     * 
+     *  - If horizontalAlign is "contentJustify", then the element's width
+     *  will be set to the larger of the target's width and its content width.
+     * 
+     *  The X coordinate of each layout element will be set to 0 unless one of the
+     *  following is true:
+     * 
+     *  - If horizontalAlign is "center" then x is set so that the element's preferred
+     *  width is centered within the larger of the contentWidth, target width:
+     *      x = (Math.max(contentWidth, target.width) - layoutElementWidth) * 0.5
+     * 
+     *  - If horizontalAlign is "right" the x is set so that the element's right
+     *  edge is aligned with the the right edge of the content:
+     *      x = (Math.max(contentWidth, target.width) - layoutElementWidth)
+     * 
+     *  Implementation note: unless horizontalAlign is either "justify" or 
+     *  "left", the layout elements' x or width depends on the contentWidth.
+     *  The contentWidth is a maximum and although it may be updated to 
+     *  different value after all (viewable) elements have been laid out, it
+     *  often does not change.  For that reason we use the current contentWidth
+     *  for the initial layout and then, if it has changed, we loop through 
+     *  the layout items again and fix up the x/width values.
+     */
+    /* private function updateDisplayListVirtual():void
+    {
+        var layoutTarget:GroupBase = target; 
+        var eltCount:int = layoutTarget.numElements;
+        var targetWidth:Number = Math.max(0, layoutTarget.width - paddingLeft - paddingRight);
+        var minVisibleY:Number = layoutTarget.verticalScrollPosition;
+        var maxVisibleY:Number = minVisibleY + layoutTarget.height;
+       
+		var contentHeight:Number;
+		var paddedContentHeight:Number;
+		
+		updateLLV(layoutTarget);
+        
+        // Find the index of the first visible item. Since the item's bounds includes the gap
+        // that follows it, we want to avoid looking at an item that has only a portion of
+        // its gap intersecting with the visible region.
+        // We have to also be careful, as gap could be negative and in that case, we should
+        // simply start from minVisibleY - SDK-22497.
+        var startIndex:int = llv.indexOf(Math.max(0, minVisibleY + gap));
+        if (startIndex == -1)
+		{
+			// No items are visible.  Just set the content size.
+			contentHeight = llv.end(llv.length - 1) - paddingTop;
+			paddedContentHeight = Math.ceil(contentHeight + paddingTop + paddingBottom);
+			layoutTarget.setContentSize(layoutTarget.contentWidth, paddedContentHeight);
+			return;
+		}
+                        
+        var fixedRowHeight:Number = NaN;
+        if (!variableRowHeight)
+            fixedRowHeight = rowHeight;  // may query typicalLayoutElement, elt at index=0
+        
+        var justifyWidths:Boolean = horizontalAlign == HorizontalAlign.JUSTIFY;
+        var eltWidth:Number = (justifyWidths) ? targetWidth : NaN;
+        var eltHeight:Number = NaN;  
+        var contentWidth:Number = (justifyWidths) ? Math.max(llv.minMinorSize, targetWidth) : llv.minorSize;
+        var containerWidth:Number = Math.max(contentWidth, targetWidth);        
+        var y:Number = llv.start(startIndex);
+        var index:int = startIndex;
+        var x0:Number = paddingLeft;
+        
+        // First pass: compute element x,y,width,height based on 
+        // current contentWidth; cache computed widths/heights in llv.
+        for (; (y < maxVisibleY) && (index < eltCount); index++)
+        {
+            var elt:ILayoutElement = layoutTarget.getVirtualElementAt(index, eltWidth, eltHeight);
+            var w:Number = calculateElementWidth(elt, targetWidth, containerWidth); // can be NaN
+            var h:Number = fixedRowHeight; // NaN for variable height rows
+            elt.setLayoutBoundsSize(w, h);
+            w = elt.getLayoutBoundsWidth();        
+            h = elt.getLayoutBoundsHeight();            
+            var x:Number = x0 + calculateElementX(elt, w, containerWidth);
+            elt.setLayoutBoundsPosition(x, y);
+            llv.cacheDimensions(index, elt);
+            y += h + gap;
+        }
+        var endIndex:int = index - 1;
+
+        // Second pass: if neccessary, fix up x and width values based
+        // on the updated contentWidth
+        if (!justifyWidths && (llv.minorSize != contentWidth))
+        {
+            contentWidth = llv.minorSize;
+            containerWidth = Math.max(contentWidth, targetWidth);            
+            if (horizontalAlign != HorizontalAlign.LEFT)
+            {
+                for (index = startIndex; index <= endIndex; index++)
+                {
+                    elt = layoutTarget.getElementAt(index);
+                    w = calculateElementWidth(elt, targetWidth, containerWidth);  // can be NaN
+                    elt.setLayoutBoundsSize(w, elt.getLayoutBoundsHeight());
+                    w = elt.getLayoutBoundsWidth();
+                    x = x0 + calculateElementX(elt, w, containerWidth);
+                    elt.setLayoutBoundsPosition(x, elt.getLayoutBoundsY());
+                }
+            }
+        }
+        
+        // Third pass: if neccessary, fix up y based on updated contentHeight
+		contentHeight = llv.end(llv.length - 1) - paddingTop;
+        var targetHeight:Number = Math.max(0, layoutTarget.height - paddingTop - paddingBottom);
+        if (contentHeight < targetHeight)
+        {
+            var excessHeight:Number = targetHeight - contentHeight;
+            var dy:Number = 0;
+            var vAlign:String = verticalAlign;
+            if (vAlign == VerticalAlign.MIDDLE)
+            {
+                dy = Math.round(excessHeight / 2);   
+            }
+            else if (vAlign == VerticalAlign.BOTTOM)
+            {
+                dy = excessHeight;
+            }
+            if (dy > 0)
+            {
+                for (index = startIndex; index <= endIndex; index++)
+                {
+                    elt = layoutTarget.getElementAt(index);
+                    elt.setLayoutBoundsPosition(elt.getLayoutBoundsX(), dy + elt.getLayoutBoundsY());
+                }
+                contentHeight += dy;
+            }
+        }
+
+        setRowCount(index - startIndex);
+        setIndexInView(startIndex, endIndex);
+        
+        // Make sure that if the content spans partially over a pixel to the right/bottom,
+        // the content size includes the whole pixel.
+        var paddedContentWidth:Number = Math.ceil(contentWidth + paddingLeft + paddingRight);
+		paddedContentHeight = Math.ceil(contentHeight + paddingTop + paddingBottom);
+        layoutTarget.setContentSize(paddedContentWidth, paddedContentHeight);
+    } */
+    
+
+    /**
+     *  @private
+     */
+    /* private function updateDisplayListReal():void
+    {
+        var layoutTarget:GroupBase = target;
+        var targetWidth:Number = Math.max(0, layoutTarget.width - paddingLeft - paddingRight);
+        var targetHeight:Number = Math.max(0, layoutTarget.height - paddingTop - paddingBottom);
+        
+        var layoutElement:ILayoutElement;
+        var count:int = layoutTarget.numElements;
+        
+        // If horizontalAlign is left, we don't need to figure out the contentWidth
+        // Otherwise the contentWidth is used to position the element and even size 
+        // the element if it's "contentJustify" or "justify".
+        var containerWidth:Number = targetWidth;        
+        if (horizontalAlign == HorizontalAlign.CONTENT_JUSTIFY ||
+           (clipAndEnableScrolling && (horizontalAlign == HorizontalAlign.CENTER ||
+                                       horizontalAlign == HorizontalAlign.RIGHT))) 
+        {
+            for (var i:int = 0; i < count; i++)
+            {
+                layoutElement = layoutTarget.getElementAt(i);
+                if (!layoutElement || !layoutElement.includeInLayout)
+                    continue;
+
+                var layoutElementWidth:Number;
+                if (!isNaN(layoutElement.percentWidth))
+                    layoutElementWidth = calculatePercentWidth(layoutElement, targetWidth);
+                else
+                    layoutElementWidth = layoutElement.getPreferredBoundsWidth();
+                
+                containerWidth = Math.max(containerWidth, Math.ceil(layoutElementWidth));
+            }
+        }
+
+        var excessHeight:Number = distributeHeight(targetWidth, targetHeight, containerWidth);
+        
+        // default to left (0)
+        var hAlign:Number = 0;
+        if (horizontalAlign == HorizontalAlign.CENTER)
+            hAlign = .5;
+        else if (horizontalAlign == HorizontalAlign.RIGHT)
+            hAlign = 1;
+        
+        // As the layoutElements are positioned, we'll count how many rows 
+        // fall within the layoutTarget's scrollRect
+        var visibleRows:uint = 0;
+        var minVisibleY:Number = layoutTarget.verticalScrollPosition;
+        var maxVisibleY:Number = minVisibleY + targetHeight;
+        
+        // Finally, position the layoutElements and find the first/last
+        // visible indices, the content size, and the number of 
+        // visible elements.    
+        var x0:Number = paddingLeft;
+        var y:Number = paddingTop;
+        var maxX:Number = paddingLeft;
+        var maxY:Number = paddingTop;
+        var firstRowInView:int = -1;
+        var lastRowInView:int = -1;
+        
+        // Take verticalAlign into account
+        if (excessHeight > 0 || !clipAndEnableScrolling)
+        {
+            var vAlign:String = verticalAlign;
+            if (vAlign == VerticalAlign.MIDDLE)
+            {
+                y = paddingTop + Math.round(excessHeight / 2);   
+            }
+            else if (vAlign == VerticalAlign.BOTTOM)
+            {
+                y = paddingTop + excessHeight;   
+            }
+        }
+
+        for (var index:int = 0; index < count; index++)
+        {
+            layoutElement = layoutTarget.getElementAt(index);
+            if (!layoutElement || !layoutElement.includeInLayout)
+                continue;
+                
+            // Set the layout element's position
+            var dx:Number = Math.ceil(layoutElement.getLayoutBoundsWidth());
+            var dy:Number = Math.ceil(layoutElement.getLayoutBoundsHeight());
+
+            var x:Number = x0 + (containerWidth - dx) * hAlign;
+            // In case we have HorizontalAlign.CENTER we have to round
+            if (hAlign == 0.5)
+                x = Math.round(x);
+            layoutElement.setLayoutBoundsPosition(x, y);
+                            
+            // Update maxX,Y, first,lastVisibleIndex, and y
+            maxX = Math.max(maxX, x + dx);
+            maxY = Math.max(maxY, y + dy);
+            if (!clipAndEnableScrolling ||
+                ((y < maxVisibleY) && ((y + dy) > minVisibleY)) || 
+                ((dy <= 0) && ((y == maxVisibleY) || (y == minVisibleY))))
+            {
+                visibleRows += 1;
+                if (firstRowInView == -1)
+                   firstRowInView = lastRowInView = index;
+                else
+                   lastRowInView = index;
+            }
+            y += dy + gap;
+        }
+        
+        setRowCount(visibleRows);
+        setIndexInView(firstRowInView, lastRowInView);
+        
+        // Make sure that if the content spans partially over a pixel to the right/bottom,
+        // the content size includes the whole pixel.
+        layoutTarget.setContentSize(Math.ceil(maxX + paddingRight),
+                                    Math.ceil(maxY + paddingBottom));
+    } */
+    
+    /**
+     *  @private
+     * 
+     *  This function sets the height of each child
+     *  so that the heights add up to <code>height</code>. 
+     *  Each child is set to its preferred height
+     *  if its percentHeight is zero.
+     *  If its percentHeight is a positive number,
+     *  the child grows (or shrinks) to consume its
+     *  share of extra space.
+     *  
+     *  The return value is any extra space that's left over
+     *  after growing all children to their maxHeight.
+     */
+    /* private function distributeHeight(width:Number, 
+                                      height:Number, 
+                                      restrictedWidth:Number):Number
+    {
+        var spaceToDistribute:Number = height;
+        var totalPercentHeight:Number = 0;
+        var childInfoArray:Array = [];
+        var childInfo:LayoutElementFlexChildInfo;
+        var layoutElement:ILayoutElement;
+        
+        // rowHeight can be expensive to compute
+        var rh:Number = (variableRowHeight) ? 0 : Math.ceil(rowHeight);
+        var count:int = target.numElements;
+        var totalCount:int = count; // number of elements to use in gap calculation
+        
+        // If the child is flexible, store information about it in the
+        // childInfoArray. For non-flexible children, just set the child's
+        // width and height immediately.
+        for (var index:int = 0; index < count; index++)
+        {
+            layoutElement = target.getElementAt(index);
+            if (!layoutElement || !layoutElement.includeInLayout)
+            {
+                totalCount--;
+                continue;
+            }
+            
+            if (!isNaN(layoutElement.percentHeight) && variableRowHeight)
+            {
+                totalPercentHeight += layoutElement.percentHeight;
+
+                childInfo = new LayoutElementFlexChildInfo();
+                childInfo.layoutElement = layoutElement;
+                childInfo.percent    = layoutElement.percentHeight;
+                childInfo.min        = layoutElement.getMinBoundsHeight();
+                childInfo.max        = layoutElement.getMaxBoundsHeight();
+                
+                childInfoArray.push(childInfo);                
+            }
+            else
+            {
+                sizeLayoutElement(layoutElement, width, horizontalAlign, 
+                               restrictedWidth, NaN, variableRowHeight, rh);
+                
+                spaceToDistribute -= Math.ceil(layoutElement.getLayoutBoundsHeight());
+            } 
+        }
+        
+        if (totalCount > 1)
+            spaceToDistribute -= (totalCount-1) * gap;
+
+        // Distribute the extra space among the flexible children
+        if (totalPercentHeight)
+        {
+            Flex.flexChildrenProportionally(height,
+                                            spaceToDistribute,
+                                            totalPercentHeight,
+                                            childInfoArray);
+
+            var roundOff:Number = 0;            
+            for each (childInfo in childInfoArray)
+            {
+                // Make sure the calculated percentages are rounded to pixel boundaries
+                var childSize:int = Math.round(childInfo.size + roundOff);
+                roundOff += childInfo.size - childSize;
+
+                sizeLayoutElement(childInfo.layoutElement, width, horizontalAlign, 
+                               restrictedWidth, childSize, 
+                               variableRowHeight, rh);
+                spaceToDistribute -= childSize;
+            }
+        }
+        return spaceToDistribute;
+    } */
+    
+    /**
+     *  @private
+     */
+    /* override public function updateDisplayList(unscaledWidth:Number, unscaledHeight:Number):void
+    {
+        super.updateDisplayList(unscaledWidth, unscaledHeight);
+        
+        var layoutTarget:GroupBase = target; 
+        if (!layoutTarget)
+            return;
+            
+        if ((layoutTarget.numElements == 0) || (unscaledWidth == 0) || (unscaledHeight == 0))
+        {
+            setRowCount(0);
+            setIndexInView(-1, -1);
+            if (layoutTarget.numElements == 0)
+                layoutTarget.setContentSize(Math.ceil(paddingLeft + paddingRight),
+                                            Math.ceil(paddingTop + paddingBottom));
+            return;         
+        }
+        
+        if (useVirtualLayout) 
+            updateDisplayListVirtual();
+        else
+            updateDisplayListReal();
+    } */
+    
+    /**
+     *  @private 
+     *  Convenience function for subclasses that invalidates the
+     *  target's size and displayList so that both layout's <code>measure()</code>
+     *  and <code>updateDisplayList</code> methods get called.
+     * 
+     *  <p>Typically a layout invalidates the target's size and display list so that
+     *  it gets a chance to recalculate the target's default size and also size and
+     *  position the target's elements. For example changing the <code>gap</code>
+     *  property on a <code>VerticalLayout</code> will internally call this method
+     *  to ensure that the elements are re-arranged with the new setting and the
+     *  target's default size is recomputed.</p> 
+     */
+    /* private function invalidateTargetSizeAndDisplayList():void
+    {
+        var g:GroupBase = target;
+        if (!g)
+            return;
+
+        g.invalidateSize();
+        g.invalidateDisplayList();
+    } */
+        
+    //--------------------------------------------------------------------------
+    //
+    //  Drop methods
+    //
+    //--------------------------------------------------------------------------
+
+    /**
+     *  @private 
+     */
+    /* override protected function calculateDropIndex(x:Number, y:Number):int
+    {
+        // Iterate over the visible elements
+        var layoutTarget:GroupBase = target;
+        var count:int = layoutTarget.numElements;
+
+        // If there are no items, insert at index 0
+        if (count == 0)
+            return 0;
+
+        // Go through the visible elements
+        var minDistance:Number = Number.MAX_VALUE;
+        var bestIndex:int = -1;
+        var start:int = this.firstIndexInView;
+        var end:int = this.lastIndexInView;
+        
+        for (var i:int = start; i <= end; i++)
+        {
+            var elementBounds:Rectangle = this.getElementBounds(i);
+            if (!elementBounds)
+                continue;
+            
+            if (elementBounds.top <= y && y <= elementBounds.bottom)
+            {
+                var centerY:Number = elementBounds.y + elementBounds.height / 2;
+                return (y < centerY) ? i : i + 1;
+            }
+
+            var curDistance:Number = Math.min(Math.abs(y - elementBounds.top),
+                                              Math.abs(y - elementBounds.bottom));
+            if (curDistance < minDistance)
+            {
+                minDistance = curDistance;
+                bestIndex = (y < elementBounds.top) ? i : i + 1;
+            }
+        }
+
+        // If there are no visible elements, either pick to drop at the beginning or at the end
+        if (bestIndex == -1)
+            bestIndex = getElementBounds(0).y < y ? count : 0;
+
+        return bestIndex;
+    } */
+
+    /**
+     *  @private
+     */
+    /* override protected function calculateDropIndicatorBounds(dropLocation:DropLocation):Rectangle
+    {
+        var dropIndex:int = dropLocation.dropIndex;
+        var count:int = target.numElements;
+        var gap:Number = this.gap;
+
+        // Special case, if we insert at the end, and the gap is negative, consider it to be zero
+        if (gap < 0 && dropIndex == count)
+            gap = 0;
+            
+        var emptySpace:Number = (0 < gap ) ? gap : 0; 
+        var emptySpaceTop:Number = 0;
+        if (target.numElements > 0)
+        {
+            emptySpaceTop = (dropIndex < count) ? getElementBounds(dropIndex).top - emptySpace : 
+                                                  getElementBounds(dropIndex - 1).bottom + gap - emptySpace;
+        }
+                                        
+        // Calculate the size of the bounds, take minium and maximum into account
+        var width:Number = Math.max(target.width, target.contentWidth) - paddingLeft - paddingRight;
+        var height:Number = emptySpace;
+        if (dropIndicator is IVisualElement)
+        {
+            var element:IVisualElement = IVisualElement(dropIndicator);
+            height = Math.max(Math.min(height, element.getMaxBoundsHeight(false)), element.getMinBoundsHeight(false));
+        }
+        
+        var x:Number = paddingLeft;
+
+        var y:Number = emptySpaceTop + Math.round((emptySpace - height)/2);
+        // Allow 1 pixel overlap with container border
+        y = Math.max(-1, Math.min(target.contentHeight - height + 1, y));
+        return new Rectangle(x, y, width, height);
+    } */
+    
+    /**
+     *  @private
+     */
+    /* override protected function calculateDragScrollDelta(dropLocation:DropLocation,
+                                                         elapsedTime:Number):Point
+    {
+        var delta:Point = super.calculateDragScrollDelta(dropLocation, elapsedTime);
+        // Don't scroll in the horizontal direction
+        if (delta)
+            delta.x = 0;
+        return delta;
+    } */
+
+    /**
+     *  @private
+     *  Identifies the element which has its "compare point" located closest 
+     *  to the specified position.
+     */
+    /* override mx_internal function getElementNearestScrollPosition(
+        position:Point,
+        elementComparePoint:String = "center"):int
+    {
+        if (!useVirtualLayout)
+            return super.getElementNearestScrollPosition(position, elementComparePoint);
+
+        var g:GroupBase = GroupBase(target);
+        if (!g)
+            return -1;
+        
+        // We need a valid LLV for this function
+        updateLLV(g);
+        
+        // Find the element which overlaps with the position
+        var index:int = llv.indexOf(position.y);
+        
+        // Invalid index indicates that the position is past either end of the 
+        // laid-out elements.   In this case, choose either the first or last one.
+        if (index == -1)
+            index = position.y < 0 ? 0 : g.numElements - 1; 
+
+        var bounds:Rectangle = llv.getBounds(index);
+        var adjacentBounds:Rectangle;
+        
+        // If we're comparing with a bottom-edge point, check both the current element and the element
+        // at index-1 to see which is closest.
+        if ((elementComparePoint == "bottomLeft" || elementComparePoint == "bottomRight") && index > 0)
+        {
+            adjacentBounds = llv.getBounds(index - 1);
+            if (Point.distance(position,adjacentBounds.bottomRight) < Point.distance(position,bounds.bottomRight))
+                index--;
+        }
+        
+        // If we're comparing with a top-edge point, check both the current element and the element
+        // at index+1 to see which is closest.
+        if ((elementComparePoint == "topLeft" || elementComparePoint == "topRight") && index < g.numElements-1) 
+        {
+            adjacentBounds = llv.getBounds(index + 1);             
+            if (Point.distance(position,adjacentBounds.topLeft) < Point.distance(position,bounds.topLeft))
+                index++;
+        }
+        
+        return index;
+    } */
+
+
+}
+}
+
+/* import mx.containers.utilityClasses.FlexChildInfo;
+import mx.core.ILayoutElement;
+
+class LayoutElementFlexChildInfo extends FlexChildInfo
+{
+    public var layoutElement:ILayoutElement;    
+}
+
+class SizesAndLimit
+{
+    public var preferredSize:Number;
+    public var minSize:Number;
+} */
+    
+    
+    

-- 
To stop receiving notification emails like this one, please contact
alinakazi@apache.org.

Mime
View raw message