Major overhaul of input and communication systems

* Add input manager

* WIP lifetime hell

* Hell yeah, dark lifetime magic

* Replace events with actions in tools

* Fix borrow in GlobalEventHandler

* Fix typo in response-handler

* Distribute dispatch structure

* Add translation from events to actions

* Port default key actions to input_mapper

* Split actions macro

* Add handling for Ambiguous Mouse events

* Fix warnings and clippy lints

* Add actions macro

* WIP rework

* Add AsMessage macro

* Add implementation for derived enums

* Add macro implementation for top level message

* Add #[child] attribute to indicate derivation

* Replace some mentions of Actions and Responses with Message

* It compiles !!!

* Add functionality to some message handlers

* Add document rendering

* ICE

* Rework the previous code while keeping basic functionality

* Reduce parent-top-level macro args to only two

* Add workaround for ICE

* Fix cyclic reference in document.rs

* Make derive_transitive_child a bit more powerful

This addresses the todo that was left,
enabling arbitrary expressions to be passed as the last
parameter of a #[parent] attribute

* Adapt frontend message format

* Make responses use VecDeque

Our responses are a queue so we should use a queue type for them

* Move traits to sensible location

* Are we rectangle yet?

* Simplify, improve & document `derive_discriminant`

* Change `child` to `sub_discriminant`

This only applies to `ToDiscriminant`.
Code using `#[impl_message]` continues to work.

* Add docs for `derive_transitive_child`

* Finish docs and improve macros

The improvements are that impl_message now uses trait
resolution to obtain the parent's discriminant
and that derive_as_message now allows for non-unit
variants (which we don't use but it's nice to have,
just in case)

* Remove logging call

* Move files around and cleanup structure

* Fix proc macro doc tests

* Improve actions_fn!() macro

* Add ellipse tool

* Pass populated actions list to the input mapper

* Add KeyState bitvector

* Merge mouse buttons into "keyboard"

* Add macro for initialization of key mapper table

* Add syntactic sugar for the macro

* Implement mapping function

* Translate the remaining tools

* Fix shape tool

* Add keybindings for line and pen tool

* Fix modifiers

* Cleanup

* Add doc comments for the actions macro

* Fix formatting

* Rename MouseMove to PointerMove

* Add keybinds for tools

* Apply review suggestions

* Rename KeyMappings -> KeyMappingEntries

* Apply review changes

Co-authored-by: T0mstone <realt0mstone@gmail.com>
Co-authored-by: Paul Kupper <kupper.pa@gmail.com>

core/editor/src/document/document_file.rs

@@ -0,0 +1,7 @@
+use document_core::document::Document as InteralDocument;
+
+#[derive(Clone, Debug, Default)]
+pub struct Document {
+	pub document: InteralDocument,
+	pub name: String,
+}

core/editor/src/document/document_message_handler.rs

@@ -0,0 +1,100 @@
+use crate::message_prelude::*;
+use document_core::{DocumentResponse, LayerId, Operation as DocumentOperation};
+
+use crate::document::Document;
+use std::collections::VecDeque;
+
+#[impl_message(Message, Document)]
+#[derive(PartialEq, Clone, Debug)]
+pub enum DocumentMessage {
+	DispatchOperation(DocumentOperation),
+	SelectLayer(Vec<LayerId>),
+	DeleteLayer(Vec<LayerId>),
+	AddFolder(Vec<LayerId>),
+	RenameLayer(Vec<LayerId>, String),
+	ToggleLayerVisibility(Vec<LayerId>),
+	ToggleLayerExpansion(Vec<LayerId>),
+	SelectDocument(usize),
+	RenderDocument,
+	Undo,
+}
+
+impl From<DocumentOperation> for DocumentMessage {
+	fn from(operation: DocumentOperation) -> DocumentMessage {
+		Self::DispatchOperation(operation)
+	}
+}
+impl From<DocumentOperation> for Message {
+	fn from(operation: DocumentOperation) -> Message {
+		DocumentMessage::DispatchOperation(operation).into()
+	}
+}
+
+#[derive(Debug, Clone)]
+pub struct DocumentMessageHandler {
+	documents: Vec<Document>,
+	active_document: usize,
+}
+
+impl DocumentMessageHandler {
+	pub fn active_document(&self) -> &Document {
+		&self.documents[self.active_document]
+	}
+	pub fn active_document_mut(&mut self) -> &mut Document {
+		&mut self.documents[self.active_document]
+	}
+	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
+	}
+}
+
+impl Default for DocumentMessageHandler {
+	fn default() -> Self {
+		Self {
+			documents: vec![Document::default()],
+			active_document: 0,
+		}
+	}
+}
+
+impl MessageHandler<DocumentMessage, ()> for DocumentMessageHandler {
+	fn process_action(&mut self, message: DocumentMessage, _data: (), responses: &mut VecDeque<Message>) {
+		use DocumentMessage::*;
+		match message {
+			DeleteLayer(path) => responses.push_back(DocumentOperation::DeleteLayer { path }.into()),
+			AddFolder(path) => responses.push_back(DocumentOperation::AddFolder { path }.into()),
+			SelectDocument(id) => {
+				assert!(id < self.documents.len(), "Tried to select a document that was not initialized");
+				self.active_document = id;
+			}
+			ToggleLayerVisibility(path) => {
+				responses.push_back(DocumentOperation::ToggleVisibility { path }.into());
+			}
+			Undo => {
+				// this is a temporary fix and will be addressed by #123
+				if let Some(id) = self.active_document().document.root.list_layers().last() {
+					responses.push_back(DocumentOperation::DeleteLayer { path: vec![*id] }.into())
+				}
+			}
+			DispatchOperation(op) => {
+				if let Ok(Some(mut document_responses)) = self.active_document_mut().document.handle_operation(op) {
+					let canvas_dirty = self.filter_document_responses(&mut document_responses);
+					responses.extend(document_responses.into_iter().map(Into::into));
+					if canvas_dirty {
+						responses.push_back(RenderDocument.into())
+					}
+				}
+			}
+			RenderDocument => responses.push_back(
+				FrontendMessage::UpdateCanvas {
+					document: self.active_document_mut().document.render_root(),
+				}
+				.into(),
+			),
+			message => todo!("document_action_handler does not implement: {}", message.to_discriminant().global_name()),
+		}
+	}
+	advertise_actions!(DocumentMessageDiscriminant; Undo, RenderDocument);
+}

core/editor/src/document/mod.rs

@@ -0,0 +1,8 @@
+mod document_file;
+mod document_message_handler;
+
+#[doc(inline)]
+pub use document_file::Document;
+
+#[doc(inline)]
+pub use document_message_handler::{DocumentMessage, DocumentMessageDiscriminant, DocumentMessageHandler};