ClipMoveState Struct Reference

#include <TimeShiftHandle.h>

Collaboration diagram for ClipMoveState:

Public Types
using	ShifterMap = std::unordered_map< Track *, std::unique_ptr< TrackShifter > >

Public Member Functions
	ClipMoveState ()=default
	ClipMoveState (const ClipMoveState &) PROHIBITED
ClipMoveState &	operator= (const ClipMoveState &) PROHIBITED
	ClipMoveState (ClipMoveState &&)=default
ClipMoveState &	operator= (ClipMoveState &&)=default
void	Init (AudacityProject &project, Track &capturedTrack, TrackShifter::HitTestResult hitTestResult, std::unique_ptr< TrackShifter > pHit, double clickTime, const ViewInfo &viewInfo, TrackList &trackList, bool syncLocked)
	Will associate a TrackShifter with each track in the list. More...
const TrackInterval *	CapturedInterval () const
	Return pointer to the first fixed interval of the captured track, if there is one. More...
double	DoSlideHorizontal (double desiredSlideAmount)
	Do sliding of tracks and intervals, maybe adjusting the offset. More...
void	DoHorizontalOffset (double offset)
	Offset tracks or intervals horizontally, without adjusting the offset. More...
void	clear ()

Public Attributes
std::shared_ptr< Track >	mCapturedTrack
bool	initialized { false }
bool	movingSelection {}
bool	wasMoved { false }
double	hSlideAmount {}
ShifterMap	shifters
wxInt64	snapLeft { -1 }
wxInt64	snapRight { -1 }
int	mMouseClickX {}

Detailed Description

Definition at line 205 of file TimeShiftHandle.h.

Member Typedef Documentation

ShifterMap

using ClipMoveState::ShifterMap = std::unordered_map<Track*, std::unique_ptr<TrackShifter> >

Definition at line 214 of file TimeShiftHandle.h.

Constructor & Destructor Documentation

ClipMoveState() [1/3]

ClipMoveState::ClipMoveState ( )

default

ClipMoveState() [2/3]

ClipMoveState::ClipMoveState

(

const ClipMoveState &

)

ClipMoveState() [3/3]

ClipMoveState::ClipMoveState ( ClipMoveState &&  )

default

Member Function Documentation

CapturedInterval()

const TrackInterval * ClipMoveState::CapturedInterval

(

)

const

Return pointer to the first fixed interval of the captured track, if there is one.

Pointer may be invalidated by operations on the associated TrackShifter

Definition at line 416 of file TimeShiftHandle.cpp.

{
   auto pTrack = mCapturedTrack.get();
   if ( pTrack ) {
      auto iter = shifters.find( pTrack );
      if ( iter != shifters.end() ) {
         auto &pShifter = iter->second;
         if ( pShifter ) {
            auto &intervals = pShifter->MovingIntervals();
            if ( !intervals.empty() )
               return &intervals[0];
         }
      }
   }
   return nullptr;
}

References mCapturedTrack, and shifters.

Referenced by anonymous_namespace{TimeShiftHandle.cpp}::AdjustToSnap(), and TimeShiftHandle::Click().

Here is the caller graph for this function:

clear()

void ClipMoveState::clear ( )

inline

Definition at line 249 of file TimeShiftHandle.h.

   {
      initialized = false;
      wasMoved = false;
      movingSelection = false;
      hSlideAmount = 0;
      shifters.clear();
      snapLeft = snapRight = -1;
      mMouseClickX = 0;
   }

Referenced by TimeShiftHandle::Click().

Here is the caller graph for this function:

DoHorizontalOffset()

void ClipMoveState::DoHorizontalOffset

(

double

offset

)

Offset tracks or intervals horizontally, without adjusting the offset.

Definition at line 118 of file TimeShiftHandle.cpp.

{
   if ( !shifters.empty() ) {
      for ( auto &pair : shifters )
         pair.second->DoHorizontalOffset( offset );
   }
   else {
      for (auto channel : TrackList::Channels( mCapturedTrack.get() ))
         channel->Offset( offset );
   }
}

References TrackList::Channels(), mCapturedTrack, and shifters.

Referenced by TimeShiftHandle::Drag().

Here is the call graph for this function:

Here is the caller graph for this function:

DoSlideHorizontal()

double ClipMoveState::DoSlideHorizontal

(

double

desiredSlideAmount

)

Do sliding of tracks and intervals, maybe adjusting the offset.

Returns

actual slide amount, maybe adjusted toward zero from desired

Definition at line 433 of file TimeShiftHandle.cpp.

