Implement pressure-sensitive drawing with pen tablets on web

desktop/src/app.rs

@@ -21,7 +21,7 @@ use crate::persist;
 use crate::preferences;
 use crate::render::{RenderError, RenderState};
 use crate::window::Window;
-use crate::wrapper::messages::{DesktopFrontendMessage, DesktopWrapperMessage, InputMessage, MouseKeys, MouseState, Preferences};
+use crate::wrapper::messages::{DesktopFrontendMessage, DesktopWrapperMessage, InputMessage, MouseKeys, PointerState, Preferences};
 use crate::wrapper::{DesktopWrapper, NodeGraphExecutionResult, WgpuContext, serialize_frontend_messages};
 
 pub(crate) struct App {
@@ -628,13 +628,13 @@ impl ApplicationHandler for App {
 				};
 				if let Some(mouse_keys) = mouse_keys {
 					let message = DesktopWrapperMessage::Input(InputMessage::PointerDown {
-						editor_mouse_state: MouseState { mouse_keys, ..Default::default() },
+						editor_pointer_state: PointerState { mouse_keys, ..Default::default() },
 						modifier_keys: Default::default(),
 					});
 					self.app_event_scheduler.schedule(AppEvent::DesktopWrapperMessage(message));
 
 					let message = DesktopWrapperMessage::Input(InputMessage::PointerUp {
-						editor_mouse_state: Default::default(),
+						editor_pointer_state: Default::default(),
 						modifier_keys: Default::default(),
 					});
 					self.app_event_scheduler.schedule(AppEvent::DesktopWrapperMessage(message));

desktop/src/cef/input/state.rs

@@ -11,7 +11,7 @@ use crate::cef::consts::{MULTICLICK_ALLOWED_TRAVEL, MULTICLICK_TIMEOUT};
 pub(crate) struct InputState {
 	modifiers: ModifiersState,
 	mouse_position: MousePosition,
-	mouse_state: MouseState,
+	pointer_state: PointerState,
 	mouse_click_tracker: ClickTracker,
 }
 impl InputState {
@@ -41,7 +41,7 @@ impl InputState {
 	}
 
 	pub(crate) fn mouse_input(&mut self, button: &MouseButton, state: &ElementState) -> ClickCount {
-		self.mouse_state.update(button, state);
+		self.pointer_state.update(button, state);
 		self.mouse_click_tracker.input(button, state, self.mouse_position)
 	}
 
@@ -93,12 +93,12 @@ impl From<&PhysicalPosition<f64>> for MousePosition {
 }
 
 #[derive(Default, Clone)]
-pub(crate) struct MouseState {
+pub(crate) struct PointerState {
 	left: bool,
 	right: bool,
 	middle: bool,
 }
-impl MouseState {
+impl PointerState {
 	pub(crate) fn update(&mut self, button: &MouseButton, state: &ElementState) {
 		match state {
 			ElementState::Pressed => match button {
@@ -233,13 +233,13 @@ impl CefModifiers {
 			inner |= cef_event_flags_t::EVENTFLAG_COMMAND_DOWN;
 		}
 
-		if input_state.mouse_state.left {
+		if input_state.pointer_state.left {
 			inner |= cef_event_flags_t::EVENTFLAG_LEFT_MOUSE_BUTTON;
 		}
-		if input_state.mouse_state.right {
+		if input_state.pointer_state.right {
 			inner |= cef_event_flags_t::EVENTFLAG_RIGHT_MOUSE_BUTTON;
 		}
-		if input_state.mouse_state.middle {
+		if input_state.pointer_state.middle {
 			inner |= cef_event_flags_t::EVENTFLAG_MIDDLE_MOUSE_BUTTON;
 		}
 

desktop/wrapper/src/messages.rs

@@ -5,7 +5,7 @@ pub(crate) use graphite_editor::messages::prelude::Message as EditorMessage;
 
 pub use graphite_editor::messages::frontend::utility_types::{DocumentInfo, PersistedState};
 pub use graphite_editor::messages::input_mapper::utility_types::input_keyboard::{Key, ModifierKeys};
-pub use graphite_editor::messages::input_mapper::utility_types::input_mouse::{EditorMouseState as MouseState, EditorPosition as Position, MouseKeys};
+pub use graphite_editor::messages::input_mapper::utility_types::input_pointer::{EditorPointerState as PointerState, EditorPosition as Position, MouseKeys};
 pub use graphite_editor::messages::prelude::DocumentId;
 pub use graphite_editor::messages::prelude::InputPreprocessorMessage as InputMessage;
 pub use graphite_editor::messages::prelude::PreferencesMessageHandler as Preferences;

editor/src/messages/input_mapper/input_mapper_message.rs

@@ -1,5 +1,5 @@
 use crate::messages::input_mapper::utility_types::input_keyboard::Key;
-use crate::messages::input_mapper::utility_types::input_mouse::MouseButton;
+use crate::messages::input_mapper::utility_types::input_pointer::MouseButton;
 use crate::messages::prelude::*;
 
 #[impl_message(Message, KeyMappingMessage, Lookup)]

editor/src/messages/input_mapper/input_mappings.rs

@@ -2,7 +2,7 @@ use crate::application::Editor;
 use crate::consts::{BIG_NUDGE_AMOUNT, BRUSH_SIZE_CHANGE_KEYBOARD, NUDGE_AMOUNT};
 use crate::messages::input_mapper::key_mapping::MappingVariant;
 use crate::messages::input_mapper::utility_types::input_keyboard::{Key, KeyStates};
-use crate::messages::input_mapper::utility_types::input_mouse::MouseButton;
+use crate::messages::input_mapper::utility_types::input_pointer::MouseButton;
 use crate::messages::input_mapper::utility_types::macros::*;
 use crate::messages::input_mapper::utility_types::misc::MappingEntry;
 use crate::messages::input_mapper::utility_types::misc::{KeyMappingEntries, Mapping};

editor/src/messages/input_mapper/utility_types/input_mouse.rs → editor/src/messages/input_mapper/utility_types/input_pointer.rs

@@ -50,47 +50,59 @@ impl ScrollDelta {
 	}
 }
 
-// TODO: Document the difference between this and EditorMouseState
+// TODO: Document the difference between this and EditorPointerState
 #[derive(Debug, Copy, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
-pub struct MouseState {
+pub struct PointerState {
 	pub position: ViewportPosition,
 	pub mouse_keys: MouseKeys,
 	pub scroll_delta: ScrollDelta,
+	pub pressure: f64,
 }
 
-impl MouseState {
+impl PointerState {
 	pub fn finish_transaction(&self, drag_start: DVec2, responses: &mut VecDeque<Message>) {
 		let drag_too_small = drag_start.distance(self.position) <= DRAG_THRESHOLD;
 		let response = if drag_too_small { DocumentMessage::AbortTransaction } else { DocumentMessage::EndTransaction };
 		responses.add(response);
 	}
 }
 
-// TODO: Document the difference between this and MouseState
+// TODO: Document the difference between this and PointerState
 #[derive(Debug, Copy, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
-pub struct EditorMouseState {
+pub struct EditorPointerState {
 	pub editor_position: EditorPosition,
 	pub mouse_keys: MouseKeys,
 	pub scroll_delta: ScrollDelta,
+
+	/// Tablet Pointer attributes
+	pub pressure: f64,
+	//TODO: tangential pressure, azimuth & altitude, twist
 }
 
-impl EditorMouseState {
+impl EditorPointerState {
 	pub fn from_keys_and_editor_position(keys: u8, editor_position: EditorPosition) -> Self {
+		let pressure: f64 = 1.0;
+		Self::from_keys_with_pressure_and_editor_position(keys, pressure, editor_position)
+	}
+
+	pub fn from_keys_with_pressure_and_editor_position(keys: u8, pressure: f64, editor_position: EditorPosition) -> Self {
 		// TODO: Some graphic tablets send key codes not mentioned in the spec. In the future we would like to support these as well.
 		let mouse_keys = MouseKeys::from_bits_truncate(keys);
 
 		Self {
 			editor_position,
 			mouse_keys,
 			scroll_delta: ScrollDelta::default(),
+			pressure,
 		}
 	}
 
-	pub fn to_mouse_state(&self, viewport: &ViewportMessageHandler) -> MouseState {
-		MouseState {
+	pub fn to_pointer_state(&self, viewport: &ViewportMessageHandler) -> PointerState {
+		PointerState {
 			position: (viewport.logical(self.editor_position) - viewport.offset()).into(),
 			mouse_keys: self.mouse_keys,
 			scroll_delta: self.scroll_delta,
+			pressure: self.pressure,
 		}
 	}
 }

editor/src/messages/input_mapper/utility_types/misc.rs

@@ -1,7 +1,7 @@
 use super::input_keyboard::{KeysGroup, LabeledShortcut, all_required_modifiers_pressed};
 use crate::messages::input_mapper::key_mapping::MappingVariant;
 use crate::messages::input_mapper::utility_types::input_keyboard::{KeyStates, NUMBER_OF_KEYS};
-use crate::messages::input_mapper::utility_types::input_mouse::NUMBER_OF_MOUSE_BUTTONS;
+use crate::messages::input_mapper::utility_types::input_pointer::NUMBER_OF_MOUSE_BUTTONS;
 use crate::messages::prelude::*;
 use core::time::Duration;
 

editor/src/messages/input_mapper/utility_types/mod.rs

@@ -1,4 +1,4 @@
 pub mod input_keyboard;
-pub mod input_mouse;
+pub mod input_pointer;
 pub mod macros;
 pub mod misc;

editor/src/messages/input_preprocessor/input_preprocessor_message.rs

@@ -1,17 +1,17 @@
 use crate::messages::input_mapper::utility_types::input_keyboard::{Key, ModifierKeys};
-use crate::messages::input_mapper::utility_types::input_mouse::EditorMouseState;
+use crate::messages::input_mapper::utility_types::input_pointer::EditorPointerState;
 use crate::messages::prelude::*;
 
 #[impl_message(Message, InputPreprocessor)]
 #[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub enum InputPreprocessorMessage {
-	DoubleClick { editor_mouse_state: EditorMouseState, modifier_keys: ModifierKeys },
+	DoubleClick { editor_pointer_state: EditorPointerState, modifier_keys: ModifierKeys },
 	KeyDown { key: Key, key_repeat: bool, modifier_keys: ModifierKeys },
 	KeyUp { key: Key, key_repeat: bool, modifier_keys: ModifierKeys },
-	PointerDown { editor_mouse_state: EditorMouseState, modifier_keys: ModifierKeys },
-	PointerMove { editor_mouse_state: EditorMouseState, modifier_keys: ModifierKeys },
-	PointerUp { editor_mouse_state: EditorMouseState, modifier_keys: ModifierKeys },
-	PointerShake { editor_mouse_state: EditorMouseState, modifier_keys: ModifierKeys },
+	PointerDown { editor_pointer_state: EditorPointerState, modifier_keys: ModifierKeys },
+	PointerMove { editor_pointer_state: EditorPointerState, modifier_keys: ModifierKeys },
+	PointerUp { editor_pointer_state: EditorPointerState, modifier_keys: ModifierKeys },
+	PointerShake { editor_pointer_state: EditorPointerState, modifier_keys: ModifierKeys },
 	CurrentTime { timestamp: u64 },
-	WheelScroll { editor_mouse_state: EditorMouseState, modifier_keys: ModifierKeys },
+	WheelScroll { editor_pointer_state: EditorPointerState, modifier_keys: ModifierKeys },
 }

editor/src/messages/input_preprocessor/input_preprocessor_message_handler.rs

@@ -1,6 +1,6 @@
 use crate::application::Editor;
 use crate::messages::input_mapper::utility_types::input_keyboard::{Key, KeyStates, ModifierKeys};
-use crate::messages::input_mapper::utility_types::input_mouse::{MouseButton, MouseKeys, MouseState};
+use crate::messages::input_mapper::utility_types::input_pointer::{MouseButton, MouseKeys, PointerState};
 use crate::messages::input_mapper::utility_types::misc::FrameTimeInfo;
 use crate::messages::prelude::*;
 use std::time::Duration;
@@ -15,7 +15,7 @@ pub struct InputPreprocessorMessageHandler {
 	pub frame_time: FrameTimeInfo,
 	pub time: u64,
 	pub keyboard: KeyStates,
-	pub mouse: MouseState,
+	pub pointer: PointerState,
 }
 
 #[message_handler_data]
@@ -24,13 +24,14 @@ impl<'a> MessageHandler<InputPreprocessorMessage, InputPreprocessorMessageContex
 		let InputPreprocessorMessageContext { viewport } = context;
 
 		match message {
-			InputPreprocessorMessage::DoubleClick { editor_mouse_state, modifier_keys } => {
+			InputPreprocessorMessage::DoubleClick { editor_pointer_state, modifier_keys } => {
 				self.update_states_of_modifier_keys(modifier_keys, responses);
 
-				let mouse_state = editor_mouse_state.to_mouse_state(viewport);
-				self.mouse.position = mouse_state.position;
+				let pointer_state = editor_pointer_state.to_pointer_state(viewport);
+				self.pointer.position = pointer_state.position;
+				self.pointer.pressure = pointer_state.pressure;
 
-				for key in mouse_state.mouse_keys {
+				for key in pointer_state.mouse_keys {
 					responses.add(InputMapperMessage::DoubleClick(match key {
 						MouseKeys::LEFT => MouseButton::Left,
 						MouseKeys::RIGHT => MouseButton::Right,
@@ -57,38 +58,42 @@ impl<'a> MessageHandler<InputPreprocessorMessage, InputPreprocessorMessageContex
 				}
 				responses.add(InputMapperMessage::KeyUp(key));
 			}
-			InputPreprocessorMessage::PointerDown { editor_mouse_state, modifier_keys } => {
+			InputPreprocessorMessage::PointerDown { editor_pointer_state, modifier_keys } => {
 				self.update_states_of_modifier_keys(modifier_keys, responses);
 
-				let mouse_state = editor_mouse_state.to_mouse_state(viewport);
-				self.mouse.position = mouse_state.position;
+				let pointer_state = editor_pointer_state.to_pointer_state(viewport);
+				self.pointer.position = pointer_state.position;
+				self.pointer.pressure = pointer_state.pressure;
 
-				self.translate_mouse_event(mouse_state, true, responses);
+				self.translate_mouse_event(pointer_state, true, responses);
 			}
-			InputPreprocessorMessage::PointerMove { editor_mouse_state, modifier_keys } => {
+			InputPreprocessorMessage::PointerMove { editor_pointer_state, modifier_keys } => {
 				self.update_states_of_modifier_keys(modifier_keys, responses);
 
-				let mouse_state = editor_mouse_state.to_mouse_state(viewport);
-				self.mouse.position = mouse_state.position;
+				let pointer_state = editor_pointer_state.to_pointer_state(viewport);
+				self.pointer.position = pointer_state.position;
+				self.pointer.pressure = pointer_state.pressure;
 
 				responses.add(InputMapperMessage::PointerMove);
 
 				// While any pointer button is already down, additional button down events are not reported, but they are sent as `pointermove` events
-				self.translate_mouse_event(mouse_state, false, responses);
+				self.translate_mouse_event(pointer_state, false, responses);
 			}
-			InputPreprocessorMessage::PointerUp { editor_mouse_state, modifier_keys } => {
+			InputPreprocessorMessage::PointerUp { editor_pointer_state, modifier_keys } => {
 				self.update_states_of_modifier_keys(modifier_keys, responses);
 
-				let mouse_state = editor_mouse_state.to_mouse_state(viewport);
-				self.mouse.position = mouse_state.position;
+				let pointer_state = editor_pointer_state.to_pointer_state(viewport);
+				self.pointer.position = pointer_state.position;
+				self.pointer.pressure = pointer_state.pressure;
 
-				self.translate_mouse_event(mouse_state, false, responses);
+				self.translate_mouse_event(pointer_state, false, responses);
 			}
-			InputPreprocessorMessage::PointerShake { editor_mouse_state, modifier_keys } => {
+			InputPreprocessorMessage::PointerShake { editor_pointer_state, modifier_keys } => {
 				self.update_states_of_modifier_keys(modifier_keys, responses);
 
-				let mouse_state = editor_mouse_state.to_mouse_state(viewport);
-				self.mouse.position = mouse_state.position;
+				let pointer_state = editor_pointer_state.to_pointer_state(viewport);
+				self.pointer.position = pointer_state.position;
+				self.pointer.pressure = pointer_state.pressure;
 
 				responses.add(InputMapperMessage::PointerShake);
 			}
@@ -97,12 +102,13 @@ impl<'a> MessageHandler<InputPreprocessorMessage, InputPreprocessorMessageContex
 				self.time = timestamp;
 				self.frame_time.advance_timestamp(Duration::from_millis(timestamp));
 			}
-			InputPreprocessorMessage::WheelScroll { editor_mouse_state, modifier_keys } => {
+			InputPreprocessorMessage::WheelScroll { editor_pointer_state, modifier_keys } => {
 				self.update_states_of_modifier_keys(modifier_keys, responses);
 
-				let mouse_state = editor_mouse_state.to_mouse_state(viewport);
-				self.mouse.position = mouse_state.position;
-				self.mouse.scroll_delta = mouse_state.scroll_delta;
+				let pointer_state = editor_pointer_state.to_pointer_state(viewport);
+				self.pointer.position = pointer_state.position;
+				self.pointer.pressure = pointer_state.pressure;
+				self.pointer.scroll_delta = pointer_state.scroll_delta;
 
 				responses.add(InputMapperMessage::WheelScroll);
 			}
@@ -116,7 +122,7 @@ impl<'a> MessageHandler<InputPreprocessorMessage, InputPreprocessorMessageContex
 }
 
 impl InputPreprocessorMessageHandler {
-	fn translate_mouse_event(&mut self, mut new_state: MouseState, allow_first_button_down: bool, responses: &mut VecDeque<Message>) {
+	fn translate_mouse_event(&mut self, mut new_state: PointerState, allow_first_button_down: bool, responses: &mut VecDeque<Message>) {
 		let click_mappings = [
 			(MouseKeys::LEFT, Key::MouseLeft),
 			(MouseKeys::RIGHT, Key::MouseRight),
@@ -127,10 +133,10 @@ impl InputPreprocessorMessageHandler {
 
 		for (bit_flag, key) in click_mappings {
 			// Calculate the intersection between the two key states
-			let old_down = self.mouse.mouse_keys & bit_flag == bit_flag;
+			let old_down = self.pointer.mouse_keys & bit_flag == bit_flag;
 			let new_down = new_state.mouse_keys & bit_flag == bit_flag;
 			if !old_down && new_down {
-				if allow_first_button_down || self.mouse.mouse_keys != MouseKeys::empty() {
+				if allow_first_button_down || self.pointer.mouse_keys != MouseKeys::empty() {
 					self.keyboard.set(key as usize);
 					responses.add(InputMapperMessage::KeyDown(key));
 				} else {
@@ -144,7 +150,7 @@ impl InputPreprocessorMessageHandler {
 			}
 		}
 
-		self.mouse = new_state;
+		self.pointer = new_state;
 	}
 
 	fn update_states_of_modifier_keys(&mut self, pressed_modifier_keys: ModifierKeys, responses: &mut VecDeque<Message>) {
@@ -186,20 +192,21 @@ impl InputPreprocessorMessageHandler {
 #[cfg(test)]
 mod test {
 	use crate::messages::input_mapper::utility_types::input_keyboard::{Key, ModifierKeys};
-	use crate::messages::input_mapper::utility_types::input_mouse::{EditorMouseState, MouseKeys, ScrollDelta};
+	use crate::messages::input_mapper::utility_types::input_pointer::{EditorPointerState, MouseKeys, ScrollDelta};
 	use crate::messages::prelude::*;
 
 	#[test]
 	fn process_action_mouse_move_handle_modifier_keys() {
 		let mut input_preprocessor = InputPreprocessorMessageHandler::default();
 
-		let editor_mouse_state = EditorMouseState {
+		let editor_pointer_state = EditorPointerState {
 			editor_position: (4., 809.).into(),
 			mouse_keys: MouseKeys::default(),
 			scroll_delta: ScrollDelta::default(),
+			pressure: 1f64,
 		};
 		let modifier_keys = ModifierKeys::ALT;
-		let message = InputPreprocessorMessage::PointerMove { editor_mouse_state, modifier_keys };
+		let message = InputPreprocessorMessage::PointerMove { editor_pointer_state, modifier_keys };
 
 		let mut responses = VecDeque::new();
 
@@ -216,9 +223,9 @@ mod test {
 	fn process_action_mouse_down_handle_modifier_keys() {
 		let mut input_preprocessor = InputPreprocessorMessageHandler::default();
 
-		let editor_mouse_state = EditorMouseState::default();
+		let editor_pointer_state = EditorPointerState::default();
 		let modifier_keys = ModifierKeys::CONTROL;
-		let message = InputPreprocessorMessage::PointerDown { editor_mouse_state, modifier_keys };
+		let message = InputPreprocessorMessage::PointerDown { editor_pointer_state, modifier_keys };
 
 		let mut responses = VecDeque::new();
 
@@ -235,9 +242,9 @@ mod test {
 	fn process_action_mouse_up_handle_modifier_keys() {
 		let mut input_preprocessor = InputPreprocessorMessageHandler::default();
 
-		let editor_mouse_state = EditorMouseState::default();
+		let editor_pointer_state = EditorPointerState::default();
 		let modifier_keys = ModifierKeys::SHIFT;
-		let message = InputPreprocessorMessage::PointerUp { editor_mouse_state, modifier_keys };
+		let message = InputPreprocessorMessage::PointerUp { editor_pointer_state, modifier_keys };
 
 		let mut responses = VecDeque::new();