convert all def_command! to #[commands]

src/device/sampler.rs

@@ -8,52 +8,61 @@ pub(crate) use symphonia::{
     },
 };
 
-def_command!(SamplerCommand: |sampler: Sampler| {
-    RecordToggle { slot: usize } => {
-        let slot = *slot;
-        let recording = sampler.recording.as_ref().map(|x|x.0);
-        let _ = Self::RecordFinish.act(sampler)?;
+#[tek_proc::commands(SamplerCommand = "sampler")]
+impl Sampler {
+
+    #[command(RecordToggle = "rec-toggle")]
+    fn record_toggle (&mut self, slot: usize) -> Perhaps<SamplerCommand> {
+        let recording = self.recording.as_ref().map(|x|x.0);
+        let _ = SamplerCommand::RecordFinish.act(self)?;
         // autoslice: continue recording at next slot
         if recording != Some(slot) {
-            Self::RecordBegin { slot }.act(sampler)
+            SamplerCommand::RecordBegin { slot }.act(self)
         } else {
             Ok(None)
         }
-    },
-    RecordBegin { slot: usize } => {
-        let slot = *slot;
-        sampler.recording = Some((
+    }
+
+    #[command(RecordBegin = "rec-begin")]
+    fn record_begin (&mut self, slot: usize) -> Perhaps<SamplerCommand> {
+        self.recording = Some((
             slot,
             Some(Arc::new(RwLock::new(Sample::new(
-                "Sample", 0, 0, vec![vec![];sampler.audio_ins.len()]
+                "Sample", 0, 0, vec![vec![];self.audio_ins.len()]
             ))))
         ));
         Ok(None)
-    },
-    RecordFinish => {
-        let _prev_sample = sampler.recording.as_mut().map(|(index, sample)|{
-            std::mem::swap(sample, &mut sampler.samples.0[*index]);
+    }
+
+    #[command(RecordFinish = "rec-finish")]
+    fn record_finish (&mut self) -> Perhaps<SamplerCommand> {
+        let _prev_sample = self.recording.as_mut().map(|(index, sample)|{
+            std::mem::swap(sample, &mut self.samples.0[*index]);
             sample
         }); // TODO: undo
         Ok(None)
-    },
-    RecordCancel => {
-        sampler.recording = None;
+    }
+
+    #[command(RecordCancel = "rec-cancel")]
+    fn record_cancel (&mut self) -> Perhaps<SamplerCommand> {
+        self.recording = None;
         Ok(None)
-    },
-    PlaySample { slot: usize } => {
-        let slot = *slot;
-        if let Some(ref sample) = sampler.samples.0[slot] {
-            sampler.voices.write().unwrap().push(Sample::play(sample, 0, &u7::from(128)));
+    }
+
+    #[command(PlaySample = "sample-play")]
+    fn sample_play (&mut self, slot: usize) -> Perhaps<SamplerCommand> {
+        if let Some(ref sample) = self.samples.0[slot] {
+            self.voices.write().unwrap().push(Sample::play(sample, 0, &u7::from(128)));
         }
         Ok(None)
-    },
-    StopSample { slot: usize } => {
-        let _slot = *slot;
+    }
+
+    #[command(StopSample = "sample-stop")]
+    fn sample_stop (&mut self, slot: usize) -> Perhaps<SamplerCommand> {
         todo!();
         //Ok(None)
-    },
-});
+    }
+}
 
 /// Plays [Voice]s from [Sample]s.
 ///