Respect smooth property and allow it to be editable (#395)

* Respect smooth property and allow it to be editable

* Update lock file

src/tool_behaviors/move_handle.rs

@@ -4,6 +4,7 @@ pub use crate::user_interface::follow::Follow;
 use glifparser::PointData;
 use glifparser::glif::contour::MFEKContourCommon;
 use glifparser::glif::point::MFEKPointCommon;
+use MFEKmath::polar::PolarCoordinates;
 
 #[derive(Clone, Debug)]
 pub struct MoveHandle {
@@ -54,12 +55,21 @@ impl MoveHandle {
             // Difference in x, difference in y
             let (dx, dy) = (cx - x, cy - y);
 
-            let follow = if self.creating {
+            let mut follow = if self.creating {
                 Follow::Mirror
             } else {
                 Follow::from(self.mouse_info)
             };
 
+            if point.get_smooth() == Some(true) {
+                // Follow::Mirror breaks smoothness
+                follow = Follow::ForceLine;
+            }
+
+            if point.get_handle(self.wh.opposite()).unwrap() == Handle::Colocated && follow == Follow::ForceLine {
+                // If the opposite handle is colocated, force line crashes due to unwrapping a None value.
+                follow = Follow::No;
+            }
             match self.wh {
                 WhichHandle::A | WhichHandle::B => {
                     point.set_handle(self.wh, Handle::At(x, y));
@@ -94,21 +104,13 @@ impl MoveHandle {
         }
     }
 
-    fn force_line<PD: PointData>(&mut self, _point: &mut dyn MFEKPointCommon<PD>) {
-        // TODO: Fix this? I have zero clue why this errors. It's forcing point to `static.
-        /*let (r, _) = point.polar(self.wh.opposite());
+    fn force_line<PD: PointData>(&self, mut point: &mut dyn MFEKPointCommon<PD>) {
+        let (r, _) = point.polar(self.wh.opposite());
         let (_, theta) = point.polar(self.wh);
         match point.get_handle(self.wh.opposite()).unwrap() {
             Handle::At(..) => point.set_polar(self.wh.opposite(), (r, theta.to_degrees())),
-            Handle::Colocated => {
-                if !self.warned_force_line {
-                    log::warn!(
-                        "Makes no sense to force line when opposite handle is colocated, ignoring"
-                    );
-                }
-                self.warned_force_line = true;
-            }
-        }*/
+            Handle::Colocated => unreachable!("Force line is nonsensical when the opposite handle is colocated")
+        }
     }
 }
 

src/user_interface/gui/windows/inspection_window.rs

@@ -8,9 +8,10 @@ use crate::{
 use egui::Context;
 use glifparser::{
     glif::{contour::MFEKContourCommon, inner::MFEKContourInnerType, point::MFEKPointCommon},
-    Handle, PointData, WhichHandle,
+    Contour, Handle, MFEKPointData, PointData, WhichHandle,
 };
 use MFEKmath::mfek::ResolveCubic;
+use MFEKmath::polar::PolarCoordinates;
 
 use super::egui_parsed_textfield;
 
@@ -50,7 +51,7 @@ impl GlifWindow for InspectionWindow {
             .show(ctx, |ui| {
                 if let Some((ci, pi)) = v.selected_point() {
                     let mut contour = v.get_active_layer_ref().outline[ci].clone();
-                    let point = contour
+                    let mut point = contour
                         .get_point_mut(pi)
                         .expect("Editor should have valid selection!");
                     // do contour stuff
@@ -114,7 +115,34 @@ impl GlifWindow for InspectionWindow {
                             egui_parsed_textfield(ui, "px", point.x(), &mut self.edit_buf),
                             egui_parsed_textfield(ui, "py", point.y(), &mut self.edit_buf),
                         );
-
+                        if let Some(smooth) = point.get_smooth() {
+                            let mut checked = smooth;
+                            let smooth_can_be_enabled = point.get_handle(WhichHandle::A).unwrap()
+                                != Handle::Colocated
+                                && point.get_handle(WhichHandle::B).unwrap() != Handle::Colocated;
+                            ui.add_enabled_ui(smooth_can_be_enabled, |ui| {
+                                ui.checkbox(&mut checked, "Smooth").
+                                    on_disabled_hover_text("Cannot enable smoothness if one of the off curve handles is colocated with the point")
+                            });
+                            if smooth != checked {
+                                point.set_smooth(checked);
+                                // If smooth was enabled just now, we need to ensure the curve is actually smooth.
+                                if checked {
+                                    // Force curve points into a line to make the curve smooth
+                                    let wh = WhichHandle::A;
+                                    let (r, _) = point.polar(wh.opposite());
+                                    let (_, theta) = point.polar(wh);
+                                    match point.get_handle(wh.opposite()).expect("Both handles should exist") {
+                                        Handle::At(..) => point.set_polar(wh.opposite(), (r, theta.to_degrees())),
+                                        Handle::Colocated => unreachable!("Handles not being colocated is required to reach this clause")
+                                    }
+                                }
+                            }
+                            // If either handle is colocated, smooth *must* be disabled
+                            if !smooth_can_be_enabled {
+                                point.set_smooth(false);
+                            }
+                        }
                         ui.collapsing("Handles", |ui| {
                             if point.has_handle(WhichHandle::A) {
                                 ui.label("Handle A:");
@@ -222,6 +250,10 @@ impl GlifWindow for InspectionWindow {
                                 mutated_point.set_name(name);
                             }
 
+                            if let Some(smooth) = point.get_smooth() {
+                                mutated_point.set_smooth(smooth);
+                            }
+
                             v.end_modification();
                         }
                     });
@@ -240,6 +272,7 @@ fn point_equivalent<PD: PointData>(
         && a.get_position() == b.get_position()
         && a.get_handle_position(WhichHandle::A) == b.get_handle_position(WhichHandle::A)
         && a.get_handle_position(WhichHandle::B) == b.get_handle_position(WhichHandle::B)
+        && a.get_smooth() == b.get_smooth()
 }
 
 /*