using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using UnityEditor;
using UnityEngine;
#if ODIN_INSPECTOR
using Sirenix.OdinInspector.Editor;
#endif
namespace XNodeEditor.Internal {
/// Handles caching of custom editor classes and their target types. Accessible with GetEditor(Type type)
/// Editor Type. Should be the type of the deriving script itself (eg. NodeEditor)
/// Attribute Type. The attribute used to connect with the runtime type (eg. CustomNodeEditorAttribute)
/// Runtime Type. The ScriptableObject this can be an editor for (eg. Node)
public abstract class NodeEditorBase where A : Attribute, NodeEditorBase.INodeEditorAttrib where T : NodeEditorBase where K : ScriptableObject {
/// Custom editors defined with [CustomNodeEditor]
private static Dictionary editorTypes;
private static Dictionary editors = new Dictionary();
public NodeEditorWindow window;
public K target;
public SerializedObject serializedObject;
#if ODIN_INSPECTOR
private PropertyTree _objectTree;
public PropertyTree objectTree {
get {
if (this._objectTree == null) {
try {
bool wasInEditor = NodeEditor.inNodeEditor;
NodeEditor.inNodeEditor = true;
this._objectTree = PropertyTree.Create(this.serializedObject);
NodeEditor.inNodeEditor = wasInEditor;
} catch (ArgumentException ex) {
Debug.Log(ex);
}
}
return this._objectTree;
}
}
#endif
public static T GetEditor(K target, NodeEditorWindow window) {
if (target == null) return null;
T editor;
if (!editors.TryGetValue(target, out editor)) {
Type type = target.GetType();
Type editorType = GetEditorType(type);
editor = Activator.CreateInstance(editorType) as T;
editor.target = target;
editor.serializedObject = new SerializedObject(target);
editor.window = window;
editor.OnCreate();
editors.Add(target, editor);
}
if (editor.target == null) editor.target = target;
if (editor.window != window) editor.window = window;
if (editor.serializedObject == null) editor.serializedObject = new SerializedObject(target);
return editor;
}
private static Type GetEditorType(Type type) {
if (type == null) return null;
if (editorTypes == null) CacheCustomEditors();
Type result;
if (editorTypes.TryGetValue(type, out result)) return result;
//If type isn't found, try base type
return GetEditorType(type.BaseType);
}
private static void CacheCustomEditors() {
editorTypes = new Dictionary();
//Get all classes deriving from NodeEditor via reflection
Type[] nodeEditors = typeof(T).GetDerivedTypes();
for (int i = 0; i < nodeEditors.Length; i++) {
if (nodeEditors[i].IsAbstract) continue;
var attribs = nodeEditors[i].GetCustomAttributes(typeof(A), false);
if (attribs == null || attribs.Length == 0) continue;
A attrib = attribs[0] as A;
editorTypes.Add(attrib.GetInspectedType(), nodeEditors[i]);
}
}
/// Called on creation, after references have been set
public virtual void OnCreate() { }
public interface INodeEditorAttrib {
Type GetInspectedType();
}
}
}