#include <Snap.h>

Collaboration diagram for SnapManager:

Public Member Functions
	SnapManager (const AudacityProject &project, SnapPointArray candidates, const ZoomInfo &zoomInfo, bool noTimeSnap=false, int pixelTolerance=kPixelTolerance)
	Construct only for specified candidate points. More...

	SnapManager (const AudacityProject &project, const TrackList &tracks, const ZoomInfo &zoomInfo, SnapPointArray candidates={}, bool noTimeSnap=false, int pixelTolerance=kPixelTolerance)

	~SnapManager ()

SnapResults	Snap (Track *currentTrack, double t, bool rightEdge)

Static Public Member Functions
static void	Draw (wxDC *dc, wxInt64 snap0, wxInt64 snap1)

Private Member Functions
void	Reinit ()

void	CondListAdd (double t, const Track *track)

double	Get (size_t index)

wxInt64	PixelDiff (double t, size_t index)

size_t	Find (double t, size_t i0, size_t i1)

size_t	Find (double t)

bool	SnapToPoints (Track currentTrack, double t, bool rightEdge, double outT)

Private Attributes
const AudacityProject *	mProject

const ZoomInfo *	mZoomInfo

int	mPixelTolerance

bool	mNoTimeSnap

double	mEpsilon { 1 / 44100.0 }
	Two time points closer than this are considered the same. More...

SnapPointArray	mCandidates

SnapPointArray	mSnapPoints

bool	mSnapToTime { false }

Identifier	mSnapTo {}

double	mRate { 0.0 }

NumericFormatSymbol	mFormat {}

Detailed Description

Definition at line 55 of file Snap.h.

Constructor & Destructor Documentation

◆ SnapManager() [1/2]

SnapManager::SnapManager	(	const AudacityProject &	project,
		SnapPointArray	candidates,
		const ZoomInfo &	zoomInfo,
		bool	noTimeSnap = `false`,
		int	pixelTolerance = `kPixelTolerance`
	)

Construct only for specified candidate points.

Definition at line 29 of file Snap.cpp.

: mProject{ &project }
, mZoomInfo{ &zoomInfo }
, mPixelTolerance{ pixelTolerance }
, mNoTimeSnap{ noTimeSnap }
, mCandidates{ move( candidates ) }
, mSnapPoints{}
{
   Reinit();
}

References Reinit().

Here is the call graph for this function:

◆ SnapManager() [2/2]

SnapManager::SnapManager	(	const AudacityProject &	project,
		const TrackList &	tracks,
		const ZoomInfo &	zoomInfo,
		SnapPointArray	candidates = `{}`,
		bool	noTimeSnap = `false`,
		int	pixelTolerance = `kPixelTolerance`
	)

Construct for (optionally) specified points, plus significant points on the tracks in the given list

Definition at line 60 of file Snap.cpp.

   : SnapManager{ project,
      // Add candidates to given ones by default rules,
      // then delegate to other ctor
      FindCandidates( move(candidates), tracks ),
      zoomInfo, noTimeSnap, pixelTolerance }
{
}

◆ ~SnapManager()

SnapManager::~SnapManager ( )

Definition at line 74 of file Snap.cpp.

75{

76}

Member Function Documentation

◆ CondListAdd()

void SnapManager::CondListAdd	(	double	t,
		const Track *	track
	)

private

Definition at line 117 of file Snap.cpp.

{
   if (!mSnapToTime || ProjectSnap::Get(*mProject).SnapTime(t).time == t)
   {
      mSnapPoints.push_back(SnapPoint { t, track });
   }
}

References ProjectSnap::Get(), mSnapPoints, mSnapToTime, ProjectSnap::SnapTime(), and SnapResult::time.

Referenced by Reinit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Draw()

void SnapManager::Draw	(	wxDC *	dc,
		wxInt64	snap0,
		wxInt64	snap1
	)

static

Definition at line 306 of file Snap.cpp.

{
   AColor::SnapGuidePen(dc);
   if ( snap0 >= 0 ) {
      AColor::Line(*dc, (int)snap0, 0, (int)snap0, 30000);
   }
   if ( snap1 >= 0 ) {
      AColor::Line(*dc, (int)snap1, 0, (int)snap1, 30000);
   }
}

