/// <summary>
/// Sorts the <paramref name="results"/> on a user selected column.
/// This function returns <paramref name="results"/> unmodified if
/// the list is already sorted
/// </summary>
/// <param name="results">the resuls to sort</param>
/// <param name="columnName">the name of the column to compare</param>
/// <param name="sortDirection">the sort direction</param>
/// <returns>the results list (sorted)</returns>
public static IEnumerable <IResultNode> Sort(this IEnumerable <IResultNode> results, string columnName, ListSortDirection sortDirection)
{
PreConditions.Argument("results").Value(results).IsNotNull();
PreConditions.Argument("columnName").Value(columnName).IsNotNull();
DefaultColumnIndex index;
if (DefaultColumnExtensions.TryParse(columnName, out index))
{
switch (index)
{
case DefaultColumnIndex.Name:
return(results.OrderBy(r => r.Name, sortDirection));
case DefaultColumnIndex.Detector:
return(results.OrderBy(r => r.Detectors.First().Name, sortDirection));
case DefaultColumnIndex.DetectorVersion:
return(results.OrderBy(r => r.Detectors.First().VersionString(), sortDirection));
case DefaultColumnIndex.Offset:
return(results.OrderBy(r => r.StartOffset, sortDirection));
case DefaultColumnIndex.Length:
return(results.OrderBy(r => r.Length, sortDirection));
case DefaultColumnIndex.EndOffset:
return(results.OrderBy(r => r.EndOffset, sortDirection));
case DefaultColumnIndex.File:
return(results.OrderBy(r => GetResultFileName(r), sortDirection));
}
}
return(results.OrderBy(r => r.FindAttributeByName(columnName) == null ? null : r.FindAttributeByName(columnName).Value, sortDirection));
}
/// <summary>
/// Sorts the <paramref name="dataBlocks"/> on a user selected column.
/// </summary>
/// <param name="dataBlocks">the data blocks to sort</param>
/// <param name="columnName">the name of the column to compare</param>
/// <param name="sortDirection">the sort direction</param>
/// <returns>the sorted data blocks</returns>
public static IEnumerable <IDataBlock> Sort(this IEnumerable <IDataBlock> dataBlocks, string columnName, ListSortDirection sortDirection)
{
PreConditions.Argument("dataBlocks").Value(dataBlocks).IsNotNull();
PreConditions.Argument("columnName").Value(columnName).IsNotNull();
DefaultColumnIndex index;
if (DefaultColumnExtensions.TryParse(columnName, out index))
{
switch (index)
{
case DefaultColumnIndex.Name:
return(dataBlocks);
case DefaultColumnIndex.Detector:
return(dataBlocks.OrderBy(d => d.Detectors.First().Name, sortDirection));
case DefaultColumnIndex.DetectorVersion:
return(dataBlocks.OrderBy(d => d.Detectors.First().VersionString(), sortDirection));
case DefaultColumnIndex.Offset:
return(dataBlocks.OrderBy(d => d.StartOffset, sortDirection));
case DefaultColumnIndex.Length:
return(dataBlocks.OrderBy(d => d.Length, sortDirection));
case DefaultColumnIndex.EndOffset:
return(dataBlocks.OrderBy(d => d.EndOffset, sortDirection));
}
}
throw new ArgumentException("Invalid sort column name.", "columnName");
}
/// <summary>
/// Gets a <c>Comparison</c> delegate for comparing results.
/// The results are compared by the given column name.
/// </summary>
/// <param name="columnName">the name of the column to compare</param>
/// <returns>the comparison delegate</returns>
private static Comparison <IResultNode> GetResultComparison(string columnName)
{
DefaultColumnIndex index;
if (DefaultColumnExtensions.TryParse(columnName, out index))
{
switch (index)
{
case DefaultColumnIndex.Name:
return(delegate(IResultNode x, IResultNode y) { return x.Name.CompareTo(y.Name); });
case DefaultColumnIndex.Detector:
return(delegate(IResultNode x, IResultNode y) { return x.Detectors.First().Name.CompareTo(y.Detectors.First().Name); });
case DefaultColumnIndex.DetectorVersion:
return(delegate(IResultNode x, IResultNode y) { return DetectorComparer.Compare(x.Detectors.First(), y.Detectors.First()); });
case DefaultColumnIndex.Offset:
return(delegate(IResultNode x, IResultNode y) { return x.StartOffset.CompareTo(y.StartOffset); });
case DefaultColumnIndex.Length:
return(delegate(IResultNode x, IResultNode y) { return x.Length.CompareTo(y.Length); });
case DefaultColumnIndex.EndOffset:
return(delegate(IResultNode x, IResultNode y) { return x.EndOffset.CompareTo(y.EndOffset); });
case DefaultColumnIndex.File:
return(delegate(IResultNode x, IResultNode y) { return GetResultFileName(x).CompareTo(GetResultFileName(y)); });
}
}
return(delegate(IResultNode x, IResultNode y) { return CompareResultsByAttributeValue(x, y, columnName); });
}
protected override void OnGetCellData(Row row, Column column, CellData cellData)
{
base.OnGetCellData(row, column, cellData);
if (column.Name == null)
{
return;
}
IResultNode result = row.Item as IResultNode;
if (result == null)
{
return;
}
DefaultColumnIndex index;
if (DefaultColumnExtensions.TryParse(column.Name, out index))
{
switch (index)
{
case DefaultColumnIndex.Name:
cellData.Value = result.Name;
if (result.InputFile is IReferenceHeaderFile)
{
cellData.EvenStyle = new Style(cellData.EvenStyle)
{
ForeColor = Color.RoyalBlue, Font = new Font(cellData.EvenStyle.Font.FontFamily, cellData.EvenStyle.Font.SizeInPoints, FontStyle.Bold)
};
cellData.OddStyle = new Style(cellData.OddStyle)
{
ForeColor = Color.RoyalBlue, Font = new Font(cellData.OddStyle.Font.FontFamily, cellData.OddStyle.Font.SizeInPoints, FontStyle.Bold)
};
}
break;
case DefaultColumnIndex.Detector:
cellData.Value = result.Detectors.First().Name;
break;
case DefaultColumnIndex.DetectorVersion:
cellData.Value = _detectorFormatter.FormatVersion(result.Detectors.First());
break;
case DefaultColumnIndex.Offset:
cellData.Value = result.StartOffset;
if (DisplayMode == DisplayMode.Hex)
{
cellData.Format = "{0:X}";
}
break;
case DefaultColumnIndex.Length:
cellData.Value = result.Length;
if (DisplayMode == DisplayMode.Hex)
{
cellData.Format = "{0:X}";
}
break;
case DefaultColumnIndex.EndOffset:
cellData.Value = result.EndOffset;
if (DisplayMode == DisplayMode.Hex)
{
cellData.Format = "{0:X}";
}
break;
case DefaultColumnIndex.File:
IInputFile inputFile = result.InputFile;
if (inputFile != null)
{
cellData.Value = (new FileInfo(inputFile.Name)).Name;
cellData.ToolTip = inputFile.Name;
cellData.AlwaysDisplayToolTip = true;
}
break;
}
}
else
{
IResultAttribute attribute = result.FindAttributeByName(column.Name);
if (attribute == null)
{
cellData.Value = string.Empty;
}
else
{
cellData.Value = attribute.ValueAsString;
// Align the cell content depending its value.
if ((attribute.Value.GetType() == typeof(string)) ||
(attribute.Value.GetType() == typeof(bool)))
{
cellData.EvenStyle = new Style(cellData.EvenStyle, _horzAlignmentNearStyleDelta);
cellData.OddStyle = new Style(cellData.OddStyle, _horzAlignmentNearStyleDelta);
}
else
{
cellData.EvenStyle = new Style(cellData.EvenStyle, _horzAlignmentFarStyleDelta);
cellData.OddStyle = new Style(cellData.OddStyle, _horzAlignmentFarStyleDelta);
}
}
}
}
