#include <SelectHandle.h>

Inheritance diagram for SelectHandle:

Collaboration diagram for SelectHandle:

Classes
class	TimerHandler

Public Member Functions
	SelectHandle (const std::shared_ptr< ChannelView > &pChannelView, bool useSnap, const TrackList &trackList, const TrackPanelMouseState &st, const ViewInfo &viewInfo)

SelectHandle &	operator= (const SelectHandle &)=default

virtual	~SelectHandle ()

std::shared_ptr< const Channel >	FindChannel () const override

bool	IsDragging () const override

void	SetUseSnap (bool use, AudacityProject *pProject)

void	Enter (bool forward, AudacityProject *pProject) override

bool	HasSnap () const

bool	HasEscape (AudacityProject *pProject) const override

bool	Escape (AudacityProject *pProject) override

Result	Click (const TrackPanelMouseEvent &event, AudacityProject *pProject) override

Result	Drag (const TrackPanelMouseEvent &event, AudacityProject *pProject) override

HitTestPreview	Preview (const TrackPanelMouseState &state, AudacityProject *pProject) override

Result	Release (const TrackPanelMouseEvent &event, AudacityProject pProject, wxWindow pParent) override

Result	Cancel (AudacityProject *) override

Public Member Functions inherited from UIHandle
virtual	~UIHandle ()=0

virtual void	Enter (bool forward, AudacityProject *pProject)

virtual bool	HasRotation () const

virtual bool	Rotate (bool forward)

virtual bool	HasEscape (AudacityProject *pProject) const

virtual bool	Escape (AudacityProject *pProject)

virtual bool	HandlesRightClick ()
	Whether the handle has any special right-button handling. More...

virtual Result	Click (const TrackPanelMouseEvent &event, AudacityProject *pProject)=0

virtual Result	Drag (const TrackPanelMouseEvent &event, AudacityProject *pProject)=0

virtual HitTestPreview	Preview (const TrackPanelMouseState &state, AudacityProject *pProject)=0

virtual Result	Release (const TrackPanelMouseEvent &event, AudacityProject pProject, wxWindow pParent)=0

virtual Result	Cancel (AudacityProject *pProject)=0

virtual bool	StopsOnKeystroke ()

virtual void	OnProjectChange (AudacityProject *pProject)

virtual std::shared_ptr< const Channel >	FindChannel () const =0

virtual bool	IsDragging () const

Result	GetChangeHighlight () const

void	SetChangeHighlight (Result val)

Public Member Functions inherited from TrackPanelDrawable
virtual	~TrackPanelDrawable ()=0

virtual void	Draw (TrackPanelDrawingContext &context, const wxRect &rect, unsigned iPass)

virtual wxRect	DrawingArea (TrackPanelDrawingContext &context, const wxRect &rect, const wxRect &panelRect, unsigned iPass)

Static Public Member Functions
static UIHandlePtr	HitTest (std::weak_ptr< SelectHandle > &holder, const TrackPanelMouseState &state, const AudacityProject *pProject, const std::shared_ptr< ChannelView > &pChannelView)

static UIHandle::Result	NeedChangeHighlight (const SelectHandle &oldState, const SelectHandle &newState)

static void	SnapCenterOnce (SpectrumAnalyst &analyst, ViewInfo &viewInfo, const WaveTrack *pTrack, bool up)

Static Public Member Functions inherited from UIHandle
static UIHandle::Result	NeedChangeHighlight (const UIHandle &, const UIHandle &)

Static Public Member Functions inherited from TrackPanelDrawable
static wxRect	MaximizeWidth (const wxRect &rect, const wxRect &panelRect)

static wxRect	MaximizeHeight (const wxRect &rect, const wxRect &panelRect)

Private Types
enum	eFreqSelMode { FREQ_SEL_INVALID , FREQ_SEL_SNAPPING_CENTER , FREQ_SEL_PINNED_CENTER , FREQ_SEL_DRAG_CENTER , FREQ_SEL_FREE , FREQ_SEL_TOP_FREE , FREQ_SEL_BOTTOM_FREE }

Private Member Functions
	SelectHandle (const SelectHandle &)

std::weak_ptr< Track >	FindTrack ()

void	Connect (AudacityProject *pProject)

void	StartSelection (AudacityProject *pProject)
	Reset our selection markers. More...

void	AdjustSelection (AudacityProject pProject, ViewInfo &viewInfo, int mouseXCoordinate, int trackLeftEdge, Track pTrack)
	Extend or contract the existing selection. More...

void	AssignSelection (ViewInfo &viewInfo, double selend, Track *pTrack)

void	StartFreqSelection (ViewInfo &viewInfo, int mouseYCoordinate, int trackTopEdge, int trackHeight, ChannelView *pChannelView)

void	AdjustFreqSelection (const WaveTrack *wt, ViewInfo &viewInfo, int mouseYCoordinate, int trackTopEdge, int trackHeight)

void	HandleCenterFrequencyClick (const ViewInfo &viewInfo, bool shiftDown, const WaveTrack *pTrack, double value)

void	MoveSnappingFreqSelection (AudacityProject pProject, ViewInfo &viewInfo, int mouseYCoordinate, int trackTopEdge, int trackHeight, ChannelView pChannelView)

void	Draw (TrackPanelDrawingContext &context, const wxRect &rect, unsigned iPass) override

wxRect	DrawingArea (TrackPanelDrawingContext &, const wxRect &rect, const wxRect &panelRect, unsigned iPass) override

Static Private Member Functions
static void	StartSnappingFreqSelection (SpectrumAnalyst &analyst, const ViewInfo &viewInfo, const WaveTrack *pTrack)

Private Attributes
std::weak_ptr< ChannelView >	mpView

wxRect	mRect {}

SelectedRegion	mInitialSelection {}

std::shared_ptr< SnapManager >	mSnapManager

SnapResults	mSnapStart

SnapResults	mSnapEnd

bool	mUseSnap { true }

bool	mSelStartValid {}

double	mSelStart { 0.0 }

int	mSelectionBoundary { 0 }

enum SelectHandle::eFreqSelMode	FREQ_SEL_INVALID

std::weak_ptr< const WaveTrack >	mFreqSelTrack

double	mFreqSelPin { -1.0 }

std::shared_ptr< SpectrumAnalyst >	mFrequencySnapper

int	mMostRecentX { -1 }

int	mMostRecentY { -1 }

bool	mAutoScrolling {}

std::shared_ptr< SelectionStateChanger >	mSelectionStateChanger

friend	TimerHandler

std::shared_ptr< TimerHandler >	mTimerHandler

Additional Inherited Members
Public Types inherited from UIHandle
using	Result = unsigned

using	Cell = TrackPanelCell

Protected Attributes inherited from UIHandle
Result	mChangeHighlight { 0 }

Detailed Description

Definition at line 30 of file SelectHandle.h.

Member Enumeration Documentation

◆ eFreqSelMode

enum SelectHandle::eFreqSelMode

private

Enumerator
FREQ_SEL_INVALID
FREQ_SEL_SNAPPING_CENTER
FREQ_SEL_PINNED_CENTER
FREQ_SEL_DRAG_CENTER
FREQ_SEL_FREE
FREQ_SEL_TOP_FREE
FREQ_SEL_BOTTOM_FREE

Definition at line 146 of file SelectHandle.h.

                     {
      FREQ_SEL_INVALID,
 
      FREQ_SEL_SNAPPING_CENTER,
      FREQ_SEL_PINNED_CENTER,
      FREQ_SEL_DRAG_CENTER,
 
      FREQ_SEL_FREE,
      FREQ_SEL_TOP_FREE,
      FREQ_SEL_BOTTOM_FREE,
   }  mFreqSelMode{ FREQ_SEL_INVALID };

Constructor & Destructor Documentation

◆ SelectHandle() [1/2]

SelectHandle::SelectHandle ( const SelectHandle & )

private

◆ SelectHandle() [2/2]

SelectHandle::SelectHandle	(	const std::shared_ptr< ChannelView > &	pChannelView,
		bool	useSnap,
		const TrackList &	trackList,
		const TrackPanelMouseState &	st,
		const ViewInfo &	viewInfo
	)

