Remove dead code from document-legacy

document-legacy/src/document.rs

@@ -1,4 +1,3 @@
-use crate::boolean_ops::composite_boolean_operation;
 use crate::intersection::Quad;
 use crate::layers::folder_layer::FolderLayer;
 use crate::layers::layer_info::{Layer, LayerData, LayerDataType, LayerDataTypeDiscriminant};
@@ -9,7 +8,6 @@ use crate::{DocumentError, DocumentResponse, Operation};
 
 use glam::{DAffine2, DVec2};
 use serde::{Deserialize, Serialize};
-use std::cell::RefCell;
 use std::cmp::max;
 use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
@@ -155,25 +153,6 @@ impl Document {
 		self.folder_mut(path)?.layer_mut(id).ok_or_else(|| DocumentError::LayerNotFound(path.into()))
 	}
 
-	/// Returns vector `Shape`s for each specified in `paths`.
-	/// If any path is not a shape, or does not exist, `DocumentError::InvalidPath` is returned.
-	fn transformed_shapes(&self, paths: &[Vec<LayerId>]) -> Result<Vec<ShapeLayer>, DocumentError> {
-		let mut shapes: Vec<ShapeLayer> = Vec::new();
-		let undo_viewport = self.root.transform.inverse();
-		for path in paths {
-			match (self.multiply_transforms(path), &self.layer(path)?.data) {
-				(Ok(shape_transform), LayerDataType::Shape(shape)) => {
-					let mut new_shape = shape.clone();
-					new_shape.shape.apply_affine(undo_viewport * shape_transform);
-					shapes.push(new_shape);
-				}
-				(Ok(_), _) => return Err(DocumentError::InvalidPath),
-				(Err(err), _) => return Err(err),
-			}
-		}
-		Ok(shapes)
-	}
-
 	pub fn common_layer_path_prefix<'a>(&self, layers: impl Iterator<Item = &'a [LayerId]>) -> &'a [LayerId] {
 		layers.reduce(|a, b| &a[..a.iter().zip(b.iter()).take_while(|&(a, b)| a == b).count()]).unwrap_or_default()
 	}
