EditActions::Handler Struct Reference

Inheritance diagram for EditActions::Handler:

Collaboration diagram for EditActions::Handler:

Public Member Functions
void	OnUndo (const CommandContext &context)
void	OnRedo (const CommandContext &context)
void	OnCut (const CommandContext &context)
void	OnDelete (const CommandContext &context)
void	OnCopy (const CommandContext &context)
std::pair< double, double >	FindSelection (const CommandContext &context)
void	OnPaste (const CommandContext &context)
void	OnDuplicate (const CommandContext &context)
void	OnSplitCut (const CommandContext &context)
void	OnSplitDelete (const CommandContext &context)
void	OnSilence (const CommandContext &context)
void	OnTrim (const CommandContext &context)
void	OnSplit (const CommandContext &context)
void	OnSplitNew (const CommandContext &context)
void	OnJoin (const CommandContext &context)
void	OnDisjoin (const CommandContext &context)
void	OnEditMetadata (const CommandContext &context)
void	OnPreferences (const CommandContext &context)

Detailed Description

Definition at line 141 of file EditMenus.cpp.

Member Function Documentation

FindSelection()

std::pair< double, double > EditActions::Handler::FindSelection ( const CommandContext &  context )

inline

Definition at line 373 of file EditMenus.cpp.

{
   double sel0 = 0.0, sel1 = 0.0;
   
#if 0
   // Use the overriding selection if any was given in the context
   if (auto *pRegion = context.temporarySelection.pSelectedRegion) {
      auto &selectedRegion = *pRegion;
      sel0 = selectedRegion.t0();
      sel1 = selectedRegion.t1();
   }
   else
#endif
   {
      auto &selectedRegion = ViewInfo::Get(context.project).selectedRegion;
      sel0 = selectedRegion.t0();
      sel1 = selectedRegion.t1();
   }
   
   return { sel0, sel1 };
}

References ViewInfo::Get(), CommandContext::project, TemporarySelection::pSelectedRegion, ViewInfo::selectedRegion, NotifyingSelectedRegion::t0(), and CommandContext::temporarySelection.

Referenced by OnPaste().

Here is the call graph for this function:

Here is the caller graph for this function:

OnCopy()

void EditActions::Handler::OnCopy ( const CommandContext &  context )

inline

Definition at line 328 of file EditMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
   auto &trackPanel = TrackPanel::Get( project );
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
 
   for (auto lt : tracks.Selected< LabelTrack >()) {
      auto &view = LabelTrackView::Get( *lt );
      if (view.CopySelectedText( context.project )) {
         //trackPanel.Refresh(false);
         return;
      }
   }
   //Presumably, there might be not more than one track
   //that expects text input
   for (auto wt : tracks.Any<WaveTrack>()) {
      auto& view = WaveTrackView::Get(*wt);
      if (view.CopySelectedText(context.project)) {
         return;
      }
   }
 
   auto &clipboard = Clipboard::Get();
   clipboard.Clear();
 
   auto pNewClipboard = TrackList::Create( nullptr );
   auto &newClipboard = *pNewClipboard;
 
   for (auto n : tracks.Selected()) {
      if (n->SupportsBasicEditing()) {
         auto dest = n->Copy(selectedRegion.t0(),
                 selectedRegion.t1());
         FinishCopy(n, dest, newClipboard);
      }
   }
 
   // Survived possibility of exceptions.  Commit changes to the clipboard now.
   clipboard.Assign( std::move( newClipboard ),
      selectedRegion.t0(), selectedRegion.t1(), project.shared_from_this() );
 
   //Make sure the menus/toolbar states get updated
   trackPanel.Refresh(false);
}

References TrackList::Create(), anonymous_namespace{EditMenus.cpp}::FinishCopy(), Clipboard::Get(), ViewInfo::Get(), TrackList::Get(), TrackPanel::Get(), LabelTrackView::Get(), WaveTrackView::Get(), CommandContext::project, and ViewInfo::selectedRegion.

Here is the call graph for this function:

OnCut()

void EditActions::Handler::OnCut ( const CommandContext &  context )

inline

