public PropertyView(uNodeProperty property, ExplorerPropertyData data = null)
{
if (data == null)
{
data = new ExplorerPropertyData();
}
data.guid = uNodeUtility.GetObjectID(property).ToString();
expanded = data.expanded;
this.data = data;
this.property = property;
title = $"{property.Name} : {property.type.DisplayName(false, false)}";
titleIcon.image = uNodeEditorUtility.GetTypeIcon(typeof(TypeIcons.PropertyIcon));
expanded = data.expanded;
expandedElement.visible = false;
onExpandClicked += () => {
if (!isInSearch)
{
data.expanded = expanded;
Save();
}
};
if (ExplorerManager.explorerData.showSummary)
{
if (!string.IsNullOrWhiteSpace(property.summary))
{
var summary = new SummaryView(property.summary);
headerContainer.Add(summary);
}
}
if (ExplorerManager.explorerData.showTypeIcon)
{
typeIcon = new Image()
{
name = "type-icon",
image = uNodeEditorUtility.GetIcon(property.type),
};
titleContainer.Add(typeIcon);
typeIcon.PlaceInFront(titleIcon);
}
}
protected override void InitializeView()
{
base.InitializeView();
// titleIcon.image = null;
NodeReturn node = targetNode as NodeReturn;
if (!node.returnAnyType)
{
var parent = node.parentComponent;
if (parent != null && parent is uNodeProperty)
{
uNodeProperty m = parent as uNodeProperty;
if (m.CanGetValue() && m.ReturnType() != typeof(void))
{
AddInputValuePort(
new PortData()
{
portID = "return",
onValueChanged = (o) => {
RegisterUndo();
node.returnValue = o as MemberData;
},
getPortName = () => "",
getPortType = () => m.ReturnType(),
getPortValue = () => node.returnValue,
}
);
}
}
else if (node.rootObject != null && node.rootObject is uNodeFunction)
{
uNodeFunction m = node.rootObject as uNodeFunction;
if (m.ReturnType() != typeof(void))
{
AddInputValuePort(
new PortData()
{
portID = "return",
onValueChanged = (o) => {
RegisterUndo();
node.returnValue = o as MemberData;
},
getPortName = () => "",
getPortType = () => m.ReturnType(),
getPortValue = () => node.returnValue,
}
);
}
}
}
else
{
AddInputValuePort(
new PortData()
{
portID = "return",
onValueChanged = (o) => {
RegisterUndo();
node.returnValue = o as MemberData;
},
getPortName = () => "",
getPortType = () => typeof(object),
getPortValue = () => node.returnValue,
}
);
}
if (uNodeUtility.preferredDisplay != DisplayKind.Full)
{
ConstructCompactTitle("return");
}
}
public HierarchyPropertyTree(uNodeProperty property, int depth) : base(property.GetHashCode(), depth, $"{property.Name} : {property.type.DisplayName(false, false)}")
{
this.property = property;
icon = uNodeEditorUtility.GetTypeIcon(property.type) as Texture2D;
}
public static void RefactorProperty(uNodeProperty property, string name)
{
name = uNodeUtility.AutoCorrectName(name);
var graph = property.owner;
bool hasVariable = false;
if (graph.Properties != null && graph.Properties.Count > 0)
{
foreach (var V in graph.Properties)
{
if (V.Name == name)
{
hasVariable = true;
break;
}
}
}
if (graph.Variables != null && graph.Variables.Count > 0)
{
foreach (var V in graph.Variables)
{
if (V.Name == name)
{
hasVariable = true;
break;
}
}
}
if (hasVariable)
{
return;
}
Undo.SetCurrentGroupName("Rename Property: " + property.Name);
HashSet <GameObject> referencedGraphs = new HashSet <GameObject>();
if (graph != null)
{
RuntimeProperty runtime = null;
if (graph is IIndependentGraph)
{
if (GraphUtility.IsTempGraphObject(graph.gameObject))
{
var prefab = uNodeEditorUtility.GetGameObjectSource(graph.gameObject, null);
if (prefab != null)
{
var oriGraph = prefab.GetComponent <uNodeRoot>();
if (oriGraph != null)
{
runtime = ReflectionUtils.GetRuntimeType(oriGraph).GetProperty(property.Name) as RuntimeProperty;
}
}
}
else
{
runtime = ReflectionUtils.GetRuntimeType(graph).GetProperty(property.Name) as RuntimeProperty;
}
}
PropertyInfo nativeMember = null;
if (graph.GeneratedTypeName.ToType(false) != null)
{
var type = graph.GeneratedTypeName.ToType(false);
nativeMember = type.GetProperty(property.Name, MemberData.flags);
}
var graphPrefabs = uNodeEditorUtility.FindPrefabsOfType <uNodeRoot>();
foreach (var prefab in graphPrefabs)
{
var gameObject = prefab;
GameObject prefabContent = null;
if (GraphUtility.HasTempGraphObject(prefab))
{
gameObject = GraphUtility.GetTempGraphObject(prefab);
}
else if (uNodeEditorUtility.IsPrefab(prefab))
{
prefabContent = PrefabUtility.LoadPrefabContents(AssetDatabase.GetAssetPath(prefab));
gameObject = prefabContent;
}
var scripts = gameObject.GetComponentsInChildren <MonoBehaviour>(true);
bool hasUndo = false;
Func <object, bool> scriptValidation = (obj) => {
MemberData member = obj as MemberData;
if (member != null && member.startType is RuntimeType)
{
var members = member.GetMembers(false);
if (members != null)
{
for (int i = 0; i < members.Length; i++)
{
var m = members[i];
if (member.namePath.Length > i + 1)
{
if (m == runtime || m == nativeMember)
{
if (!hasUndo && prefabContent == null)
{
uNodeEditorUtility.RegisterFullHierarchyUndo(gameObject);
hasUndo = true;
}
var path = member.namePath;
path[i + 1] = name;
member.name = string.Join(".", path);
if (m == nativeMember)
{
referencedGraphs.Add(prefab);
}
return(true);
}
}
}
}
}
return(false);
};
if (runtime != null || nativeMember != null)
{
bool hasChanged = false;
Array.ForEach(scripts, script => {
bool flag = AnalizerUtility.AnalizeObject(script, scriptValidation);
if (flag)
{
hasChanged = true;
hasUndo = false;
uNodeGUIUtility.GUIChanged(script);
uNodeEditorUtility.MarkDirty(script);
}
});
if (hasChanged)
{
if (gameObject != prefab)
{
uNodeEditorUtility.RegisterFullHierarchyUndo(prefab);
if (prefabContent == null)
{
//Save the temporary graph
GraphUtility.AutoSaveGraph(gameObject);
}
else
{
//Save the prefab contents and unload it
uNodeEditorUtility.SavePrefabAsset(gameObject, prefab);
}
}
uNodeEditorUtility.MarkDirty(prefab);
}
}
if (prefabContent != null)
{
PrefabUtility.UnloadPrefabContents(prefabContent);
}
}
}
uNodeEditorUtility.RegisterFullHierarchyUndo(graph.gameObject);
string oldVarName = property.Name;
property.Name = name;
graph.Refresh();
Func <object, bool> validation = delegate(object OBJ) {
return(CallbackRenameProperty(OBJ, graph, property.name, oldVarName));
};
Array.ForEach(graph.nodes, item => AnalizerUtility.AnalizeObject(item, validation));
if (GraphUtility.IsTempGraphObject(graph.gameObject))
{
var prefab = uNodeEditorUtility.GetGameObjectSource(graph.gameObject, null);
uNodeEditorUtility.RegisterFullHierarchyUndo(prefab);
GraphUtility.AutoSaveGraph(graph.gameObject);
}
uNodeEditor.ClearGraphCache();
uNodeEditor.window?.Refresh(true);
DoCompileReferences(graph, referencedGraphs);
}
