Remove most of document-legacy (#1519)

* Remove boolean ops and unused doc-legacy Operations

* Remove Shape legacy layers

* Remove legacy layer Properties panel code

* Remove additional unused doc-legacy Operations

* Removed unused rendering-related legacy-layer code

* Upgrade dep so CI builds

* Remove various additional unused functions and messages

* Remove the LayerData trait

* Remove RenderData struct and usages

* Banish the Operations system

* Further removals

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

@@ -2,7 +2,7 @@ use crate::messages::portfolio::document::node_graph::VectorDataModification;
 use crate::messages::prelude::*;
 
 use bezier_rs::{ManipulatorGroup, Subpath};
-use document_legacy::{document::Document, document_metadata::LayerNodeIdentifier, LayerId, Operation};
+use document_legacy::{document::Document, document_metadata::LayerNodeIdentifier};
 use graph_craft::document::{value::TaggedValue, DocumentNode, NodeId, NodeInput, NodeNetwork};
 use graphene_core::raster::{BlendMode, ImageFrame};
 use graphene_core::text::Font;
@@ -10,7 +10,7 @@ use graphene_core::uuid::ManipulatorGroupId;
 use graphene_core::vector::style::{FillType, Gradient};
 use graphene_core::Color;
 
-use glam::{DAffine2, DVec2};
+use glam::DVec2;
 use std::collections::VecDeque;
 
 /// Create a new vector layer from a vector of [`bezier_rs::Subpath`].
@@ -34,18 +34,6 @@ pub fn new_image_layer(image_frame: ImageFrame<Color>, id: NodeId, parent: Layer
 	LayerNodeIdentifier::new_unchecked(id)
 }
 
-/// Create a legacy node graph frame TODO: remove
-pub fn new_custom_layer(network: NodeNetwork, layer_path: Vec<LayerId>, responses: &mut VecDeque<Message>) {
-	responses.add(DocumentMessage::DeselectAllLayers);
-	responses.add(Operation::AddFrame {
-		path: layer_path.clone(),
-		insert_index: -1,
-		transform: DAffine2::ZERO.to_cols_array(),
-		network,
-	});
-	responses.add(DocumentMessage::InputFrameRasterizeRegionBelowLayer { layer_path });
-}
-
 /// Batch set all of the manipulator groups to mirror on a specific layer
 pub fn set_manipulator_mirror_angle(manipulator_groups: &[ManipulatorGroup<ManipulatorGroupId>], layer: LayerNodeIdentifier, mirror_angle: bool, responses: &mut VecDeque<Message>) {
 	for manipulator_group in manipulator_groups {
@@ -77,12 +65,6 @@ pub fn get_pivot(layer: LayerNodeIdentifier, document: &Document) -> Option<DVec
 	}
 }
 
-pub fn get_document_pivot(layer: LayerNodeIdentifier, document: &Document) -> DVec2 {
-	let [min, max] = document.metadata.nonzero_bounding_box(layer);
-	let pivot = get_pivot(layer, document).unwrap_or(DVec2::splat(0.5));
-	document.metadata.transform_to_document(layer).transform_point2(min + (max - min) * pivot)
-}
-
 pub fn get_viewport_pivot(layer: LayerNodeIdentifier, document: &Document) -> DVec2 {
 	let [min, max] = document.metadata.nonzero_bounding_box(layer);
 	let pivot = get_pivot(layer, document).unwrap_or(DVec2::splat(0.5));
@@ -234,25 +216,6 @@ impl<'a> NodeGraphLayer<'a> {
 		})
 	}
 
