double-tapping space to open/close the node graph instead of Ctrl+Space

editor/src/messages/input_mapper/input_mapper_message.rs

@@ -16,6 +16,8 @@ pub enum InputMapperMessage {
 	KeyUpNoRepeat(Key),
 	#[child]
 	DoubleClick(MouseButton),
+	#[child]
+	DoubleTap(Key),
 
 	// Messages
 	PointerMove,

editor/src/messages/input_mapper/input_mapper_message_handler.rs

@@ -40,6 +40,7 @@ impl InputMapperMessageHandler {
 			.chain(self.mapping.key_up_no_repeat.iter())
 			.chain(self.mapping.key_down_no_repeat.iter())
 			.chain(self.mapping.double_click.iter())
+			.chain(self.mapping.double_tap.iter())
 			.chain(std::iter::once(&self.mapping.wheel_scroll))
 			.chain(std::iter::once(&self.mapping.pointer_move));
 		let all_mapping_entries = all_key_mapping_entries.flat_map(|entry| entry.0.iter());
@@ -69,6 +70,14 @@ impl InputMapperMessageHandler {
 			use InputMapperMessage as IMM;
 			match entry.input {
 				IMM::KeyDown(key) | IMM::KeyUp(key) | IMM::KeyDownNoRepeat(key) | IMM::KeyUpNoRepeat(key) => keys.push(key),
+				IMM::DoubleTap(key) => {
+					keys.push(Key::Double);
+					keys.push(key);
+				}
+				IMM::DoubleClick(button) => {
+					keys.push(Key::Double);
+					keys.push(button.into());
+				}
 				_ => (),
 			}
 

editor/src/messages/input_mapper/input_mappings.rs

@@ -338,7 +338,7 @@ pub fn input_mappings(zoom_with_scroll: bool) -> Mapping {
 		entry!(KeyDown(Tab); action_dispatch=ToolMessage::ToggleSelectVsPath),
 		//
 		// DocumentMessage
-		entry!(KeyDown(Space); modifiers=[Control], action_dispatch=DocumentMessage::GraphViewOverlayToggle),
+		entry!(DoubleTap(Space); action_dispatch=DocumentMessage::GraphViewOverlayToggle),
 		entry!(KeyDownNoRepeat(Escape); action_dispatch=DocumentMessage::Escape),
 		entry!(KeyDown(Delete); action_dispatch=DocumentMessage::DeleteSelectedLayers),
 		entry!(KeyDown(Backspace); action_dispatch=DocumentMessage::DeleteSelectedLayers),
@@ -452,6 +452,7 @@ pub fn input_mappings(zoom_with_scroll: bool) -> Mapping {
 		entry!(KeyDown(KeyR); modifiers=[Alt], action_dispatch=PortfolioMessage::ToggleRulers),
 		entry!(KeyDown(KeyD); modifiers=[Alt], action_dispatch=PortfolioMessage::ToggleDataPanelOpen),
 		entry!(KeyDown(Enter); modifiers=[Alt], action_dispatch=PortfolioMessage::ToggleFocusDocument),
+		entry!(KeyDown(Space); modifiers=[Accel], action_dispatch=PortfolioMessage::ToggleFocusDocument),
 		//
 		// DialogMessage
 		entry!(KeyDown(KeyE); modifiers=[Accel], action_dispatch=DialogMessage::RequestExportDialog),
@@ -466,7 +467,7 @@ pub fn input_mappings(zoom_with_scroll: bool) -> Mapping {
 		entry!(KeyDown(Space); modifiers=[Shift], action_dispatch=AnimationMessage::ToggleLivePreview),
 		entry!(KeyDown(Home); modifiers=[Shift], action_dispatch=AnimationMessage::RestartAnimation),
 	];
-	let (mut key_up, mut key_down, mut key_up_no_repeat, mut key_down_no_repeat, mut double_click, mut wheel_scroll, mut pointer_move, mut pointer_shake) = mappings;
+	let (mut key_up, mut key_down, mut key_up_no_repeat, mut key_down_no_repeat, mut double_click, mut double_tap, mut wheel_scroll, mut pointer_move, mut pointer_shake) = mappings;
 
 	let sort = |list: &mut KeyMappingEntries| list.0.sort_by(|a, b| b.modifiers.count_ones().cmp(&a.modifiers.count_ones()));
 	// Sort the sublists of `key_up`, `key_down`, `key_up_no_repeat`, and `key_down_no_repeat`
@@ -479,6 +480,10 @@ pub fn input_mappings(zoom_with_scroll: bool) -> Mapping {
 	for sublist in &mut double_click {
 		sort(sublist)
 	}
+	// Sort the sublists of `double_tap`
+	for sublist in &mut double_tap {
+		sort(sublist)
+	}
 	// Sort `wheel_scroll`
 	sort(&mut wheel_scroll);
 	// Sort `pointer_move`
@@ -492,6 +497,7 @@ pub fn input_mappings(zoom_with_scroll: bool) -> Mapping {
 		key_up_no_repeat,
 		key_down_no_repeat,
 		double_click,
+		double_tap,
 		wheel_scroll,
 		pointer_move,
 		pointer_shake,

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

@@ -240,6 +240,8 @@ pub enum Key {
 	FakeKeyPlus,
 	/// Not a physical key that can be pressed. May be used so that an actual shortcut bound to all ten number keys (0, ..., 9) can separately map this fake "key" as an additional binding to display the "0–9" shortcut label in the UI.
 	FakeKeyNumbers,
+	/// Not a physical key that can be pressed.
+	Double,
 
 	_KeysVariantCount, // This has to be the last element in the enum
 }
@@ -331,6 +333,7 @@ impl fmt::Display for Key {
 			// Fake keys for displaying special labels in the UI
 			Self::FakeKeyPlus => "+",
 			Self::FakeKeyNumbers => "0–9",
+			Self::Double => "2x",
 
 			_ => key_name.as_str(),
 		};

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

@@ -1,3 +1,4 @@
+use super::input_keyboard::Key;
 use crate::consts::DRAG_THRESHOLD;
 use crate::messages::prelude::*;
 use bitflags::bitflags;
@@ -121,4 +122,16 @@ pub enum MouseButton {
 	Forward,
 }
 
+impl From<MouseButton> for Key {
+	fn from(mouse_button: MouseButton) -> Self {
+		match mouse_button {
+			MouseButton::Left => Key::MouseLeft,
+			MouseButton::Right => Key::MouseRight,
+			MouseButton::Middle => Key::MouseMiddle,
+			MouseButton::Back => Key::MouseBack,
+			MouseButton::Forward => Key::MouseForward,
+		}
+	}
+}
+
 pub const NUMBER_OF_MOUSE_BUTTONS: usize = 5; // Should be the number of variants in MouseButton

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

@@ -119,6 +119,7 @@ macro_rules! mapping {
 		let mut key_up_no_repeat = KeyMappingEntries::key_array();
 		let mut key_down_no_repeat = KeyMappingEntries::key_array();
 		let mut double_click = KeyMappingEntries::mouse_buttons_arrays();
+		let mut double_tap = KeyMappingEntries::key_array();
 		let mut wheel_scroll = KeyMappingEntries::new();
 		let mut pointer_move = KeyMappingEntries::new();
 		let mut pointer_shake = KeyMappingEntries::new();
@@ -138,6 +139,7 @@ macro_rules! mapping {
 					InputMapperMessage::KeyDownNoRepeat(key) => &mut key_down_no_repeat[key as usize],
 					InputMapperMessage::KeyUpNoRepeat(key) => &mut key_up_no_repeat[key as usize],
 					InputMapperMessage::DoubleClick(key) => &mut double_click[key as usize],
+					InputMapperMessage::DoubleTap(key) => &mut double_tap[key as usize],
 					InputMapperMessage::WheelScroll => &mut wheel_scroll,
 					InputMapperMessage::PointerMove => &mut pointer_move,
 					InputMapperMessage::PointerShake => &mut pointer_shake,
@@ -148,7 +150,7 @@ macro_rules! mapping {
 		}
 		)*
 
-		(key_up, key_down, key_up_no_repeat, key_down_no_repeat, double_click, wheel_scroll, pointer_move, pointer_shake)
+		(key_up, key_down, key_up_no_repeat, key_down_no_repeat, double_click, double_tap, wheel_scroll, pointer_move, pointer_shake)
 	}};
 }
 

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

@@ -12,6 +12,7 @@ pub struct Mapping {
 	pub key_up_no_repeat: [KeyMappingEntries; NUMBER_OF_KEYS],
 	pub key_down_no_repeat: [KeyMappingEntries; NUMBER_OF_KEYS],
 	pub double_click: [KeyMappingEntries; NUMBER_OF_MOUSE_BUTTONS],
+	pub double_tap: [KeyMappingEntries; NUMBER_OF_KEYS],
 	pub wheel_scroll: KeyMappingEntries,
 	pub pointer_move: KeyMappingEntries,
 	pub pointer_shake: KeyMappingEntries,
@@ -36,6 +37,7 @@ impl Mapping {
 			InputMapperMessage::KeyDownNoRepeat(key) => &self.key_down_no_repeat[*key as usize],
 			InputMapperMessage::KeyUpNoRepeat(key) => &self.key_up_no_repeat[*key as usize],
 			InputMapperMessage::DoubleClick(key) => &self.double_click[*key as usize],
+			InputMapperMessage::DoubleTap(key) => &self.double_tap[*key as usize],
 			InputMapperMessage::WheelScroll => &self.wheel_scroll,
 			InputMapperMessage::PointerMove => &self.pointer_move,
 			InputMapperMessage::PointerShake => &self.pointer_shake,

editor/src/messages/input_preprocessor/input_preprocessor_message_handler.rs

@@ -1,4 +1,5 @@
 use crate::application::Editor;
+use crate::consts::DOUBLE_CLICK_MILLISECONDS;
 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::misc::FrameTimeInfo;
@@ -16,6 +17,10 @@ pub struct InputPreprocessorMessageHandler {
 	pub time: u64,
 	pub keyboard: KeyStates,
 	pub mouse: MouseState,
+	/// The most recent non-repeated key press and the timestamp of when it occurred, used as the first tap in double-tap detection.
+	pub last_key_down: Option<(Key, u64)>,
+	/// Set when a second tap of the same key occurs within the double-tap threshold. Cleared by any interrupting input (mouse button, scroll, or different key). The `DoubleTap` event is emitted on `KeyUp` if this is still set.
+	pub double_tap_key: Option<(Key, u64)>,
 }
 
 #[message_handler_data]
@@ -25,6 +30,7 @@ impl<'a> MessageHandler<InputPreprocessorMessage, InputPreprocessorMessageContex
 
 		match message {
 			InputPreprocessorMessage::DoubleClick { editor_mouse_state, modifier_keys } => {
+				self.clear_double_tap_state();
 				self.update_states_of_modifier_keys(modifier_keys, responses);
 
 				let mouse_state = editor_mouse_state.to_mouse_state(viewport);
@@ -44,7 +50,22 @@ impl<'a> MessageHandler<InputPreprocessorMessage, InputPreprocessorMessageContex
 			InputPreprocessorMessage::KeyDown { key, key_repeat, modifier_keys } => {
 				self.update_states_of_modifier_keys(modifier_keys, responses);
 				self.keyboard.set(key as usize);
+
 				if !key_repeat {
+					let no_mouse_buttons_held = self.mouse.mouse_keys.is_empty();
+					let no_modifier_keys_held = modifier_keys.is_empty();
+					let same_key_within_threshold = self
+						.last_key_down
+						.is_some_and(|(last_key, last_time)| last_key == key && self.time.saturating_sub(last_time) < DOUBLE_CLICK_MILLISECONDS);
+
+					if no_mouse_buttons_held && no_modifier_keys_held && same_key_within_threshold {
+						self.double_tap_key = Some((key, self.time));
+						self.last_key_down = None;
+					} else {
+						self.last_key_down = Some((key, self.time));
+						self.double_tap_key = None;
+					}
+
 					responses.add(InputMapperMessage::KeyDownNoRepeat(key));
 				}
 				responses.add(InputMapperMessage::KeyDown(key));
@@ -55,9 +76,15 @@ impl<'a> MessageHandler<InputPreprocessorMessage, InputPreprocessorMessageContex
 				if !key_repeat {
 					responses.add(InputMapperMessage::KeyUpNoRepeat(key));
 				}
+				if let Some((dt_key, dt_time)) = self.double_tap_key.take() {
+					if dt_key == key && self.mouse.mouse_keys.is_empty() && self.time.saturating_sub(dt_time) < DOUBLE_CLICK_MILLISECONDS {
+						responses.add(InputMapperMessage::DoubleTap(key));
+					}
+				}
 				responses.add(InputMapperMessage::KeyUp(key));
 			}
 			InputPreprocessorMessage::PointerDown { editor_mouse_state, modifier_keys } => {
+				self.clear_double_tap_state();
 				self.update_states_of_modifier_keys(modifier_keys, responses);
 
 				let mouse_state = editor_mouse_state.to_mouse_state(viewport);
@@ -77,6 +104,7 @@ impl<'a> MessageHandler<InputPreprocessorMessage, InputPreprocessorMessageContex
 				self.translate_mouse_event(mouse_state, false, responses);
 			}
 			InputPreprocessorMessage::PointerUp { editor_mouse_state, modifier_keys } => {
+				self.clear_double_tap_state();
 				self.update_states_of_modifier_keys(modifier_keys, responses);
 
 				let mouse_state = editor_mouse_state.to_mouse_state(viewport);
@@ -98,6 +126,7 @@ impl<'a> MessageHandler<InputPreprocessorMessage, InputPreprocessorMessageContex
 				self.frame_time.advance_timestamp(Duration::from_millis(timestamp));
 			}
 			InputPreprocessorMessage::WheelScroll { editor_mouse_state, modifier_keys } => {
+				self.clear_double_tap_state();
 				self.update_states_of_modifier_keys(modifier_keys, responses);
 
 				let mouse_state = editor_mouse_state.to_mouse_state(viewport);
@@ -116,6 +145,11 @@ impl<'a> MessageHandler<InputPreprocessorMessage, InputPreprocessorMessageContex
 }
 
 impl InputPreprocessorMessageHandler {
+	fn clear_double_tap_state(&mut self) {
+		self.last_key_down = None;
+		self.double_tap_key = None;
+	}
+
 	fn translate_mouse_event(&mut self, mut new_state: MouseState, allow_first_button_down: bool, responses: &mut VecDeque<Message>) {
 		let click_mappings = [
 			(MouseKeys::LEFT, Key::MouseLeft),