// TODO: Do we limit to GraphElements or can we tab through ISelectable's?
EventPropagation FramePrevNext(List <GraphElement> childrenList)
{
GraphElement graphElement = null;
// Start from current selection, if any
if (selection.Count != 0)
{
graphElement = selection[0] as GraphElement;
}
int idx = childrenList.IndexOf(graphElement);
if (idx >= 0 && idx < childrenList.Count - 1)
{
graphElement = childrenList[idx + 1];
}
else
{
graphElement = childrenList[0];
}
// New selection...
ClearSelection();
AddToSelection(graphElement);
// ...and frame this new selection
return(Frame(FrameType.Selection));
}
protected void OnMouseMove(MouseMoveEvent e)
{
GraphElement ce = e.target as GraphElement;
if (ce != null && !ce.IsPositioned())
{
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 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);
}
private bool AcceptsElementInternal(GraphElement element, ref int proposedIndex, int maxIndex)
{
// TODO: we probably need a "Stackable" capability
return(element != null &&
!(element is StackNode) && !(element is TokenNode) &&
!(element is Placemat) &&
AcceptsElement(element, ref proposedIndex, maxIndex));
}
private VisualElement CreateDropPreview(GraphElement element)
{
VisualElement preview = dropPreviewTemplate(element);
preview.Add(new Label((element.Model as IHasTitle)?.Title));
preview.AddToClassList(k_PreviewClass);
return(preview);
}
private static VisualElement DefaultDropPreviewTemplate(GraphElement source)
{
VisualElement preview = new VisualElement();
preview.AddToClassList("default");
return(preview);
}
private void OnChildDetachedFromPanel(DetachFromPanelEvent evt)
{
if (panel == null)
{
return;
}
GraphElement element = evt.target as GraphElement;
OnChildRemoved(element);
}
private void AddToSelectionNoUndoRecord(GraphElement graphElement)
{
graphElement.selected = true;
selection.Add(graphElement);
graphElement.OnSelected();
// To ensure that the selected GraphElement gets unselected if it is removed from the GraphView.
graphElement.RegisterCallback <DetachFromPanelEvent>(OnSelectedElementDetachedFromPanel);
graphElement.MarkDirtyRepaint();
}
public void InsertElement(int index, GraphElement element)
{
if (!AcceptsElementInternal(element, ref index, childCount))
{
return;
}
Insert(index, element);
OnChildAdded(element);
GraphView?.RestorePersitentSelectionForElement(element);
}
public virtual void OnStartDragging(GraphElement ge)
{
var node = ge as CollapsiblePortNode;
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();
}
void MoveElement(GraphElement element, Rect originalPos)
{
Matrix4x4 g = element.worldTransform;
var scale = new Vector3(g.m00, g.m11, g.m22);
Rect newPos = new Rect(0, 0, originalPos.width, originalPos.height);
// Compute the new position of the selected element using the mouse delta position and panning info
newPos.x = originalPos.x - (m_MouseDiff.x - m_ItemPanDiff.x) * panSpeed.x / scale.x * element.transform.scale.x;
newPos.y = originalPos.y - (m_MouseDiff.y - m_ItemPanDiff.y) * panSpeed.y / scale.y * element.transform.scale.y;
newPos = m_GraphView.contentViewContainer.ChangeCoordinatesTo(element.hierarchy.parent, newPos);
element.style.left = newPos.x;
element.style.top = newPos.y;
}
public void RemoveElement(GraphElement graphElement)
{
StackNode stack = graphElement.parent as StackNode;
if (stack != null)
{
stack.RemoveElement(graphElement);
if (elementsRemovedFromStackNode != null)
{
elementsRemovedFromStackNode(stack, new[] { graphElement });
}
}
graphElement.RemoveFromHierarchy();
}
protected void OnMouseUp(MouseUpEvent e)
{
GraphElement ce = e.target as GraphElement;
if (ce != null && !ce.IsPositioned())
{
return;
}
if (m_Active)
{
if (CanStopManipulation(e))
{
m_Active = false;
target.ReleaseMouse();
e.StopPropagation();
}
}
}
public void AddElement(GraphElement graphElement)
{
if (graphElement.IsResizable())
{
graphElement.hierarchy.Add(new Resizer());
graphElement.style.borderBottomWidth = 6;
}
int newLayer = graphElement.layer;
if (!m_ContainerLayers.ContainsKey(newLayer))
{
AddLayer(newLayer);
}
GetLayer(newLayer).Add(graphElement);
// Attempt to restore selection on the new element if it
// was previously selected (same GUID).
RestorePersitentSelectionForElement(graphElement);
}
internal void ChangeLayer(GraphElement element)
{
if (!m_ContainerLayers.ContainsKey(element.layer))
{
AddLayer(element.layer);
}
bool selected = element.selected;
if (selected)
{
element.UnregisterCallback <DetachFromPanelEvent>(OnSelectedElementDetachedFromPanel);
}
GetLayer(element.layer).Add(element);
if (selected)
{
element.RegisterCallback <DetachFromPanelEvent>(OnSelectedElementDetachedFromPanel);
}
}
internal void RestorePersitentSelectionForElement(GraphElement element)
{
if (m_PersistedSelection == null)
{
return;
}
if (m_PersistedSelection.selectedElements.Count == selection.Count && m_PersistedSelection.version == m_SavedSelectionVersion)
{
return;
}
if (string.IsNullOrEmpty(element.viewDataKey))
{
return;
}
if (m_PersistedSelection.selectedElements.Contains(element.viewDataKey))
{
AddToSelectionNoUndoRecord(element);
}
}
protected void OnMouseDown(MouseDownEvent e)
{
if (m_Active)
{
e.StopImmediatePropagation();
return;
}
GraphElement ce = e.target as GraphElement;
if (ce != null && !ce.IsPositioned())
{
return;
}
if (CanStartManipulation(e))
{
m_Start = e.localMousePosition;
m_Active = true;
target.CaptureMouse();
e.StopPropagation();
}
}
public void RemoveElement(GraphElement element)
{
Remove(element);
}
protected new void OnMouseDown(MouseDownEvent e)
{
if (m_Active)
{
e.StopImmediatePropagation();
return;
}
if (CanStartManipulation(e))
{
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.IsPositioned() || !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();
HashSet <IGTFNodeModel> nodeModelsToMove = new HashSet <IGTFNodeModel>(elementsToMove.Select(element => element.Model).OfType <IGTFNodeModel>());
foreach (var edge in m_GraphView.edges.ToList())
{
if (nodeModelsToMove.Contains(edge.Input.NodeModel) && nodeModelsToMove.Contains(edge.Output.NodeModel))
{
m_EdgesToUpdate.Add(edge);
}
}
foreach (GraphElement ce in elementsToMove)
{
if (ce == null || !ce.IsPositioned())
{
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,
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();
}
}
protected virtual bool AcceptsElement(GraphElement element, ref int proposedIndex, int maxIndex)
{
return(true);
}
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;
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);
}
v.Value.dragStarted = true;
}
MoveElement(ce, v.Value.pos);
}
foreach (var edge in m_EdgesToUpdate)
{
UpdateEdge(edge);
}
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();
}
public void AddElement(GraphElement element)
{
InsertElement(childCount, element);
}
