protected void HeaderOnPointerMoved(object?sender, PointerEventArgs e)
{
if (PPHeaderClick != null)
{
double x = PPHeaderClick.Position.X - e.GetCurrentPoint(null).Position.X;
double y = PPHeaderClick.Position.Y - e.GetCurrentPoint(null).Position.Y;
PixelPoint pp = new PixelPoint((Position.X - (int)x), (Position.Y - (int)y));
Position = pp;
}
}
protected override void OnPointerMoved(PointerEventArgs e)
{
if (_isDrawing || _isSelecting)
{
PointerPoint pp = e.GetCurrentPoint(this);
if (pp.Properties.PointerUpdateKind == PointerUpdateKind.Other)
{
Point pos = pp.Position;
if (Bounds.TemporaryFix_PointerInControl(pos))
{
int x = (int)(pos.X / _scale) / Overworld.Tile_NumPixelsX;
int y = (int)(pos.Y / _scale) / Overworld.Tile_NumPixelsY;
if (_isDrawing)
{
SetTiles(x, y);
}
else
{
_selection.Move(x, y);
}
e.Handled = true;
}
}
}
}
private static void OnGridViewPreviewMouseMove(object?sender, PointerEventArgs e)
{
GridView?listBox = sender as GridView;
if (listBox == null)
{
return;
}
Point currentCursorPos = e.GetPosition(null);
Vector cursorVector = m_cursorStartPos - currentCursorPos;
if (!e.GetCurrentPoint(listBox).Properties.IsLeftButtonPressed ||
(!(Math.Abs(cursorVector.X) > 10) && !(Math.Abs(cursorVector.Y) > 10)) || dragging)
{
return;
}
ListBoxItem?targetItem = FindVisualParent <ListBoxItem>((IVisual?)e.Source);
if (targetItem == null || targetItem.DataContext == null)
{
return;
}
dragging = true;
var data = new DataObject();
data.Set("", new DragInfo()
{
draggedElement = listBox.ListBoxImpl !.Selection.SelectedItems,
draggedIndex = listBox.ListBoxImpl !.Selection.SelectedIndexes
});
/// <inheritdoc />
public Task PointerPressedExecuteAsync()
{
_pointerStart = PointerEventArgs.GetCurrentPoint(Canvas).Position;
// Create selector square
selectorSquare = new Rectangle();
selectorSquare.Width = 1;
selectorSquare.Height = 1;
selectorSquare.SetValue(Canvas.LeftProperty, _pointerStart.X);
selectorSquare.SetValue(Canvas.TopProperty, _pointerStart.Y);
// Give selector square blue acryl color
Brush brush = new AcrylicBrush()
{
TintColor = Colors.Blue,
TintOpacity = 0.1
};
selectorSquare.Fill = brush;
Canvas.Children.Add(selectorSquare);
return(Task.CompletedTask);
}
/// <inheritdoc />
public Task PointerMovedExecuteAsync()
{
if (PointerEventArgs.Pointer.IsInContact && selectorSquare != null)
{
// Update the size of the selector square
Point currentPoint = PointerEventArgs.GetCurrentPoint(Canvas).Position;
Point difference = new Point(currentPoint.X - _pointerStart.X, currentPoint.Y - _pointerStart.Y);
if (difference.X < 0)
{
selectorSquare.Width = difference.X * -1.0;
selectorSquare.SetValue(Canvas.LeftProperty, _pointerStart.X + difference.X);
}
else
{
selectorSquare.Width = difference.X;
}
if (difference.Y < 0)
{
selectorSquare.Height = difference.Y * -1.0;
selectorSquare.SetValue(Canvas.TopProperty, _pointerStart.Y + difference.Y);
}
else
{
selectorSquare.Height = difference.Y;
}
}
return(Task.CompletedTask);
}
public void PhonemeCanvasPointerMoved(object sender, PointerEventArgs args)
{
if (ViewModel?.NotesViewModel?.Part == null)
{
return;
}
var canvas = (Canvas)sender;
var point = args.GetCurrentPoint(canvas);
if (editState != null)
{
editState.Update(point.Pointer, point.Position);
return;
}
var hitInfo = ViewModel.NotesViewModel.HitTest.HitTestPhoneme(point.Position);
if (hitInfo.hit)
{
Cursor = ViewConstants.cursorSizeWE;
}
else
{
Cursor = null;
}
}
private void TrackMoved(object sender, PointerEventArgs e)
{
if (_isDragging)
{
MoveToPoint(e.GetCurrentPoint(_track));
}
}
/// <inheritdoc />
public Task PointerMovedExecuteAsync()
{
// Update current item accoarding to mouse movements
if (PointerEventArgs.Pointer.IsInContact && current != null)
{
Point currentPoint = PointerEventArgs.GetCurrentPoint(Canvas).Position;
Point difference = new Point(currentPoint.X - _pointerStart.X, currentPoint.Y - _pointerStart.Y);
if (difference.X < 0)
{
current.Width = difference.X * -1.0;
current.X = _pointerStart.X + difference.X;
}
else
{
current.Width = difference.X;
}
if (difference.Y < 0)
{
current.Height = difference.Y * -1.0;
current.Y = _pointerStart.Y + difference.Y;
}
else
{
current.Height = difference.Y;
}
_page.Draw();
}
return(Task.CompletedTask);
}
/// <inheritdoc />
public Task PointerPressedExecuteAsync()
{
// Add entry to UndoStack
UndoStack.Push(ShapeList.DeepCopy());
RedoStack.Clear();
// Set pointer starting point
_pointerStart = PointerEventArgs.GetCurrentPoint(Canvas).Position;
// Create new shape
PaintBase shape = new PaintShape(ShapeType);
shape.X = _pointerStart.X;
shape.Y = _pointerStart.Y;
shape.Width = 2;
shape.Height = 2;
ShapeList.Add(shape);
current = shape;
_page.Draw();
_page.UpdateList();
return(Task.CompletedTask);
}
private void CardRenderTarget_PointerMoved(object sender, PointerEventArgs e)
{
if (VM.CursorMode && CardRenderTarget.Children.Count > 0 && CardRenderTarget.Children[0] is Canvas renderedCard)
{
var currentPoint = e.GetCurrentPoint(renderedCard).Position;
if (_dragStartingPoint.HasValue)
{
var rect = new Rect(_dragStartingPoint.Value, currentPoint);
if (null == _lastRectangle)
{
_lastRectangle = new Border();
_lastRectangle.BorderBrush = Brushes.Red;
_lastRectangle.BorderThickness = new Thickness(1);
renderedCard.Children.Add(_lastRectangle);
}
_lastRectangle.SetValue(Canvas.LeftProperty, Math.Min(rect.X, rect.X + rect.Width));
_lastRectangle.SetValue(Canvas.TopProperty, Math.Min(rect.Y, rect.Y + rect.Height));
_lastRectangle.Width = Math.Abs(rect.Width);
_lastRectangle.Height = Math.Abs(rect.Height);
VM.CursorInfo = $"X: {rect.X} Y: {rect.Y} W: {rect.Width} H: {rect.Height}";
}
else
{
VM.CursorInfo = $"X: {currentPoint.X} Y: {currentPoint.Y}";
}
}
}
#pragma warning restore CS0618
private void MainImage_PointerMoved(object sender, PointerEventArgs e)
{
// allow to move cursor out leaving selection/hignlighting unchanged
if (IgnorePointerMove(e))
{
return;
}
PointerPoint p = e.GetCurrentPoint(_mainImageControl);
_pointerPos = p.Position;
//
if (p.Properties.IsMiddleButtonPressed)
{
TD.Point delta = ToPoint(_pointerPosDrag - _pointerPos);
_pointerPosDrag = _pointerPos;
_viewport.MoveOrigin(delta);
UpdateDrawerBounds();
MarkPresetChanged();
InvalidateView(false); // viewport moved only
}
else
{
TD.Point u = _viewport.ToUser(ToPoint(_pointerPos));
_gridDrawer.SetCursor(u.X, u.Y);
var mode = e.KeyModifiers.HasFlag(KeyModifiers.Alt)
? GridDrawer.CursorHighlightMode.Cents
: GridDrawer.CursorHighlightMode.NearestRational;
_gridDrawer.SetCursorHighlightMode(mode);
InvalidateView();
}
}
private void LayerControlOnPointerMoved(object sender, PointerEventArgs e)
{
var cv = OverlayLayer.GetOverlayLayer(this.GetParentTOfVisual <Window>());
double delta_v, delta_h;
//double delta_vlow, delta_hlow;
delta_v = e.GetCurrentPoint(FollowerControl).Position.Y; //Math.Min(e.GetCurrentPoint(FollowerControl).Position.Y, FollowerControl.Bounds.Height - FollowerControl.MinHeight);
var t = Canvas.GetTop(FollowerControl) + delta_v;
var t_ = t - (FollowerControl.Bounds.Height / 2);
var t_s = cv.Bounds.Height - t_ - FollowerControl.Bounds.Height;//
if (t_s >= 0)
{
Canvas.SetBottom(FollowerControl, t_s);
if (t_ >= 0) //Canvas.GetTop(FollowerControl) >= 0 || Canvas.GetBottom(FollowerControl) >= 0
{
Canvas.SetTop(FollowerControl, t_); //
}
}
delta_h = e.GetCurrentPoint(FollowerControl).Position.X; //Math.Min(e.GetCurrentPoint(FollowerControl).Position.X, FollowerControl.Bounds.Width + FollowerControl.MinWidth);
var l = Canvas.GetLeft(FollowerControl) + delta_h;
var l_ = l - (FollowerControl.Bounds.Width / 2);
var l_s = cv.Bounds.Width - l_ - FollowerControl.Bounds.Width;//
if (l_s >= 0)
{
Canvas.SetRight(FollowerControl, l_s);
if (l_ >= 0) //Canvas.GetLeft(FollowerControl) >= 0 || Canvas.GetRight(FollowerControl) >= 0
{
Canvas.SetLeft(FollowerControl, l_);
}
}
#if DEBUG
// Debug.WriteLine($"moved to Top:{t_} Bottom:{t_s} Left:{l_} Right:{l_s}");
#endif
}
protected override void OnPointerMoved(PointerEventArgs e)
{
var p = e.GetCurrentPoint(this);
if (DataContext is EditProjectVM ed)
{
ed.Canvas_MouseMove(ScreenPointToDominoCoordinates(p.Position), e);
}
}
/// <inheritdoc/>
protected override void OnPointerLeave(PointerEventArgs e)
{
base.OnPointerLeave(e);
var point = e.GetCurrentPoint(null);
RaiseEvent(new PointerEventArgs(PointerLeaveItemEvent, this, e.Pointer, this.VisualRoot, point.Position,
e.Timestamp, point.Properties, e.KeyModifiers));
}
public MouseEventArgs Convert(PointerEventArgs pea)
{
PointerPoint pp = pea.GetCurrentPoint(this);
Avalonia.Point point = pea.GetPosition(this);
int key = Key(pp.Properties.PointerUpdateKind);
return(new MouseEventArgs(key, 1, (int)(point.X * this.PlatformImpl.DesktopScaling), (int)(point.Y * this.PlatformImpl.DesktopScaling), 0));
}
/// <inheritdoc />
public Task PointerPressedExecuteAsync()
{
UndoStack.Push(ShapeList.DeepCopy());
RedoStack.Clear();
_prevPointer = PointerEventArgs.GetCurrentPoint(Canvas).Position;
_selected = ShapeList.Where(bs => bs.Selected).ToList();
return(Task.CompletedTask);
}
/// <summary>
/// remembers the current point if left button down
/// </summary>
/// <param name="e"></param>
protected override void OnPointerMoved(PointerEventArgs e)
{
base.OnPointerMoved(e);
var currentPointerPoint = e.GetCurrentPoint(this);
if (currentPointerPoint.Properties.IsLeftButtonPressed &&
_designerItem != null && _canvas != null)
{
_currentPoint = e.GetPosition(_canvas);
}
}
public void TimelinePointerMoved(object sender, PointerEventArgs args)
{
var canvas = (Canvas)sender;
var point = args.GetCurrentPoint(canvas);
if (point.Properties.IsLeftButtonPressed)
{
int tick = viewModel.TracksViewModel.PointToSnappedTick(point.Position);
viewModel.PlaybackViewModel.MovePlayPos(tick);
}
}
public ConnectorItemBaseEventArgs(RoutedEvent routedEvent,
IInteractive?source,
PointerEventArgs baseArgs) :
base(routedEvent, source,
baseArgs.Pointer,
(baseArgs.Source as IVisual)?.VisualRoot,
baseArgs.GetPosition(null),
baseArgs.Timestamp,
baseArgs.GetCurrentPoint(null).Properties,
baseArgs.KeyModifiers)
{
BaseArgs = baseArgs;
}
public void ExpCanvasPointerMoved(object sender, PointerEventArgs args)
{
var canvas = (Canvas)sender;
var point = args.GetCurrentPoint(canvas);
if (editState != null)
{
editState.Update(point.Pointer, point.Position);
}
else
{
Cursor = null;
}
}
/// <inheritdoc />
protected override void OnPointerMoved(PointerEventArgs e)
{
base.OnPointerMoved(e);
if (e.Handled)
{
return;
}
PointerPoint point = e.GetCurrentPoint(this);
if (HandlePointerEvent(point, Vector.Zero))
{
e.Handled = true;
}
}
protected override void OnPointerMoved(PointerEventArgs e)
{
base.OnPointerMoved(e);
if (_pressed)
{
if (ColorParent is not null)
{
ColorParent.IsHitTestVisible = true;
}
var p = e.GetCurrentPoint(this).Position;
UpdateValuesFromPoint(p);
UpdateSelectorPosition(p);
}
}
private void PreviewMouseMoveButtons(object sender, PointerEventArgs e)
{
var properties = e.GetCurrentPoint(this).Properties;
if (properties.IsLeftButtonPressed)
{
Point pos = e.GetPosition(this);
double h = _finalSize.Height - 1 - ButtonHeight - pos.Y;
MaxNumberOfButtons = (int)((double)(h / ButtonHeight));
}
else
{
this.PointerMoved -= PreviewMouseMoveButtons;
}
}
protected ConnectionDragEventArgs(RoutedEvent routedEvent,
IInteractive?source,
GraphNodeItemView?elementItem,
ConnectorItem sourceConnectorItem,
PointerEventArgs baseArgs) : base(routedEvent, source,
baseArgs.Pointer,
(baseArgs.Source as IVisual)?.VisualRoot,
baseArgs.GetPosition(null),
baseArgs.Timestamp,
baseArgs.GetCurrentPoint(null).Properties,
baseArgs.KeyModifiers)
{
ElementItem = elementItem;
SourceConnector = sourceConnectorItem;
}
public void NotesCanvasPointerMoved(object sender, PointerEventArgs args)
{
var canvas = (Canvas)sender;
var point = args.GetCurrentPoint(canvas);
if (editState != null)
{
editState.Update(point.Pointer, point.Position);
return;
}
if (ViewModel?.NotesViewModel?.HitTest == null)
{
return;
}
var pitHitInfo = ViewModel.NotesViewModel.HitTest.HitTestPitchPoint(point.Position);
if (pitHitInfo.Note != null)
{
Cursor = ViewConstants.cursorHand;
return;
}
var vbrHitInfo = ViewModel.NotesViewModel.HitTest.HitTestVibrato(point.Position);
if (vbrHitInfo.hit)
{
if (vbrHitInfo.hitDepth)
{
Cursor = ViewConstants.cursorSizeNS;
}
else if (vbrHitInfo.hitPeriod)
{
Cursor = ViewConstants.cursorSizeWE;
}
else
{
Cursor = ViewConstants.cursorHand;
}
return;
}
var noteHitInfo = ViewModel.NotesViewModel.HitTest.HitTestNote(point.Position);
if (noteHitInfo.hitResizeArea)
{
Cursor = ViewConstants.cursorSizeWE;
return;
}
Cursor = null;
}
protected void RectangleBoundOnPointerMoved(object?sender, PointerEventArgs e)
{
Rect rect = RectangleBoundWindow.Bounds;
PRectangleBoundClick = e.GetCurrentPoint(RectangleBoundWindow).Position;
if (PRectangleBoundClick.Y < rect.Height - (RectangleBoundWindow.StrokeThickness + 3) &&
PRectangleBoundClick.X <= RectangleBoundWindow.StrokeThickness)
{
if (!IsCursorCapture)
{
Cursor = new Cursor(StandardCursorType.LeftSide);
}
}
else if (PRectangleBoundClick.X >= rect.Width - RectangleBoundWindow.StrokeThickness &&
PRectangleBoundClick.Y < rect.Height - (RectangleBoundWindow.StrokeThickness + 3))
{
if (!IsCursorCapture)
{
Cursor = new Cursor(StandardCursorType.RightSide);
}
}
else if (PRectangleBoundClick.Y >= rect.Height - RectangleBoundWindow.StrokeThickness &&
PRectangleBoundClick.X > RectangleBoundWindow.StrokeThickness + 3 &&
PRectangleBoundClick.X < rect.Width - (RectangleBoundWindow.StrokeThickness + 3))
{
if (!IsCursorCapture)
{
Cursor = new Cursor(StandardCursorType.BottomSide);
}
}
else if (PRectangleBoundClick.X <= RectangleBoundWindow.StrokeThickness &&
PRectangleBoundClick.Y >= rect.Height - (RectangleBoundWindow.StrokeThickness + 3))
{
if (!IsCursorCapture)
{
Cursor = new Cursor(StandardCursorType.BottomLeftCorner);
}
}
else if (PRectangleBoundClick.X >= rect.Width - (RectangleBoundWindow.StrokeThickness + 3) &&
PRectangleBoundClick.Y >= rect.Height - (RectangleBoundWindow.StrokeThickness + 3))
{
if (!IsCursorCapture)
{
Cursor = new Cursor(StandardCursorType.BottomRightCorner);
}
}
}
private void PreviewMouseMoveResize(object sender, PointerEventArgs e)
{
PointerPointProperties properties = e.GetCurrentPoint(this).Properties;
if (properties.IsLeftButtonPressed == true)
{
if (DockPosition == HorizontalAlignment.Left)
{
ResizeFromRight(e);
}
else
{
ResizeFromLeft(e);
}
}
}
/// <inheritdoc />
public Task PointerMovedExecuteAsync()
{
if (PointerEventArgs.Pointer.IsInContact && _selected.Count > 0)
{
Point currentPoint = PointerEventArgs.GetCurrentPoint(Canvas).Position;
Point difference = new Point(currentPoint.X - _prevPointer.X, currentPoint.Y - _prevPointer.Y);
_prevPointer = currentPoint;
foreach (PaintBase paintBase in _selected)
{
paintBase.Accept(new MoveVisitor(difference.X, difference.Y));
}
}
_page.Draw();
return(Task.CompletedTask);
}
private void MouseMoveHandler(object sender, PointerEventArgs e)
{
if (IsMoving && _moveBuffer != null)
{
_previewComponent.IsVisible = true;
}
var pos = ToGridCoordinates(e.GetCurrentPoint(Canvas).Position);
if (_previewComponent.IsVisible)
{
Canvas.SetLeft(_previewComponent, pos.X - MainWindow.GridCellSize);
Canvas.SetTop(_previewComponent, pos.Y - MainWindow.GridCellSize);
}
if (_previewConnection == null || _previewConnection.Points[^ 1] == pos)
{
return;
}
_previewConnection.Points[^ 1] = pos;
/// <inheritdoc />
public Task PointerMovedExecuteAsync()
{
if (PointerEventArgs.Pointer.IsInContact && _selected.Count > 0)
{
Point currentPoint = PointerEventArgs.GetCurrentPoint(Canvas).Position;
// Calculate mouse movement deltas
Point difference = new Point(currentPoint.X - _prevPointer.X, currentPoint.Y - _prevPointer.Y);
_prevPointer = currentPoint;
foreach (PaintBase paintBase in _selected)
{
// Use visitor pattern to apply scale to the elements
paintBase.Accept(new ScaleVisitor(difference.X, difference.Y));
}
_page.Draw();
}
return(Task.CompletedTask);
}
