TrackList Class Reference

A list of TrackListNode items. More...

#include <Track.h>

Inheritance diagram for TrackList:

Public Types
using	iterator = TrackListIterator
using	const_iterator = TrackListConstIterator
using	value_type = Track *
using	Updater = std::function< void(Track &dest, const Track &src) >

Public Member Functions
void	Swap (TrackList &that)
virtual	~TrackList ()
iterator	begin ()
iterator	end ()
const_iterator	begin () const
const_iterator	end () const
const_iterator	cbegin () const
const_iterator	cend () const
void	Permute (const std::vector< TrackNodePointer > &permutation)
	For use in sorting: assume each iterator points into this list, no duplications. More...
Track *	FindById (TrackId id)
template<typename TrackKind >
Track *	Add (std::unique_ptr< TrackKind > &&t)
	Add a Track, giving it a fresh id. More...
template<typename TrackKind >
Track *	AddToHead (std::unique_ptr< TrackKind > &&t)
	Add a Track, giving it a fresh id. More...
template<typename TrackKind >
Track *	Add (std::shared_ptr< TrackKind > &&t)
	Add a Track, giving it a fresh id. More...
ListOfTracks::value_type	Replace (Track *t, ListOfTracks::value_type &&with)
TrackNodePointer	Remove (Track *t)
void	Clear (bool sendEvent=true)
	Make the list empty. More...
void	Select (Track *t, bool selected=true)
Track *	GetPrev (Track *t, bool linked=false) const
Track *	GetNext (Track *t, bool linked=false) const
	Return a track in the list that comes after Track t. More...
int	GetGroupHeight (Track *t) const
bool	CanMoveUp (Track *t) const
bool	CanMoveDown (Track *t) const
bool	MoveUp (Track *t)
bool	MoveDown (Track *t)
bool	Move (Track *t, bool up)
TimeTrack *	GetTimeTrack ()
const TimeTrack *	GetTimeTrack () const
unsigned	GetNumExportChannels (bool selectionOnly) const
	Find out how many channels this track list mixes to. More...
WaveTrackArray	GetWaveTrackArray (bool selectionOnly, bool includeMuted=true)
WaveTrackConstArray	GetWaveTrackConstArray (bool selectionOnly, bool includeMuted=true) const
bool	Contains (const Track *t) const
	Mainly a test function. Uses a linear search, so could be slow. More...
template<typename Subclass >
std::shared_ptr< Subclass >	Lock (const std::weak_ptr< Subclass > &wTrack)
bool	empty () const
size_t	size () const
double	GetStartTime () const
double	GetEndTime () const
double	GetMinOffset () const
int	GetHeight () const
std::shared_ptr< Track >	RegisterPendingChangedTrack (Updater updater, Track *src)
void	RegisterPendingNewTrack (const std::shared_ptr< Track > &pTrack)
void	UpdatePendingTracks ()
void	ClearPendingTracks (ListOfTracks *pAdded=nullptr)
bool	ApplyPendingTracks ()
std::shared_ptr< Track >	FindPendingChangedTrack (TrackId id) const
bool	HasPendingTracks () const

Static Public Member Functions
static std::shared_ptr< TrackList >	Create ()

Private Member Functions
	TrackList ()
	TrackList (const TrackList &that)=delete
TrackList &	operator= (const TrackList &)=delete
	TrackList (TrackList &&that)
TrackList &	operator= (TrackList &&)
void	clear ()=delete
bool	isNull (TrackNodePointer p) const
TrackNodePointer	getEnd () const
TrackNodePointer	getBegin () const
TrackNodePointer	getNext (TrackNodePointer p) const
TrackNodePointer	getPrev (TrackNodePointer p) const
void	RecalcPositions (TrackNodePointer node)
void	PermutationEvent ()
void	DeletionEvent ()
void	ResizingEvent (TrackNodePointer node)
void	SwapNodes (TrackNodePointer s1, TrackNodePointer s2)

Private Attributes
std::weak_ptr< TrackList >	mSelf
ListOfTracks	mPendingUpdates
std::vector< Updater >	mUpdaters

Static Private Attributes
static long	sCounter = -1

Friends
class	Track
class	TrackListIterator
class	SyncLockedTracksIterator

Detailed Description

A list of TrackListNode items.

Definition at line 619 of file Track.h.

Member Typedef Documentation

using TrackList::const_iterator = TrackListConstIterator

Definition at line 649 of file Track.h.

using TrackList::iterator = TrackListIterator

Definition at line 648 of file Track.h.

using TrackList::Updater = std::function< void(Track &dest, const Track &src) >

Definition at line 808 of file Track.h.

using TrackList::value_type = Track *

Definition at line 650 of file Track.h.

Constructor & Destructor Documentation

TrackList::TrackList ( )

private

Definition at line 786 of file Track.cpp.

:  wxEvtHandler()
{
}

TrackList::TrackList ( const TrackList &  that )

privatedelete

TrackList::TrackList ( TrackList &&  that )

inlineprivate

Definition at line 632 of file Track.h.

References Swap().

: TrackList() { Swap(that); }

TrackList::~TrackList ( )

virtual

Definition at line 826 of file Track.cpp.

References Clear().

{
   Clear(false);
}

