protected override void ApplySortCore(PropertyDescriptor property, ListSortDirection direction)
{
_sortProperty = property;
_sortDirection = direction;
// Get list to sort
List <T> items = Items as List <T>;
// Apply and set the sort, if items to sort
if (items != null)
{
ListSortDescription sort = new ListSortDescription(property, direction);
ListSortDescription[] sortArr = new ListSortDescription[_sortDescriptions.Count + 1];
_sortDescriptions.CopyTo(sortArr, 1);
sortArr[0] = sort;
_sortDescriptions = new ListSortDescriptionCollection(sortArr);
ApplySort(_sortDescriptions);
_isSorted = true;
}
else
{
_isSorted = false;
}
// Let bound controls know they should refresh their views
OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
}
public void ApplySort(ListSortDescriptionCollection sorts)
{
// Get list to sort
// Note: this.Items is a non-sortable ICollection<T>
List <T> items = this.Items as List <T>;
// Apply and set the sort, if items to sort
if (items != null)
{
_SortDescriptions = sorts;
comparers = new List <PropertyComparer <T> >();
foreach (ListSortDescription sort in sorts)
{
comparers.Add(new PropertyComparer <T>(sort.PropertyDescriptor,
sort.SortDirection));
}
items.Sort(CompareValuesByProperties);
//_isSorted = true;
}
else
{
//_isSorted = false;
}
this.OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
}
void IBindingListView.ApplySort(ListSortDescriptionCollection sorts)
{
if (sorts == null || sorts.Count < 1)
{
return;
}
var list = InnerList as EntityList <T>;
if (list == null || list.Count < 1)
{
return;
}
var ns = new List <string>();
var ds = new List <Boolean>();
foreach (ListSortDescription item in sorts)
{
ns.Add(item.PropertyDescriptor.Name);
ds.Add(item.SortDirection == ListSortDirection.Descending);
}
list.Sort(ns.ToArray(), ds.ToArray());
SortDescriptions = sorts;
OnListChanged(ResetEventArgs);
}
public void Sort(IDictionary <string, bool> columns)
{
if (columns != null && columns.Count > 0)
{
Guid selectedId = default(Guid);
if (SelectedRow != null && SelectedRow.Index > -1)
{
selectedId = (Guid)SelectedRow.Cells[QueueColumns.Id.Name].Value;
}
ListSortDescription[] sortArray = new ListSortDescription[columns.Count];
int columnIndex = 0;
foreach (KeyValuePair <string, bool> column in columns)
{
ListSortDirection direction = (column.Value) ? ListSortDirection.Ascending : ListSortDirection.Descending;
PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(IMediaItem))[QueueColumns.ColumnsByPropertyName[column.Key].PropertyName];
sortArray[columnIndex] = new ListSortDescription(property, direction);
columnIndex++;
}
ListSortDescriptionCollection sorts = new ListSortDescriptionCollection(sortArray);
grid.Sort(sorts);
DrawSortGlyphs(columns);
}
}
public void SortDescriptionTest()
{
IBindingListView view = new DataView(_table);
ListSortDescriptionCollection col = view.SortDescriptions;
((DataView)view).Sort = "";
col = view.SortDescriptions;
Assert.Equal(0, col.Count);
((DataView)view).Sort = null;
col = view.SortDescriptions;
Assert.Equal(0, col.Count);
((DataView)view).Sort = "col1 DESC, col2 ASC";
col = view.SortDescriptions;
Assert.Equal(2, col.Count);
Assert.Equal("col1", col[0].PropertyDescriptor.Name);
Assert.Equal(ListSortDirection.Descending, col[0].SortDirection);
Assert.Equal("col2", col[1].PropertyDescriptor.Name);
Assert.Equal(ListSortDirection.Ascending, col[1].SortDirection);
//ApplySort Test
IBindingListView view1 = new DataView(_table);
Assert.False(view.Equals(view1));
view1.ApplySort(col);
Assert.Equal("[col1] DESC,[col2]", ((DataView)view1).Sort);
for (int i = 0; i < view.Count; ++i)
{
Assert.Equal(((DataView)view)[i].Row, ((DataView)view1)[i].Row);
}
}
/// <summary>
/// Core sort function. All sorting function uses this method.
/// If the ListSortDescriptionCollection are the same stored
/// in the collection, the collection is sorted yet,
/// so it returns immediately
/// </summary>
/// <param name="sorts">List of SortDescription</param>
public void ApplySort(ListSortDescriptionCollection sorts)
{
if (sorts == null)
{
return;
}
bool bMatch = false;
if (_IsSorted && _SortDescriptions != null && _SortDescriptions.Count == sorts.Count)
{
bMatch = true;
for (int i = 0; i < sorts.Count; i++)
{
ListSortDescription ldsSource = sorts[i];
ListSortDescription ldsTarget = _SortDescriptions[i];
if (ldsSource.PropertyDescriptor != ldsTarget.PropertyDescriptor ||
ldsSource.SortDirection != ldsTarget.SortDirection)
{
bMatch = false;
break;
}
}
}
// descriptors are the same of previous sort operation? just exit
if (bMatch)
{
return;
}
_SortDescriptions = sorts;
Sort(new DescriptorComparison(sorts)); // IComparer<T>
_IsSorted = true;
}
/// <summary>
/// Invokes underlying BindingSource's ApplySort method if the source is
/// connected to a DataSource, does nothing otherwise.
/// </summary>
/// <param name="sorts"></param>
public void ApplySort(ListSortDescriptionCollection sorts)
{
if (IsConnectionAvailable())
{
((IBindingListView)source).ApplySort(sorts);
}
}
public void ApplySort(Comparison <T> comparison)
{
_descrips = new ListSortDescriptionCollection();
if (comparison == null)
{
if (_filter == null)
{
_filterIds.Clear();
}
else
{
_filterIds.Sort();
}
}
else
{
if (!_filterIds.Any() && _filter == null)
{
_filterIds.AddRange(Enumerable.Range(0, _list.Count));
}
_filterIds.Sort((x, y) => comparison((T)_list[x], (T)_list[y]));
}
ResetBindings();
}
private IComparer GetSortComparer(ListSortDescriptionCollection sortDescriptions)
{
bool needSubstitution = false;
if (_sortSubstitutions.Count > 0)
{
foreach (ListSortDescription sortDescription in sortDescriptions)
{
if (_sortSubstitutions.ContainsKey(sortDescription.PropertyDescriptor.Name))
{
needSubstitution = true;
break;
}
}
if (needSubstitution)
{
ListSortDescription[] sorts = new ListSortDescription[sortDescriptions.Count];
sortDescriptions.CopyTo(sorts, 0);
for (int i = 0; i < sorts.Length; i++)
{
if (_sortSubstitutions.ContainsKey(sorts[i].PropertyDescriptor.Name))
{
sorts[i] = new ListSortDescription(((SortSubstitutionPair)_sortSubstitutions[sorts[i].PropertyDescriptor.Name]).Substitute,
sorts[i].SortDirection);
}
}
sortDescriptions = new ListSortDescriptionCollection(sorts);
}
}
return(new SortListPropertyComparer(sortDescriptions));
}
void IBindingListView.ApplySort(ListSortDescriptionCollection sorts)
{
ListSortDescription[] sortArray = new ListSortDescription[sorts.Count + 1];
sorts.CopyTo(sortArray, 1);
sortArray[0] = fixedSort;
ApplySort(sortArray);
}
/// <summary>
/// Apply sorting to the collection
/// </summary>
/// <param name="sortCollection">The sort collection.</param>
public void ApplySort(ListSortDescriptionCollection sortCollection)
{
// Stop raising of events (preserve current state)
var oldRaise = this.RaiseListChangedEvents;
this.RaiseListChangedEvents = false;
try
{
// sort the items into a temporary list by using the new sort descriptions
var tmp = new PropertyComparerCollection <T>(sortCollection);
var items = new List <T>(this);
items.Sort(tmp);
// apply the sorting to the actual list of items
var index = 0;
foreach (var item in items)
{
this.SetItem(index++, item);
}
// and keep the sort descriptions
this.sorts = tmp;
}
finally
{
// allow events and force the update of bindings
this.RaiseListChangedEvents = oldRaise;
this.ResetBindings();
}
}
public QueryParameters SetSortDescriptions(ListSortDescriptionCollection value)
{
return(new QueryParameters(this)
{
SortDescriptions = value
});
}
/// <summary>
/// The apply sort.
/// </summary>
/// <param name="sortCollection">
/// The sort collection.
/// </param>
public void ApplySort(ListSortDescriptionCollection sortCollection)
{
if (this._allowSort)
{
bool oldRaise = RaiseListChangedEvents;
RaiseListChangedEvents = false;
try
{
var tmp = new PropertyComparerCollection <T>(sortCollection);
var items = new List <T>(this);
items.Sort(tmp);
int index = 0;
foreach (T item in items)
{
SetItem(index++, item);
}
this.sorts = tmp;
}
finally
{
RaiseListChangedEvents = oldRaise;
ResetBindings();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="descriptionCollection"></param>
public void ApplySort(ListSortDescriptionCollection descriptionCollection)
{
_logger.Log("ApplySort - ListSortDescriptionCollection ", LogCategory.Info);
SortDescriptions = descriptionCollection;
ViewOfBusinessObjectCollection.Sort(new GenericComparer <T>(SortDescriptions));
OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
}
public void ApplySort(System.ComponentModel.ListSortDescriptionCollection sorts)
{
_descrips = sorts;
if (sorts == null || sorts.Count < 1)
{
if (_filter == null)
{
_filterIds.Clear();
}
else
{
_filterIds.Sort();
}
}
else
{
if (!_filterIds.Any() && _filter == null)
{
_filterIds.AddRange(Enumerable.Range(0, _list.Count));
}
_filterIds.Sort((x, y) => CompareProp((T)_list[x], (T)_list[y]));
}
ResetBindings();
}
public void SortDescriptionTest()
{
IBindingListView view = (IBindingListView) new DataView(table);
ListSortDescriptionCollection col = view.SortDescriptions;
((DataView)view).Sort = "";
col = view.SortDescriptions;
Assert.AreEqual(0, col.Count, "#1");
((DataView)view).Sort = null;
col = view.SortDescriptions;
Assert.AreEqual(0, col.Count, "#2");
((DataView)view).Sort = "col1 DESC, col2 ASC";
col = view.SortDescriptions;
Assert.AreEqual(2, col.Count, "#3");
Assert.AreEqual("col1", col[0].PropertyDescriptor.Name, "#4");
Assert.AreEqual(ListSortDirection.Descending, col[0].SortDirection, "#5");
Assert.AreEqual("col2", col[1].PropertyDescriptor.Name, "#6");
Assert.AreEqual(ListSortDirection.Ascending, col[1].SortDirection, "#7");
//ApplySort Test
IBindingListView view1 = (IBindingListView) new DataView(table);
Assert.IsFalse(view.Equals(view1), "#8");
view1.ApplySort(col);
Assert.AreEqual("[col1] DESC,[col2]", ((DataView)view1).Sort, "#9");
for (int i = 0; i < view.Count; ++i)
{
Assert.AreEqual(((DataView)view)[i].Row, ((DataView)view1)[i].Row, "#10" + i);
}
}
public ConfigObjectComparer(ListSortDescriptionCollection sorts)
{
if (sorts == null)
{
throw new ArgumentNullException("sorts");
}
this.sorts = sorts;
}
public void ApplySort(ListSortDescriptionCollection sorts)
{
this._sortProperty = null;
this._sortDescriptions = sorts;
SortComparer <T> comparer = new SortComparer <T>(sorts);
this.ApplySortInternal(comparer);
}
public void ApplySort(ListSortDescriptionCollection sorts)
{
if (!this.SupportsAdvancedSorting)
{
throw new NotSupportedException();
}
this.OnApplySort(sorts);
}
/// <summary>
/// Sorts the list based on a <see cref="T:System.ComponentModel.PropertyDescriptor"/> and a <see cref="T:System.ComponentModel.ListSortDirection"/>.
/// </summary>
/// <param name="property">The <see cref="T:System.ComponentModel.PropertyDescriptor"/> to sort by.
/// </param><param name="direction">One of the <see cref="T:System.ComponentModel.ListSortDirection"/> values.
/// </param><exception cref="T:System.NotSupportedException"><see cref="P:System.ComponentModel.IBindingList.SupportsSorting"/> is false.
/// </exception>
public void ApplySort(PropertyDescriptor property, ListSortDirection direction)
{
ListSortDescription[] descriptions = new[] { new ListSortDescription(property, direction) };
SortDescriptions = new ListSortDescriptionCollection(descriptions);
PageProvider.Sort = property.Name + " " + (direction == ListSortDirection.Ascending ? "Asc" : "Desc");
InnerCache.Reset();
OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, 0));
}
public static ListObjectComparer <T> FromSort <T>(ListSortDescriptionCollection sorts)
{
var comparers = sorts.Cast <ListSortDescription>()
.Select(MakeComparer <T>)
.ToList();
return(new ListObjectComparer <T>(comparers));
}
void IBindingList.ApplySort(PropertyDescriptor property, ListSortDirection direction)
{
ListSortDescription[] sorts = new ListSortDescription[1];
sorts[0] = new ListSortDescription(property, direction);
ListSortDescriptionCollection lsdc = new ListSortDescriptionCollection(sorts);
this.ApplySort(lsdc);
}
protected void ApplySort(ListSortDescriptionCollection sorts)
{
_SortProperty = null;
_SortDescriptions = sorts;
var comparer = new PropertyComparer <T>(sorts);
ApplySortInternal(comparer);
}
void IBindingListView.ApplySort(ListSortDescriptionCollection sorts)
{
m_SortProperty = null;
m_SortDescriptions = sorts;
SortComparer <T> comparer = new SortComparer <T>(sorts);
ApplySortInternal(comparer);
}
/// <summary>
/// Sorts the list based on a PropertyDescriptor and a ListSortDirection.
/// </summary>
/// <param name="property">The <see cref="PropertyDescriptor"/> to sort by.</param>
/// <param name="direction">One of the <see cref="ListSortDirection"/> values.</param>
public void ApplySort(PropertyDescriptor property, ListSortDirection direction)
{
ListSortDescription listSortDescription = new ListSortDescription(property, direction);
ListSortDescription[] listSortDescriptions = new ListSortDescription[] { listSortDescription };
ListSortDescriptionCollection sorts = new ListSortDescriptionCollection(listSortDescriptions);
ApplySort(sorts);
}
public SortComparer(ListSortDescriptionCollection sortCollection)
{
this.m_SortCollection = null;
this.m_PropDesc = null;
this.m_Direction = ListSortDirection.Ascending;
this.m_PropertyDescriptors = null;
this.Initialize();
this.m_SortCollection = sortCollection;
}
public SortComparer(string orderBy)
{
this.m_SortCollection = null;
this.m_PropDesc = null;
this.m_Direction = ListSortDirection.Ascending;
this.m_PropertyDescriptors = null;
this.Initialize();
this.m_SortCollection = this.ParseOrderBy(orderBy);
}
public override void ApplySort(ListSortDescriptionCollection sorts)
{
Comparison <T> cComparison = GetComparer(sorts[0]);
if (cComparison != null)
{
__cSource.Sort(cComparison);
OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
}
}
public void ApplySort(ListSortDescriptionCollection sorts)
{
RowFilter = RowFilter.ChangeListSortDescriptionCollection(sorts);
if (ClusteringSpec != null && sorts.Count > 0)
{
ClusteringSpec = ClusteringSpec.RemoveRole(ClusterRole.ROWHEADER);
}
// Fire an event so that the NavBar updates to show that the DataGridView is sorting
OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
}
protected virtual void OnApplySort(ListSortDescriptionCollection sorts)
{
this.sortOrder.Clear();
this.sortDescriptions = sorts;
foreach (object obj in ((IEnumerable)sorts))
{
ListSortDescription listSortDescription = (ListSortDescription)obj;
this.sortOrder.Add(new QueueViewerSortOrderEntry(listSortDescription.PropertyDescriptor.Name, listSortDescription.SortDirection));
}
this.InternalSort();
}
