Remove the whole document-legacy crate (#1524)

Remove the whole document-legacy crate

Closes #1520

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

@@ -1,12 +1,11 @@
 use super::tool_prelude::*;
 use crate::application::generate_uuid;
 use crate::messages::portfolio::document::overlays::utility_types::OverlayContext;
+use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::tool::common_functionality::graph_modification_utils::is_layer_fed_by_node_of_name;
 use crate::messages::tool::common_functionality::snapping::SnapManager;
 use crate::messages::tool::common_functionality::transformation_cage::*;
 
-use document_legacy::document_metadata::LayerNodeIdentifier;
-
 use glam::{IVec2, Vec2Swizzles};
 
 #[derive(Default)]
@@ -132,9 +131,8 @@ impl ArtboardToolData {
 		responses.add(DocumentMessage::StartTransaction);
 
 		let mut intersections = document
-			.document_legacy
 			.click_xray(input.mouse.position)
-			.filter(|&layer| is_layer_fed_by_node_of_name(layer, &document.document_legacy, "Artboard"));
+			.filter(|&layer| is_layer_fed_by_node_of_name(layer, &document.network, "Artboard"));
 
 		responses.add(BroadcastEvent::DocumentIsDirty);
 		if let Some(intersection) = intersections.next() {

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

@@ -1,9 +1,9 @@
 use super::tool_prelude::*;
 use crate::messages::portfolio::document::node_graph::resolve_document_node_type;
 use crate::messages::portfolio::document::node_graph::transform_utils::{get_current_normalized_pivot, get_current_transform};
+use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::tool::common_functionality::color_selector::{ToolColorOptions, ToolColorType};
 
-use document_legacy::document_metadata::LayerNodeIdentifier;
 use graph_craft::document::value::TaggedValue;
 use graph_craft::document::{DocumentNodeMetadata, NodeInput};
 use graphene_core::raster::BlendMode;

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

@@ -69,7 +69,7 @@ impl Fsm for FillToolFsmState {
 		let ToolMessage::Fill(event) = event else {
 			return self;
 		};
-		let Some(layer_identifier) = document.document_legacy.click(input.mouse.position, &document.document_legacy.document_network) else {
+		let Some(layer_identifier) = document.click(input.mouse.position, &document.network) else {
 			return self;
 		};
 		let layer = layer_identifier.to_path();

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

@@ -1,9 +1,9 @@
 use super::tool_prelude::*;
 use crate::messages::portfolio::document::node_graph::VectorDataModification;
+use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::tool::common_functionality::color_selector::{ToolColorOptions, ToolColorType};
 use crate::messages::tool::common_functionality::graph_modification_utils;
 
-use document_legacy::document_metadata::LayerNodeIdentifier;
 use graphene_core::uuid::generate_uuid;
 use graphene_core::vector::style::{Fill, Stroke};
 use graphene_core::Color;

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

@@ -2,10 +2,10 @@ use super::tool_prelude::*;
 use crate::application::generate_uuid;
 use crate::consts::{LINE_ROTATE_SNAP_ANGLE, MANIPULATOR_GROUP_MARKER_SIZE, SELECTION_THRESHOLD};
 use crate::messages::portfolio::document::overlays::utility_types::OverlayContext;
+use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::tool::common_functionality::graph_modification_utils::get_gradient;
 use crate::messages::tool::common_functionality::snapping::SnapManager;
 
-use document_legacy::document_metadata::LayerNodeIdentifier;
 use graphene_core::raster::color::Color;
 use graphene_core::vector::style::{Fill, Gradient, GradientType};
 
@@ -170,7 +170,7 @@ impl SelectedGradient {
 		inner_gradient.transform = gradient_space_transform(inner_gradient.layer, document);
 
 		// Clear if no longer a gradient
-		let Some(gradient) = get_gradient(inner_gradient.layer, &document.document_legacy) else {
+		let Some(gradient) = get_gradient(inner_gradient.layer, &document.network) else {
 			responses.add(ToolMessage::RefreshToolOptions);
 			*gradient = None;
 			return;
@@ -296,8 +296,8 @@ impl Fsm for GradientToolFsmState {
 			(_, GradientToolMessage::Overlays(mut overlay_context)) => {
 				let selected = tool_data.selected_gradient.as_ref();
 
-				for layer in document.document_legacy.selected_visible_layers() {
-					let Some(gradient) = get_gradient(layer, &document.document_legacy) else { continue };
+				for layer in document.selected_visible_layers() {
+					let Some(gradient) = get_gradient(layer, &document.network) else { continue };
 					let transform = gradient_space_transform(layer, document);
 					let dragging = selected.filter(|selected| selected.layer == layer).map(|selected| selected.dragging);
 
@@ -366,8 +366,8 @@ impl Fsm for GradientToolFsmState {
 				self
 			}
 			(_, GradientToolMessage::InsertStop) => {
-				for layer in document.document_legacy.selected_visible_layers() {
-					let Some(mut gradient) = get_gradient(layer, &document.document_legacy) else { continue };
+				for layer in document.selected_visible_layers() {
+					let Some(mut gradient) = get_gradient(layer, &document.network) else { continue };
 					let transform = gradient_space_transform(layer, document);
 
 					let mouse = input.mouse.position;
@@ -407,8 +407,8 @@ impl Fsm for GradientToolFsmState {
 				let tolerance = (MANIPULATOR_GROUP_MARKER_SIZE * 2.).powi(2);
 
 				let mut dragging = false;
-				for layer in document.document_legacy.selected_visible_layers() {
-					let Some(gradient) = get_gradient(layer, &document.document_legacy) else { continue };
+				for layer in document.selected_visible_layers() {
+					let Some(gradient) = get_gradient(layer, &document.network) else { continue };
 					let transform = gradient_space_transform(layer, document);
 
 					// Check for dragging step
@@ -444,7 +444,7 @@ impl Fsm for GradientToolFsmState {
 					document.backup_nonmut(responses);
 					GradientToolFsmState::Drawing
 				} else {
-					let selected_layer = document.document_legacy.click(input.mouse.position, &document.document_legacy.document_network);
+					let selected_layer = document.click(input.mouse.position, &document.network);
 
 					// Apply the gradient to the selected layer
 					if let Some(layer) = selected_layer {
@@ -457,7 +457,7 @@ impl Fsm for GradientToolFsmState {
 						responses.add(DocumentMessage::StartTransaction);
 
 						// Use the already existing gradient if it exists
-						let gradient = if let Some(gradient) = get_gradient(layer, &document.document_legacy) {
+						let gradient = if let Some(gradient) = get_gradient(layer, &document.network) {
 							gradient.clone()
 						} else {
 							// Generate a new gradient

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

@@ -1,9 +1,8 @@
 use super::tool_prelude::*;
 use crate::messages::portfolio::document::node_graph::{self, IMAGINATE_NODE};
+use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::tool::common_functionality::resize::Resize;
 
-use document_legacy::document_metadata::LayerNodeIdentifier;
-
 use serde::{Deserialize, Serialize};
 
 #[derive(Default)]

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

@@ -1,10 +1,10 @@
 use super::tool_prelude::*;
 use crate::consts::LINE_ROTATE_SNAP_ANGLE;
+use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::tool::common_functionality::color_selector::{ToolColorOptions, ToolColorType};
 use crate::messages::tool::common_functionality::graph_modification_utils;
 use crate::messages::tool::common_functionality::snapping::SnapManager;
 
-use document_legacy::document_metadata::LayerNodeIdentifier;
 use graphene_core::uuid::generate_uuid;
 use graphene_core::vector::style::Stroke;
 use graphene_core::Color;

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

@@ -2,12 +2,12 @@ use super::tool_prelude::*;
 use crate::consts::{DRAG_THRESHOLD, SELECTION_THRESHOLD, SELECTION_TOLERANCE};
 use crate::messages::portfolio::document::overlays::utility_functions::path_overlays;
 use crate::messages::portfolio::document::overlays::utility_types::OverlayContext;
+use crate::messages::portfolio::document::utility_types::document_metadata::{DocumentMetadata, LayerNodeIdentifier};
 use crate::messages::tool::common_functionality::graph_modification_utils::{get_manipulator_from_id, get_mirror_handles, get_subpaths};
 use crate::messages::tool::common_functionality::shape_editor::{ManipulatorAngle, ManipulatorPointInfo, OpposingHandleLengths, SelectedPointsInfo, ShapeState};
 use crate::messages::tool::common_functionality::snapping::SnapManager;
 
-use document_legacy::document::Document;
-use document_legacy::document_metadata::LayerNodeIdentifier;
+use graph_craft::document::NodeNetwork;
 use graphene_core::renderer::Quad;
 use graphene_core::vector::{ManipulatorPointId, SelectedType};
 
@@ -223,14 +223,14 @@ impl PathToolData {
 		let _selected_layers = shape_editor.selected_layers().cloned().collect::<Vec<_>>();
 
 		// Select the first point within the threshold (in pixels)
-		if let Some(selected_points) = shape_editor.select_point(&document.document_legacy, input.mouse.position, SELECTION_THRESHOLD, shift) {
+		if let Some(selected_points) = shape_editor.select_point(&document.network, &document.metadata, input.mouse.position, SELECTION_THRESHOLD, shift) {
 			self.start_dragging_point(selected_points, input, document, responses);
 			responses.add(OverlaysMessage::Draw);
 
 			PathToolFsmState::Dragging
 		}
 		// We didn't find a point nearby, so consider selecting the nearest shape instead
-		else if let Some(layer) = document.document_legacy.click(input.mouse.position, &document.document_legacy.document_network) {
+		else if let Some(layer) = document.click(input.mouse.position, &document.network) {
 			if shift {
 				responses.add(NodeGraphMessage::SelectedNodesAdd { nodes: vec![layer.to_node()] });
 			} else {
@@ -238,7 +238,7 @@ impl PathToolData {
 			}
 			self.drag_start_pos = input.mouse.position;
 			self.previous_mouse_position = input.mouse.position;
-			shape_editor.select_all_anchors(&document.document_legacy, layer);
+			shape_editor.select_all_anchors(&document.network, layer);
 
 			PathToolFsmState::Dragging
 		} else {
@@ -292,16 +292,16 @@ impl PathToolData {
 
 		if shift {
 			if self.opposing_handle_lengths.is_none() {
-				self.opposing_handle_lengths = Some(shape_editor.opposing_handle_lengths(&document.document_legacy));
+				self.opposing_handle_lengths = Some(shape_editor.opposing_handle_lengths(&document.network));
 			}
 		} else if let Some(opposing_handle_lengths) = &self.opposing_handle_lengths {
-			shape_editor.reset_opposing_handle_lengths(&document.document_legacy, opposing_handle_lengths, responses);
+			shape_editor.reset_opposing_handle_lengths(&document.network, opposing_handle_lengths, responses);
 			self.opposing_handle_lengths = None;
 		}
 
 		// Move the selected points with the mouse
 		let snapped_position = self.snap_manager.snap_position(responses, document, input.mouse.position);
-		shape_editor.move_selected_points(&document.document_legacy, snapped_position - self.previous_mouse_position, shift, responses);
+		shape_editor.move_selected_points(&document.network, &document.metadata, snapped_position - self.previous_mouse_position, shift, responses);
 		self.previous_mouse_position = snapped_position;
 	}
 }
@@ -365,7 +365,7 @@ impl Fsm for PathToolFsmState {
 				if tool_data.drag_start_pos == tool_data.previous_mouse_position {
 					responses.add(NodeGraphMessage::SelectedNodesSet { nodes: vec![] });
 				} else {
-					shape_editor.select_all_in_quad(&document.document_legacy, [tool_data.drag_start_pos, tool_data.previous_mouse_position], !shift_pressed);
+					shape_editor.select_all_in_quad(&document.network, &document.metadata, [tool_data.drag_start_pos, tool_data.previous_mouse_position], !shift_pressed);
 				}
 				responses.add(OverlaysMessage::Draw);
 
@@ -379,7 +379,7 @@ impl Fsm for PathToolFsmState {
 				if tool_data.drag_start_pos == tool_data.previous_mouse_position {
 					responses.add(NodeGraphMessage::SelectedNodesSet { nodes: vec![] });
 				} else {
-					shape_editor.select_all_in_quad(&document.document_legacy, [tool_data.drag_start_pos, tool_data.previous_mouse_position], !shift_pressed);
+					shape_editor.select_all_in_quad(&document.network, &document.metadata, [tool_data.drag_start_pos, tool_data.previous_mouse_position], !shift_pressed);
 				}
 				responses.add(OverlaysMessage::Draw);
 				responses.add(PathToolMessage::SelectedPointUpdated);
@@ -391,16 +391,16 @@ impl Fsm for PathToolFsmState {
 				let shift_pressed = input.keyboard.get(shift_mirror_distance as usize);
 
 				let nearest_point = shape_editor
-					.find_nearest_point_indices(&document.document_legacy, input.mouse.position, SELECTION_THRESHOLD)
+					.find_nearest_point_indices(&document.network, &document.metadata, input.mouse.position, SELECTION_THRESHOLD)
 					.map(|(_, nearest_point)| nearest_point);
 
-				shape_editor.delete_selected_handles_with_zero_length(&document.document_legacy, &tool_data.opposing_handle_lengths, responses);
+				shape_editor.delete_selected_handles_with_zero_length(&document.network, &document.metadata, &tool_data.opposing_handle_lengths, responses);
 
 				if tool_data.drag_start_pos.distance(input.mouse.position) <= DRAG_THRESHOLD && !shift_pressed {
 					let clicked_selected = shape_editor.selected_points().any(|&point| nearest_point == Some(point));
 					if clicked_selected {
 						shape_editor.deselect_all();
-						shape_editor.select_point(&document.document_legacy, input.mouse.position, SELECTION_THRESHOLD, false);
+						shape_editor.select_point(&document.network, &document.metadata, input.mouse.position, SELECTION_THRESHOLD, false);
 						responses.add(OverlaysMessage::Draw);
 					}
 				}
@@ -421,9 +421,9 @@ impl Fsm for PathToolFsmState {
 			}
 			(_, PathToolMessage::InsertPoint) => {
 				// First we try and flip the sharpness (if they have clicked on an anchor)
-				if !shape_editor.flip_sharp(&document.document_legacy, input.mouse.position, SELECTION_TOLERANCE, responses) {
+				if !shape_editor.flip_sharp(&document.network, &document.metadata, input.mouse.position, SELECTION_TOLERANCE, responses) {
 					// If not, then we try and split the path that may have been clicked upon
-					shape_editor.split(&document.document_legacy, input.mouse.position, SELECTION_TOLERANCE, responses);
+					shape_editor.split(&document.network, &document.metadata, input.mouse.position, SELECTION_TOLERANCE, responses);
 				}
 
 				responses.add(PathToolMessage::SelectedPointUpdated);
@@ -436,35 +436,35 @@ impl Fsm for PathToolFsmState {
 			}
 			(_, PathToolMessage::PointerMove { .. }) => self,
 			(_, PathToolMessage::NudgeSelectedPoints { delta_x, delta_y }) => {
-				shape_editor.move_selected_points(&document.document_legacy, (delta_x, delta_y).into(), true, responses);
+				shape_editor.move_selected_points(&document.network, &document.metadata, (delta_x, delta_y).into(), true, responses);
 
 				PathToolFsmState::Ready
 			}
 			(_, PathToolMessage::SelectAllPoints) => {
-				shape_editor.select_all_points(&document.document_legacy);
+				shape_editor.select_all_points(&document.network);
 				responses.add(OverlaysMessage::Draw);
 				PathToolFsmState::Ready
 			}
 			(_, PathToolMessage::SelectedPointXChanged { new_x }) => {
 				if let Some(&SingleSelectedPoint { coordinates, id, layer, .. }) = tool_data.selection_status.as_one() {
-					shape_editor.reposition_control_point(&id, responses, &document.document_legacy, DVec2::new(new_x, coordinates.y), layer);
+					shape_editor.reposition_control_point(&id, responses, &document.network, &document.metadata, DVec2::new(new_x, coordinates.y), layer);
 				}
 				PathToolFsmState::Ready
 			}
 			(_, PathToolMessage::SelectedPointYChanged { new_y }) => {
 				if let Some(&SingleSelectedPoint { coordinates, id, layer, .. }) = tool_data.selection_status.as_one() {
-					shape_editor.reposition_control_point(&id, responses, &document.document_legacy, DVec2::new(coordinates.x, new_y), layer);
+					shape_editor.reposition_control_point(&id, responses, &document.network, &document.metadata, DVec2::new(coordinates.x, new_y), layer);
 				}
 				PathToolFsmState::Ready
 			}
 			(_, PathToolMessage::SelectedPointUpdated) => {
-				tool_data.selection_status = get_selection_status(&document.document_legacy, shape_editor);
+				tool_data.selection_status = get_selection_status(&document.network, &document.metadata, shape_editor);
 				self
 			}
 			(_, PathToolMessage::ManipulatorAngleMakeSmooth) => {
 				responses.add(DocumentMessage::StartTransaction);
 				shape_editor.set_handle_mirroring_on_selected(true, responses);
-				shape_editor.smooth_selected_groups(responses, &document.document_legacy);
+				shape_editor.smooth_selected_groups(responses, &document.network);
 				responses.add(DocumentMessage::CommitTransaction);
 				PathToolFsmState::Ready
 			}
@@ -549,7 +549,7 @@ struct SingleSelectedPoint {
 
 /// Sets the cumulative description of the selected points: if `None` are selected, if `One` is selected, or if `Multiple` are selected.
 /// Applies to any selected points, whether they are anchors or handles; and whether they are from a single shape or across multiple shapes.
-fn get_selection_status(document: &Document, shape_state: &mut ShapeState) -> SelectionStatus {
+fn get_selection_status(document_network: &NodeNetwork, document_metadata: &DocumentMetadata, shape_state: &mut ShapeState) -> SelectionStatus {
 	let mut selection_layers = shape_state.selected_shape_state.iter().map(|(k, v)| (*k, v.selected_points_count()));
 	let total_selected_points = selection_layers.clone().map(|(_, v)| v).sum::<usize>();
 
@@ -559,10 +559,10 @@ fn get_selection_status(document: &Document, shape_state: &mut ShapeState) -> Se
 			return SelectionStatus::None;
 		};
 
-		let Some(subpaths) = get_subpaths(layer, document) else {
+		let Some(subpaths) = get_subpaths(layer, document_network) else {
 			return SelectionStatus::None;
 		};
-		let Some(mirror) = get_mirror_handles(layer, document) else {
+		let Some(mirror) = get_mirror_handles(layer, document_network) else {
 			return SelectionStatus::None;
 		};
 		let Some(point) = shape_state.selected_points().next() else {
@@ -579,7 +579,7 @@ fn get_selection_status(document: &Document, shape_state: &mut ShapeState) -> Se
 		let manipulator_angle = if mirror.contains(&point.group) { ManipulatorAngle::Smooth } else { ManipulatorAngle::Sharp };
 
 		return SelectionStatus::One(SingleSelectedPoint {
-			coordinates: document.metadata.transform_to_document(layer).transform_point2(local_position),
+			coordinates: document_metadata.transform_to_document(layer).transform_point2(local_position),
 			layer,
 			id: *point,
 			manipulator_angle,
@@ -589,7 +589,7 @@ fn get_selection_status(document: &Document, shape_state: &mut ShapeState) -> Se
 	// Check to see if multiple manipulator groups are selected
 	if total_selected_points > 1 {
 		return SelectionStatus::Multiple(MultipleSelectedPoints {
-			manipulator_angle: shape_state.selected_manipulator_angles(document),
+			manipulator_angle: shape_state.selected_manipulator_angles(document_network),
 		});
 	}
 

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

@@ -3,12 +3,12 @@ use crate::consts::LINE_ROTATE_SNAP_ANGLE;
 use crate::messages::portfolio::document::node_graph::VectorDataModification;
 use crate::messages::portfolio::document::overlays::utility_functions::path_overlays;
 use crate::messages::portfolio::document::overlays::utility_types::OverlayContext;
+use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::tool::common_functionality::color_selector::{ToolColorOptions, ToolColorType};
 use crate::messages::tool::common_functionality::graph_modification_utils;
 use crate::messages::tool::common_functionality::graph_modification_utils::get_subpaths;
 use crate::messages::tool::common_functionality::snapping::SnapManager;
 
-use document_legacy::document_metadata::LayerNodeIdentifier;
 use graphene_core::uuid::{generate_uuid, ManipulatorGroupId};
 use graphene_core::vector::style::{Fill, Stroke};
 use graphene_core::vector::{ManipulatorPointId, SelectedType};
@@ -217,7 +217,7 @@ impl PenToolData {
 		self.subpath_index = subpath_index;
 
 		// Stop the handles on the first point from mirroring
-		let Some(subpaths) = get_subpaths(layer, &document.document_legacy) else {
+		let Some(subpaths) = get_subpaths(layer, &document.network) else {
 			return;
 		};
 		let manipulator_groups = subpaths[subpath_index].manipulator_groups();
@@ -277,7 +277,7 @@ impl PenToolData {
 	fn check_break(&mut self, document: &DocumentMessageHandler, transform: DAffine2, responses: &mut VecDeque<Message>) -> Option<()> {
 		// Get subpath
 		let layer = self.layer?;
-		let subpath = &get_subpaths(layer, &document.document_legacy)?[self.subpath_index];
+		let subpath = &get_subpaths(layer, &document.network)?[self.subpath_index];
 
 		// Get the last manipulator group and the one previous to that
 		let mut manipulator_groups = subpath.manipulator_groups().iter();
@@ -323,7 +323,7 @@ impl PenToolData {
 	fn finish_placing_handle(&mut self, document: &DocumentMessageHandler, transform: DAffine2, responses: &mut VecDeque<Message>) -> Option<PenToolFsmState> {
 		// Get subpath
 		let layer = self.layer?;
-		let subpath = &get_subpaths(layer, &document.document_legacy)?[self.subpath_index];
+		let subpath = &get_subpaths(layer, &document.network)?[self.subpath_index];
 
 		// Get the last manipulator group and the one previous to that
 		let mut manipulator_groups = subpath.manipulator_groups().iter();
@@ -395,7 +395,7 @@ impl PenToolData {
 
 	fn drag_handle(&mut self, document: &DocumentMessageHandler, transform: DAffine2, mouse: DVec2, modifiers: ModifierState, responses: &mut VecDeque<Message>) -> Option<PenToolFsmState> {
 		// Get subpath
-		let subpath = &get_subpaths(self.layer?, &document.document_legacy)?[self.subpath_index];
+		let subpath = &get_subpaths(self.layer?, &document.network)?[self.subpath_index];
 
 		// Get the last manipulator group
 		let manipulator_groups = subpath.manipulator_groups();
@@ -448,7 +448,7 @@ impl PenToolData {
 	fn place_anchor(&mut self, document: &DocumentMessageHandler, transform: DAffine2, mouse: DVec2, modifiers: ModifierState, responses: &mut VecDeque<Message>) -> Option<PenToolFsmState> {
 		// Get subpath
 		let layer = self.layer?;
-		let subpath = &get_subpaths(layer, &document.document_legacy)?[self.subpath_index];
+		let subpath = &get_subpaths(layer, &document.network)?[self.subpath_index];
 
 		// Get the last manipulator group and the one previous to that
 		let mut manipulator_groups = subpath.manipulator_groups().iter();
@@ -492,7 +492,7 @@ impl PenToolData {
 
 	fn finish_transaction(&mut self, fsm: PenToolFsmState, document: &DocumentMessageHandler, responses: &mut VecDeque<Message>) -> Option<DocumentMessage> {
 		// Get subpath
-		let subpath = &get_subpaths(self.layer?, &document.document_legacy)?[self.subpath_index];
+		let subpath = &get_subpaths(self.layer?, &document.network)?[self.subpath_index];
 
 		// Abort if only one manipulator group has been placed
 		if fsm == PenToolFsmState::PlacingAnchor && subpath.len() < 3 {
@@ -724,7 +724,7 @@ fn should_extend(document: &DocumentMessageHandler, pos: DVec2, tolerance: f64)
 	for layer in document.metadata().selected_layers() {
 		let viewspace = document.metadata().transform_to_viewport(layer);
 
-		let subpaths = get_subpaths(layer, &document.document_legacy)?;
+		let subpaths = get_subpaths(layer, &document.network)?;
 		for (subpath_index, subpath) in subpaths.iter().enumerate() {
 			if subpath.closed() {
 				continue;

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

@@ -4,6 +4,7 @@ use super::tool_prelude::*;
 use crate::consts::{ROTATE_SNAP_ANGLE, SELECTION_TOLERANCE};
 use crate::messages::input_mapper::utility_types::input_mouse::ViewportPosition;
 use crate::messages::portfolio::document::overlays::utility_types::OverlayContext;
+use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::portfolio::document::utility_types::misc::{AlignAggregate, AlignAxis, FlipAxis};
 use crate::messages::portfolio::document::utility_types::transformation::Selected;
 use crate::messages::tool::common_functionality::graph_modification_utils::is_layer_fed_by_node_of_name;
@@ -11,8 +12,7 @@ use crate::messages::tool::common_functionality::pivot::Pivot;
 use crate::messages::tool::common_functionality::snapping::{self, SnapManager};
 use crate::messages::tool::common_functionality::transformation_cage::*;
 
-use document_legacy::document::Document;
-use document_legacy::document_metadata::LayerNodeIdentifier;
+use graph_craft::document::NodeNetwork;
 use graphene_core::renderer::Quad;
 
 use std::fmt;
@@ -394,22 +394,21 @@ impl Fsm for SelectToolFsmState {
 				tool_data.selected_layers_count = selected_layers_count;
 
 				// Outline selected layers
-				for layer in document.document_legacy.selected_visible_layers() {
+				for layer in document.selected_visible_layers() {
 					overlay_context.outline(document.metadata().layer_outline(layer), document.metadata().transform_to_viewport(layer));
 				}
 
 				// Get the layer the user is hovering over
-				let click = document.document_legacy.click(input.mouse.position, &document.document_legacy.document_network);
+				let click = document.click(input.mouse.position, &document.network);
 				let not_selected_click = click.filter(|&hovered_layer| !document.metadata().selected_layers_contains(hovered_layer));
 				if let Some(layer) = not_selected_click {
 					overlay_context.outline(document.metadata().layer_outline(layer), document.metadata().transform_to_viewport(layer));
 				}
 
 				// Update bounds
-				let transform = document.document_legacy.selected_visible_layers().next().map(|layer| document.metadata().transform_to_viewport(layer));
+				let transform = document.selected_visible_layers().next().map(|layer| document.metadata().transform_to_viewport(layer));
 				let transform = transform.unwrap_or(DAffine2::IDENTITY);
 				let bounds = document
-					.document_legacy
 					.selected_visible_layers()
 					.filter_map(|layer| {
 						document
@@ -440,10 +439,10 @@ impl Fsm for SelectToolFsmState {
 			}
 			(_, SelectToolMessage::EditLayer) => {
 				// Edit the clicked layer
-				if let Some(intersect) = document.document_legacy.click(input.mouse.position, &document.document_legacy.document_network) {
+				if let Some(intersect) = document.click(input.mouse.position, &document.network) {
 					match tool_data.nested_selection_behavior {
 						NestedSelectionBehavior::Shallowest => edit_layer_shallowest_manipulation(document, intersect, responses),
-						NestedSelectionBehavior::Deepest => edit_layer_deepest_manipulation(intersect, &document.document_legacy, responses),
+						NestedSelectionBehavior::Deepest => edit_layer_deepest_manipulation(intersect, &document.network, responses),
 					}
 				}
 
@@ -471,8 +470,8 @@ impl Fsm for SelectToolFsmState {
 					.map(|bounding_box| bounding_box.check_rotate(input.mouse.position))
 					.unwrap_or_default();
 
-				let mut selected: Vec<_> = document.document_legacy.selected_visible_layers().collect();
-				let intersection = document.document_legacy.click(input.mouse.position, &document.document_legacy.document_network);
+				let mut selected: Vec<_> = document.selected_visible_layers().collect();
+				let intersection = document.click(input.mouse.position, &document.network);
 
 				// If the user is dragging the bounding box bounds, go into ResizingBounds mode.
 				// If the user is dragging the rotate trigger, go into RotatingBounds mode.
@@ -502,16 +501,16 @@ impl Fsm for SelectToolFsmState {
 					tool_data.layers_dragging = selected;
 
 					if let Some(bounds) = &mut tool_data.bounding_box_manager {
-						let document = &document.document_legacy;
 						bounds.original_bound_transform = bounds.transform;
 
-						tool_data.layers_dragging.retain(|layer| document.document_network.nodes.contains_key(&layer.to_node()));
+						tool_data.layers_dragging.retain(|layer| document.network.nodes.contains_key(&layer.to_node()));
 						let mut selected = Selected::new(
 							&mut bounds.original_transforms,
 							&mut bounds.center_of_transformation,
 							&tool_data.layers_dragging,
 							responses,
-							document,
+							&document.network,
+							&document.metadata,
 							None,
 							&ToolType::Select,
 						);
@@ -529,7 +528,8 @@ impl Fsm for SelectToolFsmState {
 							&mut bounds.center_of_transformation,
 							&selected,
 							responses,
-							&document.document_legacy,
+							&document.network,
+							&document.metadata,
 							None,
 							&ToolType::Select,
 						);
@@ -639,7 +639,16 @@ impl Fsm for SelectToolFsmState {
 
 						tool_data.layers_dragging.retain(|layer| document.network().nodes.contains_key(&layer.to_node()));
 						let selected = &tool_data.layers_dragging;
-						let mut selected = Selected::new(&mut bounds.original_transforms, &mut pivot, selected, responses, &document.document_legacy, None, &ToolType::Select);
+						let mut selected = Selected::new(
+							&mut bounds.original_transforms,
+							&mut pivot,
+							selected,
+							responses,
+							&document.network,
+							&document.metadata,
+							None,
+							&ToolType::Select,
+						);
 
 						selected.apply_transformation(bounds.original_bound_transform * transformation * bounds.original_bound_transform.inverse());
 					}
@@ -670,7 +679,8 @@ impl Fsm for SelectToolFsmState {
 						&mut bounds.center_of_transformation,
 						&tool_data.layers_dragging,
 						responses,
-						&document.document_legacy,
+						&document.network,
+						&document.metadata,
 						None,
 						&ToolType::Select,
 					);
@@ -725,7 +735,7 @@ impl Fsm for SelectToolFsmState {
 				// Deselect layer if not snap dragging
 				if !tool_data.has_dragged && input.keyboard.key(remove_from_selection) && tool_data.layer_selected_on_start.is_none() {
 					let quad = tool_data.selection_quad();
-					let intersection = document.document_legacy.intersect_quad(quad, &document.document_legacy.document_network);
+					let intersection = document.intersect_quad(quad, &document.network);
 
 					if let Some(path) = intersection.last() {
 						let replacement_selected_layers: Vec<_> = document.metadata().selected_layers().filter(|&layer| !path.starts_with(layer, document.metadata())).collect();
@@ -795,7 +805,7 @@ impl Fsm for SelectToolFsmState {
 			}
 			(SelectToolFsmState::DrawingBox, SelectToolMessage::DragStop { .. } | SelectToolMessage::Enter) => {
 				let quad = tool_data.selection_quad();
-				let new_selected: HashSet<_> = document.document_legacy.intersect_quad(quad, &document.document_legacy.document_network).collect();
+				let new_selected: HashSet<_> = document.intersect_quad(quad, &document.network).collect();
 				let current_selected: HashSet<_> = document.metadata().selected_layers().collect();
 				if new_selected != current_selected {
 					tool_data.layers_dragging = new_selected.into_iter().collect();
@@ -813,7 +823,7 @@ impl Fsm for SelectToolFsmState {
 
 				if let Some(layer) = selected_layers.next() {
 					// Check that only one layer is selected
-					if selected_layers.next().is_none() && is_layer_fed_by_node_of_name(layer, &document.document_legacy, "Text") {
+					if selected_layers.next().is_none() && is_layer_fed_by_node_of_name(layer, &document.network, "Text") {
 						responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Text });
 						responses.add(TextToolMessage::EditSelected);
 					}
@@ -836,7 +846,8 @@ impl Fsm for SelectToolFsmState {
 						&mut bounding_box_overlays.opposite_pivot,
 						&tool_data.layers_dragging,
 						responses,
-						&document.document_legacy,
+						&document.network,
+						&document.metadata,
 						None,
 						&ToolType::Select,
 					);
@@ -951,11 +962,11 @@ fn edit_layer_shallowest_manipulation(document: &DocumentMessageHandler, layer:
 	responses.add(NodeGraphMessage::SelectedNodesSet { nodes: vec![new_selected.to_node()] });
 }
 
-fn edit_layer_deepest_manipulation(layer: LayerNodeIdentifier, document: &Document, responses: &mut VecDeque<Message>) {
-	if is_layer_fed_by_node_of_name(layer, document, "Text") {
+fn edit_layer_deepest_manipulation(layer: LayerNodeIdentifier, document_network: &NodeNetwork, responses: &mut VecDeque<Message>) {
+	if is_layer_fed_by_node_of_name(layer, document_network, "Text") {
 		responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Text });
 		responses.add(TextToolMessage::EditSelected);
-	} else if is_layer_fed_by_node_of_name(layer, document, "Shape") {
+	} else if is_layer_fed_by_node_of_name(layer, document_network, "Shape") {
 		responses.add_front(ToolMessage::ActivateTool { tool_type: ToolType::Path });
 	}
 }

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

@@ -1,11 +1,11 @@
 use super::tool_prelude::*;
 use crate::consts::DRAG_THRESHOLD;
 use crate::messages::portfolio::document::node_graph::VectorDataModification;
+use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::tool::common_functionality::color_selector::{ToolColorOptions, ToolColorType};
 use crate::messages::tool::common_functionality::graph_modification_utils;
 use crate::messages::tool::common_functionality::snapping::SnapManager;
 
-use document_legacy::document_metadata::LayerNodeIdentifier;
 use graphene_core::uuid::generate_uuid;
 use graphene_core::vector::style::{Fill, Stroke};
 use graphene_core::Color;

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

@@ -3,10 +3,10 @@
 use super::tool_prelude::*;
 use crate::application::generate_uuid;
 use crate::messages::portfolio::document::overlays::utility_types::OverlayContext;
+use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::tool::common_functionality::color_selector::{ToolColorOptions, ToolColorType};
 use crate::messages::tool::common_functionality::graph_modification_utils::{self, is_layer_fed_by_node_of_name};
 
-use document_legacy::document_metadata::LayerNodeIdentifier;
 use graph_craft::document::value::TaggedValue;
 use graphene_core::renderer::Quad;
 use graphene_core::text::{load_face, Font, FontCache};
@@ -225,7 +225,7 @@ struct TextToolData {
 impl TextToolData {
 	/// Set the editing state of the currently modifying layer
 	fn set_editing(&self, editable: bool, font_cache: &FontCache, document: &DocumentMessageHandler, responses: &mut VecDeque<Message>) {
-		if let Some(node_id) = graph_modification_utils::get_fill_id(self.layer, &document.document_legacy) {
+		if let Some(node_id) = graph_modification_utils::get_fill_id(self.layer, &document.network) {
 			responses.add(NodeGraphMessage::SetHidden { node_id, hidden: editable });
 		}
 
@@ -245,8 +245,8 @@ impl TextToolData {
 
 	fn load_layer_text_node(&mut self, document: &DocumentMessageHandler) -> Option<()> {
 		let transform = document.metadata().transform_to_viewport(self.layer);
-		let color = graph_modification_utils::get_fill_color(self.layer, &document.document_legacy).unwrap_or(Color::BLACK);
-		let (text, font, font_size) = graph_modification_utils::get_text(self.layer, &document.document_legacy)?;
+		let color = graph_modification_utils::get_fill_color(self.layer, &document.network).unwrap_or(Color::BLACK);
+		let (text, font, font_size) = graph_modification_utils::get_text(self.layer, &document.network)?;
 		self.editing_text = Some(EditingText {
 			text: text.clone(),
 			font: font.clone(),
@@ -276,9 +276,8 @@ impl TextToolData {
 	fn interact(&mut self, state: TextToolFsmState, mouse: DVec2, document: &DocumentMessageHandler, font_cache: &FontCache, responses: &mut VecDeque<Message>) -> TextToolFsmState {
 		// Check if the user has selected an existing text layer
 		if let Some(clicked_text_layer_path) = document
-			.document_legacy
 			.click(mouse, document.network())
-			.filter(|&layer| is_layer_fed_by_node_of_name(layer, &document.document_legacy, "Text"))
+			.filter(|&layer| is_layer_fed_by_node_of_name(layer, &document.network, "Text"))
 		{
 			self.start_editing_layer(clicked_text_layer_path, state, document, font_cache, responses);
 
@@ -350,7 +349,7 @@ fn can_edit_selected(document: &DocumentMessageHandler) -> Option<LayerNodeIdent
 		return None;
 	}
 
-	if !is_layer_fed_by_node_of_name(layer, &document.document_legacy, "Text") {
+	if !is_layer_fed_by_node_of_name(layer, &document.network, "Text") {
 		return None;
 	}
 
@@ -391,7 +390,7 @@ impl Fsm for TextToolFsmState {
 			}
 			(_, TextToolMessage::Overlays(mut overlay_context)) => {
 				for layer in document.metadata().selected_layers() {
-					let Some((text, font, font_size)) = graph_modification_utils::get_text(layer, &document.document_legacy) else {
+					let Some((text, font, font_size)) = graph_modification_utils::get_text(layer, &document.network) else {
 						continue;
 					};
 					let buzz_face = font_cache.get(font).map(|data| load_face(data));
@@ -439,7 +438,7 @@ impl Fsm for TextToolFsmState {
 				tool_data.fix_text_bounds(&new_text, document, font_cache, responses);
 				responses.add(NodeGraphMessage::SetQualifiedInputValue {
 					layer_path: Vec::new(),
-					node_path: vec![graph_modification_utils::get_text_id(tool_data.layer, &document.document_legacy).unwrap()],
+					node_path: vec![graph_modification_utils::get_text_id(tool_data.layer, &document.network).unwrap()],
 					input_index: 1,
 					value: TaggedValue::String(new_text),
 				});