Member Function Documentation

template<typename TrackKind >

Track * TrackList::Add

(

std::unique_ptr< TrackKind > &&

t

)

Add a Track, giving it a fresh id.

Definition at line 906 of file Track.cpp.

References getEnd(), getPrev(), mSelf, RecalcPositions(), ResizingEvent(), sCounter, Track::SetId(), and Track::SetOwner().

Referenced by Effect::AddedAnalysisTrack::AddedAnalysisTrack(), ApplyPendingTracks(), AudacityProject::FinishCopy(), AudacityProject::OnAudioIOStopRecording(), Effect::Preview(), Effect::ReplaceProcessedTracks(), and LabelDialog::TransferDataFromWindow().

{
   Track *pTrack;
   push_back(ListOfTracks::value_type(pTrack = t.release()));

   auto n = getPrev( getEnd() );

   pTrack->SetOwner(mSelf, n);
   pTrack->SetId( TrackId{ ++sCounter } );
   RecalcPositions(n);
   ResizingEvent(n);
   return back().get();
}

template<typename TrackKind >

Track * TrackList::Add

(

std::shared_ptr< TrackKind > &&

t

)

Add a Track, giving it a fresh id.

Definition at line 946 of file Track.cpp.

References getEnd(), getPrev(), mSelf, RecalcPositions(), ResizingEvent(), and sCounter.

{
   push_back(t);

   auto n = getPrev( getEnd() );

   t->SetOwner(mSelf, n);
   t->SetId( TrackId{ ++sCounter } );
   RecalcPositions(n);
   ResizingEvent(n);
   return back().get();
}

template<typename TrackKind >

template Track * TrackList::AddToHead< TimeTrack >

(

std::unique_ptr< TrackKind > &&

t

)

Add a Track, giving it a fresh id.

Definition at line 930 of file Track.cpp.

References getBegin(), mSelf, RecalcPositions(), ResizingEvent(), sCounter, Track::SetId(), and Track::SetOwner().

{
   Track *pTrack;
   push_front(ListOfTracks::value_type(pTrack = t.release()));
   auto n = getBegin();
   pTrack->SetOwner(mSelf, n);
   pTrack->SetId( TrackId{ ++sCounter } );
   RecalcPositions(n);
   ResizingEvent(n);
   return front().get();
}

bool TrackList::ApplyPendingTracks

(

)

Definition at line 1496 of file Track.cpp.

References Add(), ClearPendingTracks(), FindById(), mPendingUpdates, mSelf, RecalcPositions(), Replace(), sCounter, and UpdatePendingTracks().

{
   bool result = false;

   ListOfTracks additions;
   ListOfTracks updates;
   {
      // Always clear, even if one of the update functions throws
      auto cleanup = finally( [&] { ClearPendingTracks( &additions ); } );
      UpdatePendingTracks();
      updates.swap( mPendingUpdates );
   }

   // Remaining steps must be NOFAIL-GUARANTEE so that this function
   // gives STRONG-GUARANTEE

   std::vector< std::shared_ptr<Track> > reinstated;

   for (auto &pendingTrack : updates) {
      if (pendingTrack) {
         auto src = FindById( pendingTrack->GetId() );
         if (src)
            this->Replace(src, std::move(pendingTrack)), result = true;
         else
            // Perhaps a track marked for pending changes got deleted by
            // some other action.  Recreate it so we don't lose the
            // accumulated changes.
            reinstated.push_back(pendingTrack);
      }
   }

   // If there are tracks to reinstate, append them to the list.
   for (auto &pendingTrack : reinstated)
      if (pendingTrack)
         this->Add(std::move(pendingTrack)), result = true;

   // Put the pending added tracks back into the list, preserving their
   // positions.
   bool inserted = false;
   ListOfTracks::iterator first;
   for (auto &pendingTrack : additions) {
      if (pendingTrack) {
         auto iter = ListOfTracks::begin();
         std::advance( iter, pendingTrack->GetIndex() );
         iter = ListOfTracks::insert( iter, pendingTrack );
         pendingTrack->SetOwner( mSelf, {iter, this} );
         pendingTrack->SetId( TrackId{ ++sCounter } );
         if (!inserted) {
            first = iter;
            inserted = true;
         }
      }
   }
   if (inserted) {
      RecalcPositions({first, this});
      result = true;
   }

   return result;
}

iterator TrackList::begin ( )

inline

Definition at line 651 of file Track.h.

Referenced by cbegin(), empty(), AudacityProject::FindClipBoundaries(), AudacityProject::FindClips(), GetTimeTrack(), GetWaveTrackArray(), GetWaveTrackConstArray(), and HasPendingTracks().

                    { return iterator{
      this, { ListOfTracks::begin(), this } }; }

const_iterator TrackList::begin ( ) const

inline

Definition at line 654 of file Track.h.

{ return const_iterator{ this }; }

bool TrackList::CanMoveDown

(

Track *

t

)

const

Definition at line 1121 of file Track.cpp.

References GetNext().

Referenced by TrackSelectHandle::CalculateRearrangingThresholds(), and TrackMenuTable::InitMenu().

{
   return GetNext(t, true) != NULL;
}

bool TrackList::CanMoveUp

(

Track *

t

)

