Fixed SD2-1123. Code coverage vist count list view is now sortable by column.

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/branches/2.1@2324 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/Misc/CodeCoverage/Project/CodeCoverage.csproj

@@ -52,6 +52,7 @@
     <Compile Include="Src\CodeCoverageMethodTreeNode.cs" />
     <Compile Include="Src\CodeCoverageClassTreeNode.cs" />
     <Compile Include="Src\CodeCoverageNamespaceTreeNode.cs" />
+    <Compile Include="Src\SequencePointListViewSorter.cs" />
     <Compile Include="Src\ToggleCodeCoverageCommand.cs" />
     <Compile Include="Src\CodeCoverageHighlighter.cs" />
     <Compile Include="Src\CodeCoverageTextMarker.cs" />

src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageControl.cs

@@ -31,6 +31,7 @@ namespace ICSharpCode.CodeCoverage
 		ToolStrip toolStrip;
 		bool showSourceCodePanel;
 		bool showVisitCountPanel = true;
+		SequencePointListViewSorter sequencePointListViewSorter;
 		
 		public CodeCoverageControl()
 		{
@@ -338,7 +339,7 @@ namespace ICSharpCode.CodeCoverage
 			listView.FullRowSelect = true;
 			listView.HideSelection = false;
 			listView.ItemActivate += ListViewItemActivate;
-			
+						
 			visitCountColumnHeader = new ColumnHeader();
 			visitCountColumnHeader.Text = StringParser.Parse("${res:ICSharpCode.CodeCoverage.VisitCount}");
 			visitCountColumnHeader.Width = 80;
@@ -364,6 +365,9 @@ namespace ICSharpCode.CodeCoverage
 			                          startColumnColumnHeader,
 			                          endLineColumnHeader,
 			                          endColumnColumnHeader});
+			
+			// Create custom list view sorter.
+			sequencePointListViewSorter = new SequencePointListViewSorter(listView);
 		}
 						
 		void DisposeListView()
@@ -383,6 +387,8 @@ namespace ICSharpCode.CodeCoverage
 			listView.ItemActivate -= ListViewItemActivate;
 			listView.Dispose();
 			listView = null;
+			
+			sequencePointListViewSorter.Dispose();
 		}
 		
 		void CreateVerticalSplitContainer()

src/AddIns/Misc/CodeCoverage/Project/Src/SequencePointListViewSorter.cs

