/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public ListSortDescriptionCollection(ListSortDescription[] sorts) {
if (sorts != null) {
for (int i = 0; i < sorts.Length; i ++) {
this.sorts.Add(sorts[i]);
}
}
}
protected override void OnSortingRangeRows(SortRangeRowsEventArgs e)
{
base.OnSortingRangeRows (e);
if (DataSource == null || DataSource.AllowSort == false)
return;
System.ComponentModel.PropertyDescriptor propertyCol = Columns[e.KeyColumn].PropertyColumn;
if (propertyCol != null)
{
ListSortDirection direction;
if (e.Ascending)
direction = ListSortDirection.Ascending;
else
direction = ListSortDirection.Descending;
ListSortDescription[] sortsArray = new ListSortDescription[1];
sortsArray[0] = new ListSortDescription(propertyCol, direction);
DataSource.ApplySort(new ListSortDescriptionCollection(sortsArray));
}
else
DataSource.ApplySort(null);
}
/// <summary>
/// Sorts the view of the underlying list based on the given <see cref="T:System.ComponentModel.ListSortDescriptionCollection"></see>.
/// </summary>
/// <param name="sorts">The <see cref="T:System.ComponentModel.ListSortDescriptionCollection"></see> containing the sorts to apply to the view.</param>
public void ApplySort(ListSortDescriptionCollection sorts)
{
Lock();
try
{
ListSortDescriptionCollection proposed;
if (sorts == null)
proposed = new ListSortDescriptionCollection();
else
{
foreach (ListSortDescription desc in sorts)
ValidateProperty(desc.PropertyDescriptor);
ListSortDescription[] props = new ListSortDescription[sorts.Count];
sorts.CopyTo(props, 0);
proposed = new ListSortDescriptionCollection(props);
}
this.SortProperties = proposed;
}
finally
{
Unlock();
}
RaiseEvents();
}
/// <summary>
/// Sorts the view based on a <see cref="T:System.ComponentModel.PropertyDescriptor"></see> and a <see cref="T:System.ComponentModel.ListSortDirection"></see>.
/// </summary>
/// <param name="property">The <see cref="T:System.ComponentModel.PropertyDescriptor"></see> to sort by.</param>
/// <param name="direction">One of the <see cref="T:System.ComponentModel.ListSortDirection"></see> values.</param>
public void ApplySort(PropertyDescriptor property, ListSortDirection direction)
{
Lock();
try
{
ListSortDescriptionCollection proposed;
if (property == null)
proposed = new ListSortDescriptionCollection();
else
{
ValidateProperty(property);
ListSortDescription[] props = new ListSortDescription[] { new ListSortDescription(property, direction) };
proposed = new ListSortDescriptionCollection(props);
}
this.SortProperties = proposed;
}
finally
{
Unlock();
}
RaiseEvents();
}
// << Some of this code is taken from System.Data.DataTable::ParseSortString method >>
private ListSortDescriptionCollection ParseSortString(string sortString) {
if (String.IsNullOrEmpty(sortString)) {
return new ListSortDescriptionCollection();
}
ArrayList sorts = new ArrayList();
PropertyDescriptorCollection props = this.currencyManager.GetItemProperties();
string[] split = sortString.Split(new char[] {','});
for (int i = 0; i < split.Length; i++) {
string current = split[i].Trim();
// Handle ASC and DESC
int length = current.Length;
bool ascending = true;
if (length >= 5 && String.Compare(current, length - 4, " ASC", 0, 4, true, CultureInfo.InvariantCulture) == 0) {
current = current.Substring(0, length - 4).Trim();
}
else if (length >= 6 && String.Compare(current, length - 5, " DESC", 0, 5, true, CultureInfo.InvariantCulture) == 0) {
ascending = false;
current = current.Substring(0, length - 5).Trim();
}
// Handle brackets
if (current.StartsWith("[")) {
if (current.EndsWith("]")) {
current = current.Substring(1, current.Length - 2);
}
else {
throw new ArgumentException(SR.GetString(SR.BindingSourceBadSortString));
}
}
// Find the property
PropertyDescriptor prop = props.Find(current, true);
if (prop == null) {
throw new ArgumentException(SR.GetString(SR.BindingSourceSortStringPropertyNotInIBindingList));
}
// Add the sort description
sorts.Add(new ListSortDescription(prop, ascending ? ListSortDirection.Ascending : ListSortDirection.Descending));
}
ListSortDescription[] result = new ListSortDescription[sorts.Count];
sorts.CopyTo(result);
return new ListSortDescriptionCollection(result);
}
public ListSortDescriptionCollection(ListSortDescription[] sorts)
{
}
// NOTE: Probably the parsing can be improved
void ProcessSortString (string sort)
{
// Only keep simple whitespaces in the middle
sort = Regex.Replace (sort, "( )+", " ");
string [] properties = sort.Split (',');
PropertyDescriptorCollection prop_descs = GetItemProperties (null);
if (properties.Length == 1) {
ListSortDescription sort_desc = GetListSortDescription (prop_descs, properties [0]);
ApplySort (sort_desc.PropertyDescriptor, sort_desc.SortDirection);
} else {
if (!SupportsAdvancedSorting)
throw new ArgumentException ("value");
ListSortDescription [] sort_descs = new ListSortDescription [properties.Length];
for (int i = 0; i < properties.Length; i++)
sort_descs [i] = GetListSortDescription (prop_descs, properties [i]);
ApplySort (new ListSortDescriptionCollection (sort_descs));
}
}
//-------------------------------------------------------------------------------------
void IBindingList.ApplySort(PropertyDescriptor property, ListSortDirection direction)
{
ListSortDescription lsd = new ListSortDescription(property, direction);
if(_sorts == null)
_sorts = new List<ListSortDescription>();
int pos = _sorts.FindIndex(delegate(ListSortDescription l)
{
return l.PropertyDescriptor.Name == lsd.PropertyDescriptor.Name;
});
if(pos == -1)
{
_sorts.Clear();
_sorts.Add(lsd);
}
else
_sorts[pos] = lsd;
ApplySort(DefaultSorter);
}
private ListSortDescriptionCollection ParseSortString(string sortString)
{
if (string.IsNullOrEmpty(sortString))
{
return new ListSortDescriptionCollection();
}
ArrayList list = new ArrayList();
PropertyDescriptorCollection itemProperties = this.currencyManager.GetItemProperties();
string[] strArray = sortString.Split(new char[] { ',' });
for (int i = 0; i < strArray.Length; i++)
{
string strA = strArray[i].Trim();
int length = strA.Length;
bool flag = true;
if ((length >= 5) && (string.Compare(strA, length - 4, " ASC", 0, 4, true, CultureInfo.InvariantCulture) == 0))
{
strA = strA.Substring(0, length - 4).Trim();
}
else if ((length >= 6) && (string.Compare(strA, length - 5, " DESC", 0, 5, true, CultureInfo.InvariantCulture) == 0))
{
flag = false;
strA = strA.Substring(0, length - 5).Trim();
}
if (strA.StartsWith("["))
{
if (!strA.EndsWith("]"))
{
throw new ArgumentException(System.Windows.Forms.SR.GetString("BindingSourceBadSortString"));
}
strA = strA.Substring(1, strA.Length - 2);
}
PropertyDescriptor property = itemProperties.Find(strA, true);
if (property == null)
{
throw new ArgumentException(System.Windows.Forms.SR.GetString("BindingSourceSortStringPropertyNotInIBindingList"));
}
list.Add(new ListSortDescription(property, flag ? ListSortDirection.Ascending : ListSortDirection.Descending));
}
ListSortDescription[] array = new ListSortDescription[list.Count];
list.CopyTo(array);
return new ListSortDescriptionCollection(array);
}
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);
}
//-------------------------------------------------------------------------------------
private void AddSortColumn(DataGridViewColumn col, ListSortDirection direction = ListSortDirection.Ascending)
{
if(this.DataSource == null)// || props.ContainsKey(col.DataPropertyName) == false)
return;
try
{
if(AllowMultipleSort == false)
{
if((this.DataSource as IBindingList) == null)
throw new Exception(String.Format("»сточник данных [{0}] не поддерживает интерфейс IBindingList!",
DataSource.GetType().FullName));
IBindingList ibl = (IBindingList)this.DataSource;
if(ibl.SupportsSorting == false)
return;
PropertyDescriptor pd = null;
if(props.ContainsKey(col.DataPropertyName))
pd = props[col.DataPropertyName];
else
pd = new UnboundColumnPropertyDescriptor(col);
ListSortDirection lsd = direction;
if(ibl.SortProperty != null && Object.Equals(ibl.SortProperty, pd))
if(ibl.SortDirection == ListSortDirection.Ascending)
lsd = ListSortDirection.Descending;
else
lsd = ListSortDirection.Ascending;
ibl.ApplySort(pd, lsd);
foreach(DataGridViewColumn c in Columns)
c.HeaderCell.SortGlyphDirection = SortOrder.None;
if(lsd == ListSortDirection.Ascending)
col.HeaderCell.SortGlyphDirection = SortOrder.Ascending;
else
col.HeaderCell.SortGlyphDirection = SortOrder.Descending;
SortedColumn = col;
SortOrder = lsd == ListSortDirection.Ascending ? SortOrder.Ascending : SortOrder.Descending;
}
else
{
if((this.DataSource as IBindingListView) == null)
throw new Exception(String.Format("»сточник данных [{0}] не поддерживает интерфейс IBindingListView!",
DataSource.GetType().FullName));
if((this.DataSource as ITypedList) == null)
throw new Exception(String.Format("»сточник данных [{0}] не поддерживает интерфейс ITypedList !",
DataSource.GetType().FullName));
if(((IBindingListView)DataSource).SupportsAdvancedSorting == false)
throw new Exception(String.Format("»сточник данных [{0}] не поддерживает сортировку по нескольким столбцам!",
DataSource.GetType().FullName));
PDictionary<string, ListSortDescription> sl = new PDictionary<string, ListSortDescription>();
if(((IBindingListView)DataSource).SortDescriptions != null)
foreach(ListSortDescription lsd in ((IBindingListView)DataSource).SortDescriptions)
sl.Add(lsd.PropertyDescriptor.Name, lsd);
List<string> toDel = new List<string>();
if(ModifierKeys != Keys.Control)
foreach(string s in sl.Keys)
if(s != (String.IsNullOrEmpty(col.DataPropertyName) ? col.Name : col.DataPropertyName))
toDel.Add(s);
foreach(string s in toDel)
sl.Remove(s);
PropertyDescriptor pd = null;
if(props.ContainsKey(col.DataPropertyName))
pd = props[col.DataPropertyName];
else
pd = new UnboundColumnPropertyDescriptor(col);
if(sl.ContainsKey(pd.Name))
{
if(sl[pd.Name].SortDirection == ListSortDirection.Ascending)
sl[pd.Name].SortDirection = ListSortDirection.Descending;
else
sl[pd.Name].SortDirection = ListSortDirection.Ascending;
}
else
sl.Add(pd.Name, new ListSortDescription(pd, direction));
SortedColumn = col;
SortOrder = sl[pd.Name].SortDirection == ListSortDirection.Ascending ? SortOrder.Ascending : SortOrder.Descending;
ListSortDescription[] sd = new ListSortDescription[sl.Count];
int c = 0;
foreach(var i in sl.Values)
sd[c++] = i;
((IBindingListView)DataSource).ApplySort(new ListSortDescriptionCollection(sd));
DrawMultiSort();
}
this.Refresh();
}
catch(Exception Err)
{
ErrorBox.Show(Err);
}
}
//-------------------------------------------------------------------------------------
void IBindingList.ApplySort(PropertyDescriptor property, ListSortDirection direction)
{
comparer = null;
ListSortDescription lsd = new ListSortDescription(property, direction);
int pos = sort.FindIndex(delegate(ListSortDescription l)
{
return l.PropertyDescriptor.Name == lsd.PropertyDescriptor.Name;
});
if(pos == -1)
{
sort.Clear();
sort.Add(lsd);
}
else
sort[pos] = lsd;
Sort();
}
// convert from Avalon SortDescriptions to the corresponding .NET collection
private ListSortDescriptionCollection ConvertSortDescriptionCollection(SortDescriptionCollection sorts)
{
PropertyDescriptorCollection pdc;
ITypedList itl;
Type itemType;
if ((itl = InternalList as ITypedList) != null)
{
pdc = itl.GetItemProperties(null);
}
else if ((itemType = GetItemType(true)) != null)
{
pdc = TypeDescriptor.GetProperties(itemType);
}
else
{
pdc = null;
}
if ((pdc == null) || (pdc.Count == 0))
throw new ArgumentException(SR.Get(SRID.CannotDetermineSortByPropertiesForCollection));
ListSortDescription[] sortDescriptions = new ListSortDescription[sorts.Count];
for (int i = 0; i < sorts.Count; i++)
{
PropertyDescriptor dd = pdc.Find(sorts[i].PropertyName, true);
if (dd == null)
{
string typeName = itl.GetListName(null);
throw new ArgumentException(SR.Get(SRID.PropertyToSortByNotFoundOnType, typeName, sorts[i].PropertyName));
}
ListSortDescription sd = new ListSortDescription(dd, sorts[i].Direction);
sortDescriptions[i] = sd;
}
return new ListSortDescriptionCollection(sortDescriptions);
}
public ListSortDescriptionCollection (ListSortDescription[] sorts) {
list = new ArrayList();
foreach (ListSortDescription item in sorts)
list.Add (item);
}
