feat: search window now applied correctly

Sample/MathGraph/Editor/MathGraphView.cs

@@ -1,7 +1,7 @@
 using TNode.Models;
 using TNode.Attribute;
 using TNode.Editor.BaseViews;
-[NodeComponent]
+[ViewComponent]
 public class MathGraphView : DataGraphView<MathGraph>{
 
 

TNode/Attribute/ViewComponentAttribute.cs

@@ -11,7 +11,7 @@ namespace TNode.Attribute{
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
    [MeansImplicitUse]
     
-    public class NodeComponentAttribute:System.Attribute{
+    public class ViewComponentAttribute:System.Attribute{
 
 
         public Type GenericType{ get; set; }

TNode/Editor/BaseViews/DataGraphView.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -7,6 +8,7 @@ using TNode.Cache;
 using TNode.Editor.GraphBlackboard;
 using TNode.Editor.Inspector;
 using TNode.Editor.Model;
+using TNode.Editor.Search;
 using TNode.Editor.Tools.NodeCreator;
 using TNode.Models;
 using Unity.VisualScripting;
@@ -281,20 +283,11 @@ namespace TNode.Editor.BaseViews{
         }
 
         public virtual void CreateBlackboard(){
-            _blackboard = new Blackboard();
+
-            //Blackboard add "Add Node" button
+            _blackboard = NodeEditorExtensions.CreateBlackboardWithGraphData(typeof(T));
-            // blackboard.Add(new BlackboardSection(){
+
-            //     title = "Hello World",
-            // });
-            // blackboard.addItemRequested = (item) => {
-            //     //Create a sub window for the blackboard to show the selection
-            //     var subWindow = ScriptableObject.CreateNodeComponentFromGenericType<NodeSearchWindowProvider>();
-            // };
-            //
-            //Set black board to left side of the view
             _blackboard.SetPosition(new Rect(0,0,200,600));
             Add(_blackboard);
-            //Check the type of the blackboard
             
             OnDataChanged+= (sender, e) => { BlackboardUpdate(); };
 
@@ -311,9 +304,25 @@ namespace TNode.Editor.BaseViews{
             foreach (var field in _data.blackboardData.GetType()
                          .GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)){
                 //if the field is MonoBehaviour,add a property field for blackboard 
-                var propertyField = new BlackboardPropertyField(new BlackboardProperty(field.Name,field.FieldType));
+                //skip if the field is a list or Ilist
-                _blackboard.Add(propertyField);
+                if (!typeof(IList).IsAssignableFrom(field.FieldType)){
+                    var propertyField = new BlackboardPropertyField(new BlackboardProperty(field.Name,field.FieldType));
+                    _blackboard.Add(propertyField);
+                }
+
             }
+            _blackboard.addItemRequested = (sender) => {
+                var res = ScriptableObject.CreateInstance<BlackboardSearchWindowProvider>();
+                
+                //Get right top corner of the blackboard
+                var blackboardPos = _blackboard.GetPosition().position;
+                var searchWindowContext = new SearchWindowContext(blackboardPos,200,200);
+                //Call search window 
+                res.Setup(typeof(T),this,Owner);
+                
+                SearchWindow.Open(searchWindowContext, res);
+            };
+                
         }
 
         public virtual void DestroyInspector(){

TNode/Editor/Cache/NodeEditorExtensions.cs

@@ -5,6 +5,7 @@ using TNode.Attribute;
 using TNode.BaseViews;
 using TNode.Editor;
 using TNode.Editor.BaseViews;
+using TNode.Editor.GraphBlackboard;
 using TNode.Editor.Inspector;
 using TNode.Models;
 using UnityEditor.Experimental.GraphView;
@@ -58,7 +59,7 @@ namespace TNode.Cache{
                 foreach(var type in assembly.GetTypes()){
                     if(type.IsClass && !type.IsAbstract){
                         //Register Node View And Graph View via its parent class
-                        SetNodeComponentAttribute(type);
+                        SetViewComponentAttribute(type);
                         //Register Node Data by GraphUsageAttribute.
                         SetGraphUsageAttribute(type);
                     }
@@ -98,9 +99,10 @@ namespace TNode.Cache{
                 }
             }
         }
-        private readonly Type[] _acceptedTypesForGenericToSpecific = new Type[]{typeof(NodeView<>),typeof(DataGraphView<>),typeof(InspectorItem<>),typeof(NodeView<>)};
+        private readonly Type[] _acceptedTypesForGenericToSpecific = new Type[]{typeof(NodeView<>),typeof(DataGraphView<>),typeof(GraphBlackboardView<>)};
-        private void SetNodeComponentAttribute(Type type){
+        private readonly Type[] _defaultTypes = new []{typeof(DefaultNodeView),typeof(DefaultGraphBlackboardView)};
-            foreach (var attribute in type.GetCustomAttributes(typeof(NodeComponentAttribute), false)){
+        private void SetViewComponentAttribute(Type type){
+            foreach (var attribute in type.GetCustomAttributes(typeof(ViewComponentAttribute), false)){
                 //fetch this type 's parent class
                 var parent = type.BaseType;
                 //Check if this type is a generic type and is a generic type of NodeView or DataGraphView,
@@ -121,17 +123,28 @@ namespace TNode.Cache{
     }
     //Outer wrapper for the singleton class
     public static class NodeEditorExtensions{
-        public static T CreateNodeComponentFromGenericType<T>(){
+        /// <summary>
+        ///  by given a generic type T,return the implementation instance  of the generic type
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public static T CreateViewComponentFromBaseType<T>(){
             var implementedType = NodeEditorSingleton.Instance.FromGenericToSpecific[typeof(T)];
             var instance = (T)Activator.CreateInstance(implementedType);
             return instance;
         }
-        public static object CreateNodeComponentFromGenericType(Type t){
+        
+        /// <summary>
+        /// by given a generic type t,return the implementation instance  of the generic type
+        /// </summary>
+        /// <returns></returns>
+        public static object CreateViewComponentFromBaseType(Type t){
             if (NodeEditorSingleton.Instance.FromGenericToSpecific.ContainsKey(t)){
                 var implementedType = NodeEditorSingleton.Instance.FromGenericToSpecific[t];
                 var instance = Activator.CreateInstance(implementedType);
                 return instance;
             }
+            
             //check if t is a generic type node view
             if (t is{IsGenericType: true} && t.GetGenericTypeDefinition() == typeof(NodeView<>)){
                 var instance = Activator.CreateInstance(typeof(NodeView<NodeData>));
@@ -139,6 +152,31 @@ namespace TNode.Cache{
             }
             return null;
         }
+        
+        public static Blackboard CreateBlackboardDataFromBlackboardDataType(Type t){
+            var type = typeof(GraphBlackboardView<>).MakeGenericType(t);
+            var res = CreateViewComponentFromBaseType(type) as Blackboard;
+            return res ?? new DefaultGraphBlackboardView();
+
+        }
+
+        public static Blackboard CreateBlackboardWithGraphData(GraphData graphData){
+            var graphType = graphData.GetType();
+            if (NodeEditorSingleton.Instance.GraphBlackboard.ContainsKey(graphType)){
+                var type = NodeEditorSingleton.Instance.GraphBlackboard[graphType];
+                return CreateBlackboardDataFromBlackboardDataType(type);
+
+            }
+            return null;
+        }
+        public static Blackboard CreateBlackboardWithGraphData(Type graphType){
+            if (NodeEditorSingleton.Instance.GraphBlackboard.ContainsKey(graphType)){
+                var type = NodeEditorSingleton.Instance.GraphBlackboard[graphType];
+                return CreateBlackboardDataFromBlackboardDataType(type);
+
+            }
+            return null;
+        }
         public static bool HasSpecificTypeComponent<T>() where T : class{
 
             return NodeEditorSingleton.Instance.FromGenericToSpecific.ContainsKey(typeof(T));
@@ -159,19 +197,6 @@ namespace TNode.Cache{
             }
             return null;
         }
-        public static object CreateNodeViewFromNodeType<T>() where  T:NodeData,new(){
-            //Check specific derived type exists or not.
-            var type = typeof(NodeView<T>);
-            if (NodeEditorSingleton.Instance.FromGenericToSpecific.ContainsKey(type)){
-                var implementedType = NodeEditorSingleton.Instance.FromGenericToSpecific[type];
-                var instance = (NodeView<T>)Activator.CreateInstance(implementedType);
-                return instance;
-            }
-            else{
-                return new DefaultNodeView();
-            }
-            
-        }
         public static object CreateNodeViewFromNodeType(Type t){
             //Check the generic type of NodeView by t
            

TNode/Editor/GraphBlackboard/DefaultGraphBlackboardView.cs

@@ -0,0 +1,17 @@
+using TNode.Attribute;
+using TNode.Models;
+
+namespace TNode.Editor.GraphBlackboard{
+    [ViewComponent]
+    public class DefaultGraphBlackboardView:GraphBlackboardView<BlackboardData>{
+        public DefaultGraphBlackboardView(){
+            
+        }
+        public void ConstructView(){
+            
+        }
+        public void AddParameter(){
+            
+        }
+    }
+}

TNode/Editor/GraphBlackboard/DefaultGraphBlackboardView.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 98e4de339ad84949ac2c50e61a108a96
+timeCreated: 1657592333

TNode/Editor/GraphBlackboard/GraphBlackboardView.cs

@@ -5,8 +5,11 @@ namespace TNode.Editor.GraphBlackboard{
     /// <summary>
     /// Implement this class to create graph black board for specified graph
     /// </summary>
-    public class GraphBlackboard<T>:Blackboard where T:BlackboardData{
+    public class GraphBlackboardView<T>:Blackboard where T:BlackboardData{
         public T BlackboardData;
 
+        public GraphBlackboardView() : base(){
+            
+        }
     }
 }

TNode/Editor/GraphEditor.cs

@@ -36,7 +36,7 @@ namespace TNode.Editor{
         }
         
         private void BuildGraphView(){
-            _graphView = NodeEditorExtensions.CreateNodeComponentFromGenericType<DataGraphView<T>>();
+            _graphView = NodeEditorExtensions.CreateViewComponentFromBaseType<DataGraphView<T>>();
             rootVisualElement.Add(_graphView);
             _graphView.StretchToParentSize();
         }

TNode/Editor/Inspector/InspectorImplementation/EnumFieldItem.cs

@@ -4,7 +4,7 @@ using UnityEngine;
 using UnityEngine.UIElements;
 
 namespace TNode.Editor.Inspector.InspectorImplementation{
-    [NodeComponent]
+    [ViewComponent]
     [Obsolete]
     public class EnumFieldItem:InspectorItem<Enum>{
         public EnumFieldItem() : base(){

TNode/Editor/Inspector/InspectorImplementation/FloatFieldItem.cs

@@ -4,7 +4,7 @@ using UnityEngine.UIElements;
 
 namespace TNode.Editor.Inspector.InspectorImplementation{
     [Obsolete]
-    [NodeComponent]
+    [ViewComponent]
     public class FloatFieldItem:InspectorItem<float>{
         public FloatFieldItem():base(){
             CreateBindable(new FloatField());

TNode/Editor/Inspector/InspectorImplementation/StringFieldItem.cs

@@ -7,7 +7,7 @@ namespace TNode.Editor.Inspector.InspectorImplementation{
     /// <summary>
     /// Force these element to bind native c# property
     /// </summary>
-    [NodeComponent]
+    [ViewComponent]
     public class StringFieldItem:InspectorItem<string>{
         public StringFieldItem():base(){
             CreateBindable(new TextField());

TNode/Editor/Inspector/InspectorImplementation/ToggleFieldItem.cs

@@ -4,7 +4,7 @@ using UnityEngine.UIElements;
 
 namespace TNode.Editor.Inspector.InspectorImplementation{
     [Obsolete]
-    [NodeComponent]
+    [ViewComponent]
     public class ToggleFieldItem:InspectorItem<bool>{
         public ToggleFieldItem(){
             CreateBindable(new Toggle());

TNode/Editor/Inspector/InspectorItemFactory.cs

@@ -15,12 +15,12 @@ namespace TNode.Editor.Inspector{
             var hasSpecificType = NodeEditorExtensions.HasSpecificTypeComponent<InspectorItem<T>>();
            
             if (hasSpecificType){
-                return NodeEditorExtensions.CreateNodeComponentFromGenericType<InspectorItem<T>>();
+                return NodeEditorExtensions.CreateViewComponentFromBaseType<InspectorItem<T>>();
             }
 
             if (typeof(T).IsEnum){
               
-                return NodeEditorExtensions.CreateNodeComponentFromGenericType(typeof(InspectorItem<Enum>)) as InspectorItem<T>;
+                return NodeEditorExtensions.CreateViewComponentFromBaseType(typeof(InspectorItem<Enum>)) as InspectorItem<T>;
             }
             return null;
         }
@@ -30,12 +30,12 @@ namespace TNode.Editor.Inspector{
             var hasSpecificType = NodeEditorExtensions.HasSpecificTypeComponent(genericType);
            
             if (hasSpecificType){
-                return NodeEditorExtensions.CreateNodeComponentFromGenericType(genericType) as INodeDataBindingBase;
+                return NodeEditorExtensions.CreateViewComponentFromBaseType(genericType) as INodeDataBindingBase;
             }
 
             if (t.IsEnum){
               
-                return NodeEditorExtensions.CreateNodeComponentFromGenericType(typeof(InspectorItem<Enum>)) as INodeDataBindingBase;
+                return NodeEditorExtensions.CreateViewComponentFromBaseType(typeof(InspectorItem<Enum>)) as INodeDataBindingBase;
             }
             return null;
         }

TNode/Editor/NodeViews/DragNodeView.cs

@@ -3,7 +3,7 @@ using TNode.Editor.BaseViews;
 using TNode.Models;
 
 namespace TNode.Editor.NodeViews{
-    [NodeComponent]
+    [ViewComponent]
     public class DragNodeView<T>:NodeView<BlackboardDragNodeData<T>>{
         public DragNodeView() : base(){
            //Make capsule like style

TNode/Editor/Search/BlackboardSearchWindowProvider.cs

@@ -6,8 +6,8 @@ using UnityEditor;
 using UnityEditor.Experimental.GraphView;
 using UnityEngine;
 
-namespace TNode.Editor{
+namespace TNode.Editor.Search{
-    public class BlackboardSearchWindowProvider:ISearchWindowProvider{
+    public class BlackboardSearchWindowProvider:ScriptableObject,ISearchWindowProvider{
         private Type _graphType;
         private IDataGraphView _graphView;
         private EditorWindow _editor;
@@ -20,15 +20,19 @@ namespace TNode.Editor{
         public List<SearchTreeEntry> CreateSearchTree(SearchWindowContext context){
             var blackboardData = _graphView.GetBlackboardData();
             var type = blackboardData.GetType();
-            var entries = new List<SearchTreeEntry>();
+            var list = new List<SearchTreeEntry>(){
-            if (entries == null) throw new ArgumentNullException(nameof(entries));
+                new SearchTreeGroupEntry(new GUIContent("Add New Blackboard Data"), 0),
+            };
+                
+            if (list == null) throw new ArgumentNullException(nameof(list));
             //search fields with List type
             Texture2D icon = new Texture2D(2,2);
+  
             foreach (var field in type.GetFields()){
                 if (field.FieldType.IsGenericType){
                     var genericType = field.FieldType.GetGenericTypeDefinition();
                     if (genericType == typeof(List<>)){
-                        entries.Add(new SearchTreeEntry(new GUIContent(field.Name,icon)){
+                        list.Add(new SearchTreeEntry(new GUIContent(field.Name,icon)){
                             level = 1,
                             userData = new InternalSearchTreeUserData(){
                                 List = field.GetValue(blackboardData) as IList,
@@ -39,24 +43,20 @@ namespace TNode.Editor{
                     }
                 }
             }
-
+            Debug.Log($"{list.Count}");
-            return entries;
+            return list;
 
         }
 
         public bool OnSelectEntry(SearchTreeEntry SearchTreeEntry, SearchWindowContext context){
             var userData = SearchTreeEntry.userData;
-            var relativePos = context.screenMousePosition - _editor.position.position;
-            var blackboardData  = _graphView.GetBlackboardData();
-            
             if (userData is InternalSearchTreeUserData){
                 var list = ((InternalSearchTreeUserData) userData).List;
                 var type = ((InternalSearchTreeUserData) userData).Type;
                 var newItem = Activator.CreateInstance(type);
-                list.Add(newItem);
+                list?.Add(newItem);
                 return true;
             }
-
             return false;
         }
 

TNode/Editor/Search/NodeSearchWindowProvider.cs

@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Drawing;
-using TNode.BaseViews;
 using TNode.Cache;
 using TNode.Editor.BaseViews;
 using TNode.Editor.Tools.NodeCreator;
@@ -11,7 +9,7 @@ using UnityEditor.Experimental.GraphView;
 using UnityEngine;
 using UnityEngine.UIElements;
 
-namespace TNode.Editor{
+namespace TNode.Editor.Search{
     public class NodeSearchWindowProvider:ScriptableObject,ISearchWindowProvider{
         private Type _graphType;
         private GraphView _graphView;