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); }