anonymous_namespace{LabelMenus.cpp} Namespace Reference

Namespace for functions for Edit Label submenu. More...

Typedefs
using	EditFunction = std::function< void(Track &track, double, double)>
using	EditFunctionWithProgress = std::function< void(Track &track, double, double, ProgressReporter)>
using	EditDestFunction = std::function< Track::Holder(Track &, double, double)>

Functions
const ReservedCommandFlag &	LabelsSelectedFlag ()
int	DoAddLabel (AudacityProject &project, const SelectedRegion &region, bool preserveFocus=false)
void	GetRegionsByLabel (const TrackList &tracks, const SelectedRegion &selectedRegion, Regions &regions)
void	EditByLabel (AudacityProject &project, TrackList &tracks, const SelectedRegion &selectedRegion, EditFunctionWithProgress action, ProgressReporter progress)
void	EditByLabel (AudacityProject &project, TrackList &tracks, const SelectedRegion &selectedRegion, EditFunction action)
void	EditClipboardByLabel (AudacityProject &project, TrackList &tracks, const SelectedRegion &selectedRegion, EditDestFunction action)
void	OnEditLabels (const CommandContext &context)
void	OnAddLabel (const CommandContext &context)
void	OnAddLabelPlaying (const CommandContext &context)
void	OnPasteNewLabel (const CommandContext &context)
void	OnToggleTypeToCreateLabel (const CommandContext &WXUNUSED(context))
void	OnCutLabels (const CommandContext &context)
void	OnDeleteLabels (const CommandContext &context)
void	OnSplitCutLabels (const CommandContext &context)
void	OnSplitDeleteLabels (const CommandContext &context)
void	OnSilenceLabels (const CommandContext &context)
void	OnCopyLabels (const CommandContext &context)
void	OnSplitLabels (const CommandContext &context)
void	OnJoinLabels (const CommandContext &context)
void	OnDisjoinLabels (const CommandContext &context)
void	OnNewLabelTrack (const CommandContext &context)
auto	LabelEditMenus ()

Variables
AttachedItem	sAttachment1
AttachedItem	sAttachment2

Detailed Description

Namespace for functions for Edit Label submenu.

Typedef Documentation

EditDestFunction

using anonymous_namespace{LabelMenus.cpp}::EditDestFunction = typedef std::function<Track::Holder(Track &, double, double)>

Definition at line 221 of file LabelMenus.cpp.

EditFunction

using anonymous_namespace{LabelMenus.cpp}::EditFunction = typedef std::function<void(Track& track, double, double)>

Definition at line 163 of file LabelMenus.cpp.

EditFunctionWithProgress

using anonymous_namespace{LabelMenus.cpp}::EditFunctionWithProgress = typedef std::function<void(Track& track, double, double, ProgressReporter)>

Definition at line 164 of file LabelMenus.cpp.

Function Documentation

DoAddLabel()

int anonymous_namespace{LabelMenus.cpp}::DoAddLabel	(	AudacityProject &	project,
		const SelectedRegion &	region,
		bool	preserveFocus = false
	)

Definition at line 56 of file LabelMenus.cpp.

{
   auto &tracks = TrackList::Get( project );
   auto &trackFocus = TrackFocus::Get( project );
   auto &trackPanel = TrackPanel::Get( project );
 
   wxString title;      // of label
 
   bool useDialog;
   gPrefs->Read(wxT("/GUI/DialogForNameNewLabel"), &useDialog, false);
   if (useDialog) {
      if (LabelTrackView::DialogForLabelName(
         project, region, wxEmptyString, title) == wxID_CANCEL)
         return -1;     // index
   }
 
   // If the focused track is a label track, use that
   const auto pFocusedTrack = trackFocus.Get();
 
   // Look for a label track at or after the focused track
   auto begin = tracks.begin();
   auto iter = pFocusedTrack
      ? tracks.Find(pFocusedTrack)
      : begin;
   auto lt = * iter.Filter<LabelTrack>();
 
   // If none found, start a NEW label track and use it
   if (!lt)
      lt = LabelTrack::Create(tracks);
 
// LLL: Commented as it seemed a little forceful to remove users
//      selection when adding the label.  This does not happen if
//      you select several tracks and the last one of those is a
//      label track...typing a label will not clear the selections.
//
//   SelectNone();
   lt->SetSelected(true);
 
   int index;
   if (useDialog) {
      index = lt->AddLabel(region, title);
   }
   else {
      int focusTrackNumber = -1;
      if (pFocusedTrack && preserveFocus) {
         // Must remember the track to re-focus after finishing a label edit.
         // do NOT identify it by a pointer, which might dangle!  Identify
         // by position.
         focusTrackNumber = std::distance(begin, iter);
      }
      index =
         LabelTrackView::Get( *lt ).AddLabel(region, title, focusTrackNumber);
   }
 
   ProjectHistory::Get( project )
      .PushState(XO("Added label"), XO("Label"));
 
   if (!useDialog) {
      TrackFocus::Get(project).Set(lt);
      Viewport::Get(project).ShowTrack(*lt);
   }
   trackPanel.SetFocus();
 
   return index;
}

