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 &)=delete
ClipMoveState &	operator= (const ClipMoveState &)=delete
	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 ChannelGroupInterval *	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 236 of file TimeShiftHandle.h.

Member Typedef Documentation

ShifterMap

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

Definition at line 245 of file TimeShiftHandle.h.

Constructor & Destructor Documentation

ClipMoveState() [1/3]

ClipMoveState::ClipMoveState ( )

default

ClipMoveState() [2/3]

ClipMoveState::ClipMoveState ( const ClipMoveState &  )

delete

ClipMoveState() [3/3]

ClipMoveState::ClipMoveState ( ClipMoveState &&  )

default

Member Function Documentation

CapturedInterval()

const ChannelGroupInterval * 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 379 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].get();
         }
      }
   }
   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 280 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 123 of file TimeShiftHandle.cpp.

{
   if (!shifters.empty()) {
      for (auto &pair : shifters)
         pair.second->DoHorizontalOffset(offset);
   }
   else if (mCapturedTrack)
      mCapturedTrack->ShiftBy(offset);
}

References mCapturedTrack, and shifters.

Referenced by TimeShiftHandle::Drag().

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 396 of file TimeShiftHandle.cpp.

{
   auto &state = *this;
 
   // 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 274 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) {
      auto &pShifter = state.shifters[track];
      if (!pShifter)
         pShifter = MakeTrackShifter::Call(*track, project);
   }
 
   if ( state.movingSelection ) {
      // All selected tracks may move some intervals
      const TrackShifter::TimeInterval 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 );
      }
   }
 
   // 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->Start(), interval->End() });
                  change = change ||
                     (shifter2.SyncLocks() &&
                      size != shifter2.MovingIntervals().size());
               }
 
            }
         }
 
         // ... and repeat if any other interval became unfixed in a
         // shifter that propagates
      }
   }
}

References AttachedVirtualFunction< Tag, Return, This, Arguments >::Call(), SyncLock::Group(), initialized, TrackShifter::Intervals, TrackShifter::Miss, project, 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 &  )

delete

Member Data Documentation

hSlideAmount

double ClipMoveState::hSlideAmount {}

Definition at line 274 of file TimeShiftHandle.h.

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

initialized

bool ClipMoveState::initialized { false }

Definition at line 271 of file TimeShiftHandle.h.

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

mCapturedTrack

std::shared_ptr<Track> ClipMoveState::mCapturedTrack

Definition at line 269 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 278 of file TimeShiftHandle.h.

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

movingSelection

bool ClipMoveState::movingSelection {}

Definition at line 272 of file TimeShiftHandle.h.

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

shifters

ShifterMap ClipMoveState::shifters

Definition at line 275 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 276 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 276 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 273 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