1.try script object type node data

Sample/HelloGraph.cs

@@ -2,7 +2,7 @@ using System;
 using TNode.Models;
 using UnityEngine;
 
-namespace Sample.Editor{
+namespace Sample{
     [CreateAssetMenu(fileName = "New HelloGraph", menuName = "TNode/HelloGraph")]
     [Serializable]
     public class HelloGraph : GraphData{

Sample/HelloNode.cs

@@ -1,5 +1,4 @@
-using Sample.Editor;
-using TNode.Attribute;
+using TNode.Attribute;
 using TNode.Models;
 
 namespace Sample{

TNode/Editor/BaseViews/DataGraphView.cs

@@ -206,10 +206,14 @@ namespace TNode.Editor.BaseViews{
                     if (evt.clickCount == 1){
                         if (_isInspectorOn){
                             _nodeInspector.Data = nodeData;
+                            _nodeInspector.NodeView = nodeView as INodeView;
                         }
                     }
                 });
                 
+                if(nodeView is INodeView nodeViewInterface){
+                    nodeViewInterface.SetNodeData(nodeData);
+                }
             }
         }
 

TNode/Editor/BaseViews/NodeView.cs

@@ -1,12 +1,13 @@
-using Dialogue;
-using TNode.Models;
+using TNode.Models;
+using UnityEditor;
 using UnityEditor.Experimental.GraphView;
+using UnityEditor.UIElements;
 
-namespace TNode.BaseViews{
+namespace TNode.Editor.BaseViews{
     
     //A NodeAttribute monitor some type of node in the graph
     
-    public abstract class NodeView<T> : Node where T:NodeData,new(){
+    public abstract class NodeView<T> : Node,INodeView where T:NodeData,new(){
         protected T _data;
         public T Data{
             get => _data;
@@ -21,8 +22,38 @@ namespace TNode.BaseViews{
         }
         public event System.Action<T> OnDataChanged;
 
-        public NodeView(){
+        protected NodeView(){
+            OnDataChanged+=OnDataChangedHandler;
+        }
+
+        private void OnDataChangedHandler(T obj){
+            this.title = _data.nodeName;
+        }
+
+        public void SetNodeData(NodeData nodeData){
+            Data = (T)nodeData;
+        }
+
+        public NodeData GetNodeData(){
+            return _data;
+        }
 
+        public void OnDataModified(){
+           Refresh();
         }
+
+        public void Refresh(){
+            title = _data.nodeName;
+            
+        }
+
+    }
+
+    public interface INodeView{
+        public void SetNodeData(NodeData nodeData);
+        public NodeData GetNodeData();
+        
+        public void OnDataModified();
+
     }
 }

TNode/Editor/Cache/NodeEditorExtensions.cs

@@ -67,7 +67,6 @@ namespace TNode.Cache{
                                                        parent.GetGenericTypeDefinition() == typeof(DataGraphView<>))){
                     //Get the generic type of this type
                     //Add this type to the dictionary
-                    Debug.Log($"Find a component named {type} and its parent is {parent}");
                     FromGenericToSpecific.Add(parent, type);
                 }
                 //TODO Note that a node component only applied to a specific type of editor,so ,same GraphView could behave differently in different editor.it's a todo feature.

TNode/Editor/DefaultNodeView.cs

@@ -1,7 +1,10 @@
 using TNode.BaseViews;
+using TNode.Editor.BaseViews;
 using TNode.Models;
 
 namespace TNode.Editor{
+
+    
     public class DefaultNodeView:NodeView<NodeData>{
         
     }

TNode/Editor/Inspector/DefaultInspectorItemFactory.cs

@@ -1,7 +1,9 @@
 using System;
 using TNode.Cache;
 using TNode.Editor.Inspector.InspectorImplementation;
+using Unity.VisualScripting;
 using UnityEditor;
+using UnityEngine;
 using UnityEngine.UIElements;
 
 namespace TNode.Editor.Inspector{
@@ -21,11 +23,21 @@ namespace TNode.Editor.Inspector{
         public static InspectorItem<T> DefaultInspectorItem<T>(){
             DefaultInspectorItem<T> item = new DefaultInspectorItem<T>();
             if (typeof(string) == typeof(T)){
-                item.foldOut.Add(new TextField(){
+                var textField = new TextField(){
                     name = "StringTextField"
+                };
+                item.foldOut.Add(textField);
+                textField.RegisterCallback<ChangeEvent<string>>(e => {
+                    Debug.Log(item.BindingNodeData);
+                    Debug.Log(item.BindingPath);
+                    item.BindingNodeData.GetType().GetField(item.BindingPath).SetValue(item.BindingNodeData, e.newValue);
+                    if (item.parent.parent is NodeInspector nodeInspector){
+                        Debug.Log("item 's parent 's parent is exactly a node inspector");
+                        nodeInspector.NodeView.OnDataModified();
+                    }
+                       
                 });
             }
-
             return item;
 
         }

TNode/Editor/Inspector/INodeDataBinding.cs

@@ -3,20 +3,8 @@ using UnityEngine;
 
 namespace TNode.Editor.Inspector{
     public interface INodeDataBinding<out T>:INodeDataBindingBase{
-        protected T GetValue(){
 
-            var fieldInfo = typeof(T).GetField(BindingPath, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
-            //check field type
-            if (fieldInfo != null && fieldInfo.FieldType == typeof(T)){
-                return (T)fieldInfo.GetValue(BindingNodeData);
-            }
-            else{
-                Debug.LogError("Wrong Type for current node data");
-            }
-            return default;
-        }        
         
-        public T Value => GetValue();
 
         public void OnBindingDataUpdate(){
             

TNode/Editor/Inspector/InspectorImplementation/DefaultInspectorItem.cs

@@ -3,13 +3,17 @@
 namespace TNode.Editor.Inspector.InspectorImplementation{
     public class DefaultInspectorItem<T>:InspectorItem<T>{
         public readonly Foldout foldOut;
-        public DefaultInspectorItem(){
+        public DefaultInspectorItem():base(){
             foldOut = new Foldout{
                 text = ""
             };
             this.Add(foldOut);
             OnValueChanged += () => {
                 foldOut.text = this.BindingPath;
+                var textField = this.Q<TextField>();
+                if(textField != null){
+                    textField.value = this.Value.ToString();
+                }
             };
         }
     }

TNode/Editor/Inspector/InspectorItem.cs

@@ -1,4 +1,5 @@
-using TNode.Models;
+using TNode.BaseViews;
+using TNode.Models;
 using UnityEngine;
 using UnityEngine.UIElements;
 
@@ -29,13 +30,29 @@ namespace TNode.Editor.Inspector{
             }
         }
 
+        private T GetValue(){
+        
+            var fieldInfo = _bindingNodeData.GetType().GetField(BindingPath, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
+            Debug.Log(fieldInfo);
+            Debug.Log(fieldInfo?.FieldType );
+            //check field type
+            if (fieldInfo != null && fieldInfo.FieldType == typeof(T)){
+                return (T)fieldInfo.GetValue(BindingNodeData);
+            }
+            else{
+                Debug.LogError("Wrong Type for current node data");
+            }
+            return default;
+        }
+
+        protected T Value => GetValue();
         public  InspectorItem(){
+           
             OnValueChanged+= OnValueChangedHandler;
         }
     
         private void OnValueChangedHandler(){
             
-
         }
         ~InspectorItem(){
             OnValueChanged-= OnValueChangedHandler;

TNode/Editor/Inspector/NodeInspector.cs

@@ -1,5 +1,6 @@
 using System.Reflection;
 using TNode.BaseViews;
+using TNode.Editor.BaseViews;
 using TNode.Models;
 using UnityEngine;
 using UnityEngine.UIElements;
@@ -17,6 +18,7 @@ namespace TNode.Editor.Inspector{
             }
         }
 
+        public INodeView NodeView;
         private void UpdateData(){
             Debug.Log(_data);
             if (_data != null){
@@ -33,21 +35,23 @@ namespace TNode.Editor.Inspector{
 
         private void RefreshInspector(){
             //iterate field of data and get name of every fields,create a new inspector item of appropriate type and add it to the inspector for each field
-            this.Q("InspectorBody").Clear();
+            var body = this.Q("InspectorBody");
+            body.Clear();
+            body.Add(new Label(_data.nodeName));
             foreach (var field in _data.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public)){
                 var bindingPath = field.Name;
-          
                 var type = field.FieldType;
                 DefaultInspectorItemFactory defaultInspectorItemFactory = new DefaultInspectorItemFactory();
                 //Invoke generic function Create<> of default inspector item factory to create an inspector item of appropriate type by reflection
                 MethodInfo methodInfo = defaultInspectorItemFactory.GetType().GetMethod("Create", BindingFlags.Instance | BindingFlags.Public);
                 if (methodInfo != null){
                     var genericMethod = methodInfo.MakeGenericMethod(type);
-                    var createdInspector  = genericMethod.Invoke(defaultInspectorItemFactory,null) as VisualElement;
-                    this.Q("InspectorBody").Add(createdInspector);
-                    if (createdInspector is INodeDataBindingBase castedInspector){
-                        castedInspector.BindingNodeData = _data;
-                        castedInspector.BindingPath = bindingPath;
+                    var createdItem  = genericMethod.Invoke(defaultInspectorItemFactory,null) as VisualElement;
+                  
+                    body.Add(createdItem);
+                    if (createdItem is INodeDataBindingBase castedItem){
+                        castedItem.BindingNodeData = _data;
+                        castedItem.BindingPath = bindingPath;
                     }
                 }
             }

TNode/Editor/SearchWindowProvider.cs

@@ -47,11 +47,12 @@ namespace TNode.Editor{
                 //Check if type is derived from NodeData
                 if (typeof(NodeData).IsAssignableFrom(type)){
                     //Make an instance of the type
-                    var nodeData = (NodeData) Activator.CreateInstance(type);
-                    nodeData.nodeName = "New Node";
-                    ((IDataGraphView)_graphView).AddTNode(nodeData,new Rect(localPos.x,localPos.y,100,100));
+                    var nodeData = CreateInstance(type) as NodeData;
+                    if (nodeData != null){
+                        nodeData.nodeName = "New Node";
+                        ((IDataGraphView) _graphView).AddTNode(nodeData, new Rect(localPos.x, localPos.y, 100, 100));
+                    }
                 }
-
                 return true;
             }
             return false;

TNode/Models/NodeData.cs

@@ -11,7 +11,7 @@ namespace TNode.Models{
     /// 
     /// </summary>
     [Serializable]
-    public class NodeData:IModel{
+    public class NodeData:ScriptableObject,IModel{
    
         public NodeData() : base(){
             //Object Registration