const

Definition at line 1116 of file Track.cpp.

References GetPrev().

Referenced by TrackSelectHandle::CalculateRearrangingThresholds(), and TrackMenuTable::InitMenu().

{
   return GetPrev(t, true) != NULL;
}

const_iterator TrackList::cbegin ( ) const

inline

Definition at line 656 of file Track.h.

References begin().

{ return begin(); }

const_iterator TrackList::cend ( ) const

inline

Definition at line 657 of file Track.h.

References end().

{ return end(); }

void TrackList::clear ( )

privatedelete

Referenced by TimeShiftHandle::Click().

void TrackList::Clear

(

bool

sendEvent = true

)

Make the list empty.

Definition at line 1006 of file Track.cpp.

References DeletionEvent(), mPendingUpdates, and mUpdaters.

Referenced by operator=(), and ~TrackList().

{
   // Null out the back-pointers in tracks, in case there are outstanding
   // shared_ptrs to those tracks.
   for ( auto pTrack: *this )
      pTrack->SetOwner( {}, {} );
   for ( auto pTrack: mPendingUpdates )
      pTrack->SetOwner( {}, {} );

   ListOfTracks tempList;
   tempList.swap( *this );

   ListOfTracks updating;
   updating.swap( mPendingUpdates );

   mUpdaters.clear();

   if (sendEvent)
      DeletionEvent();
}

void TrackList::ClearPendingTracks

(

ListOfTracks *

pAdded = nullptr

)

Definition at line 1469 of file Track.cpp.

References empty(), getBegin(), mPendingUpdates, mUpdaters, and RecalcPositions().

Referenced by ApplyPendingTracks().

{
   for (const auto &pTrack: mPendingUpdates)
      pTrack->SetOwner( {}, {} );
   mPendingUpdates.clear();
   mUpdaters.clear();

   if (pAdded)
      pAdded->clear();

   for (auto it = ListOfTracks::begin(), stop = ListOfTracks::end();
        it != stop;) {
      if (it->get()->GetId() == TrackId{}) {
         if (pAdded)
            pAdded->push_back( *it );
         (*it)->SetOwner( {}, {} );
         it = erase( it );
      }
      else
         ++it;
   }

   if (!empty())
      RecalcPositions(getBegin());
}

bool TrackList::Contains

(

const Track *

t

)

const

Mainly a test function. Uses a linear search, so could be slow.

Definition at line 1224 of file Track.cpp.

References make_iterator_range().

{
   return make_iterator_range( *this ).contains( t );
}

std::shared_ptr< TrackList > TrackList::Create ( )

static

Definition at line 792 of file Track.cpp.

References mSelf, and safenew.

Referenced by AudacityProject::AudacityProject(), Effect::CopyInputTracks(), AudacityProject::DoSave(), AudacityProject::EditClipboardByLabel(), UndoManager::ModifyState(), AudacityProject::OnCopy(), AudacityProject::OnCut(), AudacityProject::OnSplitCut(), AudacityProject::OpenFile(), Effect::Preview(), UndoManager::PushState(), AudacityProject::SaveCopyWaveTracks(), and ControlToolBar::SetupCutPreviewTracks().

{
   std::shared_ptr<TrackList> result{ safenew TrackList{} };
   result->mSelf = result;
   return result;
}

void TrackList::DeletionEvent ( )

private

Definition at line 865 of file Track.cpp.

Referenced by Clear(), and Remove().

{
   auto e = std::make_unique<wxCommandEvent>(EVT_TRACKLIST_DELETION);
   // wxWidgets will own the event object
   QueueEvent(e.release());
}

bool TrackList::empty

(

)

const

Definition at line 1229 of file Track.cpp.

References begin(), and end().

Referenced by ClearPendingTracks(), GetHeight(), CommonTrackPanelCell::HandleWheelRotation(), and size().

{
   return begin() == end();
}

iterator TrackList::end ( )

inline

Definition at line 653 of file Track.h.

Referenced by cend(), empty(), AudacityProject::FindClipBoundaries(), AudacityProject::FindClips(), GetTimeTrack(), GetWaveTrackArray(), GetWaveTrackConstArray(), HasPendingTracks(), and RecalcPositions().

{ return {}; }

const_iterator TrackList::end ( ) const

inline

Definition at line 655 of file Track.h.

{ return {}; }

Track * TrackList::FindById

(

TrackId

id

)

Definition at line 894 of file Track.cpp.

Referenced by ApplyPendingTracks(), TrackPanelAx::IsFocused(), and UpdatePendingTracks().

{
   // Linear search.  Tracks in a project are usually very few.
   // Search only the non-pending tracks.
   auto it = std::find_if( ListOfTracks::begin(), ListOfTracks::end(),
      [=](const ListOfTracks::value_type &ptr){ return ptr->GetId() == id; } );
   if (it == ListOfTracks::end())
      return {};
   return it->get();
}

std::shared_ptr< Track > TrackList::FindPendingChangedTrack

(

TrackId

id

)

const

Definition at line 1557 of file Track.cpp.

References mPendingUpdates.

Referenced by TrackPanel::DrawEverythingElse(), and TrackArtist::DrawTracks().

