|
|
@@ -1,5 +1,5 @@
|
|
|
use ezcad::pen::Pen;
|
|
|
-use log::trace;
|
|
|
+use log::debug;
|
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
|
@@ -15,34 +15,41 @@ pub struct Patch {
|
|
|
|
|
|
impl Patch {
|
|
|
fn patch(&self, id: usize, target: &mut Vec<Pen>) {
|
|
|
- trace!("Patching settings for pen #{}", id);
|
|
|
-
|
|
|
- let to_patch = target.get_mut(id).expect("Invalid pen index");
|
|
|
+ let to_patch: &mut Pen = target.get_mut(id).expect("Invalid pen index");
|
|
|
|
|
|
if let Some(color) = self.color {
|
|
|
+ debug!("Patching color for pen #{}: {:?}", id, color);
|
|
|
*to_patch.color = color.into()
|
|
|
}
|
|
|
|
|
|
if let Some(enabled) = self.enabled {
|
|
|
+ debug!("Patching enablement for pen #{}: {}", id, enabled);
|
|
|
*to_patch.disabled = !enabled as u32;
|
|
|
}
|
|
|
|
|
|
if let Some(loop_count) = self.loop_count {
|
|
|
+ debug!("Patching loop count for pen #{}: {}", id, loop_count);
|
|
|
*to_patch.loop_count = loop_count;
|
|
|
}
|
|
|
|
|
|
if let Some(speed) = self.speed {
|
|
|
+ debug!("Patching speed for pen #{}: {}", id, speed);
|
|
|
*to_patch.speed = speed;
|
|
|
}
|
|
|
|
|
|
if let Some(power) = self.power {
|
|
|
+ debug!("Patching power for pen #{}: {}", id, power);
|
|
|
*to_patch.power = power;
|
|
|
}
|
|
|
|
|
|
if let Some(frequency) = self.frequency {
|
|
|
+ debug!("Patching frequency for pen #{}: {}", id, frequency);
|
|
|
*to_patch.frequency = frequency;
|
|
|
*to_patch.frequency_2 = frequency.try_into().unwrap();
|
|
|
}
|
|
|
+
|
|
|
+ // Always enable custom settings for pen
|
|
|
+ *to_patch.use_default = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -71,15 +78,15 @@ pub struct ClonePen {
|
|
|
|
|
|
impl ClonePen {
|
|
|
fn clone(&self, target: &mut Vec<Pen>) {
|
|
|
- trace!("Cloning pen #{} to #{}", self.from, self.to);
|
|
|
+ debug!("Cloning pen #{} to #{}", self.from, self.to);
|
|
|
assert!(
|
|
|
self.to > self.from,
|
|
|
"Target pen must be greater than source pen"
|
|
|
);
|
|
|
|
|
|
// Clone pen
|
|
|
- let src = target.get(self.from).expect("Invalid pen index").clone();
|
|
|
- let dst = target.get_mut(self.to).expect("Invalid pen index");
|
|
|
+ let src: Pen = target.get(self.from).expect("Invalid pen index").clone();
|
|
|
+ let dst: &mut Pen = target.get_mut(self.to).expect("Invalid pen index");
|
|
|
*dst = src;
|
|
|
|
|
|
// Patch pen if needed
|
|
|
@@ -107,18 +114,79 @@ pub struct PatternPen {
|
|
|
|
|
|
impl PatternPen {
|
|
|
fn pattern(&self, target: &mut Vec<Pen>) {
|
|
|
- trace!("Patterning from pen #{} to #{}", self.from, self.to);
|
|
|
+ debug!("Patterning from pen #{} to #{}", self.from, self.to);
|
|
|
assert!(
|
|
|
self.to > self.from,
|
|
|
"Target pen(s) must be greater than source pen"
|
|
|
);
|
|
|
|
|
|
// Obtain settings from first pen
|
|
|
- let src = target.get(self.from).expect("Invalid pen index").clone();
|
|
|
+ let src: Pen = target.get(self.from).expect("Invalid pen index").clone();
|
|
|
+
|
|
|
+ let mut setting: PatternField = match self.field {
|
|
|
+ PatternField::Loops(_) => {
|
|
|
+ debug!(
|
|
|
+ "Initial loop count from pen #{}: {}",
|
|
|
+ self.from, *src.loop_count
|
|
|
+ );
|
|
|
+ PatternField::Loops((*src.loop_count).try_into().unwrap())
|
|
|
+ }
|
|
|
+ PatternField::Speed(_) => {
|
|
|
+ debug!("Initial speed from pen #{}: {}", self.from, *src.speed);
|
|
|
+ PatternField::Speed(*src.speed)
|
|
|
+ }
|
|
|
+ PatternField::Power(_) => {
|
|
|
+ debug!("Initial power from pen #{}: {}", self.from, *src.power);
|
|
|
+ PatternField::Power(*src.power)
|
|
|
+ }
|
|
|
+ PatternField::Frequency(_) => {
|
|
|
+ debug!(
|
|
|
+ "Initial frequency from pen #{}: {}",
|
|
|
+ self.from, *src.frequency
|
|
|
+ );
|
|
|
+ PatternField::Frequency((*src.frequency).try_into().unwrap())
|
|
|
+ }
|
|
|
+ };
|
|
|
|
|
|
- // Clone to target pen and patch pattern setting
|
|
|
for dst in (self.from..=self.to).skip(1) {
|
|
|
+ // Clone to target pen
|
|
|
+ let pen: &mut Pen = target.get_mut(dst).expect("Invalid pen index");
|
|
|
+ *pen = src.clone();
|
|
|
+
|
|
|
+ // Calculate new setting
|
|
|
+ setting = match (setting, &self.field) {
|
|
|
+ (PatternField::Loops(prev), PatternField::Loops(incr)) => {
|
|
|
+ debug!("Patching loop count for pen #{}: {}", dst, prev + incr);
|
|
|
+ PatternField::Loops(prev + incr)
|
|
|
+ }
|
|
|
+ (PatternField::Speed(prev), PatternField::Speed(incr)) => {
|
|
|
+ debug!("Patching speed for pen #{}: {}", dst, prev + incr);
|
|
|
+ PatternField::Speed(prev + incr)
|
|
|
+ }
|
|
|
+ (PatternField::Power(prev), PatternField::Power(incr)) => {
|
|
|
+ debug!("Patching power for pen #{}: {}", dst, prev + incr);
|
|
|
+ PatternField::Power(prev + incr)
|
|
|
+ }
|
|
|
+ (PatternField::Frequency(prev), PatternField::Frequency(incr)) => {
|
|
|
+ debug!("Patching frequency for pen #{}: {}", dst, prev + incr);
|
|
|
+ PatternField::Frequency(prev + incr)
|
|
|
+ }
|
|
|
+ _ => unreachable!(),
|
|
|
+ };
|
|
|
+
|
|
|
+ // Patch updated value
|
|
|
+ match setting {
|
|
|
+ PatternField::Loops(x) => *pen.loop_count = x.try_into().unwrap(),
|
|
|
+ PatternField::Speed(x) => *pen.speed = x,
|
|
|
+ PatternField::Power(x) => *pen.power = x,
|
|
|
+ PatternField::Frequency(x) => {
|
|
|
+ *pen.frequency = x.try_into().unwrap();
|
|
|
+ *pen.frequency_2 = x.try_into().unwrap();
|
|
|
+ }
|
|
|
+ }
|
|
|
|
|
|
+ // Always enable custom settings for pen
|
|
|
+ *pen.use_default = 0;
|
|
|
}
|
|
|
}
|
|
|
}
|
