void PopupClick(MouseUpEvent mouseEvent)
{
var filter = config.filter;
if (filter.OnlyGetType && filter.CanManipulateArray())
{
TypeSelectorWindow.ShowWindow(Vector2.zero, filter, delegate(MemberData[] types) {
uNodeEditorUtility.RegisterUndo(config.owner.targetNode);
member.CopyFrom(types[0]);
config.OnValueChanged(member);
config.owner.OnValueChanged();
UpdateControl();
config.owner.MarkRepaint();
}, new TypeItem[1] {
member
}).ChangePosition(GUIUtility.GUIToScreenPoint(mouseEvent.mousePosition)).targetObject = config.owner.targetNode;
}
else
{
ItemSelector.ShowWindow(config.owner.targetNode, member, filter, (m) => {
m.ResetCache();
config.OnValueChanged(member);
config.owner.OnValueChanged();
UpdateControl();
config.owner.MarkRepaint();
}).ChangePosition(GUIUtility.GUIToScreenPoint(mouseEvent.mousePosition));
}
}
public static TypeSelectorWindow ShowAsNew(Rect rect,
FilterAttribute filter,
Action <MemberData[]> selectCallback,
params TypeItem[] targetType)
{
TypeSelectorWindow window = CreateInstance(typeof(TypeSelectorWindow)) as TypeSelectorWindow;
window.targetType = targetType;
window.filter = filter;
window.selectCallback = selectCallback;
window.Init(rect);
return(window);
}
void OnClick(MouseUpEvent mouseDownEvent)
{
var val = config.value;
var mPos = mouseDownEvent.mousePosition;
if (UnityEditor.EditorWindow.focusedWindow != null)
{
mPos = (mouseDownEvent.currentTarget as VisualElement).GetScreenMousePosition(
mouseDownEvent.localMousePosition,
UnityEditor.EditorWindow.focusedWindow);
}
if (config.filter.OnlyGetType)
{
if (config.filter.CanManipulateArray())
{
TypeSelectorWindow.ShowWindow(Vector2.zero, config.filter, delegate(MemberData[] types) {
config.value = types[0];
config.OnValueChanged(config.value);
config.owner.OnValueChanged();
config.owner.MarkRepaint();
}, new TypeItem[1] {
val as MemberData
}).ChangePosition(mPos);
}
else
{
ItemSelector.ShowWindow(null, val as MemberData, config.filter, (m) => {
config.value = m;
config.OnValueChanged(m);
config.owner.OnValueChanged();
config.owner.MarkRepaint();
}).ChangePosition(mPos);
}
}
else
{
ActionPopupWindow.ShowWindow(Vector2.zero, () => {
uNodeGUIUtility.EditValueLayouted(GUIContent.none, val, config.type, (obj) => {
config.owner.RegisterUndo();
val = obj;
config.OnValueChanged(obj);
config.owner.MarkRepaint();
}, new uNodeUtility.EditValueSettings()
{
attributes = new object[] { config.filter },
unityObject = config.owner.targetNode
});
}, 300, 300).ChangePosition(mPos);
}
}
public static TypeSelectorWindow ShowWindow(Vector2 pos,
FilterAttribute filter,
Action <MemberData[]> selectCallback,
params TypeItem[] targetType)
{
if (window == null)
{
window = CreateInstance(typeof(TypeSelectorWindow)) as TypeSelectorWindow;
}
window.targetType = targetType;
window.filter = filter;
window.Init(pos);
window.selectCallback = selectCallback;
return(window);
}
public void ShowNodeMenu(Vector2 position, FilterAttribute filter = null, Action <Node> onAddNode = null, bool flowNodes = true)
{
var valueMenuPos = GetMenuPosition();
if (filter == null)
{
filter = new FilterAttribute();
//filter.CanSelectType = true;
//filter.HideTypes.Add(typeof(void));
}
else
{
filter = new FilterAttribute(filter);
}
filter.DisplayInstanceOnStatic = true;
filter.MaxMethodParam = int.MaxValue;
filter.Public = true;
filter.Instance = true;
if (flowNodes)
{
filter.VoidType = true;
}
ItemSelector w = ItemSelector.ShowWindow(editorData.selectedGroup ?? editorData.selectedRoot as UnityEngine.Object ?? editorData.graph, new MemberData(editorData.selectedGroup ?? editorData.selectedRoot as UnityEngine.Object ?? editorData.graph, MemberData.TargetType.SelfTarget), filter, delegate(MemberData value) {
NodeEditorUtility.AddNewNode <MultipurposeNode>(editorData, null, null, position, delegate(MultipurposeNode n) {
if (n.target == null)
{
n.target = new MultipurposeMember();
}
n.target.target = value;
MemberDataUtility.UpdateMultipurposeMember(n.target);
if (onAddNode != null)
{
onAddNode(n);
}
Refresh();
});
}).ChangePosition(valueMenuPos);
w.displayNoneOption = false;
w.displayCustomVariable = false;
if (filter.SetMember)
{
return; //Return on set member is true.
}
List <ItemSelector.CustomItem> customItems = new List <ItemSelector.CustomItem>();
foreach (NodeMenu menuItem in NodeEditorUtility.FindNodeMenu())
{
if (filter.OnlyGetType && menuItem.type != typeof(Type))
{
continue;
}
bool isFlowNode = !menuItem.type.IsSubclassOf(typeof(ValueNode));
if (editorData.selectedRoot && menuItem.HideOnFlow || !flowNodes && isFlowNode)
{
continue;
}
if (isFlowNode && filter.SetMember || !filter.IsValidTarget(MemberData.TargetType.FlowNode))
{
continue;
}
if (!isFlowNode && !filter.IsValidTarget(MemberData.TargetType.ValueNode))
{
continue;
}
if (editorData.selectedGroup && (menuItem.HideOnGroup))
{
continue;
}
if (menuItem.HideOnStateMachine && !editorData.selectedRoot && !editorData.selectedGroup)
{
continue;
}
if (menuItem.returnType != null && menuItem.returnType != typeof(object) && !filter.IsValidType(menuItem.returnType))
{
continue;
}
if (menuItem.IsCoroutine && !editorData.supportCoroutine)
{
continue;
}
customItems.Add(new ItemSelector.CustomItem(menuItem.name, delegate() {
NodeEditorUtility.AddNewNode <Node>(editorData, menuItem.name.Split(' ')[0], menuItem.type, position, onAddNode);
Refresh();
}, menuItem.category.Replace("/", "."))
{
icon = isFlowNode ? uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.FlowIcon)) : null,
tooltip = new GUIContent(menuItem.tooltip),
});
}
#region Flow
if (flowNodes && !filter.SetMember && filter.IsValidType(typeof(void)))
{
if (!(!editorData.selectedRoot && !editorData.selectedGroup))
{
customItems.Add(new ItemSelector.CustomItem("Continue", delegate() {
NodeEditorUtility.AddNewNode <NodeJumpStatement>(
editorData,
"Continue",
position,
delegate(NodeJumpStatement n) {
n.statementType = JumpStatementType.Continue;
});
Refresh();
}, "JumpStatement")
{
icon = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.FlowIcon)),
});
customItems.Add(new ItemSelector.CustomItem("Break", delegate() {
NodeEditorUtility.AddNewNode <NodeJumpStatement>(
editorData,
"Break",
position,
delegate(NodeJumpStatement n) {
n.statementType = JumpStatementType.Break;
});
Refresh();
}, "JumpStatement")
{
icon = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.FlowIcon)),
});
}
if (editorData.selectedRoot)
{
customItems.Add(new ItemSelector.CustomItem("Return", delegate() {
NodeEditorUtility.AddNewNode <NodeReturn>(
editorData,
"Return",
position,
delegate(NodeReturn n) {
});
Refresh();
}, "Return")
{
icon = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.FlowIcon)),
});
}
}
#endregion
if (filter.IsValidTarget(MemberData.TargetType.ValueNode))
{
if (filter.IsValidType(typeof(Type)))
{
customItems.Add(new ItemSelector.CustomItem("typeof()", delegate() {
var win = TypeSelectorWindow.ShowWindow(Vector2.zero, new FilterAttribute()
{
OnlyGetType = true, DisplayRuntimeType = false
}, delegate(MemberData[] types) {
NodeEditorUtility.AddNewNode <MultipurposeNode>(
editorData,
position,
delegate(MultipurposeNode n) {
if (n.target == null)
{
n.target = new MultipurposeMember();
}
n.target.target = types[0];
if (onAddNode != null)
{
onAddNode(n);
}
Refresh();
});
});
win.targetObject = editorData.selectedGroup ?? editorData.selectedRoot as UnityEngine.Object ?? editorData.graph;
win.ChangePosition(valueMenuPos);
}, "Data"));
}
var nodeMenuItems = NodeEditorUtility.FindCreateNodeCommands();
foreach (var n in nodeMenuItems)
{
n.graph = this;
n.filter = filter;
if (!n.IsValid())
{
continue;
}
customItems.Add(new ItemSelector.CustomItem(n.name, () => {
var createdNode = n.Setup(position);
if (onAddNode != null)
{
onAddNode(createdNode);
}
}, n.category)
{
icon = uNodeEditorUtility.GetTypeIcon(n.icon),
});
}
}
w.customItems = customItems;
}
private void BuildContextualMenu(ContextualMenuPopulateEvent evt)
{
if (config.type != null)
{
if (config.filter == null || !config.filter.SetMember && config.filter.IsValidTarget(MemberData.TargetType.Values))
{
evt.menu.AppendAction("To Default", (e) => {
if (config.type == typeof(Type))
{
member = new MemberData(typeof(object));
}
else if (config.type is RuntimeType)
{
member = MemberData.CreateFromValue(null, config.type);
}
else
{
member = new MemberData(ReflectionUtils.CanCreateInstance(config.type) ? ReflectionUtils.CreateInstance(config.type) : null)
{
startType = config.type,
targetTypeName = config.type.FullName,
};
}
config.OnValueChanged(member);
config.owner.OnValueChanged();
config.owner.MarkRepaint();
UpdateControl();
uNodeEditor.GUIChanged();
}, DropdownMenuAction.AlwaysEnabled);
if (config.type == typeof(object))
{
var types = EditorReflectionUtility.GetCommonType();
foreach (var t in types)
{
evt.menu.AppendAction("To Value/" + t.PrettyName(), (e) => {
member = new MemberData(ReflectionUtils.CanCreateInstance(t) ? ReflectionUtils.CreateInstance(t) : null)
{
startType = t,
targetTypeName = t.FullName,
};
config.OnValueChanged(member);
config.owner.OnValueChanged();
config.owner.MarkRepaint();
UpdateControl();
uNodeEditor.GUIChanged();
}, DropdownMenuAction.AlwaysEnabled);
}
}
else if (config.type == typeof(Type))
{
var mPos = NodeGraph.openedGraph.GetMousePosition();
evt.menu.AppendAction("Change Type", (e) => {
TypeSelectorWindow.ShowWindow(mPos, new FilterAttribute()
{
OnlyGetType = true
},
delegate(MemberData[] types) {
uNodeEditorUtility.RegisterUndo(config.owner.targetNode);
member.CopyFrom(types[0]);
config.OnValueChanged(member);
config.owner.OnValueChanged();
config.owner.MarkRepaint();
UpdateControl();
uNodeEditor.GUIChanged();
}, new TypeItem[1] {
member
}).targetObject = config.owner.targetNode;
}, DropdownMenuAction.AlwaysEnabled);
}
if (!config.type.IsValueType)
{
evt.menu.AppendAction("To Null", (e) => {
uNodeEditorUtility.RegisterUndo(config.owner.targetNode);
member.CopyFrom(MemberData.Null);
config.OnValueChanged(member);
config.owner.OnValueChanged();
config.owner.MarkRepaint();
UpdateControl();
uNodeEditor.GUIChanged();
}, DropdownMenuAction.AlwaysEnabled);
}
}
}
}
private void OnEnable()
{
window = this;
}
private void OnDisable()
{
window = null;
}