Definition at line 432 of file SelectHandle.cpp.

   : mpView{ pChannelView }
   // Selection dragging can snap to play region boundaries
   , mSnapManager{ std::make_shared<SnapManager>(
      *trackList.GetOwner(), trackList, viewInfo, SnapPointArray{
         SnapPoint{ viewInfo.playRegion.GetLastActiveStart() },
         SnapPoint{ viewInfo.playRegion.GetLastActiveEnd() },
   } ) }
{
   const wxMouseState &state = st.state;
   mRect = st.rect;
 
   auto time = std::max(0.0, viewInfo.PositionToTime(state.m_x, mRect.x));
   auto pTrack = pChannelView->FindTrack();
   mSnapStart = mSnapManager->Snap(pTrack.get(), time, false);
   if (mSnapStart.snappedPoint)
         mSnapStart.outCoord += mRect.x;
   else
      mSnapStart.outCoord = -1;
 
   mUseSnap = useSnap;
}

References mRect, mSnapManager, mSnapStart, mUseSnap, SnapResults::outCoord, ZoomInfo::PositionToTime(), TrackPanelMouseState::rect, SnapResults::snappedPoint, and TrackPanelMouseState::state.

Here is the call graph for this function:

◆ ~SelectHandle()

SelectHandle::~SelectHandle ( )

virtual

Definition at line 458 of file SelectHandle.cpp.

459{

460}

Member Function Documentation

◆ AdjustFreqSelection()

void SelectHandle::AdjustFreqSelection	(	const WaveTrack *	wt,
		ViewInfo &	viewInfo,
		int	mouseYCoordinate,
		int	trackTopEdge,
		int	trackHeight
	)

private

Definition at line 1255 of file SelectHandle.cpp.

{
   if (mFreqSelMode == FREQ_SEL_INVALID ||
       mFreqSelMode == FREQ_SEL_SNAPPING_CENTER)
      return;
 
   // Extension happens only when dragging in the same track in which we
   // started, and that is of a spectrogram display type.
 
   const double rate =  wt->GetRate();
   const double frequency =
      PositionToFrequency(wt, true, mouseYCoordinate,
         trackTopEdge, trackHeight);
 
   // Dragging center?
   if (mFreqSelMode == FREQ_SEL_DRAG_CENTER) {
      if (frequency == rate || frequency < 1.0)
         // snapped to top or bottom
         viewInfo.selectedRegion.setFrequencies(
            SelectedRegion::UndefinedFrequency,
            SelectedRegion::UndefinedFrequency);
      else {
         // mFreqSelPin holds the ratio of top to center
         const double maxRatio = findMaxRatio(frequency, rate);
         const double ratio = std::min(maxRatio, mFreqSelPin);
         viewInfo.selectedRegion.setFrequencies(
            frequency / ratio, frequency * ratio);
      }
   }
   else if (mFreqSelMode == FREQ_SEL_PINNED_CENTER) {
      if (mFreqSelPin >= 0) {
         // Change both upper and lower edges leaving centre where it is.
         if (frequency == rate || frequency < 1.0)
            // snapped to top or bottom
            viewInfo.selectedRegion.setFrequencies(
               SelectedRegion::UndefinedFrequency,
               SelectedRegion::UndefinedFrequency);
         else {
            // Given center and mouse position, find ratio of the larger to the
            // smaller, limit that to the frequency scale bounds, and adjust
            // top and bottom accordingly.
            const double maxRatio = findMaxRatio(mFreqSelPin, rate);
            double ratio = frequency / mFreqSelPin;
            if (ratio < 1.0)
               ratio = 1.0 / ratio;
            ratio = std::min(maxRatio, ratio);
            viewInfo.selectedRegion.setFrequencies(
               mFreqSelPin / ratio, mFreqSelPin * ratio);
         }
      }
   }
   else {
      // Dragging of upper or lower.
      const bool bottomDefined =
         !(mFreqSelMode == FREQ_SEL_TOP_FREE && mFreqSelPin < 0);
      const bool topDefined =
         !(mFreqSelMode == FREQ_SEL_BOTTOM_FREE && mFreqSelPin < 0);
      if (!bottomDefined || (topDefined && mFreqSelPin < frequency)) {
         // Adjust top
         if (frequency == rate)
            // snapped high; upper frequency is undefined
            viewInfo.selectedRegion.setF1(SelectedRegion::UndefinedFrequency);
         else
            viewInfo.selectedRegion.setF1(std::max(1.0, frequency));
 
         viewInfo.selectedRegion.setF0(mFreqSelPin);
      }
      else {
         // Adjust bottom
         if (frequency < 1.0)
            // snapped low; lower frequency is undefined
            viewInfo.selectedRegion.setF0(SelectedRegion::UndefinedFrequency);
         else
            viewInfo.selectedRegion.setF0(std::min(rate / 2.0, frequency));
 
         viewInfo.selectedRegion.setF1(mFreqSelPin);
      }
   }
}

References anonymous_namespace{SelectHandle.cpp}::findMaxRatio(), FREQ_SEL_BOTTOM_FREE, FREQ_SEL_DRAG_CENTER, FREQ_SEL_INVALID, FREQ_SEL_PINNED_CENTER, FREQ_SEL_SNAPPING_CENTER, FREQ_SEL_TOP_FREE, WaveTrack::GetRate(), mFreqSelPin, min(), anonymous_namespace{SelectHandle.cpp}::PositionToFrequency(), ViewInfo::selectedRegion, NotifyingSelectedRegion::setF0(), NotifyingSelectedRegion::setF1(), NotifyingSelectedRegion::setFrequencies(), and SelectedRegion::UndefinedFrequency.

Referenced by Click(), and Drag().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AdjustSelection()

void SelectHandle::AdjustSelection	(	AudacityProject *	pProject,
		ViewInfo &	viewInfo,
		int	mouseXCoordinate,
		int	trackLeftEdge,
		Track *	pTrack
	)

private

Extend or contract the existing selection.

Definition at line 1177 of file SelectHandle.cpp.

{
   if (!mSelStartValid)
      // Must be dragging frequency bounds only.
      return;
 
   double selend =
      std::max(0.0, viewInfo.PositionToTime(mouseXCoordinate, trackLeftEdge));
   double origSelend = selend;
 
   auto pTrack = Track::SharedPointer( track );
   if (!pTrack)
      pTrack = TrackList::Get( *pProject ).Lock( FindTrack() );
 
   if (pTrack && mSnapManager.get()) {
      bool rightEdge = (selend > mSelStart);
      mSnapEnd = mSnapManager->Snap(pTrack.get(), selend, rightEdge);
      if (mSnapEnd.Snapped()) {
         if (mUseSnap)
            selend = mSnapEnd.outTime;
         if (mSnapEnd.snappedPoint)
            mSnapEnd.outCoord += trackLeftEdge;
      }
      if (!mSnapEnd.snappedPoint)
         mSnapEnd.outCoord = -1;
 
      // Check if selection endpoints are too close together to snap (unless
      // using snap-to-time -- then we always accept the snap results)
      if (mSnapStart.outCoord >= 0 &&
          mSnapEnd.outCoord >= 0 &&
          std::abs(mSnapStart.outCoord - mSnapEnd.outCoord) < 3) {
         if(!mSnapEnd.snappedTime)
            selend = origSelend;
         mSnapEnd.outCoord = -1;
      }
   }
   AssignSelection(viewInfo, selend, pTrack.get());
}

References AssignSelection(), FindTrack(), TrackList::Get(), TrackList::Lock(), mSelStart, mSelStartValid, mSnapEnd, mSnapManager, mSnapStart, mUseSnap, SnapResults::outCoord, SnapResults::outTime, ZoomInfo::PositionToTime(), Track::SharedPointer(), SnapResults::Snapped(), SnapResults::snappedPoint, and SnapResults::snappedTime.

Referenced by Click(), and Drag().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AssignSelection()

void SelectHandle::AssignSelection	(	ViewInfo &	viewInfo,
		double	selend,
		Track *	pTrack
	)

private

Definition at line 1219 of file SelectHandle.cpp.

