feat: rework RenderedElement, prepare for JSON project format

6 files changed, 88 insertions, 57 deletions

diff --git a/Cargo.lock b/Cargo.lock
index d12997d..baeab67 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1246,6 +1246,8 @@ dependencies = [
  "iced_aw",
  "iced_drop",
  "rust-format",
+ "serde",
+ "serde_json",
  "tokio",
  "unique_id",
 ]
diff --git a/iced_builder/Cargo.toml b/iced_builder/Cargo.toml
index febff28..8106b09 100644
--- a/iced_builder/Cargo.toml
+++ b/iced_builder/Cargo.toml
@@ -12,6 +12,8 @@ keywords = ["gui", "iced"]
 iced = { version = "0.12.1", features = [ "image","svg","canvas","qr_code","advanced","tokio","highlighter"] }
 iced_aw = { version = "0.9.3", default-features = false, features = ["menu","color_picker"] }
 iced_drop = { path = "../iced_drop" }
+serde = { version = "1.0.210", features = ["derive"] }
+serde_json = "1.0.128"
 tokio = { version = "1.40.0", features = ["fs"] }
 rust-format = "0.3.4"
 unique_id = "0.1.5"
diff --git a/iced_builder/src/codegen/mod.rs b/iced_builder/src/codegen/mod.rs
index 923ef99..927b6e4 100644
--- a/iced_builder/src/codegen/mod.rs
+++ b/iced_builder/src/codegen/mod.rs
@@ -1,13 +1,18 @@
 use rust_format::{Config, Edition, Formatter, RustFmt};
 
