anonymous_namespace{TrackMenus.cpp} Namespace Reference

Enumerations
enum	{   kAlignStartZero = 0 , kAlignStartSelStart , kAlignStartSelEnd , kAlignEndSelStart ,   kAlignEndSelEnd , kAlignEndToEnd , kAlignTogether }
enum	{ kAudacitySortByTime = (1 << 1) , kAudacitySortByName = (1 << 2) }

Functions
void	DoMixAndRender (AudacityProject &project, bool toNewTrack)
void	DoPanTracks (AudacityProject &project, float PanValue)
static const std::vector< ComponentInterfaceSymbol > &	alignLabels ()
const size_t	kAlignLabelsCount ()
void	DoAlign (AudacityProject &project, int index, bool moveSel)
void	DoSortTracks (AudacityProject &project, int flags)
void	SetTrackGain (AudacityProject &project, WaveTrack *wt, LWSlider *slider)
void	SetTrackPan (AudacityProject &project, WaveTrack *wt, LWSlider *slider)
void	OnStereoToMono (const CommandContext &context)
void	OnMixAndRender (const CommandContext &context)
void	OnMixAndRenderToNewTrack (const CommandContext &context)
void	OnResample (const CommandContext &context)
void	OnRemoveTracks (const CommandContext &context)
static void	MuteTracks (const CommandContext &context, bool mute, bool selected)
void	OnMuteAllTracks (const CommandContext &context)
void	OnUnmuteAllTracks (const CommandContext &context)
void	OnMuteSelectedTracks (const CommandContext &context)
void	OnUnmuteSelectedTracks (const CommandContext &context)
void	OnPanLeft (const CommandContext &context)
void	OnPanRight (const CommandContext &context)
void	OnPanCenter (const CommandContext &context)
void	OnAlignNoSync (const CommandContext &context)
void	OnAlign (const CommandContext &context)
void	OnMoveSelectionWithTracks (const CommandContext &WXUNUSED(context))
void	OnSortTime (const CommandContext &context)
void	OnSortName (const CommandContext &context)
void	OnSyncLock (const CommandContext &context)
void	OnTrackPan (const CommandContext &context)
void	OnTrackPanLeft (const CommandContext &context)
void	OnTrackPanRight (const CommandContext &context)
void	OnTrackGain (const CommandContext &context)
void	OnTrackGainInc (const CommandContext &context)
void	OnTrackGainDec (const CommandContext &context)
void	OnTrackMenu (const CommandContext &context)
void	OnTrackMute (const CommandContext &context)
void	OnTrackSolo (const CommandContext &context)
void	OnTrackClose (const CommandContext &context)
void	OnTrackMoveUp (const CommandContext &context)
void	OnTrackMoveDown (const CommandContext &context)
void	OnTrackMoveTop (const CommandContext &context)
void	OnTrackMoveBottom (const CommandContext &context)
BaseItemSharedPtr	TracksMenu ()
BaseItemSharedPtr	ExtraTrackMenu ()

Variables
AttachedItem	sAttachment1
AttachedItem	sAttachment2

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
kAlignStartZero
kAlignStartSelStart
kAlignStartSelEnd
kAlignEndSelStart
kAlignEndSelEnd
kAlignEndToEnd
kAlignTogether

Definition at line 177 of file TrackMenus.cpp.

     {
   kAlignStartZero = 0,
   kAlignStartSelStart,
   kAlignStartSelEnd,
   kAlignEndSelStart,
   kAlignEndSelEnd,
   // The next two are only in one subMenu, so more easily handled at the end.
   kAlignEndToEnd,
   kAlignTogether
};

anonymous enum

anonymous enum

Enumerator
kAudacitySortByTime
kAudacitySortByName

Definition at line 496 of file TrackMenus.cpp.

    {
   kAudacitySortByTime = (1 << 1),
   kAudacitySortByName = (1 << 2),
};

Function Documentation

alignLabels()

static const std::vector< ComponentInterfaceSymbol > & anonymous_namespace{TrackMenus.cpp}::alignLabels ( )

static

Definition at line 189 of file TrackMenus.cpp.

               { static std::vector< ComponentInterfaceSymbol > symbols{
   { wxT("StartToZero"),     XXO("Start to &Zero") },
   { wxT("StartToSelStart"), XXO("Start to &Cursor/Selection Start") },
   { wxT("StartToSelEnd"),   XXO("Start to Selection &End") },
   { wxT("EndToSelStart"),   XXO("End to Cu&rsor/Selection Start") },
   { wxT("EndToSelEnd"),     XXO("End to Selection En&d") },
}; return symbols; }

References wxT(), and XXO().

Referenced by kAlignLabelsCount(), and TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

DoAlign()

void anonymous_namespace{TrackMenus.cpp}::DoAlign	(	AudacityProject &	project,
		int	index,
		bool	moveSel
	)

Definition at line 199 of file TrackMenus.cpp.

