anonymous_namespace{ClipMenus.cpp} Namespace Reference

Namespace for functions for Clip menu. More...

Classes
struct	FoundClip
struct	FoundClipBoundary
struct	FoundTrack

Functions
bool	TwoChannelsHaveSameBoundaries (const WaveTrack *first, const WaveTrack *second)
bool	ChannelsHaveDifferentClipBoundaries (const WaveTrack *wt)
double	AdjustForFindingStartTimes (const std::vector< const WaveClip * > &clips, double time)
double	AdjustForFindingEndTimes (const std::vector< const WaveClip * > &clips, double time)
FoundClipBoundary	FindNextClipBoundary (const WaveTrack *wt, double time)
FoundClipBoundary	FindPrevClipBoundary (const WaveTrack *wt, double time)
int	FindClipBoundaries (AudacityProject &project, double time, bool next, std::vector< FoundClipBoundary > &finalResults)
TranslatableString	ClipBoundaryMessage (const std::vector< FoundClipBoundary > &results)
void	DoSelectClipBoundary (AudacityProject &project, bool next)
FoundClip	FindNextClip (AudacityProject &project, const WaveTrack *wt, double t0, double t1)
FoundClip	FindPrevClip (AudacityProject &project, const WaveTrack *wt, double t0, double t1)
int	FindClips (AudacityProject &project, double t0, double t1, bool next, std::vector< FoundClip > &finalResults)
void	DoSelectClip (AudacityProject &project, bool next)
void	DoCursorClipBoundary (AudacityProject &project, bool next)
double	DoClipMove (AudacityProject &project, Track *track, TrackList &trackList, bool syncLocked, bool right)
void	DoClipLeftOrRight (AudacityProject &project, bool right, bool keyUp)
void	OnSelectPrevClipBoundaryToCursor (const CommandContext &context)
void	OnSelectCursorToNextClipBoundary (const CommandContext &context)
void	OnSelectPrevClip (const CommandContext &context)
void	OnSelectNextClip (const CommandContext &context)
void	OnCursorPrevClipBoundary (const CommandContext &context)
void	OnCursorNextClipBoundary (const CommandContext &context)
void	OnClipLeft (const CommandContext &context)
void	OnClipRight (const CommandContext &context)
BaseItemSharedPtr	ClipSelectMenu ()
BaseItemSharedPtr	ClipCursorItems ()
BaseItemSharedPtr	ExtraTimeShiftItems ()

Variables
AttachedItem	sAttachment1
AttachedItem	sAttachment2
AttachedItem	sAttachment3

Detailed Description

Namespace for functions for Clip menu.

Function Documentation

AdjustForFindingEndTimes()

double anonymous_namespace{ClipMenus.cpp}::AdjustForFindingEndTimes	(	const std::vector< const WaveClip * > &	clips,
		double	time
	)

Definition at line 129 of file ClipMenus.cpp.

{
   auto q = std::find_if(clips.begin(), clips.end(),
      [&] (const WaveClip* const& clip) {
         return clip->GetPlayStartTime() == time; });
   if (q != clips.end() && q != clips.begin() &&
      (*(q - 1))->SharesBoundaryWithNextClip(*q)) {
      time = (*(q-1))->GetPlayEndTime();
   }
 
   return time;
}

Referenced by FindNextClipBoundary(), and FindPrevClipBoundary().

Here is the caller graph for this function:

AdjustForFindingStartTimes()

double anonymous_namespace{ClipMenus.cpp}::AdjustForFindingStartTimes	(	const std::vector< const WaveClip * > &	clips,
		double	time
	)

Definition at line 107 of file ClipMenus.cpp.

{
   auto q = std::find_if(clips.begin(), clips.end(),
      [&] (const WaveClip* const& clip) {
         return clip->GetPlayEndTime() == time; });
   if (q != clips.end() && q + 1 != clips.end() &&
      (*q)->SharesBoundaryWithNextClip(*(q+1))) {
      time = (*(q+1))->GetPlayStartTime();
   }
 
   return time;
}

Referenced by FindNextClip(), FindNextClipBoundary(), FindPrevClip(), and FindPrevClipBoundary().

Here is the caller graph for this function:

ChannelsHaveDifferentClipBoundaries()

bool anonymous_namespace{ClipMenus.cpp}::ChannelsHaveDifferentClipBoundaries

(

const WaveTrack *

wt

)

Definition at line 83 of file ClipMenus.cpp.

{
   // This is quadratic in the number of channels
   auto channels = TrackList::Channels(wt);
   while (!channels.empty()) {
      auto channel = *channels.first++;
      for (auto other : channels) {
         if (!TwoChannelsHaveSameBoundaries(channel, other))
            return true;
      }
   }
 
   return false;
}

References TrackList::Channels(), and TwoChannelsHaveSameBoundaries().

Referenced by FindClipBoundaries(), and FindClips().

Here is the call graph for this function:

Here is the caller graph for this function:

ClipBoundaryMessage()

TranslatableString anonymous_namespace{ClipMenus.cpp}::ClipBoundaryMessage

(

const std::vector< FoundClipBoundary > &

results

)

Definition at line 319 of file ClipMenus.cpp.

{
   TranslatableString message;
   for (auto& result : results) {
 
      auto longName = result.ComposeTrackName();
 
      TranslatableString str;
      auto nClips = result.waveTrack->GetNumClips();
      if (result.nFound < 2) {
         str = XP(
            /* i18n-hint:
               First %s is replaced with the noun "start" or "end"
               identifying one end of a clip,
               second string is the name of that clip,
               first number gives the position of that clip in a sequence
               of clips,
               last number counts all clips,
               and the last string is the name of the track containing the
               clips.
             */
            "%s %s, %d of %d clip %s",
            "%s %s, %d of %d clips %s",
            3
         )(
            result.clipStart1 ? XO("start") : XO("end"),
            result.name1,
            result.index1 + 1,
            nClips,
            longName
         );
      }
      else {
         str = XP(
            /* i18n-hint:
               First and third %s are each replaced with the noun "start"
               or with "end", identifying and end of a clip,
               second and fourth strings are the names of those clips,
               first and second numbers give the position of those clips in
               a sequence of clips,
               last number counts all clips,
               and the last string is the name of the track containing the
               clips.
             */
            "%s %s and %s %s, %d and %d of %d clip %s",
            "%s %s and %s %s, %d and %d of %d clips %s",
            6
         )(
            result.clipStart1 ? XO("start") : XO("end"),
            result.name1,
            result.clipStart2 ? XO("start") : XO("end"),
            result.name2,
            result.index1 + 1,
            result.index2 + 1,
            nClips,
            longName
         );
      }
 
      if (message.empty())
         message = str;
      else
         message = XO("%s, %s").Format( message, str );
   }
 
   return message;
}

References TranslatableString::empty(), str, XO(), and XP.

Referenced by DoCursorClipBoundary(), and DoSelectClipBoundary().

Here is the call graph for this function:

Here is the caller graph for this function:

ClipCursorItems()

BaseItemSharedPtr anonymous_namespace{ClipMenus.cpp}::ClipCursorItems

(

)

Definition at line 853 of file ClipMenus.cpp.

{
   using Options = CommandManager::Options;
 
   static BaseItemSharedPtr items{
   Items( wxT("Clip"),
      Command( wxT("CursPrevClipBoundary"), XXO("Pre&vious Clip Boundary"),
         OnCursorPrevClipBoundary,
         WaveTracksExistFlag(),
         Options{}.LongName( XO("Cursor to Prev Clip Boundary") ) ),
      Command( wxT("CursNextClipBoundary"), XXO("Ne&xt Clip Boundary"),
         OnCursorNextClipBoundary,
         WaveTracksExistFlag(),
         Options{}.LongName( XO("Cursor to Next Clip Boundary") ) )
   ) };
   return items;
}

References MenuTable::Command(), MenuTable::Items(), CommandManager::Options::LongName(), OnCursorNextClipBoundary(), OnCursorPrevClipBoundary(), WaveTracksExistFlag(), wxT(), XO(), and XXO().

Here is the call graph for this function:

ClipSelectMenu()

BaseItemSharedPtr anonymous_namespace{ClipMenus.cpp}::ClipSelectMenu

(

)

Definition at line 824 of file ClipMenus.cpp.

{
   using Options = CommandManager::Options;
 
   static BaseItemSharedPtr menu {
   Menu( wxT("Clip"), XXO("Audi&o Clips"),
      Command( wxT("SelPrevClipBoundaryToCursor"),
         XXO("Pre&vious Clip Boundary to Cursor"),
         OnSelectPrevClipBoundaryToCursor,
         WaveTracksExistFlag() ),
      Command( wxT("SelCursorToNextClipBoundary"),
         XXO("Cursor to Ne&xt Clip Boundary"),
         OnSelectCursorToNextClipBoundary,
         WaveTracksExistFlag() ),
      Command( wxT("SelPrevClip"), XXO("Previo&us Clip"),
         OnSelectPrevClip, WaveTracksExistFlag(),
         Options{ wxT("Alt+,"), XO("Select Previous Clip") } ),
      Command( wxT("SelNextClip"), XXO("N&ext Clip"), OnSelectNextClip,
         WaveTracksExistFlag(),
         Options{ wxT("Alt+."), XO("Select Next Clip") } )
   ) };
   return menu;
}

References MenuTable::Command(), MenuTable::Menu(), OnSelectCursorToNextClipBoundary(), OnSelectNextClip(), OnSelectPrevClip(), OnSelectPrevClipBoundaryToCursor(), WaveTracksExistFlag(), wxT(), XO(), and XXO().

Here is the call graph for this function:

DoClipLeftOrRight()

void anonymous_namespace{ClipMenus.cpp}::DoClipLeftOrRight	(	AudacityProject &	project,
		bool	right,
		bool	keyUp
	)

Definition at line 703 of file ClipMenus.cpp.

