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