public override bool OnMouseMoved(MouseMovedEventArgs args, PlotCanvas pc)
{
double X = args.X;
double Y = args.Y;
if (selectionActive)
{
// note last selection rectangle
Rectangle lastSelection = selection;
Rectangle bounds = pc.PlotAreaBoundingBoxCache;
// clip selection rectangle to PlotArea
X = Math.Max(X, bounds.Left);
X = Math.Min(X, bounds.Right);
Y = Math.Max(Y, bounds.Top);
Y = Math.Min(Y, bounds.Bottom);
endPoint.X = X;
endPoint.Y = Y;
selection = FromPoints(startPoint, endPoint);
pc.Canvas.QueueDraw(lastSelection);
//Console.WriteLine ("Erase: {0} {1} {2} {3} ", lastSelection.X, lastSelection.Y, lastSelection.Width, lastSelection.Height);
pc.Canvas.QueueDraw(selection);
}
return(false);
}
async void Editor_MouseMoved(object sender, MouseMovedEventArgs e)
{
if (e != null)
{
x = e.X;
y = e.Y;
}
if (LinksShown)
{
var lineNumber = Editor.PointToLocation(x, y).Line;
var line = Editor.GetLine(lineNumber);
if (visibleLines.Any(l => l.Equals(line)))
{
return;
}
visibleLines.Add(line);
var segments = await RequestLinksAsync(line.Offset, line.Length, default(CancellationToken));
await Runtime.RunInMainThread(delegate {
foreach (var segment in segments)
{
var marker = Editor.TextMarkerFactory.CreateLinkMarker(Editor, segment.Offset, segment.Length, delegate { segment.Activate(); });
marker.OnlyShowLinkOnHover = true;
Editor.AddMarker(marker);
markers.Add(marker);
}
});
}
}
public MouseMovedEventArguments(MouseMovedEventArgs args) : base(args)
{
X = args.X;
Y = args.Y;
DX = args.DX;
DY = args.DY;
}
public override bool OnMouseMoved(MouseMovedEventArgs args, PlotCanvas pc)
{
Rectangle area = pc.PlotAreaBoundingBoxCache;
if (scaling)
{
pc.CacheAxes();
double dX = args.X - lastPoint.X; // distance mouse has moved
double dY = args.Y - lastPoint.Y;
lastPoint = new Point(args.X, args.Y);
// Alt key reduces sensitivity
double factor = Sensitivity;
if (key == Key.AltLeft || key == Key.AltRight)
{
factor *= 0.25; // arbitrary change
}
double xProportion = +dX * factor / area.Width;
double yProportion = -dY * factor / area.Height;
if (Horizontal)
{
pc.ZoomXAxes(xProportion, focusX);
}
if (Vertical)
{
pc.ZoomYAxes(yProportion, focusY);
}
return(true);
}
return(false);
}
public override bool OnMouseMoved(MouseMovedEventArgs args, PlotCanvas pc)
{
Rectangle area = pc.PlotAreaBoundingBoxCache;
if (dragging)
{
pc.CacheAxes();
double dX = args.X - lastPoint.X; // distance mouse has moved
double dY = args.Y - lastPoint.Y;
lastPoint = new Point(args.X, args.Y);
// Axis translation required
double xShift = -dX / area.Width;
double yShift = +dY / area.Height;
if (Horizontal)
{
pc.TranslateXAxes(xShift);
}
if (Vertical)
{
pc.TranslateYAxes(yShift);
}
return(true);
}
return(false);
}
protected override void OnMouseMoved(MouseMovedEventArgs args)
{
args.Handled = true;
var scrpt = ConvertToScreenCoordinates(args.Position);
if (captured == DragModes.Move)
{
if (!DockPanel.DragRectangle.Contains(scrpt.X - this.orgpt.X, scrpt.Y - this.orgpt.Y))
{
ClrCapture();
DockItDragDrop.StartDrag(this.owner, scrpt);
}
base.Cursor = GetCursor(captured, scrpt);
return;
}
else if (captured != DragModes.None)
{
Rectangle r = GetDragPos(args.Position);
if (r.Width >= 0 && r.Height >= 0)
{
SetNewPos(r);
}
base.Cursor = GetCursor(captured, scrpt);
return;
}
else
{
base.OnMouseMoved(args);
}
base.Cursor = GetCursor(HitTest(args.Position), args.Position);
}
protected override void OnMouseMoved(MouseMovedEventArgs args)
{
base.OnMouseMoved(args);
var hitItem = HitTest(args.Position);
if (cacheHitItem != hitItem)
{
if (cacheHitItem != null)
{
cacheHitItem.OnMouseExited(EventArgs.Empty);
}
if (hitItem != null)
{
hitItem.OnMouseEntered(EventArgs.Empty);
if (!hitItem.DisplayStyle.HasFlag(ToolItemDisplayStyle.Text))
{
TooltipText = hitItem.Text;
//Debug.WriteLine($"Tooltip Text {TooltipText}");
}
else
{
TooltipText = null;
}
}
cacheHitItem = hitItem;
}
else if (cacheHitItem != null)
{
cacheHitItem.OnMouseMove(args);
}
}
async void Editor_MouseMoved(object sender, MouseMovedEventArgs e)
{
if (e != null)
{
x = e.X;
y = e.Y;
}
CancelRequestLinks();
if (!IsHoverNavigationValid(Editor))
{
return;
}
var token = src.Token;
if (LinksShown)
{
var lineNumber = Editor.PointToLocation(x, y).Line;
if (lineNumber < 1 || lineNumber > Editor.LineCount)
{
return;
}
var line = Editor.GetLine(lineNumber);
if (line == null || visibleLines.Any(line.Equals))
{
return;
}
visibleLines.Add(line);
IEnumerable <NavigationSegment> segments;
try {
segments = await RequestLinksAsync(line.Offset, line.Length, token).ConfigureAwait(false);
} catch (OperationCanceledException) {
return;
} catch (Exception ex) {
LoggingService.LogError("Error while requestling navigation links", ex);
return;
}
if (segments == null || token.IsCancellationRequested)
{
return;
}
await Runtime.RunInMainThread(delegate {
try {
foreach (var segment in segments)
{
if (token.IsCancellationRequested)
{
return;
}
var marker = Editor.TextMarkerFactory.CreateLinkMarker(Editor, segment.Offset, segment.Length, delegate { segment.Activate(); });
marker.OnlyShowLinkOnHover = true;
Editor.AddMarker(marker);
markers.Add(marker);
}
} catch (Exception ex) {
LoggingService.LogError("Error while creating navigation line markers", ex);
}
});
}
}
public static bool HandleMouseMoved(this IViewObject view, NSEvent theEvent)
{
if (view == null)
{
throw new ArgumentNullException(nameof(view));
}
if (theEvent == null)
{
throw new ArgumentNullException(nameof(theEvent));
}
if (view.View == null)
{
throw new InvalidOperationException();
}
CGPoint p = view.View.ConvertPointFromEvent(theEvent);
if (!view.View.Bounds.Contains(p))
{
return(false);
}
MouseMovedEventArgs args = new MouseMovedEventArgs((long)TimeSpan.FromSeconds(theEvent.Timestamp).TotalMilliseconds, p.X, p.Y);
view.Backend.ApplicationContext.InvokeUserCode(delegate {
view.Backend.EventSink.OnMouseMoved(args);
});
return(args.Handled);
}
void OnMouseMoved(MouseMovedEventArgs e)
{
if (!defaultScene)
{
return;
}
const float mouseSpeed = 0.5f;
if (Input.GetMouseButtonDown(MouseButton.Left))
{
RotateRootNode(false);
if (HandMode)
{
rootNode.Translate(new Vector3(e.DX, -e.DY, 0) * 0.01f, TransformSpace.World);
}
else if (Input.GetKeyDown((Key)'v'))
{
rootNode.Rotate(new Quaternion(-e.DY * mouseSpeed, 0, 0), TransformSpace.World);
}
else
{
rootNode.Rotate(new Quaternion(0, -e.DX * mouseSpeed, 0), TransformSpace.Local);
}
}
else
{
//RotateRootNode(true);
}
}
/// <summary>
/// Creates the mouse event arguments.
/// </summary>
/// <param name="args">The motion event args.</param>
/// <returns>Mouse event arguments.</returns>
public static OxyMouseEventArgs ToOxyMouseEventArgs(this MouseMovedEventArgs args)
{
return(new OxyMouseEventArgs {
Position = new ScreenPoint(args.X, args.Y),
ModifierKeys = OxyModifierKeys.None
});
}
private void HandleMouseMoved(MouseMovedEventArgs args)
{
if (_mouseTouch != null)
{
_mouseTouch = new TouchState {
ID = MouseTouchID, ScreenPosition = Input.MousePosition, Pressure = 0.0f
};
MoveTouch(_mouseTouch);
}
if (_rigthClick != null)
{
var position = Input.MousePosition;
var diff = (position - _rigthClick.ScreenPosition).LengthSquared;
if (diff > 2)
{
_potentialRightClick = false;
}
if (!_potentialRightClick)
{
var contact = _environment.Raycast(_environment.SceenSize / 2);
Rotate?.Invoke(this, new RotateInteractionEventArgs(contact, position.X - _rigthClick.ScreenPosition.X));
_rigthClick.ScreenPosition = Input.MousePosition;
}
}
}
protected override void OnMouseMoved(MouseMovedEventArgs e)
{
if (draggingCursor)
{
double x, y;
GetValue((int)e.X, (int)e.Y, out x, out y);
if (activeCursor.Dimension == AxisDimension.X)
{
if (x < startX)
{
x = startX;
}
else if (x > endX)
{
x = endX;
}
activeCursor.Value = x;
}
else
{
if (y < startY)
{
y = startY;
}
else if (y > endY)
{
y = endY;
}
activeCursor.Value = y;
}
return;
}
base.OnMouseMoved(e);
}
/// <summary>
/// Called on mouse move events.
/// </summary>
/// <param name="args">An instance that contains the event data.</param>
protected override void OnMouseMoved(MouseMovedEventArgs args)
{
base.OnMouseMoved(args);
if (args.Handled)
{
return;
}
if (ShowDynamicTooltips)
{
string tooltip = null;
var hitArgs = new HitTestArguments(new ScreenPoint(args.X, args.Y), MouseHitTolerance);
foreach (var result in ActualModel.HitTest(hitArgs))
{
var plotElement = result.Element as PlotElement;
if (plotElement != null && !String.IsNullOrEmpty(plotElement.ToolTip))
{
tooltip = String.IsNullOrEmpty(tooltip) ? plotElement.ToolTip : tooltip + Environment.NewLine + plotElement.ToolTip;
}
}
TooltipText = tooltip;
}
args.Handled = ActualController.HandleMouseMove(this,
args.ToOxyMouseEventArgs());
}
public override bool OnMouseMoved(MouseMovedEventArgs args, PlotCanvas pc)
{
Rectangle area = pc.PlotAreaBoundingBoxCache;
if (dragging && physicalAxis != null)
{
pc.CacheAxes();
double dX = args.X - lastPoint.X;
double dY = args.Y - lastPoint.Y;
lastPoint = new Point(args.X, args.Y);
double length = physicalAxis.PhysicalLength;
if (translateX)
{
double xShift = -dX / length;
pc.TranslateXAxes(xShift);
}
if (translateY)
{
double yShift = +dY / length;
pc.TranslateYAxes(yShift);
}
return(true);
}
return(false);
}
protected override void OnMouseMoved(MouseMovedEventArgs args)
{
base.OnMouseMoved(args);
if (State.HasFlag(DockBoxState.InProcess))
{
if (State.HasFlag(DockBoxState.SizeLR))
{
stateSize.Location = new Point(args.Position.X, stateSize.Y);
}
else if (State.HasFlag(DockBoxState.SizeUD))
{
stateSize.Location = new Point(stateSize.X, args.Position.Y);
}
else if (State.HasFlag(DockBoxState.Move))
{
var htest = DockHitTest(args.X, args.Y, 50);
if (htest.Item != null)
{
stateMove = Rectangle.Zero;
if (htest.Align == LayoutAlignType.None)
{
stateMove = htest.Item.Bound.Inflate(-40, -40);
}
else
{
stateMove = new Rectangle(htest.AlignBound.X + 10, htest.AlignBound.Y + 10, htest.AlignBound.Width - 20, htest.AlignBound.Height - 20);
}
}
}
QueueDraw();
}
else
{
var test = DockHitTest(args.X, args.Y, 1);
if (test.Item == null)
{
hitLeft = DockHitTest(args.X - 10, args.Y);
hitRight = DockHitTest(args.X + 10, args.Y);
hitTop = DockHitTest(args.X, args.Y - 10);
hitBottom = DockHitTest(args.X, args.Y + 10);
if (hitLeft.Item != null && hitRight.Item != null && hitLeft.Item != hitRight.Item)
{
State = DockBoxState.SizeLR;
}
else if (hitTop.Item != null && hitBottom.Item != null && hitTop.Item != hitBottom.Item)
{
State = DockBoxState.SizeUD;
}
else
{
State = DockBoxState.Default;
}
}
else
{
State = DockBoxState.Default;
}
}
}
protected override void OnMouseMoved(MouseMovedEventArgs args)
{
var node = GetValue(BuildOutputNodeField);
var status = GetViewStatus(node);
if (status.TaskLinkRenderRectangle.Contains(args.Position) || status.ErrorsRectangle.Contains(args.Position) || status.WarningsRectangle.Contains(args.Position))
{
ParentWidget.Cursor = CursorType.Hand;
}
else
{
ParentWidget.Cursor = CursorType.Arrow;
}
status.CalculateLayout(status.LastRenderBounds, out var layout, out var layoutBounds, out var expanderRect);
var insideText = layoutBounds.Contains(args.Position);
if (clicking && insideText && selectionRow == node)
{
var pos = layout.GetIndexFromCoordinates(args.Position.X - layoutBounds.X, args.Position.Y - layoutBounds.Y);
if (pos != -1)
{
selectionEnd = pos;
QueueDraw();
}
}
else
{
if (insideText)
{
ParentWidget.Cursor = CursorType.IBeam;
}
}
}
protected override void OnMouseMoved(MouseMovedEventArgs args)
{
var node = GetValue(BuildOutputNodeField);
var status = GetViewStatus(node);
var containsClickableElement = status.TaskLinkRenderRectangle.Contains(args.Position) || status.ErrorsRectangle.Contains(args.Position) || status.WarningsRectangle.Contains(args.Position);
if (containsClickableElement)
{
ParentWidget.Cursor = CursorType.Hand;
}
else
{
ParentWidget.Cursor = CursorType.Arrow;
}
status.CalculateLayout(status.LastRenderBounds, out var layout, out var layoutBounds, out var expanderRect);
var insideText = layoutBounds.Contains(args.Position);
if ((TextSelection?.IsStarting(node) ?? false))
{
var pos = layout.GetIndexFromCoordinates(args.Position.X - layoutBounds.X, args.Position.Y - layoutBounds.Y);
if (pos != -1)
{
TextSelection.Set(pos, args.Position);
QueueDraw();
}
}
else if (insideText && !containsClickableElement)
{
ParentWidget.Cursor = CursorType.IBeam;
}
}
private void Closebutton_MouseMoved(object sender, MouseMovedEventArgs e)
{
var pt = new Point(e.X + this.CloseRectangle.Left, e.Y + this.CloseRectangle.Top);
var ee = new MouseMovedEventArgs(0, pt.X, pt.Y);
this.OnMouseMoved(ee);
e.Handled = ee.Handled;
}
void HandleMotionNotifyEvent(object o, Gtk.MotionNotifyEventArgs args)
{
var a = new MouseMovedEventArgs((long)args.Event.Time, args.Event.X, args.Event.Y);
Toolkit.Invoke(delegate {
EventSink.OnMouseMoved(a);
});
}
void HandleWidgetMotionNotifyEvent(object o, Gtk.MotionNotifyEventArgs args)
{
var a = new MouseMovedEventArgs();
a.X = args.Event.X;
a.Y = args.Event.Y;
EventSink.OnMouseMoved(a);
}
void HandleMouseMove(MouseMovedEventArgs args)
{
if (pickedNode != null)
{
ConstraintMouse2D constraintMouse = pickedNode.GetComponent <ConstraintMouse2D>();
constraintMouse.Target = GetMousePositionXY();
}
}
public override void MouseDragged (NSEvent theEvent)
{
var p = ConvertPointFromView (theEvent.LocationInWindow, null);
MouseMovedEventArgs args = new MouseMovedEventArgs ((long) TimeSpan.FromSeconds (theEvent.Timestamp).TotalMilliseconds, p.X, p.Y);
context.InvokeUserCode (delegate {
eventSink.OnMouseMoved (args);
});
}
public override void MouseDragged(NSEvent theEvent)
{
var p = ConvertPointFromView(theEvent.LocationInWindow, null);
MouseMovedEventArgs args = new MouseMovedEventArgs();
args.X = p.X;
args.Y = p.Y;
eventSink.OnMouseMoved(args);
}
protected override void OnMouseMoved(MouseMovedEventArgs args)
{
var data = GetValue(ValueField);
data.Value = (int)(100 * ((args.X - Bounds.X) / Bounds.Width));
data.YPos = args.Y - Bounds.Y;
QueueDraw();
base.OnMouseMoved(args);
}
protected override void OnMouseMoved(MouseMovedEventArgs args)
{
args.Handled = true;
if (!this.owner.checkmouse)
{
var pt = this.ConvertToScreenCoordinates(args.Position);
owner.CheckMove(pt, true);
}
}
void HandleWidgetMotionNotifyEvent(object o, Gtk.MotionNotifyEventArgs args)
{
var a = new MouseMovedEventArgs();
a.X = args.Event.X;
a.Y = args.Event.Y;
Toolkit.Invoke(delegate {
EventSink.OnMouseMoved(a);
});
}
protected override void OnMouseMoved(MouseMovedEventArgs args)
{
if (Bounds.Contains(args.Position))
{
var data = GetValue(ValueField);
data.Value = Math.Min(100, (int)(100 * ((args.X - Bounds.X) / Bounds.Width)));
data.YPos = args.Y - Bounds.Y;
QueueDraw();
}
base.OnMouseMoved(args);
}
protected override void OnMouseMoved(MouseMovedEventArgs e)
{
base.OnMouseMoved(e);
Margin margin = GetMarginAtX((int)e.X);
if (margin != null)
{
margin.MouseHover(new MarginMouseMovedEventArgs(this, margin, e));
}
}
public override void MouseMoved(NSEvent theEvent)
{
var p = ConvertPointFromView(theEvent.LocationInWindow, null);
MouseMovedEventArgs args = new MouseMovedEventArgs();
args.X = p.X;
args.Y = p.Y;
Toolkit.Invoke(delegate {
eventSink.OnMouseMoved(args);
});
}
public static void RaiseMouseMoved (this CellView cellView, MouseMovedEventArgs args)
{
cellView.OnMouseMoved (args);
}
void HandleWidgetMotionNotifyEvent(object o, Gtk.MotionNotifyEventArgs args)
{
var a = new MouseMovedEventArgs ();
a.X = args.Event.X;
a.Y = args.Event.Y;
Toolkit.Invoke (delegate {
EventSink.OnMouseMoved (a);
});
}
public override void MouseDragged (NSEvent theEvent)
{
var p = ConvertPointFromView (theEvent.LocationInWindow, null);
MouseMovedEventArgs args = new MouseMovedEventArgs ((long) TimeSpan.FromSeconds (theEvent.Timestamp).TotalMilliseconds, p.X, p.Y);
context.InvokeUserCode (delegate {
eventSink.OnMouseMoved (args);
});
}
private void WidgetMouseMoveHandler(object sender, MouseEventArgs e)
{
var p = e.GetPosition (Widget);
var a = new MouseMovedEventArgs(e.Timestamp, p.X, p.Y);
Context.InvokeUserCode (() => {
eventSink.OnMouseMoved(a);
});
if (a.Handled)
e.Handled = true;
}
void HandleWidgetMotionNotifyEvent(object o, Gtk.MotionNotifyEventArgs args)
{
var a = new MouseMovedEventArgs ();
a.X = args.Event.X;
a.Y = args.Event.Y;
EventSink.OnMouseMoved (a);
}
void HandleMouseMove(MouseMovedEventArgs args)
{
if (pickedNode != null)
{
ConstraintMouse2D constraintMouse = pickedNode.GetComponent<ConstraintMouse2D>();
constraintMouse.Target=GetMousePositionXY();
}
}
