anonymous_namespace{SelectHandle.cpp} Namespace Reference

Enumerations
enum	SelectionBoundary { SBNone , SBLeft , SBRight }

Functions
wxInt64	FrequencyToPosition (const WaveTrack *wt, double frequency, wxInt64 trackTopEdge, int trackHeight)
	Converts a frequency to screen y position. More...
double	PositionToFrequency (const WaveTrack *wt, bool maySnap, wxInt64 mouseYCoordinate, wxInt64 trackTopEdge, int trackHeight)
template<typename T >
void	SetIfNotNull (T *pValue, const T Value)
bool	isSpectralSelectionView (const ChannelView *pChannelView)
SelectionBoundary	ChooseTimeBoundary (const double t0, const double t1, const ViewInfo &viewInfo, double selend, bool onlyWithinSnapDistance, wxInt64 *pPixelDist, double *pPinValue)
SelectionBoundary	ChooseBoundary (const ViewInfo &viewInfo, wxCoord xx, wxCoord yy, const ChannelView *pChannelView, const wxRect &rect, bool mayDragWidth, bool onlyWithinSnapDistance, double *pPinValue=NULL)
wxCursor *	SelectCursor ()
wxCursor *	EnvelopeCursor ()
void	SetTipAndCursorForBoundary (SelectionBoundary boundary, bool frequencySnapping, TranslatableString &tip, wxCursor *&pCursor)
template<class A , class B , class DIST >
bool	within (A a, B b, DIST d)
double	findMaxRatio (double center, double rate)

Enumeration Type Documentation

SelectionBoundary

enum anonymous_namespace{SelectHandle.cpp}::SelectionBoundary

Enumerator
SBNone
SBLeft
SBRight

Definition at line 128 of file SelectHandle.cpp.

                          {
      SBNone,
      SBLeft, SBRight,
#ifdef EXPERIMENTAL_SPECTRAL_EDITING
      SBBottom, SBTop, SBCenter, SBWidth,
#endif
   };

Function Documentation

ChooseBoundary()

SelectionBoundary anonymous_namespace{SelectHandle.cpp}::ChooseBoundary	(	const ViewInfo &	viewInfo,
		wxCoord	xx,
		wxCoord	yy,
		const ChannelView *	pChannelView,
		const wxRect &	rect,
		bool	mayDragWidth,
		bool	onlyWithinSnapDistance,
		double *	pPinValue = NULL
	)

Definition at line 176 of file SelectHandle.cpp.

   {
      // Choose one of four boundaries to adjust, or the center frequency.
      // May choose frequencies only if in a spectrogram view and
      // within the time boundaries.
      // May choose no boundary if onlyWithinSnapDistance is true.
      // Otherwise choose the eligible boundary nearest the mouse click.
      const double selend = viewInfo.PositionToTime(xx, rect.x);
      wxInt64 pixelDist = 0;
      const double t0 = viewInfo.selectedRegion.t0();
      const double t1 = viewInfo.selectedRegion.t1();
 
      SelectionBoundary boundary =
         ChooseTimeBoundary(t0,t1,viewInfo, selend, onlyWithinSnapDistance,
         &pixelDist, pPinValue);
 
#ifdef EXPERIMENTAL_SPECTRAL_EDITING
      //const double t0 = viewInfo.selectedRegion.t0();
      //const double t1 = viewInfo.selectedRegion.t1();
      const double f0 = viewInfo.selectedRegion.f0();
      const double f1 = viewInfo.selectedRegion.f1();
      const double fc = viewInfo.selectedRegion.fc();
      double ratio = 0;
 
      bool chooseTime = true;
      bool chooseBottom = true;
      bool chooseCenter = false;
      // Consider adjustment of frequencies only if mouse is
      // within the time boundaries
      if (!viewInfo.selectedRegion.isPoint() &&
         t0 <= selend && selend < t1 &&
         isSpectralSelectionView(pChannelView)) {
         // Spectral selection track is always wave
         auto pTrack = pChannelView->FindTrack();
         const WaveTrack *const wt =
           static_cast<const WaveTrack*>(pTrack.get());
         const wxInt64 bottomSel = (f0 >= 0)
            ? FrequencyToPosition(wt, f0, rect.y, rect.height)
            : rect.y + rect.height;
         const wxInt64 topSel = (f1 >= 0)
            ? FrequencyToPosition(wt, f1, rect.y, rect.height)
            : rect.y;
         wxInt64 signedBottomDist = (int)(yy - bottomSel);
         wxInt64 verticalDist = std::abs(signedBottomDist);
         if (bottomSel == topSel)
            // Top and bottom are too close to resolve on screen
            chooseBottom = (signedBottomDist >= 0);
         else {
            const wxInt64 topDist = std::abs((int)(yy - topSel));
            if (topDist < verticalDist)
               chooseBottom = false, verticalDist = topDist;
         }
         if (fc > 0
#ifdef SPECTRAL_EDITING_ESC_KEY
            && mayDragWidth
#endif
            ) {
            const wxInt64 centerSel =
               FrequencyToPosition(wt, fc, rect.y, rect.height);
            const wxInt64 centerDist = abs((int)(yy - centerSel));
            if (centerDist < verticalDist)
               chooseCenter = true, verticalDist = centerDist,
               ratio = f1 / fc;
         }
         if (verticalDist >= 0 &&
            verticalDist < pixelDist) {
            pixelDist = verticalDist;
            chooseTime = false;
         }
      }
 
      if (!chooseTime) {
         // PRL:  Seems I need a larger tolerance to make snapping work
         // at top of track, not sure why
         if (onlyWithinSnapDistance &&
            pixelDist >= FREQ_SNAP_DISTANCE) {
            SetIfNotNull(pPinValue, -1.0);
            return SBNone;
         }
         else if (chooseCenter) {
            SetIfNotNull(pPinValue, ratio);
            return SBCenter;
         }
         else if (mayDragWidth && fc > 0) {
            SetIfNotNull(pPinValue, fc);
            return SBWidth;
         }
         else if (chooseBottom) {
            SetIfNotNull(pPinValue, f1);
            return SBBottom;
         }
         else {
            SetIfNotNull(pPinValue, f0);
            return SBTop;
         }
      }
      else
#endif
      {
         return boundary;
      }
   }

