Merge pull request #15 from ardura/beat-bar-timing-sync

Beat bar timing sync

Author: ardura

src/lib.rs

@@ -15,6 +15,12 @@ const CYAN: Color32 = Color32::from_rgb(14,177,210);
 const YELLOW: Color32 = Color32::from_rgb(248, 255, 31);
 const DARK: Color32 = Color32::from_rgb(40, 40, 40);
 
+#[derive(Enum, Clone, PartialEq)]
+pub enum BeatSync {
+    Beat,
+    Bar
+}
+
 pub struct Gain {
     params: Arc<GainParams>,
 
@@ -57,6 +63,10 @@ struct GainParams {
     /// Horizontal Scaling
     #[id = "scaling"]
     pub h_scale: IntParam,
+
+    /// Sync Timing
+    #[id = "Sync Timing"]
+    pub sync_timing: EnumParam<BeatSync>,
 }
 
 impl Default for Gain {
@@ -114,6 +124,9 @@ impl Default for GainParams {
                 24,
                     IntRange::Linear {min: 1, max: 150 },
             ).with_unit(" Skip"),
+
+            // Sync timing parameter
+            sync_timing: EnumParam::new("Timing", BeatSync::Beat),
         }
     }
 }
@@ -225,17 +238,29 @@ impl Plugin for Gain {
                                 ui.add_space(4.0);
                                 let _swap_response = ui.checkbox(&mut ontop.lock(), "Swap").on_hover_text("Change the drawing order of waveforms");
 
-                                let sync_response = ui.checkbox(&mut sync_var.lock(), "Sync Beat").on_hover_text("Lock drawing to beat");
+                                let sync_response = ui.checkbox(&mut sync_var.lock(), "Sync").on_hover_text("Lock drawing to timing");
                                 let alt_sync = ui.checkbox(&mut alt_sync.lock(), "Alt. Sync").on_hover_text("Try this if Sync doesn't work");
+                                let timing = ui.add(widgets::ParamSlider::for_param(&params.sync_timing, setter).with_width(60.0)).on_hover_text("Refresh interval when sync enabled");
 
                                 let dir_response = ui.checkbox(&mut dir_var.lock(), "Flip").on_hover_text("Flip direction of oscilloscope");
 
                                 if gain_handle.changed() {
                                     sum_line = Line::new(PlotPoints::default());
                                 }
                                 // Reset our line on change
-                                if sync_response.clicked() || dir_response.clicked() || alt_sync.clicked()
+                                if sync_response.clicked() || dir_response.clicked() || alt_sync.clicked() || timing.changed()
                                 {
+                                    // Keep same direction when syncing (Issue #12)
+                                    if sync_response.clicked(){
+                                        // If flip selected already, it should be deselected on this click
+                                        if *dir_var.lock() {
+                                            *dir_var.lock() = false;
+                                        }
+                                        // If flip not selected, it should now be selected
+                                        else {
+                                            *dir_var.lock() = true;
+                                        }
+                                    }
                                     sum_line = Line::new(PlotPoints::default());
                                     aux_line = Line::new(PlotPoints::default());
                                     line = Line::new(PlotPoints::default());
@@ -380,19 +405,43 @@ impl Plugin for Gain {
                             // This should still play well with other DAWs using this timing
                             current_beat = ((current_beat + 0.036) * 100.0 as f64).round() / 100.0 as f64;
                             let current_bar = current_beat as i64;
-                            // Tracks based off beat number for other daws - this is a mutex instead of atomic for locking
-                            if *self.alt_sync_beat.lock() != current_bar {
-                                self.in_place_index = Arc::new(AtomicI32::new(0));
-                                self.skip_counter = 0;
-                                *self.alt_sync_beat.lock() = current_bar;
+                            // Added in Issue #11
+                            match self.params.sync_timing.value() {
+                                BeatSync::Bar => {
+                                    // Tracks based off beat number for other daws - this is a mutex instead of atomic for locking
+                                    if *self.alt_sync_beat.lock() != current_bar && current_bar % 4 == 0 {
+                                        self.in_place_index = Arc::new(AtomicI32::new(0));
+                                        self.skip_counter = 0;
+                                        *self.alt_sync_beat.lock() = current_bar;
+                                    }
+                                },
+                                BeatSync::Beat => {
+                                    // Tracks based off beat number for other daws - this is a mutex instead of atomic for locking
+                                    if *self.alt_sync_beat.lock() != current_bar {
+                                        self.in_place_index = Arc::new(AtomicI32::new(0));
+                                        self.skip_counter = 0;
+                                        *self.alt_sync_beat.lock() = current_bar;
+                                    }
+                                },
                             }
                         } else {
                             // Works in FL Studio but not other daws, hence the previous couple of lines
                             current_beat = (current_beat * 10000.0 as f64).round() / 10000.0 as f64;
-                            if current_beat % 1.0 == 0.0 {
-                                // Reset our index to the sample vecdeques
-                                self.in_place_index = Arc::new(AtomicI32::new(0));
-                                self.skip_counter = 0;
+                            match self.params.sync_timing.value() {
+                                BeatSync::Bar => {
+                                    if current_beat % 4.0 == 0.0 {
+                                        // Reset our index to the sample vecdeques
+                                        self.in_place_index = Arc::new(AtomicI32::new(0));
+                                        self.skip_counter = 0;
+                                    }
+                                },
+                                BeatSync::Beat => {
+                                    if current_beat % 1.0 == 0.0 {
+                                        // Reset our index to the sample vecdeques
+                                        self.in_place_index = Arc::new(AtomicI32::new(0));
+                                        self.skip_counter = 0;
+                                    }
+                                },
                             }
                         }
                     }