Definition at line 203 of file EditMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
   auto &trackPanel = TrackPanel::Get( project );
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
   auto &ruler = AdornedRulerPanel::Get( project );
   auto &window = ProjectWindow::Get( project );
 
   // This doesn't handle cutting labels, it handles
   // cutting the _text_ inside of labels, i.e. if you're
   // in the middle of editing the label text and select "Cut".
 
   for (auto lt : tracks.Selected< LabelTrack >()) {
      auto &view = LabelTrackView::Get( *lt );
      if (view.CutSelectedText( context.project )) {
         trackPanel.Refresh(false);
         return;
      }
   }
 
   //Presumably, there might be not more than one track
   //that expects text input
   for (auto wt : tracks.Any<WaveTrack>()) {
      auto& view = WaveTrackView::Get(*wt);
      if (view.CutSelectedText(context.project)) {
         trackPanel.Refresh(false);
         return;
      }
   }
 
   auto &clipboard = Clipboard::Get();
   clipboard.Clear();
 
   auto pNewClipboard = TrackList::Create( nullptr );
   auto &newClipboard = *pNewClipboard;
 
   tracks.Selected().Visit(
#if defined(USE_MIDI)
      [&](NoteTrack *n) {
         // Since portsmf has a built-in cut operator, we use that instead
         auto dest = n->Cut(selectedRegion.t0(),
                selectedRegion.t1());
         FinishCopy(n, dest, newClipboard);
      },
#endif
      [&](Track *n) {
         if (n->SupportsBasicEditing()) {
            auto dest = n->Copy(selectedRegion.t0(),
                    selectedRegion.t1());
            FinishCopy(n, dest, newClipboard);
         }
      }
   );
 
   // Survived possibility of exceptions.  Commit changes to the clipboard now.
   clipboard.Assign(
       std::move( newClipboard ),
       selectedRegion.t0(),
       selectedRegion.t1(),
       project.shared_from_this()
   );
 
   // Proceed to change the project.  If this throws, the project will be
   // rolled back by the top level handler.
 
   (tracks.Any() + &SyncLock::IsSelectedOrSyncLockSelected).Visit(
#if defined(USE_MIDI)
      [](NoteTrack*) {
         //if NoteTrack, it was cut, so do not clear anything
 
         // PRL:  But what if it was sync lock selected only, not selected?
      },
#endif
      [&](WaveTrack *wt, const Track::Fallthrough &fallthrough) {
         if (gPrefs->Read(wxT("/GUI/EnableCutLines"), (long)0)) {
            wt->ClearAndAddCutLine(
               selectedRegion.t0(),
               selectedRegion.t1());
         }
         else
            fallthrough();
      },
      [&](Track *n) {
         if (n->SupportsBasicEditing())
            n->Clear(selectedRegion.t0(), selectedRegion.t1());
      }
   );
 
   selectedRegion.collapseToT0();
 
   ProjectHistory::Get( project )
      .PushState(XO("Cut to the clipboard"), XO("Cut"));
 
   // Bug 1663
   //mRuler->ClearPlayRegion();
   ruler.DrawOverlays( true );
}

References NoteTrack::Clear(), WaveTrack::ClearAndAddCutLine(), NoteTrack::Copy(), TrackList::Create(), NoteTrack::Cut(), anonymous_namespace{EditMenus.cpp}::FinishCopy(), Clipboard::Get(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), AdornedRulerPanel::Get(), ProjectWindow::Get(), TrackPanel::Get(), LabelTrackView::Get(), WaveTrackView::Get(), gPrefs, SyncLock::IsSelectedOrSyncLockSelected(), CommandContext::project, ProjectHistory::PushState(), anonymous_namespace{TimeTrackVRulerControls.cpp}::ruler(), ViewInfo::selectedRegion, Track::SupportsBasicEditing(), Visit(), wxT(), and XO.

Here is the call graph for this function:

OnDelete()

void EditActions::Handler::OnDelete ( const CommandContext &  context )

inline

Definition at line 302 of file EditMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
   auto &window = ProjectWindow::Get( project );
 
   for (auto n : tracks.Any()) {
      if (!n->SupportsBasicEditing())
         continue;
      if (SyncLock::IsSelectedOrSyncLockSelected(n)) {
         n->Clear(selectedRegion.t0(), selectedRegion.t1());
      }
   }
 
   double seconds = selectedRegion.duration();
 
   selectedRegion.collapseToT0();
 
   ProjectHistory::Get( project ).PushState(
      XO("Deleted %.2f seconds at t=%.2f")
         .Format( seconds, selectedRegion.t0()),
      XO("Delete"));
}

References ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), ProjectWindow::Get(), SyncLock::IsSelectedOrSyncLockSelected(), CommandContext::project, ProjectHistory::PushState(), ViewInfo::selectedRegion, and XO.

Here is the call graph for this function:

OnDisjoin()

void EditActions::Handler::OnDisjoin ( const CommandContext &  context )

inline

Definition at line 944 of file EditMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
   auto &window = ProjectWindow::Get( project );
 
   for (auto wt : tracks.Selected< WaveTrack >())
      wt->Disjoin(selectedRegion.t0(),
                  selectedRegion.t1());
 
   ProjectHistory::Get( project ).PushState(
      XO("Detached %.2f seconds at t=%.2f")
         .Format( selectedRegion.duration(), selectedRegion.t0() ),
      XO("Detach"));
}

References ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), ProjectWindow::Get(), CommandContext::project, ProjectHistory::PushState(), ViewInfo::selectedRegion, and XO.

Here is the call graph for this function:

OnDuplicate()

void EditActions::Handler::OnDuplicate ( const CommandContext &  context )

inline

Definition at line 669 of file EditMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
   auto &window = ProjectWindow::Get( project );
 
   // This iteration is unusual because we add to the list inside the loop
   auto range = tracks.Selected();
   auto last = *range.rbegin();
   for (auto n : range) {
      if (!n->SupportsBasicEditing())
         continue;
 
      // Make copies not for clipboard but for direct addition to the project
      auto dest = n->Copy(selectedRegion.t0(),
              selectedRegion.t1(), false);
      dest->Init(*n);
      dest->SetOffset(wxMax(selectedRegion.t0(), n->GetOffset()));
      tracks.Add( dest );
 
      // This break is really needed, else we loop infinitely
      if (n == last)
         break;
   }
 
   ProjectHistory::Get( project )
      .PushState(XO("Duplicated"), XO("Duplicate"));
}

References ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), ProjectWindow::Get(), CommandContext::project, ProjectHistory::PushState(), ViewInfo::selectedRegion, and XO.

Here is the call graph for this function:

OnEditMetadata()

void EditActions::Handler::OnEditMetadata ( const CommandContext &  context )

inline

Definition at line 961 of file EditMenus.cpp.

{
   auto &project = context.project;
   (void)Exporter::DoEditMetadata( project,
      XO("Edit Metadata Tags"), XO("Metadata Tags"), true);
}

References Exporter::DoEditMetadata(), CommandContext::project, and XO.

Here is the call graph for this function:

OnJoin()

void EditActions::Handler::OnJoin ( const CommandContext &  context )

inline

Definition at line 927 of file EditMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
   auto &window = ProjectWindow::Get( project );
 
   for (auto wt : tracks.Selected< WaveTrack >())
      wt->Join(selectedRegion.t0(),
               selectedRegion.t1());
 
   ProjectHistory::Get( project ).PushState(
      XO("Joined %.2f seconds at t=%.2f")
         .Format( selectedRegion.duration(), selectedRegion.t0() ),
      XO("Join"));
}

References ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), ProjectWindow::Get(), CommandContext::project, ProjectHistory::PushState(), ViewInfo::selectedRegion, and XO.

Here is the call graph for this function:

OnPaste()

void EditActions::Handler::OnPaste ( const CommandContext &  context )

inline

