private void ResetMouseState(RoutedEventArgs e)
{
if (_rcHighlight != null)
{
_htDragStarted.Panel.Children.Remove(_rcHighlight);
_rcHighlight = null;
}
if (_rcInsert != null)
{
_htDragStarted.Panel.Children.Remove(_rcInsert);
_rcInsert = null;
}
CellRange empty = CellRange.Empty;
CellRange cellRange = empty;
_dragTarget = empty;
_cellResize = cellRange;
_htDragStarted = null;
_htMove = null;
_tmScroll.Stop();
_dragHelper.Complete();
if (e != null)
{
return;
}
SetCursor(null);
}
private CellRange UpdateDragTargetCell(RoutedEventArgs e, HitTestInfo htDown)
{
GridPanel panel = htDown.Panel;
HitTestInfo hitTestInfo = panel.HitTest(e);
switch (hitTestInfo.CellType)
{
case CellType.ColumnHeader:
{
_grid.ScrollIntoView(-1, hitTestInfo.Column);
int col = (int) _rcInsert.GetValue(Grid.ColumnProperty);
int dst = GetValidDestination(panel.Columns, col, hitTestInfo.Column);
Rect cellRect = panel.GetCellRect(htDown.Row, dst);
if (hitTestInfo.Point.X <= cellRect.X + cellRect.Width/2)
{
cellRect.X = cellRect.X - 2;
}
else
{
cellRect.X = cellRect.Right - 2;
dst++;
}
cellRect.Width = 3;
_rcInsert.Arrange(cellRect);
_dragTarget.SetRange(-1, dst);
break;
}
case CellType.RowHeader:
{
_grid.ScrollIntoView(hitTestInfo.Row, -1);
int row = (int) _rcInsert.GetValue(Grid.RowProperty);
int dst = GetValidDestination(panel.Rows, row, hitTestInfo.Row);
Rect y = panel.GetCellRect(dst, htDown.Column);
if (hitTestInfo.Point.Y <= y.Y + y.Height/2)
{
y.Y = y.Y - 2;
}
else
{
y.Y = y.Bottom - 2;
dst++;
}
y.Height = 3;
_rcInsert.Arrange(y);
_dragTarget.SetRange(dst, -1);
break;
}
}
CellRange cellRange = new CellRange(_rcHighlight);
_rcHighlight.Arrange(panel.GetCellRect(cellRange));
return _dragTarget;
}
private void OnDragDelta(object sender, C1DragDeltaEventArgs e)
{
if (e.PointerDeviceType == C1PointerDeviceType.Touch && !_startOverSelectedCell)
{
double x = _startScrollPosition.X;
Point cumulativeTranslation = e.CumulativeTranslation;
x = Math.Min(x + cumulativeTranslation.X, 0);
Point cumulativeTranslation1 = e.CumulativeTranslation;
double y = _startScrollPosition.Y;
y = Math.Min(y + cumulativeTranslation1.Y, 0);
_grid.ScrollPosition = new Point(x, y);
return;
}
if (!e.IsInertial && _htDragStarted != null && _htDragStarted.Panel != null)
{
_htMove = _htDragStarted.Panel.HitTest(e.OriginalEventArgs);
HandleDrag(e.OriginalEventArgs, _htDragStarted, _htMove);
}
}
private void OnDragStarted(object sender, C1DragStartedEventArgs e)
{
Point point = UIElementEx.C1TransformToVisual(_grid, null).Inverse.Transform(e.Origin);
_htDragStarted = _grid.HitTest(point);
if (e.PointerDeviceType == C1PointerDeviceType.Touch)
{
_startScrollPosition = _grid.ScrollPosition;
_startOverSelectedCell = ((_htDragStarted.CellType == CellType.Cell || _htDragStarted.CellType == CellType.RowHeader)
&& _htDragStarted.CellRange.IsSingleCell && _grid.GetSelectedState(_htDragStarted.CellRange) != SelectedState.None);
}
if (_cellResize.Row == -1 && (e.PointerDeviceType == C1PointerDeviceType.Mouse || _startOverSelectedCell))
{
if (e.PointerDeviceType == C1PointerDeviceType.Touch)
{
HandleSelection(Kbd.IsShiftPressed(), true, _htDragStarted, _htDragStarted);
}
_tmScroll.Start();
}
}
private void HandleSelection(bool extend, bool starting, HitTestInfo htDown, HitTestInfo htMove)
{
CellRange selection = _grid.Selection;
CellType cellType = htMove.CellType;
int r = Math.Max(htMove.Row, 0);
int c = Math.Max(htMove.Column, 0);
if (htDown.Row >= 0)
{
if (_grid.SelectionMode == SelectionMode.ListBox)
{
if (starting)
{
_lbSelRows = null;
if (Kbd.IsControlPressed())
{
_lbSelState = !_grid.Rows[r].Selected;
_lbSelRows = new Dictionary<int, bool>();
for (int i = 0; i < _grid.Rows.Count; i++)
{
if (_grid.Rows[i].Selected)
{
_lbSelRows[i] = true;
}
}
}
}
if (_lbSelRows != null)
{
for (int j = 0; j < _grid.Rows.Count; j++)
{
_grid.Rows[j].Selected = (j < Math.Min(r, htDown.Row) || j > Math.Max(r, htDown.Row) ? _lbSelRows.ContainsKey(j) : _lbSelState);
}
return;
}
}
if (cellType == CellType.RowHeader)
{
int col2 = _grid.Columns.Count - 1;
if (!extend)
{
_grid.Select(r, 0, r, col2, true);
return;
}
_grid.Select(r, 0, selection.Row2, col2, true);
return;
}
if (htDown.Column > -1)
{
if (extend)
{
_grid.Select(r, c, selection.Row2, selection.Column2, true);
return;
}
_grid.Select(r, c);
}
}
}
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);
}
}
}
private void HandleMove(HitTestInfo htMove)
{
Cursor sizeNS;
_cellResize = GetResizeCell(htMove);
if (_cellResize.Row > -1)
{
sizeNS = Cursors.SizeNS;
}
else if (_cellResize.Column > -1)
{
sizeNS = Cursors.SizeWE;
}
else
{
sizeNS = null;
}
SetCursor(sizeNS);
}
private void HandleRowColDrag(HitTestInfo htDown)
{
_grid.FinishEditing();
if (htDown.CellType == CellType.ColumnHeader && _dragTarget.Column > -1)
{
CellRange selection = _grid.Selection;
Column column1 = selection.Column >= 0 ? _grid.Columns[selection.Column] : null;
Column column2 = selection.Column2 >= 0 ? _grid.Columns[selection.Column2] : null;
int col = (int) _rcInsert.GetValue(Grid.ColumnProperty);
int dragTargetCol = _dragTarget.Column;
if (dragTargetCol > col)
{
dragTargetCol--;
}
htDown.Panel.Columns.MoveElement(col, dragTargetCol);
_grid.OnDraggedColumn(new CellRangeEventArgs(htDown.Panel, new CellRange(-1, dragTargetCol)));
if (column1 != null && column2 != null)
{
_grid.Select(selection.Row, column1.Index, selection.Row2, column2.Index, false);
}
}
else if (htDown.CellType == CellType.RowHeader && _dragTarget.Row > -1)
{
CellRange cellRange = _grid.Selection;
Row row1 = cellRange.Row >= 0 ? _grid.Rows[cellRange.Row] : null;
Row row2 = cellRange.Row2 >= 0 ? _grid.Rows[cellRange.Row2] : null;
int row = (int) _rcInsert.GetValue(Grid.RowProperty);
int dragTargetRow = _dragTarget.Row;
if (dragTargetRow > row)
{
dragTargetRow--;
}
htDown.Panel.Rows.MoveElement(row, dragTargetRow);
_grid.OnDraggedRow(new CellRangeEventArgs(htDown.Panel, new CellRange(dragTargetRow, -1)));
if (row1 != null && row2 != null)
{
_grid.Select(row1.Index, cellRange.Column, row2.Index, cellRange.Column2, false);
}
}
}
private CellRange GetResizeCell(HitTestInfo ht)
{
CellRange rng = CellRange.Empty;
int threshold = (C1InputEventArgs.GetPointerType(ht.MouseEventArgs) == C1PointerDeviceType.Mouse ? MOUSE_THRESHOLD : RESIZE_TOUCH_THRESHOLD);
if (ht.CellType == CellType.ColumnHeader || ht.CellType == CellType.TopLeft)
{
if (Math.Abs(ht.Point.X - ht.Rect.X) <= threshold && ht.Column > 0)
{
int resizableColumn = GetResizableColumn(ht.Panel, Math.Max(0, ht.Column - 1));
rng.Column = (ht.Panel.Columns[resizableColumn].AllowResizing ? resizableColumn : -1);
}
else if (Math.Abs(ht.Point.X - ht.Rect.Right) <= threshold)
{
int resizableColumn1 = GetResizableColumn(ht.Panel, ht.Column);
rng.Column = (ht.Panel.Columns[resizableColumn1].AllowResizing ? resizableColumn1 : -1);
}
}
if (ht.CellType == CellType.RowHeader || ht.CellType == CellType.TopLeft)
{
if (Math.Abs(ht.Point.Y - ht.Rect.Y) <= MOUSE_THRESHOLD)
{
int row = ht.Row - 1;
while (row >= 0)
{
Row item = ht.Panel.Rows[row];
if (!item.IsVisible)
{
row--;
}
else
{
rng.Row = (item.AllowResizing ? row : -1);
switch (_grid.AllowResizing)
{
case AllowResizing.None:
{
rng.Row = -1;
rng.Column = -1;
break;
}
case AllowResizing.Columns:
{
rng.Row = -1;
break;
}
case AllowResizing.Rows:
{
rng.Column = -1;
break;
}
}
if (rng.Column >= 0)
{
_szCell.Width = ht.Panel.Columns.GetItemSize(rng.Column, false);
}
if (rng.Row >= 0)
{
_szCell.Height = ht.Panel.Rows.GetItemSize(rng.Row, false);
}
return rng;
}
}
}
else if (Math.Abs(ht.Point.Y - ht.Rect.Bottom) <= MOUSE_THRESHOLD)
{
rng.Row = (ht.Panel.Rows[ht.Row].AllowResizing ? ht.Row : -1);
}
}
switch (_grid.AllowResizing)
{
case AllowResizing.None:
{
rng.Row = -1;
rng.Column = -1;
break;
}
case AllowResizing.Columns:
{
rng.Row = -1;
break;
}
case AllowResizing.Rows:
{
rng.Column = -1;
break;
}
}
if (rng.Column >= 0)
{
_szCell.Width = ht.Panel.Columns.GetItemSize(rng.Column, false);
}
if (rng.Row >= 0)
{
_szCell.Height = ht.Panel.Rows.GetItemSize(rng.Row, false);
}
return rng;
}
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 Point GetMouseDelta(HitTestInfo htDown, RoutedEventArgs e)
{
Point point = htDown.Point;
Point position = Util.Util.GetPosition(e, htDown.Panel);
return new Point(position.X - point.X, position.Y - point.Y);
}
private void CreateDragRects(CellRange rng, HitTestInfo htDown)
{
GridPanel panel = htDown.Panel;
for (int i = 0; i < 2; i++)
{
Rectangle rectangle = new Rectangle();
rectangle.SetValue(Panel.ZIndexProperty, 1);
rectangle.SetValue(Grid.ColumnProperty, rng.Column);
rectangle.SetValue(Grid.RowProperty, rng.Row);
if (i != 0)
{
_rcInsert = rectangle;
rectangle.Fill = _brInsert;
}
else
{
_rcHighlight = rectangle;
rectangle.Fill = _brHighlight;
}
panel.Children.Add(rectangle);
}
}
private bool AllowSortColumn(HitTestInfo ht)
{
ICollectionView collectionView = _grid.CollectionView;
_grid.FinishEditing();
if (_grid.ActiveEditor != null)
{
return false;
}
IEditableCollectionView editableCollectionView = _grid.EditableCollectionView;
if (editableCollectionView != null)
{
if (editableCollectionView.IsAddingNew)
{
editableCollectionView.CommitNew();
}
if (editableCollectionView.IsEditingItem)
{
editableCollectionView.CommitEdit();
}
if (editableCollectionView.IsAddingNew || editableCollectionView.IsEditingItem)
{
return false;
}
}
if (collectionView == null || !collectionView.CanSort || !_grid.AllowSorting || _grid.ActiveEditor != null || ht.Column <= -1)
{
return false;
}
return _grid.Columns[ht.Column].AllowSorting;
}
private bool AllowDragRow(HitTestInfo ht)
{
if (_grid.CollectionView != null)
{
return false;
}
if (_grid.AllowDragging != AllowDragging.Rows && _grid.AllowDragging != AllowDragging.Both)
{
return false;
}
return _grid.Rows[ht.Row].AllowDragging;
}
private bool AllowDragColumn(HitTestInfo ht)
{
if (_grid.AllowDragging != AllowDragging.Columns && _grid.AllowDragging != AllowDragging.Both)
{
return false;
}
return _grid.Columns[ht.Column].AllowDragging;
}