@@ -487,7 +466,7 @@ impl Document {
 
 	/// Mutate the document by applying the `operation` to it. If the operation necessitates a
 	/// reaction from the frontend, responses may be returned.
-	pub fn handle_operation(&mut self, operation: Operation, render_data: &RenderData) -> Result<Option<Vec<DocumentResponse>>, DocumentError> {
+	pub fn handle_operation(&mut self, operation: Operation) -> Result<Option<Vec<DocumentResponse>>, DocumentError> {
 		use DocumentResponse::*;
 
 		operation.pseudo_hash().hash(&mut self.state_identifier);
@@ -532,19 +511,6 @@ impl Document {
 				}
 				Some(vec![LayerChanged { path: layer_path.clone() }])
 			}
-			Operation::AddNgon {
-				path,
-				insert_index,
-				transform,
-				style,
-				sides,
-			} => {
-				let layer = Layer::new(LayerDataType::Shape(ShapeLayer::ngon(sides, style)), transform);
-
-				self.set_layer(&path, layer, insert_index)?;
-
-				Some([vec![DocumentChanged, CreatedLayer { path: path.clone() }], update_thumbnails_upstream(&path)].concat())
-			}
 			Operation::AddShape {
 				path,
 				transform,
@@ -567,33 +533,6 @@ impl Document {
 				self.set_layer(&path, Layer::new(LayerDataType::Shape(ShapeLayer::poly_line(points, style)), transform), insert_index)?;
 				Some([vec![DocumentChanged, CreatedLayer { path: path.clone() }], update_thumbnails_upstream(&path)].concat())
 			}
-			Operation::BooleanOperation { operation, selected } => {
-				let mut responses = Vec::new();
-				if selected.len() > 1 {
-					let new_shapes = composite_boolean_operation(operation, &mut self.transformed_shapes(&selected)?.into_iter().rev().map(RefCell::new).collect())?;
-
-					for path in selected {
-						self.delete(&path)?;
-						responses.push(DocumentResponse::DeletedLayer { path })
-					}
-					for new_shape in new_shapes {
-						let new_id = self.add_layer(&[], Layer::new(LayerDataType::Shape(new_shape), DAffine2::IDENTITY.to_cols_array()), -1)?;
-						responses.push(DocumentResponse::CreatedLayer { path: vec![new_id] })
-					}
-				}
-				Some([vec![DocumentChanged, DocumentResponse::FolderChanged { path: vec![] }], responses].concat())
-			}
-			Operation::AddSpline {
-				path,
-				insert_index,
-				points,
-				transform,
-				style,
-			} => {
-				let points: Vec<glam::DVec2> = points.iter().map(|&it| it.into()).collect();
-				self.set_layer(&path, Layer::new(LayerDataType::Shape(ShapeLayer::spline(points, style)), transform), insert_index)?;
-				Some([vec![DocumentChanged, CreatedLayer { path: path.clone() }], update_thumbnails_upstream(&path)].concat())
-			}
 			Operation::DeleteLayer { path } => {
 				fn aggregate_deletions(folder: &FolderLayer, path: &mut Vec<LayerId>, responses: &mut Vec<DocumentResponse>) {
 					for (id, layer) in folder.layer_ids.iter().zip(folder.layers()) {
@@ -742,83 +681,6 @@ impl Document {
 				}
 				Some(Vec::new())
 			}
-			Operation::InsertManipulatorGroup {
-				layer_path,
-				manipulator_group,
-				after_id,
-			} => {
-				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_subpath_mut()) {
-					shape.manipulator_groups_mut().insert(manipulator_group, after_id);
-					self.mark_as_dirty(&layer_path)?;
-				}
-				Some([update_thumbnails_upstream(&layer_path), vec![DocumentChanged, LayerChanged { path: layer_path }]].concat())
-			}
-			Operation::PushManipulatorGroup { layer_path, manipulator_group } => {
-				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_subpath_mut()) {
-					shape.manipulator_groups_mut().push(manipulator_group);
-					self.mark_as_dirty(&layer_path)?;
-				}
-				Some([update_thumbnails_upstream(&layer_path), vec![DocumentChanged, LayerChanged { path: layer_path }]].concat())
-			}
-			Operation::PushFrontManipulatorGroup { layer_path, manipulator_group } => {
-				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_subpath_mut()) {
-					shape.manipulator_groups_mut().push_front(manipulator_group);
-					self.mark_as_dirty(&layer_path)?;
-				}
-				Some([update_thumbnails_upstream(&layer_path), vec![DocumentChanged, LayerChanged { path: layer_path }]].concat())
-			}
-			Operation::RemoveManipulatorGroup { layer_path, id } => {
-				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_subpath_mut()) {
-					shape.manipulator_groups_mut().remove(id);
-					self.mark_as_dirty(&layer_path)?;
-				}
-				Some([update_thumbnails_upstream(&layer_path), vec![DocumentChanged, LayerChanged { path: layer_path }]].concat())
-			}
-			Operation::MoveManipulatorPoint {
-				layer_path,
-				id,
-				manipulator_type: control_type,
-				position,
-			} => {
-				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_subpath_mut()) {
-					if let Some(manipulator_group) = shape.manipulator_groups_mut().by_id_mut(id) {
-						manipulator_group.set_point_position(control_type as usize, position.into());
-						self.mark_as_dirty(&layer_path)?;
-					}
-				}
-				Some([update_thumbnails_upstream(&layer_path), vec![DocumentChanged, LayerChanged { path: layer_path }]].concat())
-			}
-			Operation::SetManipulatorPoints {
-				layer_path,
-				id,
-				manipulator_type,
-				position,
-			} => {
-				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_subpath_mut()) {
-					if let Some(manipulator_group) = shape.manipulator_groups_mut().by_id_mut(id) {
-						if let Some(position) = position {
-							manipulator_group.set_point_position(manipulator_type as usize, position.into());
-						} else {
-							manipulator_group.points[manipulator_type] = None;
-						}
-						self.mark_as_dirty(&layer_path)?;
-					}
-				}
-				Some([update_thumbnails_upstream(&layer_path), vec![DocumentChanged, LayerChanged { path: layer_path }]].concat())
-			}
-			Operation::RemoveManipulatorPoint {
-				layer_path,
-				id,
-				manipulator_type: control_type,
-			} => {
-				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_subpath_mut()) {
-					if let Some(manipulator_group) = shape.manipulator_groups_mut().by_id_mut(id) {
-						manipulator_group.points[control_type as usize] = None;
-						self.mark_as_dirty(&layer_path)?;
-					}
-				}
-				Some([update_thumbnails_upstream(&layer_path), vec![DocumentChanged, LayerChanged { path: layer_path }]].concat())
-			}
 			Operation::TransformLayerInScope { path, transform, scope } => {
 				let transform = DAffine2::from_cols_array(&transform);
 				let scope = DAffine2::from_cols_array(&scope);
@@ -833,17 +695,6 @@ impl Document {
 				self.mark_as_dirty(&path)?;
 				Some([vec![DocumentChanged], update_thumbnails_upstream(&path)].concat())
 			}
-			Operation::TransformLayerScaleAroundPivot { path, scale_factor } => {
-				let layer = self.layer_mut(&path)?;
-
-				let offset = DAffine2::from_translation(-layer.pivot);
-				let scale = DAffine2::from_scale(scale_factor.into());
-				let offset_back = DAffine2::from_translation(layer.pivot);
-				layer.transform = layer.transform * offset_back * scale * offset;
-
-				self.mark_as_dirty(&path)?;
-				Some([vec![DocumentChanged], update_thumbnails_upstream(&path)].concat())
-			}
 			Operation::SetLayerScaleAroundPivot { path, new_scale } => {
 				let layer = self.layer_mut(&path)?;
 
@@ -867,12 +718,6 @@ impl Document {
 				self.mark_as_dirty(&path)?;
 				Some([vec![DocumentChanged], update_thumbnails_upstream(&path)].concat())
 			}
-			Operation::ToggleLayerVisibility { path } => {
-				self.mark_as_dirty(&path)?;
-				let layer = self.layer_mut(&path)?;
-				layer.visible = !layer.visible;
-				Some([vec![DocumentChanged], update_thumbnails_upstream(&path)].concat())
-			}
 			Operation::SetLayerVisibility { path, visible } => {
 				self.mark_as_dirty(&path)?;
 				let layer = self.layer_mut(&path)?;
@@ -919,101 +764,6 @@ impl Document {
 				self.mark_as_dirty(&path)?;
 				Some([vec![DocumentChanged], update_thumbnails_upstream(&path)].concat())
 			}
-
-			// We may not want the concept of selection here. For now leaving though.
-			Operation::SelectManipulatorPoints { layer_path, point_ids, add } => {
-				let layer = self.layer_mut(&layer_path)?;
-				if let Some(shape) = layer.as_subpath_mut() {
-					if !add {
-						shape.clear_selected_manipulator_groups();
-					}
-					shape.select_points(&point_ids, true);
-				}
-				Some(vec![LayerChanged { path: layer_path.clone() }])
-			}
-			Operation::DeselectManipulatorPoints { layer_path, point_ids } => {
-				let layer = self.layer_mut(&layer_path)?;
-				if let Some(shape) = layer.as_subpath_mut() {
-					shape.select_points(&point_ids, false);
-				}
-				Some(vec![LayerChanged { path: layer_path.clone() }])
-			}
-			Operation::SelectAllAnchors { layer_path } => {
-				let layer = self.layer_mut(&layer_path)?;
-				if let Some(subpath) = layer.as_subpath_mut() {
-					subpath.select_all_anchors();
-				}
-				Some(vec![LayerChanged { path: layer_path.clone() }])
-			}
-			Operation::DeselectAllManipulatorPoints { layer_path } => {
-				let layer = self.layer_mut(&layer_path)?;
-				if let Some(shape) = layer.as_subpath_mut() {
-					shape.clear_selected_manipulator_groups();
-				}
-				Some(vec![LayerChanged { path: layer_path.clone() }])
-			}
-			Operation::DeleteSelectedManipulatorPoints { layer_paths } => {
-				let mut responses = vec![];
-				for layer_path in layer_paths {
-					let layer = self.layer_mut(&layer_path)?;
-					if let Some(shape) = layer.as_subpath_mut() {
-						// Delete the selected points.
-						shape.delete_selected();
-
-						// Delete the layer if there are no longer any manipulator groups
-						if (shape.manipulator_groups().len() - 1) == 0 {
-							// Delegate deletion to DeleteLayer to update Layer Tree in frontend
-							match self.handle_operation(Operation::DeleteLayer { path: layer_path.clone() }, render_data) {
-								Ok(Some(delete_responses)) => {
-									responses.extend(delete_responses);
-									responses.push(DocumentResponse::DeletedSelectedManipulatorPoints);
-									return Ok(Some(responses));
-								}
-								Err(e) => error!("DocumentError: {:?}", e),
-								Ok(_) => {}
-							}
-						}
-
-						// If we still have manipulator groups, update the layer and thumbnails
-						self.mark_as_dirty(&layer_path)?;
-						responses.push(DocumentChanged);
-						responses.push(LayerChanged { path: layer_path.clone() });
-						responses.append(&mut update_thumbnails_upstream(&layer_path));
-					}
-				}
-				Some(responses)
-			}
-			Operation::MoveSelectedManipulatorPoints { layer_path, delta, mirror_distance } => {
-				if let Ok(viewspace) = self.generate_transform_relative_to_viewport(&layer_path) {
-					let objectspace = &viewspace.inverse();
-					let delta = objectspace.transform_vector2(DVec2::new(delta.0, delta.1));
-					let layer = self.layer_mut(&layer_path)?;
-					if let Some(shape) = layer.as_subpath_mut() {
-						shape.move_selected(delta, mirror_distance);
-					}
-				}
-				self.mark_as_dirty(&layer_path)?;
-				Some([vec![DocumentChanged, LayerChanged { path: layer_path.clone() }], update_thumbnails_upstream(&layer_path)].concat())
-			}
-			Operation::SetManipulatorHandleMirroring { layer_path, id, mirror_angle } => {
-				if let Ok(Some(shape)) = self.layer_mut(&layer_path).map(|layer| layer.as_subpath_mut()) {
-					if let Some(manipulator_group) = shape.manipulator_groups_mut().by_id_mut(id) {
-						manipulator_group.editor_state.mirror_angle_between_handles = mirror_angle;
-						self.mark_as_dirty(&layer_path)?;
-					}
-				}
-				Some([update_thumbnails_upstream(&layer_path), vec![DocumentChanged, LayerChanged { path: layer_path }]].concat())
-			}
-			Operation::SetSelectedHandleMirroring { layer_path, toggle_angle } => {
-				let layer = self.layer_mut(&layer_path)?;
-				if let Some(shape) = layer.as_subpath_mut() {
-					for manipulator_group in shape.selected_manipulator_groups_any_points_mut() {
-						manipulator_group.toggle_mirroring(toggle_angle);
-					}
-				}
-				// This does nothing visually so we don't need to send any messages
-				None
-			}
 		};
 		Ok(responses)
 	}

document-legacy/src/error.rs

@@ -1,5 +1,4 @@
 use super::LayerId;
-use crate::boolean_ops::BooleanOperationError;
 
 /// A set of different errors that can occur when using this crate.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -13,11 +12,4 @@ pub enum DocumentError {
 	NotText,
 	NotNodeGraph,
 	InvalidFile(String),
-	BooleanOperationError(BooleanOperationError),
-}
-
-impl From<BooleanOperationError> for DocumentError {
-	fn from(err: BooleanOperationError) -> Self {
-		DocumentError::BooleanOperationError(err)
-	}
 }