{
   // Linear search.  Tracks in a project are usually very few.
   auto it = std::find_if( mPendingUpdates.begin(), mPendingUpdates.end(),
      [=](const ListOfTracks::value_type &ptr){ return ptr->GetId() == id; } );
   if (it == mPendingUpdates.end())
      return {};
   return *it;
}

TrackNodePointer TrackList::getBegin ( ) const

inlineprivate

Definition at line 767 of file Track.h.

Referenced by AddToHead(), ClearPendingTracks(), TrackListIterator::First(), getPrev(), and Permute().

   { return { const_cast<TrackList*>(this)->ListOfTracks::begin(),
              const_cast<TrackList*>(this)}; }

TrackNodePointer TrackList::getEnd ( ) const

inlineprivate

Definition at line 764 of file Track.h.

Referenced by Add(), GetHeight(), getPrev(), TrackListIterator::Last(), SyncLockedTracksIterator::Next(), SyncLockedTracksIterator::Prev(), Remove(), and size().

   { return { const_cast<TrackList*>(this)->ListOfTracks::end(),
              const_cast<TrackList*>(this)}; }

double TrackList::GetEndTime

(

)

const

Definition at line 1418 of file Track.cpp.

References Track::GetEndTime().

Referenced by SelectTimeCommand::Apply(), LOFImportFileHandle::doDurationAndScrollOffset(), TimeShiftHandle::DoSlideHorizontal(), ExportMultiple::ExportMultipleByLabel(), MacroCommands::GetEndTime(), AdornedRulerPanel::HandleQPRelease(), CommonTrackPanelCell::HandleWheelRotation(), Scrubber::MaybeStartScrubbing(), AdornedRulerPanel::OnMouseEvents(), AudacityPrintout::OnPrintPage(), ControlToolBar::PlayPlayRegion(), AdornedRulerPanel::ShowOrHideQuickPlayIndicator(), and AdornedRulerPanel::StartQPPlay().

{
   return Accumulate(*this, &Track::GetEndTime, doubleMax);
}

int TrackList::GetGroupHeight

(

Track *

t

)

const

For mono track height of track For stereo track combined height of both channels.

Definition at line 1105 of file Track.cpp.

References Track::GetHeight(), and Track::GetLink().

Referenced by TrackSelectHandle::CalculateRearrangingThresholds().

{
   int height = t->GetHeight();

   t = t->GetLink();
   if (t) {
      height += t->GetHeight();
   }
   return height;
}

int TrackList::GetHeight

(

)

const

Definition at line 1372 of file Track.cpp.

References empty(), getEnd(), and getPrev().

Referenced by AudacityPrintout::OnPrintPage().

{
   int height = 0;

   if (!empty()) {
      auto track = getPrev( getEnd() ).first->get();
      height = track->GetY() + track->GetHeight();
   }

   return height;
}

double TrackList::GetMinOffset

(

)

const

Definition at line 1408 of file Track.cpp.

References Track::GetOffset().

{
   return Accumulate(*this, &Track::GetOffset, doubleMin);
}

Track * TrackList::GetNext	(	Track *	t,
		bool	linked = false
	)		const

Return a track in the list that comes after Track t.

Return a track in the list that comes after Track t

Parameters

t	a track in the list
linked	if true, skips over linked tracks, if false returns the next track even if it is a linked track

Definition at line 1048 of file Track.cpp.

References Track::GetLinked(), getNext(), Track::GetNode(), and isNull().

Referenced by TrackSelectHandle::CalculateRearrangingThresholds(), TrackPanelResizeHandle::Cancel(), CanMoveDown(), TrackPanelResizeHandle::Drag(), WaveTrackMenuTable::InitMenu(), SyncLockedTracksIterator::Last(), and MoveDown().

{
   if (t) {
      auto node = t->GetNode();
      if ( !isNull( node ) ) {
         if ( linked && t->GetLinked() )
            node = getNext( node );

         if ( !isNull( node ) )
            node = getNext( node );

         if ( !isNull( node ) )
            return node.first->get();
      }
   }

   return nullptr;
}

TrackNodePointer TrackList::getNext ( TrackNodePointer  p ) const

inlineprivate

Definition at line 772 of file Track.h.

References isNull().

Referenced by GetNext(), TrackListIterator::Next(), Remove(), and Select().

   {
      if ( isNull(p) )
         return p;
      auto q = p;
      ++q.first;
      return q;
   }

unsigned TrackList::GetNumExportChannels

(

bool

selectionOnly

)

const

Find out how many channels this track list mixes to.

This is used in exports of the tracks to work out whether to export in Mono, Stereo etc.

Parameters

selectionOnly

Whether to consider the entire track list or only the selected members of it

Definition at line 1260 of file Track.cpp.

References TrackListConstIterator::First(), Track::GetChannel(), Track::GetKind(), WaveTrack::GetPan(), Track::GetSelected(), Track::LeftChannel, Track::MonoChannel, TrackListConstIterator::Next(), Track::RightChannel, and Track::Wave.

Referenced by ExportMultiple::ExportMultipleByLabel().