{
   double sel0, sel1;
   if (mSelStart < selend) {
      sel0 = mSelStart;
      sel1 = selend;
   }
   else {
      sel1 = mSelStart;
      sel0 = selend;
   }
 
   viewInfo.selectedRegion.setTimes(sel0, sel1);
}

References mSelStart, ViewInfo::selectedRegion, and NotifyingSelectedRegion::setTimes().

Referenced by AdjustSelection(), and SetUseSnap().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Cancel()

UIHandle::Result SelectHandle::Cancel ( AudacityProject * pProject )

overridevirtual

Implements UIHandle.

Definition at line 1022 of file SelectHandle.cpp.

{
   mSelectionStateChanger.reset();
   ViewInfo::Get( *pProject ).selectedRegion = mInitialSelection;
 
   return RefreshCode::RefreshAll;
}

References ViewInfo::Get(), mInitialSelection, mSelectionStateChanger, RefreshCode::RefreshAll, and ViewInfo::selectedRegion.

Here is the call graph for this function:

◆ Click()

UIHandle::Result SelectHandle::Click	(	const TrackPanelMouseEvent &	event,
		AudacityProject *	pProject
	)

overridevirtual

This method gets called when we're handling selection and the mouse was just clicked.

Implements UIHandle.

Definition at line 531 of file SelectHandle.cpp.

{
 
   using namespace RefreshCode;
 
   const auto pView = mpView.lock();
   if ( !pView )
      return Cancelled;
 
   wxMouseEvent &event = evt.event;
   auto &trackList = TrackList::Get(*pProject);
   const auto sTrack = trackList.Lock(FindTrack());
   const auto pTrack = sTrack.get();
   const auto pLeader = *trackList.Find(pTrack);
   auto &trackPanel = TrackPanel::Get(*pProject);
   auto &viewInfo = ViewInfo::Get(*pProject);
 
   mMostRecentX = event.m_x;
   mMostRecentY = event.m_y;
 
   bool selectChange = (
      event.LeftDown() &&
      event.ControlDown() &&
      pTrack->TypeSwitch<bool>( [&](LabelTrack &){
         // We should reach this, only in default of other hits on glyphs or
         // text boxes.
         bool bShift = event.ShiftDown();
         bool unsafe = ProjectAudioIO::Get( *pProject ).IsAudioActive();
         SelectUtilities::DoListSelection(
            *pProject, *pTrack, bShift, true, !unsafe);
         return true;
       } )
   );
   if ( selectChange )
      // Do not start a drag
      return RefreshAll | Cancelled;
   
   auto &selectionState = SelectionState::Get( *pProject );
   if (event.LeftDClick() && !event.ShiftDown()) {
      // Deselect all other tracks and select this one.
      selectionState.SelectNone(trackList);
 
      if (pLeader)
         selectionState.SelectTrack(*pLeader, true, true);
 
      // Default behavior: select whole track
      SelectionState::SelectTrackLength(
         viewInfo, *pLeader, SyncLockState::Get(*pProject).IsSyncLocked());
 
      // Special case: if we're over a clip in a WaveTrack,
      // select just that clip
      pTrack->TypeSwitch( [&] ( WaveTrack &wt ) {
         auto time = viewInfo.PositionToTime(event.m_x, mRect.x);
         WaveClip *const selectedClip = wt.GetClipAtTime(time);
         if (selectedClip) {
            viewInfo.selectedRegion.setTimes(
               selectedClip->GetPlayStartTime(), selectedClip->GetPlayEndTime());
         }
      } );
 
      ProjectHistory::Get( *pProject ).ModifyState(false);
 
      // Do not start a drag
      return RefreshAll | Cancelled;
   }
   else if (!event.LeftDown())
      return Cancelled;
 
   mInitialSelection = viewInfo.selectedRegion;
 
   mSelectionStateChanger =
      std::make_shared<SelectionStateChanger>(selectionState, trackList);
 
   mSelectionBoundary = 0;
 
   bool bShiftDown = event.ShiftDown();
   bool bCtrlDown = event.ControlDown();
 
   mSelStart = mUseSnap ? mSnapStart.outTime : mSnapStart.timeSnappedTime;
   auto xx = viewInfo.TimeToPosition(mSelStart, mRect.x);
 
   // I. Shift-click adjusts an existing selection
   if (bShiftDown || bCtrlDown) {
      if (bShiftDown)
         selectionState.ChangeSelectionOnShiftClick(trackList, *pTrack);
      if( bCtrlDown ){
         //Commented out bIsSelected toggles, as in Track Control Panel.
         //bool bIsSelected = pTrack->GetSelected();
         //Actual bIsSelected will always add.
         bool bIsSelected = false;
         // Don't toggle away the last selected track.
         if (!bIsSelected || trackPanel.GetSelectedTrackCount() > 1)
            if (pLeader)
               selectionState.SelectTrack(*pLeader, !bIsSelected, true);
      }
 
      double value;
      // Shift-click, choose closest boundary
      SelectionBoundary boundary =
         ChooseBoundary(viewInfo, xx, event.m_y,
            pView.get(), mRect, false, false, &value);
      mSelectionBoundary = boundary;
      switch (boundary) {
         case SBLeft:
         case SBRight:
         {
#ifdef EXPERIMENTAL_SPECTRAL_EDITING
            // If drag starts, change time selection only
            // (also exit frequency snapping)
            mFreqSelMode = FREQ_SEL_INVALID;
#endif
            mSelStartValid = true;
            mSelStart = value;
            mSnapStart = SnapResults{};
            AdjustSelection(pProject, viewInfo, event.m_x, mRect.x, pTrack);
            break;
         }
#ifdef EXPERIMENTAL_SPECTRAL_EDITING
         case SBBottom:
         case SBTop:
         {
            mFreqSelTrack = pTrack->SharedPointer<const WaveTrack>();
            mFreqSelPin = value;
            mFreqSelMode =
               (boundary == SBBottom)
               ? FREQ_SEL_BOTTOM_FREE : FREQ_SEL_TOP_FREE;
 
            // Drag frequency only, not time:
            mSelStartValid = false;
            AdjustFreqSelection(
               static_cast<WaveTrack*>(pTrack),
               viewInfo, event.m_y, mRect.y, mRect.height);
            break;
         }
         case SBCenter:
         {
            const auto wt = static_cast<const WaveTrack*>(pTrack);
            HandleCenterFrequencyClick(viewInfo, true, wt, value);
            break;
         }
#endif
         default:
            wxASSERT(false);
      };
 
      // For persistence of the selection change:
      ProjectHistory::Get( *pProject ).ModifyState(false);
 
      // Get timer events so we can auto-scroll
      Connect(pProject);
 
      // Full refresh since the label area may need to indicate
      // newly selected tracks.
      return RefreshAll;
   }
 
   // II. Unmodified click starts a NEW selection
 
   //Make sure you are within the selected track
   bool startNewSelection = true;
   if (pTrack && pTrack->GetSelected()) {
      // Adjusting selection edges can be turned off in the
      // preferences now
      if (viewInfo.bAdjustSelectionEdges) {
#ifdef EXPERIMENTAL_SPECTRAL_EDITING
         if (mFreqSelMode == FREQ_SEL_SNAPPING_CENTER &&
            isSpectralSelectionView(pView.get())) {
            // This code is no longer reachable, but it had a place in the
            // spectral selection prototype.  It used to be that you could be
            // in a center-frequency-snapping mode that was not a mouse drag
            // but responded to mouse movements.  Click exited that and dragged
            // width instead.  PRL.
 
            // Ignore whether we are inside the time selection.
            // Exit center-snapping, start dragging the width.
            mFreqSelMode = FREQ_SEL_PINNED_CENTER;
            mFreqSelTrack = pTrack->SharedPointer<const WaveTrack>();
            mFreqSelPin = viewInfo.selectedRegion.fc();
            // Do not adjust time boundaries
            mSelStartValid = false;
            AdjustFreqSelection(
               static_cast<WaveTrack*>(pTrack),
               viewInfo, event.m_y, mRect.y, mRect.height);
            // For persistence of the selection change:
            ProjectHistory::Get( *pProject ).ModifyState(false);
            mSelectionBoundary = SBWidth;
            return RefreshNone;
         }
         else
#endif
         {
            // Not shift-down, choose boundary only within snapping
            double value;
            SelectionBoundary boundary =
               ChooseBoundary(viewInfo, xx, event.m_y,
                  pView.get(), mRect, true, true, &value);
            mSelectionBoundary = boundary;
            switch (boundary) {
            case SBNone:
               // startNewSelection remains true
               break;
            case SBLeft:
            case SBRight:
               startNewSelection = false;
#ifdef EXPERIMENTAL_SPECTRAL_EDITING
               // Disable frequency selection
               mFreqSelMode = FREQ_SEL_INVALID;
#endif
               mSelStartValid = true;
               mSelStart = value;
               mSnapStart = SnapResults{};
               break;
#ifdef EXPERIMENTAL_SPECTRAL_EDITING
            case SBBottom:
            case SBTop:
            case SBWidth:
               startNewSelection = false;
               // Disable time selection
               mSelStartValid = false;
               mFreqSelTrack = pTrack->SharedPointer<const WaveTrack>();
               mFreqSelPin = value;
               mFreqSelMode =
                  (boundary == SBWidth) ? FREQ_SEL_PINNED_CENTER :
                  (boundary == SBBottom) ? FREQ_SEL_BOTTOM_FREE :
                  FREQ_SEL_TOP_FREE;
               break;
            case SBCenter:
            {
               const auto wt = static_cast<const WaveTrack*>(pTrack);
               HandleCenterFrequencyClick(viewInfo, false, wt, value);
               startNewSelection = false;
               break;
            }
#endif
            default:
               wxASSERT(false);
            }
         }
      } // bAdjustSelectionEdges
   }
 
   // III. Common case for starting a NEW selection
 
   if (startNewSelection) {
      // If we didn't move a selection boundary, start a NEW selection
      selectionState.SelectNone(trackList);
#ifdef EXPERIMENTAL_SPECTRAL_EDITING
      StartFreqSelection (viewInfo, event.m_y, mRect.y, mRect.height,
         pView.get());
#endif
      StartSelection(pProject);
      if (pLeader)
         selectionState.SelectTrack(*pLeader, true, true);
      TrackFocus::Get(*pProject).Set(pTrack);
 
      Connect(pProject);
      return RefreshAll;
   }
   else {
      Connect(pProject);
      return RefreshAll;
   }
}

