#include <StretchHandle.h>

Inheritance diagram for StretchHandle:

Collaboration diagram for StretchHandle:

Classes
struct	StretchState

Public Types
enum	StretchEnum { stretchNone = 0 , stretchLeft , stretchCenter , stretchRight }

Public Types inherited from UIHandle
using	Result = unsigned

using	Cell = TrackPanelCell

Public Member Functions
	StretchHandle (const std::shared_ptr< NoteTrack > &pTrack, const StretchState &stretchState)

StretchHandle &	operator= (const StretchHandle &)=default

virtual	~StretchHandle ()

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 *pProject) override

bool	StopsOnKeystroke () 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)

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< StretchHandle > &holder, const TrackPanelMouseState &state, const AudacityProject *pProject, const std::shared_ptr< NoteTrack > &pTrack)

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 Member Functions
	StretchHandle (const StretchHandle &)

void	Stretch (AudacityProject pProject, int mouseXCoordinate, int trackLeftEdge, Track pTrack)

Static Private Member Functions
static HitTestPreview	HitPreview (StretchEnum stretchMode, bool unsafe)

static double	GetT0 (const Track &track, const ViewInfo &viewInfo)

static double	GetT1 (const Track &track, const ViewInfo &viewInfo)

Private Attributes
std::shared_ptr< NoteTrack >	mpTrack {}

int	mLeftEdge { -1 }

StretchState	mStretchState {}

Additional Inherited Members
Protected Attributes inherited from UIHandle
Result	mChangeHighlight { 0 }

Detailed Description

Definition at line 21 of file StretchHandle.h.

Member Enumeration Documentation

◆ StretchEnum

enum StretchHandle::StretchEnum

Enumerator
stretchNone
stretchLeft
stretchCenter
stretchRight

Definition at line 24 of file StretchHandle.h.

                    {
      stretchNone = 0, // false value!
      stretchLeft,
      stretchCenter,
      stretchRight
   };

Constructor & Destructor Documentation

◆ StretchHandle() [1/2]

StretchHandle::StretchHandle ( const StretchHandle & )

private

◆ StretchHandle() [2/2]

StretchHandle::StretchHandle	(	const std::shared_ptr< NoteTrack > &	pTrack,
		const StretchState &	stretchState
	)

explicit

Definition at line 33 of file StretchHandle.cpp.

   : mpTrack{ pTrack }
   , mStretchState{ stretchState }
{}

◆ ~StretchHandle()

StretchHandle::~StretchHandle ( )

virtual

Definition at line 155 of file StretchHandle.cpp.

156{

157}

Member Function Documentation

◆ Cancel()

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

overridevirtual

Implements UIHandle.

Definition at line 267 of file StretchHandle.cpp.

{
   ProjectHistory::Get( *pProject ).RollbackState();
   return RefreshCode::RefreshNone;
}

References ProjectHistory::Get(), RefreshCode::RefreshNone, and ProjectHistory::RollbackState().

Referenced by Drag(), and Release().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Click()

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

overridevirtual

Implements UIHandle.

Definition at line 159 of file StretchHandle.cpp.

{
   using namespace RefreshCode;
   const bool unsafe = ProjectAudioIO::Get( *pProject ).IsAudioActive();
   if ( unsafe )
      return Cancelled;
 
   const wxMouseEvent &event = evt.event;
 
   if (event.LeftDClick() ||
       !event.LeftDown() ||
       evt.pCell == NULL)
      return Cancelled;
 
 
   mLeftEdge = evt.rect.GetLeft();
   auto &viewInfo = ViewInfo::Get( *pProject );
 
   viewInfo.selectedRegion.setTimes
      ( mStretchState.mBeat0.first, mStretchState.mBeat1.first );
 
   // Full refresh since the label area may need to indicate
   // newly selected tracks. (I'm really not sure if the label area
   // needs to be refreshed or how to just refresh non-label areas.-RBD)
 
   return RefreshAll;
}

References Cancelled, TrackPanelMouseEvent::event, ProjectAudioIO::Get(), ViewInfo::Get(), ProjectAudioIO::IsAudioActive(), StretchHandle::StretchState::mBeat0, StretchHandle::StretchState::mBeat1, mLeftEdge, mStretchState, TrackPanelMouseEvent::pCell, TrackPanelMouseEvent::rect, and RefreshCode::RefreshAll.

Here is the call graph for this function:

◆ Drag()

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

overridevirtual

Implements UIHandle.

Definition at line 188 of file StretchHandle.cpp.