{
   auto &tracks = TrackList::Get( project );
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
   auto &window = ProjectWindow::Get( project );
 
   TranslatableString action, shortAction;
   double delta = 0.0;
   double newPos = -1.0;
 
   auto channelRange = tracks.Selected< AudioTrack >();
   auto trackRange = tracks.SelectedLeaders< AudioTrack >();
 
   auto FindOffset = []( const Track *pTrack ) {
      return TrackList::Channels(pTrack).min( &Track::GetOffset ); };
 
   auto firstTrackOffset = [&]{ return FindOffset( *trackRange.begin() ); };
   auto minOffset = [&]{ return trackRange.min( FindOffset ); };
   auto avgOffset = [&]{
      return trackRange.sum( FindOffset ) /
                             std::max( size_t(1), trackRange.size() ); };
 
   auto maxEndOffset = [&]{
      return std::max(0.0, channelRange.max( &Track::GetEndTime ) ); };
 
   switch(index) {
   case kAlignStartZero:
      delta = -minOffset();
      action = moveSel
         /* i18n-hint: In this and similar messages describing editing actions,
            the starting or ending points of tracks are re-"aligned" to other
            times, and the time selection may be "moved" too.  The first
            noun -- "start" in this example -- is the object of a verb (not of
            an implied preposition "from"). */
         ? XO("Aligned/Moved start to zero")
         : XO("Aligned start to zero");
      shortAction = moveSel
         /* i18n-hint: This and similar messages give shorter descriptions of
            the aligning and moving editing actions */
         ? XO("Align/Move Start")
         : XO("Align Start");
      break;
   case kAlignStartSelStart:
      delta = selectedRegion.t0() - minOffset();
      action = moveSel
         ? XO("Aligned/Moved start to cursor/selection start")
         : XO("Aligned start to cursor/selection start");
      shortAction = moveSel
         ? XO("Align/Move Start")
         : XO("Align Start");
      break;
   case kAlignStartSelEnd:
      delta = selectedRegion.t1() - minOffset();
      action = moveSel
         ? XO("Aligned/Moved start to selection end")
         : XO("Aligned start to selection end");
      shortAction = moveSel
         ? XO("Align/Move Start")
         : XO("Align Start");
      break;
   case kAlignEndSelStart:
      delta = selectedRegion.t0() - maxEndOffset();
      action = moveSel
         ? XO("Aligned/Moved end to cursor/selection start")
         : XO("Aligned end to cursor/selection start");
      shortAction =
         moveSel
         ? XO("Align/Move End")
         : XO("Align End");
      break;
   case kAlignEndSelEnd:
      delta = selectedRegion.t1() - maxEndOffset();
      action = moveSel
         ? XO("Aligned/Moved end to selection end")
         : XO("Aligned end to selection end");
      shortAction =
         moveSel
         ? XO("Align/Move End")
         : XO("Align End");
      break;
   // index set in alignLabelsNoSync
   case kAlignEndToEnd:
      newPos = firstTrackOffset();
      action = moveSel
         ? XO("Aligned/Moved end to end")
         : XO("Aligned end to end");
      shortAction =
         moveSel
         ? XO("Align/Move End to End")
         : XO("Align End to End");
      break;
   case kAlignTogether:
      newPos = avgOffset();
      action = moveSel
         ? XO("Aligned/Moved together")
         : XO("Aligned together");
      shortAction =
         moveSel
         ? XO("Align/Move Together")
         : XO("Align Together");
   }
 
   if ((unsigned)index >= kAlignLabelsCount()) {
      // This is an alignLabelsNoSync command.
      for (auto t : tracks.SelectedLeaders< AudioTrack >()) {
         // This shifts different tracks in different ways, so no sync-lock
         // move.
         // Only align Wave and Note tracks end to end.
         auto channels = TrackList::Channels(t);
 
         auto trackStart = channels.min( &Track::GetStartTime );
         auto trackEnd = channels.max( &Track::GetEndTime );
 
         for (auto channel : channels)
            // Move the track
            channel->SetOffset(newPos + channel->GetStartTime() - trackStart);
 
         if (index == kAlignEndToEnd)
            newPos += (trackEnd - trackStart);
      }
      if (index == kAlignEndToEnd)
         window.DoZoomFit();
   }
 
   if (delta != 0.0) {
      // For a fixed-distance shift move sync-lock selected tracks also.
      for (auto t : tracks.Any()
           + &SyncLock::IsSelectedOrSyncLockSelected )
         t->SetOffset(t->GetOffset() + delta);
   }
 
   if (moveSel)
      selectedRegion.move(delta);
 
   ProjectHistory::Get( project ).PushState(action, shortAction);
}

References TrackList::Channels(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), ProjectWindow::Get(), Track::GetEndTime(), Track::GetOffset(), Track::GetStartTime(), SyncLock::IsSelectedOrSyncLockSelected(), kAlignEndSelEnd, kAlignEndSelStart, kAlignEndToEnd, kAlignLabelsCount(), kAlignStartSelEnd, kAlignStartSelStart, kAlignStartZero, kAlignTogether, ProjectHistory::PushState(), ViewInfo::selectedRegion, ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::size(), and XO().

Referenced by OnAlign(), and OnAlignNoSync().

Here is the call graph for this function:

Here is the caller graph for this function:

DoMixAndRender()

void anonymous_namespace{TrackMenus.cpp}::DoMixAndRender	(	AudacityProject &	project,
		bool	toNewTrack
	)

Definition at line 48 of file TrackMenus.cpp.

{
   auto &tracks = TrackList::Get( project );
   auto &trackFactory = WaveTrackFactory::Get( project );
   auto rate = ProjectRate::Get(project).GetRate();
   auto defaultFormat = QualitySettings::SampleFormatChoice();
   auto &trackPanel = TrackPanel::Get( project );
   auto &window = ProjectWindow::Get( project );
 
   auto trackRange = tracks.Selected< WaveTrack >();
   WaveTrack::Holder uNewLeft, uNewRight;
   ::MixAndRender(trackRange.Filter<const WaveTrack>(),
      Mixer::WarpOptions{ tracks },
      tracks.MakeUniqueTrackName(_("Mix")),
      &trackFactory, rate, defaultFormat, 0.0, 0.0, uNewLeft, uNewRight);
 
   if (uNewLeft) {
      // Remove originals, get stats on what tracks were mixed
 
      // But before removing, determine the first track after the removal
      auto last = *trackRange.rbegin();
      auto insertionPoint = * ++ tracks.Find( last );
      
      auto selectedCount = (trackRange + &Track::IsLeader).size();
      wxString firstName;
      int firstColour = -1;
      if (selectedCount > 0) {
         firstName = (*trackRange.begin())->GetName();
         firstColour = (*trackRange.begin())->GetWaveColorIndex();
      }
      if (!toNewTrack)  {
         // Beware iterator invalidation!
         for (auto &it = trackRange.first, &end = trackRange.second; it != end;)
            tracks.Remove( *it++ );
      }
 
      // Add NEW tracks
 
      auto pNewLeft = tracks.Add( uNewLeft );
      decltype(pNewLeft) pNewRight{};
      if (uNewRight)
      {
         pNewRight = tracks.Add(uNewRight);
         tracks.MakeMultiChannelTrack(*pNewLeft, 2, true);
      }
 
      // If we're just rendering (not mixing), keep the track name the same
      if (selectedCount==1) {
         pNewLeft->SetName(firstName);
         if (pNewRight) {
            pNewRight->SetName(firstName);
         }
      }
 
      // Bug 2218, remember more things...
      if (selectedCount>=1) {
         pNewLeft->SetWaveColorIndex(firstColour);
         pNewLeft->SetSelected(!toNewTrack);
         if (pNewRight) {
            pNewRight->SetWaveColorIndex(firstColour);
            pNewRight->SetSelected(!toNewTrack);
         }
      }
 
      // Permute the tracks as needed
      // The new track appears after the old tracks (or where the old tracks
      // had been) so that they are in the same sync-lock group
      if (insertionPoint)
      {
         std::vector<TrackNodePointer> arr;
         arr.reserve( tracks.size() );
         size_t begin = 0, ii = 0;
         for (auto iter = tracks.ListOfTracks::begin(),
              end = tracks.ListOfTracks::end(); iter != end; ++iter) {
            arr.push_back( {iter, &tracks} );
            if ( iter->get() == insertionPoint )
               begin = ii;
            ++ii;
         }
         auto mid = arr.end();
         std::advance( mid, -TrackList::Channels( pNewLeft ).size() );
         std::rotate( arr.begin() + begin, mid, arr.end() );
         tracks.Permute( arr );
      }
 
      // Smart history/undo message
      if (selectedCount==1) {
         auto msg = XO("Rendered all audio in track '%s'").Format( firstName );
         /* i18n-hint: Convert the audio into a more usable form, so apply
          * panning and amplification and write to some external file.*/
         ProjectHistory::Get( project ).PushState(msg, XO("Render"));
      }
      else {
         auto msg = (pNewRight
            ? XO("Mixed and rendered %d tracks into one new stereo track")
            : XO("Mixed and rendered %d tracks into one new mono track")
         )
            .Format( (int)selectedCount );
         ProjectHistory::Get( project ).PushState(msg, XO("Mix and Render"));
      }
 
      trackPanel.SetFocus();
      TrackFocus::Get( project ).Set( pNewLeft );
      pNewLeft->EnsureVisible();
   }
}