Definition at line 395 of file EditMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
   auto& trackPanel = TrackPanel::Get(project);
   auto &trackFactory = WaveTrackFactory::Get( project );
   auto &pSampleBlockFactory = trackFactory.GetSampleBlockFactory();
   const auto &settings = ProjectSettings::Get( project );
   auto &window = ProjectWindow::Get( project );
 
   auto isSyncLocked = settings.IsSyncLocked();
 
   // Handle text paste (into active label) first.
   if (DoPasteText(project))
      return;
 
   //Presumably, there might be not more than one track
   //that expects text input
   for (auto wt : tracks.Any<WaveTrack>()) {
      auto& view = WaveTrackView::Get(*wt);
      if (view.PasteText(context.project)) {
         trackPanel.Refresh(false);
         return;
      }
   }
 
   // If nothing's selected, we just insert NEW tracks.
   if (DoPasteNothingSelected(project))
      return;
 
   const auto &clipboard = Clipboard::Get();
   auto clipTrackRange = clipboard.GetTracks().Any< const Track >();
   if (clipTrackRange.empty())
      return;
 
   // Otherwise, paste into the selected tracks.
   double t0, t1;
   std::tie(t0, t1) = FindSelection(context);
 
   auto pN = tracks.Any().begin();
 
   Track *ff = NULL;
   const Track *lastClipBeforeMismatch = NULL;
   const Track *mismatchedClip = NULL;
   const Track *prevClip = NULL;
 
   bool bAdvanceClipboard = true;
   bool bPastedSomething = false;
 
   auto pasteWaveTrack = [&](WaveTrack *dst, const Track *src){
      bPastedSomething = true;
      // For correct remapping of preserved split lines:
      PasteTimeWarper warper{ t1, t0 + src->GetEndTime() };
      dst->ClearAndPaste(t0, t1, src, true, true, &warper);
   };
 
   auto pC = clipTrackRange.begin();
   size_t nnChannels=0, ncChannels=0;
   while (*pN && *pC) {
      auto n = *pN;
      auto c = *pC;
      if (n->GetSelected()) {
         bAdvanceClipboard = true;
         if (mismatchedClip)
            c = mismatchedClip;
         if (!c->SameKindAs(*n)) {
            if (!mismatchedClip) {
               lastClipBeforeMismatch = prevClip;
               mismatchedClip = c;
            }
            bAdvanceClipboard = false;
            c = lastClipBeforeMismatch;
 
 
            // If the types still don't match...
            while (c && !c->SameKindAs(*n)) {
               prevClip = c;
               c = * ++ pC;
            }
         }
 
         // Handle case where the first track in clipboard
         // is of different type than the first selected track
         if (!c) {
            c = mismatchedClip;
            while (n && (!c->SameKindAs(*n) || !n->GetSelected()))
            {
               // Must perform sync-lock adjustment before incrementing n
               if (SyncLock::IsSyncLockSelected(n)) {
                  auto newT1 = t0 + clipboard.Duration();
                  if (t1 != newT1 && t1 <= n->GetEndTime()) {
                     n->SyncLockAdjust(t1, newT1);
                     bPastedSomething = true;
                  }
               }
               n = * ++ pN;
            }
            if (!n)
               c = NULL;
         }
 
         // The last possible case for cross-type pastes: triggered when we try
         // to paste 1+ tracks from one type into 1+ tracks of another type. If
         // there's a mix of types, this shouldn't run.
         if (!c)
            // Throw, so that any previous changes to the project in this loop
            // are discarded.
            throw SimpleMessageBoxException{
               ExceptionType::BadUserAction,
               XO("Pasting one type of track into another is not allowed."),
               XO("Warning"), 
               "Error:_Copying_or_Pasting"
            };
 
         // We should need this check only each time we visit the leading
         // channel
         if ( n->IsLeader() ) {
            wxASSERT( c->IsLeader() ); // the iteration logic should ensure this
 
            auto cChannels = TrackList::Channels(c);
            ncChannels = cChannels.size();
            auto nChannels = TrackList::Channels(n);
            nnChannels = nChannels.size();
 
            // When trying to copy from stereo to mono track, show error and
            // exit
            // TODO: Automatically offer user to mix down to mono (unfortunately
            //       this is not easy to implement
            if (ncChannels > nnChannels)
            {
               if (ncChannels > 2) {
                  // TODO: more-than-two-channels-message
                  // Re-word the error message
               }
               // else
 
               // Throw, so that any previous changes to the project in this
               // loop are discarded.
               throw SimpleMessageBoxException{
                  ExceptionType::BadUserAction,
                  XO("Copying stereo audio into a mono track is not allowed."),
                  XO("Warning"), 
                  "Error:_Copying_or_Pasting"
               };
            }
         }
 
         if (!ff)
            ff = n;
 
         wxASSERT( n && c && n->SameKindAs(*c) );
         n->TypeSwitch(
            [&](WaveTrack *wn){
               pasteWaveTrack(wn, static_cast<const WaveTrack *>(c));
            },
            [&](LabelTrack *ln){
               // Per Bug 293, users expect labels to move on a paste into
               // a label track.
               ln->Clear(t0, t1);
 
               ln->ShiftLabelsOnInsert( clipboard.Duration(), t0 );
 
               bPastedSomething |= ln->PasteOver(t0, c);
            },
            [&](Track *){
               bPastedSomething = true;
               n->Clear(t0, t1);
               n->Paste(t0, c);
            }
         );
 
         --nnChannels;
         --ncChannels;
 
         // When copying from mono to stereo track, paste the wave form
         // to both channels
         // TODO: more-than-two-channels
         // This will replicate the last pasted channel as many times as needed
         while (nnChannels > 0 && ncChannels == 0)
         {
            n = * ++ pN;
            --nnChannels;
 
            n->TypeSwitch(
               [&](WaveTrack *wn){
                  pasteWaveTrack(wn, c);
               },
               [&](Track *){
                  n->Clear(t0, t1);
                  bPastedSomething = true;
                  n->Paste(t0, c);
               }
            );
         }
 
         if (bAdvanceClipboard) {
            prevClip = c;
            c = * ++ pC;
         }
      } // if (n->GetSelected())
      else if (SyncLock::IsSyncLockSelected(n))
      {
         auto newT1 = t0 + clipboard.Duration();
         if (t1 != newT1 && t1 <= n->GetEndTime()) {
            n->SyncLockAdjust(t1, newT1);
            bPastedSomething = true;
         }
      }
      ++pN;
   }
 
   // This block handles the cases where our clipboard is smaller
   // than the amount of selected destination tracks. We take the
   // last wave track, and paste that one into the remaining
   // selected tracks.
   if ( *pN && ! *pC )
   {
      const auto wc =
         *clipboard.GetTracks().Any< const WaveTrack >().rbegin();
 
      tracks.Any().StartingWith(*pN).Visit(
         [&](WaveTrack *wt, const Track::Fallthrough &fallthrough) {
            if (!wt->GetSelected())
               return fallthrough();
 
            if (wc) {
               pasteWaveTrack(wt, wc);
            }
            else {
               auto tmp = wt->EmptyCopy( pSampleBlockFactory );
               tmp->InsertSilence( 0.0,
                  // MJS: Is this correct?
                  clipboard.Duration() );
               tmp->Flush();
 
               pasteWaveTrack(wt, tmp.get());
            }
         },
         [&](LabelTrack *lt, const Track::Fallthrough &fallthrough) {
            if (!SyncLock::IsSelectedOrSyncLockSelected(lt))
               return fallthrough();
 
            lt->Clear(t0, t1);
 
            // As above, only shift labels if sync-lock is on.
            if (isSyncLocked)
               lt->ShiftLabelsOnInsert(
                  clipboard.Duration(), t0);
         },
         [&](Track *n) {
            if (SyncLock::IsSyncLockSelected(n))
               n->SyncLockAdjust(t1, t0 + clipboard.Duration() );
         }
      );
   }
 
   // TODO: What if we clicked past the end of the track?
 
   if (bPastedSomething)
   {
      ViewInfo::Get(project).selectedRegion
         .setTimes( t0, t0 + clipboard.Duration() );
 
      ProjectHistory::Get( project )
         .PushState(XO("Pasted from the clipboard"), XO("Paste"));
 
      if (ff) {
         TrackFocus::Get(project).Set(ff);
         ff->EnsureVisible();
         ff->LinkConsistencyFix();
      }
   }
}

