From f1d2ffba19669fb3ffa75b560fbdb96f3005bded Mon Sep 17 00:00:00 2001
From: Petr Gladkikh <petrglad@gmail.com>
Date: Tue, 7 Nov 2023 22:18:26 +0100
Subject: [PATCH] Cleanup: unify time types

---
 README.md           |   9 ++-
 src/app.rs          |  21 +++----
 src/common.rs       |   4 ++
 src/engine.rs       |  22 ++++----
 src/midi.rs         |  11 ++--
 src/stave.rs        | 133 ++++++++++++++++----------------------------
 src/track.rs        |  66 ++++++++++------------
 src/track_source.rs |  17 +++---
 8 files changed, 121 insertions(+), 162 deletions(-)

diff --git a/README.md b/README.md
index 5419ab0..3273da0 100644
--- a/README.md
+++ b/README.md
@@ -35,12 +35,9 @@ I use Pianoteq, but that is a commercial product.
 
 ## TODO
 
-- [ ] Persist bookmarks in project.
-- [ ] Location history navigation (e.g. go to a bookmark that was visited recently), with Alt + LeftArrow / RightArrow
+- [ ] When start playing send current CC values (will help damper to take effect immediately, not on next change). 
 - [ ] Time marks on stave ("minute:second" from the beginning).
-- [ ] Consider TransportTime to be signed (see also StaveTime). There are too many conversions forth and back.
-- [ ] When start playing send current CC values (will help damper to take effect immediately, not on next change).
-- [ ] Find a way to separate actions from view logic with egui. It looks too messy now.
+- [ ] Location history navigation (e.g. go to a bookmark that was visited recently), with Alt + LeftArrow / RightArrow
 - [ ] Minimize use of unwrap. The biggest contention currently is event data shared between engine and stave.
 - [ ] Multi-track UI (for snippets, flight recorder, and copy/paste buffer). Can show only one at a time, though. Use
   tabs?
@@ -52,6 +49,8 @@ I use Pianoteq, but that is a commercial product.
 - [ ] Copy/cut/paste.
 - [ ] Adjust tempo for selection.
 - [ ] Optimize undo history 2: save only minimal diff instead of the whole track.
+- [x] Consider TransportTime to be signed (see also StaveTime). There are too many conversions forth and back. 
+- [x] Persist bookmarks in project.
 - [x] Have a separate edit-position and play-start cursors (time bookmarks), so it is easier to jump back and listen to
   the modified version.
 - [x] Optimize undo history: avoid O(N) algos; batch fast similar commands (e.g. tail or note shifts) saving at most
diff --git a/src/app.rs b/src/app.rs
index 9104fac..c8b1942 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -2,16 +2,17 @@ use std::fs;
 use std::path::PathBuf;
 use std::sync::mpsc;
 
+use crate::common::Time;
 use eframe::egui::{Modifiers, Vec2};
 use eframe::{self, egui, CreationContext};
 use egui_extras::{Size, StripBuilder};
 
-use crate::engine::{Engine, EngineCommand, StatusEvent, TransportTime};
+use crate::engine::{Engine, EngineCommand, StatusEvent};
 use crate::project::Project;
