protected internal override void ExecuteDefaultActionAtTarget(EventBase evt)
{
base.ExecuteDefaultActionAtTarget(evt);
if ((evt as MouseDownEvent)?.button == (int)MouseButton.LeftMouse)
{
OnMouseDown(evt as MouseDownEvent);
}
else if ((evt as KeyDownEvent)?.character == '\n')
{
OnKeyboardEnter();
}
else if (evt.GetEventTypeId() == DragUpdatedEvent.TypeId())
{
OnDragUpdated(evt);
}
else if (evt.GetEventTypeId() == DragPerformEvent.TypeId())
{
OnDragPerform(evt);
}
else if (evt.GetEventTypeId() == DragLeaveEvent.TypeId())
{
OnDragLeave();
}
}
public virtual bool DragPerform(DragPerformEvent evt, IEnumerable <ISelectable> selection, IDropTarget dropTarget, ISelection dragSource)
{
HandleDragAndDropEvent(evt);
// 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.elementsInsertedToStackNode != null)
{
graphView.elementsInsertedToStackNode(this, m_CurrentInsertIndex, m_DraggedElements);
}
int cnt = 0;
foreach (GraphElement draggedElement in m_DraggedElements)
{
InsertElement(m_CurrentInsertIndex + cnt++, draggedElement);
}
}
dragEntered = false;
m_DraggedElements = null;
return(true);
}
private void OnDragPerformEvent(DragPerformEvent e)
{
var scripts = DragAndDrop.objectReferences.OfType <MonoScript>();
foreach (var script in scripts)
{
var scriptClass = script.GetClass();
var match = _namespaceRegex.Match(script.text);
var namespaceName = (match.Success ? match.Groups[2].Value : "").Trim();
var type = typeof(IComponentData);
var types = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(s => s.GetTypes())
.Where(p => type.IsAssignableFrom(p)).ToList();
var dropedType = types.FirstOrDefault(t => t.Name == script.name && t.Namespace == namespaceName);
if (dropedType != null)
{
Debug.Log(dropedType.FullName);
}
else
{
Debug.Log("Can not find");
}
}
DragAndDrop.AcceptDrag();
}
/// <inheritdoc />
public override void OnDragPerform(DragPerformEvent e)
{
var dropElements = DragSource.GetSelection();
var contentViewContainer = (e.target as GraphView)?.ContentViewContainer ?? e.target as VisualElement;
var variablesToCreate = dropElements
.OfType <IVariableDeclarationModel>()
.Select((e1, i) => (
e1,
GUID.Generate().ToSerializableGUID(),
contentViewContainer.WorldToLocal(e.mousePosition) + i * DragDropSpacer * Vector2.down))
.ToList();
var droppedNodes = dropElements.OfType <INodeModel>();
if (droppedNodes.Any(e2 => !(e2 is IVariableNodeModel)) && variablesToCreate.Any())
{
// no way to handle this ATM
throw new ArgumentException("Unhandled case, dropping blackboard/variables fields and nodes at the same time");
}
if (variablesToCreate.Any())
{
Stencil.OnDragAndDropVariableDeclarations(Dispatcher, variablesToCreate);
}
}
void OnDragPerformEvent(DragPerformEvent e)
{
Vector2 localPos = (e.currentTarget as VisualElement).ChangeCoordinatesTo(contentViewContainer, e.localMousePosition);
var selection = DragAndDrop.GetGenericData("DragSelection") as List <ISelectable>;
if (selection != null)
{
// Blackboard
if (selection.OfType <BlackboardField>().Any())
{
IEnumerable <BlackboardField> fields = selection.OfType <BlackboardField>();
foreach (BlackboardField field in fields)
{
CreateNode(field, localPos);
}
}
}
else
{
// Handle unity objects
var objects = DragAndDrop.objectReferences;
foreach (Object obj in objects)
{
if (ValidateObjectForDrop(obj))
{
CreateNode(obj, localPos);
}
}
}
}
void OnDragPerformEvent(DragPerformEvent e)
{
SetDragIndicatorVisible(false);
var selection = DragAndDrop.GetGenericData("DragSelection") as List<ISelectable>;
if (selection == null)
{
return;
}
var category = selection.OfType<VFXBlackboardCategory>().FirstOrDefault();
if (category == null)
{
return;
}
if (m_InsertIndex != -1)
{
if (m_InsertIndex > IndexOf(category))
--m_InsertIndex;
controller.MoveCategory(category.title, m_InsertIndex - IndexOf(m_DefaultCategory) - 1);
}
SetDragIndicatorVisible(false);
e.StopPropagation();
}
void OnDragPerformEvent(DragPerformEvent e)
{
DragAndDrop.AcceptDrag();
object draggedObject = DragAndDrop.GetGenericData(DraggableLabel.s_DragDataType);
if (draggedObject != null && draggedObject is DraggableLabel)
{
var label = (DraggableLabel)draggedObject;
label.StopDraggingBox(e.localMousePosition);
}
else
{
List <string> names = new List <string>();
if (draggedObject != null)
{
names.Add(draggedObject.ToString());
}
foreach (var obj in DragAndDrop.objectReferences)
{
names.Add(obj.name);
}
var newBox = new DraggableLabel();
newBox.AddToClassList("box");
newBox.style.top = e.localMousePosition.y;
newBox.style.left = e.localMousePosition.x;
newBox.text = String.Join(", ", names);
m_DropArea.Add(newBox);
}
}
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 void OnDragPerformEvent(DragPerformEvent evt)
{
var selection = DragAndDrop.GetGenericData("DragSelection") as List <ISelectable>;
if (selection == null)
{
SetDragIndicatorVisible(false);
return;
}
if (selection.OfType <VFXBlackboardCategory>().Any())
{
return;
}
if (m_InsertIndex != -1)
{
var parent = GetFirstAncestorOfType <VFXBlackboard>();
if (parent != null)
{
parent.OnMoveParameter(selection.OfType <VisualElement>().Select(t => t.GetFirstOfType <VFXBlackboardRow>()).Where(t => t != null), this, m_InsertIndex);
}
SetDragIndicatorVisible(false);
evt.StopPropagation();
m_InsertIndex = -1;
}
}
void OnDragPerform(DragPerformEvent evt)
{
var gameObject = DragAndDrop.objectReferences.OfType <GameObject>().Single();
var template = new DropGameObjectEcsTemplate(gameObject, this.WorldToLocal(evt.mousePosition));
template.PromptToCreate(m_Store);
}
void OnDragPerform(DragPerformEvent e)
{
var stencil = Store.GetState().CurrentGraphModel.Stencil;
var dragNDropHandler = stencil.DragNDropHandler;
dragNDropHandler?.HandleDragPerform(e, Store, DragNDropContext.Blackboard, this);
e.StopPropagation();
}
private void OnDragPerformEvent(DragPerformEvent evt)
{
m_CanStartDrag = false;
OnDrop(evt.mousePosition);
ClearDragAndDropUI();
DragAndDropUtility.dragAndDrop.AcceptDrag();
}
private void OnDragPerformEvent(DragPerformEvent evt)
{
if (onDragPerform != null)
{
onDragPerform(evt);
evt.StopImmediatePropagation();
}
}
void OnDragPerform(DragPerformEvent evt)
{
var targets = DragAndDrop.objectReferences.OfType <GameObject>().ToList();
var target = targets.FirstOrDefault(t => t.GetComponent <Animator>() != null);
if (target != null && target != value)
{
OnPreviewTargetClicked(target);
}
}
private void OnDragPerformEvent(DragPerformEvent e)
{
var selection = DragAndDrop.GetGenericData("DragSelection") as List <ISelectable>;
if (selection == null)
{
return;
}
IEnumerable <BlackboardField> fields = selection.OfType <BlackboardField>();
if (!fields.Any())
{
return;
}
Vector2 localPos = (e.currentTarget as VisualElement).ChangeCoordinatesTo(m_GraphView.contentViewContainer, e.localMousePosition);
foreach (BlackboardField field in fields)
{
MathBookField bookField = field.userData as MathBookField;
if (bookField == null)
{
continue;
}
MathNode fieldNode = null;
if (bookField.direction == MathBookField.Direction.Input)
{
var varFieldNode = ScriptableObject.CreateInstance <MathBookInputNode>();
varFieldNode.fieldName = bookField.name;
fieldNode = varFieldNode;
}
else
{
var resFieldNode = ScriptableObject.CreateInstance <MathBookOutputNode>();
resFieldNode.fieldName = bookField.name;
fieldNode = resFieldNode;
}
fieldNode.m_Position = localPos;
m_GraphView.window.AddNode(fieldNode);
var visualNode = m_GraphView.window.CreateNode(fieldNode) as Node;
m_GraphView.AddElement(visualNode);
localPos += new Vector2(0, 25);
}
}
// In order for tests to run without an EditorWindow but still be able to send
// events, we sometimes need to force the event type. IMGUI::GetEventType() (native) will
// return the event type as Ignore if the proper views haven't yet been
// initialized. This (falsely) breaks tests that rely on the event type. So for tests, we
// just ensure the event type is what we originally set it to when we sent it.
internal static EventBase CreateEvent(Event systemEvent, EventType eventType)
{
switch (eventType)
{
case EventType.MouseMove:
return(MouseMoveEvent.GetPooled(systemEvent));
case EventType.MouseDrag:
return(MouseMoveEvent.GetPooled(systemEvent));
case EventType.MouseDown:
return(MouseDownEvent.GetPooled(systemEvent));
case EventType.MouseUp:
return(MouseUpEvent.GetPooled(systemEvent));
case EventType.ContextClick:
return(ContextClickEvent.GetPooled(systemEvent));
case EventType.MouseEnterWindow:
return(MouseEnterWindowEvent.GetPooled(systemEvent));
case EventType.MouseLeaveWindow:
return(MouseLeaveWindowEvent.GetPooled(systemEvent));
case EventType.ScrollWheel:
return(WheelEvent.GetPooled(systemEvent));
case EventType.KeyDown:
return(KeyDownEvent.GetPooled(systemEvent));
case EventType.KeyUp:
return(KeyUpEvent.GetPooled(systemEvent));
case EventType.DragUpdated:
return(DragUpdatedEvent.GetPooled(systemEvent));
case EventType.DragPerform:
return(DragPerformEvent.GetPooled(systemEvent));
case EventType.DragExited:
return(DragExitedEvent.GetPooled(systemEvent));
case EventType.ValidateCommand:
return(ValidateCommandEvent.GetPooled(systemEvent));
case EventType.ExecuteCommand:
return(ExecuteCommandEvent.GetPooled(systemEvent));
default: // Layout, Ignore, Used
return(IMGUIEvent.GetPooled(systemEvent));
}
}
public void HandleDragPerform(DragPerformEvent e, Store store, DragNDropContext ctx, VisualElement element)
{
var state = store.GetState();
if (state?.CurrentGraphModel == null)
{
return;
}
DotsStencil stencil = (DotsStencil)state.CurrentGraphModel.Stencil;
if (stencil.Type == DotsStencil.GraphType.Subgraph)
{
Debug.LogError("Cannot create object references in a subgraph. Create a Data Input of type Game Object instead and feed it from an object graph in the scene.");
return;
}
if (!(state?.EditorDataModel?.BoundObject as UnityEngine.Object))
{
Debug.LogError("Cannot create object references when a graph is opened in asset mode. Select a game object referencing this graph to do that.");
return;
}
Vector2 graphSpacePosition = element.WorldToLocal(e.mousePosition);
if (DragAndDrop.objectReferences.OfType <VSGraphAssetModel>().Any())
{
if (!DragAndDrop.objectReferences.All(x => x is VSGraphAssetModel assetModel && assetModel.GraphModel?.Stencil is DotsStencil dotsStencil && dotsStencil.Type == DotsStencil.GraphType.Subgraph))
{
Debug.LogError("Object graph references must be created from their Game Object in the scene hierarchy. Only subgraphs can be referenced using their asset");
return;
}
store.Dispatch(new CreateObjectReferenceAction(graphSpacePosition, state?.CurrentGraphModel, DragAndDrop.objectReferences, CreateObjectReferenceAction.ReferenceType.Subgraph));
return;
}
if (!DragAndDrop.objectReferences.Any(x => x is GameObject go && go.GetComponent <ScriptingGraphAuthoring>()))
{
store.Dispatch(new CreateObjectReferenceAction(graphSpacePosition, state?.CurrentGraphModel, DragAndDrop.objectReferences, CreateObjectReferenceAction.ReferenceType.Object));
return;
}
var menu = new GenericMenu();
menu.AddItem(new GUIContent("Object Reference"), false, () =>
{
store.Dispatch(new CreateObjectReferenceAction(graphSpacePosition, state?.CurrentGraphModel, DragAndDrop.objectReferences, CreateObjectReferenceAction.ReferenceType.Object));
});
menu.AddItem(new GUIContent("Smart Object"), false, () =>
{
store.Dispatch(new CreateObjectReferenceAction(graphSpacePosition, state?.CurrentGraphModel, DragAndDrop.objectReferences, CreateObjectReferenceAction.ReferenceType.ObjectGraph));
});
menu.DropDown(new Rect(e.originalMousePosition, Vector2.zero));
}
protected void OnDragPerformEvent(DragPerformEvent evt)
{
var selection = DragAndDrop.GetGenericData("DragSelection") as List <IGraphElementModel>;
if (selection != null && CanAcceptDrop(selection) && m_InsertIndex != -1)
{
OnItemDropped(m_InsertIndex, selection);
}
HideDragIndicator();
evt.StopPropagation();
}
private static void OnDragPerform(DragPerformEvent evt)
{
if (evt.target is IDragReceiver receiver)
{
var objects = DragAndDrop.objectReferences;
var data = DragAndDrop.GetGenericData(_dragData);
if (receiver.IsDragValid(objects, data))
{
DragAndDrop.AcceptDrag();
receiver.AcceptDrag(objects, data);
}
}
}
void OnDragPerform(DragPerformEvent evt)
{
RemoveDragIndicator();
if (DragAndDrop.GetGenericData("DragSelection") != null)
{
Vector2 mousePosition = m_BlockContainer.WorldToLocal(evt.mousePosition);
IEnumerable <VFXBlockUI> blocksUI = (DragAndDrop.GetGenericData("DragSelection") as List <ISelectable>).Select(t => t as VFXBlockUI).Where(t => t != null);
if (!CanDrop(blocksUI))
{
return;
}
int blockIndex = GetDragBlockIndex(mousePosition);
BlocksDropped(blockIndex, blocksUI, evt.ctrlKey);
DragAndDrop.AcceptDrag();
m_DragStarted = false;
RemoveFromClassList("dropping");
}
else
{
var references = DragAndDrop.objectReferences.OfType <VisualEffectSubgraphBlock>();
if (references.Count() > 0 && (!controller.viewController.model.isSubgraph || !references.Any(t => t.GetResource().GetOrCreateGraph().subgraphDependencies.Contains(controller.viewController.model.subgraph) || t.GetResource() == controller.viewController.model)))
{
var context = references.First().GetResource().GetOrCreateGraph().children.OfType <VFXBlockSubgraphContext>().FirstOrDefault();
if (context != null && (context.compatibleContextType & controller.model.contextType) == controller.model.contextType)
{
DragAndDrop.AcceptDrag();
Vector2 mousePosition = m_BlockContainer.WorldToLocal(evt.mousePosition);
int blockIndex = GetDragBlockIndex(mousePosition);
VFXBlock newModel = ScriptableObject.CreateInstance <VFXSubgraphBlock>();
newModel.SetSettingValue("m_Subgraph", references.First());
controller.AddBlock(blockIndex, newModel);
}
evt.StopPropagation();
}
}
m_DragStarted = false;
RemoveFromClassList("dropping");
}
public void HandleDragPerform(DragPerformEvent e, Store store, DragNDropContext ctx, VisualElement element)
{
var gameObject = DragAndDrop.objectReferences.OfType <GameObject>().Single();
switch (ctx)
{
case DragNDropContext.Blackboard:
store.Dispatch(new CreateComponentQueryFromGameObjectAction(gameObject));
break;
case DragNDropContext.Graph:
store.Dispatch(new CreateQueryAndElementFromGameObjectAction(gameObject, element.WorldToLocal(e.mousePosition)));
break;
}
}
protected virtual void OnDragPerformEvent(DragPerformEvent evt)
{
var tree = m_DropTree;
RemoveDragIndicator();
if (tree == null)
{
return;
}
object dragData = DragAndDrop.GetGenericData("uNode");
if (dragData == null && DragAndDrop.objectReferences.Length > 0)
{
dragData = DragAndDrop.objectReferences[0];
}
AcceptDrop(tree, dragData);
DragAndDrop.SetGenericData("uNode", null);
}
protected override void OnDragPerformEvent(DragPerformEvent evt)
{
if (!(DragAndDrop.GetGenericData("DragSelection") is GraphElement selectedElement) || !AcceptDrop(selectedElement))
{
m_ParentElement.SetDragIndicatorVisible(false);
evt.StopImmediatePropagation();
return;
}
if (selectedElement is CriteriaModelRow criteriaModelRow)
{
criteriaModelRow.DuplicateRow(criteriaModelRow, this, insertAtEnd: true);
evt.StopImmediatePropagation();
return;
}
base.OnDragPerformEvent(evt);
}
public bool DragPerform(DragPerformEvent evt, IEnumerable <ISelectable> selection, IDropTarget dropTarget, ISelection dragSource)
{
Group group = parent.GetFirstAncestorOfType <Group>();
List <GraphElement> elemsToAdd =
selection
.Cast <GraphElement>()
.Where(e => e != group && !group.containedElements.Contains(e) && !(e.GetContainingScope() is Group) && e.IsGroupable())
.ToList(); // ToList required here as the enumeration might be done again *after* the elements are added to the group
if (elemsToAdd.Any())
{
group.AddElements(elemsToAdd);
}
RemoveFromClassList("dragEntered");
return(true);
}
private void OnDragPerform(DragPerformEvent evt)
{
droppedObject = DragAndDrop.objectReferences[0];
var draggedName = "";
if (assetPath != string.Empty)
{
var splitPath = assetPath.Split('/');
draggedName = splitPath[splitPath.Length - 1];
}
else
{
draggedName = droppedObject.name;
}
dropLabel.text = $"Containing '{draggedName}'...\n\n" +
$"(You can also drag from here)";
dropArea.RemoveFromClassList("drop-area--dropping");
}
void OnDragPerform(DragPerformEvent evt)
{
if (EditorApplication.isPlaying)
{
return;
}
var clips = DragAndDrop.objectReferences.OfType <AnimationClip>().ToList();
var taggedClips = TaggedAnimationClip.BuildFromClips(clips, m_Window.Asset, ETagImportOption.AddDefaultTag);
if (taggedClips.Any())
{
if (m_Window.Asset != null)
{
m_Window.Asset.AddClips(taggedClips);
Refresh();
}
}
}
private void OnDragPerformed(DragPerformEvent evt)
{
Vector2 localPos = (evt.currentTarget as VisualElement).ChangeCoordinatesTo(this.contentViewContainer, evt.localMousePosition);
var selection = DragAndDrop.GetGenericData("DragSelection") as List <ISelectable>;
if (selection != null)
{
// Blackboard
if (selection.OfType <BlackboardField>().Any())
{
var fields = selection.OfType <BlackboardField>();
foreach (var field in fields)
{
CreateNode(field, localPos);
}
}
}
}
void OnDragPerformEvent(DragPerformEvent evt)
{
var updateList = false;
var newIndex = GetInsertIndexFromMousePosition(evt.mousePosition);
foreach (var obj in (List <ISelectable>)DragAndDrop.GetGenericData("DragSelection"))
{
if (!(obj is UniExposedParameterFieldView view))
{
continue;
}
if (!updateList)
{
graphView.RegisterCompleteObjectUndo("Moved parameters");
}
var parameters = graphAsset.uniExposedParameters;
var oldIndex = parameters.FindIndex(e => e == view.parameter);
var parameter = parameters[oldIndex];
parameters.RemoveAt(oldIndex);
// Patch new index after the remove operation:
if (newIndex > oldIndex)
{
newIndex--;
}
parameter.Apply(graphAsset);
updateList = true;
}
if (!updateList)
{
return;
}
evt.StopImmediatePropagation();
UpdateParameterList();
}
protected override void ExecuteDefaultActionAtTarget(EventBase evt)
{
base.ExecuteDefaultActionAtTarget(evt);
if (evt == null)
{
return;
}
if ((evt as MouseDownEvent)?.button == (int)MouseButton.LeftMouse)
{
OnMouseDown(evt as MouseDownEvent);
}
else if (evt.eventTypeId == KeyDownEvent.TypeId())
{
var kdEvt = evt as KeyDownEvent;
if (((evt as KeyDownEvent)?.keyCode == KeyCode.Space) ||
((evt as KeyDownEvent)?.keyCode == KeyCode.KeypadEnter) ||
((evt as KeyDownEvent)?.keyCode == KeyCode.Return))
{
OnKeyboardEnter();
}
else if (kdEvt.keyCode == KeyCode.Delete ||
kdEvt.keyCode == KeyCode.Backspace)
{
OnKeyboardDelete();
}
}
else if (evt.eventTypeId == DragUpdatedEvent.TypeId())
{
OnDragUpdated(evt);
}
else if (evt.eventTypeId == DragPerformEvent.TypeId())
{
OnDragPerform(evt);
}
else if (evt.eventTypeId == DragLeaveEvent.TypeId())
{
OnDragLeave();
}
}
void Drop(DragPerformEvent evt, Action <UnityEngine.Object, Vector2> OnDrop)
{
bool atLeastOneAccepted = false;
foreach (UnityEngine.Object obj in DragAndDrop.objectReferences)
{
if (!IsInAcceptedTypes(obj.GetType()))
{
continue;
}
OnDrop.Invoke(obj, evt.localMousePosition);
atLeastOneAccepted = true;
}
if (atLeastOneAccepted)
{
DragAndDrop.AcceptDrag();
evt.StopPropagation();
}
}
