// undo/redo column sizes void flex_ResizingColumn(object sender, CellRangeEventArgs e) { if (!(_pendingAction is ColumnResizeAction)) { _pendingAction = new ColumnResizeAction(_flex); } }
void flex_ResizedRow(object sender, CellRangeEventArgs e) { if (_pendingAction is RowResizeAction && _pendingAction.SaveNewState()) { _flex.UndoStack.AddAction(_pendingAction); } _pendingAction = null; }
internal void SetCollapsed(bool collapsed) { CellRangeEventArgs cellRangeEventArg = new CellRangeEventArgs(Grid.Cells, new CellRange(Index, -1)); RowCollection rows = Rows; C1FlexGrid grid = Rows.Grid; grid.OnGroupCollapsedChanging(cellRangeEventArg); if (!cellRangeEventArg.Cancel && grid.FinishEditing()) { CellRange cellRange = GetCellRange(); using (rows.DeferNotifications()) { bool groupRowAboveData = (grid.GroupRowPosition == GroupRowPosition.AboveData); SetFlag(RowColFlags.Collapsed, collapsed); if (!groupRowAboveData) { for (int i = cellRange.BottomRow - 1; i >= cellRange.TopRow && i > -1 && i < rows.Count; i--) { rows[i].SetFlag(RowColFlags.ParentCollapsed, collapsed); GroupRow item = rows[i] as GroupRow; if (item != null && item.IsCollapsed) { i = item.GetCellRange().TopRow; } } } else { int topRow = cellRange.TopRow + 1; while (topRow <= cellRange.BottomRow && topRow > -1) { if (topRow < rows.Count) { rows[topRow].SetFlag(RowColFlags.ParentCollapsed, collapsed); GroupRow groupRow = rows[topRow] as GroupRow; if (groupRow != null && groupRow.IsCollapsed) { topRow = groupRow.GetCellRange().BottomRow; } topRow++; } else { break; } } } } } rows.OnCollectionChanged(); grid.OnGroupCollapsedChanged(cellRangeEventArg); }
// handle user selection on the dropdown void _flex_SelectionChanged(object sender, CellRangeEventArgs e) { // not if we're updating if (_updatingSelection) { _updatingSelection = false; return; } // update textbox to match drop-down selection UpdateComboText(); // close dropdown IsDroppedDown = false; // update selected index SetSelectedIndex(_flex.SelectedIndex); }
// record original sort values void flex_SortingColumn(object sender, CellRangeEventArgs e) { _pendingAction = new SortAction(_flex); }
private void ResizeSelectedColumns(bool autoSize) { int column = _cellResize.Column; CellRange selection = _grid.Selection; if (selection.ContainsColumn(column) && selection.TopRow == 0 && selection.BottomRow == _grid.Rows.Count - 1) { for (int i = selection.LeftColumn; i <= selection.RightColumn; i++) { if (i != column) { CellRangeEventArgs cellRangeEventArg = new CellRangeEventArgs(_grid.Cells, new CellRange(-1, i)); _grid.OnResizingColumn(cellRangeEventArg); if (!autoSize) { _grid.Columns[i].Width = _grid.Columns[column].Width; } else { _grid.AutoSizeColumn(i, AUTOSIZE_EXTRA); } _grid.OnResizedColumn(cellRangeEventArg); } } } }
private void HandleDrag(RoutedEventArgs e, HitTestInfo htDown, HitTestInfo htMove) { if (htMove != null && htDown != null && htDown.CellType != CellType.None) { HitTestInfo ht = htMove; Point mouseDelta = GetMouseDelta(htDown, e); if (_cellResize.Column > -1) { int num = (int) Math.Max(0, _szCell.Width + mouseDelta.X); htDown.Panel.Columns[_cellResize.Column].Width = new GridLength(num); _grid.OnResizingColumn(new CellRangeEventArgs(htDown.Panel, _cellResize)); return; } if (_cellResize.Row > -1) { int num1 = (int) Math.Max(0, _szCell.Height + mouseDelta.Y); htDown.Panel.Rows[_cellResize.Row].Height = num1; _grid.OnResizingRow(new CellRangeEventArgs(htDown.Panel, _cellResize)); return; } if (ht.CellType == CellType.ColumnHeader && ht.CellRange.IsValid && AllowDragColumn(ht)) { if (_rcInsert == null && Math.Abs(mouseDelta.X) > MOUSE_THRESHOLD && ht.Column == htDown.Column) { CellRangeEventArgs cellRangeEventArg = new CellRangeEventArgs(htDown.Panel, htDown.CellRange); _grid.OnDraggingColumn(cellRangeEventArg); if (!cellRangeEventArg.Cancel) { CreateDragRects(ht.CellRange, htDown); SetCursor(Cursors.Hand); } } if (_rcInsert != null) { UpdateDragTargetCell(e, htDown); } } else if (ht.CellType == CellType.RowHeader && ht.CellRange.IsValid && AllowDragRow(ht)) { if (_rcInsert == null && Math.Abs(mouseDelta.Y) > MOUSE_THRESHOLD && ht.Row == htDown.Row) { CellRangeEventArgs cellRangeEventArg1 = new CellRangeEventArgs(htDown.Panel, htDown.CellRange); _grid.OnDraggingRow(cellRangeEventArg1); if (!cellRangeEventArg1.Cancel) { CreateDragRects(ht.CellRange, htDown); SetCursor(Cursors.Hand); } } if (_rcInsert != null) { UpdateDragTargetCell(e, htDown); } } else if (_rcInsert == null && (ht.CellType == CellType.Cell || ht.CellType == CellType.RowHeader)) { HandleSelection(true, false, htDown, htMove); } } }
private void _flex_DraggingColumn(object sender, CellRangeEventArgs e) { FlexGrid.ReleaseMouseCapture(); e.Cancel = true; Column col = FlexGrid.Columns[e.Column]; StartDraggingColumn(col); }
/// <summary> /// Raises the <see cref="E:C1.WPF.FlexGrid.C1FlexGrid.GroupCollapsedChanging" /> event. /// </summary> /// <param name="e"> /// <see cref="T:C1.WPF.FlexGrid.CellRangeEventArgs" /> that contains the event data. /// </param> protected internal virtual void OnGroupCollapsedChanging(CellRangeEventArgs e) { if (GroupCollapsedChanging != null) { GroupCollapsedChanging(this, e); } }
/// <summary> /// Raises the <see cref="E:C1.WPF.FlexGrid.C1FlexGrid.GroupCollapsedChanged" /> event. /// </summary> /// <param name="e"> /// <see cref="T:C1.WPF.FlexGrid.CellRangeEventArgs" /> that contains the event data. /// </param> protected internal virtual void OnGroupCollapsedChanged(CellRangeEventArgs e) { if (GroupCollapsedChanged != null && !_restoringState) { GroupCollapsedChanged(this, e); } }
/// <summary> /// Raises the <see cref="E:C1.WPF.FlexGrid.C1FlexGrid.DraggingRow" /> event. /// </summary> /// <param name="e"> /// <see cref="T:C1.WPF.FlexGrid.CellRangeEventArgs" /> that contains the event data. /// </param> protected internal virtual void OnDraggingRow(CellRangeEventArgs e) { if (DraggingRow != null) { DraggingRow(this, e); } }
/// <summary> /// Raises the <see cref="E:C1.WPF.FlexGrid.C1FlexGrid.DraggedColumn" /> event. /// </summary> /// <param name="e"> /// <see cref="T:C1.WPF.FlexGrid.CellRangeEventArgs" /> that contains the event data. /// </param> protected internal virtual void OnDraggedColumn(CellRangeEventArgs e) { if (DraggedColumn != null) { DraggedColumn(this, e); } }
// do something when the value of a cell changes void cf_CellValueChanged(object sender, CellRangeEventArgs e) { Console.WriteLine("the value of cell ({0}, {1}) has changed to {2}", e.Row, e.Column, _flex[e.Row, e.Column]); // update "Fault" column when "Enable" changes var col = _flex.Columns[e.Column]; if (col.DataType == typeof(bool) && col.ColumnName.EndsWith("Enable")) { // get current 'Enable' value var value = (bool)_flex[e.Row,e.Column]; // set corresponding 'Fault' value // (in this case, a function of the 'Enable' cell, but could be anything) System.Diagnostics.Debug.Assert(_flex.Columns[e.Column + 1].DataType == typeof(FaultType)); _flex[e.Row, e.Column + 1] = value ? FaultType.None : FaultType.Red; // refresh cell _flex.Invalidate(new CellRange(e.Row, e.Column + 1)); // if this is the Input.Enable cell, then enable/disable entire row if (col.ColumnName == "Input.Enable") { var row= _flex.Rows[e.Row]; row.Foreground = value ? _brBlack : _brGray; row.IsReadOnly = !value; } } }
private void _grid_SelectionChanging(object sender, CellRangeEventArgs e) { if (e.Row != _grid.Selection.Row && e.Row > -1) { if (!CommitRowChanges(false)) { e.Cancel = true; } } else if (ActiveEditor != null) { FinishEditing(false); } }
public void Select(int row, int col, int row2, int col2, bool scrollIntoView) { CellRange cellRange = _sel; CellRange cellRange1 = new CellRange(row, col, row2, col2); cellRange1 = AdjustSelection(cellRange1, false); if (cellRange1 == _sel) { if (scrollIntoView) { _grid.ScrollIntoView(cellRange1.Row, cellRange1.Column); } return; } CellRangeEventArgs cellRangeEventArg = new CellRangeEventArgs(_grid.Cells, cellRange1); _grid.OnSelectionChanging(cellRangeEventArg); if (cellRangeEventArg.Cancel) { return; } if (_grid.ActiveEditor != null) { return; } cellRange1.Row = Math.Min(cellRange1.Row, _grid.Rows.Count - 1); cellRange1.Row2 = Math.Min(cellRange1.Row2, _grid.Rows.Count - 1); _sel = cellRange1; if (_grid.SelectionMode == SelectionMode.ListBox) { RowCollection rows = _grid.Rows; for (int i = 0; i < rows.Count; i++) { rows[i].SetFlag(RowColFlags.Selected, cellRange1.ContainsRow(i)); } } _grid.UpdateSelectedItems(false); if (scrollIntoView) { _grid.ScrollIntoView(cellRange1.Row, cellRange1.Column); } foreach (CellRange key in GetRangeDelta(cellRange, cellRange1).Keys) { UpdateRangeBrushes(key); } if (_grid.ColumnHeaderSelectedBackground != null) { UpdateHeaderBackground(true); } if (_grid.RowHeaderSelectedBackground != null) { UpdateHeaderBackground(false); } _grid.UpdateMarquee(); _grid.OnSelectionChanged(cellRangeEventArg); }
// update UI when the selection changes void _flex_SelectionChanged(object sender, C1.WPF.FlexGrid.CellRangeEventArgs e) { UpdateUI(); }
// make all unbound grid columns the same width after they are resized void _flexUnbound_ResizedColumn(object sender, CellRangeEventArgs e) { var col = _flexUnbound.Columns[e.Column]; if (col.ActualWidth > 0) { _flexUnbound.Columns.DefaultSize = col.ActualWidth; } col.Width = new GridLength(1, GridUnitType.Auto); }
/// <summary> /// Raises the <see cref="E:C1.WPF.FlexGrid.C1FlexGrid.ResizedColumn" /> event. /// </summary> /// <param name="e"> /// <see cref="T:C1.WPF.FlexGrid.CellRangeEventArgs" /> that contains the event data. /// </param> protected internal virtual void OnResizedColumn(CellRangeEventArgs e) { if (ResizedColumn != null) { ResizedColumn(this, e); } }
private void HandleDoubleClick(C1TappedEventArgs e) { _grid.OnDoubleClick(e.OriginalEventArgs as MouseButtonEventArgs); if (!e.Handled) { HitTestInfo ht = _grid.HitTest(e.OriginalEventArgs); if (ht == null || ht.Panel == null) { return; } _cellResize = GetResizeCell(ht); CellRange cellRange = _cellResize; CellRangeEventArgs cellResizeArgs = new CellRangeEventArgs(ht.Panel, cellRange); if (ht.CellType == CellType.ColumnHeader && cellRange.Column > -1) { _grid.AutoSizeColumn(cellRange.Column, AUTOSIZE_EXTRA); _grid.OnResizedColumn(cellResizeArgs); ResizeSelectedColumns(true); e.Handled = true; return; } if (ht.CellType == CellType.RowHeader && cellRange.Row > -1) { _grid.AutoSizeRow(cellRange.Row, AUTOSIZE_EXTRA); _grid.OnResizedRow(cellResizeArgs); ResizeSelectedRows(true); e.Handled = true; return; } if (ht.CellType == CellType.TopLeft) { if (cellRange.Row > -1) { _grid.AutoSizeFixedRow(cellRange.Row, AUTOSIZE_EXTRA); _grid.OnResizedRow(cellResizeArgs); e.Handled = true; } if (cellRange.Column > -1) { _grid.AutoSizeFixedColumn(cellRange.Column, AUTOSIZE_EXTRA); _grid.OnResizedColumn(cellResizeArgs); e.Handled = true; } } } }
/// <summary> /// Raises the <see cref="E:C1.WPF.FlexGrid.C1FlexGrid.ResizingRow" /> event. /// </summary> /// <param name="e"> /// <see cref="T:C1.WPF.FlexGrid.CellRangeEventArgs" /> that contains the event data. /// </param> protected internal virtual void OnResizingRow(CellRangeEventArgs e) { if (ResizingRow != null) { ResizingRow(this, e); } }
private void HandleSort(HitTestInfo htDown) { if (!AllowSortColumn(htDown)) { return; } ICollectionView collectionView = _grid.CollectionView; Column item = _grid.Columns[htDown.Column]; ListSortDirection sortDirection = ListSortDirection.Ascending; SortDescriptionCollection sortDescriptions = collectionView.SortDescriptions; string nsd = _grid.GetNormalizedSortDescription(item.BoundPropertyName); if (!string.IsNullOrEmpty(nsd)) { foreach (SortDescription sortDescription in sortDescriptions) { if (sortDescription.PropertyName != nsd || sortDescription.Direction != ListSortDirection.Ascending) { continue; } sortDirection = ListSortDirection.Descending; break; } CellRangeEventArgs cellRangeEventArg = new CellRangeEventArgs(htDown.Panel, htDown.CellRange); _grid.OnSortingColumn(cellRangeEventArg); if (!cellRangeEventArg.Cancel) { try { using (collectionView.DeferRefresh()) { sortDescriptions.Clear(); if (!Kbd.IsControlPressed()) { sortDescriptions.Add(new SortDescription(nsd, sortDirection)); } } } catch { } _grid.OnSortedColumn(cellRangeEventArg); } } }
/// <summary> /// Raises the <see cref="E:C1.WPF.FlexGrid.C1FlexGrid.SelectionChanging" /> event. /// </summary> /// <param name="e"> /// <see cref="T:C1.WPF.FlexGrid.CellRangeEventArgs" /> that contains the event data. /// </param> protected internal virtual void OnSelectionChanging(CellRangeEventArgs e) { if (SelectionChanging != null) { SelectionChanging(this, e); } }
private void ResizeSelectedRow(int r, bool auto) { int row = _cellResize.Row; if (r != row) { CellRangeEventArgs cellRangeEventArg = new CellRangeEventArgs(_grid.Cells, new CellRange(r, -1)); _grid.OnResizingRow(cellRangeEventArg); if (!auto) { _grid.Rows[r].Height = _grid.Rows[row].Height; } else { _grid.AutoSizeRow(r, AUTOSIZE_EXTRA); } _grid.OnResizedRow(cellRangeEventArg); } }
/// <summary> /// Raises the <see cref="E:C1.WPF.FlexGrid.C1FlexGrid.SortingColumn" /> event. /// </summary> /// <param name="e"> /// <see cref="T:C1.WPF.FlexGrid.CellRangeEventArgs" /> that contains the event data. /// </param> protected internal virtual void OnSortingColumn(CellRangeEventArgs e) { if (SortingColumn != null) { SortingColumn(this, e); } }
/// <summary> /// Raises the <see cref="E:C1.WPF.FlexGrid.C1FlexGrid.ScrollingDeferred" /> event. /// </summary> /// <param name="e"> /// <see cref="T:C1.WPF.FlexGrid.CellRangeEventArgs" /> that contains the event data. /// </param> protected virtual void OnScrollingDeferred(CellRangeEventArgs e) { if (ScrollingDeferred != null) { ScrollingDeferred(this, e); } }
void _flexSelectionMode_SelectionChanged(object sender, CellRangeEventArgs e) { var fg = _flexSelectionMode; var customers = fg.SelectedItems; _lblSelState.Text = string.Format("{0} item{1} selected, {2} active, total weight: {3:n2}", customers.Count, customers.Count == 1 ? string.Empty : "s", (from Customer c in customers where c.Active select c).Count(), (from Customer c in customers select c.Weight).Sum()); }
// undo/redo row sizes void flex_ResizingRow(object sender, CellRangeEventArgs e) { if (!(_pendingAction is RowResizeAction)) { _pendingAction = new RowResizeAction(_flex, e); } }
public RowResizeAction(C1FlexGridBook flex, CellRangeEventArgs e) { _flex = flex; _row = e.Row; _oldSize = _flex.Rows[_row].Height; }