References AdjustFreqSelection(), AdjustSelection(), Cancelled, anonymous_namespace{SelectHandle.cpp}::ChooseBoundary(), Connect(), SelectUtilities::DoListSelection(), TrackPanelMouseEvent::event, FindTrack(), FREQ_SEL_BOTTOM_FREE, FREQ_SEL_INVALID, FREQ_SEL_PINNED_CENTER, FREQ_SEL_SNAPPING_CENTER, FREQ_SEL_TOP_FREE, TrackFocus::Get(), ProjectAudioIO::Get(), ProjectHistory::Get(), ViewInfo::Get(), SelectionState::Get(), SyncLockState::Get(), TrackList::Get(), TrackPanel::Get(), WaveTrack::GetClipAtTime(), HandleCenterFrequencyClick(), ProjectAudioIO::IsAudioActive(), anonymous_namespace{SelectHandle.cpp}::isSpectralSelectionView(), SyncLockState::IsSyncLocked(), mFreqSelPin, mFreqSelTrack, mInitialSelection, mMostRecentX, mMostRecentY, ProjectHistory::ModifyState(), mpView, mRect, mSelectionBoundary, mSelectionStateChanger, mSelStart, mSelStartValid, mSnapStart, mUseSnap, SnapResults::outTime, RefreshCode::RefreshAll, RefreshCode::RefreshNone, anonymous_namespace{SelectHandle.cpp}::SBLeft, anonymous_namespace{SelectHandle.cpp}::SBNone, anonymous_namespace{SelectHandle.cpp}::SBRight, SelectionState::SelectTrackLength(), StartFreqSelection(), StartSelection(), and SnapResults::timeSnappedTime.

Here is the call graph for this function:

◆ Connect()

void SelectHandle::Connect ( AudacityProject * pProject )

private

Definition at line 1064 of file SelectHandle.cpp.

{
   mTimerHandler = std::make_shared<TimerHandler>( this, pProject );
}

References mTimerHandler.

Referenced by Click().

Here is the caller graph for this function:

◆ Drag()

UIHandle::Result SelectHandle::Drag	(	const TrackPanelMouseEvent &	event,
		AudacityProject *	pProject
	)

overridevirtual

AS: If we're dragging to adjust a selection (or actually, if the screen is scrolling while you're selecting), we handle it here.

Implements UIHandle.

Definition at line 798 of file SelectHandle.cpp.

{
   using namespace RefreshCode;
 
   const auto pView = mpView.lock();
   if ( !pView )
      return Cancelled;
 
   auto &viewInfo = ViewInfo::Get( *pProject );
   const wxMouseEvent &event = evt.event;
 
   int x = mAutoScrolling ? mMostRecentX : event.m_x;
   int y = mAutoScrolling ? mMostRecentY : event.m_y;
   mMostRecentX = x;
   mMostRecentY = y;
 
 
   // Fuhggeddaboudit if we're not dragging and not autoscrolling.
   if (!event.Dragging() && !mAutoScrolling)
      return RefreshNone;
 
   if (event.CmdDown()) {
      // Ctrl-drag has no meaning, fuhggeddaboudit
      // JKC YES it has meaning.
      //return RefreshNone;
   }
 
   // Also fuhggeddaboudit if not in a track.
   auto pTrack = TrackList::Get( *pProject ).Lock( FindTrack() );
   if (!pTrack)
      return RefreshNone;
 
   // JKC: Logic to prevent a selection smaller than 5 pixels to
   // prevent accidental dragging when selecting.
   // (if user really wants a tiny selection, they should zoom in).
   // Can someone make this value of '5' configurable in
   // preferences?
   enum { minimumSizedSelection = 5 }; //measured in pixels
 
   // Might be dragging frequency bounds only, test
   if (mSelStartValid) {
      wxInt64 SelStart = viewInfo.TimeToPosition(mSelStart, mRect.x); //cvt time to pixels.
      // Abandon this drag if selecting < 5 pixels.
      if (wxLongLong(SelStart - x).Abs() < minimumSizedSelection)
         return RefreshNone;
   }
 
   if (evt.pCell) {
      if ( auto clickedTrack =
          static_cast<CommonTrackPanelCell*>(evt.pCell.get())->FindTrack() ) {
         // Handle which tracks are selected
         Track *sTrack = pTrack.get();
         Track *eTrack = clickedTrack.get();
         auto &trackList = TrackList::Get( *pProject );
         if ( sTrack && eTrack && !event.ControlDown() ) {
            auto &selectionState = SelectionState::Get( *pProject );
            selectionState.SelectRangeOfTracks( trackList, *sTrack, *eTrack );
         }
 
   #ifdef EXPERIMENTAL_SPECTRAL_EDITING
   #ifndef SPECTRAL_EDITING_ESC_KEY
         if (mFreqSelMode == FREQ_SEL_SNAPPING_CENTER &&
             !viewInfo.selectedRegion.isPoint())
            MoveSnappingFreqSelection
            (pProject, viewInfo, y, mRect.y, mRect.height, pView.get());
         else
   #endif
            if ( TrackList::Get( *pProject ).Lock(mFreqSelTrack) == pTrack )
               AdjustFreqSelection(
                  static_cast<WaveTrack*>(pTrack.get()),
                  viewInfo, y, mRect.y, mRect.height);
   #endif
         
         AdjustSelection(pProject, viewInfo, x, mRect.x, clickedTrack.get());
      }
   }
 
   return RefreshNone
 
      // If scrubbing does not use the helper poller thread, then
      // don't refresh at every mouse event, because it slows down seek-scrub.
      // Instead, let OnTimer do it, which is often enough.
      // And even if scrubbing does use the thread, then skipping refresh does not
      // bring that advantage, but it is probably still a good idea anyway.
 
      // | UpdateSelection
 
   ;
}