-use crate::stave::{Bookmarks, Stave, StaveTime};
+use crate::stave::{Bookmarks, Stave};
 
 enum Message {
-    UpdateTransportTime(TransportTime),
+    UpdateTime(Time),
 }
 
 pub struct EmApp {
@@ -50,8 +51,8 @@ impl EmApp {
             // TODO (optimization?) Throttle updates (30..60 times per second should be enough).
             //      Should not miss one-off updates, maybe skip only in same-event-type runs.
             match ev {
-                StatusEvent::TransportTime(t) => {
-                    match message_sender.send(Message::UpdateTransportTime(t)) {
+                StatusEvent::Time(t) => {
+                    match message_sender.send(Message::UpdateTime(t)) {
                         Ok(_) => engine_receiver_ctx.request_repaint(),
                         _ => (), // Will try next time.
                     }
@@ -88,9 +89,9 @@ impl EmApp {
         self.stave.save_to(&PathBuf::from(path));
     }
 
-    fn engine_seek(&self, to: StaveTime) {
+    fn engine_seek(&self, to: Time) {
         self.engine_command_send
-            .send(Box::new(move |engine| engine.seek(to as TransportTime)))
+            .send(Box::new(move |engine| engine.seek(to)))
             .unwrap();
     }
 }
@@ -100,11 +101,11 @@ impl eframe::App for EmApp {
         self.stave.history.do_pending();
         if let Some(message) = self.message_receiver.try_iter().last() {
             match message {
-                Message::UpdateTransportTime(t) => {
-                    self.stave.cursor_position = t as StaveTime;
+                Message::UpdateTime(t) => {
+                    self.stave.cursor_position = t;
                     if self.follow_playback {
                         let at = self.stave.cursor_position;
-                        self.stave.scroll_to(at as StaveTime, 0.1);
+                        self.stave.scroll_to(at, 0.1);
                     }
                 }
             }
diff --git a/src/common.rs b/src/common.rs
index 8824855..6a2858a 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -1 +1,5 @@
+/// Track time in microseconds.
+pub type Time = i64;
+
+/// A data revision identifier.
 pub type VersionId = i64;
diff --git a/src/engine.rs b/src/engine.rs
index 086a5d0..c1f3423 100644
--- a/src/engine.rs
+++ b/src/engine.rs
@@ -4,6 +4,7 @@ use std::sync::{mpsc, Arc, Mutex};
 use std::thread;
 use std::time::{Duration, Instant};
 
+use crate::common::Time;
 use midly::live::LiveEvent;
 use midly::MidiMessage;
 use vst::event::Event;
@@ -12,19 +13,16 @@ use vst::plugin::Plugin;
 use crate::midi_vst::Vst;
 use crate::track::MIDI_CC_SUSTAIN_ID;
 
-/// uSecs from the start.
-pub type TransportTime = u64;
-
 /** Event that is produced by engine. */
 #[derive(Clone, Debug)]
 pub enum StatusEvent {
-    TransportTime(TransportTime),
+    Time(Time),
 }
 
 /// A sound event to be rendered by the engine at given time.
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub struct EngineEvent {
-    pub at: TransportTime,
+    pub at: Time,
     pub event: LiveEvent<'static>,
 }
 
@@ -49,10 +47,10 @@ pub trait EventSource {
     Use this to detach it from the engine. */
     fn is_running(&self) -> bool;
     /** Reset current source's time to this moment. */
-    fn seek(&mut self, at: &TransportTime);
+    fn seek(&mut self, at: &Time);
     /** The next event to be played at the instant. On subsequent
     calls instants must not decrease unless a reset call sets another time. */
-    fn next(&mut self, at: &TransportTime, queue: &mut BinaryHeap<EngineEvent>);
+    fn next(&mut self, at: &Time, queue: &mut BinaryHeap<EngineEvent>);
 }
 
 type EventSourceHandle = dyn EventSource + Send;
@@ -62,7 +60,7 @@ pub type EngineCommand = dyn FnOnce(&mut Engine) + Send;
 pub struct Engine {
     vst: Vst,
     sources: Vec<Box<EventSourceHandle>>,
-    running_at: TransportTime,
+    running_at: Time,
     reset_at: Instant,
     paused: bool,
     status_receiver: Option<Box<StatusEventReceiver>>,
@@ -152,13 +150,13 @@ impl Engine {
     }
 
     fn update_track_time(&mut self) {
-        self.running_at = Instant::now().duration_since(self.reset_at).as_micros() as u64;
+        self.running_at = Instant::now().duration_since(self.reset_at).as_micros() as Time;
         self.status_receiver
             .as_mut()
-            .map(|recv| recv(StatusEvent::TransportTime(self.running_at)));
+            .map(|recv| recv(StatusEvent::Time(self.running_at)));
     }
 
-    pub fn seek(&mut self, at: TransportTime) {
+    pub fn seek(&mut self, at: Time) {
         for s in self.sources.iter_mut() {
             s.seek(&at);
         }
@@ -183,7 +181,7 @@ impl Engine {
     }
 
     pub fn update_realtime(&mut self) {
-        self.reset_at = Instant::now() - Duration::from_micros(self.running_at);
+        self.reset_at = Instant::now() - Duration::from_micros(self.running_at as u64);
     }
 
     pub fn add(&mut self, source: Box<EventSourceHandle>) {
diff --git a/src/midi.rs b/src/midi.rs
index 6ac32eb..509370d 100644
--- a/src/midi.rs
+++ b/src/midi.rs
@@ -1,20 +1,21 @@
 use std::collections::BinaryHeap;
 use std::time::Duration;
 
+use crate::common::Time;
 use midly::io::WriteResult;
 use midly::live::LiveEvent;
 use midly::num::u15;
 use midly::MidiMessage::Controller;
 use midly::{Format, Header, MidiMessage, Smf, Timing, Track, TrackEvent};
 
-use crate::engine::{EngineEvent, EventSource, TransportTime};
+use crate::engine::{EngineEvent, EventSource};
 use crate::track::{ChannelId, ControllerId, Level, Pitch};
 
 pub struct SmfSource {
     events: Vec<TrackEvent<'static>>,
     tick: Duration,
     current_idx: usize,
-    running_at: TransportTime,
+    running_at: Time,
 }
 
 pub fn load_smf(smf_data: &Vec<u8>) -> (Vec<TrackEvent<'static>>, u32) {
@@ -103,7 +104,7 @@ impl EventSource for SmfSource {
         self.current_idx < self.events.len()
     }
 
-    fn seek(&mut self, at: &TransportTime) {
+    fn seek(&mut self, at: &Time) {
         assert!(
             self.running_at > *at,
             "SmfSource back reset is not supported."
@@ -111,12 +112,12 @@ impl EventSource for SmfSource {
         self.running_at = at.to_owned();
     }
 
-    fn next(&mut self, at: &TransportTime, queue: &mut BinaryHeap<EngineEvent>) {
+    fn next(&mut self, at: &Time, queue: &mut BinaryHeap<EngineEvent>) {
         let track = &self.events;
         while self.is_running() {
             let event = track[self.current_idx];
             let running_at =
-                self.running_at + self.tick.as_micros() as u64 * event.delta.as_int() as u64;
+                self.running_at + self.tick.as_micros() as Time * event.delta.as_int() as Time;
             if running_at > *at {
                 return;
             }
diff --git a/src/stave.rs b/src/stave.rs
index a657e8f..c6ae46e 100644
--- a/src/stave.rs
+++ b/src/stave.rs
@@ -11,15 +11,13 @@ use egui::Rgba;
 use ordered_float::OrderedFloat;
 use serde::{Deserialize, Serialize};
 
-use crate::common::VersionId;
-use crate::engine::TransportTime;
+use crate::common::{Time, VersionId};
 use crate::track::{
-    EventId, Level, Note, Pitch, Track, TrackEvent, TrackEventType, MIDI_CC_SUSTAIN_ID,
+    EventId, Level, Note, Pitch, TimeSelection, Track, TrackEvent, TrackEventType,
+    MIDI_CC_SUSTAIN_ID,
 };
 use crate::track_history::{ActionId, TrackHistory};
-use crate::{track, Pix};
-
-pub type StaveTime = i64;
+use crate::Pix;
 
 // Tone 60 is C3, tones start at C-2 (21).
 const PIANO_LOWEST_KEY: Pitch = 21;
@@ -40,18 +38,6 @@ fn key_line_ys(view_y_range: &Rangef, pitches: Range<Pitch>) -> (BTreeMap<Pitch,
     (lines, step)
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TimeSelection {
-    pub from: StaveTime,
-    pub to: StaveTime,
-}
-
-impl TimeSelection {
-    pub fn is_empty(&self) -> bool {
-        self.to - self.from <= 0
-    }
-}
-
 #[derive(Debug)]
 pub struct NoteDraw {
     time: TimeSelection,
@@ -81,22 +67,9 @@ impl NotesSelection {
     }
 }
 
-fn to_transport_time(value: StaveTime) -> TransportTime {
-    value.max(0) as TransportTime
-}
-
-impl From<&TimeSelection> for track::TimeSelection {
-    fn from(value: &TimeSelection) -> Self {
-        track::TimeSelection {
-            from: to_transport_time(value.from),
-            to: to_transport_time(value.to),
-        }
-    }
-}
-
 #[derive(Debug, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
 pub struct Bookmark {
-    at: StaveTime,
+    at: Time,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -114,17 +87,17 @@ impl Bookmarks {
         }
     }
 
-    pub fn set(&mut self, at: StaveTime) {
+    pub fn set(&mut self, at: Time) {
         self.list.insert(Bookmark { at });
         self.store_to(&self.file_path);
     }
 
-    pub fn remove(&mut self, at: &StaveTime) {
+    pub fn remove(&mut self, at: &Time) {
         self.list.remove(&Bookmark { at: *at });
         self.store_to(&self.file_path);
     }
 
-    pub fn previous(&self, here: &StaveTime) -> Option<StaveTime> {
+    pub fn previous(&self, here: &Time) -> Option<Time> {
         self.list
             .iter()
             .rev()
@@ -132,7 +105,7 @@ impl Bookmarks {
             .map(|bm| bm.at)
     }
 
-    pub fn next(&self, here: &StaveTime) -> Option<StaveTime> {
+    pub fn next(&self, here: &Time) -> Option<Time> {
         self.list.iter().find(|&bm| bm.at > *here).map(|bm| bm.at)
     }
 
@@ -161,11 +134,11 @@ pub struct Stave {
     pub history: TrackHistory,
     pub track_version: VersionId,
 
-    pub time_left: StaveTime,
-    pub time_right: StaveTime,
+    pub time_left: Time,
+    pub time_right: Time,
     pub view_rect: Rect,
 
-    pub cursor_position: StaveTime,
+    pub cursor_position: Time,
     pub bookmarks: Bookmarks,
     pub time_selection: Option<TimeSelection>,
     pub note_draw: Option<NoteDraw>,
@@ -178,14 +151,14 @@ const COLOR_HOVERED: Rgba = COLOR_SELECTED;
 struct InnerResponse {
     response: egui::Response,
     pitch_hovered: Option<Pitch>,
-    time_hovered: Option<StaveTime>,
+    time_hovered: Option<Time>,
     note_hovered: Option<EventId>,
     modifiers: Modifiers,
 }
 
 pub struct StaveResponse {
     pub ui_response: egui::Response,
-    pub new_cursor_position: Option<StaveTime>,
+    pub new_cursor_position: Option<Time>,
 }
 
 impl Stave {
@@ -218,39 +191,39 @@ impl Stave {
         self.view_rect.width() / (self.time_right - self.time_left) as f32
     }
 
-    pub fn x_from_time(&self, at: StaveTime) -> Pix {
+    pub fn x_from_time(&self, at: Time) -> Pix {
         self.view_rect.min.x + (at as f32 - self.time_left as f32) * self.time_scale()
     }
 
-    pub fn time_from_x(&self, x: Pix) -> StaveTime {
-        self.time_left + ((x - self.view_rect.min.x) / self.time_scale()) as StaveTime
+    pub fn time_from_x(&self, x: Pix) -> Time {
+        self.time_left + ((x - self.view_rect.min.x) / self.time_scale()) as Time
     }
 
     pub fn zoom(&mut self, zoom_factor: f32, mouse_x: Pix) {
         // Zoom so that position under mouse pointer stays put.
         let at = self.time_from_x(mouse_x);
-        self.time_left = at - ((at - self.time_left) as f32 / zoom_factor) as StaveTime;
-        self.time_right = at + ((self.time_right - at) as f32 / zoom_factor) as StaveTime;
+        self.time_left = at - ((at - self.time_left) as f32 / zoom_factor) as Time;
+        self.time_right = at + ((self.time_right - at) as f32 / zoom_factor) as Time;
     }
 
-    pub fn scroll(&mut self, dt: StaveTime) {
+    pub fn scroll(&mut self, dt: Time) {
         self.time_left += dt;
         self.time_right += dt;
     }
 
     pub fn scroll_by(&mut self, dx: Pix) {
-        self.scroll((dx / self.time_scale()) as StaveTime);
+        self.scroll((dx / self.time_scale()) as Time);
     }
 
-    pub fn scroll_to(&mut self, at: StaveTime, view_fraction: f32) {
+    pub fn scroll_to(&mut self, at: Time, view_fraction: f32) {
         self.scroll(
-            at - ((self.time_right - self.time_left) as f32 * view_fraction) as StaveTime
+            at - ((self.time_right - self.time_left) as f32 * view_fraction) as Time
                 - self.time_left,
         );
     }
 
     const NOTHING_ZONE: TimeSelection = TimeSelection {
-        from: StaveTime::MIN,
+        from: Time::MIN,
         to: 0,
     };
 
@@ -337,12 +310,12 @@ impl Stave {
         key_ys: &BTreeMap<Pitch, Pix>,
         half_tone_step: &Pix,
         pitch_hovered: &Option<Pitch>,
-        time_hovered: &Option<StaveTime>,
+        time_hovered: &Option<Time>,
         note_hovered: &mut Option<EventId>,
         painter: &Painter,
         track: &Track,
     ) {
-        let mut last_damper_value: (StaveTime, Level) = (0, 0);
+        let mut last_damper_value: (Time, Level) = (0, 0);
         for i in 0..track.events.len() {
             let event = &track.events[i];
             match &event.event {
@@ -356,10 +329,7 @@ impl Stave {
                         self.draw_note(
                             &painter,
                             note.velocity,
-                            (
-                                event.at as StaveTime,
-                                (event.at + note.duration) as StaveTime,
-                            ),
+                            (event.at, event.at + note.duration),
                             *y,
                             *half_tone_step,
                             self.note_selection.contains(&event),
@@ -368,7 +338,7 @@ impl Stave {
                 }
                 TrackEventType::Controller(v) if v.controller_id == MIDI_CC_SUSTAIN_ID => {
                     if let Some(y) = key_ys.get(&PIANO_DAMPER_LINE) {
-                        let at = event.at as StaveTime;
+                        let at = event.at;
                         self.draw_cc(
                             &painter,
                             last_damper_value.0,
@@ -420,13 +390,13 @@ impl Stave {
 
     fn event_hovered(
         pitch_hovered: &Option<Pitch>,
-        time_hovered: &Option<StaveTime>,
+        time_hovered: &Option<Time>,
         event: &TrackEvent,
         pitch: &Pitch,
     ) -> bool {
         if let Some(t) = &time_hovered {
             if let Some(p) = pitch_hovered {
-                event.is_active(*t as TransportTime) && p == pitch
+                event.is_active(*t) && p == pitch
             } else {
                 false
             }
@@ -435,9 +405,9 @@ impl Stave {
         }
     }
 
-    const KEYBOARD_TIME_STEP: StaveTime = 10_000;
+    const KEYBOARD_TIME_STEP: Time = 10_000;
 
-    fn handle_commands(&mut self, response: &egui::Response) -> Option<StaveTime> {
+    fn handle_commands(&mut self, response: &egui::Response) -> Option<Time> {
         // Need to see if duplication here can be reduced.
         // Likely the dispatch needs some hash map that for each input state defines a unique command.
         // Need to support focus somehow so the commands only active when stave is focused.
@@ -458,7 +428,7 @@ impl Stave {
         }) {
             self.history.update_track(None, |track| {
                 if let Some(time_selection) = &self.time_selection {
-                    track.tape_cut(&time_selection.into());
+                    track.tape_cut(&time_selection);
                 }
                 track.delete_events(&self.note_selection.selected);
             });
@@ -471,7 +441,7 @@ impl Stave {
         }) {
             self.history.update_track(None, |track| {
                 if let Some(time_selection) = &self.time_selection {
-                    track.tape_insert(&time_selection.into());
+                    track.tape_insert(&time_selection);
                 }
             });
         }
@@ -485,10 +455,7 @@ impl Stave {
         }) {
             self.history
                 .update_track(Some("tail_shift_right"), |track| {
-                    track.shift_tail(
-                        &(self.cursor_position as TransportTime),
-                        Stave::KEYBOARD_TIME_STEP,
-                    );
+                    track.shift_tail(&(self.cursor_position), Stave::KEYBOARD_TIME_STEP);
                 });
         }
         if response.ctx.input_mut(|i| {
@@ -498,10 +465,7 @@ impl Stave {
             ))
         }) {
             self.history.update_track(Some("tail_shift_left"), |track| {
-                track.shift_tail(
-                    &(self.cursor_position as TransportTime),
-                    -Stave::KEYBOARD_TIME_STEP,
-                );
+                track.shift_tail(&(self.cursor_position), -Stave::KEYBOARD_TIME_STEP);
             });
         }
 
@@ -543,7 +507,7 @@ impl Stave {
                 &(|note| {
                     note.duration = note
                         .duration
-                        .checked_sub(Stave::KEYBOARD_TIME_STEP as TransportTime)
+                        .checked_sub(Stave::KEYBOARD_TIME_STEP)
                         .unwrap_or(0);
                 }),
             );
@@ -556,7 +520,7 @@ impl Stave {
                 &(|note| {
                     note.duration = note
                         .duration
-                        .checked_add(Stave::KEYBOARD_TIME_STEP as TransportTime)
+                        .checked_add(Stave::KEYBOARD_TIME_STEP)
                         .unwrap_or(0);
                 }),
             );
@@ -678,8 +642,8 @@ impl Stave {
         None
     }
 
-    fn max_time(&self) -> StaveTime {
-        self.history.with_track(|track| track.max_time()) as StaveTime
+    fn max_time(&self) -> Time {
+        self.history.with_track(|track| track.max_time())
     }
 
     pub fn edit_selected_notes<Action: Fn(&mut Note)>(
@@ -705,7 +669,7 @@ impl Stave {
         });
     }
 
-    fn update_time_selection(&mut self, response: &egui::Response, time: &Option<StaveTime>) {
+    fn update_time_selection(&mut self, response: &egui::Response, time: &Option<Time>) {
         let drag_button = PointerButton::Primary;
         if response.clicked_by(drag_button) {
             self.time_selection = None;
@@ -731,7 +695,7 @@ impl Stave {
         &mut self,
         response: &egui::Response,
         modifiers: &Modifiers,
-        time: &Option<StaveTime>,
+        time: &Option<Time>,
         pitch: &Option<Pitch>,
     ) {
         // TODO Extract the drag pattern? See also update_time_selection.
@@ -756,10 +720,7 @@ impl Stave {
             if let Some(draw) = &mut self.note_draw {
                 if !draw.time.is_empty() {
                     self.history.update_track(None, |track| {
-                        let time_range = (
-                            draw.time.from as TransportTime,
-                            draw.time.to as TransportTime,
-                        );
+                        let time_range = (draw.time.from, draw.time.to);
                         if draw.pitch == PIANO_DAMPER_LINE {
                             if modifiers.alt {
                                 track.set_damper_to(time_range, false);
@@ -794,7 +755,7 @@ impl Stave {
         &self,
         painter: &Painter,
         velocity: Level,
-        x_range: (StaveTime, StaveTime),
+        x_range: (Time, Time),
         y: Pix,
         height: Pix,
         selected: bool,
@@ -816,8 +777,8 @@ impl Stave {
     fn draw_cc(
         &self,
         painter: &Painter,
-        last_time: StaveTime,
-        at: StaveTime,
+        last_time: Time,
+        at: Time,
         value: Level,
         y: Pix,
         height: Pix,
@@ -889,7 +850,7 @@ impl Stave {
         )
     }
 
-    fn ensure_visible(&mut self, at: StaveTime) {
+    fn ensure_visible(&mut self, at: Time) {
         let x_range = self.view_rect.x_range();
         let x = self.x_from_time(at);
         if !x_range.contains(x) {
diff --git a/src/track.rs b/src/track.rs
index 2ee1e91..6054e0c 100644
--- a/src/track.rs
+++ b/src/track.rs
@@ -7,8 +7,7 @@ use std::sync::atomic::Ordering::SeqCst;
 use midly::num::{u4, u7};
 use midly::{MidiMessage, TrackEventKind};
 
-use crate::common::VersionId;
-use crate::engine::TransportTime;
+use crate::common::{Time, VersionId};
 use crate::util::{is_ordered, range_contains};
 use crate::{midi, util};
 
@@ -33,7 +32,7 @@ pub fn is_cc_switch_on(x: Level) -> bool {
 pub struct Note {
     pub pitch: Pitch,
     pub velocity: Level,
-    pub duration: TransportTime,
+    pub duration: Time,
 }
 
 #[derive(Debug, Eq, PartialEq)]
@@ -52,12 +51,12 @@ pub enum TrackEventType {
 pub struct TrackEvent {
     pub id: EventId,
     /// Since the track beginning.
-    pub at: TransportTime,
+    pub at: Time,
     pub event: TrackEventType,
 }
 
 impl TrackEvent {
-    pub fn is_active(&self, at: TransportTime) -> bool {
+    pub fn is_active(&self, at: Time) -> bool {
         match &self.event {
             TrackEventType::Note(n) => (self.at..(self.at + n.duration)).contains(&at),
             _ => false,
@@ -81,26 +80,30 @@ impl Ord for TrackEvent {
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TimeSelection {
-    pub from: TransportTime,
-    pub to: TransportTime,
+    pub from: Time,
+    pub to: Time,
 }
 
 impl TimeSelection {
-    pub fn length(&self) -> TransportTime {
+    pub fn length(&self) -> Time {
         self.to - self.from
     }
 
-    pub fn contains(&self, at: TransportTime) -> bool {
+    pub fn contains(&self, at: Time) -> bool {
         self.from <= at && at < self.to
     }
 
-    pub fn before(&self, at: TransportTime) -> bool {
+    pub fn before(&self, at: Time) -> bool {
         self.to <= at
     }
 
-    pub fn after_start(&self, at: TransportTime) -> bool {
+    pub fn after_start(&self, at: Time) -> bool {
         self.from <= at
     }
+
+    pub fn is_empty(&self) -> bool {
+        self.to - self.from <= 0
+    }
 }
 
 #[derive(Debug, Default)]
@@ -124,7 +127,7 @@ impl Track {
     pub fn load_from(&mut self, file_path: &PathBuf) {
         let data = std::fs::read(&file_path).unwrap();
         let events = midi::load_smf(&data);
-        self.events = from_midi_events(&mut self.id_seq, events.0, events.1 as u64);
+        self.events = from_midi_events(&mut self.id_seq, events.0, events.1 as Time);
         self.commit();
     }
 
@@ -138,12 +141,7 @@ impl Track {
             .expect(&*format!("Cannot save to {}", &file_path.display()));
     }
 
-    pub fn add_note(
-        &mut self,
-        time_range: (TransportTime, TransportTime),
-        pitch: Pitch,
-        level: Level,
-    ) {
+    pub fn add_note(&mut self, time_range: (Time, Time), pitch: Pitch, level: Level) {
         let ev = TrackEvent {
             id: self.id_seq.fetch_add(1, SeqCst),
             at: time_range.0,
@@ -167,7 +165,7 @@ impl Track {
         self.commit();
     }
 
-    fn clear_cc_events(&mut self, time_range: util::Range<TransportTime>, cc_id: ControllerId) {
+    fn clear_cc_events(&mut self, time_range: util::Range<Time>, cc_id: ControllerId) {
         let mut i = 0;
         loop {
             if let Some(ev) = self.events.get(i) {
@@ -186,7 +184,7 @@ impl Track {
         }
     }
 
-    pub fn set_damper_to(&mut self, time_range: util::Range<TransportTime>, on: bool) {
+    pub fn set_damper_to(&mut self, time_range: util::Range<Time>, on: bool) {
         dbg!("set_damper_range", time_range, on);
         let on_before = is_cc_switch_on(self.cc_value_at(&time_range.0, &MIDI_CC_SUSTAIN_ID));
         let on_after = is_cc_switch_on(self.cc_value_at(&time_range.1, &MIDI_CC_SUSTAIN_ID));
@@ -215,7 +213,7 @@ impl Track {
         self.commit();
     }
 
-    fn cc_value_at(&self, at: &TransportTime, cc_id: &ControllerId) -> Level {
+    fn cc_value_at(&self, at: &Time, cc_id: &ControllerId) -> Level {
         let mut idx = self.events.partition_point(|x| x.at < *at);
         while idx > 0 {
             idx -= 1;
@@ -230,7 +228,7 @@ impl Track {
         return 0; // default
     }
 
-    fn sustain_event(&mut self, at: &TransportTime, on: bool) -> TrackEvent {
+    fn sustain_event(&mut self, at: &Time, on: bool) -> TrackEvent {
         TrackEvent {
             id: next_id(&mut self.id_seq),
             at: *at,
@@ -264,7 +262,7 @@ impl Track {
         self.commit();
     }
 
-    pub fn shift_tail(&mut self, at: &TransportTime, dt: i64) {
+    pub fn shift_tail(&mut self, at: &Time, dt: i64) {
         dbg!("tail_shift", at, dt);
         self.shift_events(&|ev| &ev.at > at, dt);
         self.commit();
@@ -273,11 +271,7 @@ impl Track {
     pub fn shift_events<Pred: Fn(&TrackEvent) -> bool>(&mut self, selector: &Pred, d: i64) {
         for ev in &mut self.events {
             if selector(ev) {
-                ev.at = ev
-                    .at
-                    .checked_add_signed(d)
-                    // Need to show some visual feedback and just cancel the operation instead.
-                    .expect("Should not shift event into negative times.");
+                ev.at = ev.at + d;
             }
         }
         // Should do this only for out-of-order events. Brute-forcing for now.
@@ -308,7 +302,7 @@ impl Track {
         self.commit();
     }
 
-    pub fn max_time(&self) -> TransportTime {
+    pub fn max_time(&self) -> Time {
         // Looks cumbersome. Maybe this is a case for handling MIDI (-like) events directly (see README).
         let mut result = 0;
         for ev in &self.events {
@@ -316,7 +310,7 @@ impl Track {
                 TrackEventType::Note(Note { duration, .. }) => ev.at + duration,
                 TrackEventType::Controller(_) => ev.at,
             };
-            result = TransportTime::max(result, end_time);
+            result = Time::max(result, end_time);
         }
         result
     }
@@ -329,14 +323,14 @@ fn next_id(id_seq: &mut AtomicU64) -> EventId {
 pub fn from_midi_events(
     id_seq: &mut AtomicU64,
     events: Vec<midly::TrackEvent<'static>>,
-    tick_duration: TransportTime,
+    tick_duration: Time,
 ) -> Vec<TrackEvent> {
     // TODO The offset calculations are very similar to ones in the engine. Can these be shared?
-    let mut ons: HashMap<Pitch, (TransportTime, MidiMessage)> = HashMap::new();
+    let mut ons: HashMap<Pitch, (Time, MidiMessage)> = HashMap::new();
     let mut track_events = vec![];
-    let mut at: TransportTime = 0;
+    let mut at: Time = 0;
     for ev in events {
-        at += ev.delta.as_int() as TransportTime * tick_duration;
+        at += ev.delta.as_int() as Time * tick_duration;
         match ev.kind {
             TrackEventKind::Midi { message, .. } => match message {
                 MidiMessage::NoteOn { key, .. } => {
@@ -384,7 +378,7 @@ pub fn to_midi_events(
     usec_per_tick: u32,
 ) -> Vec<midly::TrackEvent<'static>> {
     let channel = u4::from(0); // Channel hard coded.
-    let mut buffer: Vec<(TransportTime, TrackEventKind)> = vec![];
+    let mut buffer: Vec<(Time, TrackEventKind)> = vec![];
     for ev in events {
         match &ev.event {
             TrackEventType::Note(n) => {
@@ -425,7 +419,7 @@ pub fn to_midi_events(
     }
     buffer.sort_by_key(|(at, _)| at.to_owned());
     let mut midi_events = vec![];
-    let mut running_at: TransportTime = 0;
+    let mut running_at: Time = 0;
     for (at, kind) in buffer {
         midi_events.push(midly::TrackEvent {
             delta: (((at - running_at) as f64 / usec_per_tick as f64) as u32).into(),
diff --git a/src/track_source.rs b/src/track_source.rs
index 8ecc613..da42024 100644
--- a/src/track_source.rs
+++ b/src/track_source.rs
@@ -1,4 +1,5 @@
-use crate::engine::{EngineEvent, EventSource, TransportTime};
+use crate::common::Time;
+use crate::engine::{EngineEvent, EventSource};
 use crate::midi::{controller_set, note_off, note_on};
 use crate::track::{Track, TrackEventType};
 use std::collections::BinaryHeap;
@@ -7,7 +8,7 @@ use std::sync::{Arc, RwLock};
 pub struct TrackSource {
     track: Arc<RwLock<Track>>,
     current_idx: usize,
-    running_at: TransportTime,
+    running_at: Time,
 }
 
 impl TrackSource {
@@ -25,7 +26,7 @@ impl EventSource for TrackSource {
         true
     }
 
-    fn seek(&mut self, at: &TransportTime) {
+    fn seek(&mut self, at: &Time) {
         let track = self.track.read().expect("Cannot read track.");
         let note_on_time = |i: usize| track.events.get(i).map(|ev| ev.at);
         // Seek back until we cross the `at`, then forward, to stop on the earliest event after
@@ -57,7 +58,7 @@ impl EventSource for TrackSource {
         self.running_at = *at;
     }
 
-    fn next(&mut self, at: &TransportTime, queue: &mut BinaryHeap<EngineEvent>) {
+    fn next(&mut self, at: &Time, queue: &mut BinaryHeap<EngineEvent>) {
         let track = self.track.read().expect("Cannot read track.");
         while self.current_idx < track.events.len() {
             let notes = &track.events;
@@ -80,7 +81,7 @@ impl EventSource for TrackSource {
                 }
                 TrackEventType::Controller(set_val) => {
                     queue.push(EngineEvent {
-                        at: running_at as u64,
+                        at: running_at,
                         event: controller_set(1, set_val.controller_id, set_val.value),
                     });
                 }
@@ -100,7 +101,7 @@ mod tests {
     fn empty_track() {
         let track = Arc::new(RwLock::new(Track::default()));
         let mut source = TrackSource::new(track);
-        source.seek(&100_000u64);
+        source.seek(&100_000i64);
         assert_eq!(source.running_at, 100_000);
         source.seek(&0);
         assert_eq!(source.running_at, 0);
@@ -125,10 +126,10 @@ mod tests {
         source.seek(&0);
         assert_eq!(source.running_at, 0);
         assert_eq!(source.current_idx, 0);
-        source.seek(&100u64);
+        source.seek(&100i64);
         assert_eq!(source.running_at, 100);
         assert_eq!(source.current_idx, 0);
-        source.seek(&2000u64);
+        source.seek(&2000i64);
         assert_eq!(source.running_at, 2000);
         assert_eq!(source.current_idx, 1)
     }