Debian Codegraph @

au4/src/trackedit/internal/au3/au3interaction.cpp

raw
1 #include "au3interaction.h"
2
3 #include <algorithm>
4
5 #include "ProjectRate.h"
6 #include "TempoChange.h"
7 #include "QualitySettings.h"
8 #include "global/types/number.h"
9
10 #include "libraries/lib-project/Project.h"
11 #include "libraries/lib-wave-track/WaveTrack.h"
12 #include "libraries/lib-track/Track.h"
13 #include "libraries/lib-wave-track/WaveClip.h"
14
15 #include "au3wrap/internal/domaccessor.h"
16 #include "au3wrap/internal/domconverter.h"
17 #include "au3wrap/internal/wxtypes_convert.h"
18
19 #include "trackedit/dom/track.h"
20
21 #include "log.h"
22 #include "trackediterrors.h"
23 #include "translation.h"
24
25 using namespace au::trackedit;
26 using namespace au::au3;
27
28 AudacityProject& Au3Interaction::projectRef() const
29 {
30 AudacityProject* project = reinterpret_cast<AudacityProject*>(globalContext()->currentProject()->au3ProjectPtr());
31 return *project;
32 }
33
34 muse::Ret Au3Interaction::pasteIntoNewTrack()
35 {
36 auto& project = projectRef();
37 auto& tracks = ::TrackList::Get(project);
38 auto prj = globalContext()->currentTrackeditProject();
39 secs_t selectedStartTime = globalContext()->playbackState()->playbackPosition();
40
41 ::Track* pFirstNewTrack = NULL;
42 for (auto data : clipboard()->trackData()) {
43 auto pNewTrack = createNewTrackAndPaste(data.track, tracks, selectedStartTime);
44 if (!pFirstNewTrack) {
45 pFirstNewTrack = pNewTrack.get();
46 }
47
48 prj->onTrackAdded(DomConverter::track(pNewTrack.get()));
49 for (const auto& clip : prj->clipList(DomConverter::trackId(pNewTrack->GetId()))) {
50 prj->onClipAdded(clip);
51 }
52 }
53 selectionController()->setSelectedTrack(DomConverter::trackId(pFirstNewTrack->GetId()));
54
55 return muse::make_ok();
56 }
57
58 ::Track::Holder Au3Interaction::createNewTrackAndPaste(std::shared_ptr<::Track> track, ::TrackList& list, secs_t begin)
59 {
60 auto& trackFactory = WaveTrackFactory::Get(projectRef());
61 auto& pSampleBlockFactory = trackFactory.GetSampleBlockFactory();
62
63 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(DomConverter::trackId(track->GetId())));
64 IF_ASSERT_FAILED(waveTrack) {
65 return nullptr;
66 }
67 auto pFirstTrack = waveTrack->EmptyCopy(pSampleBlockFactory);
68 list.Add(pFirstTrack->SharedPointer());
69 pFirstTrack->Paste(begin, *track);
70 return pFirstTrack->SharedPointer();
71 }
72
73 std::vector<au::trackedit::TrackId> Au3Interaction::determineDestinationTracksIds(const std::vector<Track>& tracks,
74 TrackId destinationTrackId, size_t tracksNum) const
75 {
76 std::vector<TrackId> tracksIds;
77 bool addingEnabled = false;
78
79 for (const auto& track : tracks) {
80 if (track.id == destinationTrackId) {
81 addingEnabled = true;
82 }
83 if (addingEnabled) {
84 tracksIds.push_back(track.id);
85 if (tracksIds.size() == tracksNum) {
86 break;
87 }
88 }
89 }
90
91 return tracksIds;
92 }
93
94 muse::Ret Au3Interaction::canPasteClips(const std::vector<TrackId>& dstTracksIds, secs_t begin) const
95 {
96 for (size_t i = 0; i < dstTracksIds.size(); ++i) {
97 WaveTrack* dstWaveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(dstTracksIds[i]));
98 IF_ASSERT_FAILED(dstWaveTrack) {
99 return make_ret(trackedit::Err::WaveTrackNotFound);
100 }
101
102 secs_t insertDuration = clipboard()->trackData(i).track.get()->GetEndTime() - clipboard()->trackData(i).track.get()->GetStartTime();
103
104 // throws incosistency exception if project tempo is not set, see:
105 // au4/src/au3wrap/internal/au3project.cpp: 92
106 // Paste func throws exception if there's not enough space to paste in (exception handler calls BasicUI logic)
107 if (!dstWaveTrack->IsEmpty(begin, begin + insertDuration)) {
108 LOGD() << "Not enough space to paste clip into";
109 return make_ret(trackedit::Err::NotEnoughSpaceForPaste);
110 }
111
112 if (dstWaveTrack->NChannels() == 1 && clipboard()->trackData(i).track.get()->NChannels() == 2) {
113 return make_ret(trackedit::Err::StereoClipIntoMonoTrack);
114 }
115 }
116
117 return muse::make_ok();
118 }
119
120 au::audio::secs_t Au3Interaction::clipStartTime(const trackedit::ClipKey& clipKey) const
121 {
122 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(clipKey.trackId));
123 IF_ASSERT_FAILED(waveTrack) {
124 return -1.0;
125 }
126
127 std::shared_ptr<WaveClip> clip = DomAccessor::findWaveClip(waveTrack, clipKey.clipId);
128 IF_ASSERT_FAILED(clip) {
129 return -1.0;
130 }
131
132 return clip->Start();
133 }
134
135 bool Au3Interaction::changeClipStartTime(const trackedit::ClipKey& clipKey, secs_t newStartTime, bool completed)
136 {
137 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(clipKey.trackId));
138 IF_ASSERT_FAILED(waveTrack) {
139 return false;
140 }
141
142 std::shared_ptr<WaveClip> clip = DomAccessor::findWaveClip(waveTrack, clipKey.clipId);
143 IF_ASSERT_FAILED(clip) {
144 return false;
145 }
146
147 //! NOTE Let's check for intersection with the previous and next clips
148 //! Clips in AU3 model may not be sorted by time, so we need to get all clips and sort them by time
149 {
150 std::list<std::shared_ptr<WaveClip> > clips = DomAccessor::waveClipsAsList(waveTrack);
151
152 clips.sort([](const std::shared_ptr<WaveClip>& c1, const std::shared_ptr<WaveClip>& c2) {
153 return c1->GetPlayStartTime() < c2->GetPlayStartTime();
154 });
155
156 auto it = std::find_if(clips.begin(), clips.end(), [&clip](const std::shared_ptr<WaveClip>& c) {
157 return clip.get() == c.get();
158 });
159 IF_ASSERT_FAILED(it != clips.end()) {
160 return false;
161 }
162
163 //! NOTE If the new time is greater than the previous one, we check for an intersection with the next one
164 if (newStartTime > clip->GetPlayStartTime()) {
165 auto nextIt = ++it;
166 //! NOTE Let's check if the clip is not the last one
167 if (nextIt != clips.end()) {
168 std::shared_ptr<WaveClip> nextClip = *nextIt;
169 secs_t nextStartTime = nextClip->GetPlayStartTime();
170 secs_t deltaSec = newStartTime - clip->GetPlayStartTime();
171
172 // check collision
173 if ((clip->GetPlayEndTime() + deltaSec) > nextStartTime) {
174 //! NOTE If we have reached the limit, we do nothing.
175 //! TODO maybe there is a problem here, the end time of the clip may coincide with the start time of the next clip
176 if (muse::is_equal(clip->GetPlayEndTime(), nextStartTime.to_double())) {
177 LOGW() << "You can't change the clip time because it overlaps with the next one.";
178 return false;
179 }
180 //! NOTE If we haven't reached the limit yet, then it shifts as much as possible
181 else {
182 deltaSec = nextStartTime - clip->GetPlayEndTime();
183 newStartTime = clip->GetPlayStartTime() + deltaSec;
184 }
185 }
186 }
187 }
188
189 if (newStartTime < clip->GetPlayStartTime()) {
190 //! NOTE For the first clip, the end time is 0.0
191 secs_t prevEndTime = 0.0;
192 if (it != clips.begin()) {
193 auto prevIt = --it;
194 std::shared_ptr<WaveClip> pervClip = *prevIt;
195 prevEndTime = pervClip->GetPlayEndTime();
196 }
197
198 // check collision
199 if (newStartTime < prevEndTime) {
200 //! NOTE If we have reached the limit, we do nothing.
201 //! TODO maybe there is a problem here, the start time of the clip may coincide with the end time of the prev clip
202 if (muse::is_equal(clip->GetPlayStartTime(), prevEndTime.to_double())) {
203 LOGW() << "You can't change the clip time because it overlaps with the prev one.";
204 return false;
205 }
206 //! NOTE If we haven't reached the limit yet, then it shifts as much as possible
207 else {
208 newStartTime = prevEndTime;
209 }
210 }
211 }
212 }
213
214 //! TODO Not sure what this method needs to be called to change the position, will need to clarify
215 clip->SetPlayStartTime(newStartTime);
216 // LOGD() << "changed PlayStartTime of track: " << clipKey.trackId
217 // << " clip: " << clipKey.index
218 // << " new PlayStartTime: " << newStartTime;
219
220 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
221 prj->onClipChanged(DomConverter::clip(waveTrack, clip.get()));
222
223 m_clipStartTimeChanged.send(clipKey, newStartTime, completed);
224
225 if (completed) {
226 //! TODO AU4: later when having keyboard arrow shortcut for moving clips
227 //! make use of UndoPush::CONSOLIDATE arg in UndoManager
228 projectHistory()->pushHistoryState("Clip moved", "Move clip");
229 }
230
231 return true;
232 }
233
234 muse::async::Channel<au::trackedit::ClipKey, secs_t /*newStartTime*/, bool /*completed*/>
235 Au3Interaction::clipStartTimeChanged() const
236 {
237 return m_clipStartTimeChanged;
238 }
239
240 bool Au3Interaction::trimTrackData(TrackId trackId, secs_t begin, secs_t end)
241 {
242 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(trackId));
243 IF_ASSERT_FAILED(waveTrack) {
244 return false;
245 }
246
247 waveTrack->Trim(begin, end);
248
249 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
250 prj->onTrackChanged(DomConverter::track(waveTrack));
251
252 return true;
253 }
254
255 bool Au3Interaction::silenceTrackData(TrackId trackId, secs_t begin, secs_t end)
256 {
257 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(trackId));
258 IF_ASSERT_FAILED(waveTrack) {
259 return false;
260 }
261
262 waveTrack->Silence(begin, end, {});
263
264 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
265 prj->onTrackChanged(DomConverter::track(waveTrack));
266
267 return true;
268 }
269
270 bool Au3Interaction::changeClipTitle(const trackedit::ClipKey& clipKey, const muse::String& newTitle)
271 {
272 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(clipKey.trackId));
273 IF_ASSERT_FAILED(waveTrack) {
274 return false;
275 }
276
277 std::shared_ptr<WaveClip> clip = DomAccessor::findWaveClip(waveTrack, clipKey.clipId);
278 IF_ASSERT_FAILED(clip) {
279 return false;
280 }
281
282 clip->SetName(wxFromString(newTitle));
283 LOGD() << "changed name of clip: " << clipKey.clipId << ", track: " << clipKey.trackId;
284
285 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
286 prj->onClipChanged(DomConverter::clip(waveTrack, clip.get()));
287
288 return true;
289 }
290
291 void Au3Interaction::clearClipboard()
292 {
293 clipboard()->clearTrackData();
294 }
295
296 muse::Ret Au3Interaction::pasteFromClipboard(secs_t begin, TrackId destinationTrackId)
297 {
298 if (clipboard()->trackDataEmpty()) {
299 return make_ret(trackedit::Err::TrackEmpty);
300 }
301
302 if (destinationTrackId == -1) {
303 return pasteIntoNewTrack();
304 }
305
306 project::IAudacityProjectPtr project = globalContext()->currentProject();
307 //! TODO: we need to make sure that we get a trackList with order
308 //! the same as in the TrackPanel
309 auto tracks = project->trackeditProject()->trackList();
310 size_t tracksNum = clipboard()->trackDataSize();
311
312 // for multiple tracks copying
313 std::vector<TrackId> dstTracksIds = determineDestinationTracksIds(tracks, destinationTrackId, tracksNum);
314
315 bool newTracksNeeded = false;
316 size_t newTracksCount = 0;
317 if (dstTracksIds.size() != tracksNum) {
318 newTracksNeeded = true;
319 newTracksCount = tracksNum - dstTracksIds.size();
320 }
321
322 // check if copied data fits into selected area
323 auto ret = canPasteClips(dstTracksIds, begin);
324 if (!ret) {
325 return ret;
326 }
327
328 for (size_t i = 0; i < dstTracksIds.size(); ++i) {
329 WaveTrack* dstWaveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(dstTracksIds[i]));
330 IF_ASSERT_FAILED(dstWaveTrack) {
331 return make_ret(trackedit::Err::WaveTrackNotFound);
332 }
333 auto prj = globalContext()->currentTrackeditProject();
334
335 // use an unordered_set to store the IDs of the clips before the paste
336 std::unordered_set<int> clipIdsBefore;
337 for (const auto& clip : prj->clipList(dstTracksIds[i])) {
338 clipIdsBefore.insert(clip.key.clipId);
339 }
340
341 if (clipboard()->trackData(i).track.get()->NChannels() == 1 && dstWaveTrack->NChannels() == 2) {
342 // When the source is mono, may paste its only channel
343 // repeatedly into a stereo track
344 const auto pastedTrack = std::static_pointer_cast<WaveTrack>(clipboard()->trackData(i).track);
345 pastedTrack->MonoToStereo();
346 dstWaveTrack->Paste(begin, *pastedTrack);
347 } else {
348 dstWaveTrack->Paste(begin, *clipboard()->trackData(i).track);
349 }
350
351 // Check which clips were added and trigger the onClipAdded event
352 for (const auto& clip : prj->clipList(dstTracksIds[i])) {
353 if (clipIdsBefore.find(clip.key.clipId) == clipIdsBefore.end()) {
354 prj->onClipAdded(clip);
355 }
356 }
357 }
358
359 if (newTracksNeeded) {
360 // remove already pasted elements from the clipboard and paste the rest into the new tracks
361 clipboard()->eraseTrackData(clipboard()->trackData().begin(), clipboard()->trackData().begin() + dstTracksIds.size());
362 return pasteIntoNewTrack();
363 }
364
365 return muse::make_ok();
366 }
367
368 bool Au3Interaction::cutClipIntoClipboard(const ClipKey &clipKey)
369 {
370 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(clipKey.trackId));
371 IF_ASSERT_FAILED(waveTrack) {
372 return false;
373 }
374
375 std::shared_ptr<WaveClip> clip = DomAccessor::findWaveClip(waveTrack, clipKey.clipId);
376 IF_ASSERT_FAILED(clip) {
377 return false;
378 }
379
380 auto track = waveTrack->Cut(clip->Start(), clip->End());
381 clipboard()->addTrackData(TrackData { track, clipKey });
382
383 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
384 prj->onClipRemoved(DomConverter::clip(waveTrack, clip.get()));
385 projectHistory()->pushHistoryState("Cut to the clipboard", "Cut");
386
387 return true;
388 }
389
390 bool Au3Interaction::cutClipDataIntoClipboard(const std::vector<TrackId> &tracksIds, secs_t begin, secs_t end)
391 {
392 for (const auto& trackId : tracksIds) {
393 bool ok = cutTrackDataIntoClipboard(trackId, begin, end);
394 if (!ok) {
395 return false;
396 }
397 }
398
399 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
400 projectHistory()->pushHistoryState("Cut to the clipboard", "Cut");
401
402 return true;
403 }
404
405 bool Au3Interaction::cutTrackDataIntoClipboard(const TrackId trackId, secs_t begin, secs_t end)
406 {
407 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(trackId));
408 IF_ASSERT_FAILED(waveTrack) {
409 return false;
410 }
411
412 auto track = waveTrack->Cut(begin, end);
413 trackedit::ClipKey dummyClipKey = trackedit::ClipKey();
414 clipboard()->addTrackData(TrackData { track, dummyClipKey });
415
416 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
417 prj->onTrackChanged(DomConverter::track(waveTrack));
418
419 return true;
420 }
421
422 bool Au3Interaction::copyClipIntoClipboard(const ClipKey& clipKey)
423 {
424 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(clipKey.trackId));
425 IF_ASSERT_FAILED(waveTrack) {
426 return false;
427 }
428
429 std::shared_ptr<WaveClip> clip = DomAccessor::findWaveClip(waveTrack, clipKey.clipId);
430 IF_ASSERT_FAILED(clip) {
431 return false;
432 }
433
434 auto track = waveTrack->Copy(clip->Start(), clip->End());
435 clipboard()->addTrackData(TrackData { track, clipKey });
436
437 return true;
438 }
439
440 bool Au3Interaction::copyClipDataIntoClipboard(const ClipKey& clipKey, secs_t begin, secs_t end)
441 {
442 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(clipKey.trackId));
443 IF_ASSERT_FAILED(waveTrack) {
444 return false;
445 }
446
447 std::shared_ptr<WaveClip> clip = DomAccessor::findWaveClip(waveTrack, clipKey.clipId);
448 IF_ASSERT_FAILED(clip) {
449 return false;
450 }
451
452 auto track = waveTrack->Copy(begin, end);
453 clipboard()->addTrackData(TrackData { track, clipKey });
454
455 return true;
456 }
457
458 bool Au3Interaction::copyTrackDataIntoClipboard(const TrackId trackId, secs_t begin, secs_t end)
459 {
460 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(trackId));
461 IF_ASSERT_FAILED(waveTrack) {
462 return false;
463 }
464
465 auto track = waveTrack->Copy(begin, end);
466 trackedit::ClipKey dummyClipKey = trackedit::ClipKey();
467 clipboard()->addTrackData(TrackData { track, dummyClipKey });
468
469 return true;
470 }
471
472 bool Au3Interaction::removeClip(const trackedit::ClipKey& clipKey)
473 {
474 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(clipKey.trackId));
475 IF_ASSERT_FAILED(waveTrack) {
476 return false;
477 }
478
479 std::shared_ptr<WaveClip> clip = DomAccessor::findWaveClip(waveTrack, clipKey.clipId);
480 IF_ASSERT_FAILED(clip) {
481 return false;
482 }
483
484 waveTrack->Clear(clip->Start(), clip->End());
485
486 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
487 prj->onTrackChanged(DomConverter::track(waveTrack));
488
489 return true;
490 }
491
492 bool Au3Interaction::removeClipData(const trackedit::ClipKey& clipKey, secs_t begin, secs_t end)
493 {
494 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(clipKey.trackId));
495 IF_ASSERT_FAILED(waveTrack) {
496 return false;
497 }
498
499 std::shared_ptr<WaveClip> clip = DomAccessor::findWaveClip(waveTrack, clipKey.clipId);
500 IF_ASSERT_FAILED(clip) {
501 return false;
502 }
503
504 waveTrack->Clear(begin, end);
505
506 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
507 prj->onTrackChanged(DomConverter::track(waveTrack));
508
509 return true;
510 }
511
512 bool Au3Interaction::splitAt(TrackId trackId, secs_t pivot)
513 {
514 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(trackId));
515 IF_ASSERT_FAILED(waveTrack) {
516 return false;
517 }
518
519 waveTrack->SplitAt(pivot);
520
521 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
522 prj->onTrackChanged(DomConverter::track(waveTrack));
523
524 projectHistory()->pushHistoryState("Split", "Split");
525
526 return true;
527 }
528
529 bool Au3Interaction::mergeSelectedOnTrack(const TrackId trackId, secs_t begin, secs_t end)
530 {
531 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(trackId));
532 IF_ASSERT_FAILED(waveTrack) {
533 return false;
534 }
535
536 //! TODO fix this so it displays progress if there's
537 //! a need to change pitch/speed
538 ProgressReporter dummyProgressReporter;
539 waveTrack->Join(begin, end, dummyProgressReporter);
540
541 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
542 prj->onTrackChanged(DomConverter::track(waveTrack));
543
544 return true;
545 }
546
547 bool Au3Interaction::duplicateSelectedOnTrack(const TrackId trackId, secs_t begin, secs_t end)
548 {
549 auto& tracks = ::TrackList::Get(projectRef());
550 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(trackId));
551 IF_ASSERT_FAILED(waveTrack) {
552 return false;
553 }
554
555 auto dest = waveTrack->Copy(begin, end, false);
556 dest->MoveTo(std::max(static_cast<double>(begin), waveTrack->GetStartTime()));
557 tracks.Add(dest);
558
559 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
560 prj->onTrackAdded(DomConverter::track(dest.get()));
561 }
562
563 bool Au3Interaction::splitCutSelectedOnTrack(const TrackId trackId, secs_t begin, secs_t end)
564 {
565 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(trackId));
566 IF_ASSERT_FAILED(waveTrack) {
567 return false;
568 }
569
570 auto track = waveTrack->SplitCut(begin, end);
571 trackedit::ClipKey dummyClipKey = trackedit::ClipKey();
572 clipboard()->addTrackData(TrackData { track, dummyClipKey });
573
574 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
575 prj->onTrackChanged(DomConverter::track(waveTrack));
576
577 return true;
578 }
579
580 bool Au3Interaction::splitDeleteSelectedOnTrack(const TrackId trackId, secs_t begin, secs_t end)
581 {
582 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(trackId));
583 IF_ASSERT_FAILED(waveTrack) {
584 return false;
585 }
586
587 waveTrack->SplitDelete(begin, end);
588
589 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
590 prj->onTrackChanged(DomConverter::track(waveTrack));
591
592 return true;
593 }
594
595 bool Au3Interaction::mergeSelectedOnTracks(const std::vector<TrackId> tracksIds, secs_t begin, secs_t end)
596 {
597 secs_t duration = end - begin;
598
599 for (const auto& trackId : tracksIds) {
600 bool ok = mergeSelectedOnTrack(trackId, begin, end);
601 if (!ok) {
602 return false;
603 }
604 }
605
606 pushProjectHistoryJoinState(begin, duration);
607
608 return true;
609 }
610
611 bool Au3Interaction::duplicateSelectedOnTracks(const std::vector<TrackId> tracksIds, secs_t begin, secs_t end)
612 {
613 for (const auto& trackId : tracksIds) {
614 bool ok = duplicateSelectedOnTrack(trackId, begin, end);
615 if (!ok) {
616 return false;
617 }
618 }
619
620 pushProjectHistoryDuplicateState();
621
622 return true;
623 }
624
625 bool Au3Interaction::duplicateClip(const ClipKey &clipKey)
626 {
627 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(clipKey.trackId));
628 IF_ASSERT_FAILED(waveTrack) {
629 return false;
630 }
631
632 std::shared_ptr<WaveClip> clip = DomAccessor::findWaveClip(waveTrack, clipKey.clipId);
633 IF_ASSERT_FAILED(clip) {
634 return false;
635 }
636
637 trackedit::secs_t begin = clip->Start();
638 trackedit::secs_t end = clip->End();
639
640 bool ok = duplicateSelectedOnTrack(clipKey.trackId, begin, end);
641 if (!ok) {
642 return false;
643 }
644
645 pushProjectHistoryDuplicateState();
646 }
647
648 bool Au3Interaction::clipSplitCut(const ClipKey &clipKey)
649 {
650 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(clipKey.trackId));
651 IF_ASSERT_FAILED(waveTrack) {
652 return false;
653 }
654
655 std::shared_ptr<WaveClip> clip = DomAccessor::findWaveClip(waveTrack, clipKey.clipId);
656 IF_ASSERT_FAILED(clip) {
657 return false;
658 }
659
660 auto track = waveTrack->SplitCut(clip->Start(), clip->End());
661 trackedit::ClipKey dummyClipKey = trackedit::ClipKey();
662 clipboard()->addTrackData(TrackData { track, dummyClipKey });
663
664 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
665 prj->onTrackChanged(DomConverter::track(waveTrack));
666
667 projectHistory()->pushHistoryState("Split-cut to the clipboard", "Split cut");
668
669 return true;
670 }
671
672 bool Au3Interaction::clipSplitDelete(const ClipKey &clipKey)
673 {
674 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(clipKey.trackId));
675 IF_ASSERT_FAILED(waveTrack) {
676 return false;
677 }
678
679 std::shared_ptr<WaveClip> clip = DomAccessor::findWaveClip(waveTrack, clipKey.clipId);
680 IF_ASSERT_FAILED(clip) {
681 return false;
682 }
683
684 waveTrack->SplitDelete(clip->Start(), clip->End());
685
686 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
687 prj->onTrackChanged(DomConverter::track(waveTrack));
688
689 pushProjectHistorySplitDeleteState(clip->Start(), clip->End() - clip->Start());
690
691 return true;
692 }
693
694 bool Au3Interaction::splitCutSelectedOnTracks(const std::vector<TrackId> tracksIds, secs_t begin, secs_t end)
695 {
696 for (const auto& trackId : tracksIds) {
697 bool ok = splitCutSelectedOnTrack(trackId, begin, end);
698 if (!ok) {
699 return false;
700 }
701 }
702
703 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
704 projectHistory()->pushHistoryState("Split-cut to the clipboard", "Split cut");
705
706 return true;
707 }
708
709 bool Au3Interaction::splitDeleteSelectedOnTracks(const std::vector<TrackId> tracksIds, secs_t begin, secs_t end)
710 {
711 secs_t duration = end - begin;
712
713 for (const auto& trackId : tracksIds) {
714 bool ok = splitDeleteSelectedOnTrack(trackId, begin, end);
715 if (!ok) {
716 return false;
717 }
718 }
719
720 pushProjectHistorySplitDeleteState(begin, duration);
721
722 return true;
723 }
724
725 bool Au3Interaction::trimClipLeft(const ClipKey& clipKey, secs_t deltaSec, bool completed)
726 {
727 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(clipKey.trackId));
728 IF_ASSERT_FAILED(waveTrack) {
729 return false;
730 }
731
732 std::shared_ptr<WaveClip> clip = DomAccessor::findWaveClip(waveTrack, clipKey.clipId);
733 IF_ASSERT_FAILED(clip) {
734 return false;
735 }
736
737 clip->TrimLeft(deltaSec);
738
739 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
740 prj->onClipChanged(DomConverter::clip(waveTrack, clip.get()));
741
742 if (completed) {
743 projectHistory()->pushHistoryState("Clip trimmed", "Trim clip");
744 }
745
746 return true;
747 }
748
749 bool Au3Interaction::trimClipRight(const ClipKey& clipKey, secs_t deltaSec, bool completed)
750 {
751 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(clipKey.trackId));
752 IF_ASSERT_FAILED(waveTrack) {
753 return false;
754 }
755
756 std::shared_ptr<WaveClip> clip = DomAccessor::findWaveClip(waveTrack, clipKey.clipId);
757 IF_ASSERT_FAILED(clip) {
758 return false;
759 }
760
761 clip->TrimRight(deltaSec);
762
763 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
764 prj->onClipChanged(DomConverter::clip(waveTrack, clip.get()));
765
766 if (completed) {
767 projectHistory()->pushHistoryState("Clip trimmed", "Trim clip");
768 }
769
770 return true;
771 }
772
773 void Au3Interaction::newMonoTrack()
774 {
775 auto& project = projectRef();
776 auto& tracks = ::TrackList::Get(project);
777 auto& trackFactory = ::WaveTrackFactory::Get(project);
778
779 sampleFormat defaultFormat = QualitySettings::SampleFormatChoice();
780 auto rate = ::ProjectRate::Get(project).GetRate();
781
782 auto track = trackFactory.Create(defaultFormat, rate);
783 track->SetName(tracks.MakeUniqueTrackName(WaveTrack::GetDefaultAudioTrackNamePreference()));
784
785 tracks.Add(track);
786
787 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
788 prj->onTrackAdded(DomConverter::track(track.get()));
789
790 selectionController()->setSelectedTrack(DomConverter::trackId(track->GetId()));
791 }
792
793 void Au3Interaction::newStereoTrack()
794 {
795 auto& project = projectRef();
796 auto& tracks = ::TrackList::Get(project);
797 auto& trackFactory = ::WaveTrackFactory::Get(project);
798
799 sampleFormat defaultFormat = QualitySettings::SampleFormatChoice();
800 auto rate = ::ProjectRate::Get(project).GetRate();
801
802 tracks.Add(trackFactory.Create(2, defaultFormat, rate));
803 auto& newTrack = **tracks.rbegin();
804 newTrack.SetName(tracks.MakeUniqueTrackName(WaveTrack::GetDefaultAudioTrackNamePreference()));
805
806 trackedit::ITrackeditProjectPtr prj = globalContext()->currentTrackeditProject();
807 auto track = *tracks.rbegin();
808 prj->onTrackAdded(DomConverter::track(track));
809
810 selectionController()->setSelectedTrack(DomConverter::trackId(track->GetId()));
811 }
812
813 void Au3Interaction::newLabelTrack()
814 {
815 NOT_IMPLEMENTED;
816 }
817
818 au::audio::secs_t Au3Interaction::clipDuration(const trackedit::ClipKey& clipKey) const
819 {
820 WaveTrack* waveTrack = DomAccessor::findWaveTrack(projectRef(), ::TrackId(clipKey.trackId));
821 IF_ASSERT_FAILED(waveTrack) {
822 return -1.0;
823 }
824
825 std::shared_ptr<WaveClip> clip = DomAccessor::findWaveClip(waveTrack, clipKey.clipId);
826 IF_ASSERT_FAILED(clip) {
827 return -1.0;
828 }
829
830 return clip->End() - clip->Start();
831 }
832
833 void Au3Interaction::pushProjectHistoryJoinState(secs_t start, secs_t duration)
834 {
835 std::stringstream ss;
836 ss << "Joined " << duration << " seconds at " << start;
837
838 projectHistory()->pushHistoryState(ss.str(), "Join");
839 }
840
841 void Au3Interaction::undo()
842 {
843 if (!projectHistory()->undoAvailable()) {
844 interactive()->error(muse::trc("undo", "Undo"), std::string("Undo not available"));
845 return;
846 }
847
848 auto trackeditProject = globalContext()->currentProject()->trackeditProject();
849
850 // Find the index of the currently selected track in the old list
851 auto trackIdList = trackeditProject->trackIdList();
852 int selectedIndex = std::distance(trackIdList.begin(),
853 std::find(trackIdList.begin(),
854 trackIdList.end(),
855 selectionController()->selectedTrack()));
856
857 projectHistory()->undo();
858
859 // Undo removes all tracks from current state and
860 // inserts tracks from the previous state so we need
861 // to reload whole model
862 trackeditProject->reload();
863
864 // Update selected track id
865 auto newTrackIdList = trackeditProject->trackIdList();
866 if (selectedIndex >= 0 && selectedIndex < newTrackIdList.size()) {
867 selectionController()->setSelectedTrack(newTrackIdList[selectedIndex]);
868 } else {
869 selectionController()->resetSelectedTrack();
870 }
871 }
872
873 void Au3Interaction::redo()
874 {
875 if (!projectHistory()->redoAvailable()) {
876 interactive()->error(muse::trc("redo", "Redo"), std::string("Redo not available"));
877 return;
878 }
879
880 auto trackeditProject = globalContext()->currentProject()->trackeditProject();
881
882 // Find the index of the currently selected track in the old list
883 auto trackIdList = trackeditProject->trackIdList();
884 int selectedIndex = std::distance(trackIdList.begin(),
885 std::find(trackIdList.begin(),
886 trackIdList.end(),
887 selectionController()->selectedTrack()));
888
889 projectHistory()->redo();
890
891 // Redo removes all tracks from current state and
892 // inserts tracks from the previous state so we need
893 // to reload whole model
894 trackeditProject->reload();
895
896 // Update selected track id
897 auto newTrackIdList = trackeditProject->trackIdList();
898 if (selectedIndex >= 0 && selectedIndex < newTrackIdList.size()) {
899 selectionController()->setSelectedTrack(newTrackIdList[selectedIndex]);
900 } else {
901 selectionController()->resetSelectedTrack();
902 }
903 }
904
905 void Au3Interaction::pushProjectHistoryDuplicateState()
906 {
907 projectHistory()->pushHistoryState("Duplicated", "Duplicate");
908 }
909
910 void Au3Interaction::pushProjectHistorySplitDeleteState(secs_t start, secs_t duration)
911 {
912 std::stringstream ss;
913 ss << "Split-deleted " << duration << " seconds at " << start;
914
915 projectHistory()->pushHistoryState(ss.str(), "Split delete");
916 }