References AdjustFreqSelection(), AdjustSelection(), Cancelled, TrackPanelMouseEvent::event, CommonTrackPanelCell::FindTrack(), FindTrack(), FREQ_SEL_SNAPPING_CENTER, ViewInfo::Get(), SelectionState::Get(), TrackList::Get(), TrackList::Lock(), mAutoScrolling, mFreqSelTrack, mMostRecentX, mMostRecentY, MoveSnappingFreqSelection(), mpView, mRect, mSelStart, mSelStartValid, TrackPanelMouseEvent::pCell, and RefreshCode::RefreshNone.

Referenced by SelectHandle::TimerHandler::OnTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Draw()

void SelectHandle::Draw	(	TrackPanelDrawingContext &	context,
		const wxRect &	rect,
		unsigned	iPass
	)

overrideprivatevirtual

Reimplemented from TrackPanelDrawable.

Definition at line 1030 of file SelectHandle.cpp.

{
   if ( iPass == TrackArtist::PassSnapping ) {
      auto &dc = context.dc;
      // Draw snap guidelines if we have any
      if ( mSnapManager ) {
         auto coord1 = (mUseSnap || IsDragging()) ? mSnapStart.outCoord : -1;
         auto coord2 = (!mUseSnap || !IsDragging()) ? -1 : mSnapEnd.outCoord;
         TrackArt::DrawSnapLines(&dc, coord1, coord2);
      }
   }
}

References TrackPanelDrawingContext::dc, TrackArt::DrawSnapLines(), IsDragging(), mSnapEnd, mSnapManager, mSnapStart, mUseSnap, SnapResults::outCoord, and TrackArtist::PassSnapping.

Here is the call graph for this function:

◆ DrawingArea()

wxRect SelectHandle::DrawingArea	(	TrackPanelDrawingContext &	,
		const wxRect &	rect,
		const wxRect &	panelRect,
		unsigned	iPass
	)

overrideprivatevirtual

Reimplemented from TrackPanelDrawable.

Definition at line 1045 of file SelectHandle.cpp.

{
   if ( iPass == TrackArtist::PassSnapping )
      return MaximizeHeight( rect, panelRect );
   else
      return rect;
}

References TrackPanelDrawable::MaximizeHeight(), and TrackArtist::PassSnapping.

Here is the call graph for this function:

◆ Enter()

void SelectHandle::Enter	(	bool	forward,
		AudacityProject *	pProject
	)

overridevirtual

Reimplemented from UIHandle.

Definition at line 488 of file SelectHandle.cpp.

{
   SetUseSnap(true, project);
}

References project, and SetUseSnap().

Here is the call graph for this function:

◆ Escape()

bool SelectHandle::Escape ( AudacityProject * pProject )

overridevirtual

Reimplemented from UIHandle.

Definition at line 522 of file SelectHandle.cpp.

{
   if (SelectHandle::HasEscape(project)) {
      SetUseSnap(false, project);
      return true;
   }
   return false;
}

References HasEscape(), project, and SetUseSnap().

Here is the call graph for this function:

◆ FindChannel()

std::shared_ptr< const Channel > SelectHandle::FindChannel ( ) const

overridevirtual

Returns: pointer to associated channel, if any

Implements UIHandle.

Definition at line 462 of file SelectHandle.cpp.

{
   if (auto pView = mpView.lock())
      return pView->FindChannel();
   return nullptr;
}

References mpView.

◆ FindTrack()

std::weak_ptr< Track > SelectHandle::FindTrack ( )

private

Definition at line 1055 of file SelectHandle.cpp.

{
   auto pView = mpView.lock();
   if (!pView)
      return {};
   else
      return pView->FindTrack();
}

References mpView.

Referenced by AdjustSelection(), Click(), Drag(), SelectHandle::TimerHandler::OnTimer(), and Preview().

Here is the caller graph for this function:

◆ HandleCenterFrequencyClick()

void SelectHandle::HandleCenterFrequencyClick	(	const ViewInfo &	viewInfo,
		bool	shiftDown,
		const WaveTrack *	pTrack,
		double	value
	)

private

Definition at line 1338 of file SelectHandle.cpp.

{
   if (shiftDown) {
      // Disable time selection
      mSelStartValid = false;
      mFreqSelTrack = pTrack->SharedPointer<const WaveTrack>();
      mFreqSelPin = value;
      mFreqSelMode = FREQ_SEL_DRAG_CENTER;
   }
   else {
#ifndef SPECTRAL_EDITING_ESC_KEY
      // Start center snapping
      // Turn center snapping on (the only way to do this)
      mFreqSelMode = FREQ_SEL_SNAPPING_CENTER;
      // Disable time selection
      mSelStartValid = false;
      mFrequencySnapper = std::make_shared<SpectrumAnalyst>();
      StartSnappingFreqSelection(*mFrequencySnapper, viewInfo, pTrack);
#endif
   }
}

References FREQ_SEL_DRAG_CENTER, FREQ_SEL_SNAPPING_CENTER, mFreqSelPin, mFreqSelTrack, mFrequencySnapper, mSelStartValid, Track::SharedPointer(), and StartSnappingFreqSelection().

Referenced by Click().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasEscape()

bool SelectHandle::HasEscape ( AudacityProject * pProject ) const

overridevirtual

Reimplemented from UIHandle.

Definition at line 517 of file SelectHandle.cpp.

{
   return HasSnap() && mUseSnap;
}

References HasSnap(), and mUseSnap.

Referenced by Escape(), and Preview().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasSnap()

bool SelectHandle::HasSnap ( ) const

Definition at line 511 of file SelectHandle.cpp.

{
   return
      (IsDragging() ? mSnapEnd : mSnapStart).snappedPoint;
}

References IsDragging(), mSnapEnd, and mSnapStart.

Referenced by HasEscape(), Preview(), and SetUseSnap().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HitTest()

UIHandlePtr SelectHandle::HitTest	(	std::weak_ptr< SelectHandle > &	holder,
		const TrackPanelMouseState &	state,
		const AudacityProject *	pProject,
		const std::shared_ptr< ChannelView > &	pChannelView
	)

static

Definition at line 365 of file SelectHandle.cpp.

{
   // This handle is a little special because there may be some state to
   // preserve during movement before the click.
   auto old = holder.lock();
   bool oldUseSnap = true;
   if (old) {
      // It should not have started listening to timer events
      if( old->mTimerHandler ) {
         wxASSERT(false);
         // Handle this eventuality anyway, don't leave a dangling back-pointer
         // in the attached event handler.
         old->mTimerHandler.reset();
      }
      oldUseSnap = old->mUseSnap;
   }
 
   const auto &viewInfo = ViewInfo::Get( *pProject );
   auto result = std::make_shared<SelectHandle>(
      pChannelView, oldUseSnap, TrackList::Get(*pProject), st, viewInfo);
 
   result = AssignUIHandlePtr(holder, result);
 
   //Make sure we are within the selected track
   // Adjusting the selection edges can be turned off in
   // the preferences...
   auto pTrack = pChannelView->FindTrack();
   if (!pTrack->GetSelected() || !viewInfo.bAdjustSelectionEdges)
   {
      return result;
   }
 
   {
      const wxRect &rect = st.rect;
      wxInt64 leftSel = viewInfo.TimeToPosition(viewInfo.selectedRegion.t0(), rect.x);
      wxInt64 rightSel = viewInfo.TimeToPosition(viewInfo.selectedRegion.t1(), rect.x);
      // Something is wrong if right edge comes before left edge
      wxASSERT(!(rightSel < leftSel));
      static_cast<void>(leftSel); // Suppress unused variable warnings if not in debug-mode
      static_cast<void>(rightSel);
   }
 
   return result;
}

References AssignUIHandlePtr(), ViewInfo::Get(), TrackList::Get(), and TrackPanelMouseState::rect.

Referenced by CommonChannelView::HitTest(), NoteTrackAffordanceControls::HitTest(), and WaveTrackAffordanceControls::HitTest().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsDragging()

bool SelectHandle::IsDragging ( ) const

overridevirtual

Whether the handle is dragging, affecting other panel painting; default returns false

Reimplemented from UIHandle.

Definition at line 59 of file SelectHandle.cpp.

{
   return mSelectionStateChanger.get() != NULL;
}

References mSelectionStateChanger.

Referenced by Draw(), HasSnap(), Preview(), and SetUseSnap().