References ChooseTimeBoundary(), NotifyingSelectedRegion::f0(), NotifyingSelectedRegion::f1(), NotifyingSelectedRegion::fc(), CommonTrackPanelCell::FindTrack(), FREQ_SNAP_DISTANCE, FrequencyToPosition(), NotifyingSelectedRegion::isPoint(), isSpectralSelectionView(), ZoomInfo::PositionToTime(), SBNone, ViewInfo::selectedRegion, SetIfNotNull(), NotifyingSelectedRegion::t0(), and NotifyingSelectedRegion::t1().

Referenced by SelectHandle::Click(), and SelectHandle::Preview().

Here is the call graph for this function:

Here is the caller graph for this function:

ChooseTimeBoundary()

SelectionBoundary anonymous_namespace{SelectHandle.cpp}::ChooseTimeBoundary	(	const double	t0,
		const double	t1,
		const ViewInfo &	viewInfo,
		double	selend,
		bool	onlyWithinSnapDistance,
		wxInt64 *	pPixelDist,
		double *	pPinValue
	)

Definition at line 136 of file SelectHandle.cpp.

   {
      const wxInt64 posS = viewInfo.TimeToPosition(selend);
      const wxInt64 pos0 = viewInfo.TimeToPosition(t0);
      wxInt64 pixelDist = std::abs(posS - pos0);
      bool chooseLeft = true;
 
      if (t1<=t0)
         // Special case when selection is a point, and thus left
         // and right distances are the same
         chooseLeft = (selend < t0);
      else {
         const wxInt64 pos1 = viewInfo.TimeToPosition(t1);
         const wxInt64 rightDist = std::abs(posS - pos1);
         if (rightDist < pixelDist)
            chooseLeft = false, pixelDist = rightDist;
      }
 
      SetIfNotNull(pPixelDist, pixelDist);
 
      if (onlyWithinSnapDistance &&
         pixelDist >= SELECTION_RESIZE_REGION) {
         SetIfNotNull(pPinValue, -1.0);
         return SBNone;
      }
      else if (chooseLeft) {
         SetIfNotNull(pPinValue, t1);
         return SBLeft;
      }
      else {
         SetIfNotNull(pPinValue, t0);
         return SBRight;
      }
   }

References SBLeft, SBNone, SBRight, SELECTION_RESIZE_REGION, SetIfNotNull(), and ZoomInfo::TimeToPosition().

Referenced by ChooseBoundary().

Here is the call graph for this function:

Here is the caller graph for this function:

EnvelopeCursor()

wxCursor * anonymous_namespace{SelectHandle.cpp}::EnvelopeCursor

(

)

Definition at line 291 of file SelectHandle.cpp.

   {
      // This one doubles as the center frequency cursor for spectral selection:
      static auto envelopeCursor =
         ::MakeCursor(wxCURSOR_ARROW, EnvCursorXpm, 16, 16);
      return &*envelopeCursor;
   }

References MakeCursor().

Referenced by SetTipAndCursorForBoundary().

Here is the call graph for this function:

Here is the caller graph for this function:

findMaxRatio()

double anonymous_namespace{SelectHandle.cpp}::findMaxRatio ( double  center, double  rate  )

inline

Definition at line 476 of file SelectHandle.cpp.

   {
      const double minFrequency = 1.0;
      const double maxFrequency = (rate / 2.0);
      const double frequency =
         std::min(maxFrequency,
            std::max(minFrequency, center));
      return
         std::min(frequency / minFrequency, maxFrequency / frequency);
   }

References min().

Referenced by SelectHandle::AdjustFreqSelection(), SelectHandle::MoveSnappingFreqSelection(), and SelectHandle::SnapCenterOnce().

Here is the call graph for this function:

Here is the caller graph for this function:

FrequencyToPosition()

wxInt64 anonymous_namespace{SelectHandle.cpp}::FrequencyToPosition	(	const WaveTrack *	wt,
		double	frequency,
		wxInt64	trackTopEdge,
		int	trackHeight
	)

Converts a frequency to screen y position.

Definition at line 67 of file SelectHandle.cpp.

   {
      const auto &settings = SpectrogramSettings::Get(*wt);
      float minFreq, maxFreq;
      SpectrogramBounds::Get(*wt).GetBounds(*wt, minFreq, maxFreq);
      const NumberScale numberScale(settings.GetScale(minFreq, maxFreq));
      const float p = numberScale.ValueToPosition(frequency);
      return trackTopEdge + wxInt64((1.0 - p) * trackHeight);
   }

References SpectrogramSettings::Get(), SpectrogramBounds::Get(), SpectrogramBounds::GetBounds(), settings(), and NumberScale::ValueToPosition().

Referenced by ChooseBoundary().

Here is the call graph for this function:

Here is the caller graph for this function:

isSpectralSelectionView()

bool anonymous_namespace{SelectHandle.cpp}::isSpectralSelectionView ( const ChannelView *  pChannelView )

inline

Definition at line 116 of file SelectHandle.cpp.

                                                                        {
      return
        pChannelView &&
        pChannelView->IsSpectral() &&
        pChannelView->FindTrack() &&
        pChannelView->FindTrack()->TypeSwitch<bool>(
           [&](const WaveTrack &wt) {
              const auto &settings = SpectrogramSettings::Get(wt);
              return settings.SpectralSelectionEnabled();
           });
   }

References CommonTrackPanelCell::FindTrack(), SpectrogramSettings::Get(), ChannelView::IsSpectral(), and settings().

Referenced by ChooseBoundary(), SelectHandle::Click(), SelectHandle::MoveSnappingFreqSelection(), SelectHandle::Preview(), and SelectHandle::StartFreqSelection().

Here is the call graph for this function:

Here is the caller graph for this function:

PositionToFrequency()

double anonymous_namespace{SelectHandle.cpp}::PositionToFrequency	(	const WaveTrack *	wt,
		bool	maySnap,
		wxInt64	mouseYCoordinate,
		wxInt64	trackTopEdge,
		int	trackHeight
	)

Converts a position (mouse Y coordinate) to frequency, in Hz.

Definition at line 82 of file SelectHandle.cpp.

   {
      const double rate = wt->GetRate();
 
      // Handle snapping
      if (maySnap &&
         mouseYCoordinate - trackTopEdge < FREQ_SNAP_DISTANCE)
         return rate;
      if (maySnap &&
         trackTopEdge + trackHeight - mouseYCoordinate < FREQ_SNAP_DISTANCE)
         return -1;
 
      const auto &settings = SpectrogramSettings::Get(*wt);
      float minFreq, maxFreq;
      SpectrogramBounds::Get(*wt)
         .GetBounds(*wt, minFreq, maxFreq);
      const NumberScale numberScale(settings.GetScale(minFreq, maxFreq));
      const double p = double(mouseYCoordinate - trackTopEdge) / trackHeight;
      return numberScale.PositionToValue(1.0 - p);
   }

