|
0
|
1 using System;
|
|
|
2
|
|
|
3 using System.Collections;
|
|
|
4 using System.Collections.Specialized;
|
|
|
5 using System.ComponentModel;
|
|
|
6 using System.Diagnostics;
|
|
|
7
|
|
|
8 using BLToolkit.EditableObjects;
|
|
|
9 using BLToolkit.Reflection;
|
|
|
10
|
|
|
11 namespace BLToolkit.ComponentModel
|
|
|
12 {
|
|
|
13 public class BindingListImpl: IBindingListView, ICancelAddNew, INotifyCollectionChanged
|
|
|
14 {
|
|
|
15 #region Init
|
|
|
16
|
|
|
17 public BindingListImpl(IList list, Type itemType)
|
|
|
18 {
|
|
|
19 if (list == null) throw new ArgumentNullException("list");
|
|
|
20 if (itemType == null) throw new ArgumentNullException("itemType");
|
|
|
21
|
|
|
22 _list = list;
|
|
|
23 _itemType = itemType;
|
|
|
24
|
|
|
25 AddInternal(_list);
|
|
|
26 }
|
|
|
27
|
|
|
28 #endregion
|
|
|
29
|
|
|
30 #region Protected Members
|
|
|
31
|
|
|
32 private readonly IList _list;
|
|
|
33 private readonly Type _itemType;
|
|
|
34
|
|
|
35 private void ApplySort(IComparer comparer)
|
|
|
36 {
|
|
|
37 if (_list is ISortable)
|
|
|
38 ((ISortable)_list).Sort(0, _list.Count, comparer);
|
|
|
39 else if (_list is ArrayList)
|
|
|
40 ((ArrayList)_list).Sort(0, _list.Count, comparer);
|
|
|
41 else if (_list is Array)
|
|
|
42 Array.Sort((Array)_list, comparer);
|
|
|
43 else
|
|
|
44 {
|
|
|
45 object[] items = new object[_list.Count];
|
|
|
46
|
|
|
47 _list.CopyTo(items, 0);
|
|
|
48 Array.Sort(items, comparer);
|
|
|
49
|
|
|
50 for (int i = 0; i < _list.Count; i++)
|
|
|
51 _list[i] = items[i];
|
|
|
52 }
|
|
|
53
|
|
|
54 _isSorted = true;
|
|
|
55 }
|
|
|
56
|
|
|
57 #endregion
|
|
|
58
|
|
|
59 #region IBindingList Members
|
|
|
60
|
|
|
61 #region Command
|
|
|
62
|
|
|
63 private int _newItemIndex = -1;
|
|
|
64 private INotifyObjectEdit _newObject;
|
|
|
65
|
|
|
66 public object AddNew()
|
|
|
67 {
|
|
|
68 if (AllowNew == false)
|
|
|
69 throw new NotSupportedException();
|
|
|
70
|
|
|
71 EndNew();
|
|
|
72
|
|
|
73 object o = TypeAccessor.CreateInstanceEx(_itemType);
|
|
|
74 _newObject = o as INotifyObjectEdit;
|
|
|
75
|
|
|
76 if (_newObject != null)
|
|
|
77 _newObject.ObjectEdit += NewObject_ObjectEdit;
|
|
|
78
|
|
|
79 _newItemIndex = _list.Add(o);
|
|
|
80 OnAddItem(o, _newItemIndex);
|
|
|
81
|
|
|
82 Debug.WriteLine(string.Format("AddNew - ({0})", o.GetType().Name));
|
|
|
83
|
|
|
84 return o;
|
|
|
85 }
|
|
|
86
|
|
|
87 void NewObject_ObjectEdit(object sender, ObjectEditEventArgs args)
|
|
|
88 {
|
|
|
89 if (sender == _newObject)
|
|
|
90 {
|
|
|
91 switch (args.EditType)
|
|
|
92 {
|
|
|
93 case ObjectEditType.End: EndNew(); break;
|
|
|
94 case ObjectEditType.Cancel: CancelNew(_newItemIndex); break;
|
|
|
95 default: return;
|
|
|
96 }
|
|
|
97 }
|
|
|
98 }
|
|
|
99
|
|
|
100 public bool AllowNew
|
|
|
101 {
|
|
|
102 get { return !_list.IsFixedSize; }
|
|
|
103 }
|
|
|
104
|
|
|
105 public bool AllowEdit
|
|
|
106 {
|
|
|
107 get { return !_list.IsReadOnly; }
|
|
|
108 }
|
|
|
109
|
|
|
110 public bool AllowRemove
|
|
|
111 {
|
|
|
112 get { return !_list.IsFixedSize; }
|
|
|
113 }
|
|
|
114
|
|
|
115 #endregion
|
|
|
116
|
|
|
117 #region Change Notification
|
|
|
118
|
|
|
119 private bool _notifyChanges = true;
|
|
|
120 public bool NotifyChanges
|
|
|
121 {
|
|
|
122 get { return _notifyChanges; }
|
|
|
123 set { _notifyChanges = value; }
|
|
|
124 }
|
|
|
125
|
|
|
126 public bool SupportsChangeNotification
|
|
|
127 {
|
|
|
128 get { return true; }
|
|
|
129 }
|
|
|
130
|
|
|
131 public event ListChangedEventHandler ListChanged;
|
|
|
132
|
|
|
133 private void FireListChangedEvent(object sender, ListChangedEventArgs e)
|
|
|
134 {
|
|
|
135 if (_notifyChanges && ListChanged != null)
|
|
|
136 ListChanged(sender, e);
|
|
|
137 }
|
|
|
138
|
|
|
139 protected virtual void OnListChanged(EditableListChangedEventArgs e)
|
|
|
140 {
|
|
|
141 FireListChangedEvent(this, e);
|
|
|
142 }
|
|
|
143
|
|
|
144 protected void OnListChanged(ListChangedType listChangedType, int index)
|
|
|
145 {
|
|
|
146 OnListChanged(new EditableListChangedEventArgs(listChangedType, index));
|
|
|
147 }
|
|
|
148
|
|
|
149 private void ItemPropertyChanged(object sender, PropertyChangedEventArgs e)
|
|
|
150 {
|
|
|
151 if (_notifyChanges && sender != null)
|
|
|
152 {
|
|
|
153 int indexOfSender = _list.IndexOf(sender);
|
|
|
154
|
|
|
155 if (indexOfSender >= 0)
|
|
|
156 {
|
|
|
157 MemberAccessor ma = TypeAccessor.GetAccessor(sender.GetType())[e.PropertyName];
|
|
|
158
|
|
|
159 if (ma != null)
|
|
|
160 OnListChanged(new EditableListChangedEventArgs(indexOfSender, ma.PropertyDescriptor));
|
|
|
161 else
|
|
|
162 OnListChanged(new EditableListChangedEventArgs(ListChangedType.ItemChanged, indexOfSender));
|
|
|
163
|
|
|
164 // Do not fire an event for OnCollectionChanged here.
|
|
|
165
|
|
|
166 if (_isSorted && _list.Count > 1)
|
|
|
167 {
|
|
|
168 int newIndex = GetItemSortedPosition(indexOfSender, sender);
|
|
|
169
|
|
|
170 if (newIndex != indexOfSender)
|
|
|
171 {
|
|
|
172 _list.RemoveAt(indexOfSender);
|
|
|
173 _list.Insert(newIndex, sender);
|
|
|
174
|
|
|
175 OnMoveItem(sender, indexOfSender, newIndex);
|
|
|
176 }
|
|
|
177 }
|
|
|
178 }
|
|
|
179 }
|
|
|
180 }
|
|
|
181
|
|
|
182 #endregion
|
|
|
183
|
|
|
184 #region Sorting
|
|
|
185
|
|
|
186 public bool SupportsSorting
|
|
|
187 {
|
|
|
188 get { return true; }
|
|
|
189 }
|
|
|
190
|
|
|
191 [NonSerialized]
|
|
|
192 private bool _isSorted;
|
|
|
193 public bool IsSorted
|
|
|
194 {
|
|
|
195 get { return _isSorted; }
|
|
|
196 }
|
|
|
197
|
|
|
198 [NonSerialized]
|
|
|
199 private PropertyDescriptor _sortProperty;
|
|
|
200 public PropertyDescriptor SortProperty
|
|
|
201 {
|
|
|
202 get { return _sortProperty; }
|
|
|
203 }
|
|
|
204
|
|
|
205 [NonSerialized]
|
|
|
206 private ListSortDirection _sortDirection;
|
|
|
207 public ListSortDirection SortDirection
|
|
|
208 {
|
|
|
209 get { return _sortDirection; }
|
|
|
210 }
|
|
|
211
|
|
|
212 public void ApplySort(PropertyDescriptor property, ListSortDirection direction)
|
|
|
213 {
|
|
|
214 Debug.WriteLine(string.Format("Begin ApplySort(\"{0}\", {1})", property.Name, direction));
|
|
|
215
|
|
|
216 _sortProperty = property;
|
|
|
217 _sortDirection = direction;
|
|
|
218 _sortDescriptions = null;
|
|
|
219
|
|
|
220 ApplySort(GetSortComparer(_sortProperty, _sortDirection));
|
|
|
221
|
|
|
222 if (_list.Count > 0)
|
|
|
223 OnReset();
|
|
|
224
|
|
|
225 Debug.WriteLine(string.Format("End ApplySort(\"{0}\", {1})", property.Name, direction));
|
|
|
226 }
|
|
|
227
|
|
|
228 public void RemoveSort()
|
|
|
229 {
|
|
|
230 _isSorted = false;
|
|
|
231 _sortProperty = null;
|
|
|
232 _sortDescriptions = null;
|
|
|
233
|
|
|
234 OnReset();
|
|
|
235 }
|
|
|
236
|
|
|
237 #endregion
|
|
|
238
|
|
|
239 #region Searching
|
|
|
240
|
|
|
241 public bool SupportsSearching
|
|
|
242 {
|
|
|
243 get { return true; }
|
|
|
244 }
|
|
|
245
|
|
|
246 public int Find(PropertyDescriptor property, object key)
|
|
|
247 {
|
|
|
248 if (property == null) throw new ArgumentException("property");
|
|
|
249
|
|
|
250 if (key != null)
|
|
|
251 for (int i = 0; i < _list.Count; i++)
|
|
|
252 if (key.Equals(property.GetValue(_list[i])))
|
|
|
253 return i;
|
|
|
254
|
|
|
255 return -1;
|
|
|
256 }
|
|
|
257
|
|
|
258 #endregion
|
|
|
259
|
|
|
260 #region Indexes
|
|
|
261
|
|
|
262 public void AddIndex(PropertyDescriptor property)
|
|
|
263 {
|
|
|
264 }
|
|
|
265
|
|
|
266 public void RemoveIndex(PropertyDescriptor property)
|
|
|
267 {
|
|
|
268 }
|
|
|
269
|
|
|
270 #endregion
|
|
|
271
|
|
|
272 #endregion
|
|
|
273
|
|
|
274 #region ICancelAddNew Members
|
|
|
275
|
|
|
276 public void CancelNew(int itemIndex)
|
|
|
277 {
|
|
|
278 if (itemIndex >= 0 && itemIndex == _newItemIndex)
|
|
|
279 {
|
|
|
280 _list.RemoveAt(itemIndex);
|
|
|
281 OnRemoveItem(_newObject, itemIndex);
|
|
|
282 EndNew();
|
|
|
283 }
|
|
|
284 }
|
|
|
285
|
|
|
286 public void EndNew(int itemIndex)
|
|
|
287 {
|
|
|
288 if (itemIndex == _newItemIndex)
|
|
|
289 EndNew();
|
|
|
290 }
|
|
|
291
|
|
|
292 public void EndNew()
|
|
|
293 {
|
|
|
294 _newItemIndex = -1;
|
|
|
295
|
|
|
296 if (_newObject != null)
|
|
|
297 _newObject.ObjectEdit -= NewObject_ObjectEdit;
|
|
|
298
|
|
|
299 _newObject = null;
|
|
|
300 }
|
|
|
301
|
|
|
302 #endregion
|
|
|
303
|
|
|
304 #region IList Members
|
|
|
305
|
|
|
306 public int Add(object value)
|
|
|
307 {
|
|
|
308 int index;
|
|
|
309
|
|
|
310 if (!_isSorted)
|
|
|
311 index = _list.Add(value);
|
|
|
312 else
|
|
|
313 {
|
|
|
314 index = GetSortedInsertIndex(value);
|
|
|
315 _list.Insert(index, value);
|
|
|
316 }
|
|
|
317
|
|
|
318 AddInternal(value);
|
|
|
319 OnAddItem(value, index);
|
|
|
320
|
|
|
321 return index;
|
|
|
322 }
|
|
|
323
|
|
|
324 public void Clear()
|
|
|
325 {
|
|
|
326 if (_list.Count > 0)
|
|
|
327 {
|
|
|
328 RemoveInternal(_list);
|
|
|
329
|
|
|
330 _list.Clear();
|
|
|
331 OnReset();
|
|
|
332 }
|
|
|
333 }
|
|
|
334
|
|
|
335 public bool Contains(object value)
|
|
|
336 {
|
|
|
337 return _list.Contains(value);
|
|
|
338 }
|
|
|
339
|
|
|
340 public int IndexOf(object value)
|
|
|
341 {
|
|
|
342 return _list.IndexOf(value);
|
|
|
343 }
|
|
|
344
|
|
|
345 public void Insert(int index, object value)
|
|
|
346 {
|
|
|
347 if (_isSorted)
|
|
|
348 index = GetSortedInsertIndex(value);
|
|
|
349
|
|
|
350 _list.Insert(index, value);
|
|
|
351 AddInternal(value);
|
|
|
352
|
|
|
353 OnAddItem(value, index);
|
|
|
354 }
|
|
|
355
|
|
|
356 public bool IsFixedSize
|
|
|
357 {
|
|
|
358 get { return _list.IsFixedSize; }
|
|
|
359 }
|
|
|
360
|
|
|
361 public bool IsReadOnly
|
|
|
362 {
|
|
|
363 get { return _list.IsReadOnly; }
|
|
|
364 }
|
|
|
365
|
|
|
366 public void Remove(object value)
|
|
|
367 {
|
|
|
368 int index = IndexOf(value);
|
|
|
369
|
|
|
370 if (index >= 0)
|
|
|
371 RemoveInternal(value);
|
|
|
372
|
|
|
373 _list.Remove(value);
|
|
|
374
|
|
|
375 if (index >= 0)
|
|
|
376 OnRemoveItem(value, index);
|
|
|
377 }
|
|
|
378
|
|
|
379 public void RemoveAt(int index)
|
|
|
380 {
|
|
|
381 object value = this[index];
|
|
|
382
|
|
|
383 RemoveInternal(value);
|
|
|
384
|
|
|
385 _list.RemoveAt(index);
|
|
|
386
|
|
|
387 OnRemoveItem(value, index);
|
|
|
388 }
|
|
|
389
|
|
|
390 public object this[int index]
|
|
|
391 {
|
|
|
392 get { return _list[index]; }
|
|
|
393 set
|
|
|
394 {
|
|
|
395 object o = _list[index];
|
|
|
396
|
|
|
397 if (o != value)
|
|
|
398 {
|
|
|
399 RemoveInternal(o);
|
|
|
400
|
|
|
401 _list[index] = value;
|
|
|
402
|
|
|
403 AddInternal(value);
|
|
|
404
|
|
|
405 OnChangeItem(o, value, index);
|
|
|
406
|
|
|
407 if (_isSorted)
|
|
|
408 {
|
|
|
409 int newIndex = GetItemSortedPosition(index, value);
|
|
|
410
|
|
|
411 if (newIndex != index)
|
|
|
412 {
|
|
|
413 _list.RemoveAt(index);
|
|
|
414 _list.Insert(newIndex, value);
|
|
|
415 }
|
|
|
416
|
|
|
417 OnMoveItem(value, index, newIndex);
|
|
|
418 }
|
|
|
419 }
|
|
|
420 }
|
|
|
421 }
|
|
|
422
|
|
|
423 #endregion
|
|
|
424
|
|
|
425 #region ICollection Members
|
|
|
426
|
|
|
427 public void CopyTo(Array array, int index)
|
|
|
428 {
|
|
|
429 _list.CopyTo(array, index);
|
|
|
430 }
|
|
|
431
|
|
|
432 public int Count
|
|
|
433 {
|
|
|
434 get { return _list.Count; }
|
|
|
435 }
|
|
|
436
|
|
|
437 public bool IsSynchronized
|
|
|
438 {
|
|
|
439 get { return _list.IsSynchronized; }
|
|
|
440 }
|
|
|
441
|
|
|
442 public object SyncRoot
|
|
|
443 {
|
|
|
444 get { return _list.SyncRoot; }
|
|
|
445 }
|
|
|
446
|
|
|
447 #endregion
|
|
|
448
|
|
|
449 #region IEnumerable Members
|
|
|
450
|
|
|
451 public IEnumerator GetEnumerator()
|
|
|
452 {
|
|
|
453 return _list.GetEnumerator();
|
|
|
454 }
|
|
|
455
|
|
|
456 #endregion
|
|
|
457
|
|
|
458 #region SortPropertyComparer
|
|
|
459
|
|
|
460 class SortPropertyComparer : IComparer
|
|
|
461 {
|
|
|
462 readonly PropertyDescriptor _property;
|
|
|
463 readonly ListSortDirection _direction;
|
|
|
464
|
|
|
465 public SortPropertyComparer(PropertyDescriptor property, ListSortDirection direction)
|
|
|
466 {
|
|
|
467 _property = property;
|
|
|
468 _direction = direction;
|
|
|
469 }
|
|
|
470
|
|
|
471 public int Compare(object x, object y)
|
|
|
472 {
|
|
|
473 object a = _property.GetValue(x);
|
|
|
474 object b = _property.GetValue(y);
|
|
|
475
|
|
|
476 int n = Comparer.Default.Compare(a, b);
|
|
|
477
|
|
|
478 return _direction == ListSortDirection.Ascending? n: -n;
|
|
|
479 }
|
|
|
480 }
|
|
|
481
|
|
|
482 #endregion
|
|
|
483
|
|
|
484 #region IComparer Accessor
|
|
|
485
|
|
|
486 public IComparer GetSortComparer()
|
|
|
487 {
|
|
|
488 if (_isSorted)
|
|
|
489 {
|
|
|
490 if (_sortDescriptions != null)
|
|
|
491 return GetSortComparer(_sortDescriptions);
|
|
|
492
|
|
|
493 return GetSortComparer(_sortProperty, _sortDirection);
|
|
|
494 }
|
|
|
495
|
|
|
496 return null;
|
|
|
497 }
|
|
|
498
|
|
|
499 private IComparer GetSortComparer(PropertyDescriptor sortProperty, ListSortDirection sortDirection)
|
|
|
500 {
|
|
|
501 if (_sortSubstitutions.ContainsKey(sortProperty.Name))
|
|
|
502 sortProperty = ((SortSubstitutionPair)_sortSubstitutions[sortProperty.Name]).Substitute;
|
|
|
503
|
|
|
504 return new SortPropertyComparer(sortProperty, sortDirection);
|
|
|
505 }
|
|
|
506
|
|
|
507 private IComparer GetSortComparer(ListSortDescriptionCollection sortDescriptions)
|
|
|
508 {
|
|
|
509 bool needSubstitution = false;
|
|
|
510
|
|
|
511 if (_sortSubstitutions.Count > 0)
|
|
|
512 {
|
|
|
513 foreach (ListSortDescription sortDescription in sortDescriptions)
|
|
|
514 {
|
|
|
515 if (_sortSubstitutions.ContainsKey(sortDescription.PropertyDescriptor.Name))
|
|
|
516 {
|
|
|
517 needSubstitution = true;
|
|
|
518 break;
|
|
|
519 }
|
|
|
520 }
|
|
|
521
|
|
|
522 if (needSubstitution)
|
|
|
523 {
|
|
|
524 ListSortDescription[] sorts = new ListSortDescription[sortDescriptions.Count];
|
|
|
525 sortDescriptions.CopyTo(sorts, 0);
|
|
|
526
|
|
|
527 for (int i = 0; i < sorts.Length; i++)
|
|
|
528 if (_sortSubstitutions.ContainsKey(sorts[i].PropertyDescriptor.Name))
|
|
|
529 sorts[i] = new ListSortDescription(((SortSubstitutionPair)_sortSubstitutions[sorts[i].PropertyDescriptor.Name]).Substitute,
|
|
|
530 sorts[i].SortDirection);
|
|
|
531
|
|
|
532 sortDescriptions = new ListSortDescriptionCollection(sorts);
|
|
|
533 }
|
|
|
534 }
|
|
|
535
|
|
|
536 return new SortListPropertyComparer(sortDescriptions);
|
|
|
537 }
|
|
|
538
|
|
|
539 #endregion
|
|
|
540
|
|
|
541 #region IBindingListView Members
|
|
|
542
|
|
|
543 public bool SupportsAdvancedSorting
|
|
|
544 {
|
|
|
545 get { return true; }
|
|
|
546 }
|
|
|
547
|
|
|
548 public void ApplySort(ListSortDescriptionCollection sorts)
|
|
|
549 {
|
|
|
550 _sortDescriptions = sorts;
|
|
|
551
|
|
|
552 _isSorted = true;
|
|
|
553 _sortProperty = null;
|
|
|
554
|
|
|
555 ApplySort(GetSortComparer(sorts));
|
|
|
556
|
|
|
557 if (_list.Count > 0)
|
|
|
558 OnReset();
|
|
|
559 }
|
|
|
560
|
|
|
561 [NonSerialized]
|
|
|
562 private ListSortDescriptionCollection _sortDescriptions;
|
|
|
563 public ListSortDescriptionCollection SortDescriptions
|
|
|
564 {
|
|
|
565 get { return _sortDescriptions; }
|
|
|
566 }
|
|
|
567
|
|
|
568 public bool SupportsFiltering
|
|
|
569 {
|
|
|
570 get { return false; }
|
|
|
571 }
|
|
|
572
|
|
|
573 public string Filter
|
|
|
574 {
|
|
|
575 get { throw new NotImplementedException("The method 'BindingListImpl.get_Filter' is not implemented."); }
|
|
|
576 set { throw new NotImplementedException("The method 'BindingListImpl.set_Filter' is not implemented."); }
|
|
|
577 }
|
|
|
578
|
|
|
579 public void RemoveFilter()
|
|
|
580 {
|
|
|
581 throw new NotImplementedException("The method 'BindingListImpl.RemoveFilter()' is not implemented.");
|
|
|
582 }
|
|
|
583
|
|
|
584 #endregion
|
|
|
585
|
|
|
586 #region SortListPropertyComparer
|
|
|
587
|
|
|
588 class SortListPropertyComparer : IComparer
|
|
|
589 {
|
|
|
590 readonly ListSortDescriptionCollection _sorts;
|
|
|
591
|
|
|
592 public SortListPropertyComparer(ListSortDescriptionCollection sorts)
|
|
|
593 {
|
|
|
594 _sorts = sorts;
|
|
|
595 }
|
|
|
596
|
|
|
597 public int Compare(object x, object y)
|
|
|
598 {
|
|
|
599 for (int i = 0; i < _sorts.Count; i++)
|
|
|
600 {
|
|
|
601 PropertyDescriptor property = _sorts[i].PropertyDescriptor;
|
|
|
602
|
|
|
603 object a = property.GetValue(x);
|
|
|
604 object b = property.GetValue(y);
|
|
|
605
|
|
|
606 int n = Comparer.Default.Compare(a, b);
|
|
|
607
|
|
|
608 if (n != 0)
|
|
|
609 return _sorts[i].SortDirection == ListSortDirection.Ascending? n: -n;
|
|
|
610 }
|
|
|
611
|
|
|
612 return 0;
|
|
|
613 }
|
|
|
614 }
|
|
|
615
|
|
|
616 #endregion
|
|
|
617
|
|
|
618 #region Sorting enhancement
|
|
|
619
|
|
|
620 private readonly Hashtable _sortSubstitutions = new Hashtable();
|
|
|
621
|
|
|
622 private class SortSubstitutionPair
|
|
|
623 {
|
|
|
624 public SortSubstitutionPair(PropertyDescriptor original, PropertyDescriptor substitute)
|
|
|
625 {
|
|
|
626 Original = original;
|
|
|
627 Substitute = substitute;
|
|
|
628 }
|
|
|
629
|
|
|
630 public readonly PropertyDescriptor Original;
|
|
|
631 public readonly PropertyDescriptor Substitute;
|
|
|
632 }
|
|
|
633
|
|
|
634 public void CreateSortSubstitution(string originalProperty, string substituteProperty)
|
|
|
635 {
|
|
|
636 TypeAccessor typeAccessor = TypeAccessor.GetAccessor(_itemType);
|
|
|
637
|
|
|
638 PropertyDescriptor originalDescriptor = typeAccessor.PropertyDescriptors[originalProperty];
|
|
|
639 PropertyDescriptor substituteDescriptor = typeAccessor.PropertyDescriptors[substituteProperty];
|
|
|
640
|
|
|
641 if (originalDescriptor == null) throw new InvalidOperationException("Can not retrieve PropertyDescriptor for original property: " + originalProperty);
|
|
|
642 if (substituteDescriptor == null) throw new InvalidOperationException("Can not retrieve PropertyDescriptor for substitute property: " + substituteProperty);
|
|
|
643
|
|
|
644 _sortSubstitutions[originalProperty] = new SortSubstitutionPair(originalDescriptor, substituteDescriptor);
|
|
|
645 }
|
|
|
646
|
|
|
647 public void RemoveSortSubstitution(string originalProperty)
|
|
|
648 {
|
|
|
649 _sortSubstitutions.Remove(originalProperty);
|
|
|
650 }
|
|
|
651
|
|
|
652 #endregion
|
|
|
653
|
|
|
654 #region Sort enforcement
|
|
|
655
|
|
|
656 public int GetItemSortedPosition(int index, object sender)
|
|
|
657 {
|
|
|
658 IComparer comparer = GetSortComparer();
|
|
|
659
|
|
|
660 if (comparer == null)
|
|
|
661 return index;
|
|
|
662
|
|
|
663 if ((index > 0 && comparer.Compare(_list[index - 1], sender) > 0) ||
|
|
|
664 (index < _list.Count - 1 && comparer.Compare(_list[index + 1], sender) < 0))
|
|
|
665 {
|
|
|
666 for (int i = 0; i < _list.Count; i++)
|
|
|
667 {
|
|
|
668 if (i != index && comparer.Compare(_list[i], sender) > 0)
|
|
|
669 {
|
|
|
670 if (i > index)
|
|
|
671 return i - 1;
|
|
|
672
|
|
|
673 return i;
|
|
|
674 }
|
|
|
675 }
|
|
|
676
|
|
|
677 return _list.Count - 1;
|
|
|
678 }
|
|
|
679
|
|
|
680 return index;
|
|
|
681 }
|
|
|
682
|
|
|
683 public int GetSortedInsertIndex(object value)
|
|
|
684 {
|
|
|
685 IComparer comparer = GetSortComparer();
|
|
|
686
|
|
|
687 if (comparer == null)
|
|
|
688 return -1;
|
|
|
689
|
|
|
690 for (int i = 0; i < _list.Count; i++)
|
|
|
691 if (comparer.Compare(_list[i], value) > 0)
|
|
|
692 return i;
|
|
|
693
|
|
|
694 return _list.Count;
|
|
|
695 }
|
|
|
696
|
|
|
697 #endregion
|
|
|
698
|
|
|
699 #region Misc/Range Operations
|
|
|
700
|
|
|
701 public void Move(int newIndex, int oldIndex)
|
|
|
702 {
|
|
|
703 if (oldIndex != newIndex)
|
|
|
704 {
|
|
|
705 EndNew();
|
|
|
706
|
|
|
707 object o = _list[oldIndex];
|
|
|
708
|
|
|
709 _list.RemoveAt(oldIndex);
|
|
|
710 if (!_isSorted)
|
|
|
711 _list.Insert(newIndex, o);
|
|
|
712 else
|
|
|
713 _list.Insert(newIndex = GetSortedInsertIndex(o), o);
|
|
|
714
|
|
|
715 OnMoveItem(o, oldIndex, newIndex);
|
|
|
716 }
|
|
|
717 }
|
|
|
718
|
|
|
719 public void AddRange(ICollection c)
|
|
|
720 {
|
|
|
721 foreach (object o in c)
|
|
|
722 {
|
|
|
723 if (!_isSorted)
|
|
|
724 _list.Add(o);
|
|
|
725 else
|
|
|
726 _list.Insert(GetSortedInsertIndex(o), o);
|
|
|
727 }
|
|
|
728
|
|
|
729 AddInternal(c);
|
|
|
730
|
|
|
731 OnReset();
|
|
|
732 }
|
|
|
733
|
|
|
734 public void InsertRange(int index, ICollection c)
|
|
|
735 {
|
|
|
736 if (c.Count == 0)
|
|
|
737 return;
|
|
|
738
|
|
|
739 foreach (object o in c)
|
|
|
740 {
|
|
|
741 if (!_isSorted)
|
|
|
742 _list.Insert(index++, o);
|
|
|
743 else
|
|
|
744 _list.Insert(GetSortedInsertIndex(o), o);
|
|
|
745 }
|
|
|
746
|
|
|
747 AddInternal(c);
|
|
|
748
|
|
|
749 OnReset();
|
|
|
750 }
|
|
|
751
|
|
|
752 public void RemoveRange(int index, int count)
|
|
|
753 {
|
|
|
754 object[] toRemove = new object[count];
|
|
|
755
|
|
|
756 for (int i = index; i < _list.Count && i < index + count; i++)
|
|
|
757 toRemove[i - index] = _list[i];
|
|
|
758
|
|
|
759 RemoveInternal(toRemove);
|
|
|
760
|
|
|
761 foreach (object o in toRemove)
|
|
|
762 _list.Remove(o);
|
|
|
763
|
|
|
764 OnReset();
|
|
|
765 }
|
|
|
766
|
|
|
767 public void SetRange(int index, ICollection c)
|
|
|
768 {
|
|
|
769 int cCount = c.Count;
|
|
|
770
|
|
|
771 if (index < 0 || index >= _list.Count - cCount)
|
|
|
772 throw new ArgumentOutOfRangeException("index");
|
|
|
773
|
|
|
774 bool oldNotifyChanges = _notifyChanges;
|
|
|
775 _notifyChanges = false;
|
|
|
776
|
|
|
777 int i = index;
|
|
|
778 foreach (object newObject in c)
|
|
|
779 {
|
|
|
780 RemoveInternal(_list[i + index]);
|
|
|
781 _list[i + index] = newObject;
|
|
|
782 }
|
|
|
783
|
|
|
784 AddInternal(c);
|
|
|
785
|
|
|
786 if (_isSorted)
|
|
|
787 ApplySort(GetSortComparer());
|
|
|
788
|
|
|
789 _notifyChanges = oldNotifyChanges;
|
|
|
790 OnReset();
|
|
|
791 }
|
|
|
792
|
|
|
793 #endregion
|
|
|
794
|
|
|
795 #region Add/Remove Internal
|
|
|
796
|
|
|
797 private void AddInternal(object value)
|
|
|
798 {
|
|
|
799 EndNew();
|
|
|
800
|
|
|
801 if (value is INotifyPropertyChanged)
|
|
|
802 ((INotifyPropertyChanged)value).PropertyChanged +=
|
|
|
803 ItemPropertyChanged;
|
|
|
804 }
|
|
|
805
|
|
|
806 private void RemoveInternal(object value)
|
|
|
807 {
|
|
|
808 EndNew();
|
|
|
809
|
|
|
810 if (value is INotifyPropertyChanged)
|
|
|
811 ((INotifyPropertyChanged)value).PropertyChanged -=
|
|
|
812 ItemPropertyChanged;
|
|
|
813 }
|
|
|
814
|
|
|
815 private void AddInternal(IEnumerable e)
|
|
|
816 {
|
|
|
817 foreach (object o in e)
|
|
|
818 AddInternal(o);
|
|
|
819 }
|
|
|
820
|
|
|
821 private void RemoveInternal(IEnumerable e)
|
|
|
822 {
|
|
|
823 foreach (object o in e)
|
|
|
824 RemoveInternal(o);
|
|
|
825 }
|
|
|
826
|
|
|
827 private void OnAddItem(object item, int index)
|
|
|
828 {
|
|
|
829 OnListChanged(new EditableListChangedEventArgs(ListChangedType.ItemAdded, index));
|
|
|
830 OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, index));
|
|
|
831 }
|
|
|
832
|
|
|
833 private void OnRemoveItem(object item, int index)
|
|
|
834 {
|
|
|
835 OnListChanged(new EditableListChangedEventArgs(ListChangedType.ItemDeleted, index));
|
|
|
836 OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item, index));
|
|
|
837 }
|
|
|
838
|
|
|
839 private void OnMoveItem(object item, int oldIndex, int newIndex)
|
|
|
840 {
|
|
|
841 OnListChanged(new EditableListChangedEventArgs(newIndex, oldIndex));
|
|
|
842 OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move, item, newIndex, oldIndex));
|
|
|
843 }
|
|
|
844
|
|
|
845 private void OnChangeItem(object oldValue, object newValue, int index)
|
|
|
846 {
|
|
|
847 OnListChanged(new EditableListChangedEventArgs(ListChangedType.ItemChanged, index));
|
|
|
848 OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, oldValue, newValue, index));
|
|
|
849 }
|
|
|
850
|
|
|
851 private void OnReset()
|
|
|
852 {
|
|
|
853 OnListChanged(new EditableListChangedEventArgs(ListChangedType.Reset));
|
|
|
854 OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
|
|
|
855 }
|
|
|
856
|
|
|
857 #endregion
|
|
|
858
|
|
|
859 #region INotifyCollectionChanged Members
|
|
|
860
|
|
|
861 public event NotifyCollectionChangedEventHandler CollectionChanged;
|
|
|
862
|
|
|
863 private void FireCollectionChangedEvent(object sender, NotifyCollectionChangedEventArgs ea)
|
|
|
864 {
|
|
|
865 if (_notifyChanges && CollectionChanged != null)
|
|
|
866 CollectionChanged(sender, ea);
|
|
|
867 }
|
|
|
868
|
|
|
869 protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs ea)
|
|
|
870 {
|
|
|
871 FireCollectionChangedEvent(this, ea);
|
|
|
872 }
|
|
|
873
|
|
|
874 #endregion
|
|
|
875 }
|
|
|
876 }
|
