LabelTrackShifter Class Reference

Inheritance diagram for LabelTrackShifter:

Collaboration diagram for LabelTrackShifter:

Classes
struct	IntervalData

Public Member Functions
	LabelTrackShifter (LabelTrack &track, AudacityProject &project)
	~LabelTrackShifter () override
Track &	GetTrack () const override
	There is always an associated track. More...
HitTestResult	HitTest (double time, const ViewInfo &viewInfo, HitTestParams *pParams) override
	Decide how shift behaves, based on the track that is clicked in. More...
void	SelectInterval (const TrackInterval &interval) override
	Notifies the shifter that a region is selected, so it may update its fixed and moving intervals. More...
bool	SyncLocks () override
	Whether unfixing of an interval should propagate to all overlapping intervals in the sync lock group. More...
bool	MayMigrateTo (Track &otherTrack) override
	Whether intervals may migrate to the other track, not yet checking all placement constraints *‍/. More...
Intervals	Detach () override
	Remove all moving intervals from the track, if possible. More...
bool	AdjustFit (const Track &, const Intervals &, double &, double) override
	Test whether intervals can fit into another track, maybe adjusting the offset slightly. More...
bool	Attach (Intervals intervals) override
	Put moving intervals into the track, which may have migrated from another. More...
void	DoHorizontalOffset (double offset) override
Public Member Functions inherited from TrackShifter
	TrackShifter ()
	TrackShifter (const TrackShifter &) PROHIBITED
TrackShifter &	operator= (const TrackShifter &) PROHIBITED
virtual	~TrackShifter ()=0
virtual Track &	GetTrack () const =0
	There is always an associated track. More...
virtual HitTestResult	HitTest (double time, const ViewInfo &viewInfo, HitTestParams *pParams=nullptr)=0
	Decide how shift behaves, based on the track that is clicked in. More...
const Intervals &	FixedIntervals () const
	Return special intervals of the track that will not move. More...
const Intervals &	MovingIntervals () const
	Return special intervals of the track that may move. More...
void	UnfixIntervals (std::function< bool(const TrackInterval &) > pred)
	Change intervals satisfying a predicate from fixed to moving. More...
void	UnfixAll ()
	Change all intervals from fixed to moving. More...
virtual void	SelectInterval (const TrackInterval &interval)
	Notifies the shifter that a region is selected, so it may update its fixed and moving intervals. More...
virtual bool	SyncLocks ()=0
	Whether unfixing of an interval should propagate to all overlapping intervals in the sync lock group. More...
virtual double	HintOffsetLarger (double desiredOffset)
	Given amount to shift by horizontally, maybe adjust it from zero to suggest minimum distance. More...
virtual double	QuantizeOffset (double desiredOffset)
	Given amount to shift by horizontally, do any preferred rounding, before placement constraint checks. More...
virtual double	AdjustOffsetSmaller (double desiredOffset)
	Given amount to shift by horizontally, maybe adjust it toward zero to meet placement constraints. More...
virtual bool	MayMigrateTo (Track &otherTrack)
	Whether intervals may migrate to the other track, not yet checking all placement constraints *‍/. More...
virtual Intervals	Detach ()
	Remove all moving intervals from the track, if possible. More...
virtual bool	AdjustFit (const Track &otherTrack, const Intervals &intervals, double &desiredOffset, double tolerance)
	Test whether intervals can fit into another track, maybe adjusting the offset slightly. More...
virtual bool	Attach (Intervals intervals)
	Put moving intervals into the track, which may have migrated from another. More...
virtual bool	FinishMigration ()
	When dragging is done, do (once) the final steps of migration (which may be expensive) More...
virtual void	DoHorizontalOffset (double offset)
virtual double	AdjustT0 (double t0) const

Static Public Member Functions
static size_t &	GetIndex (TrackInterval &interval)
static size_t	GetIndex (const TrackInterval &interval)

Private Member Functions
void	OnLabelPermuted (const LabelTrackEvent &e)
void	OnLabelAdded (const LabelTrackEvent &e)
void	OnLabelDeleted (const LabelTrackEvent e)

Private Attributes
Observer::Subscription	mSubscription
std::shared_ptr< LabelTrack >	mpTrack
AudacityProject &	mProject

Additional Inherited Members
Public Types inherited from TrackShifter
enum class	HitTestResult { Miss , Selection , Intervals , Track }
	Possibilities for HitTest on the clicked track. More...
using	Intervals = std::vector< TrackInterval >
Protected Member Functions inherited from TrackShifter
void	CommonSelectInterval (const TrackInterval &interval)
bool	CommonMayMigrateTo (Track &otherTrack)
void	InitIntervals ()
	Derived class constructor can initialize all intervals reported by the track as fixed, none moving. More...