References LabelTrackView::AddLabel(), details::begin(), LabelTrack::Create(), LabelTrackView::DialogForLabelName(), TrackFocus::Get(), ProjectHistory::Get(), TrackList::Get(), Viewport::Get(), TrackPanel::Get(), LabelTrackView::Get(), gPrefs, project, ProjectHistory::PushState(), audacity::BasicSettings::Read(), Viewport::ShowTrack(), title, tracks, wxT(), and XO().

Referenced by OnAddLabel(), and OnAddLabelPlaying().

Here is the call graph for this function:

Here is the caller graph for this function:

EditByLabel() [1/2]

void anonymous_namespace{LabelMenus.cpp}::EditByLabel	(	AudacityProject &	project,
		TrackList &	tracks,
		const SelectedRegion &	selectedRegion,
		EditFunction	action
	)

Definition at line 209 of file LabelMenus.cpp.

{
   EditByLabel(
      project, tracks, selectedRegion,
      [&](Track& track, double t0, double t1, ProgressReporter) {
         action(track, t0, t1);
      },
      nullptr);
}

References EditByLabel(), project, and tracks.

Referenced by EditByLabel(), OnCutLabels(), OnDeleteLabels(), OnDisjoinLabels(), OnJoinLabels(), OnSilenceLabels(), OnSplitDeleteLabels(), and OnSplitLabels().

Here is the call graph for this function:

Here is the caller graph for this function:

EditByLabel() [2/2]

void anonymous_namespace{LabelMenus.cpp}::EditByLabel	(	AudacityProject &	project,
		TrackList &	tracks,
		const SelectedRegion &	selectedRegion,
		EditFunctionWithProgress	action,
		ProgressReporter	progress
	)

Definition at line 174 of file LabelMenus.cpp.

{
   Regions regions;
 
   GetRegionsByLabel(tracks, selectedRegion, regions);
   if (regions.empty())
      return;
 
   const bool notLocked = (!SyncLockState::Get(project).IsSyncLocked() &&
                           (tracks.Selected<PlayableTrack>()).empty());
 
   const auto tracksToEdit = tracks.Any<Track>() + [&](const auto pTrack) {
      return SyncLock::IsSyncLockSelected(*pTrack) ||
             (notLocked && dynamic_cast<const PlayableTrack*>(pTrack) != nullptr);
   };
 
   BasicUI::SplitProgress(
      tracksToEdit.begin(), tracksToEdit.end(),
      [&](Track* aTrack, const ProgressReporter& child) {
         // Apply action on tracks starting from labeled regions in the end.
         // This is to correctly perform actions like 'Delete' which collapse
         // the track area.
         BasicUI::SplitProgress(
            regions.rbegin(), regions.rend(),
            [&](const Region& region, const ProgressReporter& grandChild) {
               action(*aTrack, region.start, region.end, grandChild);
            },
            child);
      },
      progress);
}

References SyncLockState::Get(), GetRegionsByLabel(), SyncLockState::IsSyncLocked(), SyncLock::IsSyncLockSelected(), project, BasicUI::SplitProgress(), and tracks.

Here is the call graph for this function:

EditClipboardByLabel()

void anonymous_namespace{LabelMenus.cpp}::EditClipboardByLabel	(	AudacityProject &	project,
		TrackList &	tracks,
		const SelectedRegion &	selectedRegion,
		EditDestFunction	action
	)

Definition at line 230 of file LabelMenus.cpp.

