2010-01-23 19:44:49 +00:00
/**********************************************************************
Audacity : A Digital Audio Editor
Track . cpp
Dominic Mazzoni
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /**
\ class Track
\ brief Fundamental data object of Audacity , placed in the TrackPanel .
2014-06-03 20:30:19 +00:00
Classes derived form it include the WaveTrack , NoteTrack , LabelTrack
2010-01-23 19:44:49 +00:00
and TimeTrack .
*/ /*******************************************************************/
2016-03-01 23:31:51 +00:00
# include <algorithm>
# include <numeric>
2010-01-23 19:44:49 +00:00
# include <float.h>
# include <wx/file.h>
# include <wx/textfile.h>
# include <wx/log.h>
# include "Track.h"
2016-03-01 23:31:51 +00:00
# include "TimeTrack.h"
2010-01-23 19:44:49 +00:00
# include "WaveTrack.h"
# include "NoteTrack.h"
2016-03-13 15:08:21 +00:00
# include "LabelTrack.h"
2010-01-23 19:44:49 +00:00
# include "Project.h"
# include "DirManager.h"
2015-08-31 19:50:50 +00:00
# include "Experimental.h"
2010-01-23 19:44:49 +00:00
# ifdef _MSC_VER
//Disable truncation warnings
# pragma warning( disable : 4786 )
# endif
# ifdef __WXDEBUG__
// if we are in a debug build of audacity
/// Define this to do extended (slow) debuging of TrackListIterator
// #define DEBUG_TLI
# endif
2016-08-13 04:38:31 +00:00
Track : : Track ( const std : : shared_ptr < DirManager > & projDirManager )
2010-01-23 19:44:49 +00:00
: vrulerSize ( 36 , 0 ) ,
mDirManager ( projDirManager )
{
mList = NULL ;
mSelected = false ;
mLinked = false ;
mY = 0 ;
2017-06-07 01:40:58 +00:00
mHeight = DefaultHeight ;
2010-01-23 19:44:49 +00:00
mIndex = 0 ;
2013-05-30 23:14:25 +00:00
# ifdef EXPERIMENTAL_OUTPUT_DISPLAY
mYv = mHeight ;
mHeightv = mHeight ;
mPerY = 0.5 ;
mVirtualStereo = false ;
# endif
2010-01-23 19:44:49 +00:00
mMinimized = false ;
mOffset = 0.0 ;
mChannel = MonoChannel ;
}
Track : : Track ( const Track & orig )
{
mList = NULL ;
mY = 0 ;
mIndex = 0 ;
2013-05-30 23:14:25 +00:00
# ifdef EXPERIMENTAL_OUTPUT_DISPLAY
mPerY = 0.5 ;
# endif
2010-01-23 19:44:49 +00:00
Init ( orig ) ;
mOffset = orig . mOffset ;
}
// Copy all the track properties except the actual contents
void Track : : Init ( const Track & orig )
{
mDefaultName = orig . mDefaultName ;
mName = orig . mName ;
2016-08-13 04:38:31 +00:00
mDirManager = orig . mDirManager ;
2010-01-23 19:44:49 +00:00
mSelected = orig . mSelected ;
mLinked = orig . mLinked ;
mHeight = orig . mHeight ;
mMinimized = orig . mMinimized ;
mChannel = orig . mChannel ;
2013-05-30 23:14:25 +00:00
# ifdef EXPERIMENTAL_OUTPUT_DISPLAY
mVirtualStereo = orig . mVirtualStereo ;
mHeightv = orig . mHeightv ;
mYv = orig . mYv ;
# endif
2010-01-23 19:44:49 +00:00
}
2015-08-23 23:02:06 +00:00
void Track : : SetSelected ( bool s )
{
mSelected = s ;
}
2010-01-23 19:44:49 +00:00
void Track : : Merge ( const Track & orig )
{
mSelected = orig . mSelected ;
}
Track : : ~ Track ( )
{
}
2016-03-01 23:31:51 +00:00
TrackNodePointer Track : : GetNode ( ) const
2010-01-23 19:44:49 +00:00
{
2016-03-13 15:08:21 +00:00
wxASSERT ( mList = = NULL | | this = = mNode - > get ( ) ) ;
2010-01-23 19:44:49 +00:00
return mNode ;
}
// A track can only live on one list at a time, so if you're moving a
// track from one list to another, you must call SetOwner() with NULL
// pointers first and then with the real pointers.
2016-03-01 23:31:51 +00:00
void Track : : SetOwner ( TrackList * list , TrackNodePointer node )
2010-01-23 19:44:49 +00:00
{
mList = list ;
mNode = node ;
}
int Track : : GetMinimizedHeight ( ) const
{
if ( GetLink ( ) ) {
2017-06-10 09:10:38 +00:00
return 22 ;
2010-01-23 19:44:49 +00:00
}
2017-06-10 09:10:38 +00:00
return 44 ;
2010-01-23 19:44:49 +00:00
}
int Track : : GetIndex ( ) const
{
return mIndex ;
}
void Track : : SetIndex ( int index )
{
mIndex = index ;
}
2013-05-30 23:14:25 +00:00
# ifdef EXPERIMENTAL_OUTPUT_DISPLAY
int Track : : GetY ( bool vStereo ) const
{
if ( vStereo & & mChannel = = Track : : MonoChannel ) return mYv ;
return mY ;
}
void Track : : SetY ( int y , bool vStereo )
{
if ( vStereo & & mChannel = = Track : : MonoChannel ) mYv = y ;
else mY = y ;
}
int Track : : GetHeight ( bool vStereo ) const
{
if ( mMinimized ) {
return GetMinimizedHeight ( ) ;
}
if ( vStereo & & mChannel = = Track : : MonoChannel ) return mHeightv ;
return mHeight ;
}
void Track : : SetHeight ( int h , bool vStereo )
{
if ( vStereo & & mChannel = = Track : : MonoChannel ) mHeightv = h ;
else mHeight = h ;
2016-03-01 23:31:51 +00:00
if ( mList ) {
mList - > RecalcPositions ( mNode ) ;
mList - > ResizedEvent ( mNode ) ;
}
2013-05-30 23:14:25 +00:00
}
# else // EXPERIMENTAL_OUTPUT_DISPLAY
2010-01-23 19:44:49 +00:00
int Track : : GetY ( ) const
{
return mY ;
}
void Track : : SetY ( int y )
{
mY = y ;
}
int Track : : GetHeight ( ) const
{
if ( mMinimized ) {
return GetMinimizedHeight ( ) ;
}
return mHeight ;
}
void Track : : SetHeight ( int h )
{
mHeight = h ;
2016-03-01 23:31:51 +00:00
if ( mList ) {
mList - > RecalcPositions ( mNode ) ;
mList - > ResizedEvent ( mNode ) ;
}
2010-01-23 19:44:49 +00:00
}
2013-05-30 23:14:25 +00:00
# endif // EXPERIMENTAL_OUTPUT_DISPLAY
2010-01-23 19:44:49 +00:00
bool Track : : GetMinimized ( ) const
{
return mMinimized ;
}
void Track : : SetMinimized ( bool isMinimized )
{
mMinimized = isMinimized ;
2016-03-01 23:31:51 +00:00
if ( mList ) {
mList - > RecalcPositions ( mNode ) ;
mList - > ResizedEvent ( mNode ) ;
}
2010-01-23 19:44:49 +00:00
}
2013-03-10 16:31:07 +00:00
void Track : : SetLinked ( bool l )
{
mLinked = l ;
2016-03-01 23:31:51 +00:00
if ( mList ) {
mList - > RecalcPositions ( mNode ) ;
mList - > ResizedEvent ( mNode ) ;
}
2013-03-10 16:31:07 +00:00
}
2010-01-23 19:44:49 +00:00
Track * Track : : GetLink ( ) const
{
2016-03-01 23:31:51 +00:00
if ( ! mList )
return nullptr ;
if ( ! mList - > isNull ( mNode ) ) {
if ( mLinked ) {
auto next = mNode ;
+ + next ;
if ( ! mList - > isNull ( next ) ) {
2016-03-13 15:08:21 +00:00
return next - > get ( ) ;
2016-03-01 23:31:51 +00:00
}
2010-01-23 19:44:49 +00:00
}
2016-03-01 23:31:51 +00:00
if ( mList - > hasPrev ( mNode ) ) {
auto prev = mNode ;
- - prev ;
2016-03-13 15:08:21 +00:00
auto track = prev - > get ( ) ;
2016-03-01 23:31:51 +00:00
if ( track & & track - > GetLinked ( ) ) {
return track ;
}
2010-01-23 19:44:49 +00:00
}
}
2016-03-01 23:31:51 +00:00
return nullptr ;
2010-01-23 19:44:49 +00:00
}
2013-05-30 23:14:25 +00:00
# ifdef EXPERIMENTAL_OUTPUT_DISPLAY
void Track : : ReorderList ( bool resize )
{
2016-03-01 23:31:51 +00:00
if ( mList ) {
mList - > RecalcPositions ( mNode ) ;
if ( resize )
mList - > ResizedEvent ( mNode ) ;
}
2013-05-30 23:14:25 +00:00
}
# endif
2015-04-19 11:27:33 +00:00
bool Track : : IsSyncLockSelected ( ) const
2010-02-12 16:05:02 +00:00
{
2010-09-14 05:52:01 +00:00
# ifdef EXPERIMENTAL_SYNC_LOCK
2010-02-12 16:05:02 +00:00
AudacityProject * p = GetActiveProject ( ) ;
2010-08-11 22:47:26 +00:00
if ( ! p | | ! p - > IsSyncLocked ( ) )
2010-02-12 16:05:02 +00:00
return false ;
2010-08-11 23:56:50 +00:00
SyncLockedTracksIterator git ( mList ) ;
2016-02-23 19:06:36 +00:00
Track * t = git . StartWith ( const_cast < Track * > ( this ) ) ;
2010-02-12 16:05:02 +00:00
if ( ! t ) {
2010-08-11 23:56:50 +00:00
// Not in a sync-locked group.
(Sync-Lock)
Commented out the one call to TrackInfo::DrawBordersWithin(). This eliminates all the dark lines within the TrackInfo, in an effort to make the sync-lock icon not look like a button. It leaves some lighter borders, and I think that's an aesthetic improvement, though it make be worse in terms of accessibility. I can also remove the light border above the sync-lock icon, but I think this looks best overall.
In Track::IsSyncLockSelected(), for the "// Not in a sync-locked group." conditional, it returned true if the track was selected. I made it do so only if track kind is Wave or Label. Among other things, this means Time and Note tracks will never show the sync-lock icon. I think this is correct by definition, but Al, please let me know if this will have negative repercussions elsewhere. There are *lots* of calls to that method and I can move the track-type check to the code that draws the sync-lock icon..
Fixed the bug Gale pointed out where, if a WaveTrack is shrunk such that the sync-lock icon is over a TrackInfo control, such as pan slider, it didn't intercept the mouse event, and passed it on to the control. Now, clicking on the sync-lock icon does nothing.
Fixed a bug where the sync-lock icon was redrawn dark when the minimize button is down. Now not redrawn at all in that case.
Added some clarifying comments, especially about the term "Label" as used in TrackPanel.*.
2010-09-09 00:46:40 +00:00
return ( ( this - > GetKind ( ) = = Track : : Wave ) | | ( this - > GetKind ( ) = = Track : : Label ) ) & & GetSelected ( ) ;
2010-02-12 16:05:02 +00:00
}
for ( ; t ; t = git . Next ( ) ) {
if ( t - > GetSelected ( ) )
return true ;
}
# endif
return false ;
}
2017-03-23 15:10:14 +00:00
void Track : : SyncLockAdjust ( double oldT1 , double newT1 )
2010-02-16 20:50:38 +00:00
{
if ( newT1 > oldT1 ) {
// Insert space within the track
if ( oldT1 > GetEndTime ( ) )
2017-03-23 15:10:14 +00:00
return ;
2010-02-16 20:50:38 +00:00
2016-03-02 20:36:44 +00:00
auto tmp = Cut ( oldT1 , GetEndTime ( ) ) ;
2010-02-16 20:50:38 +00:00
2017-03-23 15:10:14 +00:00
Paste ( newT1 , tmp . get ( ) ) ;
2010-02-16 20:50:38 +00:00
}
else if ( newT1 < oldT1 ) {
// Remove from the track
2017-03-23 15:10:14 +00:00
Clear ( newT1 , oldT1 ) ;
2010-02-16 20:50:38 +00:00
}
}
2017-03-29 15:25:05 +00:00
void PlayableTrack : : Init ( const PlayableTrack & orig )
{
mMute = orig . mMute ;
mSolo = orig . mSolo ;
AudioTrack : : Init ( orig ) ;
}
void PlayableTrack : : Merge ( const Track & orig )
{
auto pOrig = dynamic_cast < const PlayableTrack * > ( & orig ) ;
wxASSERT ( pOrig ) ;
mMute = pOrig - > mMute ;
mSolo = pOrig - > mSolo ;
AudioTrack : : Merge ( * pOrig ) ;
}
2017-03-30 20:00:27 +00:00
// Serialize, not with tags of its own, but as attributes within a tag.
void PlayableTrack : : WriteXMLAttributes ( XMLWriter & xmlFile ) const
{
xmlFile . WriteAttr ( wxT ( " mute " ) , mMute ) ;
xmlFile . WriteAttr ( wxT ( " solo " ) , mSolo ) ;
AudioTrack : : WriteXMLAttributes ( xmlFile ) ;
}
// Return true iff the attribute is recognized.
bool PlayableTrack : : HandleXMLAttribute ( const wxChar * attr , const wxChar * value )
{
const wxString strValue { value } ;
long nValue ;
if ( ! wxStrcmp ( attr , wxT ( " mute " ) ) & &
XMLValueChecker : : IsGoodInt ( strValue ) & & strValue . ToLong ( & nValue ) ) {
mMute = ( nValue ! = 0 ) ;
return true ;
}
else if ( ! wxStrcmp ( attr , wxT ( " solo " ) ) & &
XMLValueChecker : : IsGoodInt ( strValue ) & & strValue . ToLong ( & nValue ) ) {
mSolo = ( nValue ! = 0 ) ;
return true ;
}
return AudioTrack : : HandleXMLAttribute ( attr , value ) ;
}
2010-01-23 19:44:49 +00:00
// TrackListIterator
TrackListIterator : : TrackListIterator ( TrackList * val )
2016-03-01 23:31:51 +00:00
: l ( val )
, cur { }
2010-01-23 19:44:49 +00:00
{
2016-03-01 23:31:51 +00:00
if ( l )
cur = l - > begin ( ) ;
2010-01-23 19:44:49 +00:00
}
Track * TrackListIterator : : StartWith ( Track * val )
{
if ( val = = NULL ) {
return First ( ) ;
}
if ( l = = NULL ) {
return NULL ;
}
2016-03-01 23:31:51 +00:00
if ( val - > mList = = NULL )
return nullptr ;
2010-01-23 19:44:49 +00:00
2016-03-01 23:31:51 +00:00
cur = val - > GetNode ( ) ;
2016-03-13 15:08:21 +00:00
return cur - > get ( ) ;
2010-01-23 19:44:49 +00:00
}
Track * TrackListIterator : : First ( TrackList * val )
{
if ( val ! = NULL ) {
l = val ;
}
if ( l = = NULL ) {
return NULL ;
}
2016-03-01 23:31:51 +00:00
cur = l - > begin ( ) ;
2010-01-23 19:44:49 +00:00
2016-03-01 23:31:51 +00:00
if ( ! l - > isNull ( cur ) ) {
2016-03-13 15:08:21 +00:00
return cur - > get ( ) ;
2010-01-23 19:44:49 +00:00
}
return NULL ;
}
Track * TrackListIterator : : Last ( bool skiplinked )
{
if ( l = = NULL ) {
return NULL ;
}
2016-03-01 23:31:51 +00:00
cur = l - > end ( ) ;
if ( l - > hasPrev ( cur ) )
- - cur ;
else
return NULL ;
2010-01-23 19:44:49 +00:00
// With skiplinked set, we won't return the second channel of a linked pair
2016-03-01 23:31:51 +00:00
if ( skiplinked & &
l - > hasPrev ( cur ) & &
! ( * cur ) - > GetLinked ( ) & &
( * cur ) - > GetLink ( ) )
- - cur ;
2010-01-23 19:44:49 +00:00
2016-03-13 15:08:21 +00:00
return cur - > get ( ) ;
2010-01-23 19:44:49 +00:00
}
2010-08-25 23:24:02 +00:00
Track * TrackListIterator : : Next ( bool skipLinked )
2010-01-23 19:44:49 +00:00
{
2016-03-01 23:31:51 +00:00
# ifdef DEBUG_TLI // if we are debugging this bit
2010-01-23 19:44:49 +00:00
wxASSERT_MSG ( ( ! cur | | ( * l ) . Contains ( ( * cur ) . t ) ) , wxT ( " cur invalid at start of Next(). List changed since iterator created? " ) ) ; // check that cur is in the list
2016-03-01 23:31:51 +00:00
# endif
2010-01-23 19:44:49 +00:00
2016-03-01 23:31:51 +00:00
if ( ! l | | l - > isNull ( cur ) )
return nullptr ;
if ( skipLinked & &
( * cur ) - > GetLinked ( ) ) {
+ + cur ;
2010-01-23 19:44:49 +00:00
}
# ifdef DEBUG_TLI // if we are debugging this bit
wxASSERT_MSG ( ( ! cur | | ( * l ) . Contains ( ( * cur ) . t ) ) , wxT ( " cur invalid after skipping linked tracks. " ) ) ; // check that cur is in the list
# endif
2016-03-01 23:31:51 +00:00
if ( ! l - > isNull ( cur ) ) {
+ + cur ;
2010-01-23 19:44:49 +00:00
}
# ifdef DEBUG_TLI // if we are debugging this bit
wxASSERT_MSG ( ( ! cur | | ( * l ) . Contains ( ( * cur ) . t ) ) , wxT ( " cur invalid after moving to next track. " ) ) ; // check that cur is in the list if it is not null
# endif
2016-03-01 23:31:51 +00:00
if ( ! l - > isNull ( cur ) ) {
2016-03-13 15:08:21 +00:00
return cur - > get ( ) ;
2010-01-23 19:44:49 +00:00
}
return NULL ;
}
Track * TrackListIterator : : Prev ( bool skiplinked )
{
2016-03-01 23:31:51 +00:00
if ( ! l | | l - > isNull ( cur ) )
return nullptr ;
if ( ! l - > hasPrev ( cur ) ) {
l - > setNull ( cur ) ;
return nullptr ;
}
- - cur ;
2010-01-23 19:44:49 +00:00
2016-03-01 23:31:51 +00:00
if ( skiplinked & & l - > hasPrev ( cur ) ) {
auto prev = cur ;
- - prev ;
if ( ( * prev ) - > GetLinked ( ) )
cur = prev ;
}
2010-01-23 19:44:49 +00:00
2016-03-13 15:08:21 +00:00
return cur - > get ( ) ;
2010-01-23 19:44:49 +00:00
}
2016-03-01 21:28:59 +00:00
Track * TrackListIterator : : RemoveCurrent ( )
2010-01-23 19:44:49 +00:00
{
2016-03-01 23:31:51 +00:00
if ( ! l | | l - > isNull ( cur ) )
return nullptr ;
2014-06-03 20:30:19 +00:00
2016-03-13 15:08:21 +00:00
cur = l - > Remove ( cur - > get ( ) ) ;
2010-01-23 19:44:49 +00:00
# ifdef DEBUG_TLI // if we are debugging this bit
wxASSERT_MSG ( ( ! cur | | ( * l ) . Contains ( ( * cur ) . t ) ) , wxT ( " cur invalid after deletion of track. " ) ) ; // check that cur is in the list
# endif
2016-03-01 23:31:51 +00:00
if ( ! l - > isNull ( cur ) ) {
2016-03-13 15:08:21 +00:00
return cur - > get ( ) ;
2010-01-23 19:44:49 +00:00
}
return NULL ;
}
//
// TrackListCondIterator (base class for iterators that iterate over all tracks
// that meet a condition)
//
Track * TrackListCondIterator : : StartWith ( Track * val )
{
Track * t = TrackListIterator : : StartWith ( val ) ;
if ( t & & ! this - > Condition ( t ) )
return NULL ;
return t ;
}
Track * TrackListCondIterator : : First ( TrackList * val )
{
Track * t = TrackListIterator : : First ( val ) ;
while ( t & & ! this - > Condition ( t ) ) {
t = TrackListIterator : : Next ( ) ;
}
return t ;
}
Track * TrackListCondIterator : : Next ( bool skiplinked )
{
while ( Track * t = TrackListIterator : : Next ( skiplinked ) ) {
if ( this - > Condition ( t ) ) {
return t ;
}
}
return NULL ;
}
Track * TrackListCondIterator : : Prev ( bool skiplinked )
{
while ( Track * t = TrackListIterator : : Prev ( skiplinked ) )
{
if ( this - > Condition ( t ) ) {
return t ;
}
}
return NULL ;
}
Track * TrackListCondIterator : : Last ( bool skiplinked )
{
Track * t = TrackListIterator : : Last ( skiplinked ) ;
while ( t & & ! this - > Condition ( t ) ) {
t = TrackListIterator : : Prev ( skiplinked ) ;
}
return t ;
}
// TrackListOfKindIterator
TrackListOfKindIterator : : TrackListOfKindIterator ( int kind , TrackList * val )
: TrackListCondIterator ( val )
{
this - > kind = kind ;
}
bool TrackListOfKindIterator : : Condition ( Track * t )
{
return kind = = Track : : All | | t - > GetKind ( ) = = kind ;
}
//SelectedTrackListOfKindIterator
bool SelectedTrackListOfKindIterator : : Condition ( Track * t )
{
return TrackListOfKindIterator : : Condition ( t ) & & t - > GetSelected ( ) ;
}
// VisibleTrackIterator
//
// Based on TrackListIterator returns only the currently visible tracks.
//
VisibleTrackIterator : : VisibleTrackIterator ( AudacityProject * project )
: TrackListCondIterator ( project - > GetTracks ( ) )
{
mProject = project ;
mPanelRect . SetTop ( mProject - > mViewInfo . vpos ) ;
mPanelRect . SetSize ( mProject - > GetTPTracksUsableArea ( ) ) ;
}
bool VisibleTrackIterator : : Condition ( Track * t )
{
wxRect r ( 0 , t - > GetY ( ) , 1 , t - > GetHeight ( ) ) ;
return r . Intersects ( mPanelRect ) ;
}
2010-08-11 23:56:50 +00:00
// SyncLockedTracksIterator
2010-01-23 19:44:49 +00:00
//
// Based on TrackListIterator returns only tracks belonging to the group
// in which the starting track is a member.
//
2010-08-11 23:56:50 +00:00
SyncLockedTracksIterator : : SyncLockedTracksIterator ( TrackList * val )
2010-02-12 16:05:02 +00:00
: TrackListIterator ( val ) ,
mInLabelSection ( false )
2010-01-23 19:44:49 +00:00
{
}
2016-11-04 04:10:21 +00:00
namespace {
2017-03-31 00:48:27 +00:00
inline bool IsSyncLockableNonLabelTrack ( const Track * pTrack )
2016-11-04 04:10:21 +00:00
{
2017-03-31 00:48:27 +00:00
return nullptr ! = dynamic_cast < const AudioTrack * > ( pTrack ) ;
2016-11-04 04:10:21 +00:00
}
}
2016-02-23 19:06:36 +00:00
Track * SyncLockedTracksIterator : : StartWith ( Track * member )
2010-01-23 19:44:49 +00:00
{
Track * t = NULL ;
2016-11-04 04:10:21 +00:00
// A sync-locked group consists of any positive number of wave (or note)
// tracks followed by any
2010-02-12 16:05:02 +00:00
// non-negative number of label tracks. Step back through any label tracks,
// and then through the wave tracks above them.
2010-01-23 19:44:49 +00:00
2010-02-12 16:05:02 +00:00
while ( member & & member - > GetKind ( ) = = Track : : Label ) {
member = l - > GetPrev ( member ) ;
2010-01-23 19:44:49 +00:00
}
2016-11-04 04:10:21 +00:00
while ( member & & IsSyncLockableNonLabelTrack ( member ) ) {
2010-01-23 19:44:49 +00:00
t = member ;
member = l - > GetPrev ( member ) ;
}
2010-02-12 16:05:02 +00:00
// Make it current (if t is still NULL there are no wave tracks, so we're
2010-08-11 23:56:50 +00:00
// not in a sync-locked group).
2010-01-23 19:44:49 +00:00
if ( t )
2016-03-01 23:31:51 +00:00
cur = t - > GetNode ( ) ;
2010-01-23 19:44:49 +00:00
2010-02-12 16:05:02 +00:00
mInLabelSection = false ;
2010-01-23 19:44:49 +00:00
return t ;
}
2016-11-04 04:10:21 +00:00
bool SyncLockedTracksIterator : : IsGoodNextTrack ( const Track * t ) const
{
if ( ! t )
return false ;
const bool isLabel = ( t - > GetKind ( ) = = Track : : Label ) ;
const bool isSyncLockable = IsSyncLockableNonLabelTrack ( t ) ;
if ( ! ( isLabel | | isSyncLockable ) ) {
return false ;
}
if ( mInLabelSection & & ! isLabel ) {
return false ;
}
return true ;
}
2010-08-11 23:56:50 +00:00
Track * SyncLockedTracksIterator : : Next ( bool skiplinked )
2010-01-23 19:44:49 +00:00
{
Track * t = TrackListIterator : : Next ( skiplinked ) ;
2010-02-12 16:05:02 +00:00
if ( ! t )
return NULL ;
2016-11-04 04:10:21 +00:00
if ( ! IsGoodNextTrack ( t ) ) {
2016-03-01 23:31:51 +00:00
l - > setNull ( cur ) ;
2010-02-12 16:05:02 +00:00
return NULL ;
2010-01-23 19:44:49 +00:00
}
2016-11-04 04:10:21 +00:00
mInLabelSection = ( t - > GetKind ( ) = = Track : : Label ) ;
2010-02-12 16:05:02 +00:00
2010-01-23 19:44:49 +00:00
return t ;
}
2010-08-11 23:56:50 +00:00
Track * SyncLockedTracksIterator : : Prev ( bool skiplinked )
2010-01-23 19:44:49 +00:00
{
Track * t = TrackListIterator : : Prev ( skiplinked ) ;
2010-02-12 16:05:02 +00:00
//
2010-08-11 23:56:50 +00:00
// Ways to end a sync-locked group in reverse
2010-02-12 16:05:02 +00:00
//
// Beginning of tracks
if ( ! t )
return NULL ;
2016-11-04 04:10:21 +00:00
const bool isLabel = ( t - > GetKind ( ) = = Track : : Label ) ;
const bool isSyncLockable = IsSyncLockableNonLabelTrack ( t ) ;
if ( ! ( isLabel | | isSyncLockable ) ) {
2016-03-01 23:31:51 +00:00
l - > setNull ( cur ) ;
2010-02-12 16:05:02 +00:00
return NULL ;
}
2016-11-04 04:10:21 +00:00
if ( ! mInLabelSection & & isLabel ) {
2016-03-01 23:31:51 +00:00
l - > setNull ( cur ) ;
2010-01-23 19:44:49 +00:00
return NULL ;
}
2016-11-04 04:10:21 +00:00
mInLabelSection = isLabel ;
2010-02-12 16:05:02 +00:00
2010-01-23 19:44:49 +00:00
return t ;
}
2010-08-11 23:56:50 +00:00
Track * SyncLockedTracksIterator : : Last ( bool skiplinked )
2010-01-23 19:44:49 +00:00
{
2016-03-01 23:31:51 +00:00
if ( ! l | | l - > isNull ( cur ) )
2010-01-23 19:44:49 +00:00
return NULL ;
2016-03-13 15:08:21 +00:00
Track * t = cur - > get ( ) ;
2010-01-23 19:44:49 +00:00
2016-11-04 04:10:21 +00:00
while ( const auto next = l - > GetNext ( t , skiplinked ) ) {
if ( ! IsGoodNextTrack ( next ) )
2010-02-12 16:05:02 +00:00
break ;
2010-01-23 19:44:49 +00:00
t = Next ( skiplinked ) ;
}
return t ;
}
// TrackList
//
// The TrackList sends itself events whenever an update occurs to the list it
// is managing. Any other classes that may be interested in get these updates
// should use TrackList::Connect() and TrackList::Disconnect().
//
DEFINE_EVENT_TYPE ( EVT_TRACKLIST_RESIZED ) ;
DEFINE_EVENT_TYPE ( EVT_TRACKLIST_UPDATED ) ;
2016-03-13 14:34:44 +00:00
TrackList : : TrackList ( )
2010-01-23 19:44:49 +00:00
: wxEvtHandler ( )
{
}
2016-03-07 11:43:42 +00:00
TrackList : : TrackList ( const TrackList & that )
2016-03-13 15:08:21 +00:00
: ListOfTracks { }
2016-03-07 11:43:42 +00:00
{
DoAssign ( that ) ;
}
TrackList & TrackList : : operator = ( const TrackList & that )
{
if ( this ! = & that ) {
2016-03-13 14:34:44 +00:00
this - > Clear ( ) ;
2016-03-07 11:43:42 +00:00
DoAssign ( that ) ;
}
return * this ;
}
TrackList : : TrackList ( TrackList & & that )
{
Swap ( that ) ;
}
TrackList & TrackList : : operator = ( TrackList & & that )
{
if ( this ! = & that ) {
2016-03-13 14:34:44 +00:00
this - > Clear ( ) ;
2016-03-07 11:43:42 +00:00
Swap ( that ) ;
}
return * this ;
}
void TrackList : : DoAssign ( const TrackList & that )
{
TrackListConstIterator it ( & that ) ;
for ( const Track * track = it . First ( ) ; track ; track = it . Next ( ) )
2016-03-13 15:08:21 +00:00
Add ( track - > Duplicate ( ) ) ;
2016-03-07 11:43:42 +00:00
}
void TrackList : : Swap ( TrackList & that )
{
2016-03-01 23:31:51 +00:00
ListOfTracks : : swap ( that ) ;
for ( auto it = begin ( ) , last = end ( ) ; it ! = last ; + + it )
( * it ) - > SetOwner ( this , it ) ;
for ( auto it = that . begin ( ) , last = that . end ( ) ; it ! = last ; + + it )
( * it ) - > SetOwner ( & that , it ) ;
2016-03-07 11:43:42 +00:00
}
2010-01-23 19:44:49 +00:00
TrackList : : ~ TrackList ( )
{
2016-06-28 03:38:42 +00:00
Clear ( false ) ;
2010-01-23 19:44:49 +00:00
}
2016-03-01 23:31:51 +00:00
void TrackList : : RecalcPositions ( TrackNodePointer node )
2010-01-23 19:44:49 +00:00
{
2016-03-01 23:31:51 +00:00
if ( isNull ( node ) ) {
return ;
}
2010-01-23 19:44:49 +00:00
Track * t ;
int i = 0 ;
int y = 0 ;
2013-05-30 23:14:25 +00:00
# ifdef EXPERIMENTAL_OUTPUT_DISPLAY
int cnt = 0 ;
2017-01-06 16:23:02 +00:00
if ( hasPrev ( node ) ) {
auto prev = node ;
- - prev ;
t = prev - > get ( ) ;
2013-05-30 23:14:25 +00:00
i = t - > GetIndex ( ) + 1 ;
if ( MONO_WAVE_PAN ( t ) )
y = t - > GetY ( true ) + t - > GetHeight ( true ) ;
else
y = t - > GetY ( ) + t - > GetHeight ( ) ;
}
2017-01-06 16:23:02 +00:00
for ( auto n = node ; n ! = end ( ) ; + + n ) {
t = n - > get ( ) ;
2013-05-30 23:14:25 +00:00
if ( MONO_WAVE_PAN ( t ) )
cnt + + ;
if ( cnt ! = 2 ) {
t - > SetIndex ( i + + ) ;
t - > SetY ( y ) ;
y + = t - > GetHeight ( ) ;
}
if ( cnt ! = 0 ) {
t - > SetY ( y , true ) ;
y + = t - > GetHeight ( true ) ;
}
cnt = 0 ;
}
# else // EXPERIMENTAL_OUTPUT_DISPLAY
2016-03-01 23:31:51 +00:00
if ( hasPrev ( node ) ) {
auto prev = node ;
- - prev ;
2016-03-13 15:08:21 +00:00
t = prev - > get ( ) ;
2010-01-23 19:44:49 +00:00
i = t - > GetIndex ( ) + 1 ;
y = t - > GetY ( ) + t - > GetHeight ( ) ;
}
2016-03-01 23:31:51 +00:00
const auto theEnd = end ( ) ;
for ( auto n = node ; n ! = theEnd ; + + n ) {
2016-03-13 15:08:21 +00:00
t = n - > get ( ) ;
2010-01-23 19:44:49 +00:00
t - > SetIndex ( i + + ) ;
t - > SetY ( y ) ;
y + = t - > GetHeight ( ) ;
}
2013-05-30 23:14:25 +00:00
# endif // EXPERIMENTAL_OUTPUT_DISPLAY
2010-01-23 19:44:49 +00:00
}
2016-03-01 23:31:51 +00:00
void TrackList : : UpdatedEvent ( TrackNodePointer node )
2010-01-23 19:44:49 +00:00
{
wxCommandEvent e ( EVT_TRACKLIST_UPDATED ) ;
2016-03-01 23:31:51 +00:00
if ( ! isNull ( node ) ) {
2016-03-13 15:08:21 +00:00
e . SetClientData ( node - > get ( ) ) ;
2010-01-23 19:44:49 +00:00
}
else {
e . SetClientData ( NULL ) ;
}
2017-06-01 18:19:52 +00:00
// PRL: ProcessEvent, not QueueEvent! Listeners may need their last
// chance to examine some removed tracks that are about to be destroyed.
2010-01-23 19:44:49 +00:00
ProcessEvent ( e ) ;
}
2016-03-01 23:31:51 +00:00
void TrackList : : ResizedEvent ( TrackNodePointer node )
2010-01-23 19:44:49 +00:00
{
2016-03-01 23:31:51 +00:00
if ( ! isNull ( node ) ) {
2010-01-23 19:44:49 +00:00
wxCommandEvent e ( EVT_TRACKLIST_RESIZED ) ;
2016-03-13 15:08:21 +00:00
e . SetClientData ( node - > get ( ) ) ;
2010-01-23 19:44:49 +00:00
ProcessEvent ( e ) ;
}
}
2016-03-01 22:34:45 +00:00
void TrackList : : Permute ( const std : : vector < TrackNodePointer > & permutation )
{
for ( const auto iter : permutation ) {
2016-03-13 15:08:21 +00:00
value_type track = std : : move ( * iter ) ;
2016-03-01 22:34:45 +00:00
erase ( iter ) ;
2016-03-13 15:08:21 +00:00
Track * pTrack = track . get ( ) ;
pTrack - > SetOwner ( this , insert ( end ( ) , std : : move ( track ) ) ) ;
2016-03-01 22:34:45 +00:00
}
auto n = begin ( ) ;
RecalcPositions ( n ) ;
UpdatedEvent ( n ) ;
ResizedEvent ( n ) ;
}
2016-03-13 15:08:21 +00:00
template < typename TrackKind >
Track * TrackList : : Add ( std : : unique_ptr < TrackKind > & & t )
2010-01-23 19:44:49 +00:00
{
2016-03-13 15:08:21 +00:00
Track * pTrack ;
push_back ( value_type ( pTrack = t . release ( ) ) ) ;
2016-03-01 23:31:51 +00:00
auto n = end ( ) ;
- - n ;
2016-03-13 15:08:21 +00:00
pTrack - > SetOwner ( this , n ) ;
2010-01-23 19:44:49 +00:00
RecalcPositions ( n ) ;
UpdatedEvent ( n ) ;
2016-03-13 15:08:21 +00:00
return back ( ) . get ( ) ;
2010-01-23 19:44:49 +00:00
}
2016-03-13 15:08:21 +00:00
// Make instantiations for the linker to find
template Track * TrackList : : Add < TimeTrack > ( std : : unique_ptr < TimeTrack > & & ) ;
2016-04-28 07:25:22 +00:00
# if defined(USE_MIDI)
2016-03-13 15:08:21 +00:00
template Track * TrackList : : Add < NoteTrack > ( std : : unique_ptr < NoteTrack > & & ) ;
2016-04-28 07:25:22 +00:00
# endif
2016-03-13 15:08:21 +00:00
template Track * TrackList : : Add < WaveTrack > ( std : : unique_ptr < WaveTrack > & & ) ;
template Track * TrackList : : Add < LabelTrack > ( std : : unique_ptr < LabelTrack > & & ) ;
2017-02-07 18:11:33 +00:00
template Track * TrackList : : Add < Track > ( std : : unique_ptr < Track > & & ) ;
2016-03-13 15:08:21 +00:00
template < typename TrackKind >
Track * TrackList : : AddToHead ( std : : unique_ptr < TrackKind > & & t )
2010-01-23 19:44:49 +00:00
{
2016-03-13 15:08:21 +00:00
Track * pTrack ;
push_front ( value_type ( pTrack = t . release ( ) ) ) ;
2016-03-01 23:31:51 +00:00
auto n = begin ( ) ;
2016-03-13 15:08:21 +00:00
pTrack - > SetOwner ( this , n ) ;
2016-03-01 23:31:51 +00:00
RecalcPositions ( n ) ;
2010-01-23 19:44:49 +00:00
UpdatedEvent ( n ) ;
ResizedEvent ( n ) ;
2016-03-13 15:08:21 +00:00
return front ( ) . get ( ) ;
2010-01-23 19:44:49 +00:00
}
2016-03-13 15:08:21 +00:00
// Make instantiations for the linker to find
template Track * TrackList : : AddToHead < TimeTrack > ( std : : unique_ptr < TimeTrack > & & ) ;
# ifdef __AUDACITY_OLD_STD__
template < typename TrackKind >
Track * TrackList : : Add ( std : : shared_ptr < TrackKind > & & t )
2010-01-23 19:44:49 +00:00
{
2016-03-13 15:08:21 +00:00
push_back ( t ) ;
auto n = end ( ) ;
- - n ;
t - > SetOwner ( this , n ) ;
RecalcPositions ( n ) ;
UpdatedEvent ( n ) ;
return back ( ) . get ( ) ;
}
// Make instantiations for the linker to find
template Track * TrackList : : Add < Track > ( std : : shared_ptr < Track > & & ) ;
template Track * TrackList : : Add < WaveTrack > ( std : : shared_ptr < WaveTrack > & & ) ;
# endif
auto TrackList : : Replace ( Track * t , value_type & & with ) - > value_type
{
value_type holder ;
2016-03-01 00:54:21 +00:00
if ( t & & with ) {
2016-03-01 23:31:51 +00:00
auto node = t - > GetNode ( ) ;
2016-03-13 15:08:21 +00:00
holder = std : : move ( * node ) ;
2016-02-27 22:29:21 +00:00
2016-03-13 15:08:21 +00:00
Track * pTrack = with . get ( ) ;
* node = std : : move ( with ) ;
pTrack - > SetOwner ( this , node ) ;
2010-01-23 19:44:49 +00:00
RecalcPositions ( node ) ;
2017-06-01 18:19:52 +00:00
// PRL: Note: Send the event while t (now in holder) is not yet
// destroyed, so pointers to t that listeners may have are not dangling.
2010-01-23 19:44:49 +00:00
UpdatedEvent ( node ) ;
ResizedEvent ( node ) ;
}
2016-03-13 15:08:21 +00:00
return holder ;
2010-01-23 19:44:49 +00:00
}
2016-03-01 21:28:59 +00:00
TrackNodePointer TrackList : : Remove ( Track * t )
2010-01-23 19:44:49 +00:00
{
2016-03-01 23:31:51 +00:00
TrackNodePointer result ( end ( ) ) ;
2010-01-23 19:44:49 +00:00
if ( t ) {
2016-03-01 23:31:51 +00:00
auto node = t - > GetNode ( ) ;
2010-01-23 19:44:49 +00:00
2016-03-01 23:31:51 +00:00
if ( ! isNull ( node ) ) {
2017-06-01 18:19:52 +00:00
value_type holder = std : : move ( * node ) ;
2016-03-01 23:31:51 +00:00
result = erase ( node ) ;
if ( ! isNull ( result ) ) {
RecalcPositions ( result ) ;
2010-01-23 19:44:49 +00:00
}
2017-06-01 18:19:52 +00:00
// PRL: Note: Send the event while t (now in holder) is not yet
// destroyed, so pointers to t that listeners may have are not dangling.
2016-03-01 23:31:51 +00:00
UpdatedEvent ( end ( ) ) ;
ResizedEvent ( result ) ;
2010-01-23 19:44:49 +00:00
}
}
2016-03-01 23:31:51 +00:00
return result ;
2010-01-23 19:44:49 +00:00
}
2016-06-28 03:38:42 +00:00
void TrackList : : Clear ( bool sendEvent )
2010-01-23 19:44:49 +00:00
{
2017-06-01 18:19:52 +00:00
ListOfTracks tempList ;
tempList . swap ( * this ) ;
2016-06-28 03:38:42 +00:00
if ( sendEvent )
2017-06-01 18:19:52 +00:00
// PRL: Note: Send the event while tempList is not yet
// destroyed, so pointers to tracks that listeners may have are not
// dangling.
2016-06-28 03:38:42 +00:00
UpdatedEvent ( end ( ) ) ;
2010-01-23 19:44:49 +00:00
}
void TrackList : : Select ( Track * t , bool selected /* = true */ )
{
if ( t ) {
2016-03-01 23:31:51 +00:00
const auto node = t - > GetNode ( ) ;
if ( ! isNull ( node ) ) {
2010-01-23 19:44:49 +00:00
t - > SetSelected ( selected ) ;
2016-03-01 23:31:51 +00:00
auto next = node ;
+ + next ;
if ( t - > GetLinked ( ) & & ! isNull ( next ) ) {
( * next ) - > SetSelected ( selected ) ;
2010-01-23 19:44:49 +00:00
}
2016-03-01 23:31:51 +00:00
else if ( hasPrev ( node ) ) {
auto prev = node ;
- - prev ;
if ( ( * prev ) - > GetLinked ( ) ) {
( * prev ) - > SetSelected ( selected ) ;
}
2010-01-23 19:44:49 +00:00
}
}
}
}
2011-04-17 23:54:30 +00:00
/// Return a track in the list that comes after Track t
2010-01-23 19:44:49 +00:00
Track * TrackList : : GetNext ( Track * t , bool linked ) const
{
if ( t ) {
2016-03-01 23:31:51 +00:00
auto node = t - > GetNode ( ) ;
if ( ! isNull ( node ) ) {
2010-01-23 19:44:49 +00:00
if ( linked & & t - > GetLinked ( ) ) {
2016-03-01 23:31:51 +00:00
+ + node ;
2010-01-23 19:44:49 +00:00
}
2016-03-01 23:31:51 +00:00
if ( ! isNull ( node ) ) {
+ + node ;
2010-01-23 19:44:49 +00:00
}
2014-06-03 20:30:19 +00:00
2016-03-01 23:31:51 +00:00
if ( ! isNull ( node ) ) {
2016-03-13 15:08:21 +00:00
return node - > get ( ) ;
2010-01-23 19:44:49 +00:00
}
}
}
return NULL ;
}
Track * TrackList : : GetPrev ( Track * t , bool linked ) const
{
if ( t ) {
2016-03-01 23:31:51 +00:00
auto node = t - > GetNode ( ) ;
if ( ! isNull ( node ) ) {
// linked is true and input track second in team?
if ( linked & & hasPrev ( node ) & &
! t - > GetLinked ( ) & & t - > GetLink ( ) )
2010-01-23 19:44:49 +00:00
// Make it the first
2016-03-01 23:31:51 +00:00
- - node ;
2010-01-23 19:44:49 +00:00
2016-03-01 23:31:51 +00:00
if ( hasPrev ( node ) ) {
// Back up once
- - node ;
2010-01-23 19:44:49 +00:00
2016-03-01 23:31:51 +00:00
// Back up twice sometimes when linked is true
if ( linked & & hasPrev ( node ) & &
! ( * node ) - > GetLinked ( ) & & ( * node ) - > GetLink ( ) )
- - node ;
2010-01-23 19:44:49 +00:00
2016-03-13 15:08:21 +00:00
return node - > get ( ) ;
2010-01-23 19:44:49 +00:00
}
}
}
return NULL ;
}
/// For mono track height of track
2010-08-11 23:56:50 +00:00
/// For stereo track combined height of both channels.
2010-01-23 19:44:49 +00:00
int TrackList : : GetGroupHeight ( Track * t ) const
{
int height = t - > GetHeight ( ) ;
t = t - > GetLink ( ) ;
if ( t ) {
height + = t - > GetHeight ( ) ;
}
2013-05-30 23:14:25 +00:00
# ifdef EXPERIMENTAL_OUTPUT_DISPLAY
else if ( MONO_WAVE_PAN ( t ) ) {
height + = t - > GetHeight ( true ) ;
}
# endif
2010-01-23 19:44:49 +00:00
return height ;
}
bool TrackList : : CanMoveUp ( Track * t ) const
{
return GetPrev ( t , true ) ! = NULL ;
}
bool TrackList : : CanMoveDown ( Track * t ) const
{
return GetNext ( t , true ) ! = NULL ;
}
// This is used when you want to swap the track or pair of
// tracks in s1 with the track or pair of tracks in s2.
// The complication is that the tracks are stored in a single
// linked list, and pairs of tracks are marked only by a flag
// in one of the tracks.
2016-03-01 23:31:51 +00:00
void TrackList : : SwapNodes ( TrackNodePointer s1 , TrackNodePointer s2 )
2010-01-23 19:44:49 +00:00
{
// if a null pointer is passed in, we want to know about it
2016-03-01 23:31:51 +00:00
wxASSERT ( ! isNull ( s1 ) ) ;
wxASSERT ( ! isNull ( s2 ) ) ;
2010-01-23 19:44:49 +00:00
2016-03-01 23:31:51 +00:00
// Deal with first track in each team
Track * link ;
link = ( * s1 ) - > GetLink ( ) ;
bool linked1 = link ! = nullptr ;
if ( linked1 & & ! ( * s1 ) - > GetLinked ( ) ) {
s1 = link - > GetNode ( ) ;
2010-01-23 19:44:49 +00:00
}
2016-03-01 23:31:51 +00:00
link = ( * s2 ) - > GetLink ( ) ;
bool linked2 = link ! = nullptr ;
if ( linked2 & & ! ( * s2 ) - > GetLinked ( ) ) {
s2 = link - > GetNode ( ) ;
2010-01-23 19:44:49 +00:00
}
2016-03-01 23:31:51 +00:00
// Safety check...
if ( s1 = = s2 )
return ;
2010-01-23 19:44:49 +00:00
2016-03-01 23:31:51 +00:00
// Be sure s1 is the earlier iterator
if ( ( * s1 ) - > GetIndex ( ) > = ( * s2 ) - > GetIndex ( ) ) {
std : : swap ( s1 , s2 ) ;
std : : swap ( linked1 , linked2 ) ;
2010-01-23 19:44:49 +00:00
}
2016-03-01 23:31:51 +00:00
// Remove tracks
2016-03-13 15:08:21 +00:00
value_type save11 = std : : move ( * s1 ) , save12 { } ;
2016-03-01 23:31:51 +00:00
s1 = erase ( s1 ) ;
if ( linked1 ) {
wxASSERT ( s1 ! = s2 ) ;
2016-03-13 15:08:21 +00:00
save12 = std : : move ( * s1 ) , s1 = erase ( s1 ) ;
2010-01-23 19:44:49 +00:00
}
2016-03-01 23:31:51 +00:00
const bool same = ( s1 = = s2 ) ;
2010-01-23 19:44:49 +00:00
2016-03-13 15:08:21 +00:00
value_type save21 = std : : move ( * s2 ) , save22 { } ;
2016-03-01 23:31:51 +00:00
s2 = erase ( s2 ) ;
if ( linked2 )
2016-03-13 15:08:21 +00:00
save22 = std : : move ( * s2 ) , s2 = erase ( s2 ) ;
2010-01-23 19:44:49 +00:00
2016-03-01 23:31:51 +00:00
if ( same )
// We invalidated s1!
s1 = s2 ;
// Reinsert them
2016-03-13 15:08:21 +00:00
Track * pTrack ;
2016-03-01 23:31:51 +00:00
if ( save22 )
2016-03-13 15:08:21 +00:00
pTrack = save22 . get ( ) , pTrack - > SetOwner ( this , s1 = insert ( s1 , std : : move ( save22 ) ) ) ;
pTrack = save21 . get ( ) , pTrack - > SetOwner ( this , s1 = insert ( s1 , std : : move ( save21 ) ) ) ;
2010-01-23 19:44:49 +00:00
2016-03-01 23:31:51 +00:00
if ( save12 )
2016-03-13 15:08:21 +00:00
pTrack = save12 . get ( ) , pTrack - > SetOwner ( this , s2 = insert ( s2 , std : : move ( save12 ) ) ) ;
pTrack = save11 . get ( ) , pTrack - > SetOwner ( this , s2 = insert ( s2 , std : : move ( save11 ) ) ) ;
2016-03-01 23:31:51 +00:00
// Now correct the Index in the tracks, and other things
2010-01-23 19:44:49 +00:00
RecalcPositions ( s1 ) ;
UpdatedEvent ( s1 ) ;
ResizedEvent ( s1 ) ;
}
bool TrackList : : MoveUp ( Track * t )
{
if ( t ) {
Track * p = GetPrev ( t , true ) ;
if ( p ) {
2016-03-01 23:31:51 +00:00
SwapNodes ( p - > GetNode ( ) , t - > GetNode ( ) ) ;
2010-01-23 19:44:49 +00:00
return true ;
}
}
return false ;
}
bool TrackList : : MoveDown ( Track * t )
{
if ( t ) {
Track * n = GetNext ( t , true ) ;
if ( n ) {
2016-03-01 23:31:51 +00:00
SwapNodes ( t - > GetNode ( ) , n - > GetNode ( ) ) ;
2010-01-23 19:44:49 +00:00
return true ;
}
}
return false ;
}
2016-05-22 03:19:09 +00:00
bool TrackList : : Contains ( const Track * t ) const
2010-01-23 19:44:49 +00:00
{
2016-03-13 15:08:21 +00:00
return std : : find_if ( begin ( ) , end ( ) ,
[ = ] ( const value_type & track ) { return t = = track . get ( ) ; }
) ! = end ( ) ;
2010-01-23 19:44:49 +00:00
}
bool TrackList : : IsEmpty ( ) const
{
2016-03-01 23:31:51 +00:00
return empty ( ) ;
2010-01-23 19:44:49 +00:00
}
int TrackList : : GetCount ( ) const
{
int cnt = 0 ;
2016-03-01 23:31:51 +00:00
if ( ! empty ( ) ) {
cnt = back ( ) - > GetIndex ( ) + 1 ;
2010-01-23 19:44:49 +00:00
}
return cnt ;
}
TimeTrack * TrackList : : GetTimeTrack ( )
{
2016-03-01 23:31:51 +00:00
auto iter = std : : find_if ( begin ( ) , end ( ) ,
2016-03-13 15:08:21 +00:00
[ ] ( const value_type & t ) { return t - > GetKind ( ) = = Track : : Time ; }
2016-03-01 23:31:51 +00:00
) ;
if ( iter = = end ( ) )
return nullptr ;
else
2016-03-13 15:08:21 +00:00
return static_cast < TimeTrack * > ( iter - > get ( ) ) ;
2010-01-23 19:44:49 +00:00
}
2016-02-26 23:10:45 +00:00
const TimeTrack * TrackList : : GetTimeTrack ( ) const
{
return const_cast < TrackList * > ( this ) - > GetTimeTrack ( ) ;
}
2016-09-02 19:53:09 +00:00
unsigned TrackList : : GetNumExportChannels ( bool selectionOnly ) const
2010-01-23 19:44:49 +00:00
{
/* counters for tracks panned different places */
int numLeft = 0 ;
int numRight = 0 ;
int numMono = 0 ;
/* track iteration kit */
2016-02-26 23:10:45 +00:00
const Track * tr ;
TrackListConstIterator iter ;
2010-01-23 19:44:49 +00:00
for ( tr = iter . First ( this ) ; tr ! = NULL ; tr = iter . Next ( ) ) {
2013-01-05 00:05:59 +00:00
// Want only unmuted wave tracks.
2017-03-29 15:25:05 +00:00
auto wt = static_cast < const WaveTrack * > ( tr ) ;
if ( ( tr - > GetKind ( ) ! = Track : : Wave ) | |
wt - > GetMute ( ) )
2010-01-23 19:44:49 +00:00
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 ;
}
2016-02-26 23:10:45 +00:00
namespace {
template < typename Array >
2016-03-01 23:31:51 +00:00
Array GetWaveTracks ( ListOfTracks : : const_iterator p , ListOfTracks : : const_iterator end ,
bool selectionOnly , bool includeMuted )
2016-02-26 23:10:45 +00:00
{
Array waveTrackArray ;
2010-01-23 19:44:49 +00:00
2016-03-01 23:31:51 +00:00
for ( ; p ! = end ; + + p ) {
2016-03-13 15:08:21 +00:00
const auto & track = * p ;
2017-03-29 15:25:05 +00:00
auto wt = static_cast < const WaveTrack * > ( & * track ) ;
2016-03-01 23:31:51 +00:00
if ( track - > GetKind ( ) = = Track : : Wave & &
2017-03-29 15:25:05 +00:00
( includeMuted | | ! wt - > GetMute ( ) ) & &
2016-03-01 23:31:51 +00:00
( track - > GetSelected ( ) | | ! selectionOnly ) ) {
2016-03-13 15:08:21 +00:00
waveTrackArray . push_back ( static_cast < WaveTrack * > ( track . get ( ) ) ) ;
2016-02-26 23:10:45 +00:00
}
2010-01-23 19:44:49 +00:00
}
2016-02-26 23:10:45 +00:00
return waveTrackArray ;
2010-01-23 19:44:49 +00:00
}
}
2016-02-26 23:10:45 +00:00
WaveTrackArray TrackList : : GetWaveTrackArray ( bool selectionOnly , bool includeMuted )
2010-01-23 19:44:49 +00:00
{
2016-03-31 14:36:13 +00:00
return GetWaveTracks < WaveTrackArray > ( begin ( ) , end ( ) , selectionOnly , includeMuted ) ;
2016-02-26 23:10:45 +00:00
}
2010-01-23 19:44:49 +00:00
2016-02-26 23:10:45 +00:00
WaveTrackConstArray TrackList : : GetWaveTrackConstArray ( bool selectionOnly , bool includeMuted ) const
{
2016-03-31 14:36:13 +00:00
return GetWaveTracks < WaveTrackConstArray > ( begin ( ) , end ( ) , selectionOnly , includeMuted ) ;
2010-01-23 19:44:49 +00:00
}
# if defined(USE_MIDI)
NoteTrackArray TrackList : : GetNoteTrackArray ( bool selectionOnly )
{
NoteTrackArray noteTrackArray ;
2016-03-01 23:31:51 +00:00
for ( const auto & track : * this ) {
if ( track - > GetKind ( ) = = Track : : Note & &
( track - > GetSelected ( ) | | ! selectionOnly ) ) {
2016-04-09 19:10:05 +00:00
noteTrackArray . push_back ( static_cast < NoteTrack * > ( track . get ( ) ) ) ;
2010-01-23 19:44:49 +00:00
}
}
return noteTrackArray ;
}
# endif
int TrackList : : GetHeight ( ) const
{
int height = 0 ;
2013-05-30 23:14:25 +00:00
# ifdef EXPERIMENTAL_OUTPUT_DISPLAY
2017-01-06 16:23:02 +00:00
if ( ! empty ( ) ) {
const Track * t = rbegin ( ) - > get ( ) ;
2013-05-30 23:14:25 +00:00
if ( MONO_WAVE_PAN ( t ) )
height = t - > GetY ( true ) + t - > GetHeight ( true ) ;
else
height = t - > GetY ( ) + t - > GetHeight ( ) ;
}
# else
2016-03-01 23:31:51 +00:00
if ( ! empty ( ) ) {
const auto & track = back ( ) ;
height = track - > GetY ( ) + track - > GetHeight ( ) ;
2010-01-23 19:44:49 +00:00
}
2013-05-30 23:14:25 +00:00
# endif
2010-01-23 19:44:49 +00:00
return height ;
}
2016-03-01 23:31:51 +00:00
namespace {
// Abstract the common pattern of the following three member functions
double doubleMin ( double a , double b ) { return std : : min ( a , b ) ; }
double doubleMax ( double a , double b ) { return std : : max ( a , b ) ; }
inline double Accumulate
( const ListOfTracks & list ,
double ( Track : : * memfn ) ( ) const ,
double ( * combine ) ( double , double ) )
{
// Default the answer to zero for empty list
if ( list . empty ( ) ) {
return 0.0 ;
2010-01-23 19:44:49 +00:00
}
2016-03-01 23:31:51 +00:00
// Otherwise accumulate minimum or maximum of track values
auto iter = list . begin ( ) ;
double acc = ( * * iter + + . * memfn ) ( ) ;
return std : : accumulate ( iter , list . end ( ) , acc ,
[ = ] ( double acc , const ListOfTracks : : value_type & pTrack ) {
return combine ( acc , ( * pTrack . * memfn ) ( ) ) ;
} ) ;
2010-01-23 19:44:49 +00:00
}
2016-03-01 23:31:51 +00:00
}
2014-06-03 20:30:19 +00:00
2016-03-01 23:31:51 +00:00
double TrackList : : GetMinOffset ( ) const
{
return Accumulate ( * this , & Track : : GetOffset , doubleMin ) ;
2010-01-23 19:44:49 +00:00
}
double TrackList : : GetStartTime ( ) const
{
2016-03-01 23:31:51 +00:00
return Accumulate ( * this , & Track : : GetStartTime , doubleMin ) ;
2010-01-23 19:44:49 +00:00
}
double TrackList : : GetEndTime ( ) const
{
2016-03-01 23:31:51 +00:00
return Accumulate ( * this , & Track : : GetEndTime , doubleMax ) ;
2010-01-23 19:44:49 +00:00
}