{
   /* counters for tracks panned different places */
   int numLeft = 0;
   int numRight = 0;
   //int numMono = 0;
   /* track iteration kit */
   const Track *tr;
   TrackListConstIterator iter;

   for (tr = iter.First(this); tr != NULL; tr = iter.Next()) {

      // Want only unmuted wave tracks.
      auto wt = static_cast<const WaveTrack *>(tr);
      if ((tr->GetKind() != Track::Wave) ||
          wt->GetMute())
         continue;

      // do we only want selected ones?
      if (selectionOnly && !(tr->GetSelected())) {
         //want selected but this one is not
         continue;
      }

      // Found a left channel
      if (tr->GetChannel() == Track::LeftChannel) {
         numLeft++;
      }

      // Found a right channel
      else if (tr->GetChannel() == Track::RightChannel) {
         numRight++;
      }

      // Found a mono channel, but it may be panned
      else if (tr->GetChannel() == Track::MonoChannel) {
         float pan = ((WaveTrack*)tr)->GetPan();

         // Figure out what kind of channel it should be
         if (pan == -1.0) {   // panned hard left
            numLeft++;
         }
         else if (pan == 1.0) {  // panned hard right
            numRight++;
         }
         else if (pan == 0) { // panned dead center
            // numMono++;
         }
         else {   // panned somewhere else
            numLeft++;
            numRight++;
         }
      }
   }

   // if there is stereo content, report 2, else report 1
   if (numRight > 0 || numLeft > 0) {
      return 2;
   }

   return 1;
}

Track * TrackList::GetPrev	(	Track *	t,
		bool	linked = false
	)		const

Definition at line 1067 of file Track.cpp.

References Track::GetLink(), Track::GetLinked(), Track::GetNode(), getPrev(), and isNull().

Referenced by TrackSelectHandle::CalculateRearrangingThresholds(), TrackPanelResizeHandle::Cancel(), CanMoveUp(), TrackPanelResizeHandle::Drag(), MoveUp(), and SyncLockedTracksIterator::StartWith().

{
   if (t) {
      TrackNodePointer prev;
      auto node = t->GetNode();
      if ( !isNull( node ) ) {
         // linked is true and input track second in team?
         if (linked) {
            prev = getPrev( node );
            if( !isNull( prev ) &&
                !t->GetLinked() && t->GetLink() )
               // Make it the first
               node = prev;
         }

         prev = getPrev( node );
         if ( !isNull( prev ) ) {
            // Back up once
            node = prev;

            // Back up twice sometimes when linked is true
            if (linked) {
               prev = getPrev( node );
               if( !isNull( prev ) &&
                   !(*node.first)->GetLinked() && (*node.first)->GetLink() )
                  node = prev;
            }

            return node.first->get();
         }
      }
   }

   return nullptr;
}

TrackNodePointer TrackList::getPrev ( TrackNodePointer  p ) const

inlineprivate

Definition at line 782 of file Track.h.

References getBegin(), and getEnd().

Referenced by Add(), GetHeight(), GetPrev(), TrackListIterator::Last(), TrackListIterator::Prev(), RecalcPositions(), Select(), and size().

   {
      if (p == getBegin())
         return getEnd();
      else {
         auto q = p;
         --q.first;
         return q;
      }
   }

double TrackList::GetStartTime

(

)

const

Definition at line 1413 of file Track.cpp.

References Track::GetStartTime().

Referenced by TimeShiftHandle::DoSlideHorizontal(), AdornedRulerPanel::HandleQPRelease(), ControlToolBar::PlayPlayRegion(), and AdornedRulerPanel::StartQPPlay().

{
   return Accumulate(*this, &Track::GetStartTime, doubleMin);
}

TimeTrack * TrackList::GetTimeTrack

(

)

Definition at line 1244 of file Track.cpp.

References begin(), end(), Track::GetKind(), and Track::Time.

Referenced by ExportCL::Export(), ExportPCM::Export(), ExportMP3::Export(), AudacityProject::GetDefaultPlayOptions(), GetTimeTrack(), AudacityProject::HandlePasteNothingSelected(), and MixAndRender().

{
   auto iter = std::find_if(begin(), end(),
      [] ( Track *t ) { return t->GetKind() == Track::Time; }
   );
   if (iter == end())
      return nullptr;
   else
      return static_cast<TimeTrack*>(*iter);
}

const TimeTrack * TrackList::GetTimeTrack

(

)

const

Definition at line 1255 of file Track.cpp.

References GetTimeTrack().

{
   return const_cast<TrackList*>(this)->GetTimeTrack();
}

WaveTrackArray TrackList::GetWaveTrackArray	(	bool	selectionOnly,
		bool	includeMuted = true
	)

Definition at line 1344 of file Track.cpp.

References begin(), and end().

Referenced by RecordingRecoveryHandler::FindTrack(), RecordingRecoveryHandler::HandleXMLEndTag(), and RecordingRecoveryHandler::HandleXMLTag().

{
   return GetWaveTracks<WaveTrackArray>(begin(), end(), selectionOnly, includeMuted);
}

WaveTrackConstArray TrackList::GetWaveTrackConstArray	(	bool	selectionOnly,
		bool	includeMuted = true
	)		const

Definition at line 1349 of file Track.cpp.

References begin(), and end().

Referenced by ExportCL::Export(), ExportPCM::Export(), ExportMP3::Export(), and GetAllPlaybackTracks().