{
   Regions regions;
 
   GetRegionsByLabel(tracks, selectedRegion, regions);
   if (regions.empty())
      return;
 
   const bool notLocked = (!SyncLockState::Get(project).IsSyncLocked() &&
                           (tracks.Selected<PlayableTrack>()).empty());
 
   auto &clipboard = Clipboard::Get();
   clipboard.Clear();
 
   auto pNewClipboard = TrackList::Create(nullptr);
   auto &newClipboard = *pNewClipboard;
 
   //Apply action on wavetracks starting from
   //labeled regions in the end. This is to correctly perform
   //actions like 'Cut' which collapse the track area.
 
   for (auto t : tracks) {
      const bool playable = dynamic_cast<const PlayableTrack *>(t) != nullptr;
      if (SyncLock::IsSyncLockSelected(*t) || (notLocked && playable)) {
         // These tracks accumulate the needed clips, right to left:
         Track::Holder merged;
         for (size_t i = regions.size(); i--;) {
            const Region &region = regions.at(i);
            if (auto dest = action(*t, region.start, region.end)) {
               if (!merged)
                  merged = dest;
               else {
                  // Paste to the beginning; unless this is the first region,
                  // offset the track to account for time between the regions
                  if (i + 1 < regions.size())
                     merged->ShiftBy(
                        regions.at(i + 1).start - region.end);
 
                  // dest may have a placeholder clip at the end that is
                  // removed when pasting, which is okay because we proceed
                  // right to left.  Any placeholder already in merged is kept.
                  // Only the rightmost placeholder is important in the final
                  // result.
                  merged->Paste(0.0, *dest);
               }
            }
            else
               // nothing copied but there is a 'region', so the 'region' must
               // be a 'point label' so offset
               if (i + 1 < regions.size() && merged)
                  merged->ShiftBy(regions.at(i + 1).start - region.end);
         }
         if (merged)
            newClipboard.Add(merged);
      }
   }
 
   // Survived possibility of exceptions.  Commit changes to the clipboard now.
   clipboard.Assign( std::move( newClipboard ),
      regions.front().start, regions.back().end, project.shared_from_this() );
}

References TrackList::Create(), WaveTrack::Region::end, Clipboard::Get(), SyncLockState::Get(), GetRegionsByLabel(), SyncLockState::IsSyncLocked(), SyncLock::IsSyncLockSelected(), project, WaveTrack::Region::start, and tracks.

Referenced by OnCopyLabels(), OnCutLabels(), and OnSplitCutLabels().

Here is the call graph for this function:

Here is the caller graph for this function:

GetRegionsByLabel()

void anonymous_namespace{LabelMenus.cpp}::GetRegionsByLabel	(	const TrackList &	tracks,
		const SelectedRegion &	selectedRegion,
		Regions &	regions
	)

Definition at line 126 of file LabelMenus.cpp.

{
   //determine labeled regions
   for (auto lt : tracks.Selected< const LabelTrack >()) {
      for (int i = 0; i < lt->GetNumLabels(); i++)
      {
         const LabelStruct *ls = lt->GetLabel(i);
         if (ls->selectedRegion.t0() >= selectedRegion.t0() &&
            ls->selectedRegion.t1() <= selectedRegion.t1())
            regions.push_back(Region(ls->getT0(), ls->getT1()));
      }
   }
 
   //anything to do ?
   if( regions.size() == 0 )
      return;
 
   //sort and remove unnecessary regions
   std::sort(regions.begin(), regions.end());
   unsigned int selected = 1;
   while( selected < regions.size() )
   {
      const Region &cur = regions.at( selected );
      Region &last = regions.at( selected - 1 );
      if( cur.start < last.end )
      {
         if( cur.end > last.end )
            last.end = cur.end;
         regions.erase( regions.begin() + selected );
      }
      else
         ++selected;
   }
}

References WaveTrack::Region::end, LabelStruct::getT0(), LabelStruct::getT1(), LabelStruct::selectedRegion, WaveTrack::Region::start, SelectedRegion::t0(), SelectedRegion::t1(), and tracks.

Referenced by EditByLabel(), and EditClipboardByLabel().

Here is the call graph for this function:

Here is the caller graph for this function:

LabelEditMenus()

auto anonymous_namespace{LabelMenus.cpp}::LabelEditMenus

(

)

Definition at line 670 of file LabelMenus.cpp.