@@ -0,0 +1,140 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections;
+using System.Windows.Forms;
+
+namespace ICSharpCode.CodeCoverage
+{
+	/// <summary>
+	/// Sorts the list view that contains code coverage sequence
+	/// points.
+	/// </summary>
+	public class SequencePointListViewSorter : IComparer, IDisposable
+	{
+		ListView listView;
+		int column = -1;
+		SortOrder sortOrder = SortOrder.None;
+		
+		const int VisitCountColumn = 0;
+		const int SequencePointLineColumn = 1;
+		const int SequencePointStartColumnColumn = 2;
+		const int SequencePointEndLineColumn = 3;
+		const int SequencePointEndColumnColumn = 4;
+		
+		public SequencePointListViewSorter(ListView listView)
+		{
+			this.listView = listView;
+			listView.ListViewItemSorter = this;
+			listView.ColumnClick += ListViewColumnClick;
+		}
+		
+		public void Dispose()
+		{
+			if (listView != null) {
+				listView.ColumnClick -= ListViewColumnClick;
+			}
+		}
+		
+		/// <summary>
+		/// Compares two list view items and sorts them according
+		/// to the currently sorted column.
+		/// </summary>
+		public int Compare(object x, object y)
+		{
+			CodeCoverageSequencePoint lhs = null;
+			CodeCoverageSequencePoint rhs = null;
+			
+			ListViewItem item = x as ListViewItem;
+			if (item != null) {
+				lhs = item.Tag as CodeCoverageSequencePoint;
+			}
+			
+			item = y as ListViewItem;
+			if (item != null) {
+				rhs = item.Tag as CodeCoverageSequencePoint;
+			}
+			
+			if (lhs != null && rhs != null) {
+				return Compare(lhs, rhs);
+			}
+			return 0;
+		}
+		
+		/// <summary>
+		/// Sorts the list view by the specified column.
+		/// </summary>
+		public void Sort(int column)
+		{
+			if (this.column == column) {
+				ToggleSortOrder();
+			} else {
+				sortOrder = SortOrder.Ascending;
+			}
+			this.column = column;
+			listView.Sort();
+		}
+		
+		/// <summary>
+		/// Compares two code coverage sequence points based on the
+		/// currently sorted column and sort order.
+		/// </summary>
+		int Compare(CodeCoverageSequencePoint x, CodeCoverageSequencePoint y)
+		{
+			int result = 0;
+			switch (column) {
+				case VisitCountColumn:
+					result = x.VisitCount - y.VisitCount;
+					break;
+				case SequencePointLineColumn:
+					result = x.Line - y.Line;
+					break;
+				case SequencePointStartColumnColumn:
+					result = x.Column - y.Column;
+					break;
+				case SequencePointEndLineColumn:
+					result = x.EndLine - y.EndLine;
+					break;
+				case SequencePointEndColumnColumn:
+					result = x.EndColumn - y.EndColumn;
+					break;
+			}
+			
+			// Sort by secondary sort column?
+			if (result == 0 && column != SequencePointLineColumn) {
+				result = x.Line - y.Line;
+			}
+			
+			if (sortOrder == SortOrder.Descending) {
+				return -result;
+			}
+			return result;
+		}
+		
+		/// <summary>
+		/// Switches the sort order from ascending to descending
+		/// and vice versa.
+		/// </summary>
+		void ToggleSortOrder()
+		{
+			if (sortOrder == SortOrder.Ascending) {
+				sortOrder = SortOrder.Descending;
+			} else {
+				sortOrder = SortOrder.Ascending;
+			}
+		}
+		
+		/// <summary>
+		/// User clicked a column header so sort that column.
+		/// </summary>
+		void ListViewColumnClick(object source, ColumnClickEventArgs e)
+		{
+			Sort(e.Column);
+		}
+	}
+}

src/AddIns/Misc/CodeCoverage/Test/CodeCoverage.Tests.csproj

@@ -52,6 +52,7 @@
     <Compile Include="CodeCoverageResultsTestFixture.cs" />
     <Compile Include="CodeCoverageTreeViewTestFixture.cs" />
     <Compile Include="DerivedCodeCoverageTreeView.cs" />
+    <Compile Include="ListViewSortingTestFixture.cs" />
     <Compile Include="ModuleVisitedSequencePointsTestFixture.cs" />
     <Compile Include="AddCodeCoverageMarkersTestFixture.cs" />
     <Compile Include="MockDocument.cs" />

src/AddIns/Misc/CodeCoverage/Test/ListViewSortingTestFixture.cs

