public override void OnClick(Node source, PortCommandData data, Vector2 mousePosition)
{
if (source.owner)
{
Undo.SetCurrentGroupName("Promote to node");
Undo.RegisterFullObjectHierarchyUndo(source.owner, "Promote to node");
}
MemberData m = data.member;
if (data.portType != null && (!m.isAssigned || m.type == null))
{
if (ReflectionUtils.CanCreateInstance(data.portType))
{
m.CopyFrom(new MemberData(ReflectionUtils.CreateInstance(data.portType)));
}
else
{
m.CopyFrom(MemberData.CreateFromValue(null, data.portType));
}
}
NodeEditorUtility.AddNewNode <MultipurposeNode>(graph.editorData, null, null, new Vector2(source.editorRect.x - 100, source.editorRect.y), (node) => {
node.target.target = new MemberData(m);
MemberDataUtility.UpdateMultipurposeMember(node.target);
m.CopyFrom(new MemberData(node, MemberData.TargetType.ValueNode));
});
graph.Refresh();
}
public override void OnClick(Node source, Vector2 mousePosition)
{
FilterAttribute filter = new FilterAttribute();
filter.HideTypes.Add(typeof(void));
filter.MaxMethodParam = int.MaxValue;
filter.SetMember = true;
filter.Public = true;
filter.Instance = true;
filter.Static = false;
filter.DisplayDefaultStaticType = false;
var customItems = ItemSelector.MakeCustomItems(source.ReturnType(), filter, source.ReturnType().PrettyName());
if (customItems != null)
{
ItemSelector w = ItemSelector.ShowWindow(source, MemberData.none, filter, delegate(MemberData value) {
value.instance = new MemberData(source, MemberData.TargetType.ValueNode);
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (MultipurposeNode n) => {
if (n.target == null)
{
n.target = new MultipurposeMember();
}
n.target.target = value;
MemberDataUtility.UpdateMultipurposeMember(n.target);
NodeEditorUtility.AddNewNode(graph.editorData, null, null,
new Vector2(mousePositionOnCanvas.x + n.editorRect.width + 150, mousePositionOnCanvas.y),
(NodeSetValue SV) => {
SV.target = new MemberData(n, MemberData.TargetType.ValueNode);
});
});
graph.Refresh();
}, customItems).ChangePosition(GUIUtility.GUIToScreenPoint(mousePosition));
w.displayDefaultItem = false;
}
}
public static Events.Action onAddGetAction(MemberData member)
{
GetValue action = new GetValue();
action.target.target = member;
MemberDataUtility.UpdateMultipurposeMember(action.target);
return(action);
}
public static Condition onAddCompareValue(MemberData member)
{
MethodValidation cond = new MethodValidation();
cond.target.target = member;
MemberDataUtility.UpdateMultipurposeMember(cond.target);
return(cond);
}
public static Condition onAddIsComparer(MemberData member)
{
IsCompare cond = new IsCompare();
cond.target = new MultipurposeMember()
{
target = member
};
MemberDataUtility.UpdateMultipurposeMember(cond.target);
return(cond);
}
public MultipurposeMember(MemberData target, MemberData[] parameters)
{
this.target = new MemberData(target);
if (parameters != null)
{
this.parameters = new MemberData[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
this.parameters[i] = new MemberData(parameters[i]);
}
}
MemberDataUtility.UpdateMultipurposeMember(this);
}
public override void OnClick(Node source, PortCommandData data, Vector2 mousePosition)
{
if (source.owner)
{
Undo.SetCurrentGroupName("To value node");
Undo.RegisterFullObjectHierarchyUndo(source.owner, "To value node");
}
var member = data.member;
NodeEditorUtility.AddNewNode <MultipurposeNode>(graph.editorData, null, null, new Vector2(source.editorRect.x - 100, source.editorRect.y), (node) => {
node.target.target = MemberData.CreateFromValue(ReflectionUtils.CreateInstance(filter.Types[0]), filter.Types[0]);
MemberDataUtility.UpdateMultipurposeMember(node.target);
member.CopyFrom(MemberData.CreateConnection(node, false));
});
graph.Refresh();
}
public static Condition onAddEqualityComparer(MemberData member)
{
EqualityCompare cond = new EqualityCompare();
cond.target = new MultipurposeMember()
{
target = member
};
MemberDataUtility.UpdateMultipurposeMember(cond.target);
if (member.type != null && ReflectionUtils.CanCreateInstance(member.type))
{
cond.value = new MemberData(ReflectionUtils.CreateInstance(member.type));
}
else
{
cond.value = new MemberData(null, MemberData.TargetType.Values);
}
return(cond);
}
public override void OnClick(Node source, PortCommandData data, Vector2 mousePosition)
{
if (source.owner)
{
Undo.SetCurrentGroupName("Assign to contructor node");
Undo.RegisterFullObjectHierarchyUndo(source.owner, "Assign to contructor node");
}
var member = data.member;
NodeEditorUtility.AddNewNode <MultipurposeNode>(graph.editorData, null, null, new Vector2(source.editorRect.x - 100, source.editorRect.y), (node) => {
var type = filter.GetActualType();
var ctors = type.GetConstructors();
if (ctors != null && ctors.Length > 0)
{
System.Reflection.ConstructorInfo ctor = null;
foreach (var c in ctors)
{
if (ctor == null)
{
ctor = c;
}
else if (ctor.GetParameters().Length < c.GetParameters().Length)
{
ctor = c;
}
}
node.target.target = new MemberData(ctor);
}
else
{
node.target.target = new MemberData(type.Name + ".ctor", type, MemberData.TargetType.Constructor);
}
MemberDataUtility.UpdateMultipurposeMember(node.target);
member.CopyFrom(new MemberData(node, MemberData.TargetType.ValueNode));
});
graph.Refresh();
}
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;
}
public static List <EventActionData> GetConditionBlockFromNode(Node node)
{
if (node is NodeSetValue)
{
var source = node as NodeSetValue;
var action = new SetValue();
action.target = new MemberData(source.target);
action.value = new MemberData(source.value);
return(new List <EventActionData>()
{
action
});
}
else if (node is MultipurposeNode)
{
var source = node as MultipurposeNode;
if (source.CanGetValue() && source.ReturnType() == typeof(bool))
{
var action = new MethodValidation();
action.target = new MultipurposeMember(source.target);
return(new List <EventActionData>()
{
action
});
}
}
else if (node is Nodes.ComparisonNode)
{
var source = node as Nodes.ComparisonNode;
var action = new ObjectCompare();
action.targetA = new MultipurposeMember(source.targetA);
action.targetB = new MultipurposeMember(source.targetB);
action.operatorType = source.operatorType;
return(new List <EventActionData>()
{
action
});
}
else if (node is Nodes.MultiANDNode)
{
var source = node as Nodes.MultiANDNode;
var result = new List <EventActionData>();
foreach (var target in source.targets)
{
var action = new EqualityCompare();
action.target = new MultipurposeMember(target);
action.value = new MemberData(true);
result.Add(action);
}
return(result);
}
else if (node is Nodes.MultiORNode)
{
var source = node as Nodes.MultiORNode;
var result = new List <EventActionData>();
foreach (var target in source.targets)
{
if (result.Count > 0)
{
result.Add(EventActionData.OrEvent);
}
var action = new EqualityCompare();
action.target = new MultipurposeMember(target);
action.value = new MemberData(true);
result.Add(action);
}
return(result);
}
else if (node is Nodes.NotNode)
{
var source = node as Nodes.NotNode;
var action = new EqualityCompare();
action.target = new MultipurposeMember(source.target);
MemberDataUtility.UpdateMultipurposeMember(action.target);
action.value = new MemberData(false);
return(new List <EventActionData>()
{
action
});
}
return(new List <EventActionData>());
}
public override void OnClick(Node source, Vector2 mousePosition)
{
var rType = source.ReturnType();
FilterAttribute filter = new FilterAttribute {
VoidType = true,
MaxMethodParam = int.MaxValue,
Public = true,
Instance = true,
Static = false,
UnityReference = false,
InvalidTargetType = MemberData.TargetType.Null | MemberData.TargetType.Values,
// DisplayDefaultStaticType = false
ValidateMember = (member) => {
if (member is System.Reflection.MethodInfo)
{
var parameters = (member as System.Reflection.MethodInfo).GetParameters();
for (int i = 0; i < parameters.Length; i++)
{
if (rType.IsCastableTo(parameters[i].ParameterType))
{
return(true);
}
}
}
return(false);
},
};
List <ItemSelector.CustomItem> customItems = null;
if (rType.IsCastableTo(typeof(IGraphSystem)) && source is MultipurposeNode)
{
MultipurposeNode multipurposeNode = source as MultipurposeNode;
if (multipurposeNode.target != null && multipurposeNode.target.target != null && (multipurposeNode.target.target.targetType == MemberData.TargetType.SelfTarget || multipurposeNode.target.target.targetType == MemberData.TargetType.Values))
{
var sTarget = multipurposeNode.target.target.startTarget;
if (sTarget is IGraphSystem)
{
customItems = ItemSelector.MakeCustomItems(sTarget as Object);
customItems.AddRange(ItemSelector.MakeCustomItems(typeof(uNodeRoot), sTarget, filter, "Inherit Member"));
}
}
}
bool flag = false;
if (customItems == null)
{
if (rType is RuntimeType)
{
customItems = ItemSelector.MakeCustomItems((rType as RuntimeType).GetRuntimeMembers(), filter);
if (rType.BaseType != null)
{
customItems.AddRange(ItemSelector.MakeCustomItems(rType.BaseType, filter, "Inherit Member"));
}
}
else
{
customItems = ItemSelector.MakeCustomItems(rType, filter, " " + rType.PrettyName());
}
var usedNamespaces = source.owner.GetNamespaces().ToHashSet();
if (usedNamespaces != null)
{
customItems.AddRange(ItemSelector.MakeExtensionItems(rType, usedNamespaces, filter, "Extensions"));
flag = true;
}
var customInputItems = NodeEditorUtility.FindCustomInputPortItems();
if (customInputItems != null && customInputItems.Count > 0)
{
var mData = new MemberData(source, MemberData.TargetType.ValueNode);
foreach (var c in customInputItems)
{
c.graph = graph;
c.mousePositionOnCanvas = mousePositionOnCanvas;
if (c.IsValidPort(rType, PortAccessibility.OnlyGet))
{
var items = c.GetItems(source, mData, rType);
if (items != null)
{
customItems.AddRange(items);
}
}
}
}
}
if (customItems != null)
{
filter.Static = false;
customItems.Sort((x, y) => {
if (x.category != y.category)
{
return(string.Compare(x.category, y.category));
}
return(string.Compare(x.name, y.name));
});
ItemSelector w = ItemSelector.ShowWindow(source, MemberData.none, filter, delegate(MemberData value) {
flag = flag && value.targetType == MemberData.TargetType.Method && !rType.IsCastableTo(value.startType);
if (!flag && !value.isStatic)
{
value.instance = new MemberData(source, MemberData.TargetType.ValueNode);
}
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, delegate(MultipurposeNode n) {
if (n.target == null)
{
n.target = new MultipurposeMember();
}
n.target.target = value;
MemberDataUtility.UpdateMultipurposeMember(n.target);
if (flag)
{
var pTypes = value.ParameterTypes;
if (pTypes != null)
{
int paramIndex = 0;
MemberData param = null;
for (int i = 0; i < pTypes.Length; i++)
{
var types = pTypes[i];
if (types != null)
{
for (int y = 0; y < types.Length; y++)
{
if (rType.IsCastableTo(types[y]))
{
param = new MemberData(source, MemberData.TargetType.ValueNode);
break;
}
paramIndex++;
}
if (param != null)
{
break;
}
}
}
if (n.target.parameters.Length > paramIndex && param != null)
{
n.target.parameters[paramIndex] = param;
}
}
}
});
graph.Refresh();
}, customItems).ChangePosition(GUIUtility.GUIToScreenPoint(mousePosition));
w.displayRecentItem = false;
w.displayNoneOption = false;
}
}
public MultipurposeMember(MemberData target)
{
this.target = new MemberData(target);
MemberDataUtility.UpdateMultipurposeMember(this);
}
void InitMultipurposeMember(FieldInfo field)
{
MultipurposeMember member = field.GetValueOptimized(data.block) as MultipurposeMember;
object[] fieldAttribute = field.GetCustomAttributes(true);
if (!ReflectionUtils.TryCorrectingAttribute(data.block, ref fieldAttribute))
{
return;
}
if (member == null)
{
member = new MultipurposeMember();
field.SetValueOptimized(data.block, member);
Repaint();
}
if (member.target == null || member.target.isTargeted && member.target.IsTargetingPinOrNode)
{
var filter = ReflectionUtils.GetAttribute <FilterAttribute>(fieldAttribute) ?? new FilterAttribute()
{
MaxMethodParam = int.MaxValue,
};
var port = AddPort(new PortData()
{
getPortName = () => field.Name,
getPortType = () => typeof(MemberData),
getPortValue = () => member.target,
filter = filter,
onValueChanged = (obj) => {
var val = obj as MemberData;
RegisterUndo();
if (member.target.targetType != val.targetType || val.targetType != MemberData.TargetType.Values)
{
member.target = val;
owner.nodeView.MarkRepaint();
MemberDataUtility.UpdateMultipurposeMember(member);
}
else
{
member.target = val;
}
field.SetValueOptimized(data.block, member);
Repaint();
},
});
var control = port.portData.InstantiateControl(true);
control.HideInstance(true);
port.Add(new ControlView(control, true));
//ControlConfig config = new ControlConfig() {
// owner = owner,
// value = member.target,
// type = typeof(MemberData),
// filter = filter,
// onValueChanged = (obj) => {
// var val = obj as MemberData;
// RegisterUndo();
// if(member.target.targetType != val.targetType || val.targetType != MemberData.TargetType.Values) {
// member.target = val;
// owner.MarkRepaint();
// uNodeEditorUtility.UpdateMultipurposeMember(member);
// } else {
// member.target = val;
// }
// field.SetValue(data.actionEvent, member);
// Repaint();
// },
//};
//MemberControl control = new MemberControl(config, true);
//AddControl(field.Name, new ControlView(control, true));
}
if (member.target.isTargeted)
{
if (member.target.targetType != MemberData.TargetType.Values)
{
if (!member.target.isStatic &&
(!member.target.IsTargetingUNode || !uNodePreference.GetPreference().hideUNodeInstance) &&
member.target.targetType != MemberData.TargetType.Type &&
member.target.targetType != MemberData.TargetType.Null)
{
MemberDataUtility.UpdateMemberInstance(member.target, member.target.startType);
var port = AddPort(new PortData()
{
portID = "Instance",
getPortName = () => "Instance",
getPortType = () => member.target.startType,
getPortValue = () => member.target?.instance,
filter = new FilterAttribute(member.target.startType),
onValueChanged = (o) => {
RegisterUndo();
member.target.instance = o;
field.SetValueOptimized(data.block, member);
},
});
port.Add(new ControlView(port.portData.InstantiateControl(true), true));
}
else if (!uNodePreference.GetPreference().hideUNodeInstance&&
member.target.IsTargetingUNode && !member.target.IsTargetingNode)
{
MemberDataUtility.UpdateMemberInstance(member.target, member.target.startType);
var port = AddPort(new PortData()
{
portID = "Instance",
getPortName = () => "",
getPortType = () => typeof(uNodeRoot),
getPortValue = () => member.target?.instance,
filter = new FilterAttribute(typeof(uNodeRoot)),
onValueChanged = (o) => {
RegisterUndo();
member.target.instance = o;
field.SetValueOptimized(data.block, member);
},
});
port.Add(new ControlView(port.portData.InstantiateControl(true), true));
}
}
if (member.target.SerializedItems?.Length > 0)
{
MemberInfo[] members = null;
if (uNodePreference.GetPreference().inEditorDocumentation)
{
members = member.target.GetMembers(false);
if (members != null && members.Length > 0 && members.Length + 1 != member.target.SerializedItems.Length)
{
members = null;
}
}
uNodeFunction objRef = null;
switch (member.target.targetType)
{
case MemberData.TargetType.uNodeFunction: {
uNodeRoot root = member.target.GetInstance() as uNodeRoot;
if (root != null)
{
var gTypes = member.target.GenericTypes[0];
objRef = root.GetFunction(member.target.startName, gTypes != null ? gTypes.Length : 0, member.target.ParameterTypes[0]);
}
break;
}
}
int totalParam = 0;
bool flag = false;
for (int i = 0; i < member.target.SerializedItems.Length; i++)
{
if (i != 0)
{
if (members != null && (member.target.isDeepTarget || !member.target.IsTargetingUNode))
{
MemberInfo mData = members[i - 1];
if (mData is MethodInfo || mData is ConstructorInfo)
{
var method = mData as MethodInfo;
var parameters = method != null?method.GetParameters() : (mData as ConstructorInfo).GetParameters();
if (parameters.Length > 0)
{
totalParam++;
if (totalParam > 1)
{
flag = true;
break;
}
}
}
}
}
}
totalParam = 0;
int methodDrawCount = 1;
for (int i = 0; i < member.target.SerializedItems.Length; i++)
{
if (i != 0)
{
if (members != null && (member.target.isDeepTarget || !member.target.IsTargetingUNode))
{
MemberInfo memberInfo = members[i - 1];
if (memberInfo is MethodInfo || memberInfo is ConstructorInfo)
{
var method = memberInfo as MethodInfo;
var documentation = XmlDoc.XMLFromMember(memberInfo);
if (flag)
{
AddControl(memberInfo.Name, null);
}
var parameters = method != null?method.GetParameters() : (memberInfo as ConstructorInfo).GetParameters();
if (parameters.Length > 0)
{
while (parameters.Length + totalParam > member.parameters.Length)
{
ArrayUtility.Add(ref member.parameters, MemberData.empty);
}
for (int x = 0; x < parameters.Length; x++)
{
var parameter = parameters[x];
if (parameter.ParameterType != null)
{
int index = totalParam;
var param = member.parameters[index];
var port = AddPort(new PortData()
{
getPortName = () => ObjectNames.NicifyVariableName(parameter.Name),
getPortType = () => parameter.ParameterType,
getPortValue = () => param,
filter = new FilterAttribute(parameter.ParameterType),
onValueChanged = (obj) => {
RegisterUndo();
param = obj as MemberData;
member.parameters[index] = param;
field.SetValueOptimized(data.block, member);
Repaint();
},
});
port.Add(new ControlView(port.portData.InstantiateControl(true), true));
}
totalParam++;
}
continue;
}
}
}
}
System.Type[] paramsType = member.target.ParameterTypes[i];
if (paramsType != null && paramsType.Length > 0)
{
if (flag)
{
AddControl("Method " + (methodDrawCount), null);
methodDrawCount++;
}
while (paramsType.Length + totalParam > member.parameters.Length)
{
ArrayUtility.Add(ref member.parameters, MemberData.none);
}
for (int x = 0; x < paramsType.Length; x++)
{
System.Type PType = paramsType[x];
if (member.parameters[totalParam] == null)
{
member.parameters[totalParam] = MemberData.none;
}
if (PType != null)
{
int index = totalParam;
var param = member.parameters[index];
string pLabel;
if (objRef != null)
{
pLabel = objRef.parameters[x].name;
}
else
{
pLabel = "P" + (x + 1);
}
var port = AddPort(new PortData()
{
getPortName = () => ObjectNames.NicifyVariableName(pLabel),
getPortType = () => PType,
getPortValue = () => param,
filter = new FilterAttribute(PType),
onValueChanged = (obj) => {
RegisterUndo();
param = obj as MemberData;
member.parameters[index] = param;
field.SetValueOptimized(data.block, member);
Repaint();
},
});
port.Add(new ControlView(port.portData.InstantiateControl(true), true));
}
totalParam++;
}
}
}
while (member.parameters.Length > totalParam)
{
ArrayUtility.RemoveAt(ref member.parameters, member.parameters.Length - 1);
}
}
}
}
public override void OnClick(Node source, PortCommandData data, Vector2 mousePosition)
{
Type type = data.portType;
FilterAttribute filter = new FilterAttribute {
VoidType = true,
MaxMethodParam = int.MaxValue,
Public = true,
Instance = true,
Static = false,
UnityReference = false,
InvalidTargetType = MemberData.TargetType.Null | MemberData.TargetType.Values,
// DisplayDefaultStaticType = false
ValidateMember = (member) => {
if (member is System.Reflection.MethodInfo)
{
var parameters = (member as System.Reflection.MethodInfo).GetParameters();
for (int i = 0; i < parameters.Length; i++)
{
if (type.IsCastableTo(parameters[i].ParameterType))
{
return(true);
}
}
}
return(false);
},
};
List <ItemSelector.CustomItem> customItems;
if (type is RuntimeType)
{
customItems = ItemSelector.MakeCustomItems((type as RuntimeType).GetRuntimeMembers(), filter);
if (type.BaseType != null)
{
customItems.AddRange(ItemSelector.MakeCustomItems(type.BaseType, filter, "Inherit Member"));
}
}
else
{
customItems = ItemSelector.MakeCustomItems(type, filter);
}
var usingNamespaces = source.owner.GetNamespaces().ToHashSet();
if (usingNamespaces != null && usingNamespaces.Count > 0)
{
customItems.AddRange(ItemSelector.MakeExtensionItems(type, usingNamespaces, filter, "Extensions"));
}
{ //Custom input port items.
if (customItems == null)
{
customItems = new System.Collections.Generic.List <ItemSelector.CustomItem>();
}
var customInputItems = NodeEditorUtility.FindCustomInputPortItems();
if (customInputItems != null && customInputItems.Count > 0)
{
var mData = data.getConnection();
foreach (var c in customInputItems)
{
c.graph = graph;
c.mousePositionOnCanvas = mousePositionOnCanvas;
if (c.IsValidPort(type, PortAccessibility.OnlyGet))
{
var items = c.GetItems(source, mData, type);
if (items != null)
{
customItems.AddRange(items);
}
}
}
}
}
if (customItems != null)
{
filter.Static = true;
customItems.Sort((x, y) => {
if (x.category != y.category)
{
return(string.Compare(x.category, y.category));
}
return(string.Compare(x.name, y.name));
});
ItemSelector w = ItemSelector.ShowWindow(source, MemberData.none, filter, (MemberData mData) => {
bool flag = mData.targetType == MemberData.TargetType.Method && !type.IsCastableTo(mData.startType);
if (!flag && !mData.isStatic)
{
mData.instance = data.getConnection();
}
NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (MultipurposeNode nod) => {
if (nod.target == null)
{
nod.target = new MultipurposeMember();
}
nod.target.target = mData;
MemberDataUtility.UpdateMultipurposeMember(nod.target);
if (flag)
{
var pTypes = mData.ParameterTypes;
if (pTypes != null)
{
int paramIndex = 0;
MemberData param = null;
for (int i = 0; i < pTypes.Length; i++)
{
var types = pTypes[i];
if (types != null)
{
for (int y = 0; y < types.Length; y++)
{
if (type.IsCastableTo(types[y]))
{
param = data.getConnection();
break;
}
paramIndex++;
}
if (param != null)
{
break;
}
}
}
if (nod.target.parameters.Length > paramIndex && param != null)
{
nod.target.parameters[paramIndex] = param;
}
}
}
graph.Refresh();
});
}, customItems).ChangePosition(GUIUtility.GUIToScreenPoint(mousePosition));
w.displayRecentItem = false;
w.displayNoneOption = false;
}
}