References BadUserAction, TrackList::Channels(), LabelTrack::Clear(), WaveTrack::ClearAndPaste(), anonymous_namespace{EditMenus.cpp}::DoPasteNothingSelected(), anonymous_namespace{EditMenus.cpp}::DoPasteText(), FindSelection(), Clipboard::Get(), TrackList::Get(), ProjectSettings::Get(), ProjectWindow::Get(), TrackPanel::Get(), WaveTrackFactory::Get(), WaveTrackView::Get(), SyncLock::IsSelectedOrSyncLockSelected(), SyncLock::IsSyncLockSelected(), CommandContext::project, settings(), LabelTrack::ShiftLabelsOnInsert(), Track::SyncLockAdjust(), and XO.

Here is the call graph for this function:

OnPreferences()

void EditActions::Handler::OnPreferences ( const CommandContext &  context )

inline

Definition at line 968 of file EditMenus.cpp.

{
   auto &project = context.project;
 
   GlobalPrefsDialog dialog(&GetProjectFrame( project ) /* parent */, &project );
 
   if( VetoDialogHook::Call( &dialog ) )
      return;
 
   if (!dialog.ShowModal()) {
      // Canceled
      return;
   }
 
   // LL:  Moved from PrefsDialog since wxWidgets on OSX can't deal with
   //      rebuilding the menus while the PrefsDialog is still in the modal
   //      state.
   for (auto p : AllProjects{}) {
      MenuManager::Get(*p).RebuildMenuBar(*p);
// TODO: The comment below suggests this workaround is obsolete.
#if defined(__WXGTK__)
      // Workaround for:
      //
      //   http://bugzilla.audacityteam.org/show_bug.cgi?id=458
      //
      // This workaround should be removed when Audacity updates to wxWidgets
      // 3.x which has a fix.
      auto &window = GetProjectFrame( *p );
      wxRect r = window.GetRect();
      window.SetSize(wxSize(1,1));
      window.SetSize(r.GetSize());
#endif
   }
}