{
   using namespace RefreshCode;
   const bool unsafe = ProjectAudioIO::Get( *pProject ).IsAudioActive();
   if (unsafe) {
      this->Cancel(pProject);
      return RefreshAll | Cancelled;
   }
 
   const wxMouseEvent &event = evt.event;
   const int x = event.m_x;
 
   Track *clickedTrack=nullptr;
   if (evt.pCell)
      clickedTrack =
         static_cast<CommonTrackPanelCell*>(evt.pCell.get())->FindTrack().get();
 
   if (clickedTrack == nullptr && mpTrack != nullptr)
      clickedTrack = mpTrack.get();
   Stretch(pProject, x, mLeftEdge, clickedTrack);
   return RefreshAll;
}

References Cancel(), Cancelled, TrackPanelMouseEvent::event, anonymous_namespace{TrackPanel.cpp}::FindTrack(), ProjectAudioIO::Get(), ProjectAudioIO::IsAudioActive(), mLeftEdge, mpTrack, TrackPanelMouseEvent::pCell, RefreshCode::RefreshAll, and Stretch().

Here is the call graph for this function:

◆ GetT0()

double StretchHandle::GetT0	(	const Track &	track,
		const ViewInfo &	viewInfo
	)

staticprivate

Definition at line 273 of file StretchHandle.cpp.

{
   return std::max(track.GetStartTime(), viewInfo.selectedRegion.t0());
}

References ChannelGroup::GetStartTime(), ViewInfo::selectedRegion, and NotifyingSelectedRegion::t0().

Referenced by HitTest().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetT1()

double StretchHandle::GetT1	(	const Track &	track,
		const ViewInfo &	viewInfo
	)

staticprivate

Definition at line 278 of file StretchHandle.cpp.

{
   return std::min(track.GetEndTime(), viewInfo.selectedRegion.t1());
}

References ChannelGroup::GetEndTime(), min(), ViewInfo::selectedRegion, and NotifyingSelectedRegion::t1().

Referenced by HitTest().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HitPreview()

HitTestPreview StretchHandle::HitPreview	(	StretchEnum	stretchMode,
		bool	unsafe
	)

staticprivate

Definition at line 39 of file StretchHandle.cpp.

{
   static auto disabledCursor =
      ::MakeCursor(wxCURSOR_NO_ENTRY, DisabledCursorXpm, 16, 16);
   static auto stretchLeftCursor =
      ::MakeCursor(wxCURSOR_BULLSEYE, StretchLeftCursorXpm, 16, 16);
   static auto stretchRightCursor =
      ::MakeCursor(wxCURSOR_BULLSEYE, StretchRightCursorXpm, 16, 16);
   static auto stretchCursor =
      ::MakeCursor(wxCURSOR_BULLSEYE, StretchCursorXpm, 16, 16);
 
   if (unsafe) {
      return { {}, &*disabledCursor };
   }
   else {
      wxCursor *pCursor = NULL;
      switch (stretchMode) {
      default:
         wxASSERT(false);
      case stretchLeft:
         pCursor = &*stretchLeftCursor; break;
      case stretchCenter:
         pCursor = &*stretchCursor; break;
      case stretchRight:
         pCursor = &*stretchRightCursor; break;
      }
      return {
         XO("Click and drag to stretch selected region."),
         pCursor
      };
   }
}

References MakeCursor(), stretchCenter, stretchLeft, stretchRight, and XO().

Referenced by Preview().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HitTest()

UIHandlePtr StretchHandle::HitTest	(	std::weak_ptr< StretchHandle > &	holder,
		const TrackPanelMouseState &	state,
		const AudacityProject *	pProject,
		const std::shared_ptr< NoteTrack > &	pTrack
	)

static

Definition at line 72 of file StretchHandle.cpp.