bool	AllFixed () const
Protected Attributes inherited from TrackShifter
Intervals	mFixed
Intervals	mMoving

Detailed Description

Definition at line 11 of file LabelTrackShifter.cpp.

Constructor & Destructor Documentation

LabelTrackShifter()

LabelTrackShifter::LabelTrackShifter ( LabelTrack &  track, AudacityProject &  project  )

inline

Definition at line 13 of file LabelTrackShifter.cpp.

      : mpTrack{ track.SharedPointer<LabelTrack>() }
      , mProject{ project }
   {
      InitIntervals();
      mSubscription = mpTrack->Subscribe([this](const LabelTrackEvent &e){
         switch (e.type) {
         case LabelTrackEvent::Permutation:
            return OnLabelPermuted(e);
         case LabelTrackEvent::Addition:
            return OnLabelAdded(e);
         case LabelTrackEvent::Deletion:
            return OnLabelDeleted(e);
         default:
            return;
         }
      });
   }

References TrackShifter::InitIntervals(), mpTrack, mSubscription, and LabelTrackEvent::type.

Here is the call graph for this function:

~LabelTrackShifter()

LabelTrackShifter::~LabelTrackShifter ( )

inlineoverride

Definition at line 31 of file LabelTrackShifter.cpp.

   {
   }

Member Function Documentation

AdjustFit()

bool LabelTrackShifter::AdjustFit ( const Track &  otherTrack, const Intervals &  intervals, double &  desiredOffset, double  tolerance  )

inlineoverridevirtual

Test whether intervals can fit into another track, maybe adjusting the offset slightly.

Default implementation does nothing and returns false

Parameters

	intervals	Assume these came from Detach() and only after MayMigrateTo returned true for otherTrack
[in,out]	desiredOffset
	tolerance	Nonnegative ceiling for allowed changes in fabs(desiredOffset)

Reimplemented from TrackShifter.

Definition at line 130 of file LabelTrackShifter.cpp.

   {
      // Labels have no overlapping constraints, so just...
      return true;
   }

Attach()

bool LabelTrackShifter::Attach ( Intervals  intervals )

inlineoverridevirtual

Put moving intervals into the track, which may have migrated from another.

Returns

success

In case of failure, track states are unspecified

Default implementation does nothing and returns true

Reimplemented from TrackShifter.

Definition at line 137 of file LabelTrackShifter.cpp.

   {
      auto pTrack = mpTrack.get();
      std::for_each( intervals.rbegin(), intervals.rend(),
         [this, pTrack](auto &interval){
            auto pData = static_cast<IntervalData*>( interval.Extra() );
            auto index = pTrack->AddLabel(pData->region, pData->title);
            // Recreate the simpler TrackInterval as would be reported by LabelTrack
            mMoving.emplace_back( pTrack->MakeInterval(index) );
         } );
      return true;
   }

References mpTrack.

Detach()

Intervals LabelTrackShifter::Detach ( )

inlineoverridevirtual

Remove all moving intervals from the track, if possible.

Default implementation does nothing

Reimplemented from TrackShifter.

Definition at line 108 of file LabelTrackShifter.cpp.

   {
      auto pTrack = mpTrack.get();
      auto moveLabel = [pTrack](TrackInterval &interval) -> TrackInterval {
         auto &rindex = GetIndex(interval);
         auto index = rindex;
         rindex = -1;
         auto result = TrackInterval{
            interval.Start(), interval.End(),
            std::make_unique<IntervalData>( *pTrack->GetLabel(index) ) };
         pTrack->DeleteLabel(index);
         return result;
      };
      Intervals result;
      std::transform(
         // Reverse traversal may lessen the shifting-left in the label array
         mMoving.rbegin(), mMoving.rend(), std::back_inserter(result),
         moveLabel );
      mMoving = Intervals{};
      return result;
   }

References GetIndex(), TrackShifter::mMoving, mpTrack, and ConstTrackInterval::Start().

Here is the call graph for this function:

DoHorizontalOffset()

void LabelTrackShifter::DoHorizontalOffset ( double  offset )

inlineoverridevirtual

Shift all moving intervals horizontally Default moves the whole track, provided !AllFixed(); else does nothing

Reimplemented from TrackShifter.

Definition at line 150 of file LabelTrackShifter.cpp.

   {
      auto &labels = mpTrack->GetLabels();
      for ( auto &interval : MovingIntervals() ) {
         auto index = GetIndex( interval );
         auto labelStruct = labels[index];
         labelStruct.selectedRegion.move(offset);
         mpTrack->SetLabel( index, labelStruct );
      }
 
      mpTrack->SortLabels(); // causes callback to OnLabelPermuted
   }