References AColor::Line(), and AColor::SnapGuidePen().

Referenced by WaveClipTrimHandle::AdjustBorder::Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Find() [1/2]

size_t SnapManager::Find ( double t )

private

Definition at line 158 of file Snap.cpp.

{
   size_t cnt = mSnapPoints.size();
   size_t index = Find(t, 0, cnt);
 
   // At this point, either index is the closest, or the next one
   // to the right is.  Keep moving to the right until we get a
   // different value
   size_t next = index + 1;
   while (next + 1 < cnt && Get(next) == Get(index))
   {
      next++;
   }
 
   // Now return whichever one is closer to time t
   if (next < cnt && PixelDiff(t, next) < PixelDiff(t, index))
   {
      return next;
   }
 
   return index;
}

References Find(), Get(), mSnapPoints, and PixelDiff().

Here is the call graph for this function:

◆ Find() [2/2]

size_t SnapManager::Find	(	double	t,
		size_t	i0,
		size_t	i1
	)

private

Definition at line 140 of file Snap.cpp.

{
   if (i1 <= i0 + 1)
   {
      return i0;
   }
 
   size_t half = (i0 + i1) / 2;
 
   if (t < Get(half))
   {
      return Find(t, i0, half);
   }
 
   return Find(t, half, i1);
}

References Find(), and Get().

Referenced by Find(), and SnapToPoints().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Get()

double SnapManager::Get ( size_t index )

private

Definition at line 126 of file Snap.cpp.

{
   return mSnapPoints[index].t;
}

References mSnapPoints.

Referenced by Find(), PixelDiff(), and SnapToPoints().

Here is the caller graph for this function:

◆ PixelDiff()

wxInt64 SnapManager::PixelDiff	(	double	t,
		size_t	index
	)

private

Definition at line 132 of file Snap.cpp.

{
   return std::abs(mZoomInfo->TimeToPosition(t, 0) -
                   mZoomInfo->TimeToPosition(Get(index), 0));
}

References Get(), mZoomInfo, and ZoomInfo::TimeToPosition().

Referenced by Find(), and SnapToPoints().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Reinit()

void SnapManager::Reinit ( )

private

Definition at line 78 of file Snap.cpp.

{
   const auto &formats = ProjectNumericFormats::Get(*mProject);
   const auto &settings = ProjectSnap::Get( *mProject );
   
   auto snapTo = settings.GetSnapTo();
   auto snapMode = settings.GetSnapMode();
   
   auto rate = ProjectRate::Get(*mProject).GetRate();
   auto format = formats.GetSelectionFormat();
 
   // No need to reinit if these are still the same
   if (snapTo == mSnapTo && rate == mRate && format == mFormat)
   {
      return;
   }
 
   // Save NEW settings
   mSnapTo = snapTo;
   mRate = rate;
   mFormat = format;
 
   mSnapPoints.clear();
 
   // Grab time-snapping prefs (unless otherwise requested)
   mSnapToTime = snapMode != SnapMode::SNAP_OFF && !mNoTimeSnap;
 
   // Add a SnapPoint at t=0
   mSnapPoints.push_back(SnapPoint{});
 
   // Adjust and filter the candidate points
   for (const auto &candidate : mCandidates)
      CondListAdd( candidate.t, candidate.track );
 
   // Sort all by time
   std::sort(mSnapPoints.begin(), mSnapPoints.end());
}

References CondListAdd(), format, ProjectNumericFormats::Get(), ProjectRate::Get(), ProjectSnap::Get(), ProjectRate::GetRate(), mCandidates, mFormat, mNoTimeSnap, mProject, mRate, mSnapPoints, mSnapTo, mSnapToTime, settings(), and SNAP_OFF.

Referenced by Snap(), and SnapManager().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Snap()

SnapResults SnapManager::Snap	(	Track *	currentTrack,
		double	t,
		bool	rightEdge
	)

Definition at line 263 of file Snap.cpp.