References _, PackedArray::begin(), TrackList::Channels(), PackedArray::end(), Track::EnsureVisible(), TrackFocus::Get(), ProjectHistory::Get(), ProjectRate::Get(), TrackList::Get(), ProjectWindow::Get(), TrackPanel::Get(), WaveTrackFactory::Get(), ProjectRate::GetRate(), Track::IsLeader(), MixAndRender(), ProjectHistory::PushState(), QualitySettings::SampleFormatChoice(), size, and XO().

Referenced by OnMixAndRender(), and OnMixAndRenderToNewTrack().

Here is the call graph for this function:

Here is the caller graph for this function:

DoPanTracks()

void anonymous_namespace{TrackMenus.cpp}::DoPanTracks	(	AudacityProject &	project,
		float	PanValue
	)

Definition at line 156 of file TrackMenus.cpp.

{
   auto &tracks = TrackList::Get( project );
   auto &window = ProjectWindow::Get( project );
 
   // count selected wave tracks
   const auto range = tracks.Any< WaveTrack >();
   const auto selectedRange = range + &Track::IsSelected;
   auto count = selectedRange.size();
 
   // iter through them, all if none selected.
   for (auto left : count == 0 ? range : selectedRange )
      left->SetPan( PanValue );
 
   auto flags = UndoPush::NONE;
   ProjectHistory::Get( project )
      /*i18n-hint: One or more audio tracks have been panned*/
      .PushState(XO("Panned audio track(s)"), XO("Pan Track"), flags);
         flags = flags | UndoPush::CONSOLIDATE;
}