References GlobalHook< VetoDialogHook, bool(wxDialog *) >::Call(), MenuManager::Get(), GetProjectFrame(), CommandContext::project, MenuCreator::RebuildMenuBar(), and PrefsDialog::ShowModal().

Here is the call graph for this function:

OnRedo()

void EditActions::Handler::OnRedo ( const CommandContext &  context )

inline

Definition at line 173 of file EditMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
   auto &trackPanel = TrackPanel::Get( project );
   auto &undoManager = UndoManager::Get( project );
   auto &window = ProjectWindow::Get( project );
 
   if (!ProjectHistory::Get( project ).RedoAvailable()) {
      AudacityMessageBox( XO("Nothing to redo") );
      return;
   }
   // Can't redo whilst dragging
   if (trackPanel.IsMouseCaptured()) {
      return;
   }
 
   undoManager.Redo(
      [&]( const UndoStackElem &elem ){
         ProjectHistory::Get( project ).PopState( elem.state ); } );
 
   auto t = *tracks.Selected().begin();
   if (!t)
      t = *tracks.Any().begin();
   TrackFocus::Get(project).Set(t);
   if (t) {
      t->EnsureVisible();
   }
}

References AudacityMessageBox(), Track::EnsureVisible(), TrackFocus::Get(), ProjectHistory::Get(), UndoManager::Get(), TrackList::Get(), ProjectWindow::Get(), TrackPanel::Get(), ProjectHistory::PopState(), CommandContext::project, UndoStackElem::state, and XO.

Here is the call graph for this function:

OnSilence()

void EditActions::Handler::OnSilence ( const CommandContext &  context )

inline

Definition at line 767 of file EditMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
 
   for ( auto n : tracks.Selected< WaveTrack >() )
      n->Silence(selectedRegion.t0(), selectedRegion.t1());
 
   ProjectHistory::Get( project ).PushState(
      XO("Silenced selected tracks for %.2f seconds at %.2f")
         .Format( selectedRegion.duration(), selectedRegion.t0() ),
      /* i18n-hint: verb */
      XC("Silence", "command"));
}

References ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), CommandContext::project, ProjectHistory::PushState(), ViewInfo::selectedRegion, XC, and XO.

Here is the call graph for this function:

OnSplit()

void EditActions::Handler::OnSplit ( const CommandContext &  context )

inline

Definition at line 807 of file EditMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
 
   auto [sel0, sel1] = FindSelection(context);
   
   if (auto *pTrack = context.temporarySelection.pTrack) {
      if (auto pWaveTrack = dynamic_cast<WaveTrack*>(pTrack))
         for (auto pChannel : TrackList::Channels(pWaveTrack))
            pChannel->Split( sel0, sel1 );
      else
         // Did nothing, don't push history
         return;
   }
   else {
      for (auto wt : tracks.Selected< WaveTrack >())
         wt->Split( sel0, sel1 );
   }
 
   ProjectHistory::Get( project ).PushState(XO("Split"), XO("Split"));
