                 itemSelected(addedItems[i], true);
             }
         }
+        
+        //Dispatch the selectionChanged event
+        var e:IndexChangedEvent = new IndexChangedEvent(IndexChangedEvent.SELECTION_CHANGED);
+        e.multipleSelectionChange = true; 
+        dispatchEvent(e); 
+    }
+    
+    /**
+     *  @private
+     *  Taking into account which modifier keys were clicked, the new
+     *  selectedIndices interval is calculated. 
+     */
+    private function calculateSelectedIndicesInterval(renderer:IVisualElement, shiftKey:Boolean, ctrlKey:Boolean):Array
+    {
+        var i:int; 
+        var interval:Array = []; 
+        var index:Number = dataGroup.getElementIndex(renderer); 
+        
+        if (!shiftKey)
+        {
+            if (ctrlKey)
+            {
+                if (!isEmpty(selectedIndices))
+                {
+                    //Quick check to see if selectedIndices had only one selected item
+                    //and that item was de-selected
+                    if (selectedIndices.length == 1 && (selectedIndices[0] == index))
+                    {
+                        //selectedIndex = NO_SELECTION;
+                        return [NO_SELECTION];  
+                    }
+                    else
+                    {
+                        // Go through and see if the index passed in was in the 
+                        // selection model. If so, leave it out when constructing
+                        // the new interval so it is de-selected. 
+                        var found:Boolean = false; 
+                        for (i = 0; i < _selectedIndices.length; i++)
+                        {
+                            if (_selectedIndices[i] == index)
+                                found = true; 
+                            else if (_selectedIndices[i] != index)
+                                interval.push(_selectedIndices[i]); 
+                        }
+                        if (!found)
+                        {
+                            //Nothing from the selection model was de-selected. 
+                            //Instead, the Ctrl key was held down and we're doing a  
+                            //new add. 
+                            interval.push(index);   
+                        }
+                        for (var i:int = 0; i < interval.length; i++)
+                        {
+                            trace(interval[i]);
+                        }
+                        return interval; 
+                    } 
+                }
+            }
+            //A single item was newly selected, add that to the selection interval.  
+            else 
+                return [index];
+        }
+        
+        else (shiftKey)
+        {
+            //A contiguous selection action has occurred. Figure out which new 
+            //indices to add to the selection interval and return that. 
+            var start:Number = (!isEmpty(selectedIndices)) ? selectedIndices[0] : -1; 
+            var end:Number = index; 
+            if (start < end)
+            {
+                for (i = start; i <= end; i++)
+                {
+                    interval.push(i); 
+                }
+            }
+            else 
+            {
+                for (i = start; i >= end; i--)
+                {
+                    interval.push(i); 
+                }
+            }
+            return interval; 
+        }
     }
     
     //--------------------------------------------------------------------------

	        var delta:int = 0;
	
	        if (layout is VerticalLayout)
	            switch(event.keyCode)
	            {
	                case Keyboard.UP: delta = -1; break;
	                case Keyboard.DOWN: delta = +1; break;
	            }
	        else if (layout is HorizontalLayout)
	            switch(event.keyCode)
	            {
	                case Keyboard.LEFT: delta = -1; break;
	                case Keyboard.RIGHT: delta = +1; break;
	            }
	        
	        // Note that the KeyboardEvent is canceled even if the selectedIndex doesn't
	        // change because we don't want another component to start handling these
	        // events when the selectedIndex reaches a limit.

    
    /**
     *  @private
     *  Given a new selection interval, figure out which
     *  items are newly added/removed from the selection interval and update
     *  selection properties and view accordingly. Additionally, dispatch the 
     *  selectionChanged event. 
     */
    private function commitMultipleSelection():void
    {