{
   auto list = const_cast<TrackList*>(this);
   return GetWaveTracks<WaveTrackConstArray>(
      list->begin(), list->end(), selectionOnly, includeMuted);
}

bool TrackList::HasPendingTracks

(

)

const

Definition at line 1567 of file Track.cpp.

References begin(), end(), Track::GetId(), and mPendingUpdates.

Referenced by AudacityProject::RedoAvailable(), and AudacityProject::UndoAvailable().

{
   if ( !mPendingUpdates.empty() )
      return true;
   if (end() != std::find_if(begin(), end(), [](const Track *t){
      return t->GetId() == TrackId{};
   }))
      return true;
   return false;
}

bool TrackList::isNull ( TrackNodePointer  p ) const

inlineprivate

Definition at line 761 of file Track.h.

References mPendingUpdates.

Referenced by TrackListIterator::First(), GetNext(), getNext(), GetPrev(), TrackListIterator::Last(), SyncLockedTracksIterator::Last(), TrackListIterator::Next(), TrackListIterator::operator*(), TrackListIterator::operator==(), TrackListIterator::Prev(), RecalcPositions(), Remove(), TrackListIterator::RemoveCurrent(), Select(), and SwapNodes().

   { return (p.second == this && p.first == ListOfTracks::end())
      || (p.second == &mPendingUpdates && p.first == mPendingUpdates.end()); }

template<typename Subclass >

std::shared_ptr<Subclass> TrackList::Lock ( const std::weak_ptr< Subclass > &  wTrack )

inline

Definition at line 734 of file Track.h.

Referenced by SelectHandle::AdjustSelection(), TrackPanelResizeHandle::Cancel(), TrackPanel::CancelDragging(), SelectionState::ChangeSelectionOnShiftClick(), ButtonHandle::Click(), SelectHandle::Click(), TrackPanelResizeHandle::Drag(), LabelTextHandle::Drag(), ButtonHandle::Drag(), WaveTrackVZoomHandle::Drag(), SelectHandle::Drag(), SliderHandle::GetSlider(), TrackPanel::OnMouseEvent(), LabelTextHandle::Release(), ButtonHandle::Release(), WaveTrackVZoomHandle::Release(), and LabelDefaultClickHandle::RestoreState().

   {
      auto pTrack = wTrack.lock();
      if (pTrack) {
         auto pList = pTrack->mList.lock();
         if (pTrack && this == pList.get())
            return pTrack;
      }
      return {};
   }

bool TrackList::Move ( Track *  t, bool  up  )

inline

Definition at line 708 of file Track.h.

References MoveDown(), and MoveUp().

{ return up ? MoveUp(t) : MoveDown(t); }

bool TrackList::MoveDown

(

Track *

t

)

Definition at line 1211 of file Track.cpp.

References GetNext(), Track::GetNode(), and SwapNodes().

Referenced by Move().

{
   if (t) {
      Track *n = GetNext(t, true);
      if (n) {
         SwapNodes(t->GetNode(), n->GetNode());
         return true;
      }
   }

   return false;
}

bool TrackList::MoveUp

(

Track *

t

)

Definition at line 1198 of file Track.cpp.

References Track::GetNode(), GetPrev(), and SwapNodes().

Referenced by Move(), and WaveTrackMenuTable::OnSwapChannels().

{
   if (t) {
      Track *p = GetPrev(t, true);
      if (p) {
         SwapNodes(p->GetNode(), t->GetNode());
         return true;
      }
   }

   return false;
}

TrackList& TrackList::operator= ( const TrackList &  )

privatedelete

TrackList & TrackList::operator= ( TrackList &&  that )

private

Definition at line 799 of file Track.cpp.

References Clear(), and Swap().

{
   if (this != &that) {
      this->Clear();
      Swap(that);
   }
   return *this;
}

void TrackList::PermutationEvent ( )

private

Definition at line 858 of file Track.cpp.

Referenced by Permute(), and SwapNodes().

{
   auto e = std::make_unique<wxCommandEvent>(EVT_TRACKLIST_PERMUTED);
   // wxWidgets will own the event object
   QueueEvent(e.release());
}

void TrackList::Permute

(

const std::vector< TrackNodePointer > &

permutation

)

For use in sorting: assume each iterator points into this list, no duplications.

Definition at line 880 of file Track.cpp.

References getBegin(), mSelf, PermutationEvent(), RecalcPositions(), and Track::SetOwner().

{
   for (const auto iter : permutation) {
      ListOfTracks::value_type track = std::move(*iter.first);
      erase(iter.first);
      Track *pTrack = track.get();
      pTrack->SetOwner(mSelf,
                       { insert(ListOfTracks::end(), std::move(track)), this });
   }
   auto n = getBegin();
   RecalcPositions(n);
   PermutationEvent();
}

void TrackList::RecalcPositions ( TrackNodePointer  node )

private

Definition at line 831 of file Track.cpp.

References Track::DoSetY(), end(), Track::GetHeight(), Track::GetIndex(), getPrev(), Track::GetY(), isNull(), Track::SetIndex(), and UpdatePendingTracks().

Referenced by Add(), AddToHead(), ApplyPendingTracks(), ClearPendingTracks(), Permute(), Remove(), and SwapNodes().