References GetIndex(), TrackShifter::MovingIntervals(), and mpTrack.

Here is the call graph for this function:

GetIndex() [1/2]

static size_t LabelTrackShifter::GetIndex ( const TrackInterval &  interval )

inlinestatic

Definition at line 43 of file LabelTrackShifter.cpp.

   {
      return GetIndex( const_cast<TrackInterval&>(interval) );
   }

References GetIndex().

Here is the call graph for this function:

GetIndex() [2/2]

static size_t & LabelTrackShifter::GetIndex ( TrackInterval &  interval )

inlinestatic

Definition at line 36 of file LabelTrackShifter.cpp.

   {
      auto pExtra =
         static_cast<LabelTrack::IntervalData*>( interval.Extra() );
      return pExtra->index;
   }

References TrackInterval::Extra(), and LabelTrack::IntervalData::index.

Referenced by Detach(), DoHorizontalOffset(), GetIndex(), HitTest(), and OnLabelPermuted().

Here is the call graph for this function:

Here is the caller graph for this function:

GetTrack()

Track & LabelTrackShifter::GetTrack ( ) const

inlineoverridevirtual

There is always an associated track.

Implements TrackShifter.

Definition at line 34 of file LabelTrackShifter.cpp.

{ return *mpTrack; }

References mpTrack.

HitTest()

HitTestResult LabelTrackShifter::HitTest ( double  time, const ViewInfo &  viewInfo, HitTestParams *  pParams  )

inlineoverridevirtual

Decide how shift behaves, based on the track that is clicked in.

If the return value is Intervals or Selection, then some intervals may be marked moving as a side effect

Precondition

!pParams || (time == pParams->viewInfo.PositionToTime(pParams->xx, pParams->rect.x))

Parameters

time	A time value to test
pParams	Optional extra information

Implements TrackShifter.

Definition at line 48 of file LabelTrackShifter.cpp.

   {
      HitTestResult result = HitTestResult::Intervals;
      auto t0 = viewInfo.selectedRegion.t0();
      auto t1 = viewInfo.selectedRegion.t1();
      if ( mpTrack->IsSelected() && time >= t0 && time < t1 )
         result = HitTestResult::Selection;
 
      // Prefer the box that the mouse hovers over, else the selected one
      int iLabel = -1;
      if ( pParams )
         iLabel =
            LabelTrackView::OverATextBox(*mpTrack, pParams->xx, pParams->yy);
      if (iLabel == -1)
         iLabel = LabelTrackView::Get(*mpTrack).GetNavigationIndex(mProject);
      if (iLabel != -1) {
         UnfixIntervals([&](const auto &myInterval){
            return GetIndex( myInterval ) == iLabel;
         });
         return result;
      }
      else {
         // If the pick is within the selection, which overlaps some intervals,
         // then move those intervals only
         // Else move all labels (preserving the older beahvior of time shift)
         if ( result == HitTestResult::Selection )
            SelectInterval({ t0, t1 });
         if (mMoving.empty())
            return HitTestResult::Track;
         else
            return result;
      }
   }

References LabelTrackView::Get(), GetIndex(), LabelTrackView::GetNavigationIndex(), TrackShifter::Intervals, TrackShifter::mMoving, mProject, mpTrack, LabelTrackView::OverATextBox(), ViewInfo::selectedRegion, SelectInterval(), TrackShifter::Selection, NotifyingSelectedRegion::t0(), NotifyingSelectedRegion::t1(), TrackShifter::Track, TrackShifter::UnfixIntervals(), TrackShifter::HitTestParams::xx, and TrackShifter::HitTestParams::yy.

Here is the call graph for this function:

MayMigrateTo()

bool LabelTrackShifter::MayMigrateTo ( Track &  otherTrack )

inlineoverridevirtual

Whether intervals may migrate to the other track, not yet checking all placement constraints *‍/.

Default implementation returns false

Reimplemented from TrackShifter.

Definition at line 90 of file LabelTrackShifter.cpp.

   {
      return CommonMayMigrateTo(otherTrack);
   }

References TrackShifter::CommonMayMigrateTo().

Here is the call graph for this function:

OnLabelAdded()

void LabelTrackShifter::OnLabelAdded ( const LabelTrackEvent &  e )

inlineprivate