{
   auto &undoManager = UndoManager::Get( project );
   auto &window = ProjectWindow::Get( project );
 
   if (keyUp) {
      undoManager.StopConsolidating();
      return;
   }
 
   auto &trackFocus = TrackFocus::Get( project );
   auto &viewInfo = ViewInfo::Get( project );
   auto &selectedRegion = viewInfo.selectedRegion;
   const auto &settings = ProjectSettings::Get( project );
   auto &tracks = TrackList::Get( project );
   auto isSyncLocked = settings.IsSyncLocked();
 
   auto amount = DoClipMove( project, trackFocus.Get(),
        tracks, isSyncLocked, right );
 
   window.ScrollIntoView(selectedRegion.t0());
 
   if (amount != 0.0) {
      auto message = right? XO("Time shifted clips to the right") :
         XO("Time shifted clips to the left");
 
      // The following use of the UndoPush flags is so that both a single
      // keypress (keydown, then keyup), and holding down a key
      // (multiple keydowns followed by a keyup) result in a single
      // entry in Audacity's history dialog.
      ProjectHistory::Get( project )
         .PushState(message, XO("Time-Shift"), UndoPush::CONSOLIDATE);
   }
 
   if ( amount == 0.0 )
      trackFocus.MessageForScreenReader( XO("clip not moved"));
}

