Add colors in Rust (#78)

* 🎨 Add colors in Rust

* 🌿 Use an option for the properties and #[repr(C)]

* ❌ Remove WASM dependency on document.

* 😎 Wrap Fill and stroke in a style struct.

* 📦 Use crate::Color

* Merge Add transactions for temporary modifications to the document

* Run cargo fmt

* Color without a 'U'

core/document/src/color.rs

@@ -0,0 +1,65 @@
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct Color {
+	red: f32,
+	green: f32,
+	blue: f32,
+	alpha: f32,
+}
+
+impl Color {
+	pub const BLACK: Color = Color::from_unsafe(0., 0., 0.);
+	pub const WHITE: Color = Color::from_unsafe(1., 1., 1.);
+	pub const RED: Color = Color::from_unsafe(1., 0., 0.);
+	pub const GREEN: Color = Color::from_unsafe(0., 1., 0.);
+	pub const BLUE: Color = Color::from_unsafe(0., 0., 1.);
+
+	pub fn from_rgbaf32(red: f32, green: f32, blue: f32, alpha: f32) -> Option<Color> {
+		let color = Color { red, green, blue, alpha };
+		if [red, green, blue, alpha].iter().any(|c| c.is_sign_negative() || !c.is_finite()) {
+			return None;
+		}
+		Some(color)
+	}
+
+	const fn from_unsafe(red: f32, green: f32, blue: f32) -> Color {
+		Color { red, green, blue, alpha: 1. }
+	}
+
+	pub fn from_rgb8(red: u8, green: u8, blue: u8) -> Color {
+		Color::from_rgba8(red, green, blue, 255)
+	}
+	pub fn from_rgba8(red: u8, green: u8, blue: u8, alpha: u8) -> Color {
+		let map = |int_color| int_color as f32 / 255.0;
+		Color {
+			red: map(red),
+			green: map(green),
+			blue: map(blue),
+			alpha: map(alpha),
+		}
+	}
+	pub fn r(&self) -> f32 {
+		self.red
+	}
+	pub fn g(&self) -> f32 {
+		self.green
+	}
+	pub fn b(&self) -> f32 {
+		self.blue
+	}
+	pub fn a(&self) -> f32 {
+		self.alpha
+	}
+	pub fn components(&self) -> (f32, f32, f32, f32) {
+		(self.red, self.green, self.blue, self.alpha)
+	}
+	pub fn as_hex(&self) -> String {
+		format!(
+			"{:02X?}{:02X?}{:02X?}{:02X?}",
+			(self.r() * 255.) as u8,
+			(self.g() * 255.) as u8,
+			(self.b() * 255.) as u8,
+			(self.a() * 255.) as u8,
+		)
+	}
+}

core/document/src/document.rs

@@ -0,0 +1,234 @@
+use crate::{
+	layers::{self, Folder, Layer, LayerData, LayerDataTypes, Line, Rect, Shape},
+	DocumentError, LayerId, Operation,
+};
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Document {
+	pub root: layers::Folder,
+	pub work: Folder,
+	pub work_mount_path: Vec<LayerId>,
+	pub work_operations: Vec<Operation>,
+	pub work_mounted: bool,
+}
+
+impl Default for Document {
+	fn default() -> Self {
+		Self {
+			root: Folder::default(),
+			work: Folder::default(),
+			work_mount_path: Vec::new(),
+			work_operations: Vec::new(),
+			work_mounted: false,
+		}
+	}
+}
+
+fn split_path(path: &[LayerId]) -> Result<(&[LayerId], LayerId), DocumentError> {
+	let id = path.last().ok_or(DocumentError::InvalidPath)?;
+	let folder_path = &path[0..path.len() - 1];
+	Ok((folder_path, *id))
+}
+
+impl Document {
+	pub fn render(&self, path: &mut Vec<LayerId>) -> String {
+		if !self.work_mount_path.as_slice().starts_with(path) {
+			match &self.layer(path).unwrap().data {
+				LayerDataTypes::Folder(_) => (),
+				element => {
+					path.pop();
+					return element.render();
+				}
+			}
+		}
+		if path.as_slice() == self.work_mount_path {
+			let mut out = self.document_folder(path).unwrap().render();
+			out += self.work.render().as_str();
+			path.pop();
+			return out;
+		}
+		let mut out = String::with_capacity(30);
+		for element in self.folder(path).unwrap().layer_ids.iter() {
+			path.push(*element);
+			out += self.render(path).as_str();
+		}
+		out
+	}
+
+	fn is_mounted(&self, mount_path: &[LayerId], path: &[LayerId]) -> bool {
+		path.starts_with(mount_path) && self.work_mounted
+	}
+
+	pub fn folder(&self, mut path: &[LayerId]) -> Result<&Folder, DocumentError> {
+		let mut root = &self.root;
+		if self.is_mounted(self.work_mount_path.as_slice(), path) {
+			path = &path[self.work_mount_path.len()..];
+			root = &self.work;
+		}
+		for id in path {
+			root = root.folder(*id).ok_or(DocumentError::LayerNotFound)?;
+		}
+		Ok(root)
+	}
+
+	pub fn folder_mut(&mut self, mut path: &[LayerId]) -> Result<&mut Folder, DocumentError> {
+		let mut root = if self.is_mounted(self.work_mount_path.as_slice(), path) {
+			path = &path[self.work_mount_path.len()..];
+			&mut self.work
+		} else {
+			&mut self.root
+		};
+		for id in path {
+			root = root.folder_mut(*id).ok_or(DocumentError::LayerNotFound)?;
+		}
+		Ok(root)
+	}
+
+	pub fn document_folder(&self, path: &[LayerId]) -> Result<&Folder, DocumentError> {
+		let mut root = &self.root;
+		for id in path {
+			root = root.folder(*id).ok_or(DocumentError::LayerNotFound)?;
+		}
+		Ok(root)
+	}
+
+	pub fn document_folder_mut(&mut self, path: &[LayerId]) -> Result<&mut Folder, DocumentError> {
+		let mut root = &mut self.root;
+		for id in path {
+			root = root.folder_mut(*id).ok_or(DocumentError::LayerNotFound)?;
+		}
+		Ok(root)
+	}
+
+	pub fn layer(&self, path: &[LayerId]) -> Result<&Layer, DocumentError> {
+		let (path, id) = split_path(path)?;
+		self.folder(path)?.layer(id).ok_or(DocumentError::LayerNotFound)
+	}
+
+	pub fn layer_mut(&mut self, path: &[LayerId]) -> Result<&mut Layer, DocumentError> {
+		let (path, id) = split_path(path)?;
+		self.folder_mut(path)?.layer_mut(id).ok_or(DocumentError::LayerNotFound)
+	}
+
+	pub fn set_layer(&mut self, path: &[LayerId], layer: Layer) -> Result<(), DocumentError> {
+		let mut folder = &mut self.root;
+		if let Ok((path, id)) = split_path(path) {
+			folder = self.folder_mut(path)?;
+			if let Some(folder_layer) = folder.layer_mut(id) {
+				*folder_layer = layer;
+				return Ok(());
+			}
+		}
+		folder.add_layer(layer, -1).ok_or(DocumentError::IndexOutOfBounds)?;
+		Ok(())
+	}
+
+	/// Passing a negative `insert_index` indexes relative to the end
+	/// -1 is equivalent to adding the layer to the top
+	pub fn add_layer(&mut self, path: &[LayerId], layer: Layer, insert_index: isize) -> Result<LayerId, DocumentError> {
+		let folder = self.folder_mut(path)?;
+		folder.add_layer(layer, insert_index).ok_or(DocumentError::IndexOutOfBounds)
+	}
+
+	pub fn delete(&mut self, path: &[LayerId]) -> Result<(), DocumentError> {
+		let (path, id) = split_path(path)?;
+		self.document_folder_mut(path)?.remove_layer(id)?;
+		Ok(())
+	}
+
+	pub fn handle_operation<F: Fn(String)>(&mut self, operation: Operation, update_frontend: &F) -> Result<(), DocumentError> {
+		self.work_operations.push(operation.clone());
+		match operation {
+			Operation::AddCircle { path, insert_index, cx, cy, r, style } => {
+				self.add_layer(&path, Layer::new(LayerDataTypes::Circle(layers::Circle::new(kurbo::Point::new(cx, cy), r, style))), insert_index)?;
+
+				update_frontend(self.render(&mut vec![]));
+			}
+			Operation::AddRect {
+				path,
+				insert_index,
+				x0,
+				y0,
+				x1,
+				y1,
+				style,
+			} => {
+				self.add_layer(
+					&path,
+					Layer::new(LayerDataTypes::Rect(Rect::new(kurbo::Point::new(x0, y0), kurbo::Point::new(x1, y1), style))),
+					insert_index,
+				)?;
+
+				update_frontend(self.render(&mut vec![]));
+			}
+			Operation::AddLine {
+				path,
+				insert_index,
+				x0,
+				y0,
+				x1,
+				y1,
+				style,
+			} => {
+				self.add_layer(
+					&path,
+					Layer::new(LayerDataTypes::Line(Line::new(kurbo::Point::new(x0, y0), kurbo::Point::new(x1, y1), style))),
+					insert_index,
+				)?;
+
+				update_frontend(self.render(&mut vec![]));
+			}
+			Operation::AddShape {
+				path,
+				insert_index,
+				x0,
+				y0,
+				x1,
+				y1,
+				sides,
+				style,
+			} => {
+				let s = Shape::new(kurbo::Point::new(x0, y0), kurbo::Vec2 { x: x0 - x1, y: y0 - y1 }, sides, style);
+				self.add_layer(&path, Layer::new(LayerDataTypes::Shape(s)), insert_index)?;
+
+				update_frontend(self.render(&mut vec![]));
+			}
+			Operation::DeleteLayer { path } => {
+				self.delete(&path)?;
+
+				update_frontend(self.render(&mut vec![]));
+			}
+			Operation::AddFolder { path } => self.set_layer(&path, Layer::new(LayerDataTypes::Folder(Folder::default())))?,
+			Operation::MountWorkingFolder { path } => {
+				self.work_operations.clear();
+				self.work_mount_path = path;
+				self.work = Folder::default();
+				self.work_mounted = true;
+			}
+			Operation::DiscardWorkingFolder => {
+				self.work_operations.clear();
+				self.work_mount_path = vec![];
+				self.work = Folder::default();
+				self.work_mounted = false;
+			}
+			Operation::ClearWorkingFolder => {
+				self.work_operations.clear();
+				self.work = Folder::default();
+			}
+			Operation::CommitTransaction => {
+				let mut ops = Vec::new();
+				std::mem::swap(&mut ops, &mut self.work_operations);
+				let len = ops.len() - 1;
+				self.work_mounted = false;
+				self.work_mount_path = vec![];
+				self.work = Folder::default();
+				for operation in ops.into_iter().take(len) {
+					self.handle_operation(operation, update_frontend)?
+				}
+
+				update_frontend(self.render(&mut vec![]));
+			}
+		}
+		Ok(())
+	}
+}

core/document/src/layers/circle.rs

@@ -0,0 +1,29 @@
+use super::style;
+use super::LayerData;
+
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct Circle {
+	shape: kurbo::Circle,
+	style: style::PathStyle,
+}
+
+impl Circle {
+	pub fn new(center: impl Into<kurbo::Point>, radius: f64, style: style::PathStyle) -> Circle {
+		Circle {
+			shape: kurbo::Circle::new(center, radius),
+			style,
+		}
+	}
+}
+
+impl LayerData for Circle {
+	fn render(&self) -> String {
+		format!(
+			r#"<circle cx="{}" cy="{}" r="{}" {} />"#,
+			self.shape.center.x,
+			self.shape.center.y,
+			self.shape.radius,
+			self.style.render(),
+		)
+	}
+}

core/document/src/layers/folder.rs

@@ -0,0 +1,87 @@
+use crate::{DocumentError, LayerId};
+
+use super::{Layer, LayerData, LayerDataTypes};
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Folder {
+	next_assignment_id: LayerId,
+	pub layer_ids: Vec<LayerId>,
+	layers: Vec<Layer>,
+}
+
+impl LayerData for Folder {
+	fn render(&self) -> String {
+		self.layers
+			.iter()
+			.filter(|layer| layer.visible)
+			.map(|layer| layer.data.render())
+			.fold(String::with_capacity(self.layers.len() * 30), |s, n| s + "\n" + &n)
+	}
+}
+impl Folder {
+	pub fn add_layer(&mut self, layer: Layer, insert_index: isize) -> Option<LayerId> {
+		let mut insert_index = insert_index as i128;
+		if insert_index < 0 {
+			insert_index = self.layers.len() as i128 + insert_index as i128 + 1;
+		}
+
+		if insert_index <= self.layers.len() as i128 && insert_index >= 0 {
+			self.layers.insert(insert_index as usize, layer);
+			self.layer_ids.insert(insert_index as usize, self.next_assignment_id);
+			self.next_assignment_id += 1;
+			Some(self.next_assignment_id - 1)
+		} else {
+			None
+		}
+	}
+
+	pub fn remove_layer(&mut self, id: LayerId) -> Result<(), DocumentError> {
+		let pos = self.layer_ids.iter().position(|x| *x == id).ok_or(DocumentError::LayerNotFound)?;
+		self.layers.remove(pos);
+		self.layer_ids.remove(pos);
+		Ok(())
+	}
+
+	/// Returns a list of layers in the folder
+	pub fn list_layers(&self) -> &[LayerId] {
+		self.layer_ids.as_slice()
+	}
+
+	pub fn layer(&self, id: LayerId) -> Option<&Layer> {
+		let pos = self.layer_ids.iter().position(|x| *x == id)?;
+		Some(&self.layers[pos])
+	}
+
+	pub fn layer_mut(&mut self, id: LayerId) -> Option<&mut Layer> {
+		let pos = self.layer_ids.iter().position(|x| *x == id)?;
+		Some(&mut self.layers[pos])
+	}
+
+	pub fn folder(&self, id: LayerId) -> Option<&Folder> {
+		match self.layer(id) {
+			Some(Layer {
+				data: LayerDataTypes::Folder(folder), ..
+			}) => Some(&folder),
+			_ => None,
+		}
+	}
+
+	pub fn folder_mut(&mut self, id: LayerId) -> Option<&mut Folder> {
+		match self.layer_mut(id) {
+			Some(Layer {
+				data: LayerDataTypes::Folder(folder), ..
+			}) => Some(folder),
+			_ => None,
+		}
+	}
+}
+
+impl Default for Folder {
+	fn default() -> Self {
+		Self {
+			layer_ids: vec![],
+			layers: vec![],
+			next_assignment_id: 0,
+		}
+	}
+}

core/document/src/layers/line.rs

@@ -0,0 +1,30 @@
+use super::style;
+use super::LayerData;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Line {
+	shape: kurbo::Line,
+	style: style::PathStyle,
+}
+
+impl Line {
+	pub fn new(p0: impl Into<kurbo::Point>, p1: impl Into<kurbo::Point>, style: style::PathStyle) -> Line {
+		Line {
+			shape: kurbo::Line::new(p0, p1),
+			style,
+		}
+	}
+}
+
+impl LayerData for Line {
+	fn render(&self) -> String {
+		format!(
+			r#"<line x1="{}" y1="{}" x2="{}" y2="{}" {} />"#,
+			self.shape.p0.x,
+			self.shape.p0.y,
+			self.shape.p1.x,
+			self.shape.p1.y,
+			self.style.render(),
+		)
+	}
+}

core/document/src/layers/mod.rs

@@ -0,0 +1,54 @@
+pub mod style;
+
+pub mod circle;
+pub use circle::Circle;
+
+pub mod line;
+pub use line::Line;
+
+pub mod rect;
+pub use rect::Rect;
+
+pub mod shape;
+pub use shape::Shape;
+
+pub mod folder;
+pub use folder::Folder;
+
+pub trait LayerData {
+	fn render(&self) -> String;
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum LayerDataTypes {
+	Folder(Folder),
+	Circle(Circle),
+	Rect(Rect),
+	Line(Line),
+	Shape(Shape),
+}
+
+impl LayerDataTypes {
+	pub fn render(&self) -> String {
+		match self {
+			Self::Folder(f) => f.render(),
+			Self::Circle(c) => c.render(),
+			Self::Rect(r) => r.render(),
+			Self::Line(l) => l.render(),
+			Self::Shape(s) => s.render(),
+		}
+	}
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Layer {
+	pub visible: bool,
+	pub name: Option<String>,
+	pub data: LayerDataTypes,
+}
+
+impl Layer {
+	pub fn new(data: LayerDataTypes) -> Self {
+		Self { visible: true, name: None, data }
+	}
+}

core/document/src/layers/rect.rs

@@ -0,0 +1,30 @@
+use super::style;
+use super::LayerData;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Rect {
+	shape: kurbo::Rect,
+	style: style::PathStyle,
+}
+
+impl Rect {
+	pub fn new(p0: impl Into<kurbo::Point>, p1: impl Into<kurbo::Point>, style: style::PathStyle) -> Rect {
+		Rect {
+			shape: kurbo::Rect::from_points(p0, p1),
+			style,
+		}
+	}
+}
+
+impl LayerData for Rect {
+	fn render(&self) -> String {
+		format!(
+			r#"<rect x="{}" y="{}" width="{}" height="{}" {} />"#,
+			self.shape.min_x(),
+			self.shape.min_y(),
+			self.shape.width(),
+			self.shape.height(),
+			self.style.render(),
+		)
+	}
+}

core/document/src/layers/shape.rs

@@ -0,0 +1,25 @@
+use crate::shape_points;
+
+use super::style;
+use super::LayerData;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Shape {
+	shape: shape_points::ShapePoints,
+	style: style::PathStyle,
+}
+
+impl Shape {
+	pub fn new(center: impl Into<kurbo::Point>, extent: impl Into<kurbo::Vec2>, sides: u8, style: style::PathStyle) -> Shape {
+		Shape {
+			shape: shape_points::ShapePoints::new(center, extent, sides),
+			style,
+		}
+	}
+}
+
+impl LayerData for Shape {
+	fn render(&self) -> String {
+		format!(r#"<polygon points="{}" {} />"#, self.shape, self.style.render(),)
+	}
+}

core/document/src/layers/style/mod.rs

@@ -0,0 +1,56 @@
+use crate::color::Color;
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct Fill {
+	color: Color,
+}
+impl Fill {
+	pub fn new(color: Color) -> Self {
+		Self { color }
+	}
+	pub fn render(&self) -> String {
+		format!("fill: #{};", self.color.as_hex())
+	}
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct Stroke {
+	color: Color,
+	width: f32,
+}
+
+impl Stroke {
+	pub fn new(color: Color, width: f32) -> Self {
+		Self { color, width }
+	}
+	pub fn render(&self) -> String {
+		format!("stroke: #{};stroke-width:{};", self.color.as_hex(), self.width)
+	}
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct PathStyle {
+	stroke: Option<Stroke>,
+	fill: Option<Fill>,
+}
+impl PathStyle {
+	pub fn new(stroke: Option<Stroke>, fill: Option<Fill>) -> Self {
+		Self { stroke, fill }
+	}
+	pub fn render(&self) -> String {
+		format!(
+			"style=\"{}{}\"",
+			match self.fill {
+				Some(fill) => fill.render(),
+				None => String::new(),
+			},
+			match self.stroke {
+				Some(stroke) => stroke.render(),
+				None => String::new(),
+			},
+		)
+	}
+}

core/document/src/lib.rs

@@ -1,37 +1,12 @@
+pub mod color;
+pub mod document;
+pub mod layers;
 pub mod operation;
-
 mod shape_points;
-pub use kurbo::{Circle, Line, Point, Rect, Vec2};
+
 pub use operation::Operation;
 
-#[derive(Debug, Clone, PartialEq)]
-pub enum LayerType {
-	Folder(Folder),
-	Circle(Circle),
-	Rect(Rect),
-	Line(Line),
-	Shape(shape_points::ShapePoints),
-}
-
-impl LayerType {
-	pub fn render(&self) -> String {
-		match self {
-			Self::Folder(f) => f.render(),
-			Self::Circle(c) => {
-				format!(r#"<circle cx="{}" cy="{}" r="{}" style="fill: #fff;" />"#, c.center.x, c.center.y, c.radius)
-			}
-			Self::Rect(r) => {
-				format!(r#"<rect x="{}" y="{}" width="{}" height="{}" style="fill: #fff;" />"#, r.min_x(), r.min_y(), r.width(), r.height())
-			}
-			Self::Line(l) => {
-				format!(r#"<line x1="{}" y1="{}" x2="{}" y2="{}" style="stroke: #fff;" />"#, l.p0.x, l.p0.y, l.p1.x, l.p1.y)
-			}
-			Self::Shape(s) => {
-				format!(r#"<polygon points="{}" style="fill: #fff;" />"#, s)
-			}
-		}
-	}
-}
+type LayerId = u64;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum DocumentError {
@@ -39,302 +14,3 @@ pub enum DocumentError {
 	InvalidPath,
 	IndexOutOfBounds,
 }
-
-type LayerId = u64;
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Layer {
-	visible: bool,
-	name: Option<String>,
-	data: LayerType,
-}
-
-impl Layer {
-	pub fn new(data: LayerType) -> Self {
-		Self { visible: true, name: None, data }
-	}
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Folder {
-	next_assignment_id: LayerId,
-	layer_ids: Vec<LayerId>,
-	layers: Vec<Layer>,
-}
-
-impl Folder {
-	pub fn render(&self) -> String {
-		self.layers
-			.iter()
-			.filter(|layer| layer.visible)
-			.map(|layer| layer.data.render())
-			.fold(String::with_capacity(self.layers.len() * 30), |s, n| s + "\n" + &n)
-	}
-
-	fn add_layer(&mut self, layer: Layer, insert_index: isize) -> Option<LayerId> {
-		let mut insert_index = insert_index as i128;
-		if insert_index < 0 {
-			insert_index = self.layers.len() as i128 + insert_index as i128 + 1;
-		}
-
-		if insert_index <= self.layers.len() as i128 && insert_index >= 0 {
-			self.layers.insert(insert_index as usize, layer);
-			self.layer_ids.insert(insert_index as usize, self.next_assignment_id);
-			self.next_assignment_id += 1;
-			Some(self.next_assignment_id - 1)
-		} else {
-			None
-		}
-	}
-
-	fn remove_layer(&mut self, id: LayerId) -> Result<(), DocumentError> {
-		let pos = self.layer_ids.iter().position(|x| *x == id).ok_or(DocumentError::LayerNotFound)?;
-		self.layers.remove(pos);
-		self.layer_ids.remove(pos);
-		Ok(())
-	}
-
-	/// Returns a list of layers in the folder
-	pub fn list_layers(&self) -> &[LayerId] {
-		self.layer_ids.as_slice()
-	}
-
-	fn layer(&self, id: LayerId) -> Option<&Layer> {
-		let pos = self.layer_ids.iter().position(|x| *x == id)?;
-		Some(&self.layers[pos])
-	}
-
-	fn layer_mut(&mut self, id: LayerId) -> Option<&mut Layer> {
-		let pos = self.layer_ids.iter().position(|x| *x == id)?;
-		Some(&mut self.layers[pos])
-	}
-
-	fn folder(&self, id: LayerId) -> Option<&Folder> {
-		match self.layer(id) {
-			Some(Layer { data: LayerType::Folder(folder), .. }) => Some(&folder),
-			_ => None,
-		}
-	}
-
-	fn folder_mut(&mut self, id: LayerId) -> Option<&mut Folder> {
-		match self.layer_mut(id) {
-			Some(Layer { data: LayerType::Folder(folder), .. }) => Some(folder),
-			_ => None,
-		}
-	}
-}
-
-impl Default for Folder {
-	fn default() -> Self {
-		Self {
-			layer_ids: vec![],
-			layers: vec![],
-			next_assignment_id: 0,
-		}
-	}
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Document {
-	pub root: Folder,
-	pub work: Folder,
-	pub work_mount_path: Vec<LayerId>,
-	pub work_operations: Vec<Operation>,
-	pub work_mounted: bool,
-}
-
-impl Default for Document {
-	fn default() -> Self {
-		Self {
-			root: Folder::default(),
-			work: Folder::default(),
-			work_mount_path: Vec::new(),
-			work_operations: Vec::new(),
-			work_mounted: false,
-		}
-	}
-}
-
-fn split_path(path: &[LayerId]) -> Result<(&[LayerId], LayerId), DocumentError> {
-	let id = path.last().ok_or(DocumentError::InvalidPath)?;
-	let folder_path = &path[0..path.len() - 1];
-	Ok((folder_path, *id))
-}
-
-impl Document {
-	pub fn render(&self, path: &mut Vec<LayerId>) -> String {
-		if !self.work_mount_path.as_slice().starts_with(path) {
-			match &self.layer(path).unwrap().data {
-				LayerType::Folder(_) => (),
-				element => {
-					path.pop();
-					return element.render();
-				}
-			}
-		}
-		if path.as_slice() == self.work_mount_path {
-			let mut out = self.document_folder(path).unwrap().render();
-			out += self.work.render().as_str();
-			path.pop();
-			return out;
-		}
-		let mut out = String::with_capacity(30);
-		for element in self.folder(path).unwrap().layer_ids.iter() {
-			path.push(*element);
-			out += self.render(path).as_str();
-		}
-		out
-	}
-
-	fn is_mounted(&self, mount_path: &[LayerId], path: &[LayerId]) -> bool {
-		path.starts_with(mount_path) && self.work_mounted
-	}
-
-	pub fn folder(&self, mut path: &[LayerId]) -> Result<&Folder, DocumentError> {
-		let mut root = &self.root;
-		if self.is_mounted(self.work_mount_path.as_slice(), path) {
-			path = &path[self.work_mount_path.len()..];
-			root = &self.work;
-		}
-		for id in path {
-			root = root.folder(*id).ok_or(DocumentError::LayerNotFound)?;
-		}
-		Ok(root)
-	}
-
-	pub fn folder_mut(&mut self, mut path: &[LayerId]) -> Result<&mut Folder, DocumentError> {
-		let mut root = if self.is_mounted(self.work_mount_path.as_slice(), path) {
-			path = &path[self.work_mount_path.len()..];
-			&mut self.work
-		} else {
-			&mut self.root
-		};
-		for id in path {
-			root = root.folder_mut(*id).ok_or(DocumentError::LayerNotFound)?;
-		}
-		Ok(root)
-	}
-
-	pub fn document_folder(&self, path: &[LayerId]) -> Result<&Folder, DocumentError> {
-		let mut root = &self.root;
-		for id in path {
-			root = root.folder(*id).ok_or(DocumentError::LayerNotFound)?;
-		}
-		Ok(root)
-	}
-
-	pub fn document_folder_mut(&mut self, path: &[LayerId]) -> Result<&mut Folder, DocumentError> {
-		let mut root = &mut self.root;
-		for id in path {
-			root = root.folder_mut(*id).ok_or(DocumentError::LayerNotFound)?;
-		}
-		Ok(root)
-	}
-
-	pub fn layer(&self, path: &[LayerId]) -> Result<&Layer, DocumentError> {
-		let (path, id) = split_path(path)?;
-		self.folder(path)?.layer(id).ok_or(DocumentError::LayerNotFound)
-	}
-
-	pub fn layer_mut(&mut self, path: &[LayerId]) -> Result<&mut Layer, DocumentError> {
-		let (path, id) = split_path(path)?;
-		self.folder_mut(path)?.layer_mut(id).ok_or(DocumentError::LayerNotFound)
-	}
-
-	pub fn set_layer(&mut self, path: &[LayerId], layer: Layer) -> Result<(), DocumentError> {
-		let mut folder = &mut self.root;
-		if let Ok((path, id)) = split_path(path) {
-			folder = self.folder_mut(path)?;
-			if let Some(folder_layer) = folder.layer_mut(id) {
-				*folder_layer = layer;
-				return Ok(());
-			}
-		}
-		folder.add_layer(layer, -1).ok_or(DocumentError::IndexOutOfBounds)?;
-		Ok(())
-	}
-
-	/// Passing a negative `insert_index` indexes relative to the end
-	/// -1 is equivalent to adding the layer to the top
-	pub fn add_layer(&mut self, path: &[LayerId], layer: Layer, insert_index: isize) -> Result<LayerId, DocumentError> {
-		let folder = self.folder_mut(path)?;
-		folder.add_layer(layer, insert_index).ok_or(DocumentError::IndexOutOfBounds)
-	}
-
-	pub fn delete(&mut self, path: &[LayerId]) -> Result<(), DocumentError> {
-		let (path, id) = split_path(path)?;
-		self.folder_mut(path)?.remove_layer(id)?;
-		Ok(())
-	}
-
-	pub fn handle_operation<F: Fn(String)>(&mut self, operation: Operation, update_frontend: &F) -> Result<(), DocumentError> {
-		self.work_operations.push(operation.clone());
-		match operation {
-			Operation::AddCircle { path, insert_index, cx, cy, r } => {
-				self.add_layer(&path, Layer::new(LayerType::Circle(Circle::new(Point::new(cx, cy), r))), insert_index)?;
-
-				update_frontend(self.render(&mut vec![]));
-			}
-			Operation::AddRect { path, insert_index, x0, y0, x1, y1 } => {
-				self.add_layer(&path, Layer::new(LayerType::Rect(Rect::from_points(Point::new(x0, y0), Point::new(x1, y1)))), insert_index)?;
-
-				update_frontend(self.render(&mut vec![]));
-			}
-			Operation::AddLine { path, insert_index, x0, y0, x1, y1 } => {
-				self.add_layer(&path, Layer::new(LayerType::Line(Line::new(Point::new(x0, y0), Point::new(x1, y1)))), insert_index)?;
-
-				update_frontend(self.render(&mut vec![]));
-			}
-			Operation::AddShape {
-				path,
-				insert_index,
-				x0,
-				y0,
-				x1,
-				y1,
-				sides,
-			} => {
-				let s = shape_points::ShapePoints::new(Point::new(x0, y0), Vec2 { x: x0 - x1, y: y0 - y1 }, sides);
-				self.add_layer(&path, Layer::new(LayerType::Shape(s)), insert_index)?;
-
-				update_frontend(self.render(&mut vec![]));
-			}
-			Operation::DeleteLayer { path } => {
-				self.delete(&path)?;
-
-				update_frontend(self.render(&mut vec![]));
-			}
-			Operation::AddFolder { path } => self.set_layer(&path, Layer::new(LayerType::Folder(Folder::default())))?,
-			Operation::MountWorkingFolder { path } => {
-				self.work_operations.clear();
-				self.work_mount_path = path;
-				self.work = Folder::default();
-				self.work_mounted = true;
-			}
-			Operation::DiscardWorkingFolder => {
-				self.work_operations.clear();
-				self.work_mount_path = vec![];
-				self.work = Folder::default();
-				self.work_mounted = false;
-			}
-			Operation::ClearWorkingFolder => {
-				self.work_operations.clear();
-				self.work = Folder::default();
-			}
-			Operation::CommitTransaction => {
-				let mut ops = Vec::new();
-				std::mem::swap(&mut ops, &mut self.work_operations);
-				let len = ops.len() - 1;
-				self.work_mounted = false;
-				self.work_mount_path = vec![];
-				self.work = Folder::default();
-				for operation in ops.into_iter().take(len) {
-					self.handle_operation(operation, update_frontend)?
-				}
-
-				update_frontend(self.render(&mut vec![]));
-			}
-		}
-		Ok(())
-	}
-}

core/document/src/operation.rs

@@ -1,4 +1,4 @@
-use crate::LayerId;
+use crate::{layers::style, LayerId};
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Operation {
@@ -8,6 +8,7 @@ pub enum Operation {
 		cx: f64,
 		cy: f64,
 		r: f64,
+		style: style::PathStyle,
 	},
 	AddRect {
 		path: Vec<LayerId>,
@@ -16,6 +17,7 @@ pub enum Operation {
 		y0: f64,
 		x1: f64,
 		y1: f64,
+		style: style::PathStyle,
 	},
 	AddLine {
 		path: Vec<LayerId>,
@@ -24,6 +26,7 @@ pub enum Operation {
 		y0: f64,
 		x1: f64,
 		y1: f64,
+		style: style::PathStyle,
 	},
 	AddShape {
 		path: Vec<LayerId>,
@@ -33,6 +36,7 @@ pub enum Operation {
 		x1: f64,
 		y1: f64,
 		sides: u8,
+		style: style::PathStyle,
 	},
 	DeleteLayer {
 		path: Vec<LayerId>,