/// <summary>
/// Sorts the specified column in the specified sort direction
/// </summary>
/// <param name="index">The index of the column to sort</param>
/// <param name="column">The column to sort</param>
/// <param name="sortOrder">The direction the column is to be sorted</param>
/// <param name="stable">Specifies whether a stable sorting method
/// should be used to sort the column</param>
private void Sort(int index, Column column, SortOrder sortOrder, bool stable)
{
// make sure a null comparer type doesn't sneak past
ComparerBase comparer = null;
if (column.Comparer != null)
{
comparer = (ComparerBase) Activator.CreateInstance(column.Comparer, new object[] {this.TableModel, index, sortOrder});
}
else if (column.DefaultComparerType != null)
{
comparer = (ComparerBase) Activator.CreateInstance(column.DefaultComparerType, new object[] {this.TableModel, index, sortOrder});
}
else
{
return;
}
column.InternalSortOrder = sortOrder;
// create the comparer
SorterBase sorter = null;
// work out which sort method to use.
// - InsertionSort/MergeSort are stable sorts,
// whereas ShellSort/HeapSort are unstable
// - InsertionSort/ShellSort are faster than
// MergeSort/HeapSort on small lists and slower
// on large lists
// so we choose based on the size of the list and
// whether the user wants a stable sort
if (this.TableModel.Rows.Count < 1000)
{
if (stable)
{
sorter = new InsertionSorter(this.TableModel, index, comparer, sortOrder);
}
else
{
sorter = new ShellSorter(this.TableModel, index, comparer, sortOrder);
}
}
else
{
if (stable)
{
sorter = new MergeSorter(this.TableModel, index, comparer, sortOrder);
}
else
{
sorter = new HeapSorter(this.TableModel, index, comparer, sortOrder);
}
}
// don't let the table redraw
this.BeginUpdate();
this.OnBeginSort(new ColumnEventArgs(column, index, ColumnEventType.Sorting, null));
sorter.Sort();
this.OnEndSort(new ColumnEventArgs(column, index, ColumnEventType.Sorting, null));
// redraw any changes
this.EndUpdate();
}
/// <summary>
/// Sorts the specified column in the specified sort direction
/// </summary>
/// <param name="index">The index of the column to sort</param>
/// <param name="column">The column to sort</param>
/// <param name="sortOrder">The direction the column is to be sorted</param>
/// <param name="stable">Specifies whether a stable sorting method
/// should be used to sort the column</param>
private void Sort(int index, Column column, SortOrder sortOrder, bool stable)
{
// make sure a null comparer type doesn't sneak past
ComparerBase comparer = null;
if (column.Comparer != null)
{
comparer = (ComparerBase) Activator.CreateInstance(column.Comparer, new object[] { this.TableModel, index, sortOrder });
}
else if (column.DefaultComparerType != null)
{
comparer = (ComparerBase) Activator.CreateInstance(column.DefaultComparerType, new object[] { this.TableModel, index, sortOrder });
}
else
{
return;
}
column.InternalSortOrder = sortOrder;
// create the comparer
SorterBase sorter = null;
// work out which sort method to use.
// - InsertionSort/MergeSort are stable sorts,
// whereas ShellSort/HeapSort are unstable
// - InsertionSort/ShellSort are faster than
// MergeSort/HeapSort on small lists and slower
// on large lists
// so we choose based on the size of the list and
// whether the user wants a stable sort
if (this.SortType == SortType.AutoSort)
{
if (this.TableModel.Rows.Count < 1000)
{
if (this.StableSort)
sorter = new InsertionSorter(this.TableModel, index, comparer, sortOrder);
else
sorter = new ShellSorter(this.TableModel, index, comparer, sortOrder);
}
else
{
if (this.StableSort)
sorter = new MergeSorter(this.TableModel, index, comparer, sortOrder);
else
sorter = new HeapSorter(this.TableModel, index, comparer, sortOrder);
}
}
else
{
switch (this.SortType)
{
case SortType.HeapSort: { sorter = new HeapSorter(this.TableModel, index, comparer, sortOrder); break; }
case SortType.InsertionSort: { sorter = new InsertionSorter(this.TableModel, index, comparer, sortOrder); break; }
case SortType.MergeSort: { sorter = new MergeSorter(this.TableModel, index, comparer, sortOrder); break; }
case SortType.ShellSort: { sorter = new ShellSorter(this.TableModel, index, comparer, sortOrder); break; }
default: { throw new ApplicationException("Invalid Sort Type - " + this.SortType.ToString()); }
}
}
sorter.SecondarySortOrders = this.ColumnModel.SecondarySortOrders;
sorter.SecondaryComparers = this.GetSecondaryComparers(this.ColumnModel.SecondarySortOrders);
// don't let the table redraw
this.BeginUpdate();
this.OnBeginSort(new ColumnEventArgs(column, index, ColumnEventType.Sorting, null));
// Added by -= Micronn =- on 22 dec 2005
Row focusedRow = null;
if (this.FocusedCell != CellPos.Empty)
focusedRow = this.tableModel.Rows[ this.FocusedCell.Row ];
sorter.Sort();
// Added by -= Micronn =- on 22 dec 2005
if (focusedRow != null)
{
this.FocusedCell = new CellPos(focusedRow.Index, this.FocusedCell.Column);
this.EnsureVisible(this.FocusedCell);
}
this.OnEndSort(new ColumnEventArgs(column, index, ColumnEventType.Sorting, null));
// redraw any changes
this.EndUpdate();
}