{
   auto &state = *this;
   auto &capturedTrack = *state.mCapturedTrack;
 
   // Given a signed slide distance, move clips, but subject to constraint of
   // non-overlapping with other clips, so the distance may be adjusted toward
   // zero.
   if ( !state.shifters.empty() ) {
      double initialAllowed = 0;
      do { // loop to compute allowed, does not actually move anything yet
         initialAllowed = desiredSlideAmount;
 
         for (auto &pair : shifters) {
            auto newAmount = pair.second->AdjustOffsetSmaller( desiredSlideAmount );
            if ( desiredSlideAmount != newAmount ) {
               if ( newAmount * desiredSlideAmount < 0 ||
                    fabs(newAmount) > fabs(desiredSlideAmount) ) {
                  wxASSERT( false ); // AdjustOffsetSmaller didn't honor postcondition!
                  newAmount = 0; // Be sure the loop progresses to termination!
               }
               desiredSlideAmount = newAmount;
               state.snapLeft = state.snapRight = -1; // see bug 1067
            }
            if (newAmount == 0)
               break;
         }
      } while ( desiredSlideAmount != initialAllowed );
   }
 
   // Whether moving intervals or a whole track,
   // finally, here is where clips are moved
   if ( desiredSlideAmount != 0.0 )
      state.DoHorizontalOffset( desiredSlideAmount );
 
   //attempt to move a clip is counted to
   wasMoved = true;
 
   return (state.hSlideAmount = desiredSlideAmount);
}

References shifters, and wasMoved.

Referenced by anonymous_namespace{ClipMenus.cpp}::DoClipMove(), and TimeShiftHandle::Drag().

Here is the caller graph for this function:

Init()

void ClipMoveState::Init	(	AudacityProject &	project,
		Track &	capturedTrack,
		TrackShifter::HitTestResult	hitTestResult,
		std::unique_ptr< TrackShifter >	pHit,
		double	clickTime,
		const ViewInfo &	viewInfo,
		TrackList &	trackList,
		bool	syncLocked
	)

Will associate a TrackShifter with each track in the list.

Parameters

hitTestResult	must not be `Miss`
pHit	If null, implies `Track`, overriding previous argument

Definition at line 282 of file TimeShiftHandle.cpp.

{
   shifters.clear();
 
   initialized = true;
 
   auto &state = *this;
   state.mCapturedTrack = capturedTrack.SharedPointer();
 
   switch (hitTestResult) {
      case TrackShifter::HitTestResult::Miss:
         wxASSERT(false);
         pHit.reset();
         break;
      case TrackShifter::HitTestResult::Track:
         pHit.reset();
         break;
      case TrackShifter::HitTestResult::Intervals:
         break;
      case TrackShifter::HitTestResult::Selection:
         state.movingSelection = true;
         break;
      default:
         break;
   }
 
   if (!pHit)
      return;
 
   state.shifters[&capturedTrack] = std::move( pHit );
 
   // Collect TrackShifters for the rest of the tracks
   for ( auto track : trackList.Any() ) {
      auto &pShifter = state.shifters[track];
      if (!pShifter)
         pShifter = MakeTrackShifter::Call( *track, project );
   }
 
   if ( state.movingSelection ) {
      // All selected tracks may move some intervals
      const TrackInterval interval{
         viewInfo.selectedRegion.t0(),
         viewInfo.selectedRegion.t1()
      };
      for ( const auto &pair : state.shifters ) {
         auto &shifter = *pair.second;
         auto &track = shifter.GetTrack();
         if (&track == &capturedTrack)
            // Don't change the choice of intervals made by HitTest
            continue;
         if ( track.IsSelected() )
            shifter.SelectInterval( interval );
      }
   }
   else {
      // Move intervals only of the chosen channel group      
 
      auto selectIntervals = [&](const TrackShifter::Intervals& intervals) {
         for (auto channel : TrackList::Channels(&capturedTrack)) {
            auto& shifter = *state.shifters[channel];
            if (channel != &capturedTrack)
            {
               for (auto& interval : intervals)
               {
                  shifter.SelectInterval(interval);
               }
            }
         }
      };
      if (capturedTrack.GetLinkType() == Track::LinkType::Aligned || 
         capturedTrack.IsAlignedWithLeader())
         //for aligned tracks we always match the whole clip that was
         //positively hit tested
         selectIntervals(state.shifters[&capturedTrack]->MovingIntervals());
      else
      {
         TrackShifter::Intervals intervals;
         intervals.emplace_back(TrackInterval { clickTime, clickTime });
         //for not align, match clips from other channels that are 
         //exactly at clicked time point
         selectIntervals(intervals);
      }
   }
   
   // Sync lock propagation of unfixing of intervals
   if ( syncLocked ) {
      bool change = true;
      while( change ) {
         change = false;
 
         // Iterate over all unfixed intervals in all tracks
         // that do propagation and are in sync lock groups ...
         for ( auto &pair : state.shifters ) {
            auto &shifter = *pair.second.get();
            if (!shifter.SyncLocks())
               continue;
            auto &track = shifter.GetTrack();
            auto group = SyncLock::Group(&track);
            if ( group.size() <= 1 )
               continue;
 
            auto &intervals = shifter.MovingIntervals();
            for (auto &interval : intervals) {
 
               // ...and tell all other tracks in the sync lock group
               // to select that interval...
               for ( auto pTrack2 : group ) {
                  if (pTrack2 == &track)
                     continue;
                  
                  auto &shifter2 = *shifters[pTrack2];
                  auto size = shifter2.MovingIntervals().size();
                  shifter2.SelectInterval( interval );
                  change = change ||
                     (shifter2.SyncLocks() &&
                      size != shifter2.MovingIntervals().size());
               }
 
            }
         }
 
         // ... and repeat if any other interval became unfixed in a
         // shifter that propagates
      }
   }
}

