/// <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);
}
}
}
}
/// <summary>
/// Sets the columns for this tree to the column names of the
/// given <paramref name="detector"/>.
/// </summary>
/// <param name="detector">the detector</param>
/// <param name="isWorkpad">The column chooser can be called from a workpad or the main dailog</param>
public void SetColumns(IDetector detector, bool isWorkpad)
{
_detectors.Clear();
Columns.Clear();
listViewHiddenColumns.Items.Clear();
listViewVisibleColumns.Items.Clear();
if (!isWorkpad && detector == null)
{
return;
}
//if(detector==null && isWorkpad) -> default columns only
if (detector != null)
{
_detectors.Add(detector);
}
IList <IColumnInfo> visibleColumns = null;
IProject project = _projectManager.Project;
if (project != null && detector != null)
{
visibleColumns = project.GetVisibleColumns(detector);
}
if (visibleColumns == null || visibleColumns.Count == 0)
{
// Do not add column 'Detector' / 'Detector Version' and 'File' to the default visible columns
visibleColumns = new List <IColumnInfo>();
foreach (IColumnInfo columnInfo in DefaultColumnExtensions.GetHeaderTreeDefaultColumns(DisplayMode))
{
if (columnInfo.Name != Enum.GetName(typeof(DefaultColumnIndex), DefaultColumnIndex.Detector) &&
columnInfo.Name != Enum.GetName(typeof(DefaultColumnIndex), DefaultColumnIndex.DetectorVersion) &&
columnInfo.Name != Enum.GetName(typeof(DefaultColumnIndex), DefaultColumnIndex.File))
{
visibleColumns.Add(columnInfo);
}
}
if (project != null && detector != null)
{
project.SetVisibleColumns(detector, visibleColumns);
}
}
Columns.SuspendChangeNotification();
// Add the visible columns
foreach (ColumnInfo columnInfo in visibleColumns)
{
AddColumn(detector, GetCorrectCaptionForOffsetAndLength(columnInfo), true);
}
// Make the Offset column the default sort column; sort ascending
Column offsetColumn = Columns[DefaultColumnIndex.Offset.GetName()];
if (offsetColumn != null)
{
offsetColumn.SortDirection = ListSortDirection.Ascending;
HeaderPanel.SortColumn = offsetColumn;
}
// Add the invisible default columns
foreach (ColumnInfo defaultColumnInfo in DefaultColumnExtensions.GetHeaderTreeDefaultColumns(DisplayMode))
{
if (!IsVisibleColumn(defaultColumnInfo.Name, visibleColumns))
{
AddColumn(detector, defaultColumnInfo, false);
}
}
// Add the invisible custom columns
foreach (IColumnInfo customColumnInfo in detector.GetColumns())
{
if (!IsVisibleColumn(customColumnInfo.Name, visibleColumns))
{
AddColumn(detector, customColumnInfo, false);
}
}
Columns.ResumeChangeNotification();
CreateColumns();
}
