More serde derives and adjust NodeTemplateIter return value

egui_node_graph/src/id_type.rs

@@ -2,6 +2,7 @@ slotmap::new_key_type! { pub struct NodeId; }
 slotmap::new_key_type! { pub struct InputId; }
 slotmap::new_key_type! { pub struct OutputId; }
 
+#[cfg_attr(feature = "persistence", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
 pub enum AnyParameterId {
     Input(InputId),

egui_node_graph/src/node_finder.rs

@@ -4,6 +4,7 @@ use crate::{color_hex_utils::*, NodeTemplateIter, NodeTemplateTrait};
 
 use egui::*;
 
+#[cfg_attr(feature = "persistence", derive(serde::Serialize, serde::Deserialize))]
 pub struct NodeFinder<NodeTemplate> {
     pub query: String,
     /// Reset every frame. When set, the node finder will be moved at that position
@@ -56,14 +57,13 @@ where
 
                 Frame::default().margin(vec2(10.0, 10.0)).show(ui, |ui| {
                     for kind in all_kinds.all_kinds() {
-                        let kind_name = kind.node_finder_label();
+                        let kind_name = kind.node_finder_label().to_string();
                         if kind_name.contains(self.query.as_str()) {
-                            if query_submit {
-                                submitted_archetype = Some(kind);
-                                query_submit = false;
-                            }
                             if ui.selectable_label(false, kind_name).clicked() {
                                 submitted_archetype = Some(kind);
+                            } else if query_submit {
+                                submitted_archetype = Some(kind);
+                                query_submit = false;
                             }
                         }
                     }
@@ -71,6 +71,6 @@ where
             });
         });
 
-        submitted_archetype.cloned()
+        submitted_archetype
     }
 }

egui_node_graph/src/traits.rs

@@ -50,7 +50,7 @@ where
 /// the node finder.
 pub trait NodeTemplateIter {
     type Item;
-    fn all_kinds(&self) -> Box<dyn Iterator<Item = &Self::Item> + '_>;
+    fn all_kinds(&self) -> Vec<Self::Item>;
 }
 
 /// This trait must be implemented by the `NodeTemplate` generic parameter of

egui_node_graph/src/ui_state.rs

@@ -10,6 +10,7 @@ pub struct PanZoom {
     pub zoom: f32,
 }
 
+#[cfg_attr(feature = "persistence", derive(Serialize, Deserialize))]
 pub struct GraphEditorState<NodeData, DataType, ValueType, NodeTemplate, UserState> {
     pub graph: Graph<NodeData, DataType, ValueType>,
     /// Nodes are drawn in this order. Draw order is important because nodes

egui_node_graph_example/src/app.rs

@@ -195,22 +195,16 @@ pub struct AllMyNodeTemplates;
 impl NodeTemplateIter for AllMyNodeTemplates {
     type Item = MyNodeTemplate;
 
-    fn all_kinds(&self) -> Box<dyn Iterator<Item = &Self::Item> + '_> {
+    fn all_kinds(&self) -> Vec<Self::Item> {
         // This function must return a list of node kinds, which the node finder
         // will use to display it to the user. Crates like strum can reduce the
         // boilerplate in enumerating all variants of an enum.
-        //
+        vec![
-        // The Box here is required because traits in Rust cannot be generic
+            MyNodeTemplate::AddScalar,
-        // over return parameters, so you can't return an iterator.
+            MyNodeTemplate::SubtractScalar,
-        Box::new(
+            MyNodeTemplate::VectorTimesScalar,
-            [
+            MyNodeTemplate::AddVector,
-                MyNodeTemplate::AddScalar,
+        ]
-                MyNodeTemplate::SubtractScalar,
-                MyNodeTemplate::VectorTimesScalar,
-                MyNodeTemplate::AddVector,
-            ]
-            .iter(),
-        )
     }
 }