Add custom click targets to make Text node output easier to select (#4095)

* Stop pushing duplicate layer entries when re-clicking an already-selected layer

* Make Text node generate per-glyph bounding box click targets

* Show source-geometry outlines and aggregate all rows for layer click targets

* Strip 'editor:click_target' override on Path node so direct edits restore precise hit testing

* Fix inverting a zero-determinate transform

Author: Keavon

editor/src/messages/portfolio/document/document_message.rs

@@ -215,6 +215,9 @@ pub enum DocumentMessage {
 	UpdateClickTargets {
 		click_targets: HashMap<NodeId, Vec<Arc<ClickTarget>>>,
 	},
+	UpdateOutlines {
+		outlines: HashMap<NodeId, Vec<Arc<ClickTarget>>>,
+	},
 	UpdateClipTargets {
 		clip_targets: HashSet<NodeId>,
 	},

editor/src/messages/portfolio/document/document_message_handler.rs

@@ -1270,6 +1270,19 @@ impl MessageHandler<DocumentMessage, DocumentMessageContext<'_>> for DocumentMes
 					.collect();
 				self.network_interface.update_click_targets(layer_click_targets);
 			}
+			DocumentMessage::UpdateOutlines { outlines } => {
+				let layer_outlines = outlines
+					.into_iter()
+					.filter(|(node_id, _)| self.network_interface.document_network().nodes.contains_key(node_id))
+					.filter_map(|(node_id, outlines)| {
+						self.network_interface.is_layer(&node_id, &[]).then(|| {
+							let layer = LayerNodeIdentifier::new(node_id, &self.network_interface);
+							(layer, outlines)
+						})
+					})
+					.collect();
+				self.network_interface.update_outlines(layer_outlines);
+			}
 			DocumentMessage::UpdateClipTargets { clip_targets } => {
 				self.network_interface.update_clip_targets(clip_targets);
 			}

editor/src/messages/portfolio/document/utility_types/document_metadata.rs

@@ -28,6 +28,9 @@ pub struct DocumentMetadata {
 	pub first_element_source_ids: HashMap<NodeId, Option<NodeId>>,
 	pub structure: HashMap<LayerNodeIdentifier, NodeRelations>,
 	pub click_targets: HashMap<LayerNodeIdentifier, Vec<Arc<ClickTarget>>>,
+	/// Source-geometry outlines for hover/selection overlays, separate from `click_targets` so
+	/// nodes with an `editor:click_target` override still outline the precise geometry.
+	pub outlines: HashMap<LayerNodeIdentifier, Vec<Arc<ClickTarget>>>,
 	pub clip_targets: HashSet<NodeId>,
 	pub vector_modify: HashMap<NodeId, Vector>,
 	/// Vector data keyed by layer ID, used as fallback when no Path node exists.
@@ -154,17 +157,23 @@ impl DocumentMetadata {
 // ===============================
 
 impl DocumentMetadata {
+	/// Outline targets if present, otherwise click targets. Used for bounding boxes and outline
+	/// drawing so layers with an `editor:click_target` override report precise geometry bounds.
+	fn visual_targets(&self, layer: LayerNodeIdentifier) -> Option<&[Arc<ClickTarget>]> {
+		self.outlines.get(&layer).or_else(|| self.click_targets.get(&layer)).map(|v| v.as_slice())
+	}
+
 	/// Get the bounding box of the click target of the specified layer in the specified transform space
 	pub fn bounding_box_with_transform(&self, layer: LayerNodeIdentifier, transform: DAffine2) -> Option<[DVec2; 2]> {
-		self.click_targets(layer)?
+		self.visual_targets(layer)?
 			.iter()
 			.filter_map(|click_target| click_target.bounding_box_with_transform(transform))
 			.reduce(Quad::combine_bounds)
 	}
 
 	/// Get the loose bounding box of the click target of the specified layer in the specified transform space
 	pub fn loose_bounding_box_with_transform(&self, layer: LayerNodeIdentifier, transform: DAffine2) -> Option<[DVec2; 2]> {
-		self.click_targets(layer)?
+		self.visual_targets(layer)?
 			.iter()
 			.filter_map(|click_target| match click_target.target_type() {
 				ClickTargetType::Subpath(subpath) => subpath.loose_bounding_box_with_transform(transform),
@@ -210,18 +219,14 @@ impl DocumentMetadata {
 	}
 
 	pub fn layer_outline(&self, layer: LayerNodeIdentifier) -> impl Iterator<Item = &subpath::Subpath<PointId>> {
-		static EMPTY: Vec<Arc<ClickTarget>> = Vec::new();
-		let click_targets = self.click_targets.get(&layer).unwrap_or(&EMPTY);
-		click_targets.iter().filter_map(|target| match target.target_type() {
+		self.visual_targets(layer).unwrap_or(&[]).iter().filter_map(|target| match target.target_type() {
 			ClickTargetType::Subpath(subpath) => Some(subpath),
 			_ => None,
 		})
 	}
 
 	pub fn layer_with_free_points_outline(&self, layer: LayerNodeIdentifier) -> impl Iterator<Item = &ClickTargetType> {
-		static EMPTY: Vec<Arc<ClickTarget>> = Vec::new();
-		let click_targets = self.click_targets.get(&layer).unwrap_or(&EMPTY);
-		click_targets.iter().map(|target| target.target_type())
+		self.visual_targets(layer).unwrap_or(&[]).iter().map(|target| target.target_type())
 	}
 
 	pub fn is_clip(&self, node: NodeId) -> bool {

editor/src/messages/portfolio/document/utility_types/network_interface.rs

@@ -3276,6 +3276,7 @@ impl NodeNetworkInterface {
 		self.document_metadata.local_transforms.retain(|node, _| nodes.contains(node));
 		self.document_metadata.vector_modify.retain(|node, _| nodes.contains(node));
 		self.document_metadata.click_targets.retain(|layer, _| self.document_metadata.structure.contains_key(layer));
+		self.document_metadata.outlines.retain(|layer, _| self.document_metadata.structure.contains_key(layer));
 	}
 
 	/// Update the cached transforms of the layers
@@ -3294,6 +3295,11 @@ impl NodeNetworkInterface {
 		self.document_metadata.click_targets = new_click_targets;
 	}
 
+	/// Update the cached source-geometry outline targets of the layers
+	pub fn update_outlines(&mut self, new_outlines: HashMap<LayerNodeIdentifier, Vec<Arc<ClickTarget>>>) {
+		self.document_metadata.outlines = new_outlines;
+	}
+
 	/// Update the cached clip targets of the layers
 	pub fn update_clip_targets(&mut self, new_clip_targets: HashSet<NodeId>) {
 		self.document_metadata.clip_targets = new_clip_targets;

editor/src/messages/tool/tool_messages/select_tool.rs

@@ -1823,7 +1823,10 @@ fn drag_shallowest_manipulation(responses: &mut VecDeque<Message>, selected: Vec
 	}
 
 	let new_selected = final_selection.unwrap_or_else(|| clicked_layer.ancestors(document.metadata()).filter(not_artboard(document)).last().unwrap_or(clicked_layer));
-	tool_data.layers_dragging.extend(vec![new_selected]);
+	// Duplicates cause `SelectedNodesSet` to carry the layer twice, breaking the Data panel's single-selection check in `node_to_inspect`
+	if !tool_data.layers_dragging.contains(&new_selected) {
+		tool_data.layers_dragging.push(new_selected);
+	}
 	tool_data.layers_dragging.retain(|&selected_layer| !selected_layer.is_child_of(metadata, &new_selected));
 	if remove {
 		tool_data.layers_dragging.retain(|&selected_layer| clicked_layer != selected_layer);
@@ -1885,7 +1888,10 @@ fn drag_deepest_manipulation(responses: &mut VecDeque<Message>, selected: Vec<La
 	);
 
 	if !remove {
-		tool_data.layers_dragging.extend(vec![layer]);
+		// Duplicates cause `SelectedNodesSet` to carry the layer twice, breaking the Data panel's single-selection check in `node_to_inspect`
+		if !tool_data.layers_dragging.contains(&layer) {
+			tool_data.layers_dragging.push(layer);
+		}
 	} else {
 		tool_data.layers_dragging.retain(|&selected_layer| layer != selected_layer);
 	}

editor/src/node_graph_executor.rs

@@ -309,6 +309,7 @@ impl NodeGraphExecutor {
 						Err(e) => {
 							// Clear the click targets while the graph is in an un-renderable state
 							document.network_interface.update_click_targets(HashMap::new());
+							document.network_interface.update_outlines(HashMap::new());
 							document.network_interface.update_vector_modify(HashMap::new());
 							return Err(format!("Node graph evaluation failed:\n{e}"));
 						}
@@ -355,6 +356,7 @@ impl NodeGraphExecutor {
 							// Clear the click targets while the graph is in an un-renderable state
 
 							document.network_interface.update_click_targets(HashMap::new());
+							document.network_interface.update_outlines(HashMap::new());
 							document.network_interface.update_vector_modify(HashMap::new());
 
 							log::trace!("{e}");
@@ -415,6 +417,7 @@ impl NodeGraphExecutor {
 			local_transforms,
 			first_element_source_id,
 			click_targets,
+			outlines,
 			clip_targets,
 			vector_data,
 			backgrounds: _,
@@ -427,6 +430,7 @@ impl NodeGraphExecutor {
 			first_element_source_id,
 		});
 		responses.add(DocumentMessage::UpdateClickTargets { click_targets });
+		responses.add(DocumentMessage::UpdateOutlines { outlines });
 		responses.add(DocumentMessage::UpdateClipTargets { clip_targets });
 		responses.add(DocumentMessage::UpdateVectorData { vector_data });
 		responses.add(DocumentMessage::RenderScrollbars);

node-graph/libraries/core-types/src/lib.rs

@@ -34,8 +34,8 @@ use std::any::TypeId;
 use std::future::Future;
 use std::pin::Pin;
 pub use table::{
-	ATTR_BACKGROUND, ATTR_BLEND_MODE, ATTR_CLIP, ATTR_CLIPPING_MASK, ATTR_DIMENSIONS, ATTR_EDITOR_LAYER_PATH, ATTR_EDITOR_MERGED_LAYERS, ATTR_END, ATTR_GRADIENT_TYPE, ATTR_LOCATION, ATTR_NAME,
-	ATTR_OPACITY, ATTR_OPACITY_FILL, ATTR_SPREAD_METHOD, ATTR_START, ATTR_TRANSFORM, ATTR_TYPE,
+	ATTR_BACKGROUND, ATTR_BLEND_MODE, ATTR_CLIP, ATTR_CLIPPING_MASK, ATTR_DIMENSIONS, ATTR_EDITOR_CLICK_TARGET, ATTR_EDITOR_LAYER_PATH, ATTR_EDITOR_MERGED_LAYERS, ATTR_END, ATTR_GRADIENT_TYPE,
+	ATTR_LOCATION, ATTR_NAME, ATTR_OPACITY, ATTR_OPACITY_FILL, ATTR_SPREAD_METHOD, ATTR_START, ATTR_TRANSFORM, ATTR_TYPE,
 };
 #[cfg(feature = "wasm")]
 pub use tsify;

node-graph/libraries/core-types/src/table.rs

@@ -36,6 +36,11 @@ pub const ATTR_EDITOR_LAYER_PATH: &str = "editor:layer_path";
 /// the original child layers after their content has been collapsed.
 pub const ATTR_EDITOR_MERGED_LAYERS: &str = "editor:merged_layers";
 
+/// Optional `Vector` that overrides the row's own geometry for click-target generation.
+/// Used by the 'Text' node for per-glyph bounding-box rectangles so glyphs are selectable
+/// by clicking anywhere within their bounds, not just the filled letterform.
+pub const ATTR_EDITOR_CLICK_TARGET: &str = "editor:click_target";
+
 /// Byte offset where a regex match begins ('Regex Find All', 'Regex Capture' text nodes).
 pub const ATTR_START: &str = "start";
 
@@ -484,6 +489,13 @@ impl AttributeColumns {
 		self.columns.iter().find_map(|(k, column)| if k == key { column.get_any(index)?.downcast_ref::<T>() } else { None })
 	}
 
+	/// Removes the entire column for the given key, if present.
+	fn remove_column(&mut self, key: &str) {
+		if let Some(position) = self.columns.iter().position(|(k, _)| k == key) {
+			self.columns.remove(position);
+		}
+	}
+
 	/// Finds or creates a column for the given key and type, returning its position.
 	/// If a column with the key exists but has the wrong type, it is removed and replaced with a new column of the correct type, padded with defaults.
 	/// A newly created column is filled with `T::default()` for all existing rows.
@@ -748,6 +760,11 @@ impl<T> Table<T> {
 		self.attributes.set_value(key, index, value);
 	}
 
+	/// Removes the entire attribute column for the given key, if present.
+	pub fn remove_attribute(&mut self, key: &str) {
+		self.attributes.remove_column(key);
+	}
+
 	/// Runs the given closure on a mutable reference to the attribute value at the given row index,
 	/// creating the column with defaults if it doesn't exist, and returns the closure's result.
 	pub fn with_attribute_mut_or_default<U: Clone + Send + Sync + Default + Debug + PartialEq + CacheHash + 'static, R, F: FnOnce(&mut U) -> R>(&mut self, key: &str, index: usize, f: F) -> R {