private void OnChildAdded(GraphElement element)
{
element.AddToClassList("stack-child-element");
element.ResetPositionProperties();
element.RegisterCallback <DetachFromPanelEvent>(OnChildDetachedFromPanel);
UpdatePlaceholderVisibility();
}
static bool WasSelectableDescendantHitByMouse(GraphElement currentTarget, MouseDownEvent evt)
{
VisualElement targetElement = evt.target as VisualElement;
if (targetElement == null || currentTarget == targetElement)
{
return(false);
}
VisualElement descendant = targetElement;
while (descendant != null && currentTarget != descendant)
{
GraphElement selectableDescendant = descendant as GraphElement;
if (selectableDescendant != null && selectableDescendant.enabledInHierarchy && selectableDescendant.pickingMode != PickingMode.Ignore && selectableDescendant.IsSelectable())
{
Vector2 localMousePosition = currentTarget.ChangeCoordinatesTo(descendant, evt.localMousePosition);
if (selectableDescendant.HitTest(localMousePosition))
{
return(true);
}
}
descendant = descendant.parent;
}
return(false);
}
protected void OnMouseUp(MouseUpEvent e)
{
GraphElement ce = e.target as GraphElement;
if (ce != null && !ce.IsMovable())
{
return;
}
if (m_Active)
{
if (CanStopManipulation(e))
{
var graphElement = target as GraphElement;
if (graphElement != null)
{
graphElement.UpdatePresenterPosition();
}
m_Active = false;
target.ReleaseMouse();
e.StopPropagation();
}
}
}
protected void OnMouseMove(MouseMoveEvent e)
{
GraphElement ce = e.target as GraphElement;
if (ce != null && !ce.IsMovable())
{
return;
}
if (m_Active)
{
Vector2 diff = e.localMousePosition - m_Start;
if (ce != null)
{
var targetScale = ce.transform.scale;
diff.x *= targetScale.x;
diff.y *= targetScale.y;
}
Rect rect = CalculatePosition(target.layout.x + diff.x, target.layout.y + diff.y, target.layout.width, target.layout.height);
if (target.IsLayoutManual())
{
target.SetLayout(rect);
}
else if (target.resolvedStyle.position == Position.Absolute)
{
target.style.left = rect.x;
target.style.top = rect.y;
}
e.StopPropagation();
}
}
private VisualElement CreateDropPreview(GraphElement element)
{
VisualElement preview = dropPreviewTemplate(element);
preview.Add(new Label(element.title));
preview.AddToClassList(k_PreviewClass);
return(preview);
}
private static VisualElement DefaultDropPreviewTemplate(GraphElement source)
{
VisualElement preview = new VisualElement();
preview.AddToClassList("default");
return(preview);
}
private bool AcceptsElementInternal(GraphElement element, ref int proposedIndex, int maxIndex)
{
// TODO: we probably need a "Stackable" capability
return(element != null && !(element is Scope) &&
!(element is StackNode) && !(element is TokenNode) &&
!(element is Placemat) &&
(element.GetContainingScope() as Group) == null &&
AcceptsElement(element, ref proposedIndex, maxIndex));
}
internal static void SetContainingScope(this GraphElement element, Scope scope)
{
if (element == null)
{
throw new ArgumentNullException(nameof(element));
}
element.SetProperty(containingScopePropertyKey, scope);
}
public static Scope GetContainingScope(this GraphElement element)
{
if (element == null)
{
return(null);
}
return(element.GetProperty(containingScopePropertyKey) as Scope);
}
Rect CalculateElementRect(GraphElement elem)
{
Rect rect = elem.ChangeCoordinatesTo(graphView.contentViewContainer, elem.GetRect());
rect.x = m_ContentRect.x + ((rect.x - m_ContentRectLocal.x) * m_ContentRect.width / m_ContentRectLocal.width);
rect.y = m_ContentRect.y + ((rect.y - m_ContentRectLocal.y) * m_ContentRect.height / m_ContentRectLocal.height);
rect.width *= m_ContentRect.width / m_ContentRectLocal.width;
rect.height *= m_ContentRect.height / m_ContentRectLocal.height;
// Clip using a minimal 2 pixel wide frame around edges
// (except yMin since we already have the titleBar offset which is enough for clipping)
var xMin = 2;
var yMin = windowed ? 2 : 0;
var xMax = layout.width - 2;
var yMax = layout.height - 2;
if (rect.x < xMin)
{
if (rect.x < xMin - rect.width)
{
return(new Rect(0, 0, 0, 0));
}
rect.width -= xMin - rect.x;
rect.x = xMin;
}
if (rect.x + rect.width >= xMax)
{
if (rect.x >= xMax)
{
return(new Rect(0, 0, 0, 0));
}
rect.width -= rect.x + rect.width - xMax;
}
if (rect.y < yMin + titleBarOffset)
{
if (rect.y < yMin + titleBarOffset - rect.height)
{
return(new Rect(0, 0, 0, 0));
}
rect.height -= yMin + titleBarOffset - rect.y;
rect.y = yMin + titleBarOffset;
}
if (rect.y + rect.height >= yMax)
{
if (rect.y >= yMax)
{
return(new Rect(0, 0, 0, 0));
}
rect.height -= rect.y + rect.height - yMax;
}
return(rect);
}
private void OnChildDetachedFromPanel(DetachFromPanelEvent evt)
{
if (panel == null)
{
return;
}
GraphElement element = evt.target as GraphElement;
OnChildRemoved(element);
}
public virtual void OnStartDragging(GraphElement ge)
{
var node = ge as Node;
if (node != null)
{
ge.RemoveFromHierarchy();
graphView.AddElement(ge);
// Reselect it because RemoveFromHierarchy unselected it
ge.Select(graphView, true);
}
}
private void OnChildRemoved(GraphElement element)
{
element.RemoveFromClassList("stack-child-element");
element.UnregisterCallback <DetachFromPanelEvent>(OnChildDetachedFromPanel);
// Disable the animation temporarily
if (m_InstantAdd == false)
{
m_InstantAdd = true;
schedule.Execute(() => m_InstantAdd = false);
}
UpdatePlaceholderVisibility();
}
public override bool AcceptsElement(GraphElement element, ref string reasonWhyNotAccepted)
{
if (element is Group)
{
reasonWhyNotAccepted = "Nested group is not supported yet.";
return(false);
}
else if (element is Scope)
{
reasonWhyNotAccepted = "Nested scope is not supported yet.";
return(false);
}
return(true);
}
public void InsertElement(int index, GraphElement element)
{
if (!AcceptsElementInternal(element, ref index, childCount))
{
return;
}
Insert(index, element);
OnChildAdded(element);
if (graphView != null)
{
graphView.RestorePersitentSelectionForElement(element);
}
}
void MoveElement(GraphElement element, Rect originalPos)
{
Matrix4x4 g = element.worldTransform;
var scale = new Vector3(g.m00, g.m11, g.m22);
// Compute the new position of the selected element using the mouse delta position and panning info
var offset = new Vector2(
-(m_MouseDiff.x - m_ItemPanDiff.x) * panSpeed.x / scale.x * element.transform.scale.x,
-(m_MouseDiff.y - m_ItemPanDiff.y) * panSpeed.y / scale.y * element.transform.scale.y
);
Rect newPos = originalPos;
newPos.x = originalPos.x + offset.x;
newPos.y = originalPos.y + offset.y;
element.SetPosition(m_GraphView.contentViewContainer.ChangeCoordinatesTo(element.hierarchy.parent, newPos));
}
protected void OnMouseDown(MouseDownEvent e)
{
if (m_Active)
{
e.StopImmediatePropagation();
return;
}
GraphElement ce = e.target as GraphElement;
if (ce != null && !ce.IsMovable())
{
return;
}
if (CanStartManipulation(e))
{
m_Start = e.localMousePosition;
m_Active = true;
target.CaptureMouse();
e.StopPropagation();
}
}
protected new 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 USE_DRAG_RESET_WHEN_OUT_OF_GRAPH_VIEW
// We currently don't have a real use case for this and it just appears to annoy users.
// If and when the use case arise, we can revive this functionality.
if (gvMousePos.x < 0 || gvMousePos.y < 0 || gvMousePos.x > m_GraphView.layout.width ||
gvMousePos.y > m_GraphView.layout.height)
{
if (!m_GoneOut)
{
m_PanSchedule.Pause();
foreach (KeyValuePair <GraphElement, Rect> v in m_OriginalPos)
{
v.Key.SetPosition(v.Value);
}
m_GoneOut = true;
}
e.StopPropagation();
return;
}
if (m_GoneOut)
{
m_GoneOut = false;
}
#endif
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;
var groupElementsDraggedOut = e.shiftKey ? new Dictionary <Group, List <GraphElement> >() : null;
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)
{
// TODO Would probably be a good idea to batch stack items as we do for group ones.
var stackParent = ce.GetFirstAncestorOfType <StackNode>();
if (stackParent != null)
{
stackParent.OnStartDragging(ce);
}
if (groupElementsDraggedOut != null)
{
var groupParent = ce.GetContainingScope() as Group;
if (groupParent != null)
{
if (!groupElementsDraggedOut.ContainsKey(groupParent))
{
groupElementsDraggedOut[groupParent] = new List <GraphElement>();
}
groupElementsDraggedOut[groupParent].Add(ce);
}
}
v.Value.dragStarted = true;
}
MoveElement(ce, v.Value.pos);
}
foreach (var edge in m_EdgesToUpdate)
{
UpdateEdge(edge);
}
// Needed to ensure nodes can be dragged out of multiple groups all at once.
if (groupElementsDraggedOut != null)
{
foreach (KeyValuePair <Group, List <GraphElement> > kvp in groupElementsDraggedOut)
{
kvp.Key.OnStartDragging(e, kvp.Value);
}
}
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.mousePosition, selection.OfType <VisualElement>());
if (m_PrevDropTarget != dropTarget)
{
if (m_PrevDropTarget != null)
{
using (DragLeaveEvent eexit = DragLeaveEvent.GetPooled(e))
{
SendDragAndDropEvent(eexit, selection, m_PrevDropTarget, m_GraphView);
}
}
using (DragEnterEvent eenter = DragEnterEvent.GetPooled(e))
{
SendDragAndDropEvent(eenter, selection, dropTarget, m_GraphView);
}
}
using (DragUpdatedEvent eupdated = DragUpdatedEvent.GetPooled(e))
{
SendDragAndDropEvent(eupdated, selection, dropTarget, m_GraphView);
}
m_PrevDropTarget = dropTarget;
selectedElement = null;
e.StopPropagation();
}
protected new void OnMouseDown(MouseDownEvent e)
{
if (m_Active)
{
e.StopImmediatePropagation();
return;
}
if (CanStartManipulation(e))
{
m_GraphView = target as GraphView;
if (m_GraphView == null)
{
return;
}
selectedElement = null;
// avoid starting a manipulation on a non movable object
clickedElement = e.target as GraphElement;
if (clickedElement == null)
{
var ve = e.target as VisualElement;
clickedElement = ve.GetFirstAncestorOfType <GraphElement>();
if (clickedElement == null)
{
return;
}
}
// Only start manipulating if the clicked element is movable, selected and that the mouse is in its clickable region (it must be deselected otherwise).
if (!clickedElement.IsMovable() || !clickedElement.HitTest(clickedElement.WorldToLocal(e.mousePosition)))
{
return;
}
// If we hit this, this likely because the element has just been unselected
// It is important for this manipulator to receive the event so the previous one did not stop it
// but we shouldn't let it propagate to other manipulators to avoid a re-selection
if (!m_GraphView.selection.Contains(clickedElement))
{
e.StopImmediatePropagation();
return;
}
selectedElement = clickedElement;
m_OriginalPos = new Dictionary <GraphElement, OriginalPos>();
HashSet <GraphElement> elementsToMove = new HashSet <GraphElement>(m_GraphView.selection.OfType <GraphElement>());
var selectedPlacemats = new HashSet <Placemat>(elementsToMove.OfType <Placemat>());
foreach (var placemat in selectedPlacemats)
{
placemat.GetElementsToMove(e.shiftKey, elementsToMove);
}
m_EdgesToUpdate.Clear();
foreach (var edge in m_GraphView.edges.ToList())
{
if (elementsToMove.Contains(edge.input.node) && elementsToMove.Contains(edge.output.node))
{
m_EdgesToUpdate.Add(edge);
}
}
foreach (GraphElement ce in elementsToMove)
{
if (ce == null || !ce.IsMovable())
{
continue;
}
StackNode stackNode = null;
if (ce.parent is StackNode)
{
stackNode = ce.parent as StackNode;
if (stackNode.IsSelected(m_GraphView))
{
continue;
}
}
Rect geometry = ce.GetPosition();
Rect geometryInContentViewSpace = ce.hierarchy.parent.ChangeCoordinatesTo(m_GraphView.contentViewContainer, geometry);
m_OriginalPos[ce] = new OriginalPos
{
pos = geometryInContentViewSpace,
scope = ce.GetContainingScope(),
stack = stackNode,
stackIndex = stackNode != null?stackNode.IndexOf(ce) : -1
};
}
m_originalMouse = e.mousePosition;
m_ItemPanDiff = Vector3.zero;
if (m_PanSchedule == null)
{
m_PanSchedule = m_GraphView.schedule.Execute(Pan).Every(k_PanInterval).StartingIn(k_PanInterval);
m_PanSchedule.Pause();
}
m_Active = true;
target.CaptureMouse(); // We want to receive events even when mouse is not over ourself.
e.StopImmediatePropagation();
}
}
public void AddElement(GraphElement element)
{
InsertElement(childCount, element);
}
protected virtual bool AcceptsElement(GraphElement element, ref int proposedIndex, int maxIndex)
{
return(true);
}
public void RemoveElement(GraphElement element)
{
Remove(element);
}