@@ -0,0 +1,165 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Windows.Forms;
+using ICSharpCode.CodeCoverage;
+using NUnit.Framework;
+
+namespace ICSharpCode.CodeCoverage.Tests
+{
+	/// <summary>
+	/// Tests the sorting of the list view that shows
+	/// the code coverage sequence points (visit counts, etc).
+	/// Here we are not actually using the real list view, but
+	/// just a list view which has the same number of columns.
+	/// Eventually the sorter class will be replaced in
+	/// SharpDevelop 3.0 with the generic sorting classes.
+	/// </summary>
+	[TestFixture]
+	public class ListViewSortingTestFixture
+	{
+		ListView listView;
+		CodeCoverageSequencePoint firstSequencePoint;
+		CodeCoverageSequencePoint secondSequencePoint;
+		SequencePointListViewSorter sorter;
+		const int VisitCountColumn = 0;
+		const int SequencePointLineColumn = 1;
+		const int SequencePointStartColumnColumn = 2;
+		const int SequencePointEndLineColumn = 3;
+		const int SequencePointEndColumnColumn = 4;
+		
+		[SetUp]
+		public void SetUp()
+		{
+			listView = new ListView();
+			sorter = new SequencePointListViewSorter(listView);
+			
+			listView.Columns.Add("Visit Count");
+			listView.Columns.Add("Line");
+			listView.Columns.Add("Column");
+			listView.Columns.Add("End Line");
+			listView.Columns.Add("End Column");
+			
+			// Add first sequence point.
+			firstSequencePoint = new CodeCoverageSequencePoint(String.Empty, 1, 5, 1, 5, 10);
+			ListViewItem item = new ListViewItem("First");
+			item.Tag = firstSequencePoint;
+			listView.Items.Add(item);
+			
+			// Add second sequence point.
+			secondSequencePoint = new CodeCoverageSequencePoint(String.Empty, 0, 10, 2, 10, 8);
+			item = new ListViewItem("Second");
+			item.Tag = secondSequencePoint;
+			listView.Items.Add(item);
+			
+			// Need to create the control's handle otherwise
+			// the list view will not sort.
+			listView.CreateControl();
+		}
+		
+		[TearDown]
+		public void TearDown()
+		{
+			listView.Dispose();
+		}
+		
+		[Test]
+		public void InitialOrderSameAsOrderAdded()
+		{
+			Assert.AreSame(firstSequencePoint, listView.Items[0].Tag);
+			Assert.AreSame(secondSequencePoint, listView.Items[1].Tag);
+		}
+		
+		[Test]
+		public void SortVisitCountColumn()
+		{
+			sorter.Sort(VisitCountColumn);
+			Assert.AreSame(secondSequencePoint, listView.Items[0].Tag);
+		}
+		
+		[Test]
+		public void SortVisitCountColumnTwice()
+		{
+			sorter.Sort(VisitCountColumn);
+			sorter.Sort(VisitCountColumn);
+			Assert.AreSame(firstSequencePoint, listView.Items[0].Tag);
+		}
+		
+		[Test]
+		public void SortLineColumnTwice()
+		{
+			sorter.Sort(SequencePointLineColumn);
+			sorter.Sort(SequencePointLineColumn);
+			Assert.AreSame(secondSequencePoint, listView.Items[0].Tag);	
+		}
+		
+		[Test]
+		public void SortStartColumnTwice()
+		{
+			sorter.Sort(SequencePointStartColumnColumn);
+			sorter.Sort(SequencePointStartColumnColumn);
+			Assert.AreSame(secondSequencePoint, listView.Items[0].Tag);	
+		}
+		
+		[Test]
+		public void SortEndLineTwice()
+		{
+			sorter.Sort(SequencePointEndLineColumn);
+			sorter.Sort(SequencePointEndLineColumn);
+			Assert.AreSame(secondSequencePoint, listView.Items[0].Tag);	
+		}
+		
+		[Test]
+		public void SortEndColumn()
+		{
+			sorter.Sort(SequencePointEndColumnColumn);
+			Assert.AreSame(secondSequencePoint, listView.Items[0].Tag);	
+		}
+		
+		[Test]
+		public void CompareNulls()
+		{
+			Assert.AreEqual(0, sorter.Compare(null, null));
+		}
+		
+		[Test]
+		public void CompareNullRhs()
+		{
+			Assert.AreEqual(0, sorter.Compare(null, new ListViewItem()));
+		}
+		
+		[Test]
+		public void CompareTwoListViewItemsWithNoTags()
+		{
+			sorter.Sort(VisitCountColumn);
+			Assert.AreEqual(0, sorter.Compare(new ListViewItem(), new ListViewItem()));
+		}
+		
+		[Test]
+		public void CompareRhsListViewItemWithNoTag()
+		{
+			sorter.Sort(VisitCountColumn);
+			Assert.AreEqual(0, sorter.Compare(listView.Items[0], new ListViewItem()));
+		}
+		
+		[Test]
+		public void SecondarySortByLineWhenVisitCountSame()
+		{
+			sorter.Sort(VisitCountColumn);
+			CodeCoverageSequencePoint pt1 = new CodeCoverageSequencePoint(String.Empty, 0, 1, 0, 0, 0);
+			CodeCoverageSequencePoint pt2 = new CodeCoverageSequencePoint(String.Empty, 0, 2, 0, 0, 0);
+			
+			ListViewItem item1 = new ListViewItem();
+			item1.Tag = pt1;
+			ListViewItem item2 = new ListViewItem();
+			item2.Tag = pt2;
+			
+			Assert.AreEqual(-1, sorter.Compare(item1, item2));
+		}
+	}
+}