Restructure project directories (#333)

`/client/web` -> `/frontend`
`/client/cli` -> *delete for now*
`/client/native` -> *delete for now*
`/core/editor` -> `/editor`
`/core/document` -> `/graphene`
`/core/renderer` -> `/charcoal`
`/core/proc-macro` -> `/proc-macros` *(now plural)*

editor/src/document/document_file.rs

@@ -0,0 +1,501 @@
+pub use super::layer_panel::*;
+use crate::{frontend::layer_panel::*, EditorError};
+use glam::{DAffine2, DVec2};
+use graphene::{document::Document as InternalDocument, LayerId};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+use crate::input::InputPreprocessor;
+use crate::message_prelude::*;
+use graphene::layers::BlendMode;
+use graphene::{DocumentResponse, Operation as DocumentOperation};
+use log::warn;
+
+use std::collections::VecDeque;
+
+use super::movement_handler::{MovementMessage, MovementMessageHandler};
+
+#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, Hash)]
+pub enum FlipAxis {
+	X,
+	Y,
+}
+
+#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, Hash)]
+pub enum AlignAxis {
+	X,
+	Y,
+}
+
+#[derive(PartialEq, Clone, Debug, Serialize, Deserialize, Hash)]
+pub enum AlignAggregate {
+	Min,
+	Max,
+	Center,
+	Average,
+}
+
+#[derive(Clone, Debug)]
+pub struct DocumentMessageHandler {
+	pub document: InternalDocument,
+	pub document_backup: Option<InternalDocument>,
+	pub name: String,
+	pub layer_data: HashMap<Vec<LayerId>, LayerData>,
+	movement_handler: MovementMessageHandler,
+}
+
+impl Default for DocumentMessageHandler {
+	fn default() -> Self {
+		Self {
+			document: InternalDocument::default(),
+			document_backup: None,
+			name: String::from("Untitled Document"),
+			layer_data: vec![(vec![], LayerData::new(true))].into_iter().collect(),
+			movement_handler: MovementMessageHandler::default(),
+		}
+	}
+}
+
+#[impl_message(Message, DocumentsMessage, Document)]
+#[derive(PartialEq, Clone, Debug)]
+pub enum DocumentMessage {
+	#[child]
+	Movement(MovementMessage),
+	DispatchOperation(Box<DocumentOperation>),
+	SelectLayers(Vec<Vec<LayerId>>),
+	SelectAllLayers,
+	DeselectAllLayers,
+	DeleteLayer(Vec<LayerId>),
+	DeleteSelectedLayers,
+	DuplicateSelectedLayers,
+	SetBlendModeForSelectedLayers(BlendMode),
+	SetOpacityForSelectedLayers(f64),
+	AddFolder(Vec<LayerId>),
+	RenameLayer(Vec<LayerId>, String),
+	ToggleLayerVisibility(Vec<LayerId>),
+	FlipSelectedLayers(FlipAxis),
+	ToggleLayerExpansion(Vec<LayerId>),
+	FolderChanged(Vec<LayerId>),
+	StartTransaction,
+	RollbackTransaction,
+	AbortTransaction,
+	CommitTransaction,
+	ExportDocument,
+	RenderDocument,
+	Undo,
+	NudgeSelectedLayers(f64, f64),
+	AlignSelectedLayers(AlignAxis, AlignAggregate),
+	MoveSelectedLayersTo {
+		path: Vec<LayerId>,
+		insert_index: isize,
+	},
+	ReorderSelectedLayers(i32), // relative_position,
+}
+
+impl From<DocumentOperation> for DocumentMessage {
+	fn from(operation: DocumentOperation) -> DocumentMessage {
+		Self::DispatchOperation(Box::new(operation))
+	}
+}
+impl From<DocumentOperation> for Message {
+	fn from(operation: DocumentOperation) -> Message {
+		DocumentMessage::DispatchOperation(Box::new(operation)).into()
+	}
+}
+
+impl DocumentMessageHandler {
+	pub fn active_document(&self) -> &DocumentMessageHandler {
+		self
+	}
+	pub fn active_document_mut(&mut self) -> &mut DocumentMessageHandler {
+		self
+	}
+	fn filter_document_responses(&self, document_responses: &mut Vec<DocumentResponse>) -> bool {
+		let len = document_responses.len();
+		document_responses.retain(|response| !matches!(response, DocumentResponse::DocumentChanged));
+		document_responses.len() != len
+	}
+	fn handle_folder_changed(&mut self, path: Vec<LayerId>) -> Option<Message> {
+		let _ = self.document.render_root();
+		self.layer_data(&path).expanded.then(|| {
+			let children = self.layer_panel(path.as_slice()).expect("The provided Path was not valid");
+			FrontendMessage::ExpandFolder { path, children }.into()
+		})
+	}
+	fn clear_selection(&mut self) {
+		self.layer_data.values_mut().for_each(|layer_data| layer_data.selected = false);
+	}
+	fn select_layer(&mut self, path: &[LayerId]) -> Option<Message> {
+		self.layer_data(path).selected = true;
+		// TODO: Add deduplication
+		(!path.is_empty()).then(|| self.handle_folder_changed(path[..path.len() - 1].to_vec())).flatten()
+	}
+	pub fn layerdata(&self, path: &[LayerId]) -> &LayerData {
+		self.layer_data.get(path).expect("Layerdata does not exist")
+	}
+	pub fn layerdata_mut(&mut self, path: &[LayerId]) -> &mut LayerData {
+		self.layer_data.entry(path.to_vec()).or_insert_with(|| LayerData::new(true))
+	}
+
+	pub fn selected_layers(&self) -> impl Iterator<Item = &Vec<LayerId>> {
+		self.layer_data.iter().filter_map(|(path, data)| data.selected.then(|| path))
+	}
+
+	/// Returns the paths to all layers in order, optionally including only selected or non-selected layers.
+	fn layers_sorted(&self, selected: Option<bool>) -> Vec<Vec<LayerId>> {
+		// Compute the indices for each layer to be able to sort them
+		let mut layers_with_indices: Vec<(Vec<LayerId>, Vec<usize>)> = self
+
+			.layer_data
+			.iter()
+			// 'path.len() > 0' filters out root layer since it has no indices
+			.filter_map(|(path, data)| (!path.is_empty() && (data.selected == selected.unwrap_or(data.selected))).then(|| path.clone()))
+			.filter_map(|path| {
+				// Currently it is possible that layer_data contains layers that are don't actually exist (has been partially fixed in #281)
+				// and thus indices_for_path can return an error. We currently skip these layers and log a warning.
+				// Once this problem is solved this code can be simplified
+				match self.document.indices_for_path(&path) {
+					Err(err) => {
+						warn!("layers_sorted: Could not get indices for the layer {:?}: {:?}", path, err);
+						None
+					}
+					Ok(indices) => Some((path, indices)),
+				}
+			})
+			.collect();
+
+		layers_with_indices.sort_by_key(|(_, indices)| indices.clone());
+		layers_with_indices.into_iter().map(|(path, _)| path).collect()
+	}
+
+	/// Returns the paths to all layers in order
+	pub fn all_layers_sorted(&self) -> Vec<Vec<LayerId>> {
+		self.layers_sorted(None)
+	}
+
+	/// Returns the paths to all selected layers in order
+	pub fn selected_layers_sorted(&self) -> Vec<Vec<LayerId>> {
+		self.layers_sorted(Some(true))
+	}
+
+	/// Returns the paths to all non_selected layers in order
+	#[allow(dead_code)] // used for test cases
+	pub fn non_selected_layers_sorted(&self) -> Vec<Vec<LayerId>> {
+		self.layers_sorted(Some(false))
+	}
+	pub fn with_name(name: String) -> Self {
+		Self {
+			document: InternalDocument::default(),
+			document_backup: None,
+			name,
+			layer_data: vec![(vec![], LayerData::new(true))].into_iter().collect(),
+			movement_handler: MovementMessageHandler::default(),
+		}
+	}
+
+	pub fn layer_data(&mut self, path: &[LayerId]) -> &mut LayerData {
+		layer_data(&mut self.layer_data, path)
+	}
+
+	pub fn backup(&mut self) {
+		self.document_backup = Some(self.document.clone())
+	}
+
+	pub fn rollback(&mut self) -> Result<(), EditorError> {
+		self.backup();
+		self.reset()
+	}
+
+	pub fn reset(&mut self) -> Result<(), EditorError> {
+		match self.document_backup.take() {
+			Some(backup) => {
+				self.document = backup;
+				Ok(())
+			}
+			None => Err(EditorError::NoTransactionInProgress),
+		}
+	}
+
+	pub fn layer_panel_entry(&mut self, path: Vec<LayerId>) -> Result<LayerPanelEntry, EditorError> {
+		self.document.render_root();
+		let data: LayerData = *layer_data(&mut self.layer_data, &path);
+		let layer = self.document.layer(&path)?;
+		let entry = layer_panel_entry(&data, self.document.multiply_transforms(&path).unwrap(), layer, path);
+		Ok(entry)
+	}
+
+	/// Returns a list of `LayerPanelEntry`s intended for display purposes. These don't contain
+	/// any actual data, but ratfolderch as visibility and names of the layers.
+	pub fn layer_panel(&mut self, path: &[LayerId]) -> Result<Vec<LayerPanelEntry>, EditorError> {
+		let folder = self.document.folder(path)?;
+		let paths: Vec<Vec<LayerId>> = folder.layer_ids.iter().map(|id| [path, &[*id]].concat()).collect();
+		let data: Vec<LayerData> = paths.iter().map(|path| *layer_data(&mut self.layer_data, path)).collect();
+		let folder = self.document.folder(path)?;
+		let entries = folder
+			.layers()
+			.iter()
+			.zip(paths.iter().zip(data))
+			.rev()
+			.map(|(layer, (path, data))| {
+				layer_panel_entry(
+					&data,
+					self.document.generate_transform_across_scope(path, Some(self.document.root.transform.inverse())).unwrap(),
+					layer,
+					path.to_vec(),
+				)
+			})
+			.collect();
+		Ok(entries)
+	}
+}
+
+impl MessageHandler<DocumentMessage, &InputPreprocessor> for DocumentMessageHandler {
+	fn process_action(&mut self, message: DocumentMessage, ipp: &InputPreprocessor, responses: &mut VecDeque<Message>) {
+		use DocumentMessage::*;
+		match message {
+			Movement(message) => self.movement_handler.process_action(message, (layer_data(&mut self.layer_data, &[]), &self.document, ipp), responses),
+			DeleteLayer(path) => responses.push_back(DocumentOperation::DeleteLayer { path }.into()),
+			AddFolder(path) => responses.push_back(DocumentOperation::AddFolder { path }.into()),
+			StartTransaction => self.backup(),
+			RollbackTransaction => {
+				self.rollback().unwrap_or_else(|e| log::warn!("{}", e));
+				responses.extend([DocumentMessage::RenderDocument.into(), self.handle_folder_changed(vec![]).unwrap()]);
+			}
+			AbortTransaction => {
+				self.reset().unwrap_or_else(|e| log::warn!("{}", e));
+				responses.extend([DocumentMessage::RenderDocument.into(), self.handle_folder_changed(vec![]).unwrap()]);
+			}
+			CommitTransaction => self.document_backup = None,
+			ExportDocument => {
+				let bbox = self.document.visible_layers_bounding_box().unwrap_or([DVec2::ZERO, ipp.viewport_size.as_f64()]);
+				let size = bbox[1] - bbox[0];
+				responses.push_back(
+					FrontendMessage::ExportDocument {
+						document: format!(
+							r#"<svg xmlns="http://www.w3.org/2000/svg" viewBox="{} {} {} {}">{}{}</svg>"#,
+							bbox[0].x,
+							bbox[0].y,
+							size.x,
+							size.y,
+							"\n",
+							self.document.render_root()
+						),
+					}
+					.into(),
+				)
+			}
+			SetBlendModeForSelectedLayers(blend_mode) => {
+				let active_document = self;
+
+				for path in active_document.layer_data.iter().filter_map(|(path, data)| data.selected.then(|| path.clone())) {
+					responses.push_back(DocumentOperation::SetLayerBlendMode { path, blend_mode }.into());
+				}
+			}
+			SetOpacityForSelectedLayers(opacity) => {
+				let opacity = opacity.clamp(0., 1.);
+
+				for path in self.selected_layers().cloned() {
+					responses.push_back(DocumentOperation::SetLayerOpacity { path, opacity }.into());
+				}
+			}
+			ToggleLayerVisibility(path) => {
+				responses.push_back(DocumentOperation::ToggleVisibility { path }.into());
+			}
+			ToggleLayerExpansion(path) => {
+				self.layer_data(&path).expanded ^= true;
+				responses.extend(self.handle_folder_changed(path));
+			}
+			DeleteSelectedLayers => {
+				for path in self.selected_layers().cloned() {
+					responses.push_back(DocumentOperation::DeleteLayer { path }.into())
+				}
+			}
+			DuplicateSelectedLayers => {
+				for path in self.selected_layers_sorted() {
+					responses.push_back(DocumentOperation::DuplicateLayer { path }.into())
+				}
+			}
+			SelectLayers(paths) => {
+				self.clear_selection();
+				for path in paths {
+					responses.extend(self.select_layer(&path));
+				}
+				// TODO: Correctly update layer panel in clear_selection instead of here
+				responses.extend(self.handle_folder_changed(Vec::new()));
+			}
+			SelectAllLayers => {
+				let all_layer_paths = self.layer_data.keys().filter(|path| !path.is_empty()).cloned().collect::<Vec<_>>();
+				for path in all_layer_paths {
+					responses.extend(self.select_layer(&path));
+				}
+			}
+			DeselectAllLayers => {
+				self.clear_selection();
+				let children = self.layer_panel(&[]).expect("The provided Path was not valid");
+				responses.push_back(FrontendMessage::ExpandFolder { path: vec![], children }.into());
+			}
+			Undo => {
+				// this is a temporary fix and will be addressed by #123
+				if let Some(id) = self.document.root.as_folder().unwrap().list_layers().last() {
+					responses.push_back(DocumentOperation::DeleteLayer { path: vec![*id] }.into())
+				}
+			}
+			FolderChanged(path) => responses.extend(self.handle_folder_changed(path)),
+			DispatchOperation(op) => match self.document.handle_operation(&op) {
+				Ok(Some(mut document_responses)) => {
+					let canvas_dirty = self.filter_document_responses(&mut document_responses);
+					responses.extend(
+						document_responses
+							.into_iter()
+							.map(|response| match response {
+								DocumentResponse::FolderChanged { path } => self.handle_folder_changed(path),
+								DocumentResponse::DeletedLayer { path } => {
+									self.layer_data.remove(&path);
+									None
+								}
+								DocumentResponse::LayerChanged { path } => Some(
+									FrontendMessage::UpdateLayer {
+										path: path.clone(),
+										data: self.layer_panel_entry(path).unwrap(),
+									}
+									.into(),
+								),
+								DocumentResponse::CreatedLayer { path } => self.select_layer(&path),
+								DocumentResponse::DocumentChanged => unreachable!(),
+							})
+							.flatten(),
+					);
+					if canvas_dirty {
+						responses.push_back(RenderDocument.into())
+					}
+				}
+				Err(e) => log::error!("DocumentError: {:?}", e),
+				Ok(_) => (),
+			},
+			RenderDocument => responses.push_back(
+				FrontendMessage::UpdateCanvas {
+					document: self.document.render_root(),
+				}
+				.into(),
+			),
+			NudgeSelectedLayers(x, y) => {
+				for path in self.selected_layers().cloned() {
+					let operation = DocumentOperation::TransformLayerInViewport {
+						path,
+						transform: DAffine2::from_translation((x, y).into()).to_cols_array(),
+					};
+					responses.push_back(operation.into());
+				}
+			}
+			MoveSelectedLayersTo { path, insert_index } => {
+				responses.push_back(DocumentsMessage::CopySelectedLayers.into());
+				responses.push_back(DocumentMessage::DeleteSelectedLayers.into());
+				responses.push_back(DocumentsMessage::PasteLayers { path, insert_index }.into());
+			}
+			ReorderSelectedLayers(relative_position) => {
+				let all_layer_paths = self.all_layers_sorted();
+				let selected_layers = self.selected_layers_sorted();
+				if let Some(pivot) = match relative_position.signum() {
+					-1 => selected_layers.first(),
+					1 => selected_layers.last(),
+					_ => unreachable!(),
+				} {
+					if let Some(pos) = all_layer_paths.iter().position(|path| path == pivot) {
+						let max = all_layer_paths.len() as i64 - 1;
+						let insert_pos = (pos as i64 + relative_position as i64).clamp(0, max) as usize;
+						let insert = all_layer_paths.get(insert_pos);
+						if let Some(insert_path) = insert {
+							let (id, path) = insert_path.split_last().expect("Can't move the root folder");
+							if let Some(folder) = self.document.layer(path).ok().map(|layer| layer.as_folder().ok()).flatten() {
+								let selected: Vec<_> = selected_layers
+									.iter()
+									.filter(|layer| layer.starts_with(path) && layer.len() == path.len() + 1)
+									.map(|x| x.last().unwrap())
+									.collect();
+								let non_selected: Vec<_> = folder.layer_ids.iter().filter(|id| selected.iter().all(|x| x != id)).collect();
+								let offset = if relative_position < 0 || non_selected.is_empty() { 0 } else { 1 };
+								let fallback = offset * (non_selected.len());
+								let insert_index = non_selected.iter().position(|x| *x == id).map(|x| x + offset).unwrap_or(fallback) as isize;
+								responses.push_back(DocumentMessage::MoveSelectedLayersTo { path: path.to_vec(), insert_index }.into())
+							}
+						}
+					}
+				}
+			}
+			FlipSelectedLayers(axis) => {
+				let scale = match axis {
+					FlipAxis::X => DVec2::new(-1., 1.),
+					FlipAxis::Y => DVec2::new(1., -1.),
+				};
+				if let Some([min, max]) = self.document.combined_viewport_bounding_box(self.selected_layers().map(|x| x.as_slice())) {
+					let center = (max + min) / 2.;
+					let bbox_trans = DAffine2::from_translation(-center);
+					for path in self.selected_layers() {
+						responses.push_back(
+							DocumentOperation::TransformLayerInScope {
+								path: path.clone(),
+								transform: DAffine2::from_scale(scale).to_cols_array(),
+								scope: bbox_trans.to_cols_array(),
+							}
+							.into(),
+						);
+					}
+				}
+			}
+			AlignSelectedLayers(axis, aggregate) => {
+				let (paths, boxes): (Vec<_>, Vec<_>) = self.selected_layers().filter_map(|path| self.document.viewport_bounding_box(path).ok()?.map(|b| (path, b))).unzip();
+
+				let axis = match axis {
+					AlignAxis::X => DVec2::X,
+					AlignAxis::Y => DVec2::Y,
+				};
+				let lerp = |bbox: &[DVec2; 2]| bbox[0].lerp(bbox[1], 0.5);
+				if let Some(combined_box) = self.document.combined_viewport_bounding_box(self.selected_layers().map(|x| x.as_slice())) {
+					let aggregated = match aggregate {
+						AlignAggregate::Min => combined_box[0],
+						AlignAggregate::Max => combined_box[1],
+						AlignAggregate::Center => lerp(&combined_box),
+						AlignAggregate::Average => boxes.iter().map(|b| lerp(b)).reduce(|a, b| a + b).map(|b| b / boxes.len() as f64).unwrap(),
+					};
+					for (path, bbox) in paths.into_iter().zip(boxes) {
+						let center = match aggregate {
+							AlignAggregate::Min => bbox[0],
+							AlignAggregate::Max => bbox[1],
+							_ => lerp(&bbox),
+						};
+						let translation = (aggregated - center) * axis;
+						responses.push_back(
+							DocumentOperation::TransformLayerInViewport {
+								path: path.clone(),
+								transform: DAffine2::from_translation(translation).to_cols_array(),
+							}
+							.into(),
+						);
+					}
+				}
+			}
+			RenameLayer(path, name) => responses.push_back(DocumentOperation::RenameLayer { path, name }.into()),
+		}
+	}
+	fn actions(&self) -> ActionList {
+		let mut common = actions!(DocumentMessageDiscriminant;
+			Undo,
+			SelectAllLayers,
+			DeselectAllLayers,
+			RenderDocument,
+			ExportDocument,
+		);
+
+		if self.layer_data.values().any(|data| data.selected) {
+			let select = actions!(DocumentMessageDiscriminant;
+				DeleteSelectedLayers,
+				DuplicateSelectedLayers,
+				NudgeSelectedLayers,
+				ReorderSelectedLayers,
+			);
+			common.extend(select);
+		}
+		common.extend(self.movement_handler.actions());
+		common
+	}
+}

editor/src/document/document_message_handler.rs

@@ -0,0 +1,253 @@
+use crate::input::InputPreprocessor;
+use crate::message_prelude::*;
+use graphene::layers::Layer;
+use graphene::{LayerId, Operation as DocumentOperation};
+use log::warn;
+
+use std::collections::VecDeque;
+
+use super::DocumentMessageHandler;
+
+#[impl_message(Message, Documents)]
+#[derive(PartialEq, Clone, Debug)]
+pub enum DocumentsMessage {
+	CopySelectedLayers,
+	PasteLayers {
+		path: Vec<LayerId>,
+		insert_index: isize,
+	},
+	SelectDocument(usize),
+	CloseDocument(usize),
+	#[child]
+	Document(DocumentMessage),
+	CloseActiveDocumentWithConfirmation,
+	CloseAllDocumentsWithConfirmation,
+	CloseAllDocuments,
+	NewDocument,
+	GetOpenDocumentsList,
+	NextDocument,
+	PrevDocument,
+}
+
+#[derive(Debug, Clone)]
+pub struct DocumentsMessageHandler {
+	documents: Vec<DocumentMessageHandler>,
+	active_document_index: usize,
+	copy_buffer: Vec<Layer>,
+}
+
+impl DocumentsMessageHandler {
+	pub fn active_document(&self) -> &DocumentMessageHandler {
+		&self.documents[self.active_document_index]
+	}
+	pub fn active_document_mut(&mut self) -> &mut DocumentMessageHandler {
+		&mut self.documents[self.active_document_index]
+	}
+}
+
+impl Default for DocumentsMessageHandler {
+	fn default() -> Self {
+		Self {
+			documents: vec![DocumentMessageHandler::default()],
+			active_document_index: 0,
+			copy_buffer: vec![],
+		}
+	}
+}
+
+impl MessageHandler<DocumentsMessage, &InputPreprocessor> for DocumentsMessageHandler {
+	fn process_action(&mut self, message: DocumentsMessage, ipp: &InputPreprocessor, responses: &mut VecDeque<Message>) {
+		use DocumentMessage::*;
+		use DocumentsMessage::*;
+		match message {
+			Document(message) => self.active_document_mut().process_action(message, ipp, responses),
+			SelectDocument(id) => {
+				assert!(id < self.documents.len(), "Tried to select a document that was not initialized");
+				self.active_document_index = id;
+				responses.push_back(
+					FrontendMessage::SetActiveDocument {
+						document_index: self.active_document_index,
+					}
+					.into(),
+				);
+				responses.push_back(RenderDocument.into());
+			}
+			CloseActiveDocumentWithConfirmation => {
+				responses.push_back(
+					FrontendMessage::DisplayConfirmationToCloseDocument {
+						document_index: self.active_document_index,
+					}
+					.into(),
+				);
+			}
+			CloseAllDocumentsWithConfirmation => {
+				responses.push_back(FrontendMessage::DisplayConfirmationToCloseAllDocuments.into());
+			}
+			CloseAllDocuments => {
+				// Empty the list of internal document data
+				self.documents.clear();
+
+				// Create a new blank document
+				responses.push_back(NewDocument.into());
+			}
+			CloseDocument(id) => {
+				assert!(id < self.documents.len(), "Tried to select a document that was not initialized");
+				// Remove doc from the backend store; use `id` as client tabs and backend documents will be in sync
+				self.documents.remove(id);
+
+				// Send the new list of document tab names
+				let open_documents = self.documents.iter().map(|doc| doc.name.clone()).collect();
+				responses.push_back(FrontendMessage::UpdateOpenDocumentsList { open_documents }.into());
+
+				// Last tab was closed, so create a new blank tab
+				if self.documents.is_empty() {
+					self.active_document_index = 0;
+					responses.push_back(NewDocument.into());
+				}
+				// The currently selected doc is being closed
+				else if id == self.active_document_index {
+					// The currently selected tab was the rightmost tab
+					if id == self.documents.len() {
+						self.active_document_index -= 1;
+					}
+
+					let lp = self.active_document_mut().layer_panel(&[]).expect("Could not get panel for active doc");
+					responses.push_back(FrontendMessage::ExpandFolder { path: Vec::new(), children: lp }.into());
+					responses.push_back(
+						FrontendMessage::SetActiveDocument {
+							document_index: self.active_document_index,
+						}
+						.into(),
+					);
+					responses.push_back(
+						FrontendMessage::UpdateCanvas {
+							document: self.active_document_mut().document.render_root(),
+						}
+						.into(),
+					);
+				}
+				// Active doc will move one space to the left
+				else if id < self.active_document_index {
+					self.active_document_index -= 1;
+					responses.push_back(
+						FrontendMessage::SetActiveDocument {
+							document_index: self.active_document_index,
+						}
+						.into(),
+					);
+				}
+			}
+			NewDocument => {
+				let digits = ('0'..='9').collect::<Vec<char>>();
+				let mut doc_title_numbers = self
+					.documents
+					.iter()
+					.map(|d| {
+						if d.name.ends_with(digits.as_slice()) {
+							let (_, number) = d.name.split_at(17);
+							number.trim().parse::<usize>().unwrap()
+						} else {
+							1
+						}
+					})
+					.collect::<Vec<usize>>();
+				doc_title_numbers.sort_unstable();
+				let mut new_doc_title_num = 1;
+				while new_doc_title_num <= self.documents.len() {
+					if new_doc_title_num != doc_title_numbers[new_doc_title_num - 1] {
+						break;
+					}
+					new_doc_title_num += 1;
+				}
+				let name = match new_doc_title_num {
+					1 => "Untitled Document".to_string(),
+					_ => format!("Untitled Document {}", new_doc_title_num),
+				};
+
+				self.active_document_index = self.documents.len();
+				let new_document = DocumentMessageHandler::with_name(name);
+				self.documents.push(new_document);
+
+				// Send the new list of document tab names
+				let open_documents = self.documents.iter().map(|doc| doc.name.clone()).collect();
+				responses.push_back(FrontendMessage::UpdateOpenDocumentsList { open_documents }.into());
+
+				responses.push_back(
+					FrontendMessage::ExpandFolder {
+						path: Vec::new(),
+						children: Vec::new(),
+					}
+					.into(),
+				);
+				responses.push_back(SelectDocument(self.active_document_index).into());
+			}
+			GetOpenDocumentsList => {
+				// Send the list of document tab names
+				let open_documents = self.documents.iter().map(|doc| doc.name.clone()).collect();
+				responses.push_back(FrontendMessage::UpdateOpenDocumentsList { open_documents }.into());
+			}
+			NextDocument => {
+				let id = (self.active_document_index + 1) % self.documents.len();
+				responses.push_back(SelectDocument(id).into());
+			}
+			PrevDocument => {
+				let id = (self.active_document_index + self.documents.len() - 1) % self.documents.len();
+				responses.push_back(SelectDocument(id).into());
+			}
+			CopySelectedLayers => {
+				let paths = self.active_document().selected_layers_sorted();
+				self.copy_buffer.clear();
+				for path in paths {
+					match self.active_document().document.layer(&path).map(|t| t.clone()) {
+						Ok(layer) => {
+							self.copy_buffer.push(layer);
+						}
+						Err(e) => warn!("Could not access selected layer {:?}: {:?}", path, e),
+					}
+				}
+			}
+			PasteLayers { path, insert_index } => {
+				let paste = |layer: &Layer, responses: &mut VecDeque<_>| {
+					log::trace!("pasting into folder {:?} as index: {}", path, insert_index);
+					responses.push_back(
+						DocumentOperation::PasteLayer {
+							layer: layer.clone(),
+							path: path.clone(),
+							insert_index,
+						}
+						.into(),
+					)
+				};
+				if insert_index == -1 {
+					for layer in self.copy_buffer.iter() {
+						paste(layer, responses)
+					}
+				} else {
+					for layer in self.copy_buffer.iter().rev() {
+						paste(layer, responses)
+					}
+				}
+			}
+		}
+	}
+	fn actions(&self) -> ActionList {
+		let mut common = actions!(DocumentsMessageDiscriminant;
+			NewDocument,
+			CloseActiveDocumentWithConfirmation,
+			CloseAllDocumentsWithConfirmation,
+			CloseAllDocuments,
+			NextDocument,
+			PrevDocument,
+			PasteLayers,
+		);
+
+		if self.active_document().layer_data.values().any(|data| data.selected) {
+			let select = actions!(DocumentsMessageDiscriminant;
+				CopySelectedLayers,
+			);
+			common.extend(select);
+		}
+		common.extend(self.active_document().actions());
+		common
+	}
+}

editor/src/document/layer_panel.rs

@@ -0,0 +1,94 @@
+use crate::{consts::ROTATE_SNAP_INTERVAL, frontend::layer_panel::*};
+use glam::{DAffine2, DVec2};
+use graphene::{
+	layers::{Layer, LayerData as DocumentLayerData},
+	LayerId,
+};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Copy)]
+pub struct LayerData {
+	pub selected: bool,
+	pub expanded: bool,
+	pub translation: DVec2,
+	pub rotation: f64,
+	pub snap_rotate: bool,
+	pub scale: f64,
+}
+
+impl LayerData {
+	pub fn new(expanded: bool) -> LayerData {
+		LayerData {
+			selected: false,
+			expanded,
+			translation: DVec2::ZERO,
+			rotation: 0.,
+			snap_rotate: false,
+			scale: 1.,
+		}
+	}
+
+	pub fn snapped_angle(&self) -> f64 {
+		let increment_radians: f64 = ROTATE_SNAP_INTERVAL.to_radians();
+		if self.snap_rotate {
+			(self.rotation / increment_radians).round() * increment_radians
+		} else {
+			self.rotation
+		}
+	}
+
+	pub fn calculate_offset_transform(&self, offset: DVec2) -> DAffine2 {
+		// TODO: replace with DAffine2::from_scale_angle_translation and fix the errors
+		let offset_transform = DAffine2::from_translation(offset);
+		let scale_transform = DAffine2::from_scale(DVec2::new(self.scale, self.scale));
+		let angle_transform = DAffine2::from_angle(self.snapped_angle());
+		let translation_transform = DAffine2::from_translation(self.translation);
+		scale_transform * offset_transform * angle_transform * translation_transform
+	}
+}
+
+pub fn layer_data<'a>(layer_data: &'a mut HashMap<Vec<LayerId>, LayerData>, path: &[LayerId]) -> &'a mut LayerData {
+	if !layer_data.contains_key(path) {
+		layer_data.insert(path.to_vec(), LayerData::new(false));
+	}
+	layer_data.get_mut(path).unwrap()
+}
+
+pub fn layer_panel_entry(layer_data: &LayerData, transform: DAffine2, layer: &Layer, path: Vec<LayerId>) -> LayerPanelEntry {
+	let layer_type: LayerType = (&layer.data).into();
+	let name = layer.name.clone().unwrap_or_else(|| format!("Unnamed {}", layer_type));
+	let arr = layer.data.bounding_box(transform).unwrap_or([DVec2::ZERO, DVec2::ZERO]);
+	let arr = arr.iter().map(|x| (*x).into()).collect::<Vec<(f64, f64)>>();
+
+	let mut thumbnail = String::new();
+	layer.data.clone().render(&mut thumbnail, &mut vec![transform]);
+	let transform = transform.to_cols_array().iter().map(ToString::to_string).collect::<Vec<_>>().join(",");
+	let thumbnail = if let [(x_min, y_min), (x_max, y_max)] = arr.as_slice() {
+		format!(
+			r#"<svg xmlns="http://www.w3.org/2000/svg" viewBox="{} {} {} {}"><g transform="matrix({})">{}</g></svg>"#,
+			x_min,
+			y_min,
+			x_max - x_min,
+			y_max - y_min,
+			transform,
+			thumbnail,
+		)
+	} else {
+		String::new()
+	};
+
+	// LayerIds are sent as (u32, u32) because jsond does not support u64s
+	let path = path.iter().map(|id| ((id >> 32) as u32, (id << 32 >> 32) as u32)).collect::<Vec<_>>();
+
+	LayerPanelEntry {
+		name,
+		visible: layer.visible,
+		blend_mode: layer.blend_mode,
+		opacity: layer.opacity,
+		layer_type: (&layer.data).into(),
+		layer_data: *layer_data,
+		path,
+		thumbnail,
+	}
+}

