Add a movable canvas with matricies (#175)

* Convert polygon and rectangle tool to kurbo::BezPath

* Add glam

* Add affine transform to elipse and remove circle

* Format

* Add svg group and add matrix for group

* Convert all operations to use matricies

* Work uses same transform as root

* Format

* Frontend fixed to render changes to working colors when changed from backend (#180)

* Backend and Frontend modification to show working color mods

* Remove comments & change precedence for tool and doc actions

* Add keybind for resetting work colors

* Minor Frontend changes

* Remove early sample "greet" code

* Add a contributing section to the project README

* Add moving document around

* Add document transform for tools

* Update to GraphiteEditor's fork

* Use write in foreach for rendering group / folder

* Add missing TranslateDown action

* Use points for line operation

* Format

* Add todo to change to shape's aspect ratio

* Remove empty if

* Initial pass at refactor

* Fix polyline test

* Use document message to modify document transform

* Messages -> Operations

* Transform layer

* Format

* Use DAffine2::IDENTITY

* Clean up kurbo generation for line and rect

* Use .into for rectangle points

* Rename cols to transform

* Rename other cols to transform

* Add todo for into_iter

* Remove unnecessary clone

Co-authored-by: akshay1992kalbhor <akshay1992kalbhor@gmail.com>
Co-authored-by: Keavon Chambers <keavon@keavon.com>

core/document/src/layers/polyline.rs

@@ -1,48 +1,56 @@
-use super::style;
-use super::LayerData;
-
 use std::fmt::Write;
 
+use super::{style, LayerData};
+
 #[derive(Debug, Clone, PartialEq)]
 pub struct PolyLine {
-	points: Vec<kurbo::Point>,
-	style: style::PathStyle,
+	points: Vec<glam::DVec2>,
 }
 
 impl PolyLine {
-	pub fn new(points: Vec<impl Into<kurbo::Point>>, style: style::PathStyle) -> PolyLine {
+	pub fn new(points: Vec<impl Into<glam::DVec2>>) -> PolyLine {
 		PolyLine {
 			points: points.into_iter().map(|it| it.into()).collect(),
-			style,
 		}
 	}
 }
 
 impl LayerData for PolyLine {
-	fn render(&mut self, svg: &mut String) {
+	fn to_kurbo_path(&mut self, transform: glam::DAffine2, _style: style::PathStyle) -> kurbo::BezPath {
+		let mut path = kurbo::BezPath::new();
+		self.points
+			.iter()
+			.map(|v| transform.transform_point2(*v))
+			.map(|v| kurbo::Point { x: v.x, y: v.y })
+			.enumerate()
+			.for_each(|(i, p)| if i == 0 { path.move_to(p) } else { path.line_to(p) });
+		path
+	}
+	fn render(&mut self, svg: &mut String, transform: glam::DAffine2, style: style::PathStyle) {
 		if self.points.is_empty() {
 			return;
 		}
 		let _ = write!(svg, r#"<polyline points=""#);
-		let mut points = self.points.iter();
+		let mut points = self.points.iter().map(|v| transform.transform_point2(*v));
 		let first = points.next().unwrap();
 		let _ = write!(svg, "{:.3} {:.3}", first.x, first.y);
 		for point in points {
 			let _ = write!(svg, " {:.3} {:.3}", point.x, point.y);
 		}
-		let _ = write!(svg, r#""{} />"#, self.style.render());
+		let _ = write!(svg, r#""{} />"#, style.render());
 	}
 }
 
 #[cfg(test)]
 #[test]
 fn polyline_should_render() {
+	use super::style::PathStyle;
+	use glam::DVec2;
 	let mut polyline = PolyLine {
-		points: vec![kurbo::Point::new(3.0, 4.12354), kurbo::Point::new(1.0, 5.54)],
-		style: style::PathStyle::new(Some(style::Stroke::new(crate::color::Color::GREEN, 0.4)), None),
+		points: vec![DVec2::new(3.0, 4.12354), DVec2::new(1.0, 5.54)],
 	};
 
 	let mut svg = String::new();
-	polyline.render(&mut svg);
-	assert_eq!(r##"<polyline points="3.000 4.124 1.000 5.540" stroke="#00FF00" stroke-width="0.4" />"##, svg);
+	polyline.render(&mut svg, glam::DAffine2::IDENTITY, PathStyle::default());
+	assert_eq!(r##"<polyline points="3.000 4.124 1.000 5.540" />"##, svg);
 }