Here is the caller graph for this function:

◆ MoveSnappingFreqSelection()

void SelectHandle::MoveSnappingFreqSelection	(	AudacityProject *	pProject,
		ViewInfo &	viewInfo,
		int	mouseYCoordinate,
		int	trackTopEdge,
		int	trackHeight,
		ChannelView *	pChannelView
	)

private

Definition at line 1404 of file SelectHandle.cpp.

{
   auto pTrack = pChannelView->FindTrack().get();
   if (pTrack &&
      pTrack->GetSelected() &&
      isSpectralSelectionView(pChannelView)) {
      // Spectral selection track is always wave
      WaveTrack *const wt = static_cast<WaveTrack*>(pTrack);
      // PRL:
      // What would happen if center snapping selection began in one spectrogram track,
      // then continues inside another?  We do not then recalculate
      // the spectrum (as was done in StartSnappingFreqSelection)
      // but snap according to the peaks in the old track.
 
      // But if we always supply the original clicked track here that doesn't matter.
      const double rate = wt->GetRate();
      const double frequency =
         PositionToFrequency(wt, false, mouseYCoordinate,
         trackTopEdge, trackHeight);
      const double snappedFrequency =
         mFrequencySnapper->FindPeak(frequency, NULL);
      const double maxRatio = findMaxRatio(snappedFrequency, rate);
      double ratio = 2.0; // An arbitrary octave on each side, at most
      {
         const double f0 = viewInfo.selectedRegion.f0();
         const double f1 = viewInfo.selectedRegion.f1();
         if (f1 >= f0 && f0 >= 0)
            // Preserve already chosen ratio instead
            ratio = sqrt(f1 / f0);
      }
      ratio = std::min(ratio, maxRatio);
 
      mFreqSelPin = snappedFrequency;
      viewInfo.selectedRegion.setFrequencies(
         snappedFrequency / ratio, snappedFrequency * ratio);
 
      // A change here would affect what AdjustFreqSelection() does
      // in the prototype version where you switch from moving center to
      // dragging width with a click.  No effect now.
      mFreqSelTrack = wt->SharedPointer<const WaveTrack>();
 
      // SelectNone();
      // SelectTrack(pTrack, true);
      TrackFocus::Get( *pProject ).Set(pTrack);
   }
}

References NotifyingSelectedRegion::f0(), NotifyingSelectedRegion::f1(), anonymous_namespace{SelectHandle.cpp}::findMaxRatio(), CommonTrackPanelCell::FindTrack(), TrackFocus::Get(), WaveTrack::GetRate(), anonymous_namespace{SelectHandle.cpp}::isSpectralSelectionView(), mFreqSelPin, mFreqSelTrack, mFrequencySnapper, min(), anonymous_namespace{SelectHandle.cpp}::PositionToFrequency(), ViewInfo::selectedRegion, NotifyingSelectedRegion::setFrequencies(), Track::SharedPointer(), and staffpad::audio::simd::sqrt().

Referenced by Drag().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NeedChangeHighlight()

UIHandle::Result SelectHandle::NeedChangeHighlight	(	const SelectHandle &	oldState,
		const SelectHandle &	newState
	)

static

Definition at line 413 of file SelectHandle.cpp.

{
   auto useSnap = oldState.mUseSnap;
   // This is guaranteed when constructing the NEW handle:
   wxASSERT( useSnap == newState.mUseSnap );
   if (!useSnap)
      return 0;
 
   auto &oldSnapState = oldState.mSnapStart;
   auto &newSnapState = newState.mSnapStart;
   if ( oldSnapState.Snapped() == newSnapState.Snapped() &&
        (!oldSnapState.Snapped() ||
         oldSnapState.outCoord == newSnapState.outCoord) )
      return 0;
 
   return RefreshCode::RefreshAll;
}

References mSnapStart, mUseSnap, and RefreshCode::RefreshAll.

◆ operator=()

SelectHandle & SelectHandle::operator= ( const SelectHandle & )

default

◆ Preview()

HitTestPreview SelectHandle::Preview	(	const TrackPanelMouseState &	state,
		AudacityProject *	pProject
	)

overridevirtual

Implements UIHandle.

Definition at line 892 of file SelectHandle.cpp.

{
   if (!HasSnap() && !mUseSnap)
      // Moved out of snapping; revert to un-escaped state
      mUseSnap = true;
 
   const auto pView = mpView.lock();
   if ( !pView )
      return {};
 
   auto pTrack = FindTrack().lock();
   if (!pTrack)
      return {};
 
   TranslatableString tip;
   wxCursor *pCursor = SelectCursor();
   if (IsDragging())
      // Use same cursor as at the click
      SetTipAndCursorForBoundary
         (SelectionBoundary(mSelectionBoundary),
          (mFreqSelMode == FREQ_SEL_SNAPPING_CENTER),
          tip, pCursor);
   else {
      // Choose one of many cursors for mouse-over
 
      auto &viewInfo = ViewInfo::Get( *pProject );
 
      auto &state = st.state;
      auto time = mUseSnap ? mSnapStart.outTime : mSnapStart.timeSnappedTime;
      auto xx = viewInfo.TimeToPosition(time, mRect.x);
 
      const bool bMultiToolMode =
         (ToolCodes::multiTool == ProjectSettings::Get( *pProject ).GetTool());
 
      //In Multi-tool mode, give multitool prompt if no-special-hit.
      if (bMultiToolMode) {
         // Look up the current key binding for Preferences.
         // (Don't assume it's the default!)
         auto keyStr =
            CommandManager::Get( *pProject ).GetKeyFromName(wxT("Preferences"))
            .Display( true );
         if (keyStr.empty())
            // No keyboard preference defined for opening Preferences dialog
            /* i18n-hint: These are the names of a menu and a command in that menu */
            keyStr = _("Edit, Preferences...");
         
         /* i18n-hint: %s is usually replaced by "Ctrl+P" for Windows/Linux, "Command+," for Mac */
         tip = XO("Multi-Tool Mode: %s for Mouse and Keyboard Preferences.")
            .Format( keyStr );
         // Later in this function we may point to some other string instead.
         if (!pTrack->GetSelected() ||
             !viewInfo.bAdjustSelectionEdges)
            ;
         else {
            const wxRect &rect = st.rect;
            const bool bShiftDown = state.ShiftDown();
            const bool bCtrlDown = state.ControlDown();
            const bool bModifierDown = bShiftDown || bCtrlDown;
 
            // If not shift-down and not snapping center, then
            // choose boundaries only in snapping tolerance,
            // and may choose center.
            SelectionBoundary boundary =
            ChooseBoundary(viewInfo, xx, state.m_y,
               pView.get(), rect, !bModifierDown, !bModifierDown);
 
            SetTipAndCursorForBoundary(boundary, !bShiftDown, tip, pCursor);
         }
      }
 
#if 0
      // This is a vestige of an idea in the prototype version.
      // Center would snap without mouse button down, click would pin the center
      // and drag width.
#ifdef EXPERIMENTAL_SPECTRAL_EDITING
      if ((mFreqSelMode == FREQ_SEL_SNAPPING_CENTER) &&
         isSpectralSelectionView(pView)) {
         // Not shift-down, but center frequency snapping toggle is on
         tip = XO("Click and drag to set frequency bandwidth.");
         pCursor = &*envelopeCursor;
         return {};
      }
#endif
#endif
 
      if (!pTrack->GetSelected() || !viewInfo.bAdjustSelectionEdges)
         ;
      else {
         const wxRect &rect = st.rect;
         const bool bShiftDown = state.ShiftDown();
         const bool bCtrlDown = state.ControlDown();
         const bool bModifierDown = bShiftDown || bCtrlDown;
         SelectionBoundary boundary = ChooseBoundary(
            viewInfo, xx, state.m_y,
               pView.get(), rect, !bModifierDown, !bModifierDown);
         SetTipAndCursorForBoundary(boundary, !bShiftDown, tip, pCursor);
      }
   }
   if (tip.empty()) {
      tip = XO("Click and drag to select audio");
   }
   if (HasEscape(pProject) && mUseSnap) {
      tip.Join(
/* i18n-hint: "Snapping" means automatic alignment of selection edges to any nearby label or clip boundaries */
        XO("(snapping)"), wxT(" ")
      );
   }
   return { tip, pCursor };
}

