     /**
      *  @private
      */
+    override protected function itemInCaret(index:int, caret:Boolean):void
+    {
+        super.itemInCaret(index, caret);
+        
+        var renderer:Object = dataGroup ? dataGroup.getElementAt(index) : null;
+        
+        if (renderer is IItemRenderer)
+        {
+            IItemRenderer(renderer).caret = caret;
+        }
+    }
+    
+    /**
+     *  @private
+     */
     override public function isItemIndexSelected(index:int):Boolean
     {
         if (allowMultipleSelection && (selectedIndices != null))

     */
    protected function item_clickHandler(event:MouseEvent):void
    {
        if (!allowMultipleSelection)
        {
            //Single selection case 
            var newIndex:Number = dataGroup.getElementIndex(event.currentTarget as IVisualElement);  
            
            //Check to see if we're deselecting the currently selected item 
            if (event.ctrlKey && selectedIndex == newIndex)
                selectedIndex = NO_SELECTION;  
            //Otherwise, select the new item 
            else 
                selectedIndex = newIndex; 
        }
        else 
        {
            //Multiple selection is handled by the helper method below 
            selectedIndices = calculateSelectedIndicesInterval(event.currentTarget as IVisualElement, event.shiftKey, event.ctrlKey); 
        }
    }
    

        else
            currentIndex = selectedIndex;
            
        //Delegate to the layout to tell us what the next item is we should select or focus into.
	    // TODO (jszeto) At some point we should refactor this so we don't depend on layout
	    // for keyboard handling. If layout doesn't exist, then use some other keyboard handler
        var proposedNewIndex:int = (selectUponNavigation) ? layout.getDestinationIndex(navigationUnit, currentIndex)
            : layout.getDestinationIndex(navigationUnit, currentCaretIndex);   

        // Note that the KeyboardEvent is canceled even if the current selected or in focus index
        // doesn't change because we don't want another component to start handling these
        // events when the index reaches a limit.
        if (proposedNewIndex == -1)
            return;
        event.preventDefault(); 
        
        if (selectUponNavigation)
        {
            if (allowMultipleSelection && event.shiftKey && selectedIndices)
            {
                var newInterval:Array = []; 
                var i:int; 
                //contiguous multi-selection action - create the new selection
                //interval
                if (selectedIndex <= proposedNewIndex)
                {
                    for (i = selectedIndex; i <= proposedNewIndex; i++)
                    {
                        newInterval.push(i); 
                    }
                }
                else 
                {
                    for (i = selectedIndex; i >= proposedNewIndex; i--)
                    {
                        newInterval.push(i); 
                    }
                }
                selectedIndices = newInterval;   
                ensureItemIsVisible(proposedNewIndex); 
            }
            else
            {
                //simple new selection 
                selectedIndex = proposedNewIndex; 
                ensureItemIsVisible(proposedNewIndex);
            }
        }
        else
        {
            //Handle the focus change of the items so that the currentCaretIndex property
            //gets updated and the itemFocusChanged event dispatches. 
            if(event.ctrlKey)
            {
                handleCaretChange(proposedNewIndex, true);
                ensureItemIsVisible(proposedNewIndex); 
            }
        }
    }
  
}