{
   StretchState stretchState;
   const wxMouseState &state = st.state;
 
   // later, we may want a different policy, but for now, stretch is
   // selected when the cursor is near the center of the track and
   // within the selection
   auto &viewInfo = ViewInfo::Get( *pProject );
 
   if (!pTrack || !pTrack->GetSelected())
      return {};
 
   const wxRect &rect = st.rect;
   int center = rect.y + rect.height / 2;
   int distance = abs(state.m_y - center);
   const int yTolerance = 10;
   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));
   if (!(leftSel <= state.m_x && state.m_x <= rightSel &&
         distance < yTolerance))
      return {};
 
   // find nearest beat to sel0, sel1
   static const double minPeriod = 0.05; // minimum beat period
   stretchState.mBeatCenter = { 0, 0 };
 
   auto t0 = GetT0(*pTrack, viewInfo);
   auto t1 = GetT1(*pTrack, viewInfo);
 
   if (t0 >= t1)
      return {};
 
   stretchState.mBeat0 = pTrack->NearestBeatTime( t0 );
   stretchState.mOrigSel0Quantized = stretchState.mBeat0.first;
 
   stretchState.mBeat1 = pTrack->NearestBeatTime( t1 );
   stretchState.mOrigSel1Quantized = stretchState.mBeat1.first;
 
   // If there is not (almost) a beat to stretch that is slower
   // than 20 beats per second, don't stretch
   if ( within( stretchState.mBeat0.second,
                stretchState.mBeat1.second, 0.9 ) ||
       ( stretchState.mBeat1.first - stretchState.mBeat0.first ) /
          ( stretchState.mBeat1.second - stretchState.mBeat0.second )
            < minPeriod )
      return {};
 
   auto selStart = viewInfo.PositionToTime( state.m_x, rect.x );
   selStart = std::max(t0, std::min(t1, selStart));
   stretchState.mBeatCenter = pTrack->NearestBeatTime( selStart );
   if ( within( stretchState.mBeat0.second,
                stretchState.mBeatCenter.second, 0.1 ) ) {
      stretchState.mMode = stretchLeft;
      stretchState.mLeftBeats = 0;
      stretchState.mRightBeats =
         stretchState.mBeat1.second - stretchState.mBeat0.second;
   }
   else if ( within( stretchState.mBeat1.second,
                     stretchState.mBeatCenter.second, 0.1 ) ) {
      stretchState.mMode = stretchRight;
      stretchState.mLeftBeats =
         stretchState.mBeat1.second - stretchState.mBeat0.second;
      stretchState.mRightBeats = 0;
   }
   else {
      stretchState.mMode = stretchCenter;
      stretchState.mLeftBeats =
         stretchState.mBeat1.second - stretchState.mBeatCenter.second;
      stretchState.mRightBeats =
         stretchState.mBeatCenter.second - stretchState.mBeat0.second;
   }
 
   auto result = std::make_shared<StretchHandle>( pTrack, stretchState );
   result = AssignUIHandlePtr(holder, result);
   return result;
}

Referenced by NoteTrackView::DetailedHitTest().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=()

StretchHandle & StretchHandle::operator= ( const StretchHandle & )

default

◆ Preview()

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

overridevirtual

Implements UIHandle.

Definition at line 212 of file StretchHandle.cpp.

{
   const bool unsafe = ProjectAudioIO::Get( *pProject ).IsAudioActive();
   return HitPreview( mStretchState.mMode, unsafe );
}

References ProjectAudioIO::Get(), HitPreview(), ProjectAudioIO::IsAudioActive(), StretchHandle::StretchState::mMode, and mStretchState.

Here is the call graph for this function:

◆ Release()

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

overridevirtual

Implements UIHandle.

Definition at line 219 of file StretchHandle.cpp.

{
   using namespace RefreshCode;
 
   const bool unsafe = ProjectAudioIO::Get( *pProject ).IsAudioActive();
   if (unsafe) {
      this->Cancel(pProject);
      return RefreshAll | Cancelled;
   }
 
   bool left = mStretchState.mMode == stretchLeft;
   bool right = mStretchState.mMode == stretchRight;
   auto &viewInfo = ViewInfo::Get( *pProject );
   if (SyncLockState::Get(*pProject).IsSyncLocked() && (left || right)) {
      for (auto track : SyncLock::Group(mpTrack.get())) {
         if (track != mpTrack.get()) {
            if (left) {
               auto origT0 = mStretchState.mOrigSel0Quantized;
               auto diff = viewInfo.selectedRegion.t0() - origT0;
               if (diff > 0)
                  track->SyncLockAdjust(origT0 + diff, origT0);
               else
                  track->SyncLockAdjust(origT0, origT0 - diff);
               track->ShiftBy(diff);
            }
            else {
               auto origT1 = mStretchState.mOrigSel1Quantized;
               auto diff = viewInfo.selectedRegion.t1() - origT1;
               track->SyncLockAdjust(origT1, origT1 + diff);
            }
         }
      }
   }
 
   /* i18n-hint: (noun) The track that is used for MIDI notes which can be
   dragged to change their duration.*/
   ProjectHistory::Get( *pProject ).PushState(XO("Stretch Note Track"),
      /* i18n-hint: In the history list, indicates a MIDI note has
      been dragged to change its duration (stretch it). Using either past
      or present tense is fine here.  If unsure, go for whichever is
      shorter.*/
      XO("Stretch"),
      UndoPush::CONSOLIDATE);
   return RefreshAll;
}

References Cancel(), Cancelled, CONSOLIDATE, ProjectAudioIO::Get(), ProjectHistory::Get(), ViewInfo::Get(), SyncLockState::Get(), SyncLock::Group(), ProjectAudioIO::IsAudioActive(), SyncLockState::IsSyncLocked(), StretchHandle::StretchState::mMode, StretchHandle::StretchState::mOrigSel0Quantized, StretchHandle::StretchState::mOrigSel1Quantized, mpTrack, mStretchState, ProjectHistory::PushState(), RefreshCode::RefreshAll, stretchLeft, stretchRight, and XO().