document-legacy/src/operation.rs

@@ -1,12 +1,8 @@
-use crate::boolean_ops::BooleanOperation as BooleanOperationType;
 use crate::layers::blend_mode::BlendMode;
 use crate::layers::layer_info::Layer;
 use crate::layers::style::{self, Stroke};
 use crate::LayerId;
 
-use graphene_core::vector::SelectedType;
-use graphene_std::vector::consts::ManipulatorType;
-use graphene_std::vector::manipulator_group::ManipulatorGroup;
 use graphene_std::vector::subpath::Subpath;
 
 use serde::{Deserialize, Serialize};
@@ -18,24 +14,6 @@ use std::hash::{Hash, Hasher};
 // TODO: Rename all instances of `path` to `layer_path`
 /// Operations that can be performed to mutate the document.
 pub enum Operation {
-	AddEllipse {
-		path: Vec<LayerId>,
-		insert_index: isize,
-		transform: [f64; 6],
-		style: style::PathStyle,
-	},
-	AddRect {
-		path: Vec<LayerId>,
-		insert_index: isize,
-		transform: [f64; 6],
-		style: style::PathStyle,
-	},
-	AddLine {
-		path: Vec<LayerId>,
-		insert_index: isize,
-		transform: [f64; 6],
-		style: style::PathStyle,
-	},
 	AddFrame {
 		path: Vec<LayerId>,
 		insert_index: isize,
@@ -58,75 +36,12 @@ pub enum Operation {
 		layer_path: Vec<LayerId>,
 		pivot: (f64, f64),
 	},
-	AddPolyline {
-		path: Vec<LayerId>,
-		insert_index: isize,
-		transform: [f64; 6],
-		style: style::PathStyle,
-		points: Vec<(f64, f64)>,
-	},
-	AddSpline {
-		path: Vec<LayerId>,
-		insert_index: isize,
-		transform: [f64; 6],
-		style: style::PathStyle,
-		points: Vec<(f64, f64)>,
-	},
-	AddNgon {
-		path: Vec<LayerId>,
-		insert_index: isize,
-		transform: [f64; 6],
-		style: style::PathStyle,
-		sides: u32,
-	},
-	AddShape {
-		path: Vec<LayerId>,
-		insert_index: isize,
-		transform: [f64; 6],
-		style: style::PathStyle,
-		// TODO This will become a compound path once we support them.
-		subpath: Subpath,
-	},
-	BooleanOperation {
-		operation: BooleanOperationType,
-		selected: Vec<Vec<LayerId>>,
-	},
 	DeleteLayer {
 		path: Vec<LayerId>,
 	},
-	DeleteSelectedManipulatorPoints {
-		layer_paths: Vec<Vec<LayerId>>,
-	},
-	DeselectManipulatorPoints {
-		layer_path: Vec<LayerId>,
-		point_ids: Vec<(u64, ManipulatorType)>,
-	},
-	DeselectAllManipulatorPoints {
-		layer_path: Vec<LayerId>,
-	},
-	SelectAllAnchors {
-		layer_path: Vec<LayerId>,
-	},
 	DuplicateLayer {
 		path: Vec<LayerId>,
 	},
-	MoveSelectedManipulatorPoints {
-		layer_path: Vec<LayerId>,
-		delta: (f64, f64),
-		mirror_distance: bool,
-	},
-	MoveManipulatorPoint {
-		layer_path: Vec<LayerId>,
-		id: u64,
-		manipulator_type: SelectedType,
-		position: (f64, f64),
-	},
-	SetManipulatorPoints {
-		layer_path: Vec<LayerId>,
-		id: u64,
-		manipulator_type: ManipulatorType,
-		position: Option<(f64, f64)>,
-	},
 	RenameLayer {
 		layer_path: Vec<LayerId>,
 		new_name: String,
@@ -151,11 +66,6 @@ pub enum Operation {
 		path: Vec<LayerId>,
 		transform: [f64; 6],
 	},
-	SelectManipulatorPoints {
-		layer_path: Vec<LayerId>,
-		point_ids: Vec<(u64, ManipulatorType)>,
-		add: bool,
-	},
 	SetShapePath {
 		path: Vec<LayerId>,
 		subpath: Subpath,
@@ -164,28 +74,6 @@ pub enum Operation {
 		path: Vec<LayerId>,
 		vector_data: graphene_core::vector::VectorData,
 	},
-	InsertManipulatorGroup {
-		layer_path: Vec<LayerId>,
-		manipulator_group: ManipulatorGroup,
-		after_id: u64,
-	},
-	PushManipulatorGroup {
-		layer_path: Vec<LayerId>,
-		manipulator_group: ManipulatorGroup,
-	},
-	PushFrontManipulatorGroup {
-		layer_path: Vec<LayerId>,
-		manipulator_group: ManipulatorGroup,
-	},
-	RemoveManipulatorGroup {
-		layer_path: Vec<LayerId>,
-		id: u64,
-	},
-	RemoveManipulatorPoint {
-		layer_path: Vec<LayerId>,
-		id: u64,
-		manipulator_type: ManipulatorType,
-	},
 	TransformLayerInScope {
 		path: Vec<LayerId>,
 		transform: [f64; 6],
@@ -196,10 +84,6 @@ pub enum Operation {
 		transform: [f64; 6],
 		scope: [f64; 6],
 	},
-	TransformLayerScaleAroundPivot {
-		path: Vec<LayerId>,
-		scale_factor: (f64, f64),
-	},
 	SetLayerScaleAroundPivot {
 		path: Vec<LayerId>,
 		new_scale: (f64, f64),
@@ -208,9 +92,6 @@ pub enum Operation {
 		path: Vec<LayerId>,
 		transform: [f64; 6],
 	},
-	ToggleLayerVisibility {
-		path: Vec<LayerId>,
-	},
 	SetLayerVisibility {
 		path: Vec<LayerId>,
 		visible: bool,
@@ -231,10 +112,6 @@ pub enum Operation {
 		path: Vec<LayerId>,
 		opacity: f64,
 	},
-	SetLayerStyle {
-		path: Vec<LayerId>,
-		style: style::PathStyle,
-	},
 	SetLayerFill {
 		path: Vec<LayerId>,
 		fill: style::Fill,
@@ -243,14 +120,43 @@ pub enum Operation {
 		path: Vec<LayerId>,
 		stroke: Stroke,
 	},
-	SetManipulatorHandleMirroring {
-		layer_path: Vec<LayerId>,
-		id: u64,
-		mirror_angle: bool,
+
+	// The following are used only by the legacy overlays system
+	AddEllipse {
+		path: Vec<LayerId>,
+		insert_index: isize,
+		transform: [f64; 6],
+		style: style::PathStyle,
 	},
-	SetSelectedHandleMirroring {
-		layer_path: Vec<LayerId>,
-		toggle_angle: bool,
+	AddRect {
+		path: Vec<LayerId>,
+		insert_index: isize,
+		transform: [f64; 6],
+		style: style::PathStyle,
+	},
+	AddLine {
+		path: Vec<LayerId>,
+		insert_index: isize,
+		transform: [f64; 6],
+		style: style::PathStyle,
+	},
+	AddPolyline {
+		path: Vec<LayerId>,
+		insert_index: isize,
+		transform: [f64; 6],
+		style: style::PathStyle,
+		points: Vec<(f64, f64)>,
+	},
+	AddShape {
+		path: Vec<LayerId>,
+		insert_index: isize,
+		transform: [f64; 6],
+		style: style::PathStyle,
+		subpath: Subpath,
+	},
+	SetLayerStyle {
+		path: Vec<LayerId>,
+		style: style::PathStyle,
 	},
 }