public static GroupNode GetContainingGroupNode(this GraphElement element) { GroupNode result; if (element == null) { result = null; } else { GraphView firstAncestorOfType = element.GetFirstAncestorOfType <GraphView>(); if (firstAncestorOfType == null) { result = null; } else { List <GroupNode> list = firstAncestorOfType.Query(null, null).ToList(); foreach (GroupNode current in list) { if (current.ContainsElement(element)) { result = current; return(result); } } result = null; } } return(result); }
protected void OnMouseDown(MouseDownEvent e) { if (e.currentTarget is ISelectable) { if (base.CanStartManipulation(e)) { if ((base.target as ISelectable).HitTest(e.localMousePosition)) { GraphElement graphElement = e.currentTarget as GraphElement; if (graphElement != null) { VisualElement parent = graphElement.shadow.parent; while (parent != null && !(parent is GraphView)) { parent = parent.shadow.parent; } GraphView selectionContainer = parent as GraphView; if (graphElement.IsSelected(selectionContainer) && e.ctrlKey) { graphElement.Unselect(selectionContainer); } else { graphElement.Select(selectionContainer, e.shiftKey || e.ctrlKey); } } } } } }
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; Rect rect = CalculatePosition(target.layout.x + diff.x, target.layout.y + diff.y, target.layout.width, target.layout.height); if (target.style.positionType == PositionType.Manual) { target.layout = rect; } else if (target.style.positionType == PositionType.Absolute) { target.style.positionLeft = rect.x; target.style.positionTop = rect.y; } e.StopPropagation(); } }
public void AddElement(GraphElement element) { if (element == null) { throw new ArgumentException("Cannot add null element"); } if (element is GroupNode) { throw new ArgumentException("Nested group node is not supported yet."); } if (this.m_ContainedElements == null) { this.m_ContainedElements = new List <GraphElement>(); } else if (this.m_ContainedElements.Contains(element)) { throw new ArgumentException("The element is already contained in this group node."); } GroupNode containingGroupNode = element.GetContainingGroupNode(); if (containingGroupNode != null) { containingGroupNode.RemoveElement(element); } this.m_ContainedElements.Add(element); element.RegisterCallback <PostLayoutEvent>(new EventCallback <PostLayoutEvent>(this.OnSubElementPostLayout), Capture.NoCapture); element.RegisterCallback <DetachFromPanelEvent>(new EventCallback <DetachFromPanelEvent>(this.OnSubElementDetachedFromPanel), Capture.NoCapture); this.UpdateGeometryFromContent(); GraphView firstAncestorOfType = base.GetFirstAncestorOfType <GraphView>(); if (firstAncestorOfType != null && firstAncestorOfType.elementAddedToGroupNode != null) { firstAncestorOfType.elementAddedToGroupNode(this, element); } }
private void OnMouseMove(MouseMoveEvent e) { GraphElement graphElement = base.parent as GraphElement; if (graphElement != null) { if (graphElement.IsResizable()) { if (this.m_Active && base.parent.style.positionType == PositionType.Manual) { Vector2 vector = this.ChangeCoordinatesTo(base.parent, e.localMousePosition) - this.m_Start; Vector2 vector2 = new Vector2(this.m_StartPos.width + vector.x, this.m_StartPos.height + vector.y); if (vector2.x < this.m_MinimumSize.x) { vector2.x = this.m_MinimumSize.x; } if (vector2.y < this.m_MinimumSize.y) { vector2.y = this.m_MinimumSize.y; } graphElement.SetPosition(new Rect(graphElement.layout.x, graphElement.layout.y, vector2.x, vector2.y)); graphElement.UpdatePresenterPosition(); GraphView firstAncestorOfType = graphElement.GetFirstAncestorOfType <GraphView>(); if (firstAncestorOfType != null && firstAncestorOfType.elementResized != null) { firstAncestorOfType.elementResized(graphElement); } this.m_LabelText.text = string.Format("{0:0}", base.parent.layout.width) + "x" + string.Format("{0:0}", base.parent.layout.height); e.StopPropagation(); } } } }
private void OnMouseDown(MouseDownEvent e) { if (this.m_Active) { e.StopImmediatePropagation(); } else if (!MouseCaptureController.IsMouseCaptureTaken()) { GraphElement graphElement = base.parent as GraphElement; if (graphElement != null) { if (graphElement.IsResizable()) { if (e.button == (int)this.activateButton) { this.m_Start = this.ChangeCoordinatesTo(base.parent, e.localMousePosition); this.m_StartPos = base.parent.layout; if (base.parent.style.positionType != PositionType.Manual) { Debug.LogWarning("Attempting to resize an object with a non manual position"); } this.m_Active = true; this.TakeMouseCapture(); 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); }
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.ReleaseMouseCapture(); e.StopPropagation(); } } }
private bool AcceptsElementInternal(GraphElement element, ref int proposedIndex, int maxIndex) { return(element != null && !(element is Scope) && !(element is StackNode) && !(element is TokenNode) && (element.GetContainingScope() as Group) == null && AcceptsElement(element, ref proposedIndex, maxIndex)); }
// 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) { return(EventPropagation.Continue); } if (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)); }
public EventPropagation DragUpdated(IMGUIEvent evt, IEnumerable <ISelectable> selection, IDropTarget dropTarget) { GroupNode firstAncestorOfType = base.parent.GetFirstAncestorOfType <GroupNode>(); bool flag = false; foreach (ISelectable current in selection) { if (current != firstAncestorOfType) { GraphElement element = current as GraphElement; Event imguiEvent = evt.imguiEvent; if (imguiEvent.shift) { if (firstAncestorOfType.ContainsElement(element)) { firstAncestorOfType.RemoveElement(element); } } else if (!firstAncestorOfType.ContainsElement(element) && element.GetContainingGroupNode() == null) { flag = true; } } } if (flag) { base.AddToClassList("dragEntered"); } else { base.RemoveFromClassList("dragEntered"); } return(EventPropagation.Stop); }
private void AddElementInternal(GraphElement element) { if (element == null) { throw new ArgumentException("Cannot add null element"); } if (containedElements.Contains(element)) { throw new ArgumentException("The specified element is already contained in this scope."); } string reasonWhyNotAccepted = "Cannot add the specified element to this scope."; if (!AcceptsElement(element, ref reasonWhyNotAccepted)) { throw new ArgumentException(reasonWhyNotAccepted); } // Removes the element from its current scope Scope currentScope = element.GetContainingScope(); if (currentScope != null) { currentScope.RemoveElement(element); } m_ContainedElements.Add(element); // To update the scope geometry whenever the added element's geometry changes element.RegisterCallback <GeometryChangedEvent>(OnSubElementGeometryChanged); ScheduleUpdateGeometryFromContent(); }
public void RemoveElement(GraphElement element) { if (element == null) { throw new ArgumentException("Cannot remove null element from this group"); } if (m_ContainedElements == null) { return; } if (!m_ContainedElements.Contains(element)) { throw new ArgumentException("This element is not contained in this group"); } m_ContainedElements.Remove(element); element.UnregisterCallback <PostLayoutEvent>(OnSubElementPostLayout); element.UnregisterCallback <DetachFromPanelEvent>(OnSubElementDetachedFromPanel); UpdateGeometryFromContent(); GraphView gv = GetFirstAncestorOfType <GraphView>(); if (gv != null && gv.elementRemovedFromGroupNode != null) { gv.elementRemovedFromGroupNode(this, element); } }
public static GroupNode GetContainingGroupNode(this GraphElement element) { if (element == null) { return(null); } GraphView graphView = element.GetFirstAncestorOfType <GraphView>(); if (graphView == null) { return(null); } List <GroupNode> groups = graphView.Query <GroupNode>().ToList(); foreach (GroupNode group in groups) { if (group.ContainsElement(element)) { return(group); } } return(null); }
public bool DragPerform(DragPerformEvent evt, IEnumerable <ISelectable> selection, IDropTarget dropTarget) { HandleDragAndDropEvent(evt, selection); GraphElement droppedElement = selection.First() as GraphElement; // Remove the current preview with no animation RemovePreview(false); if (m_CurrentInsertIndex != -1) { // Notify the model that an element should be inserted at the specified index if (graphView != null && graphView.elementInsertedToStackNode != null) { graphView.elementInsertedToStackNode(this, m_CurrentInsertIndex, droppedElement); } else { InsertElement(m_CurrentInsertIndex, droppedElement); } } dragEntered = false; return(true); }
private static VisualElement DefaultDropPreviewTemplate(GraphElement source) { VisualElement preview = new VisualElement(); preview.AddToClassList("default"); return(preview); }
private void OnSubElementDetachedFromPanel(DetachFromPanelEvent evt) { if (base.panel != null) { GraphElement element = evt.target as GraphElement; this.RemoveElement(element); } }
protected override void OnElementAdded(GraphElement element) { GraphView gv = GetFirstAncestorOfType <GraphView>(); if (gv != null && gv.elementAddedToGroup != null) { gv.elementAddedToGroup(this, element); } }
private VisualElement CreateDropPreview(GraphElement element) { VisualElement preview = dropPreviewTemplate(element); preview.Add(new Label(element.title)); preview.AddToClassList(k_PreviewClass); preview.style.positionType = PositionType.Relative; return(preview); }
public virtual bool AcceptsElement(GraphElement element, ref string reasonWhyNotAccepted) { if (element.GetType() == typeof(Scope)) { reasonWhyNotAccepted = "Nested scope is not supported yet."; return(false); } return(true); }
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); contentViewContainer.Dirty(ChangeType.Repaint); }
public void RemoveElement(GraphElement graphElement) { // TODO : Find a better way to remove a graphElement from its scope when it is removed from the GraphView. Scope scope = graphElement.GetContainingScope(); if (scope != null) { scope.RemoveElement(graphElement); } graphElement.RemoveFromHierarchy(); }
private void OnChildDetachedFromPanel(DetachFromPanelEvent evt) { if (panel == null) { return; } GraphElement element = evt.target as GraphElement; OnChildRemoved(element); }
void OnSubElementDetachedFromPanel(DetachFromPanelEvent evt) { // Do nothing if the group is not in a panel if (panel == null) { return; } GraphElement element = evt.target as GraphElement; RemoveElement(element); }
protected new void OnMouseMove(MouseMoveEvent e) { if (!base.target.HasMouseCapture()) { this.m_PrevDropTarget = null; this.m_Active = false; } if (this.m_Active) { if (this.m_GraphView != null) { VisualElement src = (VisualElement)e.target; Vector2 mousePos = src.ChangeCoordinatesTo(this.m_GraphView.contentContainer, e.localMousePosition); this.m_PanDiff = this.GetEffectivePanSpeed(mousePos); if (this.m_PanDiff != Vector3.zero) { this.m_PanSchedule.Resume(); } else { this.m_PanSchedule.Pause(); } this.m_MouseDiff = this.m_originalMouse - e.mousePosition; foreach (KeyValuePair <GraphElement, Rect> current in this.m_OriginalPos) { GraphElement key = current.Key; Matrix4x4 worldTransform = key.worldTransform; Vector3 vector = new Vector3(worldTransform.m00, worldTransform.m11, worldTransform.m22); Rect position = key.GetPosition(); key.SetPosition(new Rect(current.Value.x - (this.m_MouseDiff.x - this.m_ItemPanDiff.x) * base.panSpeed.x / vector.x, current.Value.y - (this.m_MouseDiff.y - this.m_ItemPanDiff.y) * base.panSpeed.y / vector.y, position.width, position.height)); } List <ISelectable> selection = this.m_GraphView.selection; IDropTarget dropTargetAt = this.GetDropTargetAt(e.localMousePosition); if (this.m_PrevDropTarget != dropTargetAt && this.m_PrevDropTarget != null) { using (IMGUIEvent pooled = IMGUIEvent.GetPooled(e.imguiEvent)) { pooled.imguiEvent.type = EventType.DragExited; this.SendDragAndDropEvent(pooled, selection, this.m_PrevDropTarget); } } using (IMGUIEvent pooled2 = IMGUIEvent.GetPooled(e.imguiEvent)) { pooled2.imguiEvent.type = EventType.DragUpdated; this.SendDragAndDropEvent(pooled2, selection, dropTargetAt); } this.m_PrevDropTarget = dropTargetAt; this.selectedElement = null; e.StopPropagation(); } } }
void MoveElement(GraphElement element, Rect originalPos) { Matrix4x4 g = element.worldTransform; var scale = new Vector3(g.m00, g.m11, g.m22); Rect newPost = new Rect(0, 0, originalPos.width, originalPos.height); // Compute the new position of the selected element using the mouse delta position and panning info newPost.x = originalPos.x - (m_MouseDiff.x - m_ItemPanDiff.x) * panSpeed.x / scale.x * element.transform.scale.x; newPost.y = originalPos.y - (m_MouseDiff.y - m_ItemPanDiff.y) * panSpeed.y / scale.y * element.transform.scale.y; element.SetPosition(m_GraphView.contentViewContainer.ChangeCoordinatesTo(element.shadow.parent, newPost)); }
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 static void Reload(this GraphElement element) { var evt = new Event() { type = EventType.ExecuteCommand, commandName = UdonGraphCommands.Reload }; using (var e = ExecuteCommandEvent.GetPooled(evt)) { element.SendEvent(e); } }