protected override void OnGenerateVisibleColumns(VisibleLinesCollection visibleColumnLines)
{
this.VisibleColumns.Clear();
var groupCount = this.DataGrid.View != null ? this.DataGrid.View.GroupDescriptions.Count : 0;
int startIndex = 0;
if (this.DataGrid.showRowHeader)
{
if (visibleColumnLines.Any(line => line.LineIndex == 0))
{
CreateRowHeaderColumn(startIndex);
}
startIndex++;
}
if (this.DataGrid.GridModel.HasGroup)
{
for (var index = startIndex; index < groupCount + startIndex; index++)
{
if (visibleColumnLines.Any(line => line.LineIndex == index))
{
this.VisibleColumns.Add(CreateIndentColumn(index));
}
}
}
var indentDataColumn = CreateDetailsViewIndentColumn(groupCount + (this.DataGrid.showRowHeader ? 1 : 0));
this.VisibleColumns.Add(indentDataColumn);
var dc = CreateDetailsViewContent(groupCount + 1 + (this.DataGrid.showRowHeader ? 1 : 0));
this.VisibleColumns.Add(dc);
}
public void EnsureColumns(VisibleLinesCollection visibleColumns)
{
foreach (var gridRow in this.Items)
{
gridRow.EnsureColumns(visibleColumns);
}
}
public void PregenerateRows(VisibleLinesCollection visibleRows, VisibleLinesCollection visibleColumns)
{
if (this.Items.Count != 0 || this.Owner.TreeGridPanel.RowCount <= 0)
{
return;
}
for (var i = 0; i < visibleRows.Count; i++)
{
var line = visibleRows[i];
TreeDataRowBase dr = null;
switch (line.Region)
{
case ScrollAxisRegion.Header:
dr = CreateHeaderRow(line.LineIndex, visibleColumns);
break;
case ScrollAxisRegion.Body:
dr = CreateDataRow(line.LineIndex, visibleColumns);
break;
}
if (dr != null)
{
this.Items.Add(dr);
}
}
}
/// <summary>
/// Method which ensure the each columns in particular DataRow.
/// </summary>
/// <param name="visibleColumnLines"></param>
internal override void EnsureColumns(VisibleLinesCollection visibleColumnLines)
{
if (this.DataGrid.FilterRowPosition == FilterRowPosition.None)
{
return;
}
base.EnsureColumns(visibleColumnLines);
}
private TreeDataRowBase CreateHeaderRow(int rowIndex, VisibleLinesCollection visibleColumns)
{
var dr = new TreeDataRow();
dr.RowIndex = rowIndex;
dr.TreeGrid = this.Owner;
dr.RowType = TreeRowType.HeaderRow;
dr.InitializeTreeRow(visibleColumns);
return(dr);
}
private void EnsureIndentColumns(VisibleLinesCollection visibleColumns, int index)
{
var startColumnIndex = visibleColumns[0].LineIndex + (this.DataGrid.ShowRowHeader ? 1 : 0);
var endColumnIndex = visibleColumns[visibleColumns.LastBodyVisibleIndex].LineIndex;
if ((index < (this.DataGrid.View != null ? this.DataGrid.View.GroupDescriptions.Count : 0)) || (index <= (this.DataGrid.View != null ? this.DataGrid.View.GroupDescriptions.Count : 0) && this.DataGrid.ShowRowHeader))
{
if ((index < (this.DataGrid.View != null ? this.DataGrid.View.GroupDescriptions.Count : 0)) || (this.DataGrid.ShowRowHeader && index <= (this.DataGrid.View != null ? this.DataGrid.View.GroupDescriptions.Count : 0)))
{
if (index > this.RowLevel && (this.RowType == RowType.CaptionCoveredRow || this.RowType == RowType.SummaryCoveredRow || this.RowType == RowType.TableSummaryCoveredRow))
{
return;
}
}
if (!this.VisibleColumns.Any(column => column.ColumnIndex == index && column.IsIndentColumn))
{
var dataColumn = this.VisibleColumns.FirstOrDefault(column => ((column.ColumnIndex <startColumnIndex || column.ColumnIndex> endColumnIndex) && !column.IsEnsured && column.IsIndentColumn));
if (dataColumn != null)
{
if (index < 0)
{
dataColumn.ColumnVisibility = Visibility.Collapsed;
}
else
{
dataColumn.ColumnIndex = index;
//WPF-31663 - IndentColumnType should be set based on index since, any indent cells can be reused for anything.
SetIndentColumnType(dataColumn);
if (dataColumn.ColumnVisibility == Visibility.Collapsed)
{
dataColumn.ColumnVisibility = Visibility.Visible;
}
}
}
else
{
this.CreateIndentInCoveredRow(index);
}
}
else
{
var indentColumn = this.VisibleColumns.FirstOrDefault(column => column.ColumnIndex == index && column.IsIndentColumn);
if (indentColumn != null)
{
//WPF-31663 - IndentColumnType should be set based on index since, any indent cells can be reused for anything.
SetIndentColumnType(indentColumn);
indentColumn.IsEnsured = true;
}
}
}
}
protected override void OnGenerateVisibleColumns(VisibleLinesCollection visibleColumnLines)
{
this.VisibleColumns.Clear();
for (int i = 0; i < 2; i++)
{
int StartColumnIndex = 0;
int EndColumnIndex = 0;
if (i == 0)
{
if (visibleColumnLines.FirstBodyVisibleIndex <= 0)
{
continue;
}
StartColumnIndex = 0;
EndColumnIndex = visibleColumnLines[visibleColumnLines.FirstBodyVisibleIndex - 1].LineIndex;
}
else if (i == 1)
{
if (visibleColumnLines.FirstBodyVisibleIndex <= 0 && visibleColumnLines.LastBodyVisibleIndex < 0)
{
continue;
}
if (visibleColumnLines.Count > visibleColumnLines.firstBodyVisibleIndex)
{
StartColumnIndex = visibleColumnLines[visibleColumnLines.FirstBodyVisibleIndex].LineIndex;
}
else
{
continue;
}
EndColumnIndex = visibleColumnLines[visibleColumnLines.LastBodyVisibleIndex].LineIndex;
}
for (int index = StartColumnIndex; index <= EndColumnIndex; index++)
{
if (TreeGrid.showRowHeader && index == 0)
{
if (!this.VisibleColumns.Any(col => col.ColumnIndex == index))
{
CreateRowHeaderColumn(index);
}
continue;
}
var dc = CreateColumn(index);
this.VisibleColumns.Add(dc);
}
}
}
private TreeDataRowBase CreateDataRow(int rowIndex, VisibleLinesCollection visibleColumns)
{
var treeRow = new TreeDataRow();
treeRow.RowIndex = rowIndex;
treeRow.RowType = TreeRowType.DefaultRow;
treeRow.TreeGrid = this.Owner;
var node = this.Owner.GetNodeAtRowIndex(rowIndex);
treeRow.Node = node;
treeRow.Level = node.Level;
treeRow.HasChildNodes = node.HasVisibleChildNodes;
treeRow.RowData = node.Item;
treeRow.InitializeTreeRow(visibleColumns);
treeRow.RowElement.UpdateIndentMargin();
return(treeRow);
}
private void ListView_ItemTapped(object sender, Syncfusion.ListView.XForms.ItemTappedEventArgs e)
{
visibleLines = this.listview.GetVisualContainer().ScrollRows.GetVisibleLines();
var tappedItemIndex = listview.DataSource.DisplayItems.IndexOf(e.ItemData as Contact);
ToExpandTappedItem(e.ItemData as Contact);
if (visibleLines.Count <= 0)
{
return;
}
var endIndex = visibleLines[visibleLines.LastBodyVisibleIndex].LineIndex;
if (tappedItemIndex == endIndex)
{
Device.BeginInvokeOnMainThread(async() =>
{
await Task.Delay(200);
(listview.LayoutManager as LinearLayout).ScrollToRowIndex(tappedItemIndex, Syncfusion.ListView.XForms.ScrollToPosition.End, true);
});
}
}
protected override void OnGenerateVisibleColumns(VisibleLinesCollection visibleColumnLines)
{
if (visibleColumnLines.Count <= 0)
{
return;
}
int startColumnIndex;
int endColumnIndex;
this.VisibleColumns.Clear();
if (this.CoveredCells.Count > 0)
{
foreach (var coveredCell in this.CoveredCells)
{
int columnHeightIncrementation = 0;
columnHeightIncrementation = coveredCell.RowSpan;
var dc = CreateColumn(coveredCell, coveredCell.Left, columnHeightIncrementation, coveredCell.Right - coveredCell.Left);
this.VisibleColumns.Add(dc);
}
int startIndex = 0;
if (this.DataGrid.ShowRowHeader)
{
this.CreateRowHeaderColumn(startIndex);
startIndex++;
}
int index;
// WPF-20041 - Need to increment indent column index
var compareIndex = this.RowType == Grid.RowType.CaptionCoveredRow ? this.RowLevel + startIndex
:(this.DataGrid.View != null ? this.DataGrid.View.GroupDescriptions.Count : 0) + startIndex;
for (index = startIndex; index < compareIndex; index++)
{
if (!visibleColumnLines.Any(col => col.LineIndex == index))
{
continue;
}
this.CreateIndentInCoveredRow(index);
}
startIndex = index;
if (!visibleColumnLines.Any(col => col.LineIndex == index))
{
return;
}
if (this.DataGrid.DetailsViewManager.HasDetailsView)
{
if (this.RowIndex < this.DataGrid.StackedHeaderRows.Count)
{
this.VisibleColumns.Add(this.CreateIndentColumn(startIndex));
}
else if (this.DataGrid.View != null && (this.RowType == RowType.SummaryRow || this.RowType == RowType.CaptionRow || this.RowType == RowType.TableSummaryRow))
{
this.VisibleColumns.Add(CreateDetailsViewIndentColumn(startIndex));
}
}
this.ResetLastColumnBorderThickness(this.VisibleColumns.LastOrDefault(visibleColumn =>
{
if ((visibleColumn.ColumnElement is GridGroupSummaryCell || visibleColumn.ColumnElement is GridTableSummaryCell ||
visibleColumn.ColumnElement is GridCaptionSummaryCell) && visibleColumn.ColumnElement.Visibility != Visibility.Collapsed)
{
return(visibleColumn.ColumnSpan > 0 ? true : (visibleColumn.GridColumn != null && !visibleColumn.GridColumn.IsHidden));
}
else
{
return(false);
}
}), true);
}
else
{
startColumnIndex = visibleColumnLines[visibleColumnLines.FirstBodyVisibleIndex - this.DataGrid.VisualContainer.FrozenColumns].LineIndex;
endColumnIndex = visibleColumnLines[visibleColumnLines.LastBodyVisibleIndex].LineIndex;
for (int index = startColumnIndex; index <= endColumnIndex; index++)
{
if (!visibleColumnLines.Any(col => col.LineIndex == index))
{
return;
}
if (index < (this.DataGrid.View != null ? this.DataGrid.View.GroupDescriptions.Count : 0))
{
this.CreateIndentInCoveredRow(index);
continue;
}
//var dc = CreateColumn(null, index, 0, 0);
//dc.IsFixedColumn = false;
//this.VisibleColumns.Add(dc);
//this.ResetLastColumnBorderThickness(dc, index == endColumnIndex);
}
}
}
internal abstract void EnsureColumns(VisibleLinesCollection visibleColumnLines);
protected abstract void OnGenerateVisibleColumns(VisibleLinesCollection visibleColumnLines);
internal void InitializeDataRow(VisibleLinesCollection visibleColumns)
{
this.OnGenerateVisibleColumns(visibleColumns);
//µÃµ½ HeaderRowControl
this.WholeRowElement = OnCreateRowElement();
}
internal override void EnsureColumns(VisibleLinesCollection visibleColumnLines)
{
// Initially all the columns will be IsEnsured false. we need to create the column to be view and that will be ensuered.
this.VisibleColumns.ForEach(column => column.IsEnsured = false);
var needToUpdateCurrentCell = this.TreeGrid.SelectionMode != GridSelectionMode.None && this.RowIndex != -1 && this.TreeGrid.NavigationMode == NavigationMode.Cell && !this.TreeGrid.SelectionController.CurrentCellManager.HasCurrentCell && this.RowIndex == this.TreeGrid.SelectionController.CurrentCellManager.CurrentRowColumnIndex.RowIndex;
//StartBodyColumnIndex - Which will make sure the actual column index.
var StartBodyColumnIndex = (visibleColumnLines.firstBodyVisibleIndex < visibleColumnLines.Count) ? visibleColumnLines[visibleColumnLines.firstBodyVisibleIndex].LineIndex : visibleColumnLines[visibleColumnLines.LastBodyVisibleIndex].LineIndex;
for (int i = 0; i < 2; i++)
{
int StartColumnIndex = 0;
int EndColumnIndex = 0;
if (i == 0)
{
if (visibleColumnLines.FirstBodyVisibleIndex <= 0)
{
continue;
}
StartColumnIndex = 0;
EndColumnIndex = visibleColumnLines[visibleColumnLines.FirstBodyVisibleIndex - 1].LineIndex;
}
// Below will make sure the start and end column index of row. which includes only data column.
else if (i == 1)
{
if (visibleColumnLines.FirstBodyVisibleIndex <= 0 && visibleColumnLines.LastBodyVisibleIndex < 0)
{
continue;
}
if (visibleColumnLines.Count > visibleColumnLines.firstBodyVisibleIndex)
{
StartColumnIndex = visibleColumnLines[visibleColumnLines.FirstBodyVisibleIndex].LineIndex;
}
else
{
continue;
}
EndColumnIndex = visibleColumnLines[visibleColumnLines.LastBodyVisibleIndex].LineIndex;
}
for (int index = StartColumnIndex; index <= EndColumnIndex; index++)
{
if (visibleColumnLines.All(row => row.LineIndex != index))
{
continue;
}
if (TreeGrid.showRowHeader && index == 0)
{
// Reuse the row header column by checking ColumnType instead of ColumnIndex (since we reset column index while removing row header column if ShowRowHeader is False).
var rhc = this.VisibleColumns.FirstOrDefault(column => column.ColumnType == TreeColumnType.RowHeader);
if (rhc != null)
{
if (rhc.ColumnVisibility == Visibility.Collapsed)
{
rhc.ColumnVisibility = Visibility.Visible;
}
rhc.IsEnsured = true;
// To reuse the column, need to set the column index here.
rhc.ColumnIndex = 0;
}
else
{
CreateRowHeaderColumn(index);
}
continue;
}
if (this.VisibleColumns.All(column => column.ColumnIndex != index || this.isDirty))
{
var hasExpanderColumn = this.VisibleColumns.Any(c => c.ColumnType == TreeColumnType.ExpanderColumn);
var isExpanderColumn = IsExpanderColumn(index);
// ColumnIndex needs to be checked with StartBodyColumnIndex and EndColumnIndex - Due to avoid reusing freezed columns from header and footer.
TreeDataColumnBase dataColumn;
if (hasExpanderColumn && isExpanderColumn)
{
dataColumn = this.VisibleColumns.FirstOrDefault(
column => ((column.ColumnIndex <StartBodyColumnIndex || column.ColumnIndex> EndColumnIndex || this.isDirty) &&
!column.IsEnsured && !column.IsEditing && (!column.IsCurrentCell || this.isDirty) && column.ColumnType == TreeColumnType.ExpanderColumn));
}
else
{
dataColumn = this.VisibleColumns.FirstOrDefault(
column => ((column.ColumnIndex <StartBodyColumnIndex || column.ColumnIndex> EndColumnIndex || this.isDirty) &&
!column.IsEnsured && column.ColumnType != TreeColumnType.RowHeader && !column.IsEditing && (!column.IsCurrentCell || this.isDirty) &&
(column.ColumnType != TreeColumnType.ExpanderColumn || (column.ColumnType == TreeColumnType.ExpanderColumn && isExpanderColumn))));
}
if (dataColumn != null && (!isExpanderColumn || dataColumn.ColumnType == TreeColumnType.ExpanderColumn))
{
// which will reuse the column element fully, or load its element with different one.
UpdateColumn(dataColumn, index);
}
}
var dc = this.VisibleColumns.FirstOrDefault(column => column.ColumnIndex == index);
if (dc != null)
{
if (dc.ColumnVisibility == Visibility.Collapsed)
{
dc.ColumnVisibility = Visibility.Visible;
dc.UpdateCellStyle();
if (dc.Renderer != null && (dc.Renderer.HasCurrentCellState && (dc.IsEditing || dc.TreeGridColumn.CanFocus())))
{
dc.Renderer.SetFocus(true);
}
}
if (needToUpdateCurrentCell)
{
this.UpdateCurrentCellSelection(dc);
}
dc.IsEnsured = true;
}
else
{
if (index >= this.TreeGrid.TreeGridPanel.ColumnCount)
{
continue;
}
var datacolumn = CreateColumn(index);
if (needToUpdateCurrentCell)
{
this.UpdateCurrentCellSelection(datacolumn);
}
datacolumn.IsEnsured = true;
this.VisibleColumns.Add(datacolumn);
}
}
}
this.VisibleColumns.ForEach(column =>
{
if (!column.IsEnsured)
{
CollapseColumn(column);
}
});
this.isDirty = false;
Panel panel = this.RowElement.ItemsPanel;
if (panel != null && this.TreeGrid.IsLoaded)
{
panel.InvalidateMeasure();
}
}
internal void InitializeTreeRow(VisibleLinesCollection visibleColumns)
{
this.OnGenerateVisibleColumns(visibleColumns);
this.RowElement = OnCreateRowElement();
}
internal override void EnsureColumns(VisibleLinesCollection visibleColumnLines)
{
if (this.RowIndex == -1)
{
this.RowLevel = -1;
return;
}
this.VisibleColumns.ForEach(column => column.IsEnsured = false);
var StartBodyColumnIndex = (visibleColumnLines.firstBodyVisibleIndex < visibleColumnLines.Count) ? visibleColumnLines[visibleColumnLines.firstBodyVisibleIndex].LineIndex : visibleColumnLines[visibleColumnLines.LastBodyVisibleIndex].LineIndex;
if (this.CoveredCells.Count > 0 || this.RowIndex < this.DataGrid.HeaderLineCount)
{
for (int i = 0; i < 3; i++)
{
int startColumnIndex;
int endColumnIndex;
if (i == 0)
{
if (visibleColumnLines.FirstBodyVisibleIndex <= 0)
{
continue;
}
startColumnIndex = 0;
endColumnIndex = visibleColumnLines[visibleColumnLines.FirstBodyVisibleIndex - 1].LineIndex;
}
else if (i == 1)
{
if (visibleColumnLines.FirstBodyVisibleIndex <= 0 && visibleColumnLines.LastBodyVisibleIndex < 0)
{
continue;
}
if (visibleColumnLines.Count > visibleColumnLines.firstBodyVisibleIndex)
{
startColumnIndex = visibleColumnLines[visibleColumnLines.FirstBodyVisibleIndex].LineIndex;
}
else
{
continue;
}
endColumnIndex = visibleColumnLines[visibleColumnLines.LastBodyVisibleIndex].LineIndex;
}
else
{
if (visibleColumnLines.FirstFooterVisibleIndex >= visibleColumnLines.Count)
{
continue;
}
startColumnIndex = visibleColumnLines[visibleColumnLines.FirstFooterVisibleIndex].LineIndex;
endColumnIndex = visibleColumnLines[visibleColumnLines.Count - 1].LineIndex;
}
for (int index = startColumnIndex; index <= endColumnIndex; index++)
{
if (visibleColumnLines.All(row => row.LineIndex != index))
{
continue;
}
if (DataGrid.ShowRowHeader && index == 0)
{
var rhc = this.VisibleColumns.FirstOrDefault(column => column.ColumnIndex == index);
if (rhc != null)
{
if (rhc.ColumnVisibility == Visibility.Collapsed)
{
rhc.ColumnVisibility = Visibility.Visible;
}
rhc.IsEnsured = true;
}
else
{
CreateRowHeaderColumn(index);
}
continue;
}
if (this.DataGrid.View != null && this.DataGrid.DetailsViewManager.HasDetailsView && index == (this.DataGrid.ShowRowHeader ? this.DataGrid.View.GroupDescriptions.Count + 1 : this.DataGrid.View.GroupDescriptions.Count))
{
var dvc = this.VisibleColumns.FirstOrDefault(column => column.ColumnIndex == index);
if (dvc != null)
{
if (dvc.ColumnVisibility == Visibility.Collapsed)
{
dvc.ColumnVisibility = Visibility.Visible;
}
dvc.IsEnsured = true;
continue;
}
if (this.RowIndex < this.DataGrid.StackedHeaderRows.Count)
{
this.VisibleColumns.Add(this.CreateIndentColumn(index));
}
else if (this.RowType == RowType.SummaryRow || this.RowType == RowType.CaptionRow ||
this.RowType == RowType.TableSummaryRow)
{
this.VisibleColumns.Add(CreateDetailsViewIndentColumn(index));
}
continue;
}
var rowHeaderIndex = this.DataGrid.ShowRowHeader ? 1 : 0;
var indentCellIndex = -1;
if (this.RowType == RowType.CaptionCoveredRow)
{
indentCellIndex = this.DataGrid.View != null ? this.RowLevel + rowHeaderIndex : rowHeaderIndex;
}
else
{
indentCellIndex = this.DataGrid.View != null ? this.DataGrid.View.GroupDescriptions.Count + rowHeaderIndex : rowHeaderIndex;
}
if (index < indentCellIndex)
{
this.EnsureIndentColumns(visibleColumnLines, index);
this.CheckAvailablity(index, true);
continue;
}
else
{
CoveredCellInfo coveredCellItem = null;
if (this.RowType == RowType.CaptionCoveredRow || this.RowType == RowType.SummaryCoveredRow || this.RowType == RowType.TableSummaryCoveredRow)
{
coveredCellItem = this.CoveredCells.FirstOrDefault();
}
else
{
coveredCellItem = this.CoveredCells.FirstOrDefault(item => item.Left <= index && item.Right >= index);
}
var actualIndex = coveredCellItem != null ? coveredCellItem.Left : index;
if ((this.RowRegion == RowRegion.Body || RowType == RowType.TableSummaryCoveredRow || RowType == RowType.TableSummaryRow) && this.VisibleColumns.All(column => column.ColumnIndex != actualIndex))
{
if (this.VisibleColumns.Any(column => ((column.ColumnIndex < StartBodyColumnIndex || column.ColumnIndex > endColumnIndex) && !column.IsEnsured && !column.IsIndentColumn)))
{
var datacolumn = this.VisibleColumns.FirstOrDefault(column => ((column.ColumnIndex <StartBodyColumnIndex || column.ColumnIndex> endColumnIndex) && !column.IsEnsured && !column.IsIndentColumn && column.Renderer != null && column.Renderer != this.DataGrid.CellRenderers["RowHeader"]));
if (datacolumn != null)
{
UpdateColumn(datacolumn, index);
}
}
}
this.CheckAvailablity(actualIndex, false);
}
}
}
var orderedColumns = this.VisibleColumns.OrderBy(item => item.ColumnIndex);
this.ResetLastColumnBorderThickness(orderedColumns.LastOrDefault(col =>
{
if ((col.ColumnElement is GridGroupSummaryCell || col.ColumnElement is GridTableSummaryCell ||
col.ColumnElement is GridCaptionSummaryCell) && col.ColumnElement.Visibility != Visibility.Collapsed)
{
if (col.ColumnSpan > 0)
{
return(true);
}
else
{
return(col.GridColumn != null && !col.GridColumn.IsHidden);
}
}
else
{
return(false);
}
}), true);
}
if (this.RowType != Grid.RowType.TableSummaryRow || this.RowType != Grid.RowType.TableSummaryCoveredRow)
{
if (this.IsSelectedRow)
{
this.WholeRowElement.UpdateSelectionBorderClip();
}
//When scrolling horizontally the Focus border margin is not changed which sets the margin including the IndentCell Width,
//hence the below code is added.
else if (this.IsCurrentRow && this.DataGrid.SelectionMode == GridSelectionMode.Multiple)
{
this.WholeRowElement.UpdateFocusRowPosition();
}
}
this.VisibleColumns.ForEach(column =>
{
if (!column.IsEnsured)
{
CollapseColumn(column);
}
});
this.InvalidateMeasure();
}
/// <summary>
/// Method to ensure or update the row associated properties like RowIndex, RowData, row state and its selection while scrolling and Data Manipulation Operation based on VisibleRows.
/// </summary>
/// <param name="visibleRows"></param>
public virtual void EnsureRows(VisibleLinesCollection visibleRows)
{
if (visibleRows.Count > 0)
{
var ActualStartIndex = 0;
var ActualEndIndex = 0;
// Initially will set IsEnsured to false. and create will set again to true in following case.
this.Items.ForEach(row => { row.IsEnsured = false; });
var region = RowRegion.Header;
for (int i = 0; i < 2; i++)
{
// Below condition make sure the Header of the rows. will include Frozen rows, Table summaries at top, AddNewRow at Top and Headers.
if (i == 0)
{
if (visibleRows.firstBodyVisibleIndex > 0)
{
ActualStartIndex = 0;
ActualEndIndex = visibleRows[visibleRows.FirstBodyVisibleIndex - 1].LineIndex;
}
else
{
ActualStartIndex = 0;
ActualEndIndex = -1;
}
region = RowRegion.Header;
}
// Below will make sure the start and end rows. which includes only datarows.
else if (i == 1)
{
if (visibleRows.FirstBodyVisibleIndex <= 0 && visibleRows.LastBodyVisibleIndex < 0)
{
continue;
}
if (visibleRows.Count > visibleRows.FirstBodyVisibleIndex)
{
ActualStartIndex = visibleRows[visibleRows.FirstBodyVisibleIndex].LineIndex;
}
else
{
continue;
}
ActualEndIndex = visibleRows[visibleRows.LastBodyVisibleIndex].LineIndex;
region = RowRegion.Body;
}
for (int index = ActualStartIndex; index <= ActualEndIndex; index++)
{
if (this.Items.All(row => row.RowIndex != index))
{
if (this.Items.Any(row => (row.RowIndex < 0 || row.RowIndex < ActualStartIndex || row.RowIndex > ActualEndIndex) && !row.IsEnsured))
{
// we wont reuse rows that was current row, it was in editing
IEnumerable <TreeDataRowBase> rows;
if (this.Owner.SelectionController.CurrentCellManager.CurrentRowColumnIndex.RowIndex >= 0 && this.Owner.SelectionController.CurrentCellManager.CurrentRowColumnIndex.RowIndex == index)
{
rows = this.Items.Where(row => row.IsCurrentRow);
if (!rows.Any())
{
// will get rows to reuse based on some conditions , doing with key navigation(Enter/Down/Up to bring single row from unview row to view.).
rows = this.Items.Where(row => ((row.RowIndex < 0 || row.RowIndex <ActualStartIndex ||
row.RowIndex> ActualEndIndex) && !row.IsEnsured && !row.IsEditing) && !row.IsCurrentRow);
}
}
else
{
//will get rows to reuse based on some conditions , called while scroll vertically - bulk rows has been taken for reuse.
rows = this.Items.Where(row => ((row.RowIndex < 0 || row.RowIndex <ActualStartIndex ||
row.RowIndex> ActualEndIndex) && !row.IsEnsured && !row.IsEditing) && !row.IsCurrentRow);
}
if (rows != null && rows.Any())
{
//Call for reusing rows taken from above codes.
UpdateRow(rows, index, region);
var updatedRow = this.Items.FirstOrDefault(row => row.RowIndex == index);
if (updatedRow is TreeDataRow)
{
(updatedRow as TreeDataRow).UpdateExpanderCell();
}
}
}
}
var dr = this.Items.FirstOrDefault(row => row.RowIndex == index);
if (dr != null)
{
if (dr.RowVisibility == Visibility.Collapsed)
{
dr.RowVisibility = Visibility.Visible;
}
}
else
{
// Code for adding rows at run time.
if (region == RowRegion.Header)
{
dr = CreateHeaderRow(index, this.TreePanel.ScrollColumns.GetVisibleLines());
}
else
{
dr = CreateDataRow(index, this.TreePanel.ScrollColumns.GetVisibleLines());
}
this.Items.Add(dr);
}
dr.RowElement.UpdateIndentMargin();
if (dr.updateExpander)
{
(dr as TreeDataRow).UpdateExpanderCell();
dr.updateExpander = false;
}
if (dr.IsCurrentRow)
{
// selection need to check moving left to right ,
this.CheckForSelection(dr);
dr.IsCurrentRow = false;
(dr as TreeDataRowBase).ApplyRowHeaderVisualState();
}
if (!dr.IsSelectedRow)
{
this.CheckForSelection(dr);
dr.IsCurrentRow = false;
(dr as TreeDataRowBase).ApplyRowHeaderVisualState();
}
dr.IsEnsured = true;
//when scroll vertically, the new row can be created with new curerntcell for that row. where we need to set the currentcell using this call.
if (dr.RowIndex == this.Owner.SelectionController.CurrentCellManager.CurrentRowColumnIndex.RowIndex && (this.Owner.NavigationMode == NavigationMode.Cell || (this.Owner.NavigationMode == NavigationMode.Cell && this.Owner.SelectionMode == GridSelectionMode.Multiple && this.Owner.CurrentItem != null)))
{
dr.UpdateCurrentCellSelection();
}
dr.IsEnsured = true;
}
}
}
if (this.Owner.SelectionController.CurrentCellManager.HasCurrentCell || this.Owner.SelectionController.CurrentCellManager.CurrentRowColumnIndex.RowIndex >= this.Owner.GetHeaderIndex())
{
// while reusing rows, we need to update the row header cell if that row is a current row.
var currentRow = this.Items.FirstOrDefault(row => row.RowIndex == this.Owner.SelectionController.CurrentCellManager.CurrentRowColumnIndex.RowIndex);
if (currentRow != null)
{
currentRow.IsCurrentRow = true;
(currentRow as TreeDataRowBase).ApplyRowHeaderVisualState();
}
}
this.Items.ForEach(row => { if (!row.IsEnsured)
{
CollapseRow(row);
}
});
}
internal override void EnsureColumns(VisibleLinesCollection visibleColumnLines)
{
this.VisibleColumns.ForEach(dataColumn => dataColumn.IsEnsured = false);
var groupCount = this.DataGrid.View != null ? this.DataGrid.View.GroupDescriptions.Count : 0;
int startIndex = 0;
if (this.DataGrid.showRowHeader)
{
if (visibleColumnLines.Any(line => line.LineIndex == 0))
{
var dc = this.VisibleColumns.FirstOrDefault(dataColumn => dataColumn.ColumnIndex == 0);
if (dc != null)
{
dc.IsEnsured = true;
if (dc.ColumnVisibility == Visibility.Collapsed)
{
dc.ColumnVisibility = Visibility.Visible;
}
}
else
{
CreateRowHeaderColumn(startIndex);
}
}
startIndex++;
}
for (var index = startIndex; index < groupCount + startIndex; index++)
{
if (visibleColumnLines.Any(line => line.LineIndex == index))
{
var dc = this.VisibleColumns.FirstOrDefault(dataColumn => dataColumn.ColumnIndex == index);
if (dc != null)
{
dc.IsEnsured = true;
if (dc.ColumnVisibility == Visibility.Collapsed)
{
dc.ColumnVisibility = Visibility.Visible;
}
}
else
{
this.VisibleColumns.Add(CreateIndentColumn(index));
}
}
}
var indentcolumnindex = groupCount + (this.DataGrid.showRowHeader ? 1 : 0);
if (visibleColumnLines.Any(line => line.LineIndex == indentcolumnindex))
{
var indentDataColumn = this.VisibleColumns.FirstOrDefault(dataColumn => dataColumn.ColumnIndex == indentcolumnindex);
if (indentDataColumn != null)
{
indentDataColumn.IsEnsured = true;
if (indentDataColumn.ColumnVisibility == Visibility.Collapsed)
{
indentDataColumn.ColumnVisibility = Visibility.Visible;
}
}
else
{
this.VisibleColumns.Add(CreateDetailsViewIndentColumn(groupCount + (this.DataGrid.showRowHeader ? 1 : 0)));
}
}
var detailsViewDataColumn = this.VisibleColumns.FirstOrDefault(dataColumn => dataColumn.ColumnIndex == groupCount + 1 + (this.DataGrid.showRowHeader ? 1 : 0));
if (detailsViewDataColumn != null)
{
detailsViewDataColumn.IsEnsured = true;
if (detailsViewDataColumn.ColumnVisibility == Visibility.Collapsed)
{
detailsViewDataColumn.ColumnVisibility = Visibility.Visible;
}
}
else
{
this.VisibleColumns.Add(CreateDetailsViewContent(groupCount + 1 + (this.DataGrid.showRowHeader ? 1 : 0)));
}
this.VisibleColumns.ForEach(column =>
{
if (!column.IsEnsured)
{
CollapseColumn(column);
}
});
// WPF-18333 - after clearing all the columns, DetailsViewContentPresenter content will be null. Then if new column is added, its content need to be set here.
// Also parent grid width should be adjuted based on DetailsViewDataGrid
if (this.DetailsViewContentPresenter != null && this.DetailsViewContentPresenter.Content == null)
{
this.DetailsViewContentPresenter.Content = this.DetailsViewDataGrid;
if (this.DetailsViewDataGrid.NotifyListener != null)
{
DetailsViewManager.AdjustParentsWidth(this.DetailsViewDataGrid.NotifyListener.GetParentDataGrid(), this.DetailsViewDataGrid);
}
}
if (this.WholeRowElement.ItemsPanel != null)
{
this.WholeRowElement.ItemsPanel.InvalidateMeasure();
}
}