References _, anonymous_namespace{SelectHandle.cpp}::ChooseBoundary(), NormalizedKeyString::Display(), TranslatableString::empty(), FindTrack(), FREQ_SEL_SNAPPING_CENTER, CommandManager::Get(), ViewInfo::Get(), ProjectSettings::Get(), CommandManager::GetKeyFromName(), ProjectSettings::GetTool(), HasEscape(), HasSnap(), IsDragging(), anonymous_namespace{SelectHandle.cpp}::isSpectralSelectionView(), TranslatableString::Join(), mpView, mRect, mSelectionBoundary, mSnapStart, ToolCodes::multiTool, mUseSnap, SnapResults::outTime, TrackPanelMouseState::rect, anonymous_namespace{SelectHandle.cpp}::SelectCursor(), anonymous_namespace{SelectHandle.cpp}::SetTipAndCursorForBoundary(), TrackPanelMouseState::state, SnapResults::timeSnappedTime, wxT(), and XO().

Here is the call graph for this function:

◆ Release()

UIHandle::Result SelectHandle::Release	(	const TrackPanelMouseEvent &	event,
		AudacityProject *	pProject,
		wxWindow *	pParent
	)

overridevirtual

Implements UIHandle.

Definition at line 1003 of file SelectHandle.cpp.

{
   using namespace RefreshCode;
   ProjectHistory::Get( *pProject ).ModifyState(false);
   mFrequencySnapper.reset();
   mSnapManager.reset();
   if (mSelectionStateChanger) {
      mSelectionStateChanger->Commit();
      mSelectionStateChanger.reset();
   }
   
   if (mUseSnap && (mSnapStart.outCoord != -1 || mSnapEnd.outCoord != -1))
      return RefreshAll;
   else
      return RefreshNone;
}

References ProjectHistory::Get(), mFrequencySnapper, ProjectHistory::ModifyState(), mSelectionStateChanger, mSnapEnd, mSnapManager, mSnapStart, mUseSnap, SnapResults::outCoord, RefreshCode::RefreshAll, and RefreshCode::RefreshNone.

Here is the call graph for this function:

◆ SetUseSnap()

void SelectHandle::SetUseSnap	(	bool	use,
		AudacityProject *	pProject
	)

Definition at line 493 of file SelectHandle.cpp.

{
   mUseSnap = use;
 
   bool hasSnap = HasSnap();
   if (hasSnap)
      // Repaint to turn the snap lines on or off
      mChangeHighlight = RefreshCode::RefreshAll;
 
   if (IsDragging()) {
      // Readjust the moving selection end
      AssignSelection(
         ViewInfo::Get( *project ),
         mUseSnap ? mSnapEnd.outTime : mSnapEnd.timeSnappedTime,
         nullptr);
   }
}

References AssignSelection(), ViewInfo::Get(), HasSnap(), IsDragging(), UIHandle::mChangeHighlight, mSnapEnd, mUseSnap, SnapResults::outTime, project, RefreshCode::RefreshAll, and SnapResults::timeSnappedTime.

Referenced by Enter(), and Escape().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SnapCenterOnce()

void SelectHandle::SnapCenterOnce	(	SpectrumAnalyst &	analyst,
		ViewInfo &	viewInfo,
		const WaveTrack *	pTrack,
		bool	up
	)

static

Definition at line 1454 of file SelectHandle.cpp.

{
   const auto &settings = SpectrogramSettings::Get(*pTrack);
   const auto windowSize = settings.GetFFTLength();
   const double rate = pTrack->GetRate();
   const double nyq = rate / 2.0;
   const double binFrequency = rate / windowSize;
 
   double f1 = viewInfo.selectedRegion.f1();
   double centerFrequency = viewInfo.selectedRegion.fc();
   if (centerFrequency <= 0) {
      centerFrequency = up ? binFrequency : nyq;
      f1 = centerFrequency * sqrt(2.0);
   }
 
   double ratio = f1 / centerFrequency;
   const int originalBin = floor(0.5 + centerFrequency / binFrequency);
   const int limitingBin = up ? floor(0.5 + nyq / binFrequency) : 1;
 
   // This is crude and wasteful, doing the FFT each time the command is called.
   // It would be better to cache the data, but then invalidation of the cache would
   // need doing in all places that change the time selection.
   StartSnappingFreqSelection(analyst, viewInfo, pTrack);
   double snappedFrequency = centerFrequency;
   int bin = originalBin;
   if (up) {
      while (snappedFrequency <= centerFrequency &&
         bin < limitingBin)
         snappedFrequency = analyst.FindPeak(++bin * binFrequency, NULL);
   }
   else {
      while (snappedFrequency >= centerFrequency &&
         bin > limitingBin)
         snappedFrequency = analyst.FindPeak(--bin * binFrequency, NULL);
   }
 
   // PRL:  added these two lines with the big TrackPanel refactor
   const double maxRatio = findMaxRatio(snappedFrequency, rate);
   ratio = std::min(ratio, maxRatio);
 
   viewInfo.selectedRegion.setFrequencies
      (snappedFrequency / ratio, snappedFrequency * ratio);
}

References NotifyingSelectedRegion::f1(), NotifyingSelectedRegion::fc(), anonymous_namespace{SelectHandle.cpp}::findMaxRatio(), SpectrumAnalyst::FindPeak(), SpectrogramSettings::Get(), WaveTrack::GetRate(), min(), ViewInfo::selectedRegion, NotifyingSelectedRegion::setFrequencies(), settings(), staffpad::audio::simd::sqrt(), and StartSnappingFreqSelection().

Here is the call graph for this function:

◆ StartFreqSelection()

void SelectHandle::StartFreqSelection	(	ViewInfo &	viewInfo,
		int	mouseYCoordinate,
		int	trackTopEdge,
		int	trackHeight,
		ChannelView *	pChannelView
	)

private

Definition at line 1235 of file SelectHandle.cpp.

{
   mFreqSelTrack.reset();
   mFreqSelMode = FREQ_SEL_INVALID;
   mFreqSelPin = SelectedRegion::UndefinedFrequency;
 
   if (isSpectralSelectionView(pChannelView)) {
      // Spectral selection track is always wave
      auto shTrack = pChannelView->FindTrack()->SharedPointer<const WaveTrack>();
      mFreqSelTrack = shTrack;
      mFreqSelMode = FREQ_SEL_FREE;
      mFreqSelPin =
         PositionToFrequency(shTrack.get(), false, mouseYCoordinate,
         trackTopEdge, trackHeight);
      viewInfo.selectedRegion.setFrequencies(mFreqSelPin, mFreqSelPin);
   }
}

References CommonTrackPanelCell::FindTrack(), FREQ_SEL_FREE, FREQ_SEL_INVALID, anonymous_namespace{SelectHandle.cpp}::isSpectralSelectionView(), mFreqSelPin, mFreqSelTrack, anonymous_namespace{SelectHandle.cpp}::PositionToFrequency(), ViewInfo::selectedRegion, NotifyingSelectedRegion::setFrequencies(), and SelectedRegion::UndefinedFrequency.

Referenced by Click().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StartSelection()

void SelectHandle::StartSelection ( AudacityProject * pProject )

private

Reset our selection markers.

Definition at line 1162 of file SelectHandle.cpp.

{
   auto &viewInfo = ViewInfo::Get( *pProject );
   mSelStartValid = true;
 
   viewInfo.selectedRegion.setTimes(mSelStart, mSelStart);
 
   // PRL:  commented out the Sonify stuff with the TrackPanel refactor.
   // It was no-op anyway.
   //SonifyBeginModifyState();
   ProjectHistory::Get( *pProject ).ModifyState(false);
   //SonifyEndModifyState();
}

References ProjectHistory::Get(), ViewInfo::Get(), ProjectHistory::ModifyState(), mSelStart, and mSelStartValid.

Referenced by Click().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StartSnappingFreqSelection()

void SelectHandle::StartSnappingFreqSelection	(	SpectrumAnalyst &	analyst,
		const ViewInfo &	viewInfo,
		const WaveTrack *	pTrack
	)

