/// <summary>
/// Initialize a new object.
/// </summary>
/// <param name="rowIndex">The row index.</param>
/// <param name="colIndex">The column index.</param>
/// <param name="range">A <see cref="CoveredCellInfo"/> that will receive the resulting range for the covered cell.</param>
public GridQueryCoveredRangeEventArgs(RowColumnIndex cellRowColumnIndex, CoveredCellInfo range, GridColumn column, object record, object originalSource) : base(originalSource)
{
this.range = range;
this.cellRowColumnIndex = cellRowColumnIndex;
this.column = column;
this.record = record;
}
/// <summary>
/// Gets the conflicting range from existing CoveredCells collection.
/// </summary>
/// <param name="coveredCellInfo">Specifies the range that conflicting with existing covered ranges</param>
/// <returns>Returns the covered cell range if the given range is conflicting any other existing range of CoveredCells. </returns>
public static CoveredCellInfo GetConflictRange(this SfDataGrid dataGrid, CoveredCellInfo coveredCellInfo)
{
foreach (CoveredCellInfo coveredCell in dataGrid.CoveredCells)
{
// Reference - condition based on Rectangle clip check from MS.
if (coveredCell.Top <= coveredCellInfo.Bottom &&
coveredCell.Bottom >= coveredCellInfo.Top &&
coveredCell.Right >= coveredCellInfo.Left &&
coveredCell.Left <= coveredCellInfo.Right)
{
return(coveredCell);
}
}
return(null);
}
private SpannedDataColumn CreateColumn(CoveredCellInfo cc, int index, int heightIncrementation, int widthIncrementation)
{
var dc = new SpannedDataColumn
{
ColumnIndex = index,
RowSpan = heightIncrementation,
ColumnSpan = widthIncrementation,
// WPF-19238- if grid has no columns and summary row is added, need to set null for grid column
GridColumn = this.DataGrid.Columns.Count > 0 ? this.DataGrid.Columns[ResolveToGridColumnIndex(index)] : null,
RowIndex = this.RowIndex,
SelectionController = this.DataGrid.SelectionController
};
if (this.RowType == RowType.TableSummaryRow || this.RowType == RowType.TableSummaryCoveredRow)
{
dc.Renderer = this.DataGrid.CellRenderers["TableSummary"];
}
else if (this.RowType == RowType.CaptionRow || this.RowType == RowType.CaptionCoveredRow)
{
dc.Renderer = this.DataGrid.CellRenderers["CaptionSummary"];
}
else if (this.RowType == Grid.RowType.HeaderRow)
{
if (dc.RowIndex < this.DataGrid.GetHeaderIndex())
{
dc.GridColumn = null;
dc.Renderer = this.DataGrid.CellRenderers["StackedHeader"];
this.RowData = this.DataGrid.StackedHeaderRows[this.RowIndex].StackedColumns.FirstOrDefault(col => col.HeaderText == cc.Name);
}
else
{
dc.Renderer = this.DataGrid.CellRenderers["Header"];
}
}
else //(this.RowType == RowType.SummaryRow || this.RowType == RowType.SummaryCoveredRow)
{
dc.Renderer = this.DataGrid.CellRenderers["GroupSummary"];
}
dc.InitializeColumnElement(this.RowData, false);
#if WPF
if (DataGrid.useDrawing && dc.ColumnElement is GridCell)
{
(dc.ColumnElement as GridCell).UseDrawing = DataGrid.useDrawing;
}
#endif
return(dc);
}
/// <summary>
/// Add the range to CoveredCells.
/// </summary>
/// <param name="dataGrid">The SfDataGrid.</param>
/// <param name="coveredCellRange">Specifies the range that will added to CoveredCells</param>
public static void AddRange(this SfDataGrid dataGrid, CoveredCellInfo coveredCellRange)
{
if (dataGrid.CoveredCells.IsInRange(coveredCellRange))
{
throw new Exception(String.Format("Conflict detected with when trying to save {0}", coveredCellRange));
}
coveredCellRange.MappedRowColumnIndex = new RowColumnIndex(coveredCellRange.Top, coveredCellRange.Left);
dataGrid.CoveredCells.Add(coveredCellRange);
dataGrid.RowGenerator.Items.ForEach(row =>
{
if ((row.RowType == RowType.UnBoundRow || row.RowType == RowType.DefaultRow) && row.RowIndex >= coveredCellRange.Top && row.RowIndex <= coveredCellRange.Bottom)
{
dataGrid.MergedCellManager.InitializeMergedRow(row);
}
});
}
/// <summary>
/// Remove the range from CoveredCells.
/// </summary>
/// <param name="dataGrid">The SfDataGrid.</param>
/// <param name="coveredCellRange">Specifies the range to remove from CoveredCells</param>
public static void RemoveRange(this SfDataGrid dataGrid, CoveredCellInfo coveredCellRange)
{
var conatins = dataGrid.CoveredCells.Contains(coveredCellRange);
if (!conatins)
{
return;
}
// Find range from the covered cells.
var resetRange = dataGrid.CoveredCells.Find(range => coveredCellRange.Top >= range.Top && coveredCellRange.Bottom <= range.Bottom && coveredCellRange.Left >= range.Left && coveredCellRange.Right <= range.Right);
if (resetRange == null)
{
return;
}
dataGrid.CoveredCells.Remove(resetRange);
dataGrid.RowGenerator.Items.ForEach(row =>
{
if (row.RowIndex >= resetRange.Top && row.RowIndex <= resetRange.Bottom)
{
row.RowIndex = -1;
dataGrid.MergedCellManager.ResetCoveredRows(row);
}
});
if (!(resetRange.Top == coveredCellRange.Top || resetRange.Bottom == coveredCellRange.Bottom))
{
throw new Exception(string.Format("Given range {0} is not valid to remove from the range {1}", coveredCellRange, resetRange));
}
if (resetRange.Top == coveredCellRange.Top && resetRange.Bottom == coveredCellRange.Bottom)
{
return;
}
resetRange = new CoveredCellInfo(resetRange.Left, resetRange.Right, resetRange.Top == coveredCellRange.Top ? coveredCellRange.Bottom : resetRange.Top, resetRange.Bottom == coveredCellRange.Bottom ? coveredCellRange.Top : resetRange.Bottom);
resetRange.MappedRowColumnIndex = new RowColumnIndex(resetRange.Top, resetRange.Left);
dataGrid.CoveredCells.Add(resetRange);
}
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>
/// Raise query for the each column
/// </summary>
/// <param name="dataGrid"></param>
/// <param name="dc"></param>
internal void EnsureMergedCells(DataRowBase dr, DataColumnBase dc, object dataContext)
{
if (dc.GridColumn == null)
{
return;
}
var coveredCell = dataGrid.CoveredCells.GetCoveredCell(dc.RowIndex, dc.ColumnIndex, dc.GridColumn, dataContext);
if (coveredCell == null)
{
return;
}
//Throws exception for invalid range with rows.
this.dataGrid.CoveredCells.ContainsRow(coveredCell);
// Throws exception for invalid range with columns.
this.dataGrid.CoveredCells.ContainsColumn(dr, coveredCell);
if (!dc.GridColumn.hasCellTemplate &&
(dc.GridColumn.hasCellTemplateSelector ||
(dc.GridColumn.IsTemplate && ((dc.GridColumn as GridTemplateColumn).hasEditTemplateSelector || dataGrid.hasCellTemplateSelector))))
// Column has cell template selector will not get merge.
{
this.dataGrid.CoveredCells.Remove(coveredCell);
return;
}
// Raise exception for the invalid range of unbound row.
if (dr.RowType == RowType.UnBoundRow)
{
var bottomIndex = coveredCell.Bottom;
var topIndex = coveredCell.Top;
RowRegion topRowRegion = dr.RowRegion;
if (dataGrid.RowGenerator.Items.Find(row => row.RowIndex == topIndex) != null)
{
topRowRegion = dataGrid.RowGenerator.Items.Find(row => row.RowIndex == topIndex).RowRegion;
}
RowRegion bottomRowRegion = dr.RowRegion;
if (dataGrid.RowGenerator.Items.Find(row => row.RowIndex == bottomIndex) != null)
{
bottomRowRegion = dataGrid.RowGenerator.Items.Find(row => row.RowIndex == bottomIndex).RowRegion;
}
if (!dataGrid.IsUnBoundRow(bottomIndex) || !dataGrid.IsUnBoundRow(topIndex) || topRowRegion != bottomRowRegion)
{
throw new Exception(string.Format("Given range {0} is not valid", coveredCell));
}
}
dr.isSpannedRow = true;
dc.isSpannedColumn = true;
// Reset the covered cell range by bottom for Frozen rows.
if (dataGrid.FrozenRowsCount > 0 && coveredCell.Top < dataGrid.VisualContainer.FrozenRows)
{
CoveredCellInfo newCoveredCell = null;
dataGrid.CoveredCells.Remove(coveredCell);
if (coveredCell.Top < dataGrid.VisualContainer.FrozenRows && coveredCell.Bottom >= dataGrid.VisualContainer.FrozenRows)
{
newCoveredCell = new CoveredCellInfo(coveredCell.Left,
coveredCell.Right,
coveredCell.Top,
coveredCell.Bottom < dataGrid.VisualContainer.FrozenRows ? coveredCell.Bottom : dataGrid.VisualContainer.FrozenRows - 1);
}
else
{
newCoveredCell = coveredCell;
}
dataGrid.CoveredCells.Add(newCoveredCell);
this.UpdateMappedRowIndex(dr, dr.RowIndex);
dataGrid.RowGenerator.Items.ForEach(row =>
{
if (newCoveredCell != null && row.RowIndex > newCoveredCell.Bottom && row.RowIndex <= coveredCell.Bottom)
{
dataGrid.MergedCellManager.ResetCoveredRows(row);
}
}
);
}
// Reset the covered cell range by top for footer rows.
else if (dataGrid.FooterRowsCount > 0 && coveredCell.Bottom >= (this.dataGrid.VisualContainer.RowCount - this.dataGrid.VisualContainer.FooterRows) &&
coveredCell.Bottom < this.dataGrid.VisualContainer.RowCount)
{
CoveredCellInfo newCoveredCell = null;
dataGrid.CoveredCells.Remove(coveredCell);
if (coveredCell.Top < (dataGrid.VisualContainer.RowCount - dataGrid.VisualContainer.FooterRows))
{
newCoveredCell = new CoveredCellInfo(coveredCell.Left,
coveredCell.Right,
coveredCell.Top < (dataGrid.VisualContainer.RowCount - dataGrid.VisualContainer.FooterRows) ?
(dataGrid.VisualContainer.RowCount - dataGrid.VisualContainer.FooterRows) : coveredCell.Top,
coveredCell.Bottom);
}
else
{
newCoveredCell = coveredCell;
}
dataGrid.CoveredCells.Add(newCoveredCell);
this.UpdateMappedRowIndex(dr, dr.RowIndex);
dataGrid.RowGenerator.Items.ForEach(row =>
{
if (newCoveredCell != null && row.RowIndex < newCoveredCell.Top && row.RowIndex >= coveredCell.Top)
{
dataGrid.MergedCellManager.ResetCoveredRows(row);
}
}
);
}
// Reset the covered cell range by right for frozen columns
if (dataGrid.FrozenColumnCount > 0 && dc.ColumnIndex < dataGrid.VisualContainer.FrozenColumns)
{
CoveredCellInfo newCoveredCell = null;
dataGrid.CoveredCells.Remove(coveredCell);
if (coveredCell.Left < dataGrid.VisualContainer.FrozenColumns && coveredCell.Right >= dataGrid.VisualContainer.FrozenColumns)
{
newCoveredCell = new CoveredCellInfo(coveredCell.Left,
coveredCell.Right < dataGrid.VisualContainer.FrozenColumns ? coveredCell.Right : dataGrid.VisualContainer.FrozenColumns - 1,
coveredCell.Top,
coveredCell.Bottom);
}
else
{
newCoveredCell = coveredCell;
}
dataGrid.CoveredCells.Add(newCoveredCell);
this.UpdateMappedRowIndex(dr, dr.RowIndex);
dataGrid.RowGenerator.Items.ForEach(row =>
{
if (newCoveredCell != null && row.RowIndex >= coveredCell.Top && row.RowIndex <= coveredCell.Bottom)
{
row.VisibleColumns.ForEach(column =>
{
if (column.ColumnIndex > newCoveredCell.Right && column.ColumnIndex <= coveredCell.Right)
{
column.isSpannedColumn = false;
column.ColumnVisibility = Visibility.Visible;
}
});
}
}
);
}
// Reset the covered cell range by left for frozen columns
else if (dataGrid.FooterColumnCount > 0 && coveredCell.Right >= (dataGrid.VisualContainer.ColumnCount - dataGrid.VisualContainer.FooterColumns) && coveredCell.Right < dataGrid.VisualContainer.ColumnCount)
{
CoveredCellInfo newCoveredCell = null;
dataGrid.CoveredCells.Remove(coveredCell);
if ((dataGrid.VisualContainer.ColumnCount - dataGrid.VisualContainer.FooterColumns) >= coveredCell.Left && coveredCell.Right <= dataGrid.VisualContainer.ColumnCount)
{
newCoveredCell = new CoveredCellInfo(coveredCell.Left,
coveredCell.Right < (dataGrid.VisualContainer.ColumnCount - dataGrid.VisualContainer.FooterColumns) ?
coveredCell.Right : dataGrid.VisualContainer.ColumnCount - dataGrid.VisualContainer.FooterColumns,
coveredCell.Top, coveredCell.Bottom);
}
else
{
newCoveredCell = coveredCell;
}
dataGrid.CoveredCells.Add(newCoveredCell);
this.UpdateMappedRowIndex(dr, dr.RowIndex);
dataGrid.RowGenerator.Items.ForEach(row =>
{
if (newCoveredCell != null && row.RowIndex >= coveredCell.Top && row.RowIndex <= coveredCell.Bottom)
{
row.VisibleColumns.ForEach(column =>
{
if (column.ColumnIndex > newCoveredCell.Right && column.ColumnIndex <= coveredCell.Right)
{
column.isSpannedColumn = false;
column.ColumnVisibility = Visibility.Visible;
}
});
}
}
);
}
}