{
   if ( isNull( node ) )
      return;

   Track *t;
   int i = 0;
   int y = 0;

   auto prev = getPrev( node );
   if ( !isNull( prev ) ) {
      t = prev.first->get();
      i = t->GetIndex() + 1;
      y = t->GetY() + t->GetHeight();
   }

   const auto theEnd = end();
   for (auto n = TrackListIterator{ this, node }; n != theEnd; ++n) {
      t = *n;
      t->SetIndex(i++);
      t->DoSetY(y);
      y += t->GetHeight();
   }

   UpdatePendingTracks();
}

std::shared_ptr< Track > TrackList::RegisterPendingChangedTrack	(	Updater	updater,
		Track *	src
	)

Definition at line 1424 of file Track.cpp.

References Track::Duplicate(), mPendingUpdates, mSelf, and mUpdaters.

{
   std::shared_ptr<Track> pTrack;
   if (src)
      // convert from unique_ptr to shared_ptr
      pTrack.reset( src->Duplicate().release() );

   if (pTrack) {
      mUpdaters.push_back( updater );
      mPendingUpdates.push_back( pTrack );
      auto n = mPendingUpdates.end();
      --n;
      pTrack->SetOwner(mSelf, {n, &mPendingUpdates});
   }

   return pTrack;
}

void TrackList::RegisterPendingNewTrack

(

const std::shared_ptr< Track > &

pTrack

)

Definition at line 1442 of file Track.cpp.

{
   auto copy = pTrack;
   Add<Track>( std::move( copy ) );
   pTrack->SetId( TrackId{} );
}

TrackNodePointer TrackList::Remove

(

Track *

t

)

Remove this Track or all children of this TrackList. Return an iterator to what followed the removed track.

Definition at line 985 of file Track.cpp.

References DeletionEvent(), getEnd(), getNext(), Track::GetNode(), isNull(), RecalcPositions(), and Track::SetOwner().

Referenced by TrackListIterator::RemoveCurrent(), and Effect::ReplaceProcessedTracks().

{
   auto result = getEnd();
   if (t) {
      auto node = t->GetNode();
      t->SetOwner({}, {});

      if ( !isNull( node ) ) {
         ListOfTracks::value_type holder = std::move( *node.first );

         result = getNext( node );
         erase(node.first);
         if ( !isNull( result ) )
            RecalcPositions(result);

         DeletionEvent();
      }
   }
   return result;
}

auto TrackList::Replace	(	Track *	t,
		ListOfTracks::value_type &&	with
	)

Replace first track with second track, give back a holder Give the replacement the same id as the replaced

Definition at line 963 of file Track.cpp.

References Track::SetId(), and Track::SetOwner().

Referenced by ApplyPendingTracks(), Effect::ModifiedAnalysisTrack::ModifiedAnalysisTrack(), and Effect::ReplaceProcessedTracks().

{
   ListOfTracks::value_type holder;
   if (t && with) {
      auto node = t->GetNode();
      t->SetOwner({}, {});

      holder = std::move(*node.first);

      Track *pTrack = with.get();
      *node.first = std::move(with);
      pTrack->SetOwner(mSelf, node);
      pTrack->SetId( t->GetId() );
      RecalcPositions(node);

      DeletionEvent();
      ResizingEvent(node);
   }
   return holder;
}

void TrackList::ResizingEvent ( TrackNodePointer  node )

private

Definition at line 872 of file Track.cpp.

Referenced by Add(), and AddToHead().

{
   auto e = std::make_unique<TrackListEvent>(EVT_TRACKLIST_RESIZING);
   e->mpTrack = *node.first;
   // wxWidgets will own the event object
   QueueEvent(e.release());
}

void TrackList::Select	(	Track *	t,
		bool	selected = true
	)

Select a track, and if it is linked to another track, select it, too.

Definition at line 1027 of file Track.cpp.

References Track::GetLinked(), getNext(), Track::GetNode(), getPrev(), isNull(), and Track::SetSelected().

Referenced by SelectionState::SelectTrack().

{
   if (t) {
      const auto node = t->GetNode();
      if ( !isNull( node ) ) {
         t->SetSelected( selected );
         if ( t->GetLinked() ) {
            auto next = getNext( node );
            if ( !isNull( next ) )
               (*next.first)->SetSelected( selected );
         }
         else {
            auto prev = getPrev( node );
            if ( !isNull( prev ) && (*prev.first)->GetLinked() )
               (*prev.first)->SetSelected( selected );
         }
      }
   }
}

size_t TrackList::size

(

)

const

Definition at line 1234 of file Track.cpp.

References empty(), getEnd(), and getPrev().

Referenced by ScreenshotCommand::Apply().

{
   int cnt = 0;

   if (!empty())
      cnt = getPrev( getEnd() ).first->get()->GetIndex() + 1;

   return cnt;
}

void TrackList::Swap

(

TrackList &

that

)

Definition at line 808 of file Track.cpp.

Referenced by operator=(), and TrackList().