References Track::Aligned, TrackList::Any(), AttachedVirtualFunction< Tag, Return, This, Arguments >::Call(), TrackList::Channels(), Track::GetLinkType(), SyncLock::Group(), initialized, TrackShifter::Intervals, Track::IsAlignedWithLeader(), TrackShifter::Miss, ViewInfo::selectedRegion, TrackShifter::Selection, Track::SharedPointer(), shifters, size, NotifyingSelectedRegion::t0(), NotifyingSelectedRegion::t1(), and TrackShifter::Track.

Referenced by TimeShiftHandle::Click(), and anonymous_namespace{ClipMenus.cpp}::DoClipMove().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

ClipMoveState & ClipMoveState::operator= ( ClipMoveState &&  )

default

operator=() [2/2]

ClipMoveState & ClipMoveState::operator=

(

const ClipMoveState &

)

Member Data Documentation

hSlideAmount

double ClipMoveState::hSlideAmount {}

Definition at line 243 of file TimeShiftHandle.h.

Referenced by TimeShiftHandle::Drag(), and TimeShiftHandle::Release().

initialized

bool ClipMoveState::initialized { false }

Definition at line 240 of file TimeShiftHandle.h.

Referenced by TimeShiftHandle::Cancel(), TimeShiftHandle::Clicked(), Init(), and TimeShiftHandle::WasMoved().

mCapturedTrack

std::shared_ptr<Track> ClipMoveState::mCapturedTrack

Definition at line 238 of file TimeShiftHandle.h.

Referenced by anonymous_namespace{TimeShiftHandle.cpp}::AdjustToSnap(), CapturedInterval(), DoHorizontalOffset(), TimeShiftHandle::DoSlideVertical(), TimeShiftHandle::Drag(), TimeShiftHandle::GetTrack(), and TimeShiftHandle::TimeShiftHandle().

mMouseClickX

int ClipMoveState::mMouseClickX {}

Definition at line 247 of file TimeShiftHandle.h.

Referenced by TimeShiftHandle::Click(), TimeShiftHandle::DoSlideVertical(), and TimeShiftHandle::Drag().

movingSelection

bool ClipMoveState::movingSelection {}

Definition at line 241 of file TimeShiftHandle.h.

Referenced by TimeShiftHandle::DoSlideVertical(), and TimeShiftHandle::Drag().

shifters

ShifterMap ClipMoveState::shifters

Definition at line 244 of file TimeShiftHandle.h.

Referenced by CapturedInterval(), anonymous_namespace{TimeShiftHandle.cpp}::CheckFit(), TimeShiftHandle::Click(), DoHorizontalOffset(), DoSlideHorizontal(), TimeShiftHandle::DoSlideVertical(), TimeShiftHandle::Drag(), anonymous_namespace{TimeShiftHandle.cpp}::FindCorrespondence(), Init(), and TimeShiftHandle::Release().

snapLeft

wxInt64 ClipMoveState::snapLeft { -1 }

Definition at line 245 of file TimeShiftHandle.h.

Referenced by anonymous_namespace{TimeShiftHandle.cpp}::AdjustToSnap(), TimeShiftHandle::Click(), TimeShiftHandle::Draw(), and TimeShiftHandle::Release().

snapRight

wxInt64 ClipMoveState::snapRight { -1 }

Definition at line 245 of file TimeShiftHandle.h.

Referenced by anonymous_namespace{TimeShiftHandle.cpp}::AdjustToSnap(), TimeShiftHandle::Click(), TimeShiftHandle::Draw(), and TimeShiftHandle::Release().

wasMoved

bool ClipMoveState::wasMoved { false }

Definition at line 242 of file TimeShiftHandle.h.

Referenced by DoSlideHorizontal(), and TimeShiftHandle::WasMoved().

---

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

• TimeShiftHandle.h
• TimeShiftHandle.cpp