staticprivate

Definition at line 1361 of file SelectHandle.cpp.

{
   static const size_t minLength = 8;
 
   const double rate = pTrack->GetRate();
 
   // Grab samples, just for this track, at these times
   std::vector<float> frequencySnappingData;
   const auto start =
      pTrack->TimeToLongSamples(viewInfo.selectedRegion.t0());
   const auto end =
      pTrack->TimeToLongSamples(viewInfo.selectedRegion.t1());
   const auto length =
      std::min(frequencySnappingData.max_size(),
         limitSampleBufferSize(10485760, // as in FreqWindow.cpp
            end - start));
   const auto effectiveLength = std::max(minLength, length);
   frequencySnappingData.resize(effectiveLength, 0.0f);
   pTrack->GetFloats(
      &frequencySnappingData[0],
      start, length, FillFormat::fillZero,
      // Don't try to cope with exceptions, just read zeroes instead.
      false);
 
   // Use same settings as are now used for spectrogram display,
   // except, shrink the window as needed so we get some answers
 
   const auto &settings = SpectrogramSettings::Get(*pTrack);
   auto windowSize = settings.GetFFTLength();
 
   while(windowSize > effectiveLength)
      windowSize >>= 1;
   const int windowType = settings.windowType;
 
   analyst.Calculate(
      SpectrumAnalyst::Spectrum, windowType, windowSize, rate,
      &frequencySnappingData[0], length);
 
   // We can now throw away the sample data but we keep the spectrum.
}

References SpectrumAnalyst::Calculate(), PackedArray::end(), fillZero, SpectrogramSettings::Get(), WaveTrack::GetFloats(), WaveTrack::GetRate(), limitSampleBufferSize(), min(), ViewInfo::selectedRegion, settings(), SpectrumAnalyst::Spectrum, NotifyingSelectedRegion::t0(), NotifyingSelectedRegion::t1(), and WideSampleSequence::TimeToLongSamples().

Referenced by HandleCenterFrequencyClick(), and SnapCenterOnce().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ FREQ_SEL_INVALID

enum SelectHandle::eFreqSelMode SelectHandle::FREQ_SEL_INVALID

private

Referenced by AdjustFreqSelection(), Click(), and StartFreqSelection().

◆ mAutoScrolling

bool SelectHandle::mAutoScrolling {}

private

Definition at line 169 of file SelectHandle.h.

Referenced by Drag(), and SelectHandle::TimerHandler::OnTimer().

◆ mFreqSelPin

double SelectHandle::mFreqSelPin { -1.0 }

private

Definition at line 164 of file SelectHandle.h.

Referenced by AdjustFreqSelection(), Click(), HandleCenterFrequencyClick(), MoveSnappingFreqSelection(), and StartFreqSelection().

◆ mFreqSelTrack

std::weak_ptr<const WaveTrack> SelectHandle::mFreqSelTrack

private

Definition at line 157 of file SelectHandle.h.

Referenced by Click(), Drag(), HandleCenterFrequencyClick(), MoveSnappingFreqSelection(), and StartFreqSelection().

◆ mFrequencySnapper

std::shared_ptr<SpectrumAnalyst> SelectHandle::mFrequencySnapper

private

Definition at line 165 of file SelectHandle.h.

Referenced by HandleCenterFrequencyClick(), MoveSnappingFreqSelection(), and Release().

◆ mInitialSelection

SelectedRegion SelectHandle::mInitialSelection {}

private

Definition at line 135 of file SelectHandle.h.

Referenced by Cancel(), and Click().

◆ mMostRecentX

int SelectHandle::mMostRecentX { -1 }

private

Definition at line 167 of file SelectHandle.h.

Referenced by Click(), Drag(), and SelectHandle::TimerHandler::OnTimer().

◆ mMostRecentY

int SelectHandle::mMostRecentY { -1 }

private

Definition at line 167 of file SelectHandle.h.

Referenced by Click(), and Drag().

◆ mpView

std::weak_ptr<ChannelView> SelectHandle::mpView

private

Definition at line 133 of file SelectHandle.h.

Referenced by Click(), Drag(), FindChannel(), FindTrack(), and Preview().

◆ mRect

wxRect SelectHandle::mRect {}

private

Definition at line 134 of file SelectHandle.h.

Referenced by Click(), Drag(), SelectHandle::TimerHandler::OnTimer(), Preview(), and SelectHandle().

◆ mSelectionBoundary

int SelectHandle::mSelectionBoundary { 0 }

private

Definition at line 144 of file SelectHandle.h.

Referenced by Click(), and Preview().

◆ mSelectionStateChanger

std::shared_ptr<SelectionStateChanger> SelectHandle::mSelectionStateChanger

private

Definition at line 171 of file SelectHandle.h.

Referenced by Cancel(), Click(), IsDragging(), and Release().

◆ mSelStart

double SelectHandle::mSelStart { 0.0 }

private

Definition at line 142 of file SelectHandle.h.

Referenced by AdjustSelection(), AssignSelection(), Click(), Drag(), and StartSelection().

◆ mSelStartValid

bool SelectHandle::mSelStartValid {}

private

Definition at line 141 of file SelectHandle.h.

Referenced by AdjustSelection(), Click(), Drag(), HandleCenterFrequencyClick(), and StartSelection().

◆ mSnapEnd

SnapResults SelectHandle::mSnapEnd

private

Definition at line 138 of file SelectHandle.h.

Referenced by AdjustSelection(), Draw(), HasSnap(), Release(), and SetUseSnap().

◆ mSnapManager

std::shared_ptr<SnapManager> SelectHandle::mSnapManager

private

Definition at line 137 of file SelectHandle.h.

Referenced by AdjustSelection(), Draw(), Release(), and SelectHandle().

◆ mSnapStart

SnapResults SelectHandle::mSnapStart

private

Definition at line 138 of file SelectHandle.h.

Referenced by AdjustSelection(), Click(), Draw(), HasSnap(), NeedChangeHighlight(), Preview(), Release(), and SelectHandle().

◆ mTimerHandler

std::shared_ptr<TimerHandler> SelectHandle::mTimerHandler

private

Definition at line 175 of file SelectHandle.h.

Referenced by Connect().

◆ mUseSnap

bool SelectHandle::mUseSnap { true }

private

Definition at line 139 of file SelectHandle.h.

Referenced by AdjustSelection(), Click(), Draw(), HasEscape(), NeedChangeHighlight(), Preview(), Release(), SelectHandle(), and SetUseSnap().

◆ TimerHandler

friend SelectHandle::TimerHandler

private

Definition at line 174 of file SelectHandle.h.

The documentation for this class was generated from the following files:

Classes

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ eFreqSelMode

Constructor & Destructor Documentation

◆ SelectHandle() [1/2]

◆ SelectHandle() [2/2]

◆ ~SelectHandle()

Member Function Documentation

◆ AdjustFreqSelection()

◆ AdjustSelection()

◆ AssignSelection()

◆ Cancel()

◆ Click()

◆ Connect()

◆ Drag()

◆ Draw()

◆ DrawingArea()

◆ Enter()

◆ Escape()

◆ FindChannel()

◆ FindTrack()

◆ HandleCenterFrequencyClick()

◆ HasEscape()

◆ HasSnap()

◆ HitTest()

◆ IsDragging()

◆ MoveSnappingFreqSelection()

◆ NeedChangeHighlight()

◆ operator=()

◆ Preview()

◆ Release()

◆ SetUseSnap()

◆ SnapCenterOnce()

◆ StartFreqSelection()

◆ StartSelection()

◆ StartSnappingFreqSelection()

Member Data Documentation

◆ FREQ_SEL_INVALID

◆ mAutoScrolling

◆ mFreqSelPin

◆ mFreqSelTrack

◆ mFrequencySnapper

◆ mInitialSelection

◆ mMostRecentX

◆ mMostRecentY

◆ mpView

◆ mRect

◆ mSelectionBoundary

◆ mSelectionStateChanger

◆ mSelStart

◆ mSelStartValid

◆ mSnapEnd

◆ mSnapManager

◆ mSnapStart

◆ mTimerHandler

◆ mUseSnap

◆ TimerHandler