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/communication/dispatcher.rs

@@ -0,0 +1,326 @@
+use crate::{frontend::FrontendMessageHandler, message_prelude::*, Callback, EditorError};
+
+pub use crate::document::DocumentsMessageHandler;
+pub use crate::input::{InputMapper, InputPreprocessor};
+pub use crate::tool::ToolMessageHandler;
+
+use crate::global::GlobalMessageHandler;
+use std::collections::VecDeque;
+
+pub struct Dispatcher {
+	frontend_message_handler: FrontendMessageHandler,
+	input_preprocessor: InputPreprocessor,
+	input_mapper: InputMapper,
+	global_message_handler: GlobalMessageHandler,
+	tool_message_handler: ToolMessageHandler,
+	documents_message_handler: DocumentsMessageHandler,
+	messages: VecDeque<Message>,
+}
+
+impl Dispatcher {
+	pub fn handle_message<T: Into<Message>>(&mut self, message: T) -> Result<(), EditorError> {
+		let message = message.into();
+		use Message::*;
+		if !(matches!(
+			message,
+			Message::InputPreprocessor(_)
+				| Message::InputMapper(_)
+				| Message::Documents(DocumentsMessage::Document(DocumentMessage::RenderDocument))
+				| Message::Frontend(FrontendMessage::UpdateCanvas { .. })
+				| Message::Frontend(FrontendMessage::SetCanvasZoom { .. })
+				| Message::Frontend(FrontendMessage::SetCanvasRotation { .. })
+				| Message::Documents(DocumentsMessage::Document(DocumentMessage::DispatchOperation { .. }))
+		) || MessageDiscriminant::from(&message).local_name().ends_with("MouseMove"))
+		{
+			log::trace!("Message: {:?}", message);
+			//log::trace!("Hints:{:?}", self.input_mapper.hints(self.collect_actions()));
+		}
+		match message {
+			NoOp => (),
+			Documents(message) => self.documents_message_handler.process_action(message, &self.input_preprocessor, &mut self.messages),
+			Global(message) => self.global_message_handler.process_action(message, (), &mut self.messages),
+			Tool(message) => self
+				.tool_message_handler
+				.process_action(message, (self.documents_message_handler.active_document(), &self.input_preprocessor), &mut self.messages),
+			Frontend(message) => self.frontend_message_handler.process_action(message, (), &mut self.messages),
+			InputPreprocessor(message) => self.input_preprocessor.process_action(message, (), &mut self.messages),
+			InputMapper(message) => {
+				let actions = self.collect_actions();
+				self.input_mapper.process_action(message, (&self.input_preprocessor, actions), &mut self.messages)
+			}
+		}
+		if let Some(message) = self.messages.pop_front() {
+			self.handle_message(message)?;
+		}
+		Ok(())
+	}
+
+	pub fn collect_actions(&self) -> ActionList {
+		//TODO: reduce the number of heap allocations
+		let mut list = Vec::new();
+		list.extend(self.frontend_message_handler.actions());
+		list.extend(self.input_preprocessor.actions());
+		list.extend(self.input_mapper.actions());
+		list.extend(self.global_message_handler.actions());
+		list.extend(self.tool_message_handler.actions());
+		list.extend(self.documents_message_handler.actions());
+		list
+	}
+
+	pub fn new(callback: Callback) -> Dispatcher {
+		Dispatcher {
+			frontend_message_handler: FrontendMessageHandler::new(callback),
+			input_preprocessor: InputPreprocessor::default(),
+			global_message_handler: GlobalMessageHandler::new(),
+			input_mapper: InputMapper::default(),
+			documents_message_handler: DocumentsMessageHandler::default(),
+			tool_message_handler: ToolMessageHandler::default(),
+			messages: VecDeque::new(),
+		}
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use crate::{document::DocumentMessageHandler, message_prelude::*, misc::test_utils::EditorTestUtils, Editor};
+	use graphene::{color::Color, Operation};
+	use log::info;
+
+	fn init_logger() {
+		let _ = env_logger::builder().is_test(true).try_init();
+	}
+
+	/// Create an editor instance with three layers
+	/// 1. A red rectangle
+	/// 2. A blue shape
+	/// 3. A green ellipse
+	fn create_editor_with_three_layers() -> Editor {
+		let mut editor = Editor::new(Box::new(|e| {
+			info!("Got frontend message: {:?}", e);
+		}));
+
+		editor.select_primary_color(Color::RED);
+		editor.draw_rect(100, 200, 300, 400);
+		editor.select_primary_color(Color::BLUE);
+		editor.draw_shape(10, 1200, 1300, 400);
+		editor.select_primary_color(Color::GREEN);
+		editor.draw_ellipse(104, 1200, 1300, 400);
+
+		editor
+	}
+
+	#[test]
+	/// - create rect, shape and ellipse
+	/// - copy
+	/// - paste
+	/// - assert that ellipse was copied
+	fn copy_paste_single_layer() {
+		init_logger();
+		let mut editor = create_editor_with_three_layers();
+
+		let document_before_copy = editor.dispatcher.documents_message_handler.active_document().document.clone();
+		editor.handle_message(DocumentsMessage::CopySelectedLayers).unwrap();
+		editor.handle_message(DocumentsMessage::PasteLayers { path: vec![], insert_index: -1 }).unwrap();
+		let document_after_copy = editor.dispatcher.documents_message_handler.active_document().document.clone();
+
+		let layers_before_copy = document_before_copy.root.as_folder().unwrap().layers();
+		let layers_after_copy = document_after_copy.root.as_folder().unwrap().layers();
+
+		assert_eq!(layers_before_copy.len(), 3);
+		assert_eq!(layers_after_copy.len(), 4);
+
+		// Existing layers are unaffected
+		for i in 0..=2 {
+			assert_eq!(layers_before_copy[i], layers_after_copy[i]);
+		}
+
+		// The ellipse was copied
+		assert_eq!(layers_before_copy[2], layers_after_copy[3]);
+	}
+
+	#[test]
+	/// - create rect, shape and ellipse
+	/// - select shape
+	/// - copy
+	/// - paste
+	/// - assert that shape was copied
+	fn copy_paste_single_layer_from_middle() {
+		init_logger();
+		let mut editor = create_editor_with_three_layers();
+
+		let document_before_copy = editor.dispatcher.documents_message_handler.active_document().document.clone();
+		let shape_id = document_before_copy.root.as_folder().unwrap().layer_ids[1];
+
+		editor.handle_message(DocumentMessage::SelectLayers(vec![vec![shape_id]])).unwrap();
+		editor.handle_message(DocumentsMessage::CopySelectedLayers).unwrap();
+		editor.handle_message(DocumentsMessage::PasteLayers { path: vec![], insert_index: -1 }).unwrap();
+
+		let document_after_copy = editor.dispatcher.documents_message_handler.active_document().document.clone();
+
+		let layers_before_copy = document_before_copy.root.as_folder().unwrap().layers();
+		let layers_after_copy = document_after_copy.root.as_folder().unwrap().layers();
+
+		assert_eq!(layers_before_copy.len(), 3);
+		assert_eq!(layers_after_copy.len(), 4);
+
+		// Existing layers are unaffected
+		for i in 0..=2 {
+			assert_eq!(layers_before_copy[i], layers_after_copy[i]);
+		}
+
+		// The shape was copied
+		assert_eq!(layers_before_copy[1], layers_after_copy[3]);
+	}
+
+	#[test]
+	fn copy_paste_folder() {
+		init_logger();
+		let mut editor = create_editor_with_three_layers();
+
+		const FOLDER_INDEX: usize = 3;
+		const ELLIPSE_INDEX: usize = 2;
+		const SHAPE_INDEX: usize = 1;
+		const RECT_INDEX: usize = 0;
+
+		const LINE_INDEX: usize = 0;
+		const PEN_INDEX: usize = 1;
+
+		editor.handle_message(DocumentMessage::AddFolder(vec![])).unwrap();
+
+		let document_before_added_shapes = editor.dispatcher.documents_message_handler.active_document().document.clone();
+		let folder_id = document_before_added_shapes.root.as_folder().unwrap().layer_ids[FOLDER_INDEX];
+
+		// TODO: This adding of a Line and Pen should be rewritten using the corresponding functions in EditorTestUtils.
+		// This has not been done yet as the line and pen tool are not yet able to add layers to the currently selected folder
+		editor
+			.handle_message(Operation::AddLine {
+				path: vec![folder_id, LINE_INDEX as u64],
+				insert_index: 0,
+				transform: [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+				style: Default::default(),
+			})
+			.unwrap();
+
+		editor
+			.handle_message(Operation::AddPen {
+				path: vec![folder_id, PEN_INDEX as u64],
+				insert_index: 0,
+				transform: [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+				style: Default::default(),
+				points: vec![(10.0, 20.0), (30.0, 40.0)],
+			})
+			.unwrap();
+
+		editor.handle_message(DocumentMessage::SelectLayers(vec![vec![folder_id]])).unwrap();
+
+		let document_before_copy = editor.dispatcher.documents_message_handler.active_document().document.clone();
+
+		editor.handle_message(DocumentsMessage::CopySelectedLayers).unwrap();
+		editor.handle_message(DocumentMessage::DeleteSelectedLayers).unwrap();
+		editor.handle_message(DocumentsMessage::PasteLayers { path: vec![], insert_index: -1 }).unwrap();
+		editor.handle_message(DocumentsMessage::PasteLayers { path: vec![], insert_index: -1 }).unwrap();
+
+		let document_after_copy = editor.dispatcher.documents_message_handler.active_document().document.clone();
+
+		let layers_before_copy = document_before_copy.root.as_folder().unwrap().layers();
+		let layers_after_copy = document_after_copy.root.as_folder().unwrap().layers();
+
+		assert_eq!(layers_before_copy.len(), 4);
+		assert_eq!(layers_after_copy.len(), 5);
+
+		let rect_before_copy = &layers_before_copy[RECT_INDEX];
+		let ellipse_before_copy = &layers_before_copy[ELLIPSE_INDEX];
+		let shape_before_copy = &layers_before_copy[SHAPE_INDEX];
+		let folder_before_copy = &layers_before_copy[FOLDER_INDEX];
+		let line_before_copy = folder_before_copy.as_folder().unwrap().layers()[LINE_INDEX].clone();
+		let pen_before_copy = folder_before_copy.as_folder().unwrap().layers()[PEN_INDEX].clone();
+
+		assert_eq!(&layers_after_copy[0], rect_before_copy);
+		assert_eq!(&layers_after_copy[1], shape_before_copy);
+		assert_eq!(&layers_after_copy[2], ellipse_before_copy);
+		assert_eq!(&layers_after_copy[3], folder_before_copy);
+		assert_eq!(&layers_after_copy[4], folder_before_copy);
+
+		// Check the layers inside the two folders
+		let first_folder_layers_after_copy = layers_after_copy[3].as_folder().unwrap().layers();
+		let second_folder_layers_after_copy = layers_after_copy[4].as_folder().unwrap().layers();
+
+		assert_eq!(first_folder_layers_after_copy.len(), 2);
+		assert_eq!(second_folder_layers_after_copy.len(), 2);
+
+		assert_eq!(first_folder_layers_after_copy[0], line_before_copy);
+		assert_eq!(first_folder_layers_after_copy[1], pen_before_copy);
+
+		assert_eq!(second_folder_layers_after_copy[0], line_before_copy);
+		assert_eq!(second_folder_layers_after_copy[1], pen_before_copy);
+	}
+
+	#[test]
+	/// - create rect, shape and ellipse
+	/// - select ellipse and rect
+	/// - copy
+	/// - delete
+	/// - create another rect
+	/// - paste
+	/// - paste
+	fn copy_paste_deleted_layers() {
+		init_logger();
+		let mut editor = create_editor_with_three_layers();
+
+		const ELLIPSE_INDEX: usize = 2;
+		const SHAPE_INDEX: usize = 1;
+		const RECT_INDEX: usize = 0;
+
+		let document_before_copy = editor.dispatcher.documents_message_handler.active_document().document.clone();
+		let rect_id = document_before_copy.root.as_folder().unwrap().layer_ids[RECT_INDEX];
+		let ellipse_id = document_before_copy.root.as_folder().unwrap().layer_ids[ELLIPSE_INDEX];
+
+		editor.handle_message(DocumentMessage::SelectLayers(vec![vec![rect_id], vec![ellipse_id]])).unwrap();
+		editor.handle_message(DocumentsMessage::CopySelectedLayers).unwrap();
+		editor.handle_message(DocumentMessage::DeleteSelectedLayers).unwrap();
+		editor.draw_rect(0, 800, 12, 200);
+		editor.handle_message(DocumentsMessage::PasteLayers { path: vec![], insert_index: -1 }).unwrap();
+		editor.handle_message(DocumentsMessage::PasteLayers { path: vec![], insert_index: -1 }).unwrap();
+
+		let document_after_copy = editor.dispatcher.documents_message_handler.active_document().document.clone();
+
+		let layers_before_copy = document_before_copy.root.as_folder().unwrap().layers();
+		let layers_after_copy = document_after_copy.root.as_folder().unwrap().layers();
+
+		assert_eq!(layers_before_copy.len(), 3);
+		assert_eq!(layers_after_copy.len(), 6);
+
+		let rect_before_copy = &layers_before_copy[RECT_INDEX];
+		let ellipse_before_copy = &layers_before_copy[ELLIPSE_INDEX];
+
+		assert_eq!(layers_after_copy[0], layers_before_copy[SHAPE_INDEX]);
+		assert_eq!(&layers_after_copy[2], rect_before_copy);
+		assert_eq!(&layers_after_copy[3], ellipse_before_copy);
+		assert_eq!(&layers_after_copy[4], rect_before_copy);
+		assert_eq!(&layers_after_copy[5], ellipse_before_copy);
+	}
+	#[test]
+	/// - create rect, shape and ellipse
+	/// - select ellipse and rect
+	/// - move them down and back up again
+	fn move_seletion() {
+		init_logger();
+		let mut editor = create_editor_with_three_layers();
+
+		let verify_order = |handler: &mut DocumentMessageHandler| (handler.all_layers_sorted(), handler.non_selected_layers_sorted(), handler.selected_layers_sorted());
+
+		editor.handle_message(DocumentMessage::SelectLayers(vec![vec![0], vec![2]])).unwrap();
+
+		editor.handle_message(DocumentMessage::ReorderSelectedLayers(1)).unwrap();
+		let (all, non_selected, selected) = verify_order(&mut editor.dispatcher.documents_message_handler.active_document_mut());
+		assert_eq!(all, non_selected.into_iter().chain(selected.into_iter()).collect::<Vec<_>>());
+
+		editor.handle_message(DocumentMessage::ReorderSelectedLayers(-1)).unwrap();
+		let (all, non_selected, selected) = verify_order(&mut editor.dispatcher.documents_message_handler.active_document_mut());
+		assert_eq!(all, selected.into_iter().chain(non_selected.into_iter()).collect::<Vec<_>>());
+
+		editor.handle_message(DocumentMessage::ReorderSelectedLayers(i32::MAX)).unwrap();
+		let (all, non_selected, selected) = verify_order(&mut editor.dispatcher.documents_message_handler.active_document_mut());
+		assert_eq!(all, non_selected.into_iter().chain(selected.into_iter()).collect::<Vec<_>>());
+	}
+}

editor/src/communication/message.rs

@@ -0,0 +1,55 @@
+use crate::message_prelude::*;
+use graphite_proc_macros::*;
+use std::{
+	collections::hash_map::DefaultHasher,
+	hash::{Hash, Hasher},
+};
+
+pub trait AsMessage: TransitiveChild
+where
+	Self::TopParent: TransitiveChild<Parent = Self::TopParent, TopParent = Self::TopParent> + AsMessage,
+{
+	fn local_name(self) -> String;
+	fn global_name(self) -> String {
+		<Self as Into<Self::TopParent>>::into(self).local_name()
+	}
+}
+
+#[impl_message]
+#[derive(Clone, Debug, PartialEq)]
+pub enum Message {
+	NoOp,
+	#[child]
+	Documents(DocumentsMessage),
+	#[child]
+	Global(GlobalMessage),
+	#[child]
+	Tool(ToolMessage),
+	#[child]
+	Frontend(FrontendMessage),
+	#[child]
+	InputPreprocessor(InputPreprocessorMessage),
+	#[child]
+	InputMapper(InputMapperMessage),
+}
+
+impl Message {
+	/// Returns the byte representation of the message.
+	///
+	/// # Safety
+	/// This function reads from uninitialized memory!!!
+	/// Only use if you know what you are doing
+	unsafe fn as_slice(&self) -> &[u8] {
+		core::slice::from_raw_parts(self as *const Message as *const u8, std::mem::size_of::<Message>())
+	}
+	/// Returns a pseudo hash that should uniquely identify the message.
+	/// This is needed because `Hash` is not implemented for f64s
+	///
+	/// # Safety
+	/// This function reads from uninitialized memory but the generated value should be fine.
+	pub fn pseudo_hash(&self) -> u64 {
+		let mut s = DefaultHasher::new();
+		unsafe { self.as_slice() }.hash(&mut s);
+		s.finish()
+	}
+}

editor/src/communication/mod.rs

@@ -0,0 +1,36 @@
+use std::collections::hash_map::DefaultHasher;
+use std::hash::{Hash, Hasher};
+
+pub mod dispatcher;
+pub mod message;
+use crate::message_prelude::*;
+pub use dispatcher::*;
+
+pub use crate::input::InputPreprocessor;
+use std::collections::VecDeque;
+
+pub type ActionList = Vec<Vec<MessageDiscriminant>>;
+
+// TODO: Add Send + Sync requirement
+// Use something like rw locks for synchronization
+pub trait MessageHandlerData {}
+
+pub trait MessageHandler<A: ToDiscriminant, T>
+where
+	A::Discriminant: AsMessage,
+	<A::Discriminant as TransitiveChild>::TopParent: TransitiveChild<Parent = <A::Discriminant as TransitiveChild>::TopParent, TopParent = <A::Discriminant as TransitiveChild>::TopParent> + AsMessage,
+{
+	/// Return true if the Action is consumed.
+	fn process_action(&mut self, action: A, data: T, responses: &mut VecDeque<Message>);
+	fn actions(&self) -> ActionList;
+}
+
+pub fn generate_hash<'a>(messages: impl IntoIterator<Item = &'a Message>, ipp: &InputPreprocessor, document_hash: u64) -> u64 {
+	let mut s = DefaultHasher::new();
+	document_hash.hash(&mut s);
+	ipp.hash(&mut s);
+	for message in messages {
+		message.pseudo_hash().hash(&mut s);
+	}
+	s.finish()
+}