-	/// Get the nearest layer node from the path and the document
-	pub fn new_from_path(layer: &[LayerId], document: &'a document_legacy::document::Document) -> Option<Self> {
-		let node_graph = &document.document_network;
-		let outwards_links = document.document_network.collect_outwards_links();
-
-		let Some(mut layer_node) = layer.last().copied() else {
-			error!("Tried to modify root layer");
-			return None;
-		};
-		while !node_graph.nodes.get(&layer_node)?.is_layer() {
-			layer_node = outwards_links.get(&layer_node)?.first().copied()?;
-		}
-		Some(Self {
-			node_graph,
-			_outwards_links: outwards_links,
-			layer_node,
-		})
-	}
-
 	/// Return an iterator up the primary flow of the layer
 	pub fn primary_layer_flow(&self) -> impl Iterator<Item = (&'a DocumentNode, u64)> {
 		self.node_graph.upstream_flow_back_from_nodes(vec![self.layer_node], true)

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

@@ -4,7 +4,6 @@ use crate::messages::prelude::*;
 use crate::messages::tool::common_functionality::snapping::SnapManager;
 
 use document_legacy::document_metadata::LayerNodeIdentifier;
-use document_legacy::layers::style::RenderData;
 
 use glam::{DAffine2, DVec2, Vec2Swizzles};
 
@@ -17,16 +16,16 @@ pub struct Resize {
 
 impl Resize {
 	/// Starts a resize, assigning the snap targets and snapping the starting position.
-	pub fn start(&mut self, responses: &mut VecDeque<Message>, document: &DocumentMessageHandler, input: &InputPreprocessorMessageHandler, render_data: &RenderData) {
-		self.snap_manager.start_snap(document, input, document.bounding_boxes(None, None, render_data), true, true);
+	pub fn start(&mut self, responses: &mut VecDeque<Message>, document: &DocumentMessageHandler, input: &InputPreprocessorMessageHandler) {
+		self.snap_manager.start_snap(document, input, document.bounding_boxes(), true, true);
 		self.snap_manager.add_all_document_handles(document, input, &[], &[], &[]);
 		let root_transform = document.metadata().document_to_viewport;
 		self.drag_start = root_transform.inverse().transform_point2(self.snap_manager.snap_position(responses, document, input.mouse.position));
 	}
 
 	/// Recalculates snap targets without snapping the starting position.
-	pub fn recalculate_snaps(&mut self, document: &DocumentMessageHandler, input: &InputPreprocessorMessageHandler, render_data: &RenderData) {
-		self.snap_manager.start_snap(document, input, document.bounding_boxes(None, None, render_data), true, true);
+	pub fn recalculate_snaps(&mut self, document: &DocumentMessageHandler, input: &InputPreprocessorMessageHandler) {
+		self.snap_manager.start_snap(document, input, document.bounding_boxes(), true, true);
 		self.snap_manager.add_all_document_handles(document, input, &[], &[], &[]);
 	}
 

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

@@ -2,10 +2,8 @@ use super::shape_editor::ManipulatorPointInfo;
 use crate::consts::{SNAP_AXIS_TOLERANCE, SNAP_POINT_TOLERANCE};
 use crate::messages::prelude::*;
 
-use document_legacy::document_metadata::LayerNodeIdentifier;
+use document_legacy::document::LayerId;
 use document_legacy::layers::layer_info::LegacyLayer;
-use document_legacy::LayerId;
-use graphene_core::vector::{ManipulatorPointId, SelectedType};
 
 use glam::DVec2;
 
@@ -109,42 +107,44 @@ impl SnapManager {
 	/// This should be called after start_snap
 	pub fn add_snap_path(
 		&mut self,
-		document_message_handler: &DocumentMessageHandler,
-		input: &InputPreprocessorMessageHandler,
-		layer: &LegacyLayer,
-		path: &[LayerId],
-		include_handles: bool,
-		ignore_points: &[ManipulatorPointInfo],
+		_document_message_handler: &DocumentMessageHandler,
+		_input: &InputPreprocessorMessageHandler,
+		_layer: &LegacyLayer,
+		_path: &[LayerId],
+		_include_handles: bool,
+		_ignore_points: &[ManipulatorPointInfo],
 	) {
-		let Some(vector_data) = &layer.as_vector_data() else { return };
+		todo!();
 
-		if !document_message_handler.snapping_state.node_snapping {
-			return;
-		};
+		// let Some(vector_data) = &layer.as_vector_data() else { return };
 
-		let transform = document_message_handler.document_legacy.multiply_transforms(path).unwrap();
-		let snap_points = vector_data
-			.manipulator_groups()
-			.flat_map(|group| {
-				if include_handles {
-					[
-						Some((ManipulatorPointId::new(group.id, SelectedType::Anchor), group.anchor)),
-						group.in_handle.map(|pos| (ManipulatorPointId::new(group.id, SelectedType::InHandle), pos)),
-						group.out_handle.map(|pos| (ManipulatorPointId::new(group.id, SelectedType::OutHandle), pos)),
-					]
-				} else {
-					[Some((ManipulatorPointId::new(group.id, SelectedType::Anchor), group.anchor)), None, None]
-				}
-			})
-			.flatten()
-			.filter(|&(point_id, _)| {
-				!ignore_points.contains(&ManipulatorPointInfo {
-					layer: LayerNodeIdentifier::from_path(path, document_message_handler.network()),
-					point_id,
-				})
-			})
-			.map(|(_, pos)| transform.transform_point2(pos));
-		self.add_snap_points(document_message_handler, input, snap_points);
+		// if !document_message_handler.snapping_state.node_snapping {
+		// 	return;
+		// };
+
+		// let transform = document_message_handler.document_legacy.multiply_transforms(path).unwrap();
+		// let snap_points = vector_data
+		// 	.manipulator_groups()
+		// 	.flat_map(|group| {
+		// 		if include_handles {
+		// 			[
+		// 				Some((ManipulatorPointId::new(group.id, SelectedType::Anchor), group.anchor)),
+		// 				group.in_handle.map(|pos| (ManipulatorPointId::new(group.id, SelectedType::InHandle), pos)),
+		// 				group.out_handle.map(|pos| (ManipulatorPointId::new(group.id, SelectedType::OutHandle), pos)),
+		// 			]
+		// 		} else {
+		// 			[Some((ManipulatorPointId::new(group.id, SelectedType::Anchor), group.anchor)), None, None]
+		// 		}
+		// 	})
+		// 	.flatten()
+		// 	.filter(|&(point_id, _)| {
+		// 		!ignore_points.contains(&ManipulatorPointInfo {
+		// 			layer: LayerNodeIdentifier::from_path(path, document_message_handler.network()),
+		// 			point_id,
+		// 		})
+		// 	})
+		// 	.map(|(_, pos)| transform.transform_point2(pos));
+		// self.add_snap_points(document_message_handler, input, snap_points);
 	}
 
 	/// Adds all of the shape handles in the document, including bézier handles of the points specified