public InterfaceView(InterfaceData interfaceData, uNodeData owner)
{
this.owner = owner;
this.interfaceData = interfaceData;
title = interfaceData.name;
titleIcon.image = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.InterfaceIcon));
foreach (var p in interfaceData.properties)
{
AddChild(new InterfacePropertyView(p, interfaceData));
}
foreach (var f in interfaceData.functions)
{
AddChild(new InterfaceFunctionView(f, interfaceData));
}
}
public EnumView(EnumData enumData, uNodeData owner)
{
this.enumData = enumData;
this.owner = owner;
title = enumData.name;
titleIcon.image = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.EnumIcon));
onFirstExpanded += () => {
foreach (var e in enumData.enumeratorList)
{
var item = new SimpleTreeView(uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.EnumItemIcon)), null)
{
title = e.name,
};
AddChild(item);
}
};
}
public override void OnInspectorGUI()
{
uNodeData comp = target as uNodeData;
EditorGUI.BeginChangeCheck();
base.OnInspectorGUI();
EditorGUI.BeginDisabledGroup(uNodeEditorUtility.IsPrefab(comp));
VariableEditorUtility.DrawNamespace("Using Namespaces", comp.generatorSettings.usingNamespace.ToList(), comp, (arr) => {
comp.generatorSettings.usingNamespace = arr.ToArray();
uNodeEditorUtility.MarkDirty(comp);
});
EditorGUI.EndDisabledGroup();
if (EditorGUI.EndChangeCheck())
{
uNodeGUIUtility.GUIChanged(comp);
}
if (comp.GetComponent <uNodeRoot>() == null)
{
if (GUILayout.Button(new GUIContent("Open uNode Editor", "Open uNode Editor to edit this uNode"), EditorStyles.toolbarButton))
{
uNodeEditor.ChangeTarget(comp, true);
}
}
}
private void ReloadTabbar()
{
if (tabbarContainer != null)
{
tabbarContainer.RemoveFromHierarchy();
}
tabbarContainer = new VisualElement()
{
name = "tabbar-container"
};
tabbarContainer.style.left = _tabPosition;
tabbarContainer.AddStyleSheet("uNodeStyles/Tabbar");
tabbarContainer.AddStyleSheet(UIElementUtility.Theme.tabbarStyle);
var tabbar = new VisualElement()
{
name = "tabbar"
};
{
#region Main/Selection Tab
if (window.mainGraph != null && window.mainGraph == window.selectedGraph && !window.mainGraph.selectedData.isValidGraph)
{
window.mainGraph.owner = null;
window.mainGraph.graph = null;
window.mainGraph.selectedData = new GraphEditorData();
}
var tabMainElement = new ClickableElement("\"Main\"")
{
name = "tab-element",
onClick = () => {
window.ChangeEditorTarget(null);
},
};
tabMainElement.AddManipulator(new ContextualMenuManipulator((evt) => {
evt.menu.AppendAction("Close All But This", (act) => {
window.graphs.Clear();
window.ChangeEditorTarget(null);
ReloadTabbar();
}, DropdownMenuAction.AlwaysEnabled);
evt.menu.AppendSeparator("");
evt.menu.AppendAction("Find Object", (act) => {
EditorGUIUtility.PingObject(window.mainGraph.owner);
ReloadTabbar();
}, DropdownMenuAction.AlwaysEnabled);
evt.menu.AppendAction("Select Object", (act) => {
EditorGUIUtility.PingObject(window.mainGraph.owner);
Selection.activeObject = window.mainGraph.owner;
ReloadTabbar();
}, DropdownMenuAction.AlwaysEnabled);
}));
if (window.selectedGraph == window.mainGraph)
{
tabMainElement.AddToClassList("tab-selected");
}
tabbar.Add(tabMainElement);
#endregion
for (int i = 0; i < window.graphs.Count; i++)
{
var graph = window.graphs[i];
try {
if (graph == null || graph.owner == null || !graph.selectedData.isValidGraph)
{
window.graphs.RemoveAt(i);
i--;
continue;
}
} catch {
window.graphs.RemoveAt(i);
i--;
continue;
}
var tabElement = new ClickableElement(graph.displayName)
{
name = "tab-element",
onClick = () => {
window.ChangeEditorTarget(graph);
},
};
tabElement.AddManipulator(new ContextualMenuManipulator((evt) => {
evt.menu.AppendAction("Close", (act) => {
var oldData = window.selectedGraph;
window.graphs.Remove(graph);
window.ChangeEditorTarget(oldData);
ReloadTabbar();
}, DropdownMenuAction.AlwaysEnabled);
evt.menu.AppendAction("Close All", (act) => {
window.graphs.Clear();
window.ChangeEditorTarget(null);
ReloadTabbar();
}, DropdownMenuAction.AlwaysEnabled);
evt.menu.AppendAction("Close Others", (act) => {
var current = window.selectedGraph;
window.graphs.Clear();
window.graphs.Add(current);
window.ChangeEditorTarget(current);
ReloadTabbar();
}, DropdownMenuAction.AlwaysEnabled);
evt.menu.AppendSeparator("");
evt.menu.AppendAction("Find Object", (act) => {
EditorGUIUtility.PingObject(graph.owner);
ReloadTabbar();
}, DropdownMenuAction.AlwaysEnabled);
evt.menu.AppendAction("Select Object", (act) => {
EditorGUIUtility.PingObject(graph.owner);
Selection.activeObject = graph.owner;
ReloadTabbar();
}, DropdownMenuAction.AlwaysEnabled);
}));
if (window.selectedGraph == graph)
{
tabElement.AddToClassList("tab-selected");
}
tabbar.Add(tabElement);
}
#region Plus Tab
{
var plusElement = new ClickableElement("+")
{
name = "tab-element",
};
{
plusElement.menu = new DropdownMenu();
plusElement.menu.AppendAction("Open...", (act) => {
window.OpenNewGraphTab();
ReloadTabbar();
});
#region Recent Files
List <UnityEngine.Object> lastOpenedObjects = uNodeEditor.FindLastOpenedGraphs();
for (int i = 0; i < lastOpenedObjects.Count; i++)
{
var obj = lastOpenedObjects[i];
if (obj is uNodeRoot)
{
uNodeRoot root = obj as uNodeRoot;
plusElement.menu.AppendAction("Open Recent/" + root.gameObject.name, (act) => {
uNodeEditor.ChangeTarget(root, true);
});
}
else if (obj is uNodeData)
{
uNodeData data = obj as uNodeData;
plusElement.menu.AppendAction("Open Recent/" + data.gameObject.name, (act) => {
uNodeEditor.ChangeTarget(data, true);
});
}
}
if (lastOpenedObjects.Count > 0)
{
plusElement.menu.AppendSeparator("Open Recent/");
plusElement.menu.AppendAction("Open Recent/Clear Recent", (act) => {
uNodeEditor.ClearLastOpenedGraphs();
});
}
#endregion
var graphSystem = GraphUtility.FindGraphSystemAttributes();
int lastOrder = int.MinValue;
for (int i = 0; i < graphSystem.Count; i++)
{
var g = graphSystem[i];
if (i == 0 || Mathf.Abs(g.order - lastOrder) >= 10)
{
plusElement.menu.AppendSeparator("");
}
lastOrder = g.order;
plusElement.menu.AppendAction(g.menu, (act) => {
string path = EditorUtility.SaveFilePanelInProject("Create " + g.menu, "", "prefab", "");
if (!string.IsNullOrEmpty(path))
{
GameObject go = new GameObject();
go.name = path.Split('/').Last().Split('.')[0];
go.AddComponent(g.type);
GameObject prefab = PrefabUtility.SaveAsPrefabAsset(go, path);
UnityEngine.Object.DestroyImmediate(go);
AssetDatabase.SaveAssets();
EditorUtility.FocusProjectWindow();
uNodeEditor.ChangeTarget(prefab.GetComponent(g.type) as uNodeRoot);
}
});
}
}
tabbar.Add(plusElement);
}
#endregion
}
var pathbar = new VisualElement()
{
name = "pathbar"
};
if (editorData.graph != null)
{
var graph = new ClickableElement(editorData.graph.DisplayName)
{
name = "path-element"
};
graph.AddToClassList("path-graph");
{
graph.menu = new DropdownMenu();
uNodeRoot[] graphs = editorData.graphs;
if (graphs == null)
{
return;
}
for (int i = 0; i < graphs.Length; i++)
{
var g = graphs[i];
if (g == null)
{
continue;
}
graph.menu.AppendAction(g.DisplayName, (act) => {
if (g == editorData.graph)
{
window.ChangeEditorSelection(g);
}
else
{
uNodeEditor.ChangeTarget(g);
}
}, (act) => {
if (g == editorData.graph)
{
return(DropdownMenuAction.Status.Checked);
}
return(DropdownMenuAction.Status.Normal);
});
}
}
Type graphIcon = typeof(TypeIcons.GraphIcon);
if (editorData.graph is IClass)
{
IClass classSystem = editorData.graph as IClass;
graphIcon = classSystem.IsStruct ? typeof(TypeIcons.StructureIcon) : typeof(TypeIcons.ClassIcon);
}
graph.ShowIcon(uNodeEditorUtility.GetTypeIcon(graphIcon));
graph.EnableBreadcrumb(true);
pathbar.Add(graph);
var root = window.selectedGraph.selectedData.selectedRoot;
var function = new ClickableElement(root != null ? root.Name : editorData.graph is IStateGraph state && state.canCreateGraph ? "[State Graph]" : editorData.graph is IMacroGraph ? "[MACRO]" : "[NO ROOT]")
{
name = "path-element"
};
function.AddToClassList("path-function");
{
function.menu = new DropdownMenu();
if (editorData.graph is IStateGraph stateGraph && stateGraph.canCreateGraph)
{
function.menu.AppendAction("[State Graph]", (act) => {
if (editorData.selectedRoot != null || editorData.selectedGroup != null)
{
editorData.selected = null;
editorData.selectedRoot = null;
Refresh();
UpdatePosition();
}
window.ChangeEditorSelection(null);
}, (act) => {
if (editorData.selectedRoot == null)
{
return(DropdownMenuAction.Status.Checked);
}
return(DropdownMenuAction.Status.Normal);
});
}
List <RootObject> roots = new List <RootObject>();
roots.AddRange(editorData.graph.Functions);
roots.Sort((x, y) => string.Compare(x.Name, y.Name));
for (int i = 0; i < roots.Count; i++)
{
var r = roots[i];
if (r == null)
{
continue;
}
function.menu.AppendAction(r.Name, (act) => {
if (editorData.currentCanvas == r)
{
window.ChangeEditorSelection(r);
}
else
{
editorData.selectedRoot = r;
SelectionChanged();
Refresh();
UpdatePosition();
}
}, (act) => {
if (r == editorData.selectedRoot)
{
return(DropdownMenuAction.Status.Checked);
}
return(DropdownMenuAction.Status.Normal);
});
}
}
function.ShowIcon(uNodeEditorUtility.GetTypeIcon(root == null ? typeof(TypeIcons.StateIcon) : typeof(TypeIcons.MethodIcon)));
pathbar.Add(function);
if (editorData.graph != null && editorData.selectedGroup && editorData.selectedGroup.owner == editorData.graph)
{
function.EnableBreadcrumb(true);
List <Node> GN = new List <Node>();
GN.Add(editorData.selectedGroup);
NodeEditorUtility.FindParentNode(editorData.selectedGroup.transform, ref GN, editorData.graph);
for (int i = GN.Count - 1; i >= 0; i--)
{
var nestedGraph = GN[i];
var element = new ClickableElement(nestedGraph.GetNodeName())
{
name = "path-element",
onClick = () => {
window.ChangeEditorSelection(nestedGraph);
if (editorData.selectedGroup != nestedGraph)
{
editorData.selectedGroup = nestedGraph;
Refresh();
UpdatePosition();
}
}
};
element.AddToClassList("path-nested");
element.ShowIcon(uNodeEditorUtility.GetTypeIcon(nestedGraph.GetNodeIcon()));
pathbar.Add(element);
if (i != 0)
{
element.EnableBreadcrumb(true);
}
}
}
}
else
{
var graph = new ClickableElement("[NO GRAPH]")
{
name = "path-element"
};
pathbar.Add(graph);
}
tabbarContainer.Add(tabbar);
tabbarContainer.Add(pathbar);
window.rootVisualElement.Add(tabbarContainer);
tabbarContainer.SendToBack();
}
void Setup()
{
if (reflectionValue == null)
{
reflectionValue = MemberData.none;
}
if (filter == null)
{
filter = new FilterAttribute()
{
UnityReference = false, OnlyGetType = onlyGetType
};
}
if (onlyGetType)
{
filter = new FilterAttribute(filter)
{
OnlyGetType = onlyGetType
}
}
;
if (filter.OnlyGetType)
{
filter.ValidTargetType = MemberData.TargetType.Type | MemberData.TargetType.Null;
}
if (targetObject)
{
uNodeRoot UNR = null;
if (targetObject is uNodeRoot)
{
UNR = targetObject as uNodeRoot;
}
else if (targetObject is RootObject)
{
UNR = (targetObject as RootObject).owner;
}
else if (targetObject is NodeComponent)
{
UNR = (targetObject as NodeComponent).owner;
}
else if (targetObject is TransitionEvent)
{
UNR = (targetObject as TransitionEvent).owner;
}
if (UNR)
{
uNodeData data = UNR.GetComponent <uNodeData>();
if (data)
{
//Clear the default namespace
usingNamespaces.Clear();
//Add graph namespaces
foreach (var n in data.GetNamespaces())
{
usingNamespaces.Add(n);
}
}
if (UNR is IIndependentGraph graph)
{
if (data == null)
{
//Clear the default namespace
usingNamespaces.Clear();
}
foreach (var n in graph.UsingNamespaces)
{
usingNamespaces.Add(n);
}
}
}
}
editorData.manager = new Manager(new TreeViewState());
editorData.manager.window = this;
editorData.searchField = new SearchField();
editorData.searchField.downOrUpArrowKeyPressed += editorData.manager.SetFocusAndEnsureSelectedItem;
editorData.searchField.autoSetFocusOnFindCommand = true;
window = this;
uNodeThreadUtility.Queue(DoSetup);
}
void DoSetup()
{
editorData.setup.Setup((progress) => {
if (progress == 1)
{
uNodeThreadUtility.Queue(() => {
var categories = new List <TreeViewItem>();
if (displayDefaultItem)
{
var categoryTree = new SelectorCategoryTreeView("#", "", uNodeEditorUtility.GetUIDFromString("[CATEG]#"), -1);
categories.Add(categoryTree);
var recentTree = new SelectorCategoryTreeView("Recently", "", uNodeEditorUtility.GetUIDFromString("[CATEG]#Recently"), -1);
categories.Add(recentTree);
if (displayNoneOption && filter.IsValidTarget(MemberData.TargetType.None))
{
categoryTree.AddChild(new SelectorMemberTreeView(MemberData.none, "None", uNodeEditorUtility.GetUIDFromString("#None"))
{
icon = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.NullTypeIcon)) as Texture2D
});
}
if (!filter.SetMember)
{
if (!filter.IsValueTypes() && filter.IsValidTarget(MemberData.TargetType.Null) && !filter.OnlyGetType)
{
categoryTree.AddChild(new SelectorMemberTreeView(MemberData.Null, "Null", uNodeEditorUtility.GetUIDFromString("#Null"))
{
icon = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.NullTypeIcon)) as Texture2D
});
}
//if(!filter.OnlyGetType && filter.IsValidTarget(MemberData.TargetType.Values) &&
// (filter.Types == null || filter.Types.Count != 1 || filter.Types[0] != typeof(Type))) {
// categoryTree.AddChild(new SelectorCallbackTreeView((cRect) => {
// var screenRect = cRect.ToScreenRect();
// FilterAttribute F = new FilterAttribute(filter);
// F.OnlyGetType = true;
// ItemSelector w = null;
// Action<MemberData> action = delegate (MemberData m) {
// if(w != null) {
// w.Close();
// //EditorGUIUtility.ExitGUI();
// }
// if(filter.CanManipulateArray()) {
// if(Event.current.button == 0) {
// TypeSelectorWindow.ShowAsNew(Rect.zero, F, delegate (MemberData[] members) {
// Type t = members[0].Get<Type>();
// SelectValues(t);
// }, m).ChangePosition(screenRect);
// } else {
// CommandWindow.CreateWindow(screenRect, (items) => {
// var member = CompletionEvaluator.CompletionsToMemberData(items);
// if(member != null) {
// Type t = member.Get<Type>();
// SelectValues(t);
// return true;
// }
// return false;
// }, new CompletionEvaluator.CompletionSetting() {
// validCompletionKind = CompletionKind.Type | CompletionKind.Namespace | CompletionKind.Keyword,
// });
// }
// } else {
// Type t = m.Get<Type>();
// SelectValues(t);
// }
// };
// w = ShowAsNew(targetObject, F, action, true).ChangePosition(screenRect);
// }, "Values", uNodeEditorUtility.GetUIDFromString("#Values"), -1) {
// icon = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.ValueIcon)) as Texture2D
// });
//}
}
if (displayRecentItem)
{
var listRecentItems = new List <TreeViewItem>();
if (uNodeEditor.SavedData.recentItems != null)
{
foreach (var recent in uNodeEditor.SavedData.recentItems)
{
if (recent != null && recent.info != null)
{
if (recent.info is Type)
{
listRecentItems.Add(new TypeTreeView(recent.info as Type, recent.GetHashCode(), -1));
}
else if (!filter.OnlyGetType && (recent.isStatic || filter.DisplayInstanceOnStatic))
{
listRecentItems.Add(new MemberTreeView(recent.info, recent.GetHashCode(), -1));
}
}
}
}
while (listRecentItems.Count > 10)
{
listRecentItems.RemoveAt(listRecentItems.Count - 1);
}
if (listRecentItems.Count > 0)
{
foreach (var item in listRecentItems)
{
if (item is MemberTreeView)
{
var tree = item as MemberTreeView;
if (!(tree.member is Type))
{
tree.displayName = tree.member.DeclaringType.Name + "." + tree.displayName;
}
}
recentTree.AddChild(item);
}
recentTree.expanded = false;
}
}
if (!filter.OnlyGetType && filter.UnityReference)
{
if (reflectionValue != null && reflectionValue.GetInstance() != null && !(reflectionValue.GetInstance() is IGraphSystem) && !(reflectionValue.GetInstance() is INode))
{
categories.Add(TreeFunction.CreateTargetItem(reflectionValue.GetInstance(), "Target Reference", filter));
}
categories.AddRange(TreeFunction.CreateGraphItem(targetObject, reflectionValue, filter));
}
if (filter.UnityReference)
{
categories.AddRange(TreeFunction.CreateRootItem(targetObject, filter));
}
categories.AddRange(TreeFunction.CreateCustomItem(customItems));
if (filter.DisplayDefaultStaticType)
{
categoryTree.AddChild(new SelectorGroupedTreeView(() => {
var result = new List <TreeViewItem>();
result.Add(new SelectorSearchTreeView((prog) => {
var treeResult = new List <TreeViewItem>();
var sp = new SearchProgress();
prog?.Invoke(sp);
var allTypes = GetAllTypes((currProgress) => {
prog?.Invoke(currProgress);
}, true, true);
sp.info = "Setup Items";
for (int i = 0; i < allTypes.Count; i++)
{
var pair = allTypes[i];
var nsTree = new SelectorCategoryTreeView(pair.Key, "", uNodeEditorUtility.GetUIDFromString("[CATEG-SEARCH]" + pair.Key), -1);
foreach (var type in pair.Value)
{
nsTree.AddChild(new TypeTreeView(type, type.GetHashCode(), -1));
}
treeResult.Add(nsTree);
sp.progress = (float)i / (float)allTypes.Count;
prog?.Invoke(sp);
}
return(treeResult);
}, "Search All Types", uNodeEditorUtility.GetUIDFromString("[SAT]"), -1));
var nestedNS = new HashSet <string>();
//var excludedNs = uNodePreference.GetExcludedNamespace();
var namespaces = new List <string>(EditorReflectionUtility.GetNamespaces());
namespaces.Sort();
namespaces.RemoveAll(i => /*excludedNs.Contains(i) ||*/ i == null || i.Contains("."));
foreach (var ns in namespaces)
{
result.Add(new NamespaceTreeView(ns, uNodeEditorUtility.GetUIDFromString("[N]" + ns), -1));
}
//var nsTypes = GetNamespaceTypes(namespaces);
//foreach(var pair in nsTypes) {
// var nsTree = new SelectorCategoryTreeView(pair.Key, "", uNodeEditorUtility.GetUIDFromString("[Nested-NS]" + pair.Key), -1);
// foreach(var ns in nestedNS) {
// if(ns.StartsWith(pair.Key)) {
// nsTree.AddChild(new NamespaceTreeView(ns, uNodeEditorUtility.GetUIDFromString("[N]" + ns), -1));
// }
// }
// foreach(var type in pair.Value) {
// nsTree.AddChild(new TypeTreeView(type, type.GetHashCode(), -1));
// }
// //nsTree.children.Sort((x, y) => string.Compare(x.displayName, y.displayName));
// nsTree.expanded = false;
// result.Add(nsTree);
//}
return(result);
}, "All Namespaces", uNodeEditorUtility.GetUIDFromString("[ALL-NS]"), -1)
{
icon = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.NamespaceIcon)) as Texture2D
});
categoryTree.AddChild(new SelectorGroupedTreeView(() => {
var result = new List <TreeViewItem>();
var favorites = uNodeEditor.SavedData.favoriteItems;
if (favorites != null) //Favorite Type and Members
{
var typeTrees = new List <TypeTreeView>();
var memberTrees = new List <MemberTreeView>();
foreach (var fav in favorites)
{
if (fav.info != null && window.filter.IsValidMember(fav.info))
{
if (fav.info is Type type)
{
typeTrees.Add(new TypeTreeView(type));
}
else
{
var tree = new MemberTreeView(fav.info);
tree.displayName = tree.member.DeclaringType.Name + "." + tree.displayName;
memberTrees.Add(tree);
}
}
}
typeTrees.Sort((x, y) => string.Compare(x.displayName, y.displayName));
memberTrees.Sort((x, y) => string.Compare(x.displayName, y.displayName));
var typeCategory = new SelectorCategoryTreeView("Types", "", uNodeEditorUtility.GetUIDFromString("[TYPES]"), -1);
foreach (var tree in typeTrees)
{
typeCategory.AddChild(tree);
}
var memberCategory = new SelectorCategoryTreeView("Members", "", uNodeEditorUtility.GetUIDFromString("[MEMBERS]"), -1);
foreach (var tree in memberTrees)
{
memberCategory.AddChild(tree);
}
if (typeCategory.hasChildren)
{
result.Add(typeCategory);
}
if (memberCategory.hasChildren)
{
result.Add(memberCategory);
}
}
{ //Favorite Namespaces
var nsTrees = new List <NamespaceTreeView>();
foreach (var fav in uNodeEditor.SavedData.favoriteNamespaces)
{
nsTrees.Add(new NamespaceTreeView(fav, uNodeEditorUtility.GetUIDFromString("[NS-FAV]" + fav), -1));
}
nsTrees.Sort((x, y) => string.Compare(x.displayName, y.displayName));
var nsCategory = new SelectorCategoryTreeView("Namespaces", "", uNodeEditorUtility.GetUIDFromString("[NS]"), -1);
foreach (var tree in nsTrees)
{
nsCategory.AddChild(tree);
}
if (nsCategory.hasChildren)
{
result.Add(nsCategory);
}
}
return(result);
}, "Favorites", uNodeEditorUtility.GetUIDFromString("[fav]"), -1)
{
icon = uNodeGUIUtility.Styles.favoriteIconOn
});
var namespaceTrees = new SelectorCategoryTreeView("Types", "", uNodeEditorUtility.GetUIDFromString("[NS]"), -1);
if (displayGeneralType)
{
var categTree = new SelectorCategoryTreeView("General", "", uNodeEditorUtility.GetUIDFromString("[GENERAL]"), -1);
var items = TreeFunction.GetGeneralTrees();
items.ForEach(tree => categTree.AddChild(tree));
namespaceTrees.AddChild(categTree);
}
if (filter.DisplayRuntimeType)
{
var runtimeItems = TreeFunction.GetRuntimeItems();
var runtimeTypes = new Dictionary <string, List <TypeTreeView> >();
foreach (var item in runtimeItems)
{
var ns = item.type.Namespace;
if (string.IsNullOrEmpty(ns) || ns == RuntimeType.RuntimeNamespace)
{
ns = "Generated Type";
}
List <TypeTreeView> list;
if (!runtimeTypes.TryGetValue(ns, out list))
{
list = new List <TypeTreeView>();
runtimeTypes[ns] = list;
}
list.Add(item);
}
foreach (var pair in runtimeTypes)
{
var categTree = new SelectorCategoryTreeView(pair.Key, "", uNodeEditorUtility.GetUIDFromString("[RT]" + pair.Key), -1);
var items = pair.Value;
items.ForEach(tree => categTree.AddChild(tree));
namespaceTrees.AddChild(categTree);
}
}
var typeList = editorData.setup.typeList;
foreach (var pair in typeList)
{
var nsTree = new SelectorCategoryTreeView(pair.Key, "", uNodeEditorUtility.GetUIDFromString("[CATEG]" + pair.Key), -1);
foreach (var type in pair.Value)
{
nsTree.AddChild(new TypeTreeView(type, type.GetHashCode(), -1));
}
namespaceTrees.AddChild(nsTree);
}
categories.Add(namespaceTrees);
}
}
public static CodeGenerator.GeneratedData GenerateCSharpScript(IList <uNodeRoot> roots, uNodeData targetData, bool force = true, Action <float, string> updateProgress = null)
{
if (!force && targetData == null && roots.All(r => r.graphData.isUpToDate) || roots.Count == 0 && targetData == null)
{
return(null);
}
var generatorSettings = targetData?.generatorSettings;
string nameSpace;
IList <string> usingNamespace;
bool debug, debugValue;
if (generatorSettings != null)
{
nameSpace = generatorSettings.Namespace;
usingNamespace = generatorSettings.usingNamespace;
debug = generatorSettings.debug;
debugValue = generatorSettings.debugValueNode;
}
else if (roots.Count == 1 && roots[0] is IIndependentGraph graph)
{
if (graph is IMacroGraph)
{
return(null); //Ensure to bypass macro graph since we don't support it yet.
}
nameSpace = graph.Namespace;
usingNamespace = graph.UsingNamespaces;
debug = roots[0].graphData.debug;
debugValue = roots[0].graphData.debugValueNode;
}
else if (roots.Count > 0)
{
var root = roots.FirstOrDefault();
nameSpace = RuntimeType.RuntimeNamespace;
usingNamespace = (root as INamespaceSystem)?.GetNamespaces().ToList();
debug = false;
debugValue = false;
}
else
{
throw new InvalidOperationException();
}
return(CodeGenerator.Generate(new CodeGenerator.GeneratorSetting(roots, nameSpace, usingNamespace)
{
forceGenerateAllNode = preferenceData.generatorData.forceGenerateAllNode,
resolveUnityObject = preferenceData.generatorData.resolveUnityObject,
fullTypeName = preferenceData.generatorData.fullTypeName,
enableOptimization = preferenceData.generatorData.enableOptimization,
fullComment = preferenceData.generatorData.fullComment,
generateTwice = preferenceData.generatorData.generateNodeTwice,
generationMode = preferenceData.generatorData.generationMode,
debugScript = debug,
debugValueNode = debugValue,
targetData = targetData,
updateProgress = updateProgress,
}));
}
