public void HandleMouseMove(MouseMoveEvent e)
{
OnMouseMove(e);
}
protected override bool OnMouseMove(MouseMoveEvent e)
{
catcher.UpdatePosition(e.MousePosition.X / DrawSize.X);
return(base.OnMouseMove(e));
}
void UpdateEventbaseInfo(EventDebuggerEventRecord eventBase, IEventHandler focused, IEventHandler capture)
{
ClearEventbaseInfo();
if (eventBase == null)
{
return;
}
m_EventbaseInfo.text += "Focused element: " + EventDebugger.GetObjectDisplayName(focused) + "\n";
m_EventbaseInfo.text += "Capture element: " + EventDebugger.GetObjectDisplayName(capture) + "\n";
if (eventBase.eventTypeId == MouseMoveEvent.TypeId() ||
eventBase.eventTypeId == MouseOverEvent.TypeId() ||
eventBase.eventTypeId == MouseDownEvent.TypeId() ||
eventBase.eventTypeId == MouseUpEvent.TypeId() ||
eventBase.eventTypeId == DragUpdatedEvent.TypeId() ||
eventBase.eventTypeId == DragPerformEvent.TypeId() ||
eventBase.eventTypeId == DragExitedEvent.TypeId() ||
eventBase.eventTypeId == ContextClickEvent.TypeId())
{
m_EventbaseInfo.text += "Mouse position: " + eventBase.mousePosition + "\n";
}
if (eventBase.eventTypeId == MouseDownEvent.TypeId() ||
eventBase.eventTypeId == MouseUpEvent.TypeId() ||
eventBase.eventTypeId == DragUpdatedEvent.TypeId() ||
eventBase.eventTypeId == DragPerformEvent.TypeId() ||
eventBase.eventTypeId == DragExitedEvent.TypeId() ||
eventBase.eventTypeId == KeyDownEvent.TypeId() ||
eventBase.eventTypeId == KeyUpEvent.TypeId())
{
m_EventbaseInfo.text += "Modifiers: " + eventBase.modifiers + "\n";
}
if (eventBase.eventTypeId == MouseDownEvent.TypeId() ||
eventBase.eventTypeId == MouseUpEvent.TypeId() ||
eventBase.eventTypeId == DragUpdatedEvent.TypeId() ||
eventBase.eventTypeId == DragPerformEvent.TypeId() ||
eventBase.eventTypeId == DragExitedEvent.TypeId())
{
m_EventbaseInfo.text += "Button: " + (eventBase.button == 0 ? "Left" : eventBase.button == 1 ? "Middle" : "Right") + "\n";
m_EventbaseInfo.text += "Click count: " + eventBase.clickCount + "\n";
}
if (eventBase.eventTypeId == WheelEvent.TypeId())
{
m_EventbaseInfo.text += "Mouse delta: " + eventBase.delta + "\n";
}
if (eventBase.eventTypeId == KeyDownEvent.TypeId() ||
eventBase.eventTypeId == KeyUpEvent.TypeId())
{
if (char.IsControl(eventBase.character))
{
m_EventbaseInfo.text += "Character: \\" + (byte)(eventBase.character) + "\n";
}
else
{
m_EventbaseInfo.text += "Character: " + eventBase.character + "\n";
}
m_EventbaseInfo.text += "Key code: " + eventBase.keyCode + "\n";
}
if (eventBase.eventTypeId == ValidateCommandEvent.TypeId() ||
eventBase.eventTypeId == ExecuteCommandEvent.TypeId())
{
m_EventbaseInfo.text += "Command: " + eventBase.commandName + "\n";
}
}
protected override bool OnMouseMove(MouseMoveEvent e)
{
Child.MoveTo(e.MousePosition, 100, Easing.OutQuint);
return(base.OnMouseMove(e));
}
remove => RemoveHandler(MouseMoveEvent, value);
internal void CommitElementUnderPointers(EventDispatcher dispatcher)
{
for (var i = 0; i < m_TopElementUnderPointer.Length; i++)
{
var triggerPointerEvent = m_TriggerPointerEvent[i];
var previous = m_TopElementUnderPointer[i];
var current = m_PendingTopElementUnderPointer[i];
if (current == previous)
{
if (triggerPointerEvent != null)
{
var pos3d = triggerPointerEvent.position;
m_PickingPointerPositions[i] = new Vector2(pos3d.x, pos3d.y);
}
else if (m_TriggerMouseEvent[i] != null)
{
m_PickingPointerPositions[i] = m_TriggerMouseEvent[i].mousePosition;
}
continue;
}
m_TopElementUnderPointer[i] = current;
if (triggerPointerEvent == null && m_TriggerMouseEvent[i] == null)
{
using (new EventDispatcherGate(dispatcher))
{
Vector2 position = PointerDeviceState.GetPointerPosition(i);
PointerEventsHelper.SendOverOut(previous, current, null, position, i);
PointerEventsHelper.SendEnterLeave <PointerLeaveEvent, PointerEnterEvent>(
previous, current, null, position, i);
m_PickingPointerPositions[i] = position;
if (i == PointerId.mousePointerId)
{
MouseEventsHelper.SendMouseOverMouseOut(previous, current, null, position);
MouseEventsHelper.SendEnterLeave <MouseLeaveEvent, MouseEnterEvent>(
previous, current, null, position);
}
}
}
if (triggerPointerEvent != null)
{
var pos3d = triggerPointerEvent.position;
m_PickingPointerPositions[i] = new Vector2(pos3d.x, pos3d.y);
var baseEvent = triggerPointerEvent as EventBase;
if (baseEvent != null && (
baseEvent.eventTypeId == PointerMoveEvent.TypeId() ||
baseEvent.eventTypeId == PointerDownEvent.TypeId() ||
baseEvent.eventTypeId == PointerUpEvent.TypeId() ||
baseEvent.eventTypeId == PointerCancelEvent.TypeId()))
{
using (new EventDispatcherGate(dispatcher))
{
PointerEventsHelper.SendOverOut(previous, current, triggerPointerEvent, pos3d, i);
PointerEventsHelper.SendEnterLeave <PointerLeaveEvent, PointerEnterEvent>(
previous, current, triggerPointerEvent, pos3d, i);
}
}
}
m_TriggerPointerEvent[i] = null;
var triggerMouseEvent = m_TriggerMouseEvent[i];
if (triggerMouseEvent != null)
{
Vector2 mousePos = triggerMouseEvent.mousePosition;
m_PickingPointerPositions[i] = mousePos;
var baseEvent = triggerMouseEvent as EventBase;
if (baseEvent != null)
{
if (baseEvent.eventTypeId == MouseMoveEvent.TypeId() ||
baseEvent.eventTypeId == MouseDownEvent.TypeId() ||
baseEvent.eventTypeId == MouseUpEvent.TypeId() ||
baseEvent.eventTypeId == WheelEvent.TypeId())
{
using (new EventDispatcherGate(dispatcher))
{
MouseEventsHelper.SendMouseOverMouseOut(previous, current, triggerMouseEvent, mousePos);
MouseEventsHelper.SendEnterLeave <MouseLeaveEvent, MouseEnterEvent>(
previous, current, triggerMouseEvent, mousePos);
}
}
else if (baseEvent.eventTypeId == MouseEnterWindowEvent.TypeId() ||
baseEvent.eventTypeId == MouseLeaveWindowEvent.TypeId()
)
{
using (new EventDispatcherGate(dispatcher))
{
PointerEventsHelper.SendOverOut(previous, current, null, mousePos, i);
PointerEventsHelper.SendEnterLeave <PointerLeaveEvent, PointerEnterEvent>(
previous, current, null, mousePos, i);
if (i == PointerId.mousePointerId)
{
MouseEventsHelper.SendMouseOverMouseOut(previous, current, triggerMouseEvent, mousePos);
MouseEventsHelper.SendEnterLeave <MouseLeaveEvent, MouseEnterEvent>(
previous, current, triggerMouseEvent, mousePos);
}
}
}
else if (baseEvent.eventTypeId == DragUpdatedEvent.TypeId() ||
baseEvent.eventTypeId == DragExitedEvent.TypeId())
{
using (new EventDispatcherGate(dispatcher))
{
PointerEventsHelper.SendOverOut(previous, current, null, mousePos, i);
PointerEventsHelper.SendEnterLeave <PointerLeaveEvent, PointerEnterEvent>(
previous, current, null, mousePos, i);
MouseEventsHelper.SendMouseOverMouseOut(previous, current, triggerMouseEvent, mousePos);
MouseEventsHelper.SendEnterLeave <MouseLeaveEvent, MouseEnterEvent>(
previous, current, triggerMouseEvent, mousePos);
MouseEventsHelper.SendEnterLeave <DragLeaveEvent, DragEnterEvent>(
previous, current, triggerMouseEvent, mousePos);
}
}
}
m_TriggerMouseEvent[i] = null;
}
}
}
protected void OnMouseMove(MouseMoveEvent evt)
{
/// If the left mouse button is not down then return
if (m_Edge == null)
{
return;
}
evt.StopPropagation();
bool alreadyDetached = (m_DetachedPort != null);
// If one end of the edge is not already detached then
if (!alreadyDetached)
{
float delta = (evt.mousePosition - m_PressPos).sqrMagnitude;
if (delta < (s_StartDragDistance * s_StartDragDistance))
{
return;
}
/// Determine which end is the nearest to the mouse position then detach it.
Vector2 outputPos = new Vector2(m_Edge.output.GetGlobalCenter().x, m_Edge.output.GetGlobalCenter().y);
Vector2 inputPos = new Vector2(m_Edge.input.GetGlobalCenter().x, m_Edge.input.GetGlobalCenter().y);
float distanceFromOutput = (m_PressPos - outputPos).sqrMagnitude;
float distanceFromInput = (m_PressPos - inputPos).sqrMagnitude;
m_DetachedFromInputPort = distanceFromInput < distanceFromOutput;
if (m_DetachedFromInputPort)
{
m_ConnectedPort = m_Edge.output;
m_DetachedPort = m_Edge.input;
m_DetachedPort.Disconnect(m_Edge);
m_Edge.input = null;
}
else
{
m_ConnectedPort = m_Edge.input;
m_DetachedPort = m_Edge.output;
m_DetachedPort.Disconnect(m_Edge);
m_Edge.output = null;
}
// Use the edge drag helper of the still connected port
m_ConnectedEdgeDragHelper = m_ConnectedPort.edgeConnector.edgeDragHelper;
m_ConnectedEdgeDragHelper.draggedPort = m_ConnectedPort;
m_ConnectedEdgeDragHelper.edgeCandidate = m_Edge;
m_Edge.candidatePosition = evt.mousePosition;
// Redirect the last mouse down event to active the drag helper
if (m_ConnectedEdgeDragHelper.HandleMouseDown(m_LastMouseDownEvent))
{
m_Active = true;
}
else
{
Reset();
}
m_LastMouseDownEvent = null;
}
if (m_Active)
{
m_ConnectedEdgeDragHelper.HandleMouseMove(evt);
}
}
protected virtual void OnMouseMoveEvent(EditorEventArgs e)
{
MouseMoveEvent?.Invoke(this, e);
}
protected override bool OnMouseMove(MouseMoveEvent e) => true;
protected override bool OnMouseMove(MouseMoveEvent e)
{
Selected.Value = true;
return(base.OnMouseMove(e));
}
void HandleMouseMove(MouseMoveEvent args)
{
if (pickedNode != null)
{
ConstraintMouse2D constraintMouse = pickedNode.GetComponent<ConstraintMouse2D>();
constraintMouse.Target = GetMousePositionXY();
}
}
protected void OnMouseMove(MouseMoveEvent evt)
{
// If the left mouse button is not down then return
if (m_Edge == null)
{
return;
}
evt.StopPropagation();
bool alreadyDetached = (m_DetachedPort != null);
// If one end of the edge is not already detached then
if (!alreadyDetached)
{
float delta = (evt.mousePosition - m_PressPos).sqrMagnitude;
if (delta < (s_StartDragDistance * s_StartDragDistance))
{
return;
}
var graphView = m_Edge.GetFirstAncestorOfType <GraphView>();
var outputPortUI = m_Edge.Output.GetUI <Port>(graphView);
var inputPortUI = m_Edge.Input.GetUI <Port>(graphView);
if (outputPortUI == null || inputPortUI == null)
{
return;
}
// Determine which end is the nearest to the mouse position then detach it.
Vector2 outputPos = new Vector2(outputPortUI.GetGlobalCenter().x, outputPortUI.GetGlobalCenter().y);
Vector2 inputPos = new Vector2(inputPortUI.GetGlobalCenter().x, inputPortUI.GetGlobalCenter().y);
float distanceFromOutput = (m_PressPos - outputPos).sqrMagnitude;
float distanceFromInput = (m_PressPos - inputPos).sqrMagnitude;
if (distanceFromInput > 50 * 50 && distanceFromOutput > 50 * 50)
{
return;
}
m_DetachedFromInputPort = distanceFromInput < distanceFromOutput;
IGTFPortModel connectedPort;
Port connectedPortUI;
if (m_DetachedFromInputPort)
{
connectedPort = m_Edge.Output;
connectedPortUI = outputPortUI;
m_DetachedPort = m_Edge.Input;
}
else
{
connectedPort = m_Edge.Input;
connectedPortUI = inputPortUI;
m_DetachedPort = m_Edge.Output;
}
// Use the edge drag helper of the still connected port
m_ConnectedEdgeDragHelper = connectedPortUI.EdgeConnector.edgeDragHelper;
m_ConnectedEdgeDragHelper.originalEdge = m_Edge;
m_ConnectedEdgeDragHelper.draggedPort = connectedPort;
m_ConnectedEdgeDragHelper.CreateEdgeCandidate(connectedPort.GraphModel);
m_ConnectedEdgeDragHelper.edgeCandidateModel.EndPoint = evt.mousePosition;
// Redirect the last mouse down event to active the drag helper
if (m_ConnectedEdgeDragHelper.HandleMouseDown(m_LastMouseDownEvent))
{
m_Active = true;
}
else
{
Reset();
}
m_LastMouseDownEvent = null;
}
if (m_Active)
{
m_ConnectedEdgeDragHelper.HandleMouseMove(evt);
}
}
protected override bool OnMouseMove(MouseMoveEvent mouseMoveEvent)
{
Rotation = mousePosAngle(mouseMoveEvent.MousePosition, Position);
return(base.OnMouseMove(mouseMoveEvent));
}
void ProcessMouseMove(MouseMoveEvent mouseMoveEvent)
{
int dx = mouseMoveEvent.x - m_MouseX;
int dy = mouseMoveEvent.y - m_MouseY;
m_MouseX = mouseMoveEvent.x;
m_MouseY = mouseMoveEvent.y;
m_Canvas.Input_MouseMoved(m_MouseX, m_MouseY, dx, dy);
}
protected override bool OnMouseMove(MouseMoveEvent e)
{
mousePosition = Parent.ToLocalSpace(e.ScreenSpaceMousePosition);
return(base.OnMouseMove(e));
}
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the mouse move arguments from a mouse move event
/// </summary>
/// <param name="e">Mouse move event</param>
////////////////////////////////////////////////////////////
public MouseMoveEventArgs(MouseMoveEvent e)
{
X = e.X;
Y = e.Y;
}
private void OnMouseMove(MouseMoveEvent evt)
{
SendMouseEvent(evt, MousePhase.Move);
}
add => AddHandler(MouseMoveEvent, value);
private void MqttClient_RcvDataEvent(byte[] data)
{
try
{
if (data?.Length > 0)
{
switch (data[0])
{
case 0x00:
if (CommID.ToHexString() != data.SubArray(1, 4).ToHexString())
{
MqttClient.Unsubscribe(CommID.GetInt().ToString());
MqttClient.Subscribe(data.SubArray(1, 4).GetInt().ToString());
}
CommID = data.SubArray(1, 4);
Password = data.SubArray(6, data[5]).ToASCIIString();
break;
case 0x01:
SelectServerEvent?.BeginInvoke(data[1], null, null);
break;
case 0x02:
RcvImageEvent?.BeginInvoke(data.SubArray(1, data.Length - 1).Bytes2BitMap(), null, null);
break;
case 0x03:
IsCompression = data[1] == 1;
CompressionLevel = data[2];
break;
case 0x04:
IsSession = false;
Status = 0;
break;
case 0x05:
RcvKeyEvent?.BeginInvoke(data[1], data[2], null, null);
break;
case 0x06:
int type = (data[1] << 8) | data[2];
int x = (data[3] << 8) | data[4];
int y = (data[5] << 8) | data[6];
int dw = (data[7] << 24) | (data[8] << 16) | (data[9] << 8) | data[10];
int info = (data[11] << 24) | (data[12] << 16) | (data[13] << 8) | data[14];
MouseMoveEvent?.BeginInvoke(type, x, y, dw, info, null, null);
break;
case 0x07:
if (data.Length > 2)
{
string pwd = data.SubArray(6, data[5]).ToASCIIString();
OtherCommid = data.SubArray(1, 4);
OtherCommidStr = OtherCommid.GetInt().ToString();
if (pwd == Password)
{
MqttClient?.Request(OtherCommidStr, new byte[] { 0x07, 0x00 });
IsSession = true;
Status = 1;
Conn1Event?.BeginInvoke(null, null);
}
else
{
MqttClient?.Request(OtherCommidStr, new byte[] { 0x07, 0x01 });
}
}
else
{
if (data[1] == 0x00)
{
Status = 2;
IsSession = true;
}
Conn2Event?.Invoke(data[1]);
}
break;
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + "****" + ex.StackTrace);
}
}
protected override bool OnMouseMove(MouseMoveEvent e)
{
lastScreenSpaceMousePosition = e.ScreenSpaceMousePosition;
return(base.OnMouseMove(e));
}
void OnMouseMove(MouseMoveEvent e)
{
if (!m_Active)
{
return;
}
VisualElement resizedTarget = resizedElement.parent;
VisualElement resizedBase = resizedTarget.parent;
Vector2 mousePos = resizedBase.WorldToLocal(e.mousePosition);
if (!m_DragStarted)
{
if (resizedTarget is IResizable)
{
(resizedTarget as IResizable).OnStartResize();
}
m_DragStarted = true;
}
if (resizedTarget.isLayoutManual)
{
Rect layout = resizedTarget.layout;
if ((direction & ResizerDirection.Right) != 0)
{
layout.width = Mathf.Min(m_MaxSize.x, Mathf.Max(m_MinSize.x, m_StartSize.x + mousePos.x - m_StartMouse.x));
}
else if ((direction & ResizerDirection.Left) != 0)
{
float delta = mousePos.x - m_StartMouse.x;
if (m_StartSize.x - delta < m_MinSize.x)
{
delta = -m_MinSize.x + m_StartSize.x;
}
else if (m_StartSize.x - delta > m_MaxSize.x)
{
delta = -m_MaxSize.x + m_StartSize.x;
}
layout.xMin = delta + m_StartPosition.x;
layout.width = -delta + m_StartSize.x;
}
if ((direction & ResizerDirection.Bottom) != 0)
{
layout.height = Mathf.Min(m_MaxSize.y, Mathf.Max(m_MinSize.y, m_StartSize.y + mousePos.y - m_StartMouse.y));
}
else if ((direction & ResizerDirection.Top) != 0)
{
float delta = mousePos.y - m_StartMouse.y;
if (m_StartSize.y - delta < m_MinSize.y)
{
delta = -m_MinSize.y + m_StartSize.y;
}
else if (m_StartSize.y - delta > m_MaxSize.y)
{
delta = -m_MaxSize.y + m_StartSize.y;
}
layout.yMin = delta + m_StartPosition.y;
layout.height = -delta + m_StartSize.y;
}
if (direction != 0)
{
resizedTarget.layout = layout;
}
}
else
{
if ((direction & ResizerDirection.Right) != 0)
{
resizedTarget.style.width = Mathf.Min(m_MaxSize.x, Mathf.Max(m_MinSize.x, m_StartSize.x + mousePos.x - m_StartMouse.x));
}
else if ((direction & ResizerDirection.Left) != 0)
{
float delta = mousePos.x - m_StartMouse.x;
if (m_StartSize.x - delta < m_MinSize.x)
{
delta = -m_MinSize.x + m_StartSize.x;
}
else if (m_StartSize.x - delta > m_MaxSize.x)
{
delta = -m_MaxSize.x + m_StartSize.x;
}
resizedTarget.style.left = delta + m_StartPosition.x;
resizedTarget.style.width = -delta + m_StartSize.x;
}
if ((direction & ResizerDirection.Bottom) != 0)
{
resizedTarget.style.height = Mathf.Min(m_MaxSize.y, Mathf.Max(m_MinSize.y, m_StartSize.y + mousePos.y - m_StartMouse.y));
}
else if ((direction & ResizerDirection.Top) != 0)
{
float delta = mousePos.y - m_StartMouse.y;
if (m_StartSize.y - delta < m_MinSize.y)
{
delta = -m_MinSize.y + m_StartSize.y;
}
else if (m_StartSize.y - delta > m_MaxSize.y)
{
delta = -m_MaxSize.y + m_StartSize.y;
}
resizedTarget.style.top = delta + m_StartPosition.y;
resizedTarget.style.height = -delta + m_StartSize.y;
}
}
e.StopPropagation();
}
/// <summary>
/// Callback for the MouseMove event.
/// </summary>
/// <param name="e">The event.</param>
protected void OnMouseMove(MouseMoveEvent e)
{
if (!m_Active)
{
return;
}
if (m_GraphView == null)
{
return;
}
var ve = (VisualElement)e.target;
Vector2 gvMousePos = ve.ChangeCoordinatesTo(m_GraphView.contentContainer, e.localMousePosition);
m_PanDiff = GetEffectivePanSpeed(gvMousePos);
if (m_PanDiff != Vector3.zero)
{
m_PanSchedule.Resume();
}
else
{
m_PanSchedule.Pause();
}
// We need to monitor the mouse diff "by hand" because we stop positioning the graph elements once the
// mouse has gone out.
m_MouseDiff = m_OriginalMouse - e.mousePosition;
if (m_SelectedElement.parent != null)
{
// Handle the selected element
Rect selectedElementGeom = GetSelectedElementGeom();
ComputeSnappedRect(ref selectedElementGeom, m_SelectedElement);
foreach (KeyValuePair <GraphElement, OriginalPos> v in m_OriginalPos)
{
GraphElement ce = v.Key;
// Protect against stale visual elements that have been deparented since the start of the manipulation
if (ce.hierarchy.parent == null)
{
continue;
}
if (!v.Value.dragStarted)
{
v.Value.dragStarted = true;
}
SnapOrMoveElement(v.Key, v.Value.pos, selectedElementGeom);
}
foreach (var edge in m_EdgesToUpdate)
{
SnapOrMoveEdge(edge, selectedElementGeom);
}
}
var selection = m_GraphView.GetSelection();
var selectedUI = selection.Select(m => m.GetUI(m_GraphView));
// TODO: Replace with a temp drawing or something...maybe manipulator could fake position
// all this to let operation know which element sits under cursor...or is there another way to draw stuff that is being dragged?
var previousDropTarget = m_CurrentDropTarget;
m_CurrentDropTarget = GetDropTargetAt(e.mousePosition, selectedUI.OfType <VisualElement>().ToList());
if (m_CurrentDropTarget != previousDropTarget)
{
if (previousDropTarget != null)
{
using (DragLeaveEvent eLeave = DragLeaveEvent.GetPooled(e))
{
eLeave.target = previousDropTarget;
m_GraphView.SendEvent(eLeave);
}
}
if (m_CurrentDropTarget != null)
{
using (DragEnterEvent eEnter = DragEnterEvent.GetPooled(e))
{
eEnter.target = m_CurrentDropTarget;
m_GraphView.SendEvent(eEnter);
}
}
}
if (m_CurrentDropTarget != null)
{
using (DragUpdatedEvent eUpdated = DragUpdatedEvent.GetPooled(e))
{
eUpdated.target = m_CurrentDropTarget;
m_GraphView.SendEvent(eUpdated);
}
}
m_Dragging = true;
e.StopPropagation();
}
protected override bool OnMouseMove(MouseMoveEvent e)
{
++MouseMoveCount;
onMouseMoveStatus.Text = $"OnMouseMove {MouseMoveCount}: Position={e.MousePosition}, Delta={e.Delta}";
return(base.OnMouseMove(e));
}
protected void OnMouseMove(MouseMoveEvent evt)
{
/// If the left mouse button is not down then return
if (m_Edge == null)
{
return;
}
evt.StopPropagation();
bool alreadyDetached = (m_DetachedPort != null);
// If one end of the edge is not already detached then
if (!alreadyDetached)
{
float delta = (evt.mousePosition - m_PressPos).sqrMagnitude;
if (delta < (s_StartDragDistance * s_StartDragDistance))
{
return;
}
/// Determine which end is the nearest to the mouse position then detach it.
Vector2 outputPos = new Vector2(m_Edge.output.GetGlobalCenter().x, m_Edge.output.GetGlobalCenter().y);
Vector2 inputPos = new Vector2(m_Edge.input.GetGlobalCenter().x, m_Edge.input.GetGlobalCenter().y);
float distanceFromOutput = (m_PressPos - outputPos).sqrMagnitude;
float distanceFromInput = (m_PressPos - inputPos).sqrMagnitude;
m_DetachedFromInputPort = distanceFromInput < distanceFromOutput;
if (m_DetachedFromInputPort)
{
m_ConnectedPort = m_Edge.output;
m_DetachedPort = m_Edge.input;
m_DetachedPort.Disconnect(m_Edge);
m_Edge.input = null;
}
else
{
m_ConnectedPort = m_Edge.input;
m_DetachedPort = m_Edge.output;
m_DetachedPort.Disconnect(m_Edge);
m_Edge.output = null;
}
// Use the edge drag helper of the still connected port
m_ConnectedEdgeDragHelper = m_ConnectedPort.edgeConnector.edgeDragHelper;
m_ConnectedEdgeDragHelper.draggedPort = m_ConnectedPort;
m_ConnectedEdgeDragHelper.edgeCandidate = m_Edge;
m_AdditionalEdgeDragHelpers = new List <EdgeDragHelper>();
m_AdditionalEdges = new List <Edge>();
GraphView gv = m_DetachedPort.GetFirstAncestorOfType <GraphView>();
if (m_DetachedPort.allowMultiDrag)
{
foreach (var edge in m_DetachedPort.connections)
{
if (edge != m_Edge && edge.IsSelected(gv))
{
var otherPort = m_DetachedPort == edge.input ? edge.output : edge.input;
var edgeDragHelper = otherPort.edgeConnector.edgeDragHelper;
edgeDragHelper.draggedPort = otherPort;
edgeDragHelper.edgeCandidate = edge;
if (m_DetachedPort == edge.input)
{
edge.input = null;
}
else
{
edge.output = null;
}
m_AdditionalEdgeDragHelpers.Add(edgeDragHelper);
m_AdditionalEdges.Add(edge);
}
}
foreach (var edge in m_AdditionalEdges)
{
m_DetachedPort.Disconnect(edge);
}
}
m_Edge.candidatePosition = evt.mousePosition;
// Redirect the last mouse down event to active the drag helper
if (m_ConnectedEdgeDragHelper.HandleMouseDown(m_LastMouseDownEvent))
{
m_Active = true;
foreach (var edgeDrag in m_AdditionalEdgeDragHelpers)
{
edgeDrag.HandleMouseDown(m_LastMouseDownEvent);
}
}
else
{
Reset();
}
m_LastMouseDownEvent = null;
}
if (m_Active)
{
m_ConnectedEdgeDragHelper.HandleMouseMove(evt);
foreach (var edgeDrag in m_AdditionalEdgeDragHelpers)
{
edgeDrag.HandleMouseMove(evt);
}
}
}
public void HandleMouseMove(MouseMoveEvent evt)
{
var ve = (VisualElement)evt.target;
Vector2 gvMousePos = ve.ChangeCoordinatesTo(GraphView.contentContainer, evt.localMousePosition);
m_PanDiff = GetEffectivePanSpeed(gvMousePos);
if (m_PanDiff != Vector3.zero)
{
m_PanSchedule.Resume();
}
else
{
m_PanSchedule.Pause();
}
Vector2 mousePosition = evt.mousePosition;
edgeCandidateModel.EndPoint = mousePosition;
m_EdgeCandidate.UpdateFromModel();
// Draw ghost edge if possible port exists.
Port endPort = GetEndPort(mousePosition);
if (endPort != null)
{
if (m_GhostEdge == null)
{
m_GhostEdge = CreateGhostEdge(endPort.PortModel.GraphModel);
m_GhostEdgeModel = m_GhostEdge.EdgeModel as GhostEdgeModel;
m_GhostEdge.pickingMode = PickingMode.Ignore;
GraphView.AddElement(m_GhostEdge);
}
Debug.Assert(m_GhostEdgeModel != null);
if (edgeCandidateModel.FromPort == null)
{
m_GhostEdgeModel.ToPort = edgeCandidateModel.ToPort;
var portUI = m_GhostEdgeModel?.FromPort?.GetUI <Port>(GraphView);
if (portUI != null)
{
portUI.WillConnect = false;
}
m_GhostEdgeModel.FromPort = endPort.PortModel;
endPort.WillConnect = true;
}
else
{
var portUI = m_GhostEdgeModel?.ToPort?.GetUI <Port>(GraphView);
if (portUI != null)
{
portUI.WillConnect = false;
}
m_GhostEdgeModel.ToPort = endPort.PortModel;
endPort.WillConnect = true;
m_GhostEdgeModel.FromPort = edgeCandidateModel.FromPort;
}
m_GhostEdge.UpdateFromModel();
}
else if (m_GhostEdge != null && m_GhostEdgeModel != null)
{
if (edgeCandidateModel.ToPort == null)
{
var portUI = m_GhostEdgeModel?.ToPort?.GetUI <Port>(GraphView);
if (portUI != null)
{
portUI.WillConnect = false;
}
}
else
{
var portUI = m_GhostEdgeModel?.FromPort?.GetUI <Port>(GraphView);
if (portUI != null)
{
portUI.WillConnect = false;
}
}
GraphView.RemoveElement(m_GhostEdge);
m_GhostEdgeModel.ToPort = null;
m_GhostEdgeModel.FromPort = null;
m_GhostEdgeModel = null;
m_GhostEdge = null;
}
}
protected override bool OnMouseMove(MouseMoveEvent e)
{
Position = e.MousePosition;
return(base.OnMouseMove(e));
}
protected new void OnMouseMove(MouseMoveEvent e)
{
if (!target.HasMouseCapture())
{
// We lost the capture. Since we still receive mouse events,
// the MouseDown target must have taken it in its ExecuteDefaultAction().
// Stop processing the event sequence, then.
// FIXME: replace this by a handler on the upcoming LostCaptureEvent.
m_PrevDropTarget = null;
m_Active = false;
}
if (!m_Active)
{
return;
}
if (m_GraphView == null)
{
return;
}
var ve = (VisualElement)e.target;
Vector2 gvMousePos = ve.ChangeCoordinatesTo(m_GraphView.contentContainer, e.localMousePosition);
m_PanDiff = GetEffectivePanSpeed(gvMousePos);
if (m_PanDiff != Vector3.zero)
{
m_PanSchedule.Resume();
}
else
{
m_PanSchedule.Pause();
}
// We need to monitor the mouse diff "by hand" because we stop positionning the graph elements once the
// mouse has gone out.
m_MouseDiff = m_originalMouse - e.mousePosition;
foreach (KeyValuePair <GraphElement, Rect> v in m_OriginalPos)
{
GraphElement ce = v.Key;
Matrix4x4 g = ce.worldTransform;
var scale = new Vector3(g.m00, g.m11, g.m22);
Rect ceLayout = ce.GetPosition();
ce.SetPosition(
new Rect(v.Value.x - (m_MouseDiff.x - m_ItemPanDiff.x) * panSpeed.x / scale.x,
v.Value.y - (m_MouseDiff.y - m_ItemPanDiff.y) * panSpeed.y / scale.y,
ceLayout.width, ceLayout.height));
}
List <ISelectable> selection = m_GraphView.selection;
// TODO: Replace with a temp drawing or something...maybe manipulator could fake position
// all this to let operation know which element sits under cursor...or is there another way to draw stuff that is being dragged?
IDropTarget dropTarget = GetDropTargetAt(e.localMousePosition);
if (m_PrevDropTarget != dropTarget && m_PrevDropTarget != null)
{
using (IMGUIEvent eexit = IMGUIEvent.GetPooled(e.imguiEvent))
{
eexit.imguiEvent.type = EventType.DragExited;
SendDragAndDropEvent(eexit, selection, m_PrevDropTarget);
}
}
using (IMGUIEvent eupdated = IMGUIEvent.GetPooled(e.imguiEvent))
{
eupdated.imguiEvent.type = EventType.DragUpdated;
SendDragAndDropEvent(eupdated, selection, dropTarget);
}
m_PrevDropTarget = dropTarget;
selectedElement = null;
e.StopPropagation();
}
protected virtual void OnMouseMove(MouseMoveEvent e)
{
MouseMove.Raise(e);
}
protected override bool OnMouseMove(MouseMoveEvent e)
{
IsActiveArea.Value = true;
return(base.OnMouseMove(e));
}
public abstract void HandleMouseMove(MouseMoveEvent evt);
protected override bool OnMouseMove(MouseMoveEvent e)
{
queueExpandIfHovering();
return(base.OnMouseMove(e));
}
protected void ExecuteMouseMove(MouseMoveEvent evt)
{
MouseMoveHandler dlgt = MouseMoved;
if (dlgt != null)
dlgt(evt.X, evt.Y);
}
protected override bool OnMouseMove(MouseMoveEvent e)
{
catcherArea.SetCatcherPosition(e.MousePosition.X / DrawSize.X * CatchPlayfield.WIDTH);
return(base.OnMouseMove(e));
}
void ProcessMouseMove(MouseMoveEvent mouseMoveEvent)
{
var dx = mouseMoveEvent.X - mouseX;
var dy = mouseMoveEvent.Y - mouseY;
mouseX = mouseMoveEvent.X;
mouseY = mouseMoveEvent.Y;
canvas.Input_MouseMoved(mouseX, mouseY, dx, dy);
}
void OnMouseMove(MouseMoveEvent evt)
{
localMousePosition = rootVisualElement.WorldToLocal(evt.mousePosition);
}