References CONSOLIDATE, ProjectHistory::Get(), TrackList::Get(), ProjectWindow::Get(), Track::IsSelected(), NONE, ProjectHistory::PushState(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::size(), and XO().

Referenced by OnPanCenter(), OnPanLeft(), and OnPanRight().

Here is the call graph for this function:

Here is the caller graph for this function:

DoSortTracks()

void anonymous_namespace{TrackMenus.cpp}::DoSortTracks	(	AudacityProject &	project,
		int	flags
	)

Definition at line 501 of file TrackMenus.cpp.

{
   auto GetTime = [](const Track *t) {
      return t->TypeSwitch< double >(
         [&](const WaveTrack* w) {
            auto stime = w->GetEndTime();
 
            int ndx;
            for (ndx = 0; ndx < w->GetNumClips(); ndx++) {
               const auto c = w->GetClipByIndex(ndx);
               if (c->GetPlaySamplesCount() == 0)
                  continue;
               stime = std::min(stime, c->GetPlayStartTime());
            }
            return stime;
         },
         [&](const LabelTrack* l) {
            return l->GetStartTime();
         }
      );
   };
 
   size_t ndx = 0;
   // This one place outside of TrackList where we must use undisguised
   // std::list iterators!  Avoid this elsewhere!
   std::vector<TrackNodePointer> arr;
   auto &tracks = TrackList::Get( project );
   arr.reserve(tracks.size());
 
   // First find the permutation.
   // This routine, very unusually, deals with the underlying stl list
   // iterators, not with TrackIter!  Dangerous!
   for (auto iter = tracks.ListOfTracks::begin(),
        end = tracks.ListOfTracks::end(); iter != end; ++iter) {
      const auto &track = *iter;
      if ( !track->IsLeader() )
         // keep channels contiguous
         ndx++;
      else {
         auto size = arr.size();
         for (ndx = 0; ndx < size;) {
            Track &arrTrack = **arr[ndx].first;
            auto channels = TrackList::Channels(&arrTrack);
            if(flags & kAudacitySortByName) {
               //do case insensitive sort - cmpNoCase returns less than zero if
               // the string is 'less than' its argument
               //also if we have case insensitive equality, then we need to sort
               // by case as well
               //We sort 'b' before 'B' accordingly.  We uncharacteristically
               // use greater than for the case sensitive
               //compare because 'b' is greater than 'B' in ascii.
               auto cmpValue = track->GetName().CmpNoCase(arrTrack.GetName());
               if ( cmpValue < 0 ||
                     ( 0 == cmpValue &&
                        track->GetName().CompareTo(arrTrack.GetName()) > 0 ) )
                  break;
            }
            //sort by time otherwise
            else if(flags & kAudacitySortByTime) {
               auto time1 = TrackList::Channels(track.get()).min( GetTime );
 
               //get candidate's (from sorted array) time
               auto time2 = channels.min( GetTime );
 
               if (time1 < time2)
                  break;
            }
            ndx += channels.size();
         }
      }
      arr.insert(arr.begin() + ndx, TrackNodePointer{iter, &tracks});
   }
 
   // Now apply the permutation
   tracks.Permute(arr);
}

References TrackList::Channels(), PackedArray::end(), TrackList::Get(), Track::GetName(), kAudacitySortByName, kAudacitySortByTime, min(), and size.

Referenced by OnSortName(), and OnSortTime().

Here is the call graph for this function:

Here is the caller graph for this function:

ExtraTrackMenu()

BaseItemSharedPtr anonymous_namespace{TrackMenus.cpp}::ExtraTrackMenu

(

)

Definition at line 1348 of file TrackMenus.cpp.

{
   using Options = CommandManager::Options;
   static BaseItemSharedPtr menu{
   Menu( wxT("Track"), XXO("&Track"),
      Command( wxT("TrackPan"), XXO("Change P&an on Focused Track..."),
         OnTrackPan,
         TrackPanelHasFocus() | TracksExistFlag(), wxT("Shift+P") ),
      Command( wxT("TrackPanLeft"), XXO("Pan &Left on Focused Track"),
         OnTrackPanLeft,
         TrackPanelHasFocus() | TracksExistFlag(), wxT("Alt+Shift+Left") ),
      Command( wxT("TrackPanRight"), XXO("Pan &Right on Focused Track"),
         OnTrackPanRight,
         TrackPanelHasFocus() | TracksExistFlag(), wxT("Alt+Shift+Right") ),
      Command( wxT("TrackGain"), XXO("Change Gai&n on Focused Track..."),
         OnTrackGain,
         TrackPanelHasFocus() | TracksExistFlag(), wxT("Shift+G") ),
      Command( wxT("TrackGainInc"), XXO("&Increase Gain on Focused Track"),
         OnTrackGainInc,
         TrackPanelHasFocus() | TracksExistFlag(), wxT("Alt+Shift+Up") ),
      Command( wxT("TrackGainDec"), XXO("&Decrease Gain on Focused Track"),
         OnTrackGainDec,
         TrackPanelHasFocus() | TracksExistFlag(), wxT("Alt+Shift+Down") ),
      Command( wxT("TrackMenu"), XXO("Op&en Menu on Focused Track..."),
         OnTrackMenu,
         TracksExistFlag() | TrackPanelHasFocus(),
         Options{ wxT("Shift+M") }.SkipKeyDown() ),
      Command( wxT("TrackMute"), XXO("M&ute/Unmute Focused Track"),
         OnTrackMute,
         TracksExistFlag() | TrackPanelHasFocus(), wxT("Shift+U") ),
      Command( wxT("TrackSolo"), XXO("&Solo/Unsolo Focused Track"),
         OnTrackSolo,
         TracksExistFlag() | TrackPanelHasFocus(), wxT("Shift+S") ),
      Command( wxT("TrackClose"), XXO("&Close Focused Track"),
         OnTrackClose,
         AudioIONotBusyFlag() | TrackPanelHasFocus() | TracksExistFlag(),
         wxT("Shift+C") ),
      Command( wxT("TrackMoveUp"), XXO("Move Focused Track U&p"),
         OnTrackMoveUp,
         AudioIONotBusyFlag() | TrackPanelHasFocus() | TracksExistFlag() ),
      Command( wxT("TrackMoveDown"), XXO("Move Focused Track Do&wn"),
         OnTrackMoveDown,
         AudioIONotBusyFlag() | TrackPanelHasFocus() | TracksExistFlag() ),
      Command( wxT("TrackMoveTop"), XXO("Move Focused Track to T&op"),
         OnTrackMoveTop,
         AudioIONotBusyFlag() | TrackPanelHasFocus() | TracksExistFlag() ),
      Command( wxT("TrackMoveBottom"), XXO("Move Focused Track to &Bottom"),
         OnTrackMoveBottom,
         AudioIONotBusyFlag() | TrackPanelHasFocus() | TracksExistFlag() )
   ) };
   return menu;
}

References AudioIONotBusyFlag(), MenuTable::Command(), MenuTable::Menu(), OnTrackClose(), OnTrackGain(), OnTrackGainDec(), OnTrackGainInc(), OnTrackMenu(), OnTrackMoveBottom(), OnTrackMoveDown(), OnTrackMoveTop(), OnTrackMoveUp(), OnTrackMute(), OnTrackPan(), OnTrackPanLeft(), OnTrackPanRight(), OnTrackSolo(), TrackPanelHasFocus(), TracksExistFlag(), wxT(), and XXO().

Here is the call graph for this function:

kAlignLabelsCount()

const size_t anonymous_namespace{TrackMenus.cpp}::kAlignLabelsCount

(

)

Definition at line 197 of file TrackMenus.cpp.

{ return alignLabels().size(); }

References alignLabels().

Referenced by DoAlign(), and OnAlignNoSync().

Here is the call graph for this function:

Here is the caller graph for this function:

MuteTracks()

static void anonymous_namespace{TrackMenus.cpp}::MuteTracks ( const CommandContext &  context, bool  mute, bool  selected  )

static

Definition at line 744 of file TrackMenus.cpp.

{
   auto &project = context.project;
   const auto &settings = ProjectSettings::Get( project );
   auto &tracks = TrackList::Get( project );
   auto &window = ProjectWindow::Get( project );
 
   auto soloSimple = settings.IsSoloSimple();
   auto soloNone = settings.IsSoloNone();
 
   auto iter = selected ? tracks.Selected<PlayableTrack>() : tracks.Any<PlayableTrack>();
   for (auto pt : iter)
   {
      pt->SetMute(mute);
      if (soloSimple || soloNone)
         pt->SetSolo(false);
   }
 
   ProjectHistory::Get( project ).ModifyState(true);
}

References Track::Any(), ProjectHistory::Get(), TrackList::Get(), ProjectSettings::Get(), ProjectWindow::Get(), ProjectHistory::ModifyState(), CommandContext::project, PlayableTrack::SetMute(), and settings().

Referenced by OnMuteAllTracks(), OnMuteSelectedTracks(), OnUnmuteAllTracks(), and OnUnmuteSelectedTracks().

Here is the call graph for this function:

Here is the caller graph for this function:

OnAlign()

void anonymous_namespace{TrackMenus.cpp}::OnAlign

(

const CommandContext &

context

)

Definition at line 811 of file TrackMenus.cpp.

{
   auto &project = context.project;
 
   bool bMoveWith;
   gPrefs->Read(wxT("/GUI/MoveSelectionWithTracks"), &bMoveWith, false);
   DoAlign(project, context.index, bMoveWith);
}

References DoAlign(), gPrefs, CommandContext::index, CommandContext::project, and wxT().

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnAlignNoSync()

void anonymous_namespace{TrackMenus.cpp}::OnAlignNoSync

(

const CommandContext &

context

)

Definition at line 803 of file TrackMenus.cpp.

{
   auto &project = context.project;
 
   DoAlign(project,
      context.index + kAlignLabelsCount(), false);
}

References DoAlign(), CommandContext::index, kAlignLabelsCount(), and CommandContext::project.

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnMixAndRender()

void anonymous_namespace{TrackMenus.cpp}::OnMixAndRender

(

const CommandContext &

context

)

Definition at line 620 of file TrackMenus.cpp.

{
   auto &project = context.project;
   DoMixAndRender(project, false);
}

References DoMixAndRender(), and CommandContext::project.

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnMixAndRenderToNewTrack()

void anonymous_namespace{TrackMenus.cpp}::OnMixAndRenderToNewTrack

(

const CommandContext &

context

)

Definition at line 626 of file TrackMenus.cpp.

{
   auto &project = context.project;
   DoMixAndRender(project, true);
}

References DoMixAndRender(), and CommandContext::project.

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnMoveSelectionWithTracks()

void anonymous_namespace{TrackMenus.cpp}::OnMoveSelectionWithTracks

(

const CommandContext &

WXUNUSEDcontext

)

Definition at line 828 of file TrackMenus.cpp.

{
   bool bMoveWith;
   gPrefs->Read(wxT("/GUI/MoveSelectionWithTracks"), &bMoveWith, false);
   gPrefs->Write(wxT("/GUI/MoveSelectionWithTracks"), !bMoveWith);
   gPrefs->Flush();
 
}

References FileConfig::Flush(), gPrefs, and wxT().

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnMuteAllTracks()

void anonymous_namespace{TrackMenus.cpp}::OnMuteAllTracks

(

const CommandContext &

context

)

Definition at line 765 of file TrackMenus.cpp.

{
   MuteTracks(context, true, false);
}

References MuteTracks().

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnMuteSelectedTracks()

void anonymous_namespace{TrackMenus.cpp}::OnMuteSelectedTracks

(

const CommandContext &

context

)

Definition at line 775 of file TrackMenus.cpp.

{
   MuteTracks(context, true, true);
}

References MuteTracks().

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnPanCenter()

void anonymous_namespace{TrackMenus.cpp}::OnPanCenter

(

const CommandContext &

context

)

Definition at line 797 of file TrackMenus.cpp.

{
   auto &project = context.project;
   DoPanTracks( project, 0.0);
}

References DoPanTracks(), and CommandContext::project.

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnPanLeft()

void anonymous_namespace{TrackMenus.cpp}::OnPanLeft

(

const CommandContext &

context

)

Definition at line 785 of file TrackMenus.cpp.

{
   auto &project = context.project;
   DoPanTracks( project, -1.0);
}

References DoPanTracks(), and CommandContext::project.

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnPanRight()

void anonymous_namespace{TrackMenus.cpp}::OnPanRight

(

const CommandContext &

context

)

Definition at line 791 of file TrackMenus.cpp.

{
   auto &project = context.project;
   DoPanTracks( project, 1.0);
}

References DoPanTracks(), and CommandContext::project.

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnRemoveTracks()

void anonymous_namespace{TrackMenus.cpp}::OnRemoveTracks

(

const CommandContext &

context

)

Definition at line 739 of file TrackMenus.cpp.

{
   TrackUtilities::DoRemoveTracks( context.project );
}

References TrackUtilities::DoRemoveTracks(), and CommandContext::project.

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnResample()

void anonymous_namespace{TrackMenus.cpp}::OnResample

(

const CommandContext &

context

)

Definition at line 632 of file TrackMenus.cpp.

{
   auto &project = context.project;
   auto projectRate = ProjectRate::Get(project).GetRate();
   auto &tracks = TrackList::Get( project );
   auto &undoManager = UndoManager::Get( project );
   auto &window = ProjectWindow::Get( project );
 
   int newRate;
 
   while (true)
   {
      wxDialogWrapper dlg(&window, wxID_ANY, XO("Resample"));
      ShuttleGui S(&dlg, eIsCreating);
      wxString rate;
      wxComboBox *cb;
 
      rate.Printf(wxT("%ld"), lrint(projectRate));
 
      wxArrayStringEx rates{
         wxT("8000") ,
         wxT("11025") ,
         wxT("16000") ,
         wxT("22050") ,
         wxT("32000") ,
         wxT("44100") ,
         wxT("48000") ,
         wxT("88200") ,
         wxT("96000") ,
         wxT("176400") ,
         wxT("192000") ,
         wxT("352800") ,
         wxT("384000") ,
      };
 
      S.StartVerticalLay(true);
      {
         S.AddSpace(-1, 15);
 
         S.StartHorizontalLay(wxCENTER, false);
         {
            cb = S.AddCombo(XXO("New sample rate (Hz):"),
                            rate,
                            rates);
         }
         S.EndHorizontalLay();
 
         S.AddSpace(-1, 15);
 
         S.AddStandardButtons();
      }
      S.EndVerticalLay();
 
      dlg.Layout();
      dlg.Fit();
      dlg.Center();
 
      if (dlg.ShowModal() != wxID_OK)
      {
         return;  // user cancelled dialog
      }
 
      long lrate;
      if (cb->GetValue().ToLong(&lrate) && lrate >= 1 && lrate <= 1000000)
      {
         newRate = (int)lrate;
         break;
      }
 
      AudacityMessageBox(
         XO("The entered value is invalid"),
         XO("Error"),
         wxICON_ERROR,
         &window);
   }
 
   int ndx = 0;
   auto flags = UndoPush::NONE;
   for (auto wt : tracks.Selected< WaveTrack >())
   {
      auto msg = XO("Resampling track %d").Format( ++ndx );
 
      using namespace BasicUI;
      auto progress = MakeProgress(XO("Resample"), msg);
 
      // The resampling of a track may be stopped by the user.  This might
      // leave a track with multiple clips in a partially resampled state.
      // But the thrown exception will cause rollback in the application
      // level handler.
 
       wt->Resample(newRate, progress.get());
 
      // Each time a track is successfully, completely resampled,
      // commit that to the undo stack.  The second and later times,
      // consolidate.
 
      ProjectHistory::Get( project ).PushState(
         XO("Resampled audio track(s)"), XO("Resample Track"), flags);
      flags = flags | UndoPush::CONSOLIDATE;
   }
 
   undoManager.StopConsolidating();
 
   // Need to reset
   window.FinishAutoScroll();
}

References AudacityMessageBox(), CONSOLIDATE, eIsCreating, ProjectHistory::Get(), UndoManager::Get(), ProjectRate::Get(), TrackList::Get(), ProjectWindow::Get(), ProjectRate::GetRate(), lrint, BasicUI::MakeProgress(), NONE, CommandContext::project, ProjectHistory::PushState(), S, wxT(), XO(), and XXO().

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSortName()

void anonymous_namespace{TrackMenus.cpp}::OnSortName

(

const CommandContext &

context

)

Definition at line 972 of file TrackMenus.cpp.

{
   auto &project = context.project;
   DoSortTracks(project, kAudacitySortByName);
 
   ProjectHistory::Get( project )
      .PushState(XO("Tracks sorted by name"), XO("Sort by Name"));
}

References DoSortTracks(), ProjectHistory::Get(), kAudacitySortByName, CommandContext::project, ProjectHistory::PushState(), and XO().

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSortTime()

void anonymous_namespace{TrackMenus.cpp}::OnSortTime

(

const CommandContext &

context

)

Definition at line 963 of file TrackMenus.cpp.

{
   auto &project = context.project;
   DoSortTracks(project, kAudacitySortByTime);
 
   ProjectHistory::Get( project )
      .PushState(XO("Tracks sorted by time"), XO("Sort by Time"));
}

References DoSortTracks(), ProjectHistory::Get(), kAudacitySortByTime, CommandContext::project, ProjectHistory::PushState(), and XO().

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnStereoToMono()

void anonymous_namespace{TrackMenus.cpp}::OnStereoToMono

(

const CommandContext &

context

)

Definition at line 612 of file TrackMenus.cpp.

{
   EffectUI::DoEffect(
      EffectManager::Get().GetEffectByIdentifier(wxT("StereoToMono")),
      context,
      EffectManager::kConfigured);
}

References EffectUI::DoEffect(), EffectManager::Get(), EffectManager::kConfigured, and wxT().

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSyncLock()

void anonymous_namespace{TrackMenus.cpp}::OnSyncLock

(

const CommandContext &

context

)

Definition at line 981 of file TrackMenus.cpp.

{
   auto &project = context.project;
   auto &trackPanel = TrackPanel::Get( project );
 
   bool bSyncLockTracks;
   gPrefs->Read(wxT("/GUI/SyncLockTracks"), &bSyncLockTracks, false);
   gPrefs->Write(wxT("/GUI/SyncLockTracks"), !bSyncLockTracks);
   gPrefs->Flush();
 
   // Toolbar, project sync-lock handled within
   ToolManager::ModifyAllProjectToolbarMenus();
 
   trackPanel.Refresh(false);
}

References FileConfig::Flush(), TrackPanel::Get(), gPrefs, ToolManager::ModifyAllProjectToolbarMenus(), CommandContext::project, and wxT().

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTrackClose()

void anonymous_namespace{TrackMenus.cpp}::OnTrackClose

(

const CommandContext &

context

)

Definition at line 1110 of file TrackMenus.cpp.

{
   auto &project = context.project;
   auto &trackPanel = TrackPanel::Get( project );
 
   const auto t = TrackFocus::Get( project ).Get();
   if (!t)
      return;
 
   auto isAudioActive = ProjectAudioIO::Get( project ).IsAudioActive();
 
   if (isAudioActive)
   {
      ProjectStatus::Get( project ).Set(
         XO("Can't delete track with active audio"));
      wxBell();
      return;
   }
 
   TrackUtilities::DoRemoveTrack(project, t);
 
   trackPanel.UpdateViewIfNoTracks();
   trackPanel.Refresh(false);
}

References TrackUtilities::DoRemoveTrack(), TrackFocus::Get(), ProjectAudioIO::Get(), ProjectStatus::Get(), TrackPanel::Get(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get(), ProjectAudioIO::IsAudioActive(), CommandContext::project, ProjectStatus::Set(), and XO().

Referenced by ExtraTrackMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTrackGain()

void anonymous_namespace{TrackMenus.cpp}::OnTrackGain

(

const CommandContext &

context

)

This will pop up the track gain dialog for specified track

Definition at line 1038 of file TrackMenus.cpp.

{
   auto &project = context.project;
   auto &trackPanel = TrackPanel::Get( project );
 
   const auto track = TrackFocus::Get( project ).Get();
   if (track) track->TypeSwitch( [&](WaveTrack *wt) {
      LWSlider *slider = WaveTrackControls::GainSlider( trackPanel, *wt );
      if (slider->ShowDialog())
         SetTrackGain(project, wt, slider);
   });
}

References WaveTrackControls::GainSlider(), TrackFocus::Get(), TrackPanel::Get(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get(), CommandContext::project, SetTrackGain(), and LWSlider::ShowDialog().

Referenced by ExtraTrackMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTrackGainDec()

void anonymous_namespace{TrackMenus.cpp}::OnTrackGainDec

(

const CommandContext &

context

)

Definition at line 1065 of file TrackMenus.cpp.

{
   auto &project = context.project;
   auto &trackPanel = TrackPanel::Get( project );
 
   const auto track = TrackFocus::Get( project ).Get();
   if (track) track->TypeSwitch( [&](WaveTrack *wt) {
      LWSlider *slider = WaveTrackControls::GainSlider( trackPanel, *wt );
      slider->Decrease(1);
      SetTrackGain(project, wt, slider);
   });
}

References LWSlider::Decrease(), WaveTrackControls::GainSlider(), TrackFocus::Get(), TrackPanel::Get(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get(), CommandContext::project, and SetTrackGain().

Referenced by ExtraTrackMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTrackGainInc()

void anonymous_namespace{TrackMenus.cpp}::OnTrackGainInc

(

const CommandContext &

context

)

Definition at line 1052 of file TrackMenus.cpp.

{
   auto &project = context.project;
   auto &trackPanel = TrackPanel::Get( project );
 
   const auto track = TrackFocus::Get( project ).Get();
   if (track) track->TypeSwitch( [&](WaveTrack *wt) {
      LWSlider *slider = WaveTrackControls::GainSlider( trackPanel, *wt );
      slider->Increase(1);
      SetTrackGain(project, wt, slider);
   });
}

References WaveTrackControls::GainSlider(), TrackFocus::Get(), TrackPanel::Get(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get(), LWSlider::Increase(), CommandContext::project, and SetTrackGain().

Referenced by ExtraTrackMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTrackMenu()

void anonymous_namespace{TrackMenus.cpp}::OnTrackMenu

(

const CommandContext &

context

)

Definition at line 1078 of file TrackMenus.cpp.

{
   auto &project = context.project;
   auto &trackPanel = TrackPanel::Get( project );
 
   trackPanel.OnTrackMenu();
}

References TrackPanel::Get(), and CommandContext::project.

Referenced by ExtraTrackMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTrackMoveBottom()

void anonymous_namespace{TrackMenus.cpp}::OnTrackMoveBottom

(

const CommandContext &

context

)

Definition at line 1174 of file TrackMenus.cpp.

{
   auto &project = context.project;
   auto &trackPanel = TrackPanel::Get( project );
   auto &tracks = TrackList::Get( project );
 
   const auto focusedTrack = TrackFocus::Get( project ).Get();
   if (tracks.CanMoveDown(focusedTrack)) {
      DoMoveTrack(project, focusedTrack, TrackUtilities::OnMoveBottomID);
      trackPanel.Refresh(false);
   }
}

References TrackUtilities::DoMoveTrack(), TrackFocus::Get(), TrackList::Get(), TrackPanel::Get(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get(), TrackUtilities::OnMoveBottomID, and CommandContext::project.

Referenced by ExtraTrackMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTrackMoveDown()

void anonymous_namespace{TrackMenus.cpp}::OnTrackMoveDown

(

const CommandContext &

context

)

Definition at line 1148 of file TrackMenus.cpp.

{
   auto &project = context.project;
   auto &trackPanel = TrackPanel::Get( project );
   auto &tracks = TrackList::Get( project );
 
   const auto focusedTrack = TrackFocus::Get( project ).Get();
   if (tracks.CanMoveDown(focusedTrack)) {
      DoMoveTrack(project, focusedTrack, TrackUtilities::OnMoveDownID);
      trackPanel.Refresh(false);
   }
}

References TrackUtilities::DoMoveTrack(), TrackFocus::Get(), TrackList::Get(), TrackPanel::Get(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get(), TrackUtilities::OnMoveDownID, and CommandContext::project.

Referenced by ExtraTrackMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTrackMoveTop()

void anonymous_namespace{TrackMenus.cpp}::OnTrackMoveTop

(

const CommandContext &

context

)

Definition at line 1161 of file TrackMenus.cpp.

{
   auto &project = context.project;
   auto &trackPanel = TrackPanel::Get( project );
   auto &tracks = TrackList::Get( project );
 
   const auto focusedTrack = TrackFocus::Get( project ).Get();
   if (tracks.CanMoveUp(focusedTrack)) {
      DoMoveTrack(project, focusedTrack, TrackUtilities::OnMoveTopID);
      trackPanel.Refresh(false);
   }
}

References TrackUtilities::DoMoveTrack(), TrackFocus::Get(), TrackList::Get(), TrackPanel::Get(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get(), TrackUtilities::OnMoveTopID, and CommandContext::project.

Referenced by ExtraTrackMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTrackMoveUp()

void anonymous_namespace{TrackMenus.cpp}::OnTrackMoveUp

(

const CommandContext &

context

)

Definition at line 1135 of file TrackMenus.cpp.

{
   auto &project = context.project;
   auto &trackPanel = TrackPanel::Get( project );
   auto &tracks = TrackList::Get( project );
 
   const auto focusedTrack = TrackFocus::Get( project ).Get();
   if (tracks.CanMoveUp(focusedTrack)) {
      DoMoveTrack(project, focusedTrack, TrackUtilities::OnMoveUpID);
      trackPanel.Refresh(false);
   }
}

References TrackUtilities::DoMoveTrack(), TrackFocus::Get(), TrackList::Get(), TrackPanel::Get(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get(), TrackUtilities::OnMoveUpID, and CommandContext::project.

Referenced by ExtraTrackMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTrackMute()

void anonymous_namespace{TrackMenus.cpp}::OnTrackMute

(

const CommandContext &

context

)

Definition at line 1086 of file TrackMenus.cpp.

{
   auto &project = context.project;
 
   // Use the temporary selection if it is specified, else the track focus
   auto track = context.temporarySelection.pTrack;
   if (!track)
      track = TrackFocus::Get( project ).Get();
 
   if (track) track->TypeSwitch( [&](PlayableTrack *t) {
      TrackUtilities::DoTrackMute(project, t, false);
   });
}

References TrackUtilities::DoTrackMute(), TrackFocus::Get(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get(), CommandContext::project, TemporarySelection::pTrack, and CommandContext::temporarySelection.

Referenced by ExtraTrackMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTrackPan()

void anonymous_namespace{TrackMenus.cpp}::OnTrackPan

(

const CommandContext &

context

)

The following methods operate controls on specified tracks, This will pop up the track panning dialog for specified track

Definition at line 999 of file TrackMenus.cpp.

{
   auto &project = context.project;
   auto &trackPanel = TrackPanel::Get( project );
 
   const auto track = TrackFocus::Get( project ).Get();
   if (track) track->TypeSwitch( [&](WaveTrack *wt) {
      LWSlider *slider = WaveTrackControls::PanSlider( trackPanel, *wt );
      if (slider->ShowDialog())
         SetTrackPan(project, wt, slider);
   });
}

References TrackFocus::Get(), TrackPanel::Get(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get(), WaveTrackControls::PanSlider(), CommandContext::project, SetTrackPan(), and LWSlider::ShowDialog().

Referenced by ExtraTrackMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTrackPanLeft()

void anonymous_namespace{TrackMenus.cpp}::OnTrackPanLeft

(

const CommandContext &

context

)

Definition at line 1012 of file TrackMenus.cpp.

{
   auto &project = context.project;
   auto &trackPanel = TrackPanel::Get( project );
 
   const auto track = TrackFocus::Get( project ).Get();
   if (track) track->TypeSwitch( [&](WaveTrack *wt) {
      LWSlider *slider = WaveTrackControls::PanSlider( trackPanel, *wt );
      slider->Decrease(1);
      SetTrackPan(project, wt, slider);
   });
}

References LWSlider::Decrease(), TrackFocus::Get(), TrackPanel::Get(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get(), WaveTrackControls::PanSlider(), CommandContext::project, and SetTrackPan().

Referenced by ExtraTrackMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTrackPanRight()

void anonymous_namespace{TrackMenus.cpp}::OnTrackPanRight

(

const CommandContext &

context

)

Definition at line 1025 of file TrackMenus.cpp.

{
   auto &project = context.project;
   auto &trackPanel = TrackPanel::Get( project );
 
   const auto track = TrackFocus::Get( project ).Get();
   if (track) track->TypeSwitch( [&](WaveTrack *wt) {
      LWSlider *slider = WaveTrackControls::PanSlider( trackPanel, *wt );
      slider->Increase(1);
      SetTrackPan(project, wt, slider);
   });
}

References TrackFocus::Get(), TrackPanel::Get(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get(), LWSlider::Increase(), WaveTrackControls::PanSlider(), CommandContext::project, and SetTrackPan().

Referenced by ExtraTrackMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTrackSolo()

void anonymous_namespace{TrackMenus.cpp}::OnTrackSolo

(

const CommandContext &

context

)

Definition at line 1100 of file TrackMenus.cpp.

{
   auto &project = context.project;
 
   const auto track = TrackFocus::Get( project ).Get();
   if (track) track->TypeSwitch( [&](PlayableTrack *t) {
      TrackUtilities::DoTrackSolo(project, t, false);
   });
}

References TrackUtilities::DoTrackSolo(), TrackFocus::Get(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get(), and CommandContext::project.

Referenced by ExtraTrackMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnUnmuteAllTracks()

void anonymous_namespace{TrackMenus.cpp}::OnUnmuteAllTracks

(

const CommandContext &

context

)

Definition at line 770 of file TrackMenus.cpp.

{
   MuteTracks(context, false, false);
}

References MuteTracks().

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnUnmuteSelectedTracks()

void anonymous_namespace{TrackMenus.cpp}::OnUnmuteSelectedTracks

(

const CommandContext &

context

)

Definition at line 780 of file TrackMenus.cpp.

{
   MuteTracks(context, false, true);
}

References MuteTracks().

Referenced by TracksMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

SetTrackGain()

void anonymous_namespace{TrackMenus.cpp}::SetTrackGain	(	AudacityProject &	project,
		WaveTrack *	wt,
		LWSlider *	slider
	)

Definition at line 578 of file TrackMenus.cpp.

{
   wxASSERT(wt);
   float newValue = slider->Get();
 
   for (auto channel : TrackList::Channels(wt))
      channel->SetGain(newValue);
 
   ProjectHistory::Get( project )
      .PushState(XO("Adjusted gain"), XO("Gain"), UndoPush::CONSOLIDATE);
 
   TrackPanel::Get( project ).RefreshTrack(wt);
}

References TrackList::Channels(), CONSOLIDATE, ProjectHistory::Get(), TrackPanel::Get(), LWSlider::Get(), ProjectHistory::PushState(), TrackPanel::RefreshTrack(), and XO().

Referenced by OnTrackGain(), OnTrackGainDec(), and OnTrackGainInc().

Here is the call graph for this function:

Here is the caller graph for this function:

SetTrackPan()

void anonymous_namespace{TrackMenus.cpp}::SetTrackPan	(	AudacityProject &	project,
		WaveTrack *	wt,
		LWSlider *	slider
	)

Definition at line 592 of file TrackMenus.cpp.

{
   wxASSERT(wt);
   float newValue = slider->Get();
 
   for (auto channel : TrackList::Channels(wt))
      channel->SetPan(newValue);
 
   ProjectHistory::Get( project )
      .PushState(XO("Adjusted Pan"), XO("Pan"), UndoPush::CONSOLIDATE);
 
   TrackPanel::Get( project ).RefreshTrack(wt);
}

References TrackList::Channels(), CONSOLIDATE, ProjectHistory::Get(), TrackPanel::Get(), LWSlider::Get(), ProjectHistory::PushState(), TrackPanel::RefreshTrack(), and XO().

Referenced by OnTrackPan(), OnTrackPanLeft(), and OnTrackPanRight().

Here is the call graph for this function:

Here is the caller graph for this function:

TracksMenu()

BaseItemSharedPtr anonymous_namespace{TrackMenus.cpp}::TracksMenu

(

)

Definition at line 1191 of file TrackMenus.cpp.

{
   // Tracks Menu (formerly Project Menu)
   using Options = CommandManager::Options;
   
   static BaseItemSharedPtr menu{
   Menu( wxT("Tracks"), XXO("&Tracks"),
      Section( "Add",
         Menu( wxT("Add"), XXO("Add &New") )
      ),
 
 
      Section( "",
         Menu( wxT("Mix"), XXO("Mi&x"),
            // Delayed evaluation
            // Stereo to Mono is an oddball command that is also subject to control
            // by the plug-in manager, as if an effect.  Decide whether to show or
            // hide it.
            [](AudacityProject&) -> BaseItemPtr {
               const PluginID ID =
                  EffectManager::Get().GetEffectByIdentifier(wxT("StereoToMono"));
               const PluginDescriptor *plug = PluginManager::Get().GetPlugin(ID);
               if (plug && plug->IsEnabled())
                  return Command( wxT("Stereo to Mono"),
                     XXO("Mix Stereo Down to &Mono"), OnStereoToMono,
                     AudioIONotBusyFlag() | StereoRequiredFlag() |
                        WaveTracksSelectedFlag(), Options{} );
               else
                  return {};
            },
            Command( wxT("MixAndRender"), XXO("Mi&x and Render"),
               OnMixAndRender,
               AudioIONotBusyFlag() | WaveTracksSelectedFlag() ),
            Command( wxT("MixAndRenderToNewTrack"),
               XXO("Mix and Render to Ne&w Track"),
               OnMixAndRenderToNewTrack,
               AudioIONotBusyFlag() | WaveTracksSelectedFlag(), wxT("Ctrl+Shift+M") )
         ),
 
         Command( wxT("Resample"), XXO("&Resample..."), OnResample,
            AudioIONotBusyFlag() | WaveTracksSelectedFlag() )
      ),
 
      Section( "",
         Command( wxT("RemoveTracks"), XXO("Remo&ve Tracks"), OnRemoveTracks,
            AudioIONotBusyFlag() | AnyTracksSelectedFlag() )
      ),
 
      Section( "",
         Menu( wxT("Mute"), XXO("M&ute/Unmute"),
            Command( wxT("MuteAllTracks"), XXO("&Mute All Tracks"),
               OnMuteAllTracks, TracksExistFlag(), wxT("Ctrl+U") ),
            Command( wxT("UnmuteAllTracks"), XXO("&Unmute All Tracks"),
               OnUnmuteAllTracks, TracksExistFlag(), wxT("Ctrl+Shift+U") ),
            Command( wxT("MuteTracks"), XXO("Mut&e Tracks"),
               OnMuteSelectedTracks, EditableTracksSelectedFlag(), wxT("Ctrl+Alt+U") ),
            Command( wxT("UnmuteTracks"), XXO("U&nmute Tracks"),
               OnUnmuteSelectedTracks, EditableTracksSelectedFlag(), wxT("Ctrl+Alt+Shift+U") )
         ),
 
         Menu( wxT("Pan"), XXO("&Pan"),
            // As Pan changes are not saved on Undo stack,
            // pan settings for all tracks
            // in the project could very easily be lost unless we
            // require the tracks to be selected.
            Command( wxT("PanLeft"), XXO("&Left"), OnPanLeft,
               EditableTracksSelectedFlag(),
               Options{}.LongName( XO("Pan Left") ) ),
            Command( wxT("PanRight"), XXO("&Right"), OnPanRight,
               EditableTracksSelectedFlag(),
               Options{}.LongName( XO("Pan Right") ) ),
            Command( wxT("PanCenter"), XXO("&Center"), OnPanCenter,
               EditableTracksSelectedFlag(),
               Options{}.LongName( XO("Pan Center") ) )
         )
      ),
 
      Section( "",
         Menu( wxT("Align"), XXO("&Align Tracks"), // XO("Just Move Tracks"),
            Section( "",
               // Mutual alignment of tracks independent of selection or zero
               CommandGroup(wxT("Align"),
                  {
                     { wxT("EndToEnd"),     XXO("&Align End to End") },
                     { wxT("Together"),     XXO("Align &Together") },
                  },
                  OnAlignNoSync, AudioIONotBusyFlag() | EditableTracksSelectedFlag())
            ),
 
            Section( "",
               // Alignment commands using selection or zero
               CommandGroup(wxT("Align"),
                  alignLabels(),
                  OnAlign, AudioIONotBusyFlag() | EditableTracksSelectedFlag())
            ),
 
            Section( "",
               Command( wxT("MoveSelectionWithTracks"),
                  XXO("&Move Selection with Tracks (on/off)"),
                  OnMoveSelectionWithTracks,
                  AlwaysEnabledFlag,
                  Options{}.CheckTest( wxT("/GUI/MoveSelectionWithTracks"), false ) )
            )
         ),
 
   #if 0
         // TODO: Can these labels be made clearer?
         // Do we need this sub-menu at all?
         Menu( wxT("MoveSelectionAndTracks"), XO("Move Sele&ction and Tracks"), {
            CommandGroup(wxT("AlignMove"), alignLabels(),
               OnAlignMoveSel, AudioIONotBusyFlag() | EditableTracksSelectedFlag()),
         } ),
   #endif
 
 
   #ifdef EXPERIMENTAL_SCOREALIGN
         Command( wxT("ScoreAlign"), XXO("Synchronize MIDI with Audio"),
            OnScoreAlign,
            AudioIONotBusyFlag() | NoteTracksSelectedFlag() | WaveTracksSelectedFlag() ),
   #endif // EXPERIMENTAL_SCOREALIGN
 
 
         Menu( wxT("Sort"), XXO("S&ort Tracks"),
            Command( wxT("SortByTime"), XXO("By &Start Time"), OnSortTime,
               TracksExistFlag(),
               Options{}.LongName( XO("Sort by Time") ) ),
            Command( wxT("SortByName"), XXO("By &Name"), OnSortName,
               TracksExistFlag(),
               Options{}.LongName( XO("Sort by Name") ) )
         )
 
      )
 
#ifdef EXPERIMENTAL_SYNC_LOCK
      ,
 
      Section( "",
         Command( wxT("SyncLock"), XXO("Sync-&Lock Tracks (on/off)"),
            OnSyncLock, AlwaysEnabledFlag,
            Options{}.CheckTest( wxT("/GUI/SyncLockTracks"), false ) )
      )
 
#endif
 
   ) };
   return menu;
}

References alignLabels(), AlwaysEnabledFlag, AnyTracksSelectedFlag(), AudioIONotBusyFlag(), CommandManager::Options::CheckTest(), MenuTable::Command(), MenuTable::CommandGroup(), EditableTracksSelectedFlag(), PluginManager::Get(), EffectManager::Get(), EffectManager::GetEffectByIdentifier(), PluginManager::GetPlugin(), PluginDescriptor::IsEnabled(), CommandManager::Options::LongName(), MenuTable::Menu(), OnAlign(), OnAlignNoSync(), OnMixAndRender(), OnMixAndRenderToNewTrack(), OnMoveSelectionWithTracks(), OnMuteAllTracks(), OnMuteSelectedTracks(), OnPanCenter(), OnPanLeft(), OnPanRight(), OnRemoveTracks(), OnResample(), OnSortName(), OnSortTime(), OnStereoToMono(), OnSyncLock(), OnUnmuteAllTracks(), OnUnmuteSelectedTracks(), MenuTable::Section(), StereoRequiredFlag(), TracksExistFlag(), WaveTracksSelectedFlag(), wxT(), XO(), and XXO().

Here is the call graph for this function:

Variable Documentation

sAttachment1

AttachedItem anonymous_namespace{TrackMenus.cpp}::sAttachment1

Initial value:

{
   wxT(""),
   Shared( TracksMenu() )
}

Definition at line 1343 of file TrackMenus.cpp.

sAttachment2

AttachedItem anonymous_namespace{TrackMenus.cpp}::sAttachment2

Initial value:

{
   wxT("Optional/Extra/Part2"),
   Shared( ExtraTrackMenu() )
}

Definition at line 1401 of file TrackMenus.cpp.