private void IconBorder_MouseLeftButtonUp(object obj, PointerReleasedEventArgs e)
{
if (this.HasText)
{
this.Text = string.Empty;
}
}
protected override void OnPointerReleased(PointerReleasedEventArgs e)
{
if (_presenter != null && e.Device.Captured == _presenter)
{
e.Device.Capture(null);
}
}
/// <summary>
/// Handles the mouse left button up event on the selector control.
/// </summary>
/// <param name="sender">The source object.</param>
/// <param name="e">The event data.</param>
private void OnSelectorPointerReleased(object?sender, PointerReleasedEventArgs e)
{
if (e.InitialPressMouseButton == MouseButton.Left)
{
OnCommit();
}
}
private void Month_MouseLeave(object sender, PointerEventArgs e)
{
if (_isMouseLeftButtonDownYearView)
{
CalendarButton b = (CalendarButton)sender;
// The button is in Pressed state. Change the state to normal.
if (e.Device.Captured == b)
{
e.Device.Capture(null);
}
//b.ReleaseMouseCapture();
if (_downEventArgYearView != null)
{
var args =
new PointerReleasedEventArgs()
{
Device = _downEventArgYearView.Device,
MouseButton = _downEventArgYearView.MouseButton,
Handled = _downEventArgYearView.Handled,
InputModifiers = _downEventArgYearView.InputModifiers,
Route = _downEventArgYearView.Route,
Source = _downEventArgYearView.Source
};
b.SendMouseLeftButtonUp(args);
}
_lastCalendarButton = b;
}
}
private void PointerReleasedHandler(object sender, PointerReleasedEventArgs e)
{
_modSourceItem = null;
_modpackSourceItem = null;
_dragStart = null;
_dragging = false;
}
private static void ControlPointerReleased(object sender, PointerReleasedEventArgs e)
{
var control = (Control)sender;
var contextMenu = control.ContextMenu;
if (control.ContextMenu.IsOpen)
{
if (contextMenu.CancelClosing())
{
return;
}
control.ContextMenu.Close();
e.Handled = true;
}
if (e.MouseButton == MouseButton.Right)
{
if (contextMenu.CancelOpening())
{
return;
}
contextMenu.Open(control);
e.Handled = true;
}
}
protected override void OnPointerReleased(PointerReleasedEventArgs e)
{
previewPointVisible = true;
var textView = TextView;
var offset = _editor.GetOffsetFromPoint(e.GetPosition(this));
if (offset != -1)
{
var lineClicked = -1;
lineClicked = textView.Document.GetLineByOffset(offset).LineNumber; // convert from text line to visual line.
var currentBreakPoint =
_manager.OfType <Breakpoint>().FirstOrDefault(bp => bp.FileName == _editor.Editor.SourceFile.FilePath && bp.Line == lineClicked) as BreakEvent;
if (currentBreakPoint != null)
{
_manager.Remove(currentBreakPoint);
}
else
{
if (!string.IsNullOrEmpty(_editor.Editor.SourceFile.FilePath))
{
_manager.Add(_editor.Editor.SourceFile.FilePath, lineClicked);
}
}
}
InvalidateVisual();
}
/// <summary>
/// is the left button is pressed e.handled is set to true
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void CanvasColor_MouseLeftButtonUp(object sender, PointerReleasedEventArgs e)
{
if (e.GetCurrentPoint(_ellipsePointer).Properties.IsLeftButtonPressed == false)
{
e.Handled = true;
}
}
/// <summary>
/// just sets the is <see cref="_isMouseDownOverEllipse"/> flag
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void EllipsePointer_MouseLeftButtonUp(object sender, PointerReleasedEventArgs e)
{
if (e.GetCurrentPoint(_ellipsePointer).Properties.IsLeftButtonPressed == false)
{
_isMouseDownOverEllipse = false;
}
}
private void OnClick(object sender, PointerReleasedEventArgs e)
{
if (e.InitialPressMouseButton == MouseButton.Left)
{
ViewModelClickHandler.OnLeftClick();
}
}
void MouseUp(object sender, PointerReleasedEventArgs e)
{
PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;
if (MouseButton == PointerUpdateKind.LeftButtonReleased)
{
MouseMove(sender, e);
if (old != null)
{
Program.Project.Undo.Add(new MacroFilter.FilterUndoEntry(
_filter,
old.ToArray()
));
old = null;
}
mouseHeld = false;
mouseOver = null;
e.Pointer.Capture(null);
MacrosGrid.Cursor = new Cursor(StandardCursorType.Arrow);
}
}
void MouseUp(object sender, PointerReleasedEventArgs e)
{
PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;
if (MouseButton == PointerUpdateKind.LeftButtonReleased)
{
MouseMove(sender, e);
if (old != null)
{
bool[] u = old.ToArray();
bool[] r = _filter.Filter.ToArray();
List <int> path = Track.GetPath(_filter);
Program.Project.Undo.Add($"MacroFilter Changed", () => {
Track.TraversePath <MacroFilter>(path).Filter = u.ToArray();
}, () => {
Track.TraversePath <MacroFilter>(path).Filter = r.ToArray();
});
old = null;
}
mouseHeld = false;
mouseOver = null;
e.Pointer.Capture(null);
MacrosGrid.Cursor = new Cursor(StandardCursorType.Arrow);
}
}
protected override void OnPointerReleased(PointerReleasedEventArgs e)
{
if (e.Device.Captured == TextView)
{
e.Device.Capture(null);
}
}
protected override void OnPointerReleased(PointerReleasedEventArgs e)
{
if (/*e.Pointer.Captured.*/ this.IsDragging)
{
e.Handled = true;
// now we are in normal mode
this.ClearValue(IsDraggingProperty);
// release the captured mouse
e.Pointer.Capture(null);
//this.ReleaseMouseCapture();
// get the current mouse position and call the completed event with the horizontal/vertical change
PixelPoint currentMouseScreenPoint = this.PointToScreen(e.GetPosition(this));
var horizontalChange = currentMouseScreenPoint.X - this.startDragScreenPoint.X;
var verticalChange = currentMouseScreenPoint.Y - this.startDragScreenPoint.Y;
var args = new VectorEventArgs()
{
Handled = false,
RoutedEvent = DragCompletedEvent,
Vector = new Vector(horizontalChange, verticalChange)
};
this.RaiseEvent(args);
}
}
/// <inheritdoc />
protected override void OnPointerReleased(PointerReleasedEventArgs e)
{
base.OnPointerReleased(e);
Point mousePosition;
if (IncreaseButton != null && IncreaseButton.IsEnabled == false)
{
mousePosition = e.GetPosition(IncreaseButton);
if (mousePosition.X > 0 && mousePosition.X < IncreaseButton.Width &&
mousePosition.Y > 0 && mousePosition.Y < IncreaseButton.Height)
{
e.Handled = true;
}
}
if (DecreaseButton != null && DecreaseButton.IsEnabled == false)
{
mousePosition = e.GetPosition(DecreaseButton);
if (mousePosition.X > 0 && mousePosition.X < DecreaseButton.Width &&
mousePosition.Y > 0 && mousePosition.Y < DecreaseButton.Height)
{
e.Handled = true;
}
}
}
/// <summary>
/// Invoked when a mouse button is released on the NavigatorCanvas. Stops panning.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void NavigatorPointerReleased(object sender, PointerReleasedEventArgs e)
{
if (e.InitialPressMouseButton == MouseButton.Left)
{
IsMouseDown = false;
}
}
private async void OnCarPointerReleased(object sender, PointerReleasedEventArgs e)
{
var actualWidth = car.DesiredSize.Width;
if (!double.IsNaN(actualWidth))
{
var pos = e.GetCurrentPoint(sender as IVisual);
var left = actualWidth / 2;
try
{
if (pos.Position.X >= left)
{
await vm.NextPageAsync();
}
else
{
await vm.PrevPageAsync();
}
}
catch (Exception ex)
{
vm.ExceptionService.Exception = ex;
}
}
}
void TextAreaMouseUp(object sender, PointerReleasedEventArgs e)
{
if (mouseDownPos == null)
{
return;
}
Vector dragDistance = e.GetPosition(this) - mouseDownPos.Value;
if (Math.Abs(dragDistance.X) < SystemParameters.MinimumHorizontalDragDistance &&
Math.Abs(dragDistance.Y) < SystemParameters.MinimumVerticalDragDistance &&
e.MouseButton == MouseButton.Left)
{
// click without moving mouse
var referenceSegment = GetReferenceSegmentAtMousePosition(e.Device);
if (referenceSegment == null)
{
ClearLocalReferenceMarks();
}
else
{
JumpToReference(referenceSegment);
textEditor.TextArea.ClearSelection();
}
// TODO: cancel mouse selection to avoid AvaloniaEdit selecting between the new
// cursor position and the mouse position.
//textEditor.TextArea.MouseSelectionMode = MouseSelectionMode.None;
}
}
async void MouseUp(object sender, PointerReleasedEventArgs e)
{
PointerUpdateKind MouseButton = e.GetCurrentPoint(this).Properties.PointerUpdateKind;
if (mouseHeld)
{
if (MouseButton == PointerUpdateKind.LeftButtonReleased)
{
bool remove = false;
if (File.Exists(_path))
{
Opened?.Invoke(_path);
}
else
{
remove = await ShouldRemove();
}
if (remove)
{
Removed?.Invoke(this, _path);
}
}
else if (MouseButton == PointerUpdateKind.RightButtonReleased)
{
((ApolloContextMenu)this.Resources["InfoContextMenu"]).Open((Control)sender);
}
mouseHeld = false;
}
}
/// <summary>
/// Invoked when an unhandled MouseUp routed event reaches an element in its route that is derived from this class. Implement this method to add class handling for this event.
/// </summary>
/// <param name="e">The <see cref="T:System.Windows.Input.MouseButtonEventArgs" /> that contains the event data. The event data reports that the mouse button was released.</param>
protected override void OnPointerReleased(PointerReleasedEventArgs e)
{
base.OnPointerReleased(e);
if (e.Handled)
{
return;
}
var releasedArgs = (PointerReleasedEventArgs)e;
((TopLevel)this.VisualRoot).PlatformImpl.MouseDevice.Capture(null);
e.Handled = ActualController.HandleMouseUp(this, releasedArgs.ToMouseReleasedEventArgs(this));
// Open the context menu
var p = e.GetPosition(this).ToScreenPoint();
var d = p.DistanceTo(mouseDownPoint);
if (ContextMenu != null)
{
if (Math.Abs(d) < 1e-8 && releasedArgs.InitialPressMouseButton == MouseButton.Right)
{
ContextMenu.DataContext = DataContext;
ContextMenu.IsVisible = true;
}
else
{
ContextMenu.IsVisible = false;
}
}
}
private void HandlePointerReleased(PointerReleasedEventArgs e)
{
if (e.MouseButton == MouseButton.Left)
{
if (InputTarget != null)
{
var point = AdjustGetPosition(e.GetPosition(RelativeTo));
var args = new InputArgs(point.X, point.Y, GetModifier(e.InputModifiers));
if (InputTarget.IsLeftUpAvailable())
{
InputTarget.LeftUp(args);
}
}
}
else if (e.MouseButton == MouseButton.Right)
{
if (InputTarget != null)
{
var point = AdjustGetPosition(e.GetPosition(RelativeTo));
var args = new InputArgs(point.X, point.Y, GetModifier(e.InputModifiers));
if (InputTarget.IsRightUpAvailable())
{
InputTarget.RightUp(args);
}
}
}
}
private void DropDownButtonMouseRightButtonUp(object sender, PointerReleasedEventArgs e)
{
if (e.InitialPressMouseButton == MouseButton.Right)
{
e.Handled = true;
}
}
internal void Cell_MouseLeave(object sender, PointerEventArgs e)
{
if (_isMouseLeftButtonDown)
{
CalendarDayButton b = (CalendarDayButton)sender;
// The button is in Pressed state. Change the state to normal.
if (e.Device.Captured == b)
{
e.Device.Capture(null);
}
// null check is added for unit tests
if (_downEventArg != null)
{
var arg =
new PointerReleasedEventArgs()
{
Device = _downEventArg.Device,
MouseButton = _downEventArg.MouseButton,
Handled = _downEventArg.Handled,
InputModifiers = _downEventArg.InputModifiers,
Route = _downEventArg.Route,
Source = _downEventArg.Source
};
b.SendMouseLeftButtonUp(arg);
}
_lastCalendarDayButton = b;
}
}
void treeView_ContextMenuOpening(object sender, PointerReleasedEventArgs e)
{
var control = (Control)sender;
var contextMenu = control?.ContextMenu;
if (contextMenu == null || e.MouseButton != MouseButton.Right)
{
return;
}
TextViewContext context = TextViewContext.Create(e.Device, treeView);
if (context.SelectedTreeNodes.Length == 0)
{
e.Handled = true; // don't show the menu
return;
}
ContextMenu menu;
if (ShowContextMenu(context, out menu))
{
treeView.ContextMenu = menu;
}
else
{
// hide the context menu.
e.Handled = true;
}
}
private void ColorCanvas_PointerReleased(object sender, PointerReleasedEventArgs e)
{
if (_captured == true)
{
_captured = false;
}
}
private void Canvas_PointerReleased(object sender, PointerReleasedEventArgs e)
{
switch (e.MouseButton)
{
case MouseButton.Left:
{
var point = e.GetPosition(canvas);
try
{
_vm.Editor.LeftUp(point.X, point.Y);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
Debug.WriteLine(ex.StackTrace);
}
}
break;
case MouseButton.Right:
break;
case MouseButton.Middle:
break;
}
}
void AlphaCanvas_PointerReleased(object?sender, PointerReleasedEventArgs e)
{
if (captured)
{
captured = false;
}
}
private void HandlePointerReleased(PointerReleasedEventArgs e)
{
if (e.MouseButton == MouseButton.Left)
{
if (this.DataContext is LayerContainerViewModel vm)
{
var point = AdjustGetPosition(e.GetPosition(RelativeTo));
if (vm.Mode == EditMode.Mouse)
{
vm.CurrentTool.LeftUp(vm, point.X, point.Y, GetModifier(e.InputModifiers));
}
else if (vm.Mode == EditMode.Touch)
{
vm.CurrentTool.LeftDown(vm, point.X, point.Y, GetModifier(e.InputModifiers));
}
}
}
else if (e.MouseButton == MouseButton.Right)
{
if (this.DataContext is LayerContainerViewModel vm)
{
var point = AdjustGetPosition(e.GetPosition(RelativeTo));
vm.CurrentTool.RightUp(vm, point.X, point.Y, GetModifier(e.InputModifiers));
}
}
}
private void Calendar_PointerReleased(object sender, PointerReleasedEventArgs e)
{
if (e.InitialPressMouseButton == MouseButton.Left)
{
e.Handled = true;
}
}
private void TextArea_MouseLeftButtonUp(object sender, PointerReleasedEventArgs e)
{
if (_mode == SelectionMode.None || e.Handled || e.InitialPressMouseButton == MouseButton.Right)
{
return;
}
e.Handled = true;
switch (_mode)
{
case SelectionMode.PossibleDragStart:
// this was not a drag start (mouse didn't move after mousedown)
SetCaretOffsetToMousePosition(e);
TextArea.ClearSelection();
break;
case SelectionMode.Normal:
case SelectionMode.WholeWord:
case SelectionMode.WholeLine:
case SelectionMode.Rectangular:
ExtendSelectionToMouse(e);
break;
}
_mode = SelectionMode.None;
TextArea.ReleasePointerCapture(e.Pointer);
}
private static void ControlPointerReleased(object sender, PointerReleasedEventArgs e)
{
var control = (Control)sender;
var contextMenu = control.ContextMenu;
if (e.MouseButton == MouseButton.Right)
{
if (control.ContextMenu._isOpen)
{
control.ContextMenu.Hide();
}
Show(control);
e.Handled = true;
}
else if (contextMenu._isOpen)
{
control.ContextMenu.Hide();
e.Handled = true;
}
}
