1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
use scene::{Element, Project, SceneTracks, Track};
use time::MediaTime;
use timeline::TrackType;
use timeline::placement::build_empty_track;
use crate::command::{Command, CommandError, CommandResult};
use crate::project_ext::active_scene_mut;
use crate::tracks::{all_tracks_mut, find_track};
#[derive(Clone, Debug, PartialEq)]
pub struct PlannedTrackCreation {
pub id: String,
pub track_type: TrackType,
pub index: usize,
}
#[derive(Clone, Debug, PartialEq)]
pub struct PlannedElementMove {
pub source_track_id: String,
pub target_track_id: String,
pub element_id: String,
pub new_start_time: MediaTime,
}
fn insert_track_at_display_index(
tracks: &mut SceneTracks,
track: Track,
insert_index: usize,
) {
if matches!(track, Track::Audio { .. }) {
let audio_insert_index = insert_index
.saturating_sub(tracks.overlay.len() + 1)
.min(tracks.audio.len());
tracks.audio.insert(audio_insert_index, track);
return;
}
let overlay_insert_index = insert_index.min(tracks.overlay.len());
tracks.overlay.insert(overlay_insert_index, track);
}
fn validate_compatibility(element: &Element, track: &Track) -> Result<(), CommandError> {
let compatibility = timeline::placement::validate_element_track_compatibility(
timeline::ElementType::of_element(element),
timeline::TrackType::of_track(track),
);
if compatibility.is_valid {
return Ok(());
}
Err(CommandError::IncompatiblePlacement(
compatibility.error_message.unwrap_or_default(),
))
}
pub struct MoveElementCommand {
moves: Vec<PlannedElementMove>,
create_tracks: Vec<PlannedTrackCreation>,
saved_state: Option<SceneTracks>,
}
impl MoveElementCommand {
pub fn new(moves: Vec<PlannedElementMove>, create_tracks: Vec<PlannedTrackCreation>) -> Self {
Self {
moves,
create_tracks,
saved_state: None,
}
}
}
impl Command for MoveElementCommand {
fn execute(
&mut self,
project: &mut Project,
) -> Result<Option<CommandResult>, CommandError> {
let Some(scene) = active_scene_mut(project) else {
return Ok(None);
};
let saved_state = scene.tracks.clone();
self.saved_state = Some(saved_state.clone());
let mut create_tracks = self.create_tracks.clone();
create_tracks.sort_by_key(|creation| creation.index);
for creation in &create_tracks {
let track = build_empty_track(creation.id.clone(), creation.track_type, None);
insert_track_at_display_index(&mut scene.tracks, track, creation.index);
}
let mut moved_elements = Vec::new();
for planned_move in &self.moves {
let source_track = find_track(&saved_state, &planned_move.source_track_id);
let source_element = source_track.and_then(|track| {
track
.elements()
.iter()
.find(|element| element.base().id == planned_move.element_id)
});
let Some(source_element) = source_element else {
return Err(CommandError::SourceNotFound);
};
let Some(target_track) = find_track(&scene.tracks, &planned_move.target_track_id)
else {
return Err(CommandError::TargetTrackNotFound);
};
validate_compatibility(source_element, target_track)?;
let mut moved = source_element.clone();
moved.base_mut().start_time = planned_move.new_start_time;
moved_elements.push((planned_move.target_track_id.clone(), moved));
}
let moved_ids: Vec<&str> = self
.moves
.iter()
.map(|planned_move| planned_move.element_id.as_str())
.collect();
for track in all_tracks_mut(&mut scene.tracks) {
let track_id = track.id().to_string();
let mut elements = std::mem::take(track.elements_mut());
elements.retain(|element| !moved_ids.contains(&element.base().id.as_str()));
elements.extend(
moved_elements
.iter()
.filter(|(target_track_id, _)| *target_track_id == track_id)
.map(|(_, element)| element.clone()),
);
*track.elements_mut() = elements;
}
Ok(Some(CommandResult::element_selection(
self.moves
.iter()
.map(|planned_move| scene::ElementRef {
track_id: planned_move.target_track_id.clone(),
element_id: planned_move.element_id.clone(),
})
.collect(),
)))
}
fn undo(&mut self, project: &mut Project) {
let Some(saved) = &self.saved_state else {
return;
};
if let Some(scene) = active_scene_mut(project) {
scene.tracks = saved.clone();
}
}
}
|