{
   auto SwapLOTs = [](
      ListOfTracks &a, const std::weak_ptr< TrackList > &aSelf,
      ListOfTracks &b, const std::weak_ptr< TrackList > &bSelf )
   {
      a.swap(b);
      for (auto it = a.begin(), last = a.end(); it != last; ++it)
         (*it)->SetOwner(aSelf, {it, &a});
      for (auto it = b.begin(), last = b.end(); it != last; ++it)
         (*it)->SetOwner(bSelf, {it, &b});
   };

   SwapLOTs( *this, mSelf, that, that.mSelf );
   SwapLOTs( this->mPendingUpdates, mSelf, that.mPendingUpdates, that.mSelf );
   mUpdaters.swap(that.mUpdaters);
}

void TrackList::SwapNodes ( TrackNodePointer  s1, TrackNodePointer  s2  )

private

Definition at line 1131 of file Track.cpp.

References Track::GetNode(), isNull(), mSelf, PermutationEvent(), RecalcPositions(), and Track::SetOwner().

Referenced by MoveDown(), and MoveUp().

{
   // if a null pointer is passed in, we want to know about it
   wxASSERT(!isNull(s1));
   wxASSERT(!isNull(s2));

   // Deal with first track in each team
   Track *link;
   link = (*s1.first)->GetLink();
   bool linked1 = link != nullptr;
   if (linked1 && !(*s1.first)->GetLinked()) {
      s1 = link->GetNode();
   }

   link = (*s2.first)->GetLink();
   bool linked2 = link != nullptr;
   if (linked2 && !(*s2.first)->GetLinked()) {
      s2 = link->GetNode();
   }

   // Safety check...
   if (s1 == s2)
      return;

   // Be sure s1 is the earlier iterator
   if ((*s1.first)->GetIndex() >= (*s2.first)->GetIndex()) {
      std::swap(s1, s2);
      std::swap(linked1, linked2);
   }

   // Remove tracks
   ListOfTracks::value_type save11 = std::move(*s1.first), save12{};
   s1.first = erase(s1.first);
   if (linked1) {
      wxASSERT(s1 != s2);
      save12 = std::move(*s1.first), s1.first = erase(s1.first);
   }
   const bool same = (s1 == s2);

   ListOfTracks::value_type save21 = std::move(*s2.first), save22{};
   s2.first = erase(s2.first);
   if (linked2)
      save22 = std::move(*s2.first), s2.first = erase(s2.first);

   if (same)
      // We invalidated s1!
      s1 = s2;

   // Reinsert them
   Track *pTrack;
   if (save22)
      pTrack = save22.get(),
      pTrack->SetOwner(mSelf, s1 = { insert(s1.first, std::move(save22)), this });
   pTrack = save21.get(),
   pTrack->SetOwner(mSelf, s1 = { insert(s1.first, std::move(save21)), this });

   if (save12)
      pTrack = save12.get(),
      pTrack->SetOwner(mSelf, s2 = { insert(s2.first, std::move(save12)), this });
   pTrack = save11.get(),
   pTrack->SetOwner(mSelf, s2 = { insert(s2.first, std::move(save11)), this });

   // Now correct the Index in the tracks, and other things
   RecalcPositions(s1);
   PermutationEvent();
}

void TrackList::UpdatePendingTracks

(

)

Definition at line 1449 of file Track.cpp.

References FindById(), mPendingUpdates, and mUpdaters.

Referenced by ApplyPendingTracks(), and RecalcPositions().

{
   auto pUpdater = mUpdaters.begin();
   for (const auto &pendingTrack : mPendingUpdates) {
      // Copy just a part of the track state, according to the update
      // function
      const auto &updater = *pUpdater;
      auto src = FindById( pendingTrack->GetId() );
      if (pendingTrack && src) {
         if (updater)
            updater( *pendingTrack, *src );
         pendingTrack->DoSetY(src->GetY());
         pendingTrack->DoSetHeight(src->GetHeight());
         pendingTrack->DoSetMinimized(src->GetMinimized());
         pendingTrack->DoSetLinked(src->GetLinked());
      }
      ++pUpdater;
   }
}

Friends And Related Function Documentation

friend class SyncLockedTracksIterator

friend

Definition at line 661 of file Track.h.

friend class Track

friend

Definition at line 659 of file Track.h.

friend class TrackListIterator

friend

Definition at line 660 of file Track.h.

Member Data Documentation

ListOfTracks TrackList::mPendingUpdates

private

Definition at line 858 of file Track.h.

Referenced by ApplyPendingTracks(), Clear(), ClearPendingTracks(), FindPendingChangedTrack(), HasPendingTracks(), isNull(), RegisterPendingChangedTrack(), and UpdatePendingTracks().

std::weak_ptr<TrackList> TrackList::mSelf

private

Definition at line 800 of file Track.h.

Referenced by Add(), AddToHead(), ApplyPendingTracks(), Create(), Permute(), RegisterPendingChangedTrack(), and SwapNodes().

std::vector< Updater > TrackList::mUpdaters

private

Definition at line 860 of file Track.h.

Referenced by Clear(), ClearPendingTracks(), RegisterPendingChangedTrack(), and UpdatePendingTracks().

long TrackList::sCounter = -1

staticprivate

Definition at line 805 of file Track.h.

Referenced by Add(), AddToHead(), and ApplyPendingTracks().

---

The documentation for this class was generated from the following files:

• Track.h
• Track.cpp