-use crate::types::{rendered_element::RenderedElement, ElementName};
+use crate::types::{
+    rendered_element::{container, row, svg, text, RenderedElement},
+    ElementName,
+};
 
 impl RenderedElement {
     fn props_codegen(&self) -> String {
         let mut props_string = String::new();
 
         for (k, v) in self.props.clone() {
-            props_string = format!("{props_string}.{k}({v})");
+            if let Some(value) = v {
+                props_string = format!("{props_string}.{k}({value})");
+            }
         }
 
         props_string
@@ -20,25 +25,18 @@ impl RenderedElement {
 
         let mut elements = String::new();
 
-        match self.name {
-            ElementName::Column | ElementName::Row | ElementName::Container => {
-                for element in &self.child_elements {
-                    let (c_imports, children) = element.codegen();
-                    imports = format!("{imports}{c_imports}");
-                    elements = format!("{elements}{},", children);
-                }
+        if let Some(els) = &self.child_elements {
+            for element in els {
+                let (c_imports, children) = element.codegen();
+                imports = format!("{imports}{c_imports}");
+                elements = format!("{elements}{},", children);
             }
-            _ => {}
         }
 
         match &self.name {
             ElementName::Container => {
                 imports = format!("{imports}container,");
-                view = if self.child_elements.len() < 2 {
-                    format!("{view}\ncontainer({elements}){props}")
-                } else {
-                    format!("{view}\ncontainer(){props}")
-                };
+                view = format!("{view}\ncontainer({elements}){props}");
             }
             ElementName::Row => {
                 imports = format!("{imports}row,");
@@ -139,20 +137,13 @@ impl RenderedElement {
     }
 
     pub fn test() -> RenderedElement {
-        let mut text1 = RenderedElement::new(ElementName::Text("wow"));
-        text1.set_property("height", "120.5");
-        text1.set_property("width", "230");
-
-        let element = RenderedElement::new(ElementName::Container).push(RenderedElement::from_vec(
-            ElementName::Row,
-            vec![
-                text1,
-                RenderedElement::new(ElementName::Text("heh")),
-                RenderedElement::new(ElementName::SVG(
-                    "/mnt/drive_d/git/obs-website/src/lib/assets/bars-solid.svg",
-                )),
-            ],
-        ));
+        let text1 = text("wow").option("height", "120.5").option("width", "230");
+
+        let element = container(row(vec![
+            text1,
+            text("heh"),
+            svg("/mnt/drive_d/git/obs-website/src/lib/assets/bars-solid.svg"),
+        ]));
 
         element
     }
diff --git a/iced_builder/src/main.rs b/iced_builder/src/main.rs
index 42ea627..971adce 100644
--- a/iced_builder/src/main.rs
+++ b/iced_builder/src/main.rs
@@ -132,7 +132,7 @@ impl Application for App {
             }
             Message::Drop(name, point, _) => {
                 return iced_drop::zones_on_point(
-                    move |zones| Message::HandleZones(name, zones),
+                    move |zones| Message::HandleZones(name.clone(), zones),
                     point,
                     None,
                     None,
@@ -231,7 +231,11 @@ impl Application for App {
                                 .on_action(Message::EditorAction)
                                 .highlight::<Highlighter>(
                                     highlighter::Settings {
-                                        theme: highlighter::Theme::Base16Mocha,
+                                        theme: if self.dark_theme {
+                                            highlighter::Theme::Base16Mocha
+                                        } else {
+                                            highlighter::Theme::InspiredGitHub
+                                        },
                                         extension: "rs".to_string(),
                                     },
                                     |highlight, _theme| highlight.to_format(),
@@ -314,7 +318,7 @@ fn items_list_view(items: Vec<types::ElementName>) -> Element<'static, Message>
         let value = item.clone();
         column = column.push(
             droppable(text(value.to_string()))
-                .on_drop(move |point, rect| Message::Drop(value, point, rect)),
+                .on_drop(move |point, rect| Message::Drop(value.clone(), point, rect)),
         );
     }
 
diff --git a/iced_builder/src/types/mod.rs b/iced_builder/src/types/mod.rs
index eaf1686..def04cf 100644
--- a/iced_builder/src/types/mod.rs
+++ b/iced_builder/src/types/mod.rs
@@ -1,18 +1,19 @@
 pub mod rendered_element;
 
 use rendered_element::RenderedElement;
+use serde::{Deserialize, Serialize};
 
 pub struct DesignerState {
     pub designer_content: Option<RenderedElement>,
     pub designer_page: DesignerPage,
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum ElementName {
-    Text(&'static str),
-    Button(&'static str),
-    SVG(&'static str),
-    Image(&'static str),
+    Text(String),
+    Button(String),
+    SVG(String),
+    Image(String),
     Container,
     Row,
     Column,
@@ -20,10 +21,10 @@ pub enum ElementName {
 
 impl ElementName {
     pub const ALL: [Self; 7] = [
-        Self::Text(""),
-        Self::Button(""),
-        Self::SVG(""),
-        Self::Image(""),
+        Self::Text(String::new()),
+        Self::Button(String::new()),
+        Self::SVG(String::new()),
+        Self::Image(String::new()),
         Self::Container,
         Self::Row,
         Self::Column,
diff --git a/iced_builder/src/types/rendered_element.rs b/iced_builder/src/types/rendered_element.rs
index f05594d..1938aa0 100644
--- a/iced_builder/src/types/rendered_element.rs
+++ b/iced_builder/src/types/rendered_element.rs
@@ -1,47 +1,78 @@
 use std::collections::HashMap;
 
+use serde::{Deserialize, Serialize};
 use unique_id::{string::StringGenerator, Generator};
 
-use iced::advanced::widget::Id;
-
 use super::ElementName;
 
-#[derive(Debug)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct RenderedElement {
-    pub id: Id,
-    pub child_elements: Vec<RenderedElement>,
+    pub id: String,
+    pub child_elements: Option<Vec<RenderedElement>>,
     pub name: ElementName,
-    pub props: HashMap<&'static str, &'static str>,
+    pub props: HashMap<String, Option<String>>,
 }
 
 impl RenderedElement {
-    pub fn new(name: ElementName) -> Self {
+    fn new(name: ElementName) -> Self {
         let gen = StringGenerator::default();
         Self {
-            id: Id::new(gen.next_id()),
-            child_elements: vec![],
+            id: gen.next_id(),
+            child_elements: None,
             name,
             props: HashMap::new(),
         }
     }
 
-    pub fn from_vec(name: ElementName, child_elements: Vec<RenderedElement>) -> Self {
+    fn from_vec(name: ElementName, child_elements: Vec<RenderedElement>) -> Self {
         let gen = StringGenerator::default();
         Self {
-            id: Id::new(gen.next_id()),
-            child_elements,
+            id: gen.next_id(),
+            child_elements: Some(child_elements),
             name,
             props: HashMap::new(),
         }
     }
 
     pub fn push(mut self, element: RenderedElement) -> Self {
-        self.child_elements.push(element);
+        if let Some(els) = self.child_elements.as_mut() {
+            els.push(element);
+        } else {
+            self.child_elements = Some(vec![element]);
+        }
         self
     }
 
-    pub fn set_property(&mut self, prop: &'static str, value: &'static str) {
-        let prop_ref = self.props.entry(prop).or_insert(value);
-        *prop_ref = value;
+    pub fn option(mut self, prop: &'static str, value: &'static str) -> Self {
+        let prop_ref = self
+            .props
+            .entry(prop.to_owned())
+            .or_insert(Some(value.to_owned()));
+        *prop_ref = Some(value.to_owned());
+        self
     }
 }
+
+pub fn text(text: &str) -> RenderedElement {
+    RenderedElement::new(ElementName::Text(text.to_owned()))
+}
+
+pub fn button(text: &str) -> RenderedElement {
+    RenderedElement::new(ElementName::Button(text.to_owned()))
+}
+
+pub fn svg(path: &str) -> RenderedElement {
+    RenderedElement::new(ElementName::SVG(path.to_owned()))
+}
+
+pub fn image(path: &str) -> RenderedElement {
+    RenderedElement::new(ElementName::Image(path.to_owned()))
+}
+
+pub fn container(content: RenderedElement) -> RenderedElement {
+    RenderedElement::from_vec(ElementName::Container, vec![content])
+}
+
+pub fn row(child_elements: Vec<RenderedElement>) -> RenderedElement {
+    RenderedElement::from_vec(ElementName::Row, child_elements)
+}