Plumb layer panel (#107)

* WIP ExpandFolder handling

* Implement response parsing in typescript

* Update layer panel with list sent by wasm

* Add events for layer interaction

* Add proper default naming

* Fix displaying of the eye icon

* Attach path to LayerPanelEntry

* Fix lint issues

Co-authored-by: Keavon Chambers <keavon@keavon.com>

core/document/src/document.rs

@@ -1,6 +1,6 @@
 use crate::{
 	layers::{self, Folder, Layer, LayerData, LayerDataTypes, Line, PolyLine, Rect, Shape},
-	response::{LayerPanelEntry, LayerType},
+	response::LayerPanelEntry,
 	DocumentError, DocumentResponse, LayerId, Operation,
 };
 
@@ -172,16 +172,12 @@ impl Document {
 	/// any actual data, but rather metadata such as visibility and names of the layers.
 	pub fn layer_panel(&self, path: &[LayerId]) -> Result<Vec<LayerPanelEntry>, DocumentError> {
 		let folder = self.document_folder(path)?;
-		let l_type = |layer: &LayerDataTypes| match layer {
-			LayerDataTypes::Folder(_) => LayerType::Folder,
-			_ => LayerType::Shape,
-		};
-		let translate = |layer: &Layer| LayerPanelEntry {
-			name: layer.name.clone().unwrap_or_else(|| String::from("UnnamedFolder")),
-			visible: layer.visible,
-			layer_type: l_type(&layer.data),
-		};
-		let entries = folder.layers().iter().map(|layer| translate(layer)).collect();
+		let entries = folder
+			.layers()
+			.iter()
+			.zip(folder.layer_ids.iter())
+			.map(|(layer, id)| LayerPanelEntry::from_layer(layer, [path, &[*id]].concat()))
+			.collect();
 		Ok(entries)
 	}
 

core/document/src/layers/folder.rs

@@ -9,6 +9,7 @@ pub struct Folder {
 	next_assignment_id: LayerId,
 	pub layer_ids: Vec<LayerId>,
 	layers: Vec<Layer>,
+	pub collapsed: bool,
 }
 
 impl LayerData for Folder {
@@ -87,6 +88,7 @@ impl Default for Folder {
 			layer_ids: vec![],
 			layers: vec![],
 			next_assignment_id: 0,
+			collapsed: false,
 		}
 	}
 }

core/document/src/response.rs

@@ -1,4 +1,7 @@
-use crate::LayerId;
+use crate::{
+	layers::{Layer, LayerDataTypes},
+	LayerId,
+};
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
@@ -7,12 +10,19 @@ pub struct LayerPanelEntry {
 	pub name: String,
 	pub visible: bool,
 	pub layer_type: LayerType,
+	pub collapsed: bool,
+	pub path: Vec<LayerId>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum LayerType {
 	Folder,
 	Shape,
+	Circle,
+	Rect,
+	Line,
+	PolyLine,
+	Ellipse,
 }
 
 impl fmt::Display for LayerType {
@@ -20,12 +30,47 @@ impl fmt::Display for LayerType {
 		let name = match self {
 			LayerType::Folder => "folder",
 			LayerType::Shape => "shape",
+			LayerType::Rect => "rect",
+			LayerType::Line => "line",
+			LayerType::Circle => "circle",
+			LayerType::PolyLine => "poly line",
+			LayerType::Ellipse => "ellipse",
 		};
 
 		formatter.write_str(name)
 	}
 }
 
+impl From<&LayerDataTypes> for LayerType {
+	fn from(data: &LayerDataTypes) -> Self {
+		use LayerDataTypes::*;
+		match data {
+			Folder(_) => LayerType::Folder,
+			Shape(_) => LayerType::Shape,
+			Circle(_) => LayerType::Circle,
+			Rect(_) => LayerType::Rect,
+			Line(_) => LayerType::Line,
+			PolyLine(_) => LayerType::PolyLine,
+			Ellipse(_) => LayerType::Ellipse,
+		}
+	}
+}
+
+impl LayerPanelEntry {
+	pub fn from_layer(layer: &Layer, path: Vec<LayerId>) -> Self {
+		let layer_type: LayerType = (&layer.data).into();
+		let name = layer.name.clone().unwrap_or_else(|| format!("Unnamed {}", layer_type));
+		let collapsed = if let LayerDataTypes::Folder(f) = &layer.data { f.collapsed } else { true };
+		Self {
+			name,
+			visible: layer.visible,
+			layer_type,
+			collapsed,
+			path,
+		}
+	}
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[repr(C)]
 // TODO - Make Copy when possible

core/document/src/shape_points.rs

@@ -1,7 +1,6 @@
 use std::{fmt, ops::Add};
 
 use kurbo::{PathEl, Point, Vec2};
-use log::info;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct ShapePoints {
@@ -47,7 +46,6 @@ impl std::fmt::Display for ShapePoints {
 			let sine = theta.sin();
 			Vec2::new(v.x * cosine - v.y * sine, v.x * sine + v.y * cosine)
 		}
-		info!("sides{}", self.sides);
 		for i in 0..self.sides {
 			let radians = self.apothem_offset_angle() * ((i * 2 + (self.sides % 2)) as f64);
 			let offset = rotate(&self.extent, radians);