/// <summary>
/// Removes the specified number of columns from the right side of the table.
/// </summary>
/// <param name="count">The number of columns to remove from the right side of the table.</param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="count"/> is less than 0 -or-
/// when <paramref name="count"/> is greater than the number of columns currently in the table.</exception>
public void RemoveColumns(int count)
{
if (count < 0)
{
throw new ArgumentOutOfRangeException("count", "Value cannot be less than 0.");
}
if (count > ColumnCount)
{
throw new ArgumentOutOfRangeException("count", "Value cannot be greater than the number of columns currently in the table.");
}
var list = ColumnHeaders.ToList();
for (int i = list.Count - 1; i >= list.Count - count; i--)
{
NativeCell.RemoveChild(list[i]);
list.RemoveAt(i);
var cc = columnControls[i];
foreach (var control in cc)
{
NativeCell.RemoveChild(control);
}
}
Array.Resize(ref columnControls, ColumnCount - count);
ColumnHeaders = new ReadOnlyCollection <Label>(list);
}
public string GetDescription(DataSchema dataSchema)
{
var parts = new List <string>();
if (RowHeaders.Any())
{
parts.Add(Resources.PivotSpec_GetDescription_Row_Headers_);
parts.AddRange(RowHeaders.Select(header => header.Caption ?? header.SourceColumn.ToString()));
}
if (ColumnHeaders.Any())
{
if (parts.Any())
{
parts.Add(string.Empty);
}
parts.Add(Resources.PivotSpec_GetDescription_Column_Headers_);
parts.AddRange(ColumnHeaders.Select(header => header.Caption ?? header.SourceColumn.ToString()));
}
if (Values.Any())
{
if (parts.Any())
{
parts.Add(string.Empty);
}
parts.Add(Resources.PivotSpec_GetDescription_Values_);
parts.AddRange(Values.Select(value =>
(ColumnCaption.ExplicitCaption(value.Caption) ??
value.AggregateOperation.QualifyColumnCaption(value.SourceColumn.ToColumnCaption()))
.GetCaption(dataSchema.DataSchemaLocalizer)));
}
return(string.Join(Environment.NewLine, parts));
}
/// <summary>
/// Adds the specified number of columns to the right side of the table.
/// </summary>
/// <param name="count">The number of columns to add to the right side of the table.</param>
/// <param name="headerTexts">Optional strings to apply to the header labels of the new columns.</param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="count"/> is less than 0.</exception>
public void AddColumns(int count, params string[] headerTexts)
{
if (count < 0)
{
throw new ArgumentOutOfRangeException("count", "Value cannot be less than 0.");
}
var list = ColumnHeaders.ToList();
int currentCount = ColumnCount;
Array.Resize(ref columnControls, currentCount + count);
for (int i = 0; i < count; i++)
{
var label = new Label();
label.Text = headerTexts != null && headerTexts.Length > i ? headerTexts[i] : null;
label.HorizontalAlignment = HorizontalAlignment.Left;
label.VerticalAlignment = VerticalAlignment.Center;
NativeCell.AddChild(label);
list.Add(label);
columnControls[currentCount + i] = new IControl[RowCount];
}
ColumnHeaders = new ReadOnlyCollection <Label>(list);
}
public TableData(List <List <double> > predictions, Data data)
{
var format = new NumberFormatInfo
{
NumberDecimalSeparator = ".",
NumberDecimalDigits = 2
};
ColumnHeaders.Add("prediction");
ColumnHeaders.Add("class");
for (var i = 1; i <= data.Attributes.First().Count; i++)
{
ColumnHeaders.Add("attribute " + i);
}
for (var i = 0; i < data.Attributes.Count; i++)
{
var p = new List <double>(new[] { predictions[i][0], data.ObjectClass[i] });
var row = new TableDataRow(p.Concat(data.Attributes[i])
.Select(d => d.ToString("N", format)).ToList());
Rows.Add(row);
}
}
private void SetUpColumnHeaders()
{
TableTitle = string.Format("Name{0}", SortByTitle ? SortDescending ? DownArrowLeftAligned : UpArrowLeftAligned : "");
ColumnHeaders.Clear();
HeaderHints.Clear();
switch (MaterialType)
{
case MaterialType.Metal:
ColumnHeaders.Add(GetSortedLabel(0, Phi));
HeaderHints.Add("Work Function (eV)");
break;
case MaterialType.Dielectric:
ColumnHeaders.Add(GetSortedLabel(0, Kappa));
HeaderHints.Add("Dielectric Constant");
ColumnHeaders.Add(GetSortedLabel(1, "Eg"));
HeaderHints.Add("Band Gap (eV)");
ColumnHeaders.Add(GetSortedLabel(2, Phi));
HeaderHints.Add("Electron Affinity (eV)");
break;
case MaterialType.Semiconductor:
ColumnHeaders.Add(GetSortedLabel(0, Kappa));
HeaderHints.Add("Dielectric Constant");
ColumnHeaders.Add(GetSortedLabel(1, "Eg"));
HeaderHints.Add("Band Gap (eV)");
ColumnHeaders.Add(GetSortedLabel(2, Phi));
HeaderHints.Add("Electron Affinity (eV)");
ColumnHeaders.Add(GetSortedLabel(3, "ni"));
HeaderHints.Add("Intrinsic Carrier Concentration (cm\u207a\u00b2)");
break;
}
}
public override int GetHashCode()
{
unchecked
{
var hashCode = RowHeaders.GetHashCode();
hashCode = (hashCode * 397) ^ ColumnHeaders.GetHashCode();
hashCode = (hashCode * 397) ^ Values.GetHashCode();
return(hashCode);
}
}
protected void gvAutoGrid_DataRowBound(object sender, GridViewRowEventArgs e)
{
if (e.Row.RowType == DataControlRowType.Header)
{
var col = 0;
foreach (TableCell c in e.Row.Cells)
{
var link = c.Controls[0] as LinkButton;
if (link == null)
{
return;
}
link.Text = ColumnHeaders[col];
col++;
}
}
if (e.Row.RowType == DataControlRowType.DataRow)
{
if (ColumnFormats != null)
{
for (var i = 0; i < ColumnFormats.Length; i++)
{
if (ColumnFormats[i] == string.Empty)
{
continue;
}
e.Row.Cells[i].Text = e.Row.Cells[i].Text == " " ? string.Empty : (double.Parse(e.Row.Cells[i].Text)).ToString(ColumnFormats[i]);
e.Row.Cells[i].HorizontalAlign = HorizontalAlign.Right;
}
}
var lastColumnHeader = ColumnHeaders.Count() - 1;
if (ColumnHeaders[lastColumnHeader] == ViewKeyword)
{
var commandParameter = e.Row.Cells[lastColumnHeader].Text;
e.Row.Cells.RemoveAt(lastColumnHeader);
var tc = new TableCell();
var lb = new LinkButton {
Text = ViewKeyword
, ID = ViewKeyword + commandParameter
, CommandName = ViewKeyword
, CommandArgument = commandParameter
};
//lb.Command += LinkButton_Command;
tc.Controls.Add(lb);
tc.HorizontalAlign = HorizontalAlign.Center;
tc.ForeColor = Color.DarkBlue;
e.Row.Cells.Add(tc);
}
}
}
public IFilterValue?GetColumnValue(String columnName, int rowIndex)
{
IFilterValue?columnValue = null;
int columnIndex = ColumnHeaders.IndexOf(columnName);
if (columnIndex > -1 && rowIndex < Rows.Count)
{
columnValue = Rows[rowIndex].GetColumn(columnName);
}
return(columnValue);
}
public void AddNewColumn(String headerName, String value)
{
if (ColumnHeaders.Contains(headerName) == false)
{
ColumnHeaders.Add(headerName);
foreach (CsvRow row in Rows)
{
CsvColumn csvColumn = new CsvColumn(headerName, value);
row.AddColumn(headerName, value);
}
}
}
private void UserControl_LayoutUpdated(object sender, EventArgs e)
{
List <FrameworkElement> rowHeaders = ItemsIn(RowHeaderContainer);
List <FrameworkElement> rows = ItemsIn(RowContainer);
for (int i = 0; i < rowHeaders.Count && i < rows.Count; i++)
{
rowHeaders[i].Height = rows[i].ActualHeight;
}
ColumnHeaders.ScrollToHorizontalOffset(Scroller.HorizontalOffset);
RowHeaders.ScrollToVerticalOffset(Scroller.VerticalOffset);
}
public void RecreateContent()
{
LogicalChildren.Clear();
VisualChildren.Clear();
GridBorderLines.Clear();
for (int i = 0; i < 4; i++)
{
var line = new Line()
{
Stroke = GridControl.BorderBrush, StrokeThickness = GridControl.BorderThickness
};
GridBorderLines.Add(line);
LogicalChildren.Add(line);
VisualChildren.Add(line);
}
ColumnHeaders.Clear();
ColumnHeaderLines.Clear();
for (int i = 0; i < GridControl.Columns.Count; i++)
{
GridControl.Columns[i].Index = i;
var columnHeader = GridControl.Columns[i].CreateColumnHeader();
ColumnHeaders.Add(columnHeader);
LogicalChildren.Add(columnHeader);
VisualChildren.Add(columnHeader);
var line = new Line()
{
Stroke = GridControl.VerticalLinesBrush, StrokeThickness = GridControl.VerticalLinesThickness
};
ColumnHeaderLines.Add(line);
LogicalChildren.Add(line);
VisualChildren.Add(line);
}
HorizontalHeaderLine = new Line()
{
Stroke = GridControl.HorizontalLinesBrush, StrokeThickness = GridControl.HorizontalLinesThickness
};
LogicalChildren.Add(HorizontalHeaderLine);
VisualChildren.Add(HorizontalHeaderLine);
CellsPanel.RecreateCells();
LogicalChildren.Add(CellsPanel);
VisualChildren.Add(CellsPanel);
}
public DataTableImpl(IEnumerable <Tuple <TR, TC, TD> > data)
{
foreach (var tuple in data)
{
if (RowHeaders.All(r => r.Guid != tuple.Item1.Guid))
{
_rowHeaders.Add(tuple.Item1);
}
if (ColumnHeaders.All(c => c.Guid != tuple.Item2.Guid))
{
_columnHeaders.Add(tuple.Item2);
}
_dataDictionary[tuple.Item1.Guid.Add(tuple.Item2.Guid)] = tuple.Item3;
}
}
public List <string> GetAllColumnRows(ColumnHeaders _headers)
{
switch (_headers)
{
case ColumnHeaders.productTitle:
return(_driver.FindElements(By.CssSelector(baseSelectorPath + "tr > td.product > a")).Select(o => o.Text).ToList());
case ColumnHeaders.price:
return(_driver.FindElements(By.CssSelector(baseSelectorPath + "tr > td.unit-price")).Select(o => o.Text).ToList());
case ColumnHeaders.qty:
return(_driver.FindElements(By.CssSelector(baseSelectorPath + "tr > td.quantity > input")).Select(o => o.GetAttribute("value")).ToList());
default:
throw new ArgumentOutOfRangeException("No column header with value found");
}
}
public WorksheetData ReadWorksheet(string fileName)
{
WorksheetData worksheetData = new WorksheetData();
for (int i = 0; i < ColumnHeaders.Count(); i++)
{
worksheetData.ColumnHeaders.Add(this.ColumnHeaders[i]);
}
for (int row = 0; row < ExcellData.Count(); row++)
{
worksheetData.CellData.Add(new List <string>());
for (int column = 0; column < ExcellData[row].Count(); column++)
{
worksheetData.CellData[worksheetData.CellData.Count - 1].Add(ExcellData[row][column]);
}
}
return(worksheetData);
}
/// <summary>
/// Constructor</summary>
public ColumnHeadersAdapter()
{
m_columnHeaders = new ColumnHeaders(this);
m_columnHeaders.Dock = DockStyle.Top;
if (ColumnMoved == null)
{
return;
}
if (ColumnResized == null)
{
return;
}
if (ColumnSortDirectionChanged == null)
{
return;
}
}
/// <summary>
/// Constructor with column headers</summary>
/// <param name="columnHeaders">Column headers</param>
public GridView(ColumnHeaders columnHeaders)
{
m_selectedRows = new Selection<int>();
m_selectedRows.Changed += selectedRows_Changed;
m_columnHeaders = columnHeaders;
m_columnHeaders.GridView = this;
m_columnHeaders.Height = HeaderHeight;
m_columnHeaders.Dock = DockStyle.Top;
m_vScrollBar = new VScrollBar();
m_vScrollBar.Dock = DockStyle.Right;
m_vScrollBar.ValueChanged += vScrollBar_ValueChanged;
m_hScrollBar = new HScrollBar();
m_hScrollBar.Dock = DockStyle.Bottom;
m_hScrollBar.ValueChanged += hScrollBar_ValueChanged;
Controls.Add(m_columnHeaders);
Controls.Add(m_vScrollBar); // add vertical scrollbar here, so header can't overlap it
Controls.Add(m_hScrollBar);
SetPens();
Color color1 = Color.LightSteelBlue;
m_evenRowBrush = new SolidBrush(color1);
Color color2 = ColorUtil.GetShade(color1, 1.2f);
m_oddRowBrush = new SolidBrush(color2);
base.DoubleBuffered = true;
// enable dragging and dropping of column headers by default
DragDropColumnsEnabed = true;
// enable selection in the grid
SelectionEnabed = true;
// enable selection of more than one item in the grid
MultiSelectionEnabled = true;
// enable wrapping with the up and down arrow keys
UpDownKeySelectionWrapEnabled = true;
}
protected override Size ArrangeOverride(Size finalSize)
{
if (GridControl.ShowBorder)
{
var halfBorderLineThickness = GridControl.BorderThickness / 2.0;
GridBorderLines[0].StartPoint = new Point(0.0, halfBorderLineThickness);
GridBorderLines[0].EndPoint = new Point(finalSize.Width, halfBorderLineThickness);
GridBorderLines[1].StartPoint = new Point(0.0, finalSize.Height - halfBorderLineThickness);
GridBorderLines[1].EndPoint = new Point(finalSize.Width, finalSize.Height - halfBorderLineThickness);
GridBorderLines[2].StartPoint = new Point(halfBorderLineThickness, 0.0);
GridBorderLines[2].EndPoint = new Point(halfBorderLineThickness, finalSize.Height);
GridBorderLines[3].StartPoint = new Point(finalSize.Width - halfBorderLineThickness, 0.0);
GridBorderLines[3].EndPoint = new Point(finalSize.Width - halfBorderLineThickness, finalSize.Height);
}
foreach (var borderLine in GridBorderLines)
{
borderLine.IsVisible = GridControl.ShowBorder;
}
double columnHeadersHeight = ColumnHeaders.Max(ch => ch.DesiredSize.Height) + GridControl.HorizontalLinesThickness;
double borderThickness = GridControl.ShowBorder ? GridControl.BorderThickness : 0.0;
double horizontalLineY = borderThickness + columnHeadersHeight - GridControl.HorizontalLinesThickness / 2.0;
HorizontalHeaderLine.StartPoint = new Point(borderThickness, horizontalLineY);
HorizontalHeaderLine.EndPoint = new Point(finalSize.Width - borderThickness, horizontalLineY);
double columnHeadersWidth = borderThickness;
for (int i = 0; i < ColumnHeaders.Count; i++)
{
var columnHeader = ColumnHeaders[i];
columnHeader.Arrange(new Rect(columnHeadersWidth, borderThickness, columnHeader.Column.Width, columnHeadersHeight));
columnHeadersWidth += columnHeader.Column.Width + GridControl.VerticalLinesThickness;
double verticalLineX = columnHeadersWidth - GridControl.VerticalLinesThickness / 2.0;
ColumnHeaderLines[i].StartPoint = new Point(verticalLineX, borderThickness);
ColumnHeaderLines[i].EndPoint = new Point(verticalLineX, columnHeadersHeight + borderThickness);
}
CellsPanel.Arrange(new Rect(borderThickness, borderThickness + columnHeadersHeight,
finalSize.Width - 2.0 * borderThickness, finalSize.Height - 2.0 * borderThickness - columnHeadersHeight));
return(finalSize);
}
protected override Size MeasureOverride(Size availableSize)
{
double doubleBorderThickness = GridControl.ShowBorder ? GridControl.BorderThickness * 2.0 : 0.0;
double columnHeadersHeight = 0.0;
foreach (var columnHeader in ColumnHeaders)
{
columnHeader.Measure(new Size(availableSize.Width - doubleBorderThickness, Double.PositiveInfinity));
columnHeadersHeight = Math.Max(columnHeadersHeight, columnHeader.DesiredSize.Height);
}
columnHeadersHeight += GridControl.HorizontalLinesThickness;
double columnHeadersWidth = ColumnHeaders.Sum(ch => ch.Column.Width + GridControl.VerticalLinesThickness);
//TODO check negative height
CellsPanel.Measure(new Size(availableSize.Width - doubleBorderThickness,
availableSize.Height - doubleBorderThickness - columnHeadersHeight));
return(new Size(columnHeadersWidth + doubleBorderThickness,
columnHeadersHeight + CellsPanel.DesiredSize.Height + doubleBorderThickness));
}
public void Reset()
{
cells = null;
if (RowHeaders == null)
{
RowHeaders = new List <double>();
}
else
{
RowHeaders.Clear();
}
if (ColumnHeaders == null)
{
ColumnHeaders = new List <double>();
}
else
{
ColumnHeaders.Clear();
}
}
private object[,] BuildDataArray()
{
try
{
int columnNumber = 0;
string cellValue = null;
for (int row = 0; row < DataRange.Rows.Count; row++)
{
for (int column = 0; column < DataRange.Columns.Count; column++)
{
cellValue = DataRange[row, column].ToString();
columnNumber = ColumnHeaders.IndexOf(cellValue);
DataArray[row, columnNumber] = cellValue;
}
}
return(DataArray);
}
catch (Exception)
{
Console.WriteLine("Could not build the data array from the extracted range.");
return(null);
}
}
public IEnumerable <RowItem> GroupAndTotal(IEnumerable <RowItem> rows, IList <DataPropertyDescriptor> propertyDescriptors)
{
var rowsByRowHeader = rows.ToLookup(row =>
{
CancellationToken.ThrowIfCancellationRequested();
return(ImmutableList.ValueOf(RowHeaders.Select(tuple => tuple.Item1.GetValue(row))));
});
propertyDescriptors.AddRange(RowHeaders.Select((tuple, index) => new IndexedPropertyDescriptor(DataSchema, index, tuple.Item1, tuple.Item2)));
var columnHeaders = new Dictionary <ImmutableList <object>, int>();
var resultRows = new List <RowItem>();
List <List <object> > aggregateValues = new List <List <object> >();
foreach (IGrouping <ImmutableList <object>, RowItem> rowGroup in rowsByRowHeader)
{
foreach (var list in aggregateValues)
{
list.Clear();
}
var rowValues = rowGroup.Key.ToList();
foreach (RowItem row in rowGroup)
{
// ReSharper disable AccessToForEachVariableInClosure
var columnHeader = ImmutableList.ValueOf(ColumnHeaders.Select(pd => pd.GetValue(row)));
// ReSharper restore AccessToForEachVariableInClosure
int columnHeaderIndex;
if (!columnHeaders.TryGetValue(columnHeader, out columnHeaderIndex))
{
columnHeaderIndex = columnHeaders.Count;
columnHeaders.Add(columnHeader, columnHeaderIndex);
foreach (var aggregateColumn in AggregateColumns)
{
propertyDescriptors.Add(MakePropertyDescriptor(propertyDescriptors.Count, columnHeader,
aggregateColumn.Item1, aggregateColumn.Item2, aggregateColumn.Item3));
aggregateValues.Add(new List <object>());
}
}
for (int iAggColumn = 0; iAggColumn < AggregateColumns.Count; iAggColumn++)
{
var value = AggregateColumns[iAggColumn].Item1.GetValue(row);
if (value != null)
{
var aggList = aggregateValues[iAggColumn + columnHeaderIndex * AggregateColumns.Count];
aggList.Add(value);
}
}
}
for (int iGroup = 0; iGroup < columnHeaders.Count; iGroup++)
{
for (int iAggColumn = 0; iAggColumn < AggregateColumns.Count; iAggColumn++)
{
int aggregateValueIndex = iGroup * AggregateColumns.Count + iAggColumn;
var individualValues = aggregateValues[aggregateValueIndex];
if (individualValues.Count == 0)
{
rowValues.Add(null);
}
else
{
rowValues.Add(AggregateColumns[iAggColumn].Item3.CalculateValue(DataSchema, individualValues));
}
}
}
resultRows.Add(new RowItem(rowValues));
}
return(resultRows);
}
private IQueryable <GoalieSeasonStat> SortBy(IQueryable <GoalieSeasonStat> stats, string column, bool sortDesc)
{
if (column == null)
{
column = "W";
}
IsSortDescending = sortDesc;
IOrderedQueryable <GoalieSeasonStat> orderableStats;
if (IsSortDescending)
{
switch (column)
{
case "GP": orderableStats = stats.OrderByDescending(s => s.GP); break;
case "W": orderableStats = stats.OrderByDescending(s => s.W); break;
case "L": orderableStats = stats.OrderByDescending(s => s.L); break;
case "OTL": orderableStats = stats.OrderByDescending(s => s.OTL); break;
case "MP": orderableStats = stats.OrderByDescending(s => s.MP); break;
case "PIM": orderableStats = stats.OrderByDescending(s => s.PIM); break;
case "SO": orderableStats = stats.OrderByDescending(s => s.SO); break;
case "A": orderableStats = stats.OrderByDescending(s => s.A); break;
case "EG": orderableStats = stats.OrderByDescending(s => s.EG); break;
case "GA": orderableStats = stats.OrderByDescending(s => s.GA); break;
case "SA": orderableStats = stats.OrderByDescending(s => s.SA); break;
case "PSS": orderableStats = stats.OrderByDescending(s => s.PSS); break;
case "PSA": orderableStats = stats.OrderByDescending(s => s.PSA); break;
case "ST": orderableStats = stats.OrderByDescending(s => s.ST); break;
case "BG": orderableStats = stats.OrderByDescending(s => s.BG); break;
case "S1": orderableStats = stats.OrderByDescending(s => s.S1); break;
case "S2": orderableStats = stats.OrderByDescending(s => s.S2); break;
case "S3": orderableStats = stats.OrderByDescending(s => s.S3); break;
default:
{
AlertMessage = "Column does not exist.";
goto case "W";
}
}
}
else
{
switch (column)
{
case "GP": orderableStats = stats.OrderBy(s => s.GP); break;
case "W": orderableStats = stats.OrderBy(s => s.W); break;
case "L": orderableStats = stats.OrderBy(s => s.L); break;
case "OTL": orderableStats = stats.OrderBy(s => s.OTL); break;
case "MP": orderableStats = stats.OrderBy(s => s.MP); break;
case "PIM": orderableStats = stats.OrderBy(s => s.PIM); break;
case "SO": orderableStats = stats.OrderBy(s => s.SO); break;
case "A": orderableStats = stats.OrderBy(s => s.A); break;
case "EG": orderableStats = stats.OrderBy(s => s.EG); break;
case "GA": orderableStats = stats.OrderBy(s => s.GA); break;
case "SA": orderableStats = stats.OrderBy(s => s.SA); break;
case "PSS": orderableStats = stats.OrderBy(s => s.PSS); break;
case "PSA": orderableStats = stats.OrderBy(s => s.PSA); break;
case "ST": orderableStats = stats.OrderBy(s => s.ST); break;
case "BG": orderableStats = stats.OrderBy(s => s.BG); break;
case "S1": orderableStats = stats.OrderBy(s => s.S1); break;
case "S2": orderableStats = stats.OrderBy(s => s.S2); break;
case "S3": orderableStats = stats.OrderBy(s => s.S3); break;
default:
{
AlertMessage = "Column does not exist.";
goto case "W";
}
}
}
SelectedColumnSort = column;
var matchedColumn = ColumnHeaders.Where(a => a.Name == column).FirstOrDefault();
SelectedColumnSortIndex = ColumnHeaders.IndexOf(matchedColumn);
if (column == "MP")
{
return(orderableStats);
}
return((IsSortDescending) ?
orderableStats.ThenBy(s => s.MP) :
orderableStats.ThenByDescending(s => s.MP));
}
public String GetHeaderString()
{
return(ColumnHeaders.Aggregate((item, next) => item + CsvDelimit + next));
}
protected bool Equals(PivotSpec other)
{
return(RowHeaders.Equals(other.RowHeaders) &&
ColumnHeaders.Equals(other.ColumnHeaders) &&
Values.Equals(other.Values));
}
public double InterpolateXY(double xValue, double yValue)
{
return(InterpolateXY(xValue, yValue, ColumnHeaders.ToArray(), RowHeaders.ToArray(), cells.ToArray()));
}
/// <summary>
/// Constructor</summary>
public ColumnHeadersAdapter()
{
m_columnHeaders = new ColumnHeaders(this);
m_columnHeaders.Dock = DockStyle.Top;
if (ColumnMoved == null) return;
if (ColumnResized == null) return;
if (ColumnSortDirectionChanged == null) return;
}
public ITable <TItem> WithExplicitColumn(string name, params Expression <Func <TItem, bool> >[] selectors)
{
ColumnHeaders.Add(CreateExplicitAxis(name, selectors));
return(this);
}
public ITable <TItem> WithColumns <TKey>(string name, Func <TItem, TKey> selector)
{
ColumnHeaders.Add(CreateIdenttiyAxis(name, selector));
return(this);
}
private IQueryable <SkaterSeasonStat> SortBy(IQueryable <SkaterSeasonStat> stats, string column, bool sortDesc)
{
if (column == null)
{
column = "P";
}
IsSortDescending = sortDesc;
IOrderedQueryable <SkaterSeasonStat> orderableStats;
if (IsSortDescending)
{
switch (column)
{
case "GP": orderableStats = stats.OrderByDescending(s => s.GP); break;
case "G": orderableStats = stats.OrderByDescending(s => s.G); break;
case "A": orderableStats = stats.OrderByDescending(s => s.A); break;
case "P": orderableStats = stats.OrderByDescending(s => s.P).ThenByDescending(s => s.G); break;
case "PLMI": orderableStats = stats.OrderByDescending(s => s.PLMI); break;
case "SHT": orderableStats = stats.OrderByDescending(s => s.SHT); break;
case "SB": orderableStats = stats.OrderByDescending(s => s.SB); break;
case "MP": orderableStats = stats.OrderByDescending(s => s.MP); break;
case "PIM": orderableStats = stats.OrderByDescending(s => s.PIM); break;
case "PM5": orderableStats = stats.OrderByDescending(s => s.PM5); break;
case "HIT": orderableStats = stats.OrderByDescending(s => s.HIT); break;
case "HTT": orderableStats = stats.OrderByDescending(s => s.HTT); break;
case "PPG": orderableStats = stats.OrderByDescending(s => s.PPG); break;
case "PPA": orderableStats = stats.OrderByDescending(s => s.PPA); break;
case "PPP": orderableStats = stats.OrderByDescending(s => s.PPP); break;
case "PPS": orderableStats = stats.OrderByDescending(s => s.PPS); break;
case "PPM": orderableStats = stats.OrderByDescending(s => s.PPM); break;
case "PKG": orderableStats = stats.OrderByDescending(s => s.PKG); break;
case "PKA": orderableStats = stats.OrderByDescending(s => s.PKA); break;
case "PKP": orderableStats = stats.OrderByDescending(s => s.PKP); break;
case "PKS": orderableStats = stats.OrderByDescending(s => s.PKS); break;
case "PKM": orderableStats = stats.OrderByDescending(s => s.PKM); break;
case "GW": orderableStats = stats.OrderByDescending(s => s.GW); break;
case "GT": orderableStats = stats.OrderByDescending(s => s.GT); break;
case "EG": orderableStats = stats.OrderByDescending(s => s.EG); break;
case "HT": orderableStats = stats.OrderByDescending(s => s.HT); break;
case "FOW": orderableStats = stats.OrderByDescending(s => s.FOW); break;
case "FOT": orderableStats = stats.OrderByDescending(s => s.FOT); break;
case "PSG": orderableStats = stats.OrderByDescending(s => s.PSG); break;
case "PSS": orderableStats = stats.OrderByDescending(s => s.PSS); break;
case "FW": orderableStats = stats.OrderByDescending(s => s.FW); break;
case "FL": orderableStats = stats.OrderByDescending(s => s.FL); break;
case "FT": orderableStats = stats.OrderByDescending(s => s.FT); break;
case "S1": orderableStats = stats.OrderByDescending(s => s.S1); break;
case "S2": orderableStats = stats.OrderByDescending(s => s.S2); break;
case "S3": orderableStats = stats.OrderByDescending(s => s.S3); break;
default:
{
AlertMessage = "Column does not exist.";
goto case "P";
}
}
}
else
{
switch (column)
{
case "GP": orderableStats = stats.OrderBy(s => s.GP); break;
case "G": orderableStats = stats.OrderBy(s => s.G); break;
case "A": orderableStats = stats.OrderBy(s => s.A); break;
case "P": orderableStats = stats.OrderBy(s => s.P).ThenByDescending(s => s.G); break;
case "PLMI": orderableStats = stats.OrderBy(s => s.PLMI); break;
case "SHT": orderableStats = stats.OrderBy(s => s.SHT); break;
case "SB": orderableStats = stats.OrderBy(s => s.SB); break;
case "MP": orderableStats = stats.OrderBy(s => s.MP); break;
case "PIM": orderableStats = stats.OrderBy(s => s.PIM); break;
case "PM5": orderableStats = stats.OrderBy(s => s.PM5); break;
case "HIT": orderableStats = stats.OrderBy(s => s.HIT); break;
case "HTT": orderableStats = stats.OrderBy(s => s.HTT); break;
case "PPG": orderableStats = stats.OrderBy(s => s.PPG); break;
case "PPA": orderableStats = stats.OrderBy(s => s.PPA); break;
case "PPP": orderableStats = stats.OrderBy(s => s.PPP); break;
case "PPS": orderableStats = stats.OrderBy(s => s.PPS); break;
case "PPM": orderableStats = stats.OrderBy(s => s.PPM); break;
case "PKG": orderableStats = stats.OrderBy(s => s.PKG); break;
case "PKA": orderableStats = stats.OrderBy(s => s.PKA); break;
case "PKP": orderableStats = stats.OrderBy(s => s.PKP); break;
case "PKS": orderableStats = stats.OrderBy(s => s.PKS); break;
case "PKM": orderableStats = stats.OrderBy(s => s.PKM); break;
case "GW": orderableStats = stats.OrderBy(s => s.GW); break;
case "GT": orderableStats = stats.OrderBy(s => s.GT); break;
case "EG": orderableStats = stats.OrderBy(s => s.EG); break;
case "HT": orderableStats = stats.OrderBy(s => s.HT); break;
case "FOW": orderableStats = stats.OrderBy(s => s.FOW); break;
case "FOT": orderableStats = stats.OrderBy(s => s.FOT); break;
case "PSG": orderableStats = stats.OrderBy(s => s.PSG); break;
case "PSS": orderableStats = stats.OrderBy(s => s.PSS); break;
case "FW": orderableStats = stats.OrderBy(s => s.FW); break;
case "FL": orderableStats = stats.OrderBy(s => s.FL); break;
case "FT": orderableStats = stats.OrderBy(s => s.FT); break;
case "S1": orderableStats = stats.OrderBy(s => s.S1); break;
case "S2": orderableStats = stats.OrderBy(s => s.S2); break;
case "S3": orderableStats = stats.OrderBy(s => s.S3); break;
default:
{
AlertMessage = "Column does not exist.";
goto case "P";
}
}
}
SelectedColumnSort = column;
var matchedColumn = ColumnHeaders.Where(a => a.Name == column).FirstOrDefault();
SelectedColumnSortIndex = ColumnHeaders.IndexOf(matchedColumn);
if (column == "MP")
{
return(orderableStats);
}
return((IsSortDescending) ?
orderableStats.ThenBy(s => s.MP) :
orderableStats.ThenByDescending(s => s.MP));
}