{
   using namespace MenuRegistry;
 
   static const auto NotBusyLabelsAndWaveFlags =
      AudioIONotBusyFlag() |
      LabelsSelectedFlag() | WaveTracksExistFlag() | TimeSelectedFlag();
 
   // Returns TWO menus.
 
   static auto menus = std::shared_ptr{
   Items( wxT("LabelEditMenus"),
 
   Menu( wxT("Labels"), XXO("&Labels"),
      Section( "",
         Command( wxT("EditLabels"), XXO("Label &Editor"), OnEditLabels,
                    AudioIONotBusyFlag() )
      ),
 
      Section( "",
         Command( wxT("AddLabel"), XXO("Add Label at &Selection"),
            OnAddLabel, AlwaysEnabledFlag, wxT("Ctrl+B") ),
         Command( wxT("AddLabelPlaying"),
            XXO("Add Label at &Playback Position"),
            OnAddLabelPlaying, AudioIOBusyFlag(),
   #ifdef __WXMAC__
            wxT("Ctrl+.")
   #else
            wxT("Ctrl+M")
   #endif
         ),
         Command( wxT("PasteNewLabel"), XXO("Paste Te&xt to New Label"),
            OnPasteNewLabel,
            AudioIONotBusyFlag(), wxT("Ctrl+Alt+V") )
      ),
 
      Section( "",
         Command( wxT("TypeToCreateLabel"),
            XXO("&Typing Creates New Labels"),
            OnToggleTypeToCreateLabel, AlwaysEnabledFlag,
            Options{}.CheckTest(wxT("/GUI/TypeToCreateLabel"), false) )
      )
   ), // first menu
 
 
   Menu( wxT("Labeled"), XXO("La&beled Audio"),
      Section( "",
         /* i18n-hint: (verb)*/
         Command( wxT("CutLabels"), XXO("&Cut"), OnCutLabels,
            AudioIONotBusyFlag() | LabelsSelectedFlag() | WaveTracksExistFlag() |
               TimeSelectedFlag(),
               Options{ wxT("Alt+X"), XO("Label Cut") } ),
         Command( wxT("DeleteLabels"), XXO("&Delete"), OnDeleteLabels,
            AudioIONotBusyFlag() | LabelsSelectedFlag() | WaveTracksExistFlag() |
               TimeSelectedFlag(),
            Options{ wxT("Alt+K"), XO("Label Delete") } )
      ),
 
      Section( "",
         /* i18n-hint: (verb) A special way to cut out a piece of audio*/
         Command( wxT("SplitCutLabels"), XXO("&Split Cut"),
            OnSplitCutLabels, NotBusyLabelsAndWaveFlags,
            Options{ wxT("Alt+Shift+X"), XO("Label Split Cut") } ),
         Command( wxT("SplitDeleteLabels"), XXO("Sp&lit Delete"),
            OnSplitDeleteLabels, NotBusyLabelsAndWaveFlags,
            Options{ wxT("Alt+Shift+K"), XO("Label Split Delete") } )
      ),
 
      Section( "",
         Command( wxT("SilenceLabels"), XXO("Silence &Audio"),
            OnSilenceLabels, NotBusyLabelsAndWaveFlags,
            Options{ wxT("Alt+L"), XO("Label Silence") } ),
         /* i18n-hint: (verb)*/
         Command( wxT("CopyLabels"), XXO("Co&py"), OnCopyLabels,
            NotBusyLabelsAndWaveFlags,
            Options{ wxT("Alt+Shift+C"), XO("Label Copy") } )
      ),
 
      Section( "",
         /* i18n-hint: (verb)*/
         Command( wxT("SplitLabels"), XXO("Spli&t"), OnSplitLabels,
            AudioIONotBusyFlag() | LabelsSelectedFlag() | WaveTracksExistFlag(),
            Options{ wxT("Alt+I"), XO("Label Split") } ),
         /* i18n-hint: (verb)*/
         Command( wxT("JoinLabels"), XXO("&Join"), OnJoinLabels,
            NotBusyLabelsAndWaveFlags,
            Options{ wxT("Alt+J"), XO("Label Join") } ),
         Command( wxT("DisjoinLabels"), XXO("Detac&h at Silences"),
            OnDisjoinLabels, NotBusyLabelsAndWaveFlags,
            wxT("Alt+Shift+J") )
      )
   ) // second menu
 
   ) }; // two menus
   return menus;
}

References AlwaysEnabledFlag, AudioIOBusyFlag(), AudioIONotBusyFlag(), MenuRegistry::Options::CheckTest(), MenuRegistry::Command, MenuRegistry::Items, LabelsSelectedFlag(), MenuRegistry::Menu, OnAddLabel(), OnAddLabelPlaying(), OnCopyLabels(), OnCutLabels(), OnDeleteLabels(), OnDisjoinLabels(), OnEditLabels(), OnJoinLabels(), OnPasteNewLabel(), OnSilenceLabels(), OnSplitCutLabels(), OnSplitDeleteLabels(), OnSplitLabels(), OnToggleTypeToCreateLabel(), MenuRegistry::Section, TimeSelectedFlag(), WaveTracksExistFlag(), wxT(), XO(), and XXO().

Here is the call graph for this function:

LabelsSelectedFlag()

const ReservedCommandFlag & anonymous_namespace{LabelMenus.cpp}::LabelsSelectedFlag

(

)

