         super.validateSize(recursive);
     }   
     
+    /**
+     *  @private
+     */
     override protected function updateDisplayList(unscaledWidth:Number, unscaledHeight:Number):void
     {
         super.updateDisplayList(unscaledWidth, unscaledHeight);

    //  is the item itself. For data items, the layout item is the item renderer
    //  instance that is associated with the item.
    //--------------------------------------------------------------------------
     /**
     *  The number of layout items in this Group. Typically this is the same
     *  as the number of items in the Group.
     */
    override public function get numLayoutItems():int
    {

        return item;
    }
    
    /**
     *  Returns the index position of an item
     *
     *  @param item The item to identify
     *
     *  @return The index position of the item to identify
     * 
     *  @throws ArgumentError Throws if the item is not a child of this object
     */ 
    public function getItemIndex(item:Object):int
    {
        var index:int = -1;
        
        switch (_contentType)
        {
            case CONTENT_TYPE_UNKNOWN:
            {
                if (_content == item)
                    index = 0;
                break;
            }
            
            case CONTENT_TYPE_ARRAY:
            {
                index = _content.indexOf(item);
                break;
            }
        }
        
        if (index == -1)
            throw ArgumentError(item + " is not found in this Group");
        else
            return index;
    }
    
    /**
     *  Changes the position of an existing child in the Group.
     * 
     *  <p>When you use the setItemIndex() method and specify an 
     *  index position that is already occupied, the only positions 
     *  that change are those in between the item's former and new position.
     *  All others will stay the same.  If an item is moved to an index 
     *  LOWER than its current index, all items in between will INCREASE 
     *  by 1 for their index reference.  If an item is moved to an index
     *  HIGHER than its current index, all items in between will 
     *  DECREASE by 1 for their index reference.</p>
     *
     *  @param item The item for which you want to change the index number.
     *  @param index The resulting index number for the item
     * 
     *  @throws RangeError - Throws if the index does not exist in the child list.
     *  @throws ArgumentError - Throws if the item parameter is not a child 
     *  of this object
     */
    public function setItemIndex(item:Object, index:int):void
    {
        // check for RangeError...this is done in addItemAt
        // but we want to do it before removing the item
        checkForRangeError(index);
        
        removeItem(item);
        addItemAt(item, index);
    }
    
    /**
     *  Swaps the index of the two specified items. All other items
     *  remain in the same index position.
     *
     *  @param item1 The first item.
     *  @param item2 The second item.
     * 
     *  @throws ArgumentError Throws if either item is not a child of this object
     */
    public function swapItems(item1:Object, item2:Object):void
    {
        swapItemsAt(getItemIndex(item1), getItemIndex(item2));
    }
    
    /**
     *  Swaps the items at the two specified index positions in 
     *  the Group.  All other items remain in the same index position.
     *
     *  @param index1 The index of the first item.
     *  @param index2 The index of the second item.
     * 
     *  @throws RangeError If either index does not exist in the child list
     */
    public function swapItemsAt(index1:int, index2:int):void
    {
        // Make sure that index1 is the smaller index so that addItemAt 
