anonymous_namespace{TimeShiftHandle.cpp} Namespace Reference

Classes
struct	TemporaryClipRemover

Typedefs
using	Correspondence = std::unordered_map< Track *, Track * >
using	DetachedIntervals = std::unordered_map< Track *, TrackShifter::Intervals >

Functions
SnapPointArray	FindCandidates (const TrackList &tracks, const ClipMoveState::ShifterMap &shifters)
double	FindDesiredSlideAmount (const ViewInfo &viewInfo, wxCoord xx, const wxMouseEvent &event, SnapManager *pSnapManager, bool slideUpDownOnly, bool snapPreferRightEdge, ClipMoveState &state, Track &track)
bool	FindCorrespondence (Correspondence &correspondence, TrackList &trackList, Track &capturedTrack, Track &track, ClipMoveState &state)
bool	CheckFit (ClipMoveState &state, const Correspondence &correspondence, const DetachedIntervals &intervals, double tolerance, double &desiredSlideAmount)
void	MigrationFailure ()

Typedef Documentation

Correspondence

using anonymous_namespace{TimeShiftHandle.cpp}::Correspondence = typedef std::unordered_map< Track*, Track* >

Definition at line 638 of file TimeShiftHandle.cpp.

DetachedIntervals

using anonymous_namespace{TimeShiftHandle.cpp}::DetachedIntervals = typedef std::unordered_map<Track*, TrackShifter::Intervals>

Definition at line 708 of file TimeShiftHandle.cpp.

Function Documentation

CheckFit()

bool anonymous_namespace{TimeShiftHandle.cpp}::CheckFit	(	ClipMoveState &	state,
		const Correspondence &	correspondence,
		const DetachedIntervals &	intervals,
		double	tolerance,
		double &	desiredSlideAmount
	)

Definition at line 711 of file TimeShiftHandle.cpp.

   {
      bool ok = true;
      double firstTolerance = tolerance;
      
      // The desiredSlideAmount may change and the tolerance may get used up.
      for ( unsigned iPass = 0; iPass < 2 && ok; ++iPass ) {
         for ( auto &pair : state.shifters ) {
            auto *pSrcTrack = pair.first;
            auto iter = correspondence.find( pSrcTrack );
            if ( iter != correspondence.end() )
               if( auto *pOtherTrack = iter->second )
                  if ( !(ok = pair.second->AdjustFit(
                     *pOtherTrack, intervals.at(pSrcTrack),
                     desiredSlideAmount /*in,out*/, tolerance)) )
                     break;
         }
 
         // If it fits ok, desiredSlideAmount could have been updated to get
         // the clip to fit.
         // Check again, in the new position, this time with zero tolerance.
         if (firstTolerance == 0)
            break;
         else
            tolerance = 0.0;
      }
 
      return ok;
   }

References ClipMoveState::shifters.

Referenced by TimeShiftHandle::DoSlideVertical().

Here is the caller graph for this function:

FindCandidates()

SnapPointArray anonymous_namespace{TimeShiftHandle.cpp}::FindCandidates	(	const TrackList &	tracks,
		const ClipMoveState::ShifterMap &	shifters
	)

Definition at line 475 of file TimeShiftHandle.cpp.

{
   // Compare with the other function FindCandidates in Snap
   // Make the snap manager more selective than it would be if just constructed
   // from the track list
   SnapPointArray candidates;
   for ( const auto &pair : shifters ) {
      auto &shifter = pair.second;
      auto &track = shifter->GetTrack();
      for (const auto &interval : shifter->FixedIntervals() ) {
         candidates.emplace_back( interval.Start(), &track );
         if ( interval.Start() != interval.End() )
            candidates.emplace_back( interval.End(), &track );
      }
   }
   return candidates;
}

Referenced by TimeShiftHandle::Click().

Here is the caller graph for this function:

FindCorrespondence()

bool anonymous_namespace{TimeShiftHandle.cpp}::FindCorrespondence	(	Correspondence &	correspondence,
		TrackList &	trackList,
		Track &	capturedTrack,
		Track &	track,
		ClipMoveState &	state
	)