References FREQ_SNAP_DISTANCE, SpectrogramSettings::Get(), SpectrogramBounds::Get(), SpectrogramBounds::GetBounds(), WaveTrack::GetRate(), NumberScale::PositionToValue(), and settings().

Referenced by SelectHandle::AdjustFreqSelection(), SelectHandle::MoveSnappingFreqSelection(), and SelectHandle::StartFreqSelection().

Here is the call graph for this function:

Here is the caller graph for this function:

SelectCursor()

wxCursor * anonymous_namespace{SelectHandle.cpp}::SelectCursor

(

)

Definition at line 284 of file SelectHandle.cpp.

   {
      static auto selectCursor =
         ::MakeCursor(wxCURSOR_IBEAM, IBeamCursorXpm, 17, 16);
      return &*selectCursor;
   }

References MakeCursor().

Referenced by SelectHandle::Preview(), and SetTipAndCursorForBoundary().

Here is the call graph for this function:

Here is the caller graph for this function:

SetIfNotNull()

template<typename T >

void anonymous_namespace{SelectHandle.cpp}::SetIfNotNull ( T *  pValue, const T  Value  )

inline

Definition at line 108 of file SelectHandle.cpp.

   {
      if (pValue == NULL)
         return;
      *pValue = Value;
   }

Referenced by ChooseBoundary(), and ChooseTimeBoundary().

Here is the caller graph for this function:

SetTipAndCursorForBoundary()

void anonymous_namespace{SelectHandle.cpp}::SetTipAndCursorForBoundary	(	SelectionBoundary	boundary,
		bool	frequencySnapping,
		TranslatableString &	tip,
		wxCursor *&	pCursor
	)

Definition at line 299 of file SelectHandle.cpp.

   {
      static wxCursor adjustLeftSelectionCursor{ wxCURSOR_POINT_LEFT };
      static wxCursor adjustRightSelectionCursor{ wxCURSOR_POINT_RIGHT };
 
      static auto bottomFrequencyCursor =
         ::MakeCursor(wxCURSOR_ARROW, BottomFrequencyCursorXpm, 16, 16);
      static auto topFrequencyCursor =
         ::MakeCursor(wxCURSOR_ARROW, TopFrequencyCursorXpm, 16, 16);
      static auto bandWidthCursor =
         ::MakeCursor(wxCURSOR_ARROW, BandWidthCursorXpm, 16, 16);
 
      switch (boundary) {
      case SBNone:
         pCursor = SelectCursor();
         break;
      case SBLeft:
         tip = XO("Click and drag to move left selection boundary.");
         pCursor = &adjustLeftSelectionCursor;
         break;
      case SBRight:
         tip = XO("Click and drag to move right selection boundary.");
         pCursor = &adjustRightSelectionCursor;
         break;
#ifdef EXPERIMENTAL_SPECTRAL_EDITING
      case SBBottom:
         tip = XO("Click and drag to move bottom selection frequency.");
         pCursor = &*bottomFrequencyCursor;
         break;
      case SBTop:
         tip = XO("Click and drag to move top selection frequency.");
         pCursor = &*topFrequencyCursor;
         break;
      case SBCenter:
      {
#ifndef SPECTRAL_EDITING_ESC_KEY
         tip =
            frequencySnapping ?
            XO("Click and drag to move center selection frequency to a spectral peak.") :
            XO("Click and drag to move center selection frequency.");
 
#else
         shiftDown;
 
         tip =
            XO("Click and drag to move center selection frequency.");
 
#endif
 
         pCursor = EnvelopeCursor();
      }
      break;
      case SBWidth:
         tip = XO("Click and drag to adjust frequency bandwidth.");
         pCursor = &*bandWidthCursor;
         break;
#endif
      default:
         wxASSERT(false);
      } // switch
      // Falls through the switch if there was no boundary found.
   }

References EnvelopeCursor(), MakeCursor(), SBLeft, SBNone, SBRight, SelectCursor(), and XO().

Referenced by SelectHandle::Preview().

Here is the call graph for this function:

Here is the caller graph for this function:

within()

template<class A , class B , class DIST >

bool anonymous_namespace{SelectHandle.cpp}::within	(	A	a,
		B	b,
		DIST	d
	)

Definition at line 471 of file SelectHandle.cpp.

   {
      return (a > b - d) && (a < b + d);
   }