Definition at line 32 of file LabelMenus.cpp.

                      { static ReservedCommandFlag flag{
   [](const AudacityProject &project){
      // At least one label track selected, having at least one label
      // completely within the time selection.
      const auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
      const auto &test = [&]( const LabelTrack *pTrack ){
         const auto &labels = pTrack->GetLabels();
         return std::any_of( labels.begin(), labels.end(),
            [&](const LabelStruct &label){
               return
                  label.getT0() >= selectedRegion.t0()
               &&
                  label.getT1() <= selectedRegion.t1()
               ;
            }
         );
      };
      auto range = TrackList::Get(project).Selected<const LabelTrack>()
         + test;
      return !range.empty();
   }
}; return flag; }

References flag, ViewInfo::Get(), TrackList::Get(), label, project, TrackList::Selected(), and ViewInfo::selectedRegion.

Referenced by LabelEditMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

OnAddLabel()

void anonymous_namespace{LabelMenus.cpp}::OnAddLabel

(

const CommandContext &

context

)

Definition at line 307 of file LabelMenus.cpp.

{
   auto &project = context.project;
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
 
   DoAddLabel(project, selectedRegion);
}

References DoAddLabel(), ViewInfo::Get(), CommandContext::project, project, and ViewInfo::selectedRegion.

Referenced by LabelEditMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

OnAddLabelPlaying()

void anonymous_namespace{LabelMenus.cpp}::OnAddLabelPlaying

(

const CommandContext &

context

)

Definition at line 315 of file LabelMenus.cpp.

{
   auto &project = context.project;
   auto token = ProjectAudioIO::Get( project ).GetAudioIOToken();
 
   auto gAudioIO = AudioIO::Get();
   if (token > 0 &&
       gAudioIO->IsStreamActive(token)) {
      double indicator = gAudioIO->GetStreamTime();
      DoAddLabel(project, SelectedRegion(indicator, indicator), true);
   }
}

References DoAddLabel(), AudioIO::Get(), ProjectAudioIO::Get(), ProjectAudioIO::GetAudioIOToken(), CommandContext::project, and project.

Referenced by LabelEditMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

OnCopyLabels()

void anonymous_namespace{LabelMenus.cpp}::OnCopyLabels

(

const CommandContext &

context

)

Definition at line 553 of file LabelMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get(project);
   auto &selectedRegion = ViewInfo::Get(project).selectedRegion;
 
   if (selectedRegion.isPoint())
      return;
 
   auto copyfunc = [&](Track &track, double t0, double t1) {
      Track::Holder result;
      track.TypeSwitch( [&](WaveTrack &wt) { result = wt.Copy(t0, t1); } );
      return result;
   };
   EditClipboardByLabel(project, tracks, selectedRegion, copyfunc);
 
   ProjectHistory::Get(project)
      .PushState(XO("Copied labeled audio regions to clipboard"),
         /* i18n-hint: (verb)*/
         XO("Copy Labeled Audio"));
}

References WaveTrack::Copy(), EditClipboardByLabel(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), CommandContext::project, project, ProjectHistory::PushState(), ViewInfo::selectedRegion, tracks, Track::TypeSwitch(), and XO().

Referenced by LabelEditMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

OnCutLabels()

void anonymous_namespace{LabelMenus.cpp}::OnCutLabels

(

const CommandContext &

context

)

Definition at line 401 of file LabelMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get(project);
   auto &selectedRegion = ViewInfo::Get(project).selectedRegion;
 
   if (selectedRegion.isPoint())
     return;
 
   // Because of grouping the copy may need to operate on different tracks than
   // the clear, so we do these actions separately.
   auto copyfunc = [&](Track &track, double t0, double t1) {
      Track::Holder result;
      track.TypeSwitch( [&](WaveTrack &wt) { result = wt.Copy(t0, t1); } );
      return result;
   };
   EditClipboardByLabel(project, tracks, selectedRegion, copyfunc);
 
   bool enableCutlines = gPrefs->ReadBool(wxT( "/GUI/EnableCutLines"), false);
   auto editfunc = [&](Track &track, double t0, double t1) {
      track.TypeSwitch(
         [&](WaveTrack &t) {
            if (enableCutlines)
               t.ClearAndAddCutLine(t0, t1);
            else
               t.Clear(t0, t1);
         },
         [&](Track &t) {
            t.Clear(t0, t1);
         }
      );
   };
   EditByLabel(project, tracks, selectedRegion, editfunc);
 
   selectedRegion.collapseToT0();
 
   ProjectHistory::Get(project).PushState(
   /* i18n-hint: (verb) past tense.  Audacity has just cut the labeled audio
      regions.*/
      XO("Cut labeled audio regions to clipboard"),
   /* i18n-hint: (verb)*/
      XO("Cut Labeled Audio"));
}

