public int CompareByMemberProperty(CodeMember other, Tuple <MemberProperty, bool> propertyOrder)
{
int result = 0;
switch (propertyOrder.Item1)
{
case MemberProperty.Kind:
result = (int)this.Kind - (int)other.Kind;
break;
case MemberProperty.Name:
result = string.Compare(this.Name, other.Name);
break;
case MemberProperty.IsStatic:
// Static members come before instance members.
result = (this.IsStatic ? -1 : 0) - (other.IsStatic ? -1 : 0);
break;
case MemberProperty.Access:
result = (int)this.Access - (int)other.Access;
break;
case MemberProperty.ParameterCount:
result = this.ParameterCount - other.ParameterCount;
break;
case MemberProperty.OverrideModifier:
result = CompareModifiers((int?)this.OverrideModifier, (int?)other.OverrideModifier);
break;
case MemberProperty.ConstModifier:
result = CompareModifiers((int?)this.ConstModifier, (int?)other.ConstModifier);
break;
case MemberProperty.KindModifier:
result = CompareModifiers((int?)this.KindModifier, (int?)other.KindModifier);
break;
default:
throw new NotSupportedException("Unsupported property: " + propertyOrder.Item1);
}
// Negate the result if we're supposed to sort this property in descending order.
if (!propertyOrder.Item2)
{
result = -result;
}
return(result);
}
public int CompareByMemberProperties(CodeMember other, IEnumerable <Tuple <MemberProperty, bool> > sortOrder)
{
int result = 0;
foreach (Tuple <MemberProperty, bool> tuple in sortOrder)
{
result = this.CompareByMemberProperty(other, tuple);
if (result != 0)
{
break;
}
}
return(result);
}
private void List_Drop(object sender, DragEventArgs e)
{
Tuple <ListViewItem, List <CodeMember> > dropTargetInfo = this.GetDropTargetInfo(e);
if (dropTargetInfo != null)
{
this.ClearDragMembers();
ListViewItem listItem = dropTargetInfo.Item1;
List <CodeMember> selectedMembers = dropTargetInfo.Item2;
int targetIndex = this.list.Items.IndexOf(listItem.Content);
if (targetIndex >= 0)
{
// If the drop point is in the bottom half of the ListViewItem, then increment targetIndex
// so we'll insert the items after the target ListViewItem instead of before it. This allows
// people to drop between items and (almost) after the last item as expected.
if (IsInBottomHalfOfItem(e, listItem))
{
targetIndex++;
}
// The selected members may not be in top-to-bottom order in the list (depending on the order
// they were clicked and/or added to the ListView's SelectedItems collection), so we need to
// get them in visual order so we can re-insert them that way.
List <Tuple <CodeMember, int> > orderedSelection = selectedMembers
.Select(member => Tuple.Create(member, this.list.Items.IndexOf(member)))
.OrderBy(tuple => tuple.Item2).ToList();
int numberOfSelectedItemsBeforeTarget = orderedSelection.Count(tuple => tuple.Item2 < targetIndex);
targetIndex -= numberOfSelectedItemsBeforeTarget;
foreach (var tuple in orderedSelection)
{
CodeMember member = tuple.Item1;
this.observableMembers.Remove(member);
}
foreach (var tuple in orderedSelection)
{
CodeMember member = tuple.Item1;
this.observableMembers.Insert(targetIndex++, member);
this.list.SelectedItems.Add(member);
}
}
}
}
public int CompareByStartPoint(CodeMember other)
{
int result = 0;
TextPoint thisStart = this.element.StartPoint;
TextPoint otherStart = other.element.StartPoint;
if (thisStart.LessThan(otherStart))
{
result = -1;
}
else if (otherStart.LessThan(thisStart))
{
result = 1;
}
return(result);
}
private void Sort_Click(object sender, RoutedEventArgs e)
{
if (this.sortMembers != null && this.list.SelectedItems.Count > 0)
{
List <CodeMember> selectedMembers = this.list.SelectedItems.Cast <CodeMember>().ToList();
Dictionary <CodeMember, int> selectedIndexes = selectedMembers
.ToDictionary(member => member, member => this.observableMembers.IndexOf(member));
foreach (var typeGroup in selectedMembers.GroupBy(member => member.TypeElement))
{
List <CodeMember> typeMembers = typeGroup.ToList();
this.sortMembers(typeMembers);
// Get the selected indexes for the current type members in index order (i.e., from top to bottom in the list).
List <int> sortedIndexes = typeMembers.Select(member => selectedIndexes[member]).OrderBy(index => index).ToList();
int itemCount = sortedIndexes.Count;
// First, we have to take all the items out of the list. The ListView's data binding
// logic gets really confused if we ever have the same item in the list multiple times,
// and it can't restore SelectedItems properly after that. By nulling all the items
// out first, we can replace the items in sorted order, and data binding stays happy.
foreach (int index in sortedIndexes)
{
this.observableMembers[index] = null;
}
// Put the sorted members back in the type's selected ListView rows (but in sorted order).
for (int i = 0; i < itemCount; i++)
{
CodeMember member = typeMembers[i];
int index = sortedIndexes[i];
this.observableMembers[index] = member;
}
}
// Restore the list's selected items now that they're replaced in sorted order.
// Note: this.list.SelectedItems should be empty now because we temporarily
// nulled out all the selected items above.
foreach (var pair in selectedIndexes)
{
this.list.SelectedItems.Add(pair.Key);
}
}
}
private static bool IsOrderedByGroupingProperty(List <CodeMember> members, Tuple <MemberProperty, bool> groupingProperty)
{
bool result = true;
CodeMember previousMember = null;
foreach (CodeMember member in members)
{
if (previousMember != null && previousMember.CompareByMemberProperty(member, groupingProperty) > 0)
{
result = false;
break;
}
previousMember = member;
}
return(result);
}
private Tuple <ListViewItem, List <CodeMember> > GetDropTargetInfo(DragEventArgs e)
{
Tuple <ListViewItem, List <CodeMember> > result = null;
Point dropPoint = e.GetPosition(this.list);
ListViewItem listViewItem = this.GetItemTargetInfo(dropPoint);
if (listViewItem != null)
{
CodeMember targetMember = listViewItem.Content as CodeMember;
if (targetMember != null && e.Data.GetDataPresent(typeof(List <CodeMember>)))
{
// Make sure they're dropping members within the same type they originated from.
// We don't support dragging members into different types.
List <CodeMember> selectedMembers = (List <CodeMember>)e.Data.GetData(typeof(List <CodeMember>));
if (selectedMembers.Count > 0 && selectedMembers[0].TypeElement == targetMember.TypeElement)
{
result = Tuple.Create(listViewItem, selectedMembers);
}
}
}
return(result);
}
