/// <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; } }); } } ); } }