editor/src/document/mod.rs

@@ -0,0 +1,14 @@
+mod document_file;
+mod document_message_handler;
+mod layer_panel;
+mod movement_handler;
+
+#[doc(inline)]
+pub use document_file::LayerData;
+
+#[doc(inline)]
+pub use document_file::{AlignAggregate, AlignAxis, DocumentMessage, DocumentMessageDiscriminant, DocumentMessageHandler, FlipAxis};
+#[doc(inline)]
+pub use document_message_handler::{DocumentsMessage, DocumentsMessageDiscriminant, DocumentsMessageHandler};
+#[doc(inline)]
+pub use movement_handler::{MovementMessage, MovementMessageDiscriminant};

editor/src/document/movement_handler.rs

@@ -0,0 +1,214 @@
+pub use super::layer_panel::*;
+
+use super::LayerData;
+
+use crate::message_prelude::*;
+use crate::{
+	consts::{MOUSE_ZOOM_RATE, VIEWPORT_SCROLL_RATE, VIEWPORT_ZOOM_SCALE_MAX, VIEWPORT_ZOOM_SCALE_MIN, WHEEL_ZOOM_RATE},
+	input::{mouse::ViewportPosition, InputPreprocessor},
+};
+use glam::DVec2;
+use graphene::document::Document;
+use graphene::Operation as DocumentOperation;
+
+use std::collections::VecDeque;
+
+#[impl_message(Message, DocumentMessage, Movement)]
+#[derive(PartialEq, Clone, Debug)]
+pub enum MovementMessage {
+	MouseMove,
+	TranslateCanvasBegin,
+	WheelCanvasTranslate { use_y_as_x: bool },
+	RotateCanvasBegin { snap: bool },
+	EnableSnapping,
+	DisableSnapping,
+	ZoomCanvasBegin,
+	TranslateCanvasEnd,
+	SetCanvasZoom(f64),
+	MultiplyCanvasZoom(f64),
+	WheelCanvasZoom,
+	SetCanvasRotation(f64),
+	ZoomCanvasToFitAll,
+}
+
+#[derive(Debug, Clone, Hash, Default, PartialEq)]
+pub struct MovementMessageHandler {
+	translating: bool,
+	rotating: bool,
+	zooming: bool,
+	snapping: bool,
+	mouse_pos: ViewportPosition,
+}
+
+impl MovementMessageHandler {
+	fn create_document_transform_from_layerdata(&self, layerdata: &LayerData, viewport_size: &ViewportPosition, responses: &mut VecDeque<Message>) {
+		let half_viewport = viewport_size.as_f64() / 2.;
+		let scaled_half_viewport = half_viewport / layerdata.scale;
+		responses.push_back(
+			DocumentOperation::SetLayerTransform {
+				path: vec![],
+				transform: layerdata.calculate_offset_transform(scaled_half_viewport).to_cols_array(),
+			}
+			.into(),
+		);
+	}
+}
+
+impl MessageHandler<MovementMessage, (&mut LayerData, &Document, &InputPreprocessor)> for MovementMessageHandler {
+	fn process_action(&mut self, message: MovementMessage, data: (&mut LayerData, &Document, &InputPreprocessor), responses: &mut VecDeque<Message>) {
+		let (layerdata, document, ipp) = data;
+		use MovementMessage::*;
+		match message {
+			TranslateCanvasBegin => {
+				self.translating = true;
+				self.mouse_pos = ipp.mouse.position;
+			}
+
+			RotateCanvasBegin { snap } => {
+				self.rotating = true;
+				self.snapping = snap;
+				layerdata.snap_rotate = snap;
+				self.mouse_pos = ipp.mouse.position;
+			}
+			EnableSnapping => self.snapping = true,
+			DisableSnapping => self.snapping = false,
+			ZoomCanvasBegin => {
+				self.zooming = true;
+				self.mouse_pos = ipp.mouse.position;
+			}
+			TranslateCanvasEnd => {
+				layerdata.rotation = layerdata.snapped_angle();
+				layerdata.snap_rotate = false;
+				self.translating = false;
+				self.rotating = false;
+				self.zooming = false;
+			}
+			MouseMove => {
+				if self.translating {
+					let delta = ipp.mouse.position.as_f64() - self.mouse_pos.as_f64();
+					let transformed_delta = document.root.transform.inverse().transform_vector2(delta);
+
+					layerdata.translation += transformed_delta;
+					self.create_document_transform_from_layerdata(layerdata, &ipp.viewport_size, responses);
+				}
+				if self.rotating {
+					let half_viewport = ipp.viewport_size.as_f64() / 2.;
+					let rotation = {
+						let start_vec = self.mouse_pos.as_f64() - half_viewport;
+						let end_vec = ipp.mouse.position.as_f64() - half_viewport;
+						start_vec.angle_between(end_vec)
+					};
+
+					let snapping = self.snapping;
+
+					layerdata.rotation += rotation;
+					layerdata.snap_rotate = snapping;
+					responses.push_back(
+						FrontendMessage::SetCanvasRotation {
+							new_radians: layerdata.snapped_angle(),
+						}
+						.into(),
+					);
+					self.create_document_transform_from_layerdata(layerdata, &ipp.viewport_size, responses);
+				}
+				if self.zooming {
+					let difference = self.mouse_pos.y as f64 - ipp.mouse.position.y as f64;
+					let amount = 1. + difference * MOUSE_ZOOM_RATE;
+
+					let new = (layerdata.scale * amount).clamp(VIEWPORT_ZOOM_SCALE_MIN, VIEWPORT_ZOOM_SCALE_MAX);
+					layerdata.scale = new;
+					responses.push_back(FrontendMessage::SetCanvasZoom { new_zoom: layerdata.scale }.into());
+					self.create_document_transform_from_layerdata(layerdata, &ipp.viewport_size, responses);
+				}
+				self.mouse_pos = ipp.mouse.position;
+			}
+			SetCanvasZoom(new) => {
+				layerdata.scale = new.clamp(VIEWPORT_ZOOM_SCALE_MIN, VIEWPORT_ZOOM_SCALE_MAX);
+				responses.push_back(FrontendMessage::SetCanvasZoom { new_zoom: layerdata.scale }.into());
+				self.create_document_transform_from_layerdata(layerdata, &ipp.viewport_size, responses);
+			}
+			MultiplyCanvasZoom(multiplier) => {
+				let new = (layerdata.scale * multiplier).clamp(VIEWPORT_ZOOM_SCALE_MIN, VIEWPORT_ZOOM_SCALE_MAX);
+				layerdata.scale = new;
+				responses.push_back(FrontendMessage::SetCanvasZoom { new_zoom: layerdata.scale }.into());
+				self.create_document_transform_from_layerdata(layerdata, &ipp.viewport_size, responses);
+			}
+			WheelCanvasZoom => {
+				let scroll = ipp.mouse.scroll_delta.scroll_delta();
+				let mouse = ipp.mouse.position.as_f64();
+				let viewport_size = ipp.viewport_size.as_f64();
+				let mut zoom_factor = 1. + scroll.abs() * WHEEL_ZOOM_RATE;
+				if ipp.mouse.scroll_delta.y > 0 {
+					zoom_factor = 1. / zoom_factor
+				};
+				let new_viewport_size = viewport_size * (1. / zoom_factor);
+				let delta_size = viewport_size - new_viewport_size;
+				let mouse_percent = mouse / viewport_size;
+				let delta = (delta_size * -2.) * (mouse_percent - DVec2::splat(0.5));
+
+				let transformed_delta = document.root.transform.inverse().transform_vector2(delta);
+				let new = (layerdata.scale * zoom_factor).clamp(VIEWPORT_ZOOM_SCALE_MIN, VIEWPORT_ZOOM_SCALE_MAX);
+				layerdata.scale = new;
+				layerdata.translation += transformed_delta;
+				responses.push_back(FrontendMessage::SetCanvasZoom { new_zoom: layerdata.scale }.into());
+				self.create_document_transform_from_layerdata(layerdata, &ipp.viewport_size, responses);
+			}
+			WheelCanvasTranslate { use_y_as_x } => {
+				let delta = match use_y_as_x {
+					false => -ipp.mouse.scroll_delta.as_dvec2(),
+					true => (-ipp.mouse.scroll_delta.y as f64, 0.).into(),
+				} * VIEWPORT_SCROLL_RATE;
+				let transformed_delta = document.root.transform.inverse().transform_vector2(delta);
+				layerdata.translation += transformed_delta;
+				self.create_document_transform_from_layerdata(layerdata, &ipp.viewport_size, responses);
+			}
+			SetCanvasRotation(new) => {
+				layerdata.rotation = new;
+				self.create_document_transform_from_layerdata(layerdata, &ipp.viewport_size, responses);
+				responses.push_back(FrontendMessage::SetCanvasRotation { new_radians: new }.into());
+			}
+			ZoomCanvasToFitAll => {
+				if let Some([pos1, pos2]) = document.visible_layers_bounding_box() {
+					let pos1 = document.root.transform.inverse().transform_point2(pos1);
+					let pos2 = document.root.transform.inverse().transform_point2(pos2);
+					let v1 = document.root.transform.inverse().transform_point2(DVec2::ZERO);
+					let v2 = document.root.transform.inverse().transform_point2(ipp.viewport_size.as_f64());
+
+					let center = v1.lerp(v2, 0.5) - pos1.lerp(pos2, 0.5);
+					let size = (pos2 - pos1) / (v2 - v1);
+					let size = 1. / size;
+					let new_scale = size.min_element();
+
+					layerdata.translation += center;
+					layerdata.scale *= new_scale;
+					responses.push_back(FrontendMessage::SetCanvasZoom { new_zoom: layerdata.scale }.into());
+					self.create_document_transform_from_layerdata(layerdata, &ipp.viewport_size, responses);
+				}
+			}
+		}
+	}
+	fn actions(&self) -> ActionList {
+		let mut common = actions!(MovementMessageDiscriminant;
+			MouseMove,
+			TranslateCanvasEnd,
+			TranslateCanvasBegin,
+			RotateCanvasBegin,
+			ZoomCanvasBegin,
+			SetCanvasZoom,
+			MultiplyCanvasZoom,
+			SetCanvasRotation,
+			WheelCanvasZoom,
+			WheelCanvasTranslate,
+			ZoomCanvasToFitAll,
+		);
+
+		if self.rotating {
+			let snapping = actions!(MovementMessageDiscriminant;
+				EnableSnapping,
+				DisableSnapping,
+			);
+			common.extend(snapping);
+		}
+		common
+	}
+}