References CONSOLIDATE, DoClipMove(), TrackFocus::Get(), ProjectHistory::Get(), UndoManager::Get(), ViewInfo::Get(), TrackList::Get(), ProjectSettings::Get(), ProjectWindow::Get(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get(), ProjectHistory::PushState(), settings(), and XO().

Referenced by OnClipLeft(), and OnClipRight().

Here is the call graph for this function:

Here is the caller graph for this function:

DoClipMove()

double anonymous_namespace{ClipMenus.cpp}::DoClipMove	(	AudacityProject &	project,
		Track *	track,
		TrackList &	trackList,
		bool	syncLocked,
		bool	right
	)

Definition at line 651 of file ClipMenus.cpp.

{
   auto &viewInfo = ViewInfo::Get(project);
   auto &selectedRegion = viewInfo.selectedRegion;
 
   if (track) {
      ClipMoveState state;
 
      auto t0 = selectedRegion.t0();
 
      std::unique_ptr<TrackShifter> uShifter;
 
      // Find the first channel that has a clip at time t0
      auto hitTestResult = TrackShifter::HitTestResult::Track;
      for (auto channel : TrackList::Channels(track) ) {
         uShifter = MakeTrackShifter::Call( *channel, project );
         if ( (hitTestResult = uShifter->HitTest( t0, viewInfo )) ==
             TrackShifter::HitTestResult::Miss )
            uShifter.reset();
         else
            break;
      }
 
      if (!uShifter)
         return 0.0;
      auto pShifter = uShifter.get();
      auto desiredT0 = viewInfo.OffsetTimeByPixels( t0, ( right ? 1 : -1 ) );
      auto desiredSlideAmount = pShifter->HintOffsetLarger( desiredT0 - t0 );
 
      state.Init( project, pShifter->GetTrack(), hitTestResult, std::move( uShifter ),
         t0, viewInfo, trackList, syncLocked );
 
      auto hSlideAmount = state.DoSlideHorizontal( desiredSlideAmount );
 
      double newT0 = t0 + hSlideAmount;
      if (hitTestResult != TrackShifter::HitTestResult::Track) {
         // If necessary, correct for rounding errors. For example,
         // for a wavetrack, ensure that t0 is still in the clip
         // which it was within before the move.
         // (pShifter is still undestroyed in the ClipMoveState.)
         newT0 = pShifter->AdjustT0(newT0);
      }
 
      double diff = selectedRegion.duration();
      selectedRegion.setTimes(newT0, newT0 + diff);
 
      return hSlideAmount;
   };
   return 0.0;
}

References AttachedVirtualFunction< Tag, Return, This, Arguments >::Call(), TrackList::Channels(), ClipMoveState::DoSlideHorizontal(), ViewInfo::Get(), ClipMoveState::Init(), TrackShifter::Miss, and TrackShifter::Track.

Referenced by DoClipLeftOrRight().

Here is the call graph for this function:

Here is the caller graph for this function:

DoCursorClipBoundary()

void anonymous_namespace{ClipMenus.cpp}::DoCursorClipBoundary	(	AudacityProject &	project,
		bool	next
	)

Definition at line 626 of file ClipMenus.cpp.

{
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
   auto &trackFocus = TrackFocus::Get( project );
   auto &window = ProjectWindow::Get( project );
 
   std::vector<FoundClipBoundary> results;
   FindClipBoundaries(project, next ? selectedRegion.t1() :
      selectedRegion.t0(), next, results);
 
   if (results.size() > 0) {
      // note that if there is more than one result, each has the same time
      // value.
      double time = results[0].time;
      selectedRegion.setTimes(time, time);
      ProjectHistory::Get( project ).ModifyState(false);
      window.ScrollIntoView(selectedRegion.t0());
 
      auto message = ClipBoundaryMessage(results);
      trackFocus.MessageForScreenReader(message);
   }
}

References ClipBoundaryMessage(), FindClipBoundaries(), TrackFocus::Get(), ProjectHistory::Get(), ViewInfo::Get(), ProjectWindow::Get(), ProjectHistory::ModifyState(), and ViewInfo::selectedRegion.

Referenced by OnCursorNextClipBoundary(), and OnCursorPrevClipBoundary().

Here is the call graph for this function:

Here is the caller graph for this function:

DoSelectClip()

void anonymous_namespace{ClipMenus.cpp}::DoSelectClip	(	AudacityProject &	project,
		bool	next
	)

Definition at line 576 of file ClipMenus.cpp.

{
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
   auto &trackFocus = TrackFocus::Get( project );
   auto &window = ProjectWindow::Get( project );
 
   std::vector<FoundClip> results;
   FindClips(project, selectedRegion.t0(),
      selectedRegion.t1(), next, results);
 
   if (results.size() > 0) {
      // note that if there is more than one result, each has the same start
      // and end time
      double t0 = results[0].startTime;
      double t1 = results[0].endTime;
      selectedRegion.setTimes(t0, t1);
      ProjectHistory::Get( project ).ModifyState(false);
      window.ScrollIntoView(selectedRegion.t0());
 
      // create and send message to screen reader
      TranslatableString message;
      for (auto& result : results) {
         auto longName = result.ComposeTrackName();
         auto nClips = result.waveTrack->GetNumClips();
         auto str = XP(
            /* i18n-hint:
               first string is the name of a clip,
               first number gives the position of that clip
               in a sequence of clips,
               last number counts all clips,
               last string names a track */
            "%s, %d of %d clip %s",
            "%s, %d of %d clips %s",
            2
         )(
            result.name,
            result.index + 1,
            nClips,
            longName
         );
 
         if (message.empty())
            message = str;
         else
            message = XO("%s, %s").Format( message, str );
      }
      trackFocus.MessageForScreenReader(message);
   }
}

References TranslatableString::empty(), FindClips(), TrackFocus::Get(), ProjectHistory::Get(), ViewInfo::Get(), ProjectWindow::Get(), ProjectHistory::ModifyState(), ViewInfo::selectedRegion, str, XO(), and XP.

Referenced by OnSelectNextClip(), and OnSelectPrevClip().

Here is the call graph for this function:

Here is the caller graph for this function:

DoSelectClipBoundary()

void anonymous_namespace{ClipMenus.cpp}::DoSelectClipBoundary	(	AudacityProject &	project,
		bool	next
	)

Definition at line 388 of file ClipMenus.cpp.

{
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
   auto &trackFocus = TrackFocus::Get( project );
 
   std::vector<FoundClipBoundary> results;
   FindClipBoundaries(project, next ? selectedRegion.t1() :
      selectedRegion.t0(), next, results);
 
   if (results.size() > 0) {
      // note that if there is more than one result, each has the same time
      // value.
      if (next)
         selectedRegion.setT1(results[0].time);
      else
         selectedRegion.setT0(results[0].time);
 
      ProjectHistory::Get( project ).ModifyState(false);
 
      auto message = ClipBoundaryMessage(results);
      trackFocus.MessageForScreenReader(message);
   }
}

References ClipBoundaryMessage(), FindClipBoundaries(), TrackFocus::Get(), ProjectHistory::Get(), ViewInfo::Get(), ProjectHistory::ModifyState(), and ViewInfo::selectedRegion.

Referenced by OnSelectCursorToNextClipBoundary(), and OnSelectPrevClipBoundaryToCursor().

Here is the call graph for this function:

Here is the caller graph for this function:

ExtraTimeShiftItems()

BaseItemSharedPtr anonymous_namespace{ClipMenus.cpp}::ExtraTimeShiftItems

(

)

Definition at line 877 of file ClipMenus.cpp.

{
   using Options = CommandManager::Options;
   static BaseItemSharedPtr items{
   Items( wxT("TimeShift"),
      Command( wxT("ClipLeft"), XXO("Time Shift &Left"), OnClipLeft,
         TracksExistFlag() | TrackPanelHasFocus(), Options{}.WantKeyUp() ),
      Command( wxT("ClipRight"), XXO("Time Shift &Right"), OnClipRight,
         TracksExistFlag() | TrackPanelHasFocus(), Options{}.WantKeyUp() )
   ) };
   return items;
}

References MenuTable::Command(), MenuTable::Items(), OnClipLeft(), OnClipRight(), TrackPanelHasFocus(), TracksExistFlag(), CommandManager::Options::WantKeyUp(), wxT(), and XXO().

Here is the call graph for this function:

FindClipBoundaries()

int anonymous_namespace{ClipMenus.cpp}::FindClipBoundaries	(	AudacityProject &	project,
		double	time,
		bool	next,
		std::vector< FoundClipBoundary > &	finalResults
	)

Definition at line 260 of file ClipMenus.cpp.

{
   auto &tracks = TrackList::Get( project );
   finalResults.clear();
 
   bool anyWaveTracksSelected{ tracks.Selected< const WaveTrack >() };
 
 
   // first search the tracks individually
 
   std::vector<FoundClipBoundary> results;
 
   int nTracksSearched = 0;
   auto leaders = tracks.Leaders();
   auto rangeLeaders = leaders.Filter<const WaveTrack>();
   if (anyWaveTracksSelected)
      rangeLeaders = rangeLeaders + &Track::GetSelected;
   for (auto waveTrack : rangeLeaders) {
      bool stereoAndDiff = ChannelsHaveDifferentClipBoundaries(waveTrack);
 
      auto rangeChan = stereoAndDiff
         ? TrackList::Channels( waveTrack )
         : TrackList::SingletonRange(waveTrack);
 
      for (auto wt : rangeChan) {
         auto result = next ? FindNextClipBoundary(wt, time) :
         FindPrevClipBoundary(wt, time);
         if (result.nFound > 0) {
            result.trackNum =
               1 + std::distance( leaders.begin(), leaders.find( waveTrack ) );
            result.channel = stereoAndDiff;
            results.push_back(result);
         }
      }
 
      nTracksSearched++;
   }
 
 
   if (results.size() > 0) {
      // If any clip boundaries were found
      // find the clip boundary or boundaries with the min/max time
      auto compare = [] (const FoundClipBoundary& a, const FoundClipBoundary&b)
         { return a.time < b.time; };
 
      auto p = next ? min_element(results.begin(), results.end(), compare ) :
         max_element(results.begin(), results.end(), compare);
 
      for ( auto &r : results )
         if ( r.time == (*p).time )
            finalResults.push_back( r );
   }
 
   return nTracksSearched; // can be used for screen reader messages if required
}

References TrackList::Channels(), ChannelsHaveDifferentClipBoundaries(), FindNextClipBoundary(), FindPrevClipBoundary(), TrackList::Get(), Track::GetSelected(), TrackList::SingletonRange(), and anonymous_namespace{ClipMenus.cpp}::FoundClipBoundary::time.

Referenced by DoCursorClipBoundary(), and DoSelectClipBoundary().

Here is the call graph for this function:

Here is the caller graph for this function:

FindClips()

int anonymous_namespace{ClipMenus.cpp}::FindClips	(	AudacityProject &	project,
		double	t0,
		double	t1,
		bool	next,
		std::vector< FoundClip > &	finalResults
	)

Definition at line 498 of file ClipMenus.cpp.

{
   auto &tracks = TrackList::Get( project );
   finalResults.clear();
 
   bool anyWaveTracksSelected{ tracks.Selected< const WaveTrack >() };
 
   // first search the tracks individually
 
   std::vector<FoundClip> results;
 
   int nTracksSearched = 0;
   auto leaders = tracks.Leaders();
   auto rangeLeaders = leaders.Filter<const WaveTrack>();
   if (anyWaveTracksSelected)
      rangeLeaders = rangeLeaders + &Track::GetSelected;
   for (auto waveTrack : rangeLeaders) {
      bool stereoAndDiff = ChannelsHaveDifferentClipBoundaries(waveTrack);
 
      auto rangeChans = stereoAndDiff
         ? TrackList::Channels( waveTrack )
         : TrackList::SingletonRange( waveTrack );
 
      for ( auto wt : rangeChans ) {
         auto result = next ? FindNextClip(project, wt, t0, t1) :
            FindPrevClip(project, wt, t0, t1);
         if (result.found) {
            result.trackNum =
               1 + std::distance( leaders.begin(), leaders.find( waveTrack ) );
            result.channel = stereoAndDiff;
            results.push_back(result);
         }
      }
 
      nTracksSearched++;
   }
 
 
   if (results.size() > 0) {
      // if any clips were found,
      // find the clip or clips with the min/max start time
      auto compareStart = [] (const FoundClip& a, const FoundClip& b)
         { return a.startTime < b.startTime; };
 
      auto pStart = next
         ? std::min_element(results.begin(), results.end(), compareStart)
         : std::max_element(results.begin(), results.end(), compareStart);
 
      std::vector<FoundClip> resultsStartTime;
      for ( auto &r : results )
         if ( r.startTime == (*pStart).startTime )
            resultsStartTime.push_back( r );
 
      if (resultsStartTime.size() > 1) {
         // more than one clip with same start time so
         // find the clip or clips with the min/max end time
         auto compareEnd = [] (const FoundClip& a, const FoundClip& b)
            { return a.endTime < b.endTime; };
 
         auto pEnd = next ? std::min_element(resultsStartTime.begin(),
            resultsStartTime.end(), compareEnd) :
            std::max_element(resultsStartTime.begin(),
            resultsStartTime.end(), compareEnd);
 
         for ( auto &r : resultsStartTime )
            if ( r.endTime == (*pEnd).endTime )
               finalResults.push_back( r );
      }
      else {
         finalResults = resultsStartTime;
      }
   }
 
   return nTracksSearched; // can be used for screen reader messages if required
}

References TrackList::Channels(), ChannelsHaveDifferentClipBoundaries(), anonymous_namespace{ClipMenus.cpp}::FoundClip::endTime, FindNextClip(), FindPrevClip(), TrackList::Get(), Track::GetSelected(), TrackList::SingletonRange(), and anonymous_namespace{ClipMenus.cpp}::FoundClip::startTime.

Referenced by DoSelectClip().

Here is the call graph for this function:

Here is the caller graph for this function:

FindNextClip()

FoundClip anonymous_namespace{ClipMenus.cpp}::FindNextClip	(	AudacityProject &	project,
		const WaveTrack *	wt,
		double	t0,
		double	t1
	)

Definition at line 412 of file ClipMenus.cpp.

{
   (void)project;//Compiler food.
 
   FoundClip result{};
   result.waveTrack = wt;
   const auto clips = wt->SortedClipArray();
 
   t0 = AdjustForFindingStartTimes(clips, t0);
 
   {
      auto p = std::find_if(clips.begin(), clips.end(),
         [&] (const WaveClip* const& clip) {
            return clip->GetPlayStartTime() == t0; });
      if (p != clips.end() && (*p)->GetPlayEndTime() > t1) {
         result.found = true;
         result.startTime = (*p)->GetPlayStartTime();
         result.endTime = (*p)->GetPlayEndTime();
         result.name = (*p)->GetName();
         result.index = std::distance(clips.begin(), p);
         return result;
      }
   }
 
   {
      auto p = std::find_if(clips.begin(), clips.end(),
         [&] (const WaveClip* const& clip) {
            return clip->GetPlayStartTime() > t0; });
      if (p != clips.end()) {
         result.found = true;
         result.startTime = (*p)->GetPlayStartTime();
         result.endTime = (*p)->GetPlayEndTime();
         result.name = (*p)->GetName();
         result.index = std::distance(clips.begin(), p);
         return result;
      }
   }
 
   return result;
}

References AdjustForFindingStartTimes(), WaveTrack::SortedClipArray(), and anonymous_namespace{ClipMenus.cpp}::FoundTrack::waveTrack.

Referenced by FindClips().

Here is the call graph for this function:

Here is the caller graph for this function:

FindNextClipBoundary()

FoundClipBoundary anonymous_namespace{ClipMenus.cpp}::FindNextClipBoundary	(	const WaveTrack *	wt,
		double	time
	)

Definition at line 143 of file ClipMenus.cpp.

{
   FoundClipBoundary result{};
   result.waveTrack = wt;
   const auto clips = wt->SortedClipArray();
   double timeStart = AdjustForFindingStartTimes(clips, time);
   double timeEnd = AdjustForFindingEndTimes(clips, time);
 
   auto pStart = std::find_if(clips.begin(), clips.end(),
      [&] (const WaveClip* const& clip) {
         return clip->GetPlayStartTime() > timeStart; });
   auto pEnd = std::find_if(clips.begin(), clips.end(),
      [&] (const WaveClip* const& clip) {
         return clip->GetPlayEndTime() > timeEnd; });
 
   if (pStart != clips.end() && pEnd != clips.end()) {
      if ((*pEnd)->SharesBoundaryWithNextClip(*pStart)) {
         // boundary between two clips which are immediately next to each other.
         result.nFound = 2;
         result.time = (*pEnd)->GetPlayEndTime();
         result.index1 = std::distance(clips.begin(), pEnd);
         result.name1 = (*pEnd)->GetName();
         result.clipStart1 = false;
         result.index2 = std::distance(clips.begin(), pStart);
         result.name2 = (*pStart)->GetName();
         result.clipStart2 = true;
      }
      else if ((*pStart)->GetPlayStartTime() < (*pEnd)->GetPlayEndTime()) {
         result.nFound = 1;
         result.time = (*pStart)->GetPlayStartTime();
         result.index1 = std::distance(clips.begin(), pStart);
         result.name1 = (*pStart)->GetName();
         result.clipStart1 = true;
      }
      else  {
         result.nFound = 1;
         result.time = (*pEnd)->GetPlayEndTime();
         result.index1 = std::distance(clips.begin(), pEnd);
         result.name1 = (*pEnd)->GetName();
         result.clipStart1 = false;
      }
   }
   else if (pEnd != clips.end()) {
      result.nFound = 1;
      result.time = (*pEnd)->GetPlayEndTime();
      result.index1 = std::distance(clips.begin(), pEnd);
      result.name1 = (*pEnd)->GetName();
      result.clipStart1 = false;
   }
 
   return result;
}

References AdjustForFindingEndTimes(), AdjustForFindingStartTimes(), WaveTrack::SortedClipArray(), and anonymous_namespace{ClipMenus.cpp}::FoundTrack::waveTrack.

Referenced by FindClipBoundaries().

Here is the call graph for this function:

Here is the caller graph for this function:

FindPrevClip()

FoundClip anonymous_namespace{ClipMenus.cpp}::FindPrevClip	(	AudacityProject &	project,
		const WaveTrack *	wt,
		double	t0,
		double	t1
	)

Definition at line 454 of file ClipMenus.cpp.

{
   (void)project;//Compiler food.
 
   FoundClip result{};
   result.waveTrack = wt;
   const auto clips = wt->SortedClipArray();
 
   t0 = AdjustForFindingStartTimes(clips, t0);
 
   {
      auto p = std::find_if(clips.begin(), clips.end(),
         [&] (const WaveClip* const& clip) {
            return clip->GetPlayStartTime() == t0; });
      if (p != clips.end() && (*p)->GetPlayEndTime() < t1) {
         result.found = true;
         result.startTime = (*p)->GetPlayStartTime();
         result.endTime = (*p)->GetPlayEndTime();
         result.name = (*p)->GetName();
         result.index = std::distance(clips.begin(), p);
         return result;
      }
   }
   
   {
      auto p = std::find_if(clips.rbegin(), clips.rend(),
         [&] (const WaveClip* const& clip) {
            return clip->GetPlayStartTime() < t0; });
      if (p != clips.rend()) {
         result.found = true;
         result.startTime = (*p)->GetPlayStartTime();
         result.endTime = (*p)->GetPlayEndTime();
         result.name = (*p)->GetName();
         result.index =
            static_cast<int>(clips.size()) - 1 -
               std::distance(clips.rbegin(), p);
         return result;
      }
   }
 
   return result;
}

References AdjustForFindingStartTimes(), WaveTrack::SortedClipArray(), and anonymous_namespace{ClipMenus.cpp}::FoundTrack::waveTrack.

Referenced by FindClips().

Here is the call graph for this function:

Here is the caller graph for this function:

FindPrevClipBoundary()

FoundClipBoundary anonymous_namespace{ClipMenus.cpp}::FindPrevClipBoundary	(	const WaveTrack *	wt,
		double	time
	)

Definition at line 197 of file ClipMenus.cpp.

{
   FoundClipBoundary result{};
   result.waveTrack = wt;
   const auto clips = wt->SortedClipArray();
   double timeStart = AdjustForFindingStartTimes(clips, time);
   double timeEnd = AdjustForFindingEndTimes(clips, time);
 
   auto pStart = std::find_if(clips.rbegin(), clips.rend(),
      [&] (const WaveClip* const& clip) {
         return clip->GetPlayStartTime() < timeStart; });
   auto pEnd = std::find_if(clips.rbegin(), clips.rend(),
      [&] (const WaveClip* const& clip) {
         return clip->GetPlayEndTime() < timeEnd; });
 
   if (pStart != clips.rend() && pEnd != clips.rend()) {
      if ((*pEnd)->SharesBoundaryWithNextClip(*pStart)) {
         // boundary between two clips which are immediately next to each other.
         result.nFound = 2;
         result.time = (*pStart)->GetPlayStartTime();
         result.index1 =
            static_cast<int>(clips.size()) - 1 -
               std::distance(clips.rbegin(), pStart);
         result.name1 = (*pStart)->GetName();
         result.clipStart1 = true;
         result.index2 =
            static_cast<int>(clips.size()) - 1 -
               std::distance(clips.rbegin(), pEnd);
         result.name2 = (*pEnd)->GetName();
         result.clipStart2 = false;
      }
      else if ((*pStart)->GetPlayStartTime() > (*pEnd)->GetPlayEndTime()) {
         result.nFound = 1;
         result.time = (*pStart)->GetPlayStartTime();
         result.index1 =
            static_cast<int>(clips.size()) - 1 -
               std::distance(clips.rbegin(), pStart);
         result.name1 = (*pStart)->GetName();
         result.clipStart1 = true;
      }
      else {
         result.nFound = 1;
         result.time = (*pEnd)->GetPlayEndTime();
         result.index1 =
            static_cast<int>(clips.size()) - 1 -
               std::distance(clips.rbegin(), pEnd);
         result.name1 = (*pEnd)->GetName();
         result.clipStart1 = false;
      }
   }
   else if (pStart != clips.rend()) {
      result.nFound = 1;
      result.time = (*pStart)->GetPlayStartTime();
      result.index1 =
         static_cast<int>(clips.size()) - 1 -
            std::distance(clips.rbegin(), pStart);
      result.name1 = (*pStart)->GetName();
      result.clipStart1 = true;
   }
 
   return result;
}

References AdjustForFindingEndTimes(), AdjustForFindingStartTimes(), WaveTrack::SortedClipArray(), and anonymous_namespace{ClipMenus.cpp}::FoundTrack::waveTrack.

Referenced by FindClipBoundaries().

Here is the call graph for this function:

Here is the caller graph for this function:

OnClipLeft()

void anonymous_namespace{ClipMenus.cpp}::OnClipLeft

(

const CommandContext &

context

)

Definition at line 794 of file ClipMenus.cpp.

{
   auto &project = context.project;
   auto evt = context.pEvt;
   if (evt)
      DoClipLeftOrRight( project, false, evt->GetEventType() == wxEVT_KEY_UP );
   else  {              // called from menu, so simulate keydown and keyup
      DoClipLeftOrRight( project, false, false );
      DoClipLeftOrRight( project, false, true );
   }
}

References DoClipLeftOrRight(), CommandContext::pEvt, and CommandContext::project.

Referenced by ExtraTimeShiftItems().

Here is the call graph for this function:

Here is the caller graph for this function:

OnClipRight()

void anonymous_namespace{ClipMenus.cpp}::OnClipRight

(

const CommandContext &

context

)

Definition at line 806 of file ClipMenus.cpp.

{
   auto &project = context.project;
   auto evt = context.pEvt;
   if (evt)
      DoClipLeftOrRight( project, true, evt->GetEventType() == wxEVT_KEY_UP );
   else  {              // called from menu, so simulate keydown and keyup
      DoClipLeftOrRight( project, true, false );
      DoClipLeftOrRight( project, true, true );
   }
}

References DoClipLeftOrRight(), CommandContext::pEvt, and CommandContext::project.

Referenced by ExtraTimeShiftItems().

Here is the call graph for this function:

Here is the caller graph for this function:

OnCursorNextClipBoundary()

void anonymous_namespace{ClipMenus.cpp}::OnCursorNextClipBoundary

(

const CommandContext &

context

)

Definition at line 785 of file ClipMenus.cpp.

{
   AudacityProject &project = context.project;
   
   DoCursorClipBoundary(project, true);
}

References DoCursorClipBoundary(), and CommandContext::project.

Referenced by ClipCursorItems().

Here is the call graph for this function:

Here is the caller graph for this function:

OnCursorPrevClipBoundary()

void anonymous_namespace{ClipMenus.cpp}::OnCursorPrevClipBoundary

(

const CommandContext &

context

)

Definition at line 778 of file ClipMenus.cpp.

{
   AudacityProject &project = context.project;
 
   DoCursorClipBoundary(project, false);
}

References DoCursorClipBoundary(), and CommandContext::project.

Referenced by ClipCursorItems().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSelectCursorToNextClipBoundary()

void anonymous_namespace{ClipMenus.cpp}::OnSelectCursorToNextClipBoundary

(

const CommandContext &

context

)

Definition at line 759 of file ClipMenus.cpp.

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

References DoSelectClipBoundary(), and CommandContext::project.

Referenced by ClipSelectMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSelectNextClip()

void anonymous_namespace{ClipMenus.cpp}::OnSelectNextClip

(

const CommandContext &

context

)

Definition at line 772 of file ClipMenus.cpp.

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

References DoSelectClip(), and CommandContext::project.

Referenced by ClipSelectMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSelectPrevClip()

void anonymous_namespace{ClipMenus.cpp}::OnSelectPrevClip

(

const CommandContext &

context

)

Definition at line 766 of file ClipMenus.cpp.

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

References DoSelectClip(), and CommandContext::project.

Referenced by ClipSelectMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSelectPrevClipBoundaryToCursor()

void anonymous_namespace{ClipMenus.cpp}::OnSelectPrevClipBoundaryToCursor

(

const CommandContext &

context

)

Definition at line 752 of file ClipMenus.cpp.

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

References DoSelectClipBoundary(), and CommandContext::project.

Referenced by ClipSelectMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

TwoChannelsHaveSameBoundaries()

bool anonymous_namespace{ClipMenus.cpp}::TwoChannelsHaveSameBoundaries	(	const WaveTrack *	first,
		const WaveTrack *	second
	)

Definition at line 58 of file ClipMenus.cpp.

{
   bool sameClips = false;
 
   auto& left = first->GetClips();
   auto& right = second->GetClips();
   
   // PRL:  should that have been? :
   // auto left = first->SortedClipArray();
   // auto right = second->SortedClipArray();
 
   if (left.size() == right.size()) {
      sameClips = true;
      for (unsigned int i = 0; i < left.size(); i++) {
         if (left[i]->GetPlayStartTime() != right[i]->GetPlayStartTime() ||
            left[i]->GetPlayEndTime() != right[i]->GetPlayEndTime()) {
            sameClips = false;
            break;
         }
      }
   }
   return sameClips;
}

References WaveTrack::GetClips().

Referenced by ChannelsHaveDifferentClipBoundaries().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

sAttachment1

AttachedItem anonymous_namespace{ClipMenus.cpp}::sAttachment1

Initial value:

{
   wxT("Select/Basic"),
   Shared( ClipSelectMenu() )
}

Definition at line 848 of file ClipMenus.cpp.

sAttachment2

AttachedItem anonymous_namespace{ClipMenus.cpp}::sAttachment2

Initial value:

{
   { wxT("Transport/Basic/Cursor"),
     { OrderingHint::Before, wxT("CursProjectStart") } },
   Shared( ClipCursorItems() )
}

Definition at line 871 of file ClipMenus.cpp.

sAttachment3

AttachedItem anonymous_namespace{ClipMenus.cpp}::sAttachment3

Initial value:

{
  { wxT("Optional/Extra/Part1/Edit"), { OrderingHint::End, {} } },
  Shared( ExtraTimeShiftItems() )
}

Definition at line 890 of file ClipMenus.cpp.