Feat: introduce follow up actions

crates/project/src/lib.rs

@@ -7,4 +7,4 @@ pub const MAX_STEPS: usize = 1024;
 pub const DEFAULT_LENGTH: usize = 16;
 
 pub use file::{load, save, FileError};
-pub use project::{Bank, LaunchQuantization, Pattern, PatternSpeed, Project, Step, SyncMode};
+pub use project::{Bank, FollowUp, LaunchQuantization, Pattern, PatternSpeed, Project, Step, SyncMode};

crates/project/src/project.rs

@@ -206,6 +206,44 @@ impl SyncMode {
     }
 }
 
+#[derive(Clone, Copy, Serialize, Deserialize, Default, PartialEq, Eq)]
+pub enum FollowUp {
+    #[default]
+    Loop,
+    Stop,
+    Chain { bank: usize, pattern: usize },
+}
+
+impl FollowUp {
+    pub fn label(&self) -> &'static str {
+        match self {
+            Self::Loop => "Loop",
+            Self::Stop => "Stop",
+            Self::Chain { .. } => "Chain",
+        }
+    }
+
+    pub fn next_mode(&self) -> Self {
+        match self {
+            Self::Loop => Self::Stop,
+            Self::Stop => Self::Chain { bank: 0, pattern: 0 },
+            Self::Chain { .. } => Self::Loop,
+        }
+    }
+
+    pub fn prev_mode(&self) -> Self {
+        match self {
+            Self::Loop => Self::Chain { bank: 0, pattern: 0 },
+            Self::Stop => Self::Loop,
+            Self::Chain { .. } => Self::Stop,
+        }
+    }
+}
+
+fn is_default_follow_up(f: &FollowUp) -> bool {
+    *f == FollowUp::default()
+}
+
 #[derive(Clone, Serialize, Deserialize)]
 pub struct Step {
     pub active: bool,
@@ -245,6 +283,7 @@ pub struct Pattern {
     pub name: Option<String>,
     pub quantization: LaunchQuantization,
     pub sync_mode: SyncMode,
+    pub follow_up: FollowUp,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -280,6 +319,8 @@ struct SparsePattern {
     quantization: LaunchQuantization,
     #[serde(default, skip_serializing_if = "is_default_sync_mode")]
     sync_mode: SyncMode,
+    #[serde(default, skip_serializing_if = "is_default_follow_up")]
+    follow_up: FollowUp,
 }
 
 fn is_default_quantization(q: &LaunchQuantization) -> bool {
@@ -302,6 +343,8 @@ struct LegacyPattern {
     quantization: LaunchQuantization,
     #[serde(default)]
     sync_mode: SyncMode,
+    #[serde(default)]
+    follow_up: FollowUp,
 }
 
 impl Serialize for Pattern {
@@ -327,6 +370,7 @@ impl Serialize for Pattern {
             name: self.name.clone(),
             quantization: self.quantization,
             sync_mode: self.sync_mode,
+            follow_up: self.follow_up,
         };
         sparse.serialize(serializer)
     }
@@ -361,6 +405,7 @@ impl<'de> Deserialize<'de> for Pattern {
                     name: sparse.name,
                     quantization: sparse.quantization,
                     sync_mode: sparse.sync_mode,
+                    follow_up: sparse.follow_up,
                 })
             }
             PatternFormat::Legacy(legacy) => Ok(Pattern {
@@ -370,6 +415,7 @@ impl<'de> Deserialize<'de> for Pattern {
                 name: legacy.name,
                 quantization: legacy.quantization,
                 sync_mode: legacy.sync_mode,
+                follow_up: legacy.follow_up,
             }),
         }
     }
@@ -384,6 +430,7 @@ impl Default for Pattern {
             name: None,
             quantization: LaunchQuantization::default(),
             sync_mode: SyncMode::default(),
+            follow_up: FollowUp::default(),
         }
     }
 }