References WaveTrack::Clear(), WaveTrack::ClearAndAddCutLine(), WaveTrack::Copy(), EditByLabel(), EditClipboardByLabel(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), gPrefs, CommandContext::project, project, ProjectHistory::PushState(), audacity::BasicSettings::ReadBool(), ViewInfo::selectedRegion, tracks, Track::TypeSwitch(), wxT(), and XO().

Referenced by LabelEditMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

OnDeleteLabels()

void anonymous_namespace{LabelMenus.cpp}::OnDeleteLabels

(

const CommandContext &

context

)

Definition at line 445 of file LabelMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get(project);
   auto &selectedRegion = ViewInfo::Get(project).selectedRegion;
 
   if (selectedRegion.isPoint())
      return;
 
   auto editfunc = [&](Track &track, double t0, double t1) {
      track.TypeSwitch( [&](Track &t) { t.Clear(t0, t1); } );
   };
   EditByLabel(project, tracks, selectedRegion, editfunc);
 
   selectedRegion.collapseToT0();
 
   ProjectHistory::Get(project).PushState(
      /* i18n-hint: (verb) Audacity has just deleted the labeled audio regions*/
      XO("Deleted labeled audio regions"),
      /* i18n-hint: (verb)*/
      XO("Delete Labeled Audio"));
}

References Track::Clear(), EditByLabel(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), CommandContext::project, project, ProjectHistory::PushState(), ViewInfo::selectedRegion, tracks, Track::TypeSwitch(), and XO().

Referenced by LabelEditMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

OnDisjoinLabels()

void anonymous_namespace{LabelMenus.cpp}::OnDisjoinLabels

(

const CommandContext &

context

)

Definition at line 623 of file LabelMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get(project);
   auto &selectedRegion = ViewInfo::Get(project).selectedRegion;
 
   if (selectedRegion.isPoint())
      return;
 
   auto editfunc = [&](Track &track, double t0, double t1) {
      track.TypeSwitch( [&](WaveTrack &t) {
         wxBusyCursor busy;
         t.Disjoin(t0, t1);
      } );
   };
   EditByLabel(project, tracks, selectedRegion, editfunc);
 
   ProjectHistory::Get(project).PushState(
      /* i18n-hint: (verb) Audacity has just detached the labeled audio regions.
      This message appears in history and tells you about something
      Audacity has done.*/
      XO("Detached labeled audio regions"),
      /* i18n-hint: (verb)*/
      XO("Detach Labeled Audio"));
}

References WaveTrack::Disjoin(), EditByLabel(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), CommandContext::project, project, ProjectHistory::PushState(), ViewInfo::selectedRegion, tracks, Track::TypeSwitch(), and XO().

Referenced by LabelEditMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

OnEditLabels()

void anonymous_namespace{LabelMenus.cpp}::OnEditLabels

(

const CommandContext &

context

)

Definition at line 301 of file LabelMenus.cpp.

{
   auto &project = context.project;
   LabelTrackView::DoEditLabels(project);
}

References LabelTrackView::DoEditLabels(), CommandContext::project, and project.

Referenced by LabelEditMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

OnJoinLabels()

void anonymous_namespace{LabelMenus.cpp}::OnJoinLabels

(

const CommandContext &

context

)

Definition at line 597 of file LabelMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get(project);
   auto &selectedRegion = ViewInfo::Get(project).selectedRegion;
 
   if (selectedRegion.isPoint())
      return;
 
   auto editfunc = [&](Track& track, double t0, double t1, ProgressReporter reportProgress) {
      track.TypeSwitch(
         [&](WaveTrack& t) { t.Join(t0, t1, std::move(reportProgress)); });
   };
   TimeStretching::WithClipRenderingProgress(
      [&](ProgressReporter progress) {
         EditByLabel(project, tracks, selectedRegion, editfunc, progress);
      });
 
   ProjectHistory::Get(project).PushState(
      /* i18n-hint: (verb) Audacity has just joined the labeled audio (points or
         regions) */
      XO("Joined labeled audio (points or regions)"),
      /* i18n-hint: (verb) */
      XO("Join Labeled Audio"));
}

References EditByLabel(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), WaveTrack::Join(), CommandContext::project, project, ProjectHistory::PushState(), ViewInfo::selectedRegion, tracks, Track::TypeSwitch(), TimeStretching::WithClipRenderingProgress(), and XO().

Referenced by LabelEditMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

OnNewLabelTrack()

void anonymous_namespace{LabelMenus.cpp}::OnNewLabelTrack

(

const CommandContext &

context

)

Definition at line 649 of file LabelMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
 
   auto track = LabelTrack::Create(tracks);
 
   SelectUtilities::SelectNone( project );
 
   track->SetSelected(true);
 
   ProjectHistory::Get( project )
      .PushState(XO("Created new label track"), XO("New Track"));
 
   TrackFocus::Get(project).Set(track);
   Viewport::Get(project).ShowTrack(*track);
}

References LabelTrack::Create(), TrackFocus::Get(), ProjectHistory::Get(), TrackList::Get(), Viewport::Get(), CommandContext::project, project, ProjectHistory::PushState(), SelectUtilities::SelectNone(), Viewport::ShowTrack(), tracks, and XO().

Here is the call graph for this function:

OnPasteNewLabel()

void anonymous_namespace{LabelMenus.cpp}::OnPasteNewLabel

(

const CommandContext &

context

)

Definition at line 330 of file LabelMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get( project );
   auto &trackPanel = TrackPanel::Get( project );
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
 
   bool bPastedSomething = false;
 
   {
      auto trackRange = tracks.Selected<const LabelTrack>();
      if (trackRange.empty())
      {
         // If there are no selected label tracks, try to choose the first label
         // track after some other selected track
         Track *t = *tracks.Selected().begin()
            .Filter(&Track::Any)
            .Filter<LabelTrack>();
 
         // If no match found, add one
         if (!t)
            t = LabelTrack::Create(tracks);
 
         // Select this track so the loop picks it up
         t->SetSelected(true);
      }
   }
 
   LabelTrack *plt = NULL; // the previous track
   for ( auto lt : tracks.Selected<LabelTrack>() )
   {
      // Unselect the last label, so we'll have just one active label when
      // we're done
      if (plt)
         LabelTrackView::Get( *plt ).ResetTextSelection();
 
      // Add a NEW label, paste into it
      // Paul L:  copy whatever defines the selected region, not just times
      auto &view = LabelTrackView::Get( *lt );
      view.AddLabel(selectedRegion);
      if (view.PasteSelectedText( context.project, selectedRegion.t0(),
                                selectedRegion.t1() ))
         bPastedSomething = true;
 
      // Set previous track
      plt = lt;
   }
 
   // plt should point to the last label track pasted to -- ensure it's visible
   // and set focus
   if (plt) {
      TrackFocus::Get(project).Set(plt);
      Viewport::Get(project).ShowTrack(*plt);
      trackPanel.SetFocus();
   }
 
   if (bPastedSomething) {
      ProjectHistory::Get( project ).PushState(
         XO("Pasted from the clipboard"), XO("Paste Text to New Label"));
   }
}

References Track::Any(), LabelTrack::Create(), TrackFocus::Get(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), Viewport::Get(), TrackPanel::Get(), LabelTrackView::Get(), CommandContext::project, project, ProjectHistory::PushState(), LabelTrackView::ResetTextSelection(), ViewInfo::selectedRegion, Track::SetSelected(), Viewport::ShowTrack(), tracks, and XO().

Referenced by LabelEditMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSilenceLabels()

void anonymous_namespace{LabelMenus.cpp}::OnSilenceLabels

(

const CommandContext &

context

)

Definition at line 530 of file LabelMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get(project);
   auto &selectedRegion = ViewInfo::Get(project).selectedRegion;
 
   if (selectedRegion.isPoint())
      return;
 
   auto editfunc = [&](Track &track, double t0, double t1) {
      // TODO use progress-bar utilities pending in
      // https://github.com/audacity/audacity/pull/5043
      track.TypeSwitch([&](WaveTrack& t) { t.Silence(t0, t1, {}); });
   };
   EditByLabel(project, tracks, selectedRegion, editfunc);
 
   ProjectHistory::Get(project).PushState(
      /* i18n-hint: (verb)*/
      XO("Silenced labeled audio regions"),
      /* i18n-hint: (verb)*/
      XO("Silence Labeled Audio"));
}

References EditByLabel(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), CommandContext::project, project, ProjectHistory::PushState(), ViewInfo::selectedRegion, WaveTrack::Silence(), tracks, Track::TypeSwitch(), and XO().

Referenced by LabelEditMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSplitCutLabels()

void anonymous_namespace{LabelMenus.cpp}::OnSplitCutLabels

(

const CommandContext &

context

)

Definition at line 468 of file LabelMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get(project);
   auto &selectedRegion = ViewInfo::Get(project).selectedRegion;
 
   if (selectedRegion.isPoint())
      return;
 
   auto copyfunc = [&](Track &track, double t0, double t1) {
      Track::Holder result;
      track.TypeSwitch(
         [&](WaveTrack &wt) {
            result = wt.SplitCut(t0, t1);
         },
         [&](Track &t) {
            result = t.Copy(t0, t1);
            t.Silence(t0, t1);
         }
      );
      return result;
   };
   EditClipboardByLabel(project, tracks, selectedRegion, copyfunc);
 
   ProjectHistory::Get(project).PushState(
      /* i18n-hint: (verb) Audacity has just split cut the labeled audio
         regions*/
      XO("Split Cut labeled audio regions to clipboard"),
      /* i18n-hint: (verb) Do a special kind of cut on the labels*/
      XO("Split Cut Labeled Audio"));
}

