// 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); }