#if 0
//ANSWER-ME: Do we need to keep this commented out OnSplit() code?
// This whole section no longer used...
   /*
    * Previous (pre-multiclip) implementation of "Split" command
    * This does work only when a range is selected!
    *
   TrackListIterator iter(tracks);
 
   Track *n = iter.First();
   Track *dest;
 
   TrackList newTracks;
 
   while (n) {
      if (n->GetSelected()) {
         double sel0 = selectedRegion.t0();
         double sel1 = selectedRegion.t1();
 
         dest = n->Copy(sel0, sel1);
         dest->Init(*n);
         dest->SetOffset(wxMax(sel0, n->GetOffset()));
 
         if (sel1 >= n->GetEndTime())
            n->Clear(sel0, sel1);
         else if (sel0 <= n->GetOffset()) {
            n->Clear(sel0, sel1);
            n->SetOffset(sel1);
         } else
            n->Silence(sel0, sel1);
 
         newTracks.Add(dest);
      }
      n = iter.Next();
   }
 
   TrackListIterator nIter(&newTracks);
   n = nIter.First();
   while (n) {
      tracks->Add(n);
      n = nIter.Next();
   }
 
   PushState(XO("Split"), XO("Split"));
   */
#endif
}

References TrackList::Channels(), ProjectHistory::Get(), TrackList::Get(), CommandContext::project, TemporarySelection::pTrack, ProjectHistory::PushState(), CommandContext::temporarySelection, and XO.

Here is the call graph for this function:

OnSplitCut()

void EditActions::Handler::OnSplitCut ( const CommandContext &  context )

inline

Definition at line 699 of file EditMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
   auto &window = ProjectWindow::Get( project );
 
   auto &clipboard = Clipboard::Get();
   clipboard.Clear();
 
   auto pNewClipboard = TrackList::Create( nullptr );
   auto &newClipboard = *pNewClipboard;
 
   Track::Holder dest;
 
   tracks.Selected().Visit(
      [&](WaveTrack *n) {
         dest = n->SplitCut(
            selectedRegion.t0(),
            selectedRegion.t1());
         if (dest)
            FinishCopy(n, dest, newClipboard);
      },
      [&](Track *n) {
         if (n->SupportsBasicEditing()) {
            dest = n->Copy(selectedRegion.t0(),
                    selectedRegion.t1());
            n->Silence(selectedRegion.t0(),
                       selectedRegion.t1());
            if (dest)
               FinishCopy(n, dest, newClipboard);
         }
      }
   );
 
   // Survived possibility of exceptions.  Commit changes to the clipboard now.
   clipboard.Assign( std::move( newClipboard ),
      selectedRegion.t0(), selectedRegion.t1(), project.shared_from_this() );
 
   ProjectHistory::Get( project )
      .PushState(XO("Split-cut to the clipboard"), XO("Split Cut"));
}

References WaveTrack::Copy(), TrackList::Create(), anonymous_namespace{EditMenus.cpp}::FinishCopy(), Clipboard::Get(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), ProjectWindow::Get(), CommandContext::project, ProjectHistory::PushState(), ViewInfo::selectedRegion, WaveTrack::Silence(), WaveTrack::SplitCut(), Track::SupportsBasicEditing(), and XO.

Here is the call graph for this function:

OnSplitDelete()

void EditActions::Handler::OnSplitDelete ( const CommandContext &  context )

inline

Definition at line 742 of file EditMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
   auto &window = ProjectWindow::Get( project );
 
   tracks.Selected().Visit(
      [&](WaveTrack *wt) {
         wt->SplitDelete(selectedRegion.t0(),
                         selectedRegion.t1());
      },
      [&](Track *n) {
         if (n->SupportsBasicEditing())
            n->Silence(selectedRegion.t0(),
                       selectedRegion.t1());
      }
   );
 
   ProjectHistory::Get( project ).PushState(
      XO("Split-deleted %.2f seconds at t=%.2f")
         .Format( selectedRegion.duration(), selectedRegion.t0() ),
      XO("Split Delete"));
}

References ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), ProjectWindow::Get(), CommandContext::project, ProjectHistory::PushState(), ViewInfo::selectedRegion, WaveTrack::SplitDelete(), and XO.

Here is the call graph for this function:

OnSplitNew()

void EditActions::Handler::OnSplitNew ( const CommandContext &  context )