Here is the call graph for this function:

◆ StopsOnKeystroke()

bool StretchHandle::StopsOnKeystroke ( )

inlineoverridevirtual

Reimplemented from UIHandle.

Definition at line 87 of file StretchHandle.h.

87{ return true; }

◆ Stretch()

void StretchHandle::Stretch	(	AudacityProject *	pProject,
		int	mouseXCoordinate,
		int	trackLeftEdge,
		Track *	pTrack
	)

private

Definition at line 283 of file StretchHandle.cpp.

{
   auto &viewInfo = ViewInfo::Get( *pProject );
 
   if (pTrack == NULL && mpTrack != NULL)
      pTrack = mpTrack.get();
 
  if (pTrack) pTrack->TypeSwitch( [&](NoteTrack &nt) {
      double moveto =
        std::max(0.0, viewInfo.PositionToTime(mouseXCoordinate, trackLeftEdge));
 
      double dur, left_dur, right_dur;
 
      // check to make sure tempo is not higher than 20 beats per second
      // (In principle, tempo can be higher, but not infinity.)
      double minPeriod = 0.05; // minimum beat period
 
      // make sure target duration is not too short
      // Take quick exit if so, without changing the selection.
      auto t0 = mStretchState.mBeat0.first;
      auto t1 = mStretchState.mBeat1.first;
      switch ( mStretchState.mMode ) {
      case stretchLeft: {
         dur = t1 - moveto;
         if (dur < mStretchState.mRightBeats * minPeriod)
            return;
         nt.StretchRegion
            ( mStretchState.mBeat0, mStretchState.mBeat1, dur );
         nt.ShiftBy(moveto - t0);
         mStretchState.mBeat0.first = moveto;
         viewInfo.selectedRegion.setT0(moveto);
         break;
      }
      case stretchRight: {
         dur = moveto - t0;
         if (dur < mStretchState.mLeftBeats * minPeriod)
            return;
         nt.StretchRegion
            ( mStretchState.mBeat0, mStretchState.mBeat1, dur );
         viewInfo.selectedRegion.setT1(moveto);
         mStretchState.mBeat1.first = moveto;
         break;
      }
      case stretchCenter: {
         moveto = std::max(t0, std::min(t1, moveto));
         left_dur = moveto - t0;
         right_dur = t1 - moveto;
         if ( left_dur < mStretchState.mLeftBeats * minPeriod ||
              right_dur < mStretchState.mRightBeats * minPeriod )
            return;
         nt.StretchRegion
            ( mStretchState.mBeatCenter, mStretchState.mBeat1, right_dur );
         nt.StretchRegion
            ( mStretchState.mBeat0, mStretchState.mBeatCenter, left_dur );
         mStretchState.mBeatCenter.first = moveto;
         break;
      }
      default:
         wxASSERT(false);
         break;
      }
  });
}

References ViewInfo::Get(), StretchHandle::StretchState::mBeat0, StretchHandle::StretchState::mBeat1, StretchHandle::StretchState::mBeatCenter, min(), StretchHandle::StretchState::mLeftBeats, StretchHandle::StretchState::mMode, mpTrack, StretchHandle::StretchState::mRightBeats, mStretchState, ChannelGroup::ShiftBy(), stretchCenter, stretchLeft, NoteTrack::StretchRegion(), stretchRight, and Track::TypeSwitch().

Referenced by Drag().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ mLeftEdge

int StretchHandle::mLeftEdge { -1 }

private

Definition at line 97 of file StretchHandle.h.

Referenced by Click(), and Drag().

◆ mpTrack

std::shared_ptr<NoteTrack> StretchHandle::mpTrack {}

private

Definition at line 96 of file StretchHandle.h.

Referenced by Drag(), Release(), and Stretch().

◆ mStretchState

StretchState StretchHandle::mStretchState {}

private

Definition at line 99 of file StretchHandle.h.

Referenced by Click(), Preview(), Release(), and Stretch().

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ StretchEnum

Constructor & Destructor Documentation

◆ StretchHandle() [1/2]

◆ StretchHandle() [2/2]

◆ ~StretchHandle()

Member Function Documentation

◆ Cancel()

◆ Click()

◆ Drag()

◆ GetT0()

◆ GetT1()

◆ HitPreview()

◆ HitTest()

◆ operator=()

◆ Preview()

◆ Release()

◆ StopsOnKeystroke()

◆ Stretch()

Member Data Documentation

◆ mLeftEdge

◆ mpTrack

◆ mStretchState