Implement input hints based on the active tool state (#388)

* Hook up user input hints to display in the frontend status bar

Closes #171

* MVP hint system based on tool FSM

* Fix hints for Fill and Eyedropper tools

* Add icons for keyboard shortcuts

* Fix hints for Pen Tool

* Cleanup

editor/src/tool/tools/eyedropper.rs

@@ -1,40 +1,124 @@
 use crate::consts::SELECTION_TOLERANCE;
+use crate::document::DocumentMessageHandler;
+use crate::input::{keyboard::MouseMotion, InputPreprocessor};
 use crate::message_prelude::*;
-use crate::tool::{ToolActionHandlerData, ToolMessage};
+use crate::misc::{HintData, HintGroup, HintInfo};
+use crate::tool::{DocumentToolData, Fsm, ToolActionHandlerData, ToolMessage};
 use glam::DVec2;
 use graphene::layers::LayerDataType;
 use graphene::Quad;
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]
-pub struct Eyedropper;
+pub struct Eyedropper {
+	fsm_state: EyedropperToolFsmState,
+	data: EyedropperToolData,
+}
 
 #[impl_message(Message, ToolMessage, Eyedropper)]
 #[derive(PartialEq, Clone, Debug, Hash, Serialize, Deserialize)]
 pub enum EyedropperMessage {
 	LeftMouseDown,
 	RightMouseDown,
+	Abort,
 }
 
 impl<'a> MessageHandler<ToolMessage, ToolActionHandlerData<'a>> for Eyedropper {
 	fn process_action(&mut self, action: ToolMessage, data: ToolActionHandlerData<'a>, responses: &mut VecDeque<Message>) {
-		let mouse_pos = data.2.mouse.position;
-		let tolerance = DVec2::splat(SELECTION_TOLERANCE);
-		let quad = Quad::from_box([mouse_pos - tolerance, mouse_pos + tolerance]);
+		if action == ToolMessage::UpdateHints {
+			self.fsm_state.update_hints(responses);
+			return;
+		}
 
-		if let Some(path) = data.0.graphene_document.intersects_quad_root(quad).last() {
-			if let Ok(layer) = data.0.graphene_document.layer(path) {
-				if let LayerDataType::Shape(s) = &layer.data {
-					s.style.fill().and_then(|fill| {
-						fill.color().map(|color| match action {
-							ToolMessage::Eyedropper(EyedropperMessage::LeftMouseDown) => responses.push_back(ToolMessage::SelectPrimaryColor(color).into()),
-							ToolMessage::Eyedropper(EyedropperMessage::RightMouseDown) => responses.push_back(ToolMessage::SelectSecondaryColor(color).into()),
-							_ => {}
-						})
-					});
-				}
-			}
+		let new_state = self.fsm_state.transition(action, data.0, data.1, &mut self.data, data.2, responses);
+
+		if self.fsm_state != new_state {
+			self.fsm_state = new_state;
+			self.fsm_state.update_hints(responses);
 		}
 	}
+
 	advertise_actions!(EyedropperMessageDiscriminant; LeftMouseDown, RightMouseDown);
 }
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum EyedropperToolFsmState {
+	Ready,
+}
+
+impl Default for EyedropperToolFsmState {
+	fn default() -> Self {
+		EyedropperToolFsmState::Ready
+	}
+}
+
+#[derive(Clone, Debug, Default)]
+struct EyedropperToolData {}
+
+impl Fsm for EyedropperToolFsmState {
+	type ToolData = EyedropperToolData;
+
+	fn transition(
+		self,
+		event: ToolMessage,
+		document: &DocumentMessageHandler,
+		tool_data: &DocumentToolData,
+		data: &mut Self::ToolData,
+		input: &InputPreprocessor,
+		responses: &mut VecDeque<Message>,
+	) -> Self {
+		use EyedropperMessage::*;
+		use EyedropperToolFsmState::*;
+		if let ToolMessage::Eyedropper(event) = event {
+			match (self, event) {
+				(Ready, lmb_or_rmb) if lmb_or_rmb == LeftMouseDown || lmb_or_rmb == RightMouseDown => {
+					let mouse_pos = input.mouse.position;
+					let tolerance = DVec2::splat(SELECTION_TOLERANCE);
+					let quad = Quad::from_box([mouse_pos - tolerance, mouse_pos + tolerance]);
+
+					if let Some(path) = document.graphene_document.intersects_quad_root(quad).last() {
+						if let Ok(layer) = document.graphene_document.layer(path) {
+							if let LayerDataType::Shape(shape) = &layer.data {
+								if let Some(fill) = shape.style.fill() {
+									if let Some(color) = fill.color() {
+										match lmb_or_rmb {
+											EyedropperMessage::LeftMouseDown => responses.push_back(ToolMessage::SelectPrimaryColor(color).into()),
+											EyedropperMessage::RightMouseDown => responses.push_back(ToolMessage::SelectSecondaryColor(color).into()),
+											_ => {}
+										}
+									}
+								}
+							}
+						}
+					}
+
+					Ready
+				}
+				_ => self,
+			}
+		} else {
+			self
+		}
+	}
+
+	fn update_hints(&self, responses: &mut VecDeque<Message>) {
+		let hint_data = match self {
+			EyedropperToolFsmState::Ready => HintData(vec![HintGroup(vec![
+				HintInfo {
+					key_groups: vec![],
+					mouse: Some(MouseMotion::Lmb),
+					label: String::from("Sample to Primary"),
+					plus: false,
+				},
+				HintInfo {
+					key_groups: vec![],
+					mouse: Some(MouseMotion::Rmb),
+					label: String::from("Sample to Secondary"),
+					plus: false,
+				},
+			])]),
+		};
+
+		responses.push_back(FrontendMessage::UpdateInputHints { hint_data }.into());
+	}
+}