      * 
      *  @param columnIndices The indices of the columns by which to sort the <code>dataProvider</code>.
      * 
-     *  @return <code>true</code> if the <code>dataProvider</code> can be sorted with the provided column indices.
-     * 
-     *  @langversion 3.0
-     *  @playerversion Flash 10
-     *  @playerversion AIR 2.5
-     *  @productversion Flex 4.5
-     */
-    public function sortByColumns(columnIndices:Vector.<int>):Boolean
+     *  @param isInteractive If true, <code>GridSortEvent.SORT_CHANGING</code> and
+     *  <code>GridSortEvent.SORT_CHANGE</code> events are dispatched and the column header group 
+     *  <code>visibleSortIndicatorIndices</code> is updated with <code>columnIndices</code>.
+     * 
+     *  @return <code>true</code> if the <code>dataProvider</code> was sorted with the provided
+     *  column indicies.
+     * 
+     *  @see spark.components.DataGrid#dataProvider
+     *  @see spark.components.gridClasses.GridColumn#sortCompareFunction
+     *  @see spark.components.gridClasses.GridColumn#sortDescending
+     *  @see spark.components.gridClasses.GridColumn#sortField
+     *  @see spark.components.gridClasses.GridColumnHeaderGroup#visibleSortIndicatorIndices
+     *  @see spark.events.GridSortEvent
+     * 
+     *  @langversion 3.0
+     *  @playerversion Flash 10
+     *  @playerversion AIR 2.5
+     *  @productversion Flex 4.5
+     */
+    public function sortByColumns(columnIndices:Vector.<int>, isInteractive:Boolean=false):Boolean
     {
         const dataProvider:ICollectionView = this.dataProvider as ICollectionView;
         if (!dataProvider)

        
        dataProvider.sort = sort;
        dataProvider.refresh();
        return true;
    }

    /**
     *  @private
     *  This function builds an array of SortFields based on the column
     *  indices given. The direction is based on the current value of
     *  sortDescending from the column.
     */
    private function createSortFields(columnIndices:Vector.<int>, previousFields:Array):Array
    {
        if (columnIndices.length == 0)
            return null;
        
        var fields:Array = new Array();
        
        for each (var columnIndex:int in columnIndices)
        {
            var col:GridColumn = this.getColumnAt(columnIndex);

        else
            sort = new Sort();
        
        var sortFields:Array = createSortFields(columnIndices, sort.fields, isInteractive);
        if (!sortFields)
            return false;
        
        var oldSortFields:Array = (dataProvider.sort) ? dataProvider.sort.fields : null;
        
        // Dispatch the "changing" event. If preventDefault() is called
        // on this event, the sort operation will be cancelled.  If columnIndices or
        // sortFields are changed, the new values will be used.
        if (isInteractive)
        {
            // This is a shallow copy which means only the pointers to the ISortField objects
            // are copied to the new Array, not the ISortField objects themselves.
            if (oldSortFields)
                oldSortFields = oldSortFields.concat();
            
            if (hasEventListener(GridSortEvent.SORT_CHANGING))
            {
                const changingEvent:GridSortEvent = 
                    new GridSortEvent(GridSortEvent.SORT_CHANGING,
                        false, true, 
                        columnIndices, 
                        oldSortFields,  /* intended to be read-only but no way to enforce this */
                        sortFields); 
                                
                // The event was cancelled so don't sort.
                if (!dispatchEvent(changingEvent))
                    return false;
                
                // Update the sort columns since they might have changed.
                columnIndices = changingEvent.columnIndices;
                if (!columnIndices)
                    return false;
                
                // Update the new sort fields since they might have changed.
                sortFields = changingEvent.newSortFields;
                if (!sortFields)
                    return false;
            }
        }
        
        // Remove each old SortField that's not a member of the new sortFields Array
        // as a "styleClient" of this DataGrid.
        
        if (oldSortFields)
        {
            for each (var oldSortField:ISortField in oldSortFields)