inline

Definition at line 876 of file EditMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
   auto &window = ProjectWindow::Get( project );
 
   Track::Holder dest;
 
   // This iteration is unusual because we add to the list inside the loop
   auto range = tracks.Selected();
   auto last = *range.rbegin();
   for (auto track : range) {
      track->TypeSwitch(
         [&](WaveTrack *wt) {
            // Clips must be aligned to sample positions or the NEW clip will
            // not fit in the gap where it came from
            double offset = wt->GetOffset();
            offset = wt->LongSamplesToTime(wt->TimeToLongSamples(offset));
            double newt0 = wt->LongSamplesToTime(wt->TimeToLongSamples(
               selectedRegion.t0()));
            double newt1 = wt->LongSamplesToTime(wt->TimeToLongSamples(
               selectedRegion.t1()));
            dest = wt->SplitCut(newt0, newt1);
            if (dest) {
               dest->SetOffset(wxMax(newt0, offset));
               FinishCopy(wt, dest, tracks);
            }
         }
#if 0
         ,
         // LL:  For now, just skip all non-wave tracks since the other do not
         //      yet support proper splitting.
         [&](Track *n) {
            dest = n->Cut(viewInfo.selectedRegion.t0(),
                   viewInfo.selectedRegion.t1());
            if (dest) {
               dest->SetOffset(wxMax(0, n->GetOffset()));
               FinishCopy(n, dest, *tracks);
            }
         }
#endif
      );
      if (track == last)
         break;
   }
 
   ProjectHistory::Get( project )
      .PushState(XO("Split to new track"), XO("Split New"));
}

References anonymous_namespace{EditMenus.cpp}::FinishCopy(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), ProjectWindow::Get(), WaveTrack::GetOffset(), SampleTrack::LongSamplesToTime(), CommandContext::project, ProjectHistory::PushState(), ViewInfo::selectedRegion, WaveTrack::SplitCut(), SampleTrack::TimeToLongSamples(), and XO.

Here is the call graph for this function:

OnTrim()

void EditActions::Handler::OnTrim ( const CommandContext &  context )

inline

Definition at line 783 of file EditMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
   auto &window = ProjectWindow::Get( project );
 
   if (selectedRegion.isPoint())
      return;
 
   tracks.Selected().Visit(
      [&](WaveTrack *wt) {
         //Hide the section before the left selector
         wt->Trim(selectedRegion.t0(),
            selectedRegion.t1());
      }
   );
 
   ProjectHistory::Get( project ).PushState(
      XO("Trim selected audio tracks from %.2f seconds to %.2f seconds")
         .Format( selectedRegion.t0(), selectedRegion.t1() ),
      XO("Trim Audio"));
}

References ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), ProjectWindow::Get(), CommandContext::project, ProjectHistory::PushState(), ViewInfo::selectedRegion, WaveTrack::Trim(), and XO.

Here is the call graph for this function:

OnUndo()

void EditActions::Handler::OnUndo ( const CommandContext &  context )

inline

Definition at line 142 of file EditMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
   auto &trackPanel = TrackPanel::Get( project );
   auto &undoManager = UndoManager::Get( project );
   auto &window = ProjectWindow::Get( project );
 
   if (!ProjectHistory::Get( project ).UndoAvailable()) {
      AudacityMessageBox( XO("Nothing to undo") );
      return;
   }
 
   // can't undo while dragging
   if (trackPanel.IsMouseCaptured()) {
      return;
   }
 
   undoManager.Undo(
      [&]( const UndoStackElem &elem ){
         ProjectHistory::Get( project ).PopState( elem.state ); } );
 
   auto t = *tracks.Selected().begin();
   if (!t)
      t = *tracks.Any().begin();
   TrackFocus::Get(project).Set(t);
   if (t) {
      t->EnsureVisible();
   }
}

References AudacityMessageBox(), Track::EnsureVisible(), TrackFocus::Get(), ProjectHistory::Get(), UndoManager::Get(), TrackList::Get(), ProjectWindow::Get(), TrackPanel::Get(), ProjectHistory::PopState(), CommandContext::project, UndoStackElem::state, and XO.

Here is the call graph for this function:

---

The documentation for this struct was generated from the following file:

• EditMenus.cpp