{
 
   SnapResults results;
   // Check to see if we need to reinitialize
   Reinit();
 
   results.timeSnappedTime = results.outTime = t;
   results.outCoord = mZoomInfo->TimeToPosition(t);
 
   // First snap to points in mSnapPoints
   results.snappedPoint =
      SnapToPoints(currentTrack, t, rightEdge, &results.outTime);
 
   if (mSnapToTime) {
      // Find where it would snap time to the grid
      results.timeSnappedTime = ProjectSnap::Get(*mProject).SnapTime(t).time;
   }
 
   results.snappedTime = false;
   if (mSnapToTime)
   {
      if (results.snappedPoint)
      {
         // Since mSnapPoints only contains points on the grid, we're done
         results.snappedTime = true;
      }
      else
      {
         results.outTime = results.timeSnappedTime;
         results.snappedTime = true;
      }
   }
 
   if (results.Snapped())
      results.outCoord = mZoomInfo->TimeToPosition(results.outTime);
 
   return results;
}

References ProjectSnap::Get(), mSnapToTime, mZoomInfo, SnapResults::outCoord, SnapResults::outTime, Reinit(), SnapResults::Snapped(), SnapResults::snappedPoint, SnapResults::snappedTime, ProjectSnap::SnapTime(), SnapToPoints(), SnapResult::time, SnapResults::timeSnappedTime, and ZoomInfo::TimeToPosition().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SnapToPoints()

bool SnapManager::SnapToPoints	(	Track *	currentTrack,
		double	t,
		bool	rightEdge,
		double *	outT
	)

private

Definition at line 182 of file Snap.cpp.

{
   *outT = t;
 
   size_t cnt = mSnapPoints.size();
   if (cnt == 0)
   {
      return false;
   }
 
   // Find the nearest SnapPoint
   size_t index = Find(t);
 
   // If it's too far away, just give up now
   if (PixelDiff(t, index) >= mPixelTolerance)
   {
      return false;
   }
 
   // Otherwise, search left and right for all of the points
   // within the allowed range.
   size_t left = index;
   size_t right = index;
   size_t i;
 
   while (left > 0 && PixelDiff(t, left - 1) < mPixelTolerance)
   {
      left--;
   }
 
   while (right < cnt - 1 && PixelDiff(t, right + 1) < mPixelTolerance)
   {
      right++;
   }
 
   if (left == index && right == index)
   {
      // Awesome, there's only one point that matches!
      *outT = Get(index);
      return true;
   }
 
   size_t indexInThisTrack = 0;
   size_t countInThisTrack = 0;
   for (i = left; i <= right; ++i)
   {
      if (mSnapPoints[i].track == currentTrack)
      {
         indexInThisTrack = i;
         countInThisTrack++;
      }
   }
 
   if (countInThisTrack == 1)
   {
      // Cool, only one of the points is in the same track, so
      // we'll use that one.
      *outT = Get(indexInThisTrack);
      return true;
   }
 
   if (Get(right) - Get(left) < mEpsilon)
   {
      // OK, they're basically the same point
      if (rightEdge)
      {
         *outT = Get(right);  // Return rightmost
      }
      else {
         *outT = Get(left);   // Return leftmost
      }
      return true;
   }
 
   // None of the points matched, bummer.
   return false;
}

References Find(), Get(), mEpsilon, mPixelTolerance, mSnapPoints, and PixelDiff().

Referenced by Snap().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ mCandidates

SnapPointArray SnapManager::mCandidates

private

Definition at line 106 of file Snap.h.

Referenced by Reinit().

◆ mEpsilon

double SnapManager::mEpsilon { 1 / 44100.0 }

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SnapManager() [1/2]

◆ SnapManager() [2/2]

◆ ~SnapManager()

Member Function Documentation

◆ CondListAdd()

◆ Draw()

◆ Find() [1/2]

◆ Find() [2/2]

◆ Get()

◆ PixelDiff()

◆ Reinit()

◆ Snap()

◆ SnapToPoints()

Member Data Documentation

◆ mCandidates

◆ mEpsilon

◆ mFormat

◆ mNoTimeSnap

◆ mPixelTolerance

◆ mProject

◆ mRate

◆ mSnapPoints

◆ mSnapTo

◆ mSnapToTime

◆ mZoomInfo