Definition at line 192 of file LabelTrackShifter.cpp.

   {
      if ( e.mpTrack.lock() != mpTrack )
         return;
 
      auto present = e.mPresentPosition;
 
      // Avoid signed-unsigned comparison below!
      if (present < 0) {
         wxASSERT(false);
         return;
      }
 
      auto update = [=]( TrackInterval &interval ){
         auto pExtra = static_cast<LabelTrack::IntervalData*>(interval.Extra());
         auto &index = pExtra->index;
         if ( index >= present )
            ++ index;
      };
 
      std::for_each(mFixed.begin(), mFixed.end(), update);
      std::for_each(mMoving.begin(), mMoving.end(), update);
   }

References LabelTrack::IntervalData::index, TrackShifter::mFixed, TrackShifter::mMoving, LabelTrackEvent::mPresentPosition, LabelTrackEvent::mpTrack, and mpTrack.

OnLabelDeleted()

void LabelTrackShifter::OnLabelDeleted ( const LabelTrackEvent  e )

inlineprivate

Definition at line 216 of file LabelTrackShifter.cpp.

   {
      if ( e.mpTrack.lock() != mpTrack )
         return;
 
      auto former = e.mFormerPosition;
 
      // Avoid signed-unsigned comparison below!
      if (former < 0) {
         wxASSERT(false);
         return;
      }
 
      auto update = [=]( TrackInterval &interval ){
         auto pExtra = static_cast<LabelTrack::IntervalData*>(interval.Extra());
         auto &index = pExtra->index;
         if ( index > former )
            -- index;
         else if ( index == former )
            // It should have been deleted first!
            wxASSERT( false );
      };
 
      std::for_each(mFixed.begin(), mFixed.end(), update);
      std::for_each(mMoving.begin(), mMoving.end(), update);
   }

References LabelTrack::IntervalData::index, TrackShifter::mFixed, LabelTrackEvent::mFormerPosition, TrackShifter::mMoving, LabelTrackEvent::mpTrack, and mpTrack.

OnLabelPermuted()

void LabelTrackShifter::OnLabelPermuted ( const LabelTrackEvent &  e )

inlineprivate

Definition at line 164 of file LabelTrackShifter.cpp.

   {
      if ( e.mpTrack.lock() != mpTrack )
         return;
 
      auto former = e.mFormerPosition;
      auto present = e.mPresentPosition;
 
      // Avoid signed-unsigned comparison below!
      if (former < 0 || present < 0) {
         wxASSERT(false);
         return;
      }
 
      auto update = [=]( TrackInterval &interval ){
         auto &index = GetIndex( interval );
         if ( index == former )
            index = present;
         else if ( former < index && index <= present )
            -- index;
         else if ( former > index && index >= present )
            ++ index;
      };
 
      std::for_each(mFixed.begin(), mFixed.end(), update);
      std::for_each(mMoving.begin(), mMoving.end(), update);
   }

References GetIndex(), TrackShifter::mFixed, LabelTrackEvent::mFormerPosition, TrackShifter::mMoving, LabelTrackEvent::mPresentPosition, LabelTrackEvent::mpTrack, and mpTrack.

Here is the call graph for this function:

SelectInterval()

void LabelTrackShifter::SelectInterval ( const TrackInterval &  interval )

inlineoverridevirtual

Notifies the shifter that a region is selected, so it may update its fixed and moving intervals.

Default behavior: if any part of the track is selected, unfix all parts of it.

Reimplemented from TrackShifter.

Definition at line 83 of file LabelTrackShifter.cpp.

   {
      CommonSelectInterval(interval);
   }

References TrackShifter::CommonSelectInterval().

Referenced by HitTest().

Here is the call graph for this function:

Here is the caller graph for this function:

SyncLocks()

bool LabelTrackShifter::SyncLocks ( )

inlineoverridevirtual

Whether unfixing of an interval should propagate to all overlapping intervals in the sync lock group.

Implements TrackShifter.

Definition at line 88 of file LabelTrackShifter.cpp.

{ return false; }

Member Data Documentation

mProject

AudacityProject& LabelTrackShifter::mProject

private

Definition at line 245 of file LabelTrackShifter.cpp.

Referenced by HitTest().

mpTrack

std::shared_ptr<LabelTrack> LabelTrackShifter::mpTrack

private

Definition at line 244 of file LabelTrackShifter.cpp.

Referenced by Attach(), Detach(), DoHorizontalOffset(), GetTrack(), HitTest(), LabelTrackShifter(), OnLabelAdded(), OnLabelDeleted(), and OnLabelPermuted().

mSubscription

Observer::Subscription LabelTrackShifter::mSubscription

private

Definition at line 243 of file LabelTrackShifter.cpp.

Referenced by LabelTrackShifter().

---

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

• LabelTrackShifter.cpp