Artboard grab scale

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

@@ -508,8 +508,11 @@ impl<'a> Selected<'a> {
 		tool_type: &'a ToolType,
 		pen_handle: Option<&'a mut DVec2>,
 	) -> Self {
-		// If user is using the Select tool or Shape tool then use the original layer transforms
-		if (*tool_type == ToolType::Select || *tool_type == ToolType::Shape) && (*original_transforms == OriginalTransforms::Path(HashMap::new())) {
+
+		// If user is using the Select tool or Shape tool then use the original layer transforms.
+		// Added the artboard tool to the list of tools that can use the layer transorms
+		if ((*tool_type == ToolType::Select || *tool_type == ToolType::Shape || *tool_type == ToolType::Artboard) 
+				&& (*original_transforms == OriginalTransforms::Path(HashMap::new()))) {
 			*original_transforms = OriginalTransforms::Layer(HashMap::new());
 		}
 
@@ -540,11 +543,13 @@ impl<'a> Selected<'a> {
 	pub fn bounding_box(&mut self) -> Quad {
 		let metadata = self.network_interface.document_metadata();
 
+		let using_artboard_tool = *self.tool_type == ToolType::Artboard; //Checks if the Artboard tool is being used
+
 		let mut transform = self
 			.network_interface
 			.selected_nodes()
 			.selected_visible_and_unlocked_layers(self.network_interface)
-			.find(|layer| !self.network_interface.is_artboard(&layer.to_node(), &[]))
+			.find(|layer| using_artboard_tool || !self.network_interface.is_artboard(&layer.to_node(), &[])) // allows the Artboard tool to be used on artboards
 			.map(|layer| metadata.transform_to_viewport(layer))
 			.unwrap_or(DAffine2::IDENTITY);
 

editor/src/messages/tool/common_functionality/pivot.rs

@@ -136,8 +136,8 @@ impl PivotGizmo {
 			.unwrap_or_else(|| self.pivot.transform_from_normalized.transform_point2(DVec2::splat(0.5)))
 	}
 
-	pub fn recalculate_transform(&mut self, document: &DocumentMessageHandler) -> DAffine2 {
-		self.pivot.recalculate_pivot(document);
+	pub fn recalculate_transform(&mut self, document: &DocumentMessageHandler, active_tool_type: ToolType) -> DAffine2 {
+		self.pivot.recalculate_pivot(document, active_tool_type);
 		self.pivot.transform_from_normalized
 	}
 
@@ -225,16 +225,19 @@ impl Default for Pivot {
 
 impl Pivot {
 	/// Recomputes the pivot position and transform.
-	pub fn recalculate_pivot(&mut self, document: &DocumentMessageHandler) {
+	/// `active_tool_type` controls whether artboards are considered: the Artboard tool
+	/// needs them included so the pivot lands on the selected artboard during G/S.
+	pub fn recalculate_pivot(&mut self, document: &DocumentMessageHandler, active_tool_type: ToolType) {
 		let selected = document.network_interface.selected_nodes();
 		self.empty = !selected.has_selected_nodes();
 		if !selected.has_selected_nodes() {
 			return;
 		}
 
+		let include_artboards = active_tool_type == ToolType::Artboard;
 		let transform = selected
 			.selected_visible_and_unlocked_layers(&document.network_interface)
-			.find(|layer| !document.network_interface.is_artboard(&layer.to_node(), &[]))
+			.find(|layer| include_artboards || !document.network_interface.is_artboard(&layer.to_node(), &[]))
 			.map(|layer| document.metadata().transform_to_viewport_with_first_transform_node_if_group(layer, &document.network_interface))
 			.unwrap_or_default();
 

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

@@ -586,6 +586,7 @@ impl Fsm for ArtboardToolFsmState {
 			ArtboardToolFsmState::Ready { .. } => HintData(vec![
 				HintGroup(vec![HintInfo::mouse(MouseMotion::LmbDrag, "Draw Artboard")]),
 				HintGroup(vec![HintInfo::mouse(MouseMotion::LmbDrag, "Move Artboard")]),
+				HintGroup(vec![HintInfo::multi_keys([[Key::KeyG], [Key::KeyS]], "Grab/Scale Selected")]), // enable G/S for the Artboard tool
 				HintGroup(vec![HintInfo::keys([Key::Backspace], "Delete Artboard")]),
 			]),
 			ArtboardToolFsmState::Dragging => HintData(vec![

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

@@ -585,13 +585,15 @@ impl SelectToolData {
 
 /// Bounding boxes are unfortunately not axis aligned. The bounding boxes are found after a transformation is applied to all of the layers.
 /// This uses some rather confusing logic to determine what transform that should be.
-pub fn create_bounding_box_transform(document: &DocumentMessageHandler) -> DAffine2 {
-	// Update bounds
+// Added active_tool_type to check if the Artboard tool is being used
+pub fn create_bounding_box_transform(document: &DocumentMessageHandler, active_tool_type: ToolType) -> DAffine2 {
+	let include_artboards = active_tool_type == ToolType::Artboard;
+
 	document
 		.network_interface
 		.selected_nodes()
 		.selected_visible_and_unlocked_layers(&document.network_interface)
-		.find(|layer| !document.network_interface.is_artboard(&layer.to_node(), &[]))
+		.find(|layer| include_artboards || !document.network_interface.is_artboard(&layer.to_node(), &[]))
 		.map(|layer| document.metadata().transform_to_viewport_with_first_transform_node_if_group(layer, &document.network_interface))
 		.unwrap_or_default()
 }
@@ -638,7 +640,7 @@ impl Fsm for SelectToolFsmState {
 					}
 				}
 
-				let mut transform = create_bounding_box_transform(document);
+				let mut transform = create_bounding_box_transform(document, ToolType::Select);
 
 				// Check if the matrix is not invertible
 				let mut transform_tampered = false;
@@ -847,7 +849,7 @@ impl Fsm for SelectToolFsmState {
 
 				let has_layers = document.network_interface.selected_nodes().has_selected_nodes();
 				let draw_pivot = tool_data.pivot_gizmo.state.is_pivot() && overlay_context.visibility_settings.pivot() && has_layers;
-				tool_data.pivot_gizmo.pivot.recalculate_pivot(document);
+				tool_data.pivot_gizmo.pivot.recalculate_pivot(document, ToolType::Select);
 				let pivot = draw_pivot.then_some(tool_data.pivot_gizmo.pivot.pivot).flatten();
 				if let Some(pivot) = pivot {
 					let offset = tool_data

editor/src/messages/tool/transform_layer/transform_layer_message_handler.rs

@@ -148,7 +148,7 @@ impl MessageHandler<TransformLayerMessage, TransformLayerMessageContext<'_>> for
 			}
 
 			if !using_path_tool {
-				self.pivot_gizmo.recalculate_transform(document);
+				self.pivot_gizmo.recalculate_transform(document, tool_data.active_tool_type);
 				*selected.pivot = self.pivot_gizmo.position(document);
 				self.state.document_space_pivot = document.metadata().document_to_viewport.inverse().transform_point2(*selected.pivot);
 				self.grab_target = self.state.document_space_pivot;
@@ -348,7 +348,7 @@ impl MessageHandler<TransformLayerMessage, TransformLayerMessageContext<'_>> for
 					TransformType::Scale => TransformOperation::Scaling(Default::default()),
 				};
 				self.layer_bounding_box = selected.bounding_box();
-				let bounding_box = select_tool::create_bounding_box_transform(document);
+				let bounding_box = select_tool::create_bounding_box_transform(document, tool_data.active_tool_type);
 				self.state.local_transform_axes = [bounding_box.x_axis, bounding_box.y_axis].map(|axis| axis.normalize_or_zero());
 			}
 			TransformLayerMessage::BeginGrabPen { last_point, handle } | TransformLayerMessage::BeginRotatePen { last_point, handle } | TransformLayerMessage::BeginScalePen { last_point, handle } => {
@@ -390,6 +390,12 @@ impl MessageHandler<TransformLayerMessage, TransformLayerMessageContext<'_>> for
 				});
 			}
 			TransformLayerMessage::BeginGRS { operation: transform_type } => {
+
+				// Rotation is not applicable for the Artboard tool
+				if tool_data.active_tool_type == ToolType::Artboard && transform_type == TransformType::Rotate {
+					return;
+				}
+
 				let selected_points: Vec<&ManipulatorPointId> = shape_editor.selected_points().collect();
 				let selected_segments = shape_editor.selected_segments().collect::<Vec<_>>();