References EditClipboardByLabel(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), CommandContext::project, project, ProjectHistory::PushState(), ViewInfo::selectedRegion, WaveTrack::SplitCut(), tracks, Track::TypeSwitch(), and XO().

Referenced by LabelEditMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSplitDeleteLabels()

void anonymous_namespace{LabelMenus.cpp}::OnSplitDeleteLabels

(

const CommandContext &

context

)

Definition at line 500 of file LabelMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get(project);
   auto &selectedRegion = ViewInfo::Get(project).selectedRegion;
 
   if (selectedRegion.isPoint())
      return;
 
   auto editfunc = [&](Track &track, double t0, double t1) {
      track.TypeSwitch(
         [&](WaveTrack &t) {
            t.SplitDelete(t0, t1);
         },
         [&](Track &t) {
            t.Silence(t0, t1);
         }
      );
   };
   EditByLabel(project, tracks, selectedRegion, editfunc);
 
   ProjectHistory::Get(project).PushState(
      /* i18n-hint: (verb) Audacity has just done a special kind of DELETE on
         the labeled audio regions */
      XO("Split Deleted labeled audio regions"),
      /* i18n-hint: (verb) Do a special kind of DELETE on labeled audio
         regions */
      XO("Split Delete Labeled Audio"));
}

References EditByLabel(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), CommandContext::project, project, ProjectHistory::PushState(), ViewInfo::selectedRegion, WaveTrack::Silence(), WaveTrack::SplitDelete(), tracks, Track::TypeSwitch(), and XO().

Referenced by LabelEditMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSplitLabels()

void anonymous_namespace{LabelMenus.cpp}::OnSplitLabels

(

const CommandContext &

context

)

Definition at line 575 of file LabelMenus.cpp.

{
   auto &project = context.project;
   auto &tracks = TrackList::Get(project);
   auto &selectedRegion = ViewInfo::Get(project).selectedRegion;
 
   if (selectedRegion.isPoint())
      return;
 
   auto editfunc = [&](Track &track, double t0, double t1) {
      track.TypeSwitch( [&](WaveTrack &t) { t.Split(t0, t1); } );
   };
   EditByLabel(project, tracks, selectedRegion, editfunc);
 
   ProjectHistory::Get(project).PushState(
      /* i18n-hint: (verb) past tense.  Audacity has just split the labeled
         audio (a point or a region)*/
      XO("Split labeled audio (points or regions)"),
      /* i18n-hint: (verb)*/
      XO("Split Labeled Audio"));
}

References EditByLabel(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), CommandContext::project, project, ProjectHistory::PushState(), ViewInfo::selectedRegion, WaveTrack::Split(), tracks, Track::TypeSwitch(), and XO().

Referenced by LabelEditMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

OnToggleTypeToCreateLabel()

void anonymous_namespace{LabelMenus.cpp}::OnToggleTypeToCreateLabel

(

const CommandContext &

WXUNUSEDcontext

)

Definition at line 392 of file LabelMenus.cpp.

{
   bool typeToCreateLabel;
   gPrefs->Read(wxT("/GUI/TypeToCreateLabel"), &typeToCreateLabel, false);
   gPrefs->Write(wxT("/GUI/TypeToCreateLabel"), !typeToCreateLabel);
   gPrefs->Flush();
   ToolManager::ModifyAllProjectToolbarMenus();
}

References audacity::BasicSettings::Flush(), gPrefs, ToolManager::ModifyAllProjectToolbarMenus(), audacity::BasicSettings::Read(), audacity::BasicSettings::Write(), and wxT().

Referenced by LabelEditMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

sAttachment1

AttachedItem anonymous_namespace{LabelMenus.cpp}::sAttachment1

Initial value:

{ Indirect(LabelEditMenus()),
   { wxT("Edit/Other"),
     { OrderingHint::Before, wxT("EditMetaData") } }
}

Definition at line 768 of file LabelMenus.cpp.

sAttachment2

AttachedItem anonymous_namespace{LabelMenus.cpp}::sAttachment2

Initial value:

{
   Command( wxT("NewLabelTrack"), XXO("&Label Track"),
      OnNewLabelTrack, AudioIONotBusyFlag() ),
   wxT("Tracks/Add/Add")
}

Definition at line 773 of file LabelMenus.cpp.