Definition at line 640 of file TimeShiftHandle.cpp.

   {
      if (state.shifters.empty())
         // Shift + Dragging hasn't yet supported vertical movement
         return false;
 
      // Accumulate new pairs for the correspondence, and merge them
      // into the given correspondence only on success
      Correspondence newPairs;
 
      auto sameType = [&]( auto pTrack ){
         return capturedTrack.SameKindAs( *pTrack );
      };
      if (!sameType(&track))
         return false;
   
      // All tracks of the same kind as the captured track
      auto range = trackList.Any() + sameType;
 
      // Find how far this track would shift down among those (signed)
      const auto myPosition =
         std::distance( range.first, trackList.Find( &capturedTrack ) );
      const auto otherPosition =
         std::distance( range.first, trackList.Find( &track ) );
      auto diff = otherPosition - myPosition;
 
      // Point to destination track
      auto iter = range.first.advance( diff > 0 ? diff : 0 );
 
      for (auto pTrack : range) {
         auto &pShifter = state.shifters[pTrack];
         if ( !pShifter->MovingIntervals().empty() ) {
            // One of the interesting tracks
 
            auto pOther = *iter;
            if ( diff < 0 || !pOther )
               // No corresponding track
               return false;
 
            if ( !pShifter->MayMigrateTo(*pOther) )
               // Rejected for other reason
               return false;
 
            if ( correspondence.count(pTrack) )
               // Don't overwrite the given correspondence
               return false;
 
            newPairs[ pTrack ] = pOther;
         }
 
         if ( diff < 0 )
            ++diff; // Still consuming initial tracks
         else
            ++iter; // Safe to increment TrackIter even at end of range
      }
 
      // Success
      if (correspondence.empty())
         correspondence.swap(newPairs);
      else
         std::copy( newPairs.begin(), newPairs.end(),
            std::inserter( correspondence, correspondence.end() ) );
      return true;
   }

References TrackList::Any(), TrackList::Find(), Track::SameKindAs(), and ClipMoveState::shifters.

Referenced by TimeShiftHandle::DoSlideVertical().

Here is the call graph for this function:

Here is the caller graph for this function:

FindDesiredSlideAmount()

double anonymous_namespace{TimeShiftHandle.cpp}::FindDesiredSlideAmount	(	const ViewInfo &	viewInfo,
		wxCoord	xx,
		const wxMouseEvent &	event,
		SnapManager *	pSnapManager,
		bool	slideUpDownOnly,
		bool	snapPreferRightEdge,
		ClipMoveState &	state,
		Track &	track
	)

Definition at line 570 of file TimeShiftHandle.cpp.

   {
      auto &capturedTrack = *state.mCapturedTrack;
      if (slideUpDownOnly)
         return 0.0;
      else {
         double desiredSlideAmount =
            viewInfo.PositionToTime(event.m_x) -
            viewInfo.PositionToTime(state.mMouseClickX);
         double clipLeft = 0, clipRight = 0;
 
         if (!state.shifters.empty())
            desiredSlideAmount =
               state.shifters[ &track ]->QuantizeOffset( desiredSlideAmount );
 
         // Adjust desiredSlideAmount using SnapManager
         if (pSnapManager) {
            auto pInterval = state.CapturedInterval();
            if (pInterval) {
               clipLeft = pInterval->Start() + desiredSlideAmount;
               clipRight = pInterval->End() + desiredSlideAmount;
            }
            else {
               clipLeft = capturedTrack.GetStartTime() + desiredSlideAmount;
               clipRight = capturedTrack.GetEndTime() + desiredSlideAmount;
            }
 
            auto results =
               pSnapManager->Snap(&capturedTrack, clipLeft, false);
            auto newClipLeft = results.outTime;
            results =
               pSnapManager->Snap(&capturedTrack, clipRight, false);
            auto newClipRight = results.outTime;
 
            // Only one of them is allowed to snap
            if (newClipLeft != clipLeft && newClipRight != clipRight) {
               // Un-snap the un-preferred edge
               if (snapPreferRightEdge)
                  newClipLeft = clipLeft;
               else
                  newClipRight = clipRight;
            }
 
            // Take whichever one snapped (if any) and compute the NEW desiredSlideAmount
            state.snapLeft = -1;
            state.snapRight = -1;
            if (newClipLeft != clipLeft) {
               const double difference = (newClipLeft - clipLeft);
               desiredSlideAmount += difference;
               state.snapLeft =
                  viewInfo.TimeToPosition(newClipLeft, xx);
            }
            else if (newClipRight != clipRight) {
               const double difference = (newClipRight - clipRight);
               desiredSlideAmount += difference;
               state.snapRight =
                  viewInfo.TimeToPosition(newClipRight, xx);
            }
         }
         return desiredSlideAmount;
      }
   }

References ClipMoveState::CapturedInterval(), ClipMoveState::mCapturedTrack, ClipMoveState::mMouseClickX, SnapResults::outTime, ZoomInfo::PositionToTime(), ClipMoveState::shifters, SnapManager::Snap(), ClipMoveState::snapLeft, ClipMoveState::snapRight, ConstTrackInterval::Start(), and ZoomInfo::TimeToPosition().

Referenced by TimeShiftHandle::Drag().

Here is the call graph for this function:

Here is the caller graph for this function:

MigrationFailure()

void anonymous_namespace{TimeShiftHandle.cpp}::MigrationFailure

(

)

Definition at line 744 of file TimeShiftHandle.cpp.

                                        {
      // Tracks may be in an inconsistent state; throw to the application
      // handler which restores consistency from undo history
      throw SimpleMessageBoxException{ ExceptionType::Internal,
         XO("Could not shift between tracks")};
   }

References Internal, and XO().

Referenced by anonymous_namespace{TimeShiftHandle.cpp}::TemporaryClipRemover::Reinsert(), and TimeShiftHandle::Release().

Here is the call graph for this function:

Here is the caller graph for this function: