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)
void	AdjustToSnap (const ViewInfo &viewInfo, wxCoord xx, SnapManager *pSnapManager, bool snapPreferRightEdge, ClipMoveState &state, double &desiredSlideAmount)
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 595 of file TimeShiftHandle.cpp.

DetachedIntervals

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

Definition at line 668 of file TimeShiftHandle.cpp.

Function Documentation

AdjustToSnap()

void anonymous_namespace{TimeShiftHandle.cpp}::AdjustToSnap	(	const ViewInfo &	viewInfo,
		wxCoord	xx,
		SnapManager *	pSnapManager,
		bool	snapPreferRightEdge,
		ClipMoveState &	state,
		double &	desiredSlideAmount
	)

Definition at line 539 of file TimeShiftHandle.cpp.

   {
      auto track = state.mCapturedTrack.get();
      double clipLeft, clipRight;
 
      // Adjust desiredSlideAmount using SnapManager
      if (pSnapManager) {
         auto pInterval = state.CapturedInterval();
         if (pInterval) {
            clipLeft = pInterval->Start() + desiredSlideAmount;
            clipRight = pInterval->End() + desiredSlideAmount;
         }
         else {
            clipLeft = track->GetStartTime() + desiredSlideAmount;
            clipRight = track->GetEndTime() + desiredSlideAmount;
         }
 
         auto results =
            pSnapManager->Snap(track, clipLeft, false);
         auto newClipLeft = results.outTime;
         results =
            pSnapManager->Snap(track, 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);
         }
      }
   }

References ClipMoveState::CapturedInterval(), ClipMoveState::mCapturedTrack, SnapResults::outTime, SnapManager::Snap(), ClipMoveState::snapLeft, ClipMoveState::snapRight, ChannelGroupInterval::Start(), and ZoomInfo::TimeToPosition().

Referenced by TimeShiftHandle::Drag().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckFit()

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

Definition at line 671 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 446 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 597 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 for first of range, when diff >= 0
      // Otherwise the loop below iterates -diff times checking that initial
      // members of the range are not the shifting tracks
      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;
 
            assert(pOther->IsLeader()); // by construction of range
            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
         copy(newPairs.begin(), newPairs.end(),
            inserter(correspondence, correspondence.end()));
      return true;
   }

References TrackList::Any(), staffpad::vo::copy(), 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:

MigrationFailure()

void anonymous_namespace{TimeShiftHandle.cpp}::MigrationFailure

(

)

Definition at line 704 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: