Audacity 3.2.0
Classes | Public Types | Public Member Functions | Static Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
StretchHandle Class Reference

#include <StretchHandle.h>

Inheritance diagram for StretchHandle:
[legend]
Collaboration diagram for StretchHandle:
[legend]

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)
 
StretchHandleoperator= (const StretchHandle &)=default
 
virtual ~StretchHandle ()
 
std::shared_ptr< const ChannelFindChannel () const 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 *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)
 
virtual std::shared_ptr< const ChannelFindChannel () 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< 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< NoteTrackmpTrack {}
 
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

Enumerator
stretchNone 
stretchLeft 
stretchCenter 
stretchRight 

Definition at line 24 of file StretchHandle.h.

24 {
25 stretchNone = 0, // false value!
29 };

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.

35 : mpTrack{ pTrack }
36 , mStretchState{ stretchState }
37{}
StretchState mStretchState
std::shared_ptr< NoteTrack > mpTrack
Definition: StretchHandle.h:98

◆ ~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 272 of file StretchHandle.cpp.

273{
274 ProjectHistory::Get( *pProject ).RollbackState();
276}
static ProjectHistory & Get(AudacityProject &project)

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 164 of file StretchHandle.cpp.

166{
167 using namespace RefreshCode;
168 const bool unsafe = ProjectAudioIO::Get( *pProject ).IsAudioActive();
169 if ( unsafe )
170 return Cancelled;
171
172 const wxMouseEvent &event = evt.event;
173
174 if (event.LeftDClick() ||
175 !event.LeftDown() ||
176 evt.pCell == NULL)
177 return Cancelled;
178
179
180 mLeftEdge = evt.rect.GetLeft();
181 auto &viewInfo = ViewInfo::Get( *pProject );
182
183 viewInfo.selectedRegion.setTimes
184 ( mStretchState.mBeat0.first, mStretchState.mBeat1.first );
185
186 // Full refresh since the label area may need to indicate
187 // newly selected tracks. (I'm really not sure if the label area
188 // needs to be refreshed or how to just refresh non-label areas.-RBD)
189
190 return RefreshAll;
191}
bool IsAudioActive() const
static ProjectAudioIO & Get(AudacityProject &project)
static ViewInfo & Get(AudacityProject &project)
Definition: ViewInfo.cpp:235
Namespace containing an enum 'what to do on a refresh?'.
Definition: RefreshCode.h:16
QuantizedTimeAndBeat mBeat0
Definition: StretchHandle.h:45
QuantizedTimeAndBeat mBeat1
Definition: StretchHandle.h:46
std::shared_ptr< TrackPanelCell > pCell

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 193 of file StretchHandle.cpp.

195{
196 using namespace RefreshCode;
197 const bool unsafe = ProjectAudioIO::Get( *pProject ).IsAudioActive();
198 if (unsafe) {
199 this->Cancel(pProject);
200 return RefreshAll | Cancelled;
201 }
202
203 const wxMouseEvent &event = evt.event;
204 const int x = event.m_x;
205
206 Track *clickedTrack=nullptr;
207 if (evt.pCell)
208 clickedTrack =
209 static_cast<CommonTrackPanelCell*>(evt.pCell.get())->FindTrack().get();
210
211 if (clickedTrack == nullptr && mpTrack != nullptr)
212 clickedTrack = mpTrack.get();
213 Stretch(pProject, x, mLeftEdge, clickedTrack);
214 return RefreshAll;
215}
void Stretch(AudacityProject *pProject, int mouseXCoordinate, int trackLeftEdge, Track *pTrack)
Result Cancel(AudacityProject *pProject) override
Abstract base class for an object holding data associated with points on a time axis.
Definition: Track.h:122
std::shared_ptr< Track > FindTrack(TrackPanelCell *pCell)
Definition: TrackPanel.cpp:537

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:

◆ FindChannel()

std::shared_ptr< const Channel > StretchHandle::FindChannel ( ) const
overridevirtual
Returns
pointer to associated channel, if any

Implements UIHandle.

Definition at line 159 of file StretchHandle.cpp.

160{
161 return mpTrack;
162}

References mpTrack.

◆ GetT0()

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

Definition at line 278 of file StretchHandle.cpp.

279{
280 return std::max(track.GetStartTime(), viewInfo.selectedRegion.t0());
281}
double GetStartTime() const
Get the minimum of Start() values of intervals, or 0 when none.
Definition: Channel.cpp:124
double t0() const
Definition: ViewInfo.h:35
NotifyingSelectedRegion selectedRegion
Definition: ViewInfo.h:215

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 283 of file StretchHandle.cpp.

284{
285 return std::min(track.GetEndTime(), viewInfo.selectedRegion.t1());
286}
int min(int a, int b)
double GetEndTime() const
Get the maximum of End() values of intervals, or 0 when none.
Definition: Channel.cpp:135
double t1() const
Definition: ViewInfo.h:36

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.

40{
41 static auto disabledCursor =
42 ::MakeCursor(wxCURSOR_NO_ENTRY, DisabledCursorXpm, 16, 16);
43 static auto stretchLeftCursor =
44 ::MakeCursor(wxCURSOR_BULLSEYE, StretchLeftCursorXpm, 16, 16);
45 static auto stretchRightCursor =
46 ::MakeCursor(wxCURSOR_BULLSEYE, StretchRightCursorXpm, 16, 16);
47 static auto stretchCursor =
48 ::MakeCursor(wxCURSOR_BULLSEYE, StretchCursorXpm, 16, 16);
49
50 if (unsafe) {
51 return { {}, &*disabledCursor };
52 }
53 else {
54 wxCursor *pCursor = NULL;
55 switch (stretchMode) {
56 default:
57 wxASSERT(false);
58 case stretchLeft:
59 pCursor = &*stretchLeftCursor; break;
60 case stretchCenter:
61 pCursor = &*stretchCursor; break;
62 case stretchRight:
63 pCursor = &*stretchRightCursor; break;
64 }
65 return {
66 XO("Click and drag to stretch selected region."),
67 pCursor
68 };
69 }
70}
XO("Cut/Copy/Paste")
std::unique_ptr< wxCursor > MakeCursor(int WXUNUSED(CursorId), const char *const pXpm[36], int HotX, int HotY)
Definition: TrackPanel.cpp:188

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.

76{
77 StretchState stretchState;
78 const wxMouseState &state = st.state;
79
80 // later, we may want a different policy, but for now, stretch is
81 // selected when the cursor is near the center of the track and
82 // within the selection
83 auto &viewInfo = ViewInfo::Get( *pProject );
84
85 if (!pTrack || !pTrack->GetSelected())
86 return {};
87
88 const wxRect &rect = st.rect;
89 int center = rect.y + rect.height / 2;
90 int distance = abs(state.m_y - center);
91 const int yTolerance = 10;
92 wxInt64 leftSel = viewInfo.TimeToPosition(viewInfo.selectedRegion.t0(), rect.x);
93 wxInt64 rightSel = viewInfo.TimeToPosition(viewInfo.selectedRegion.t1(), rect.x);
94 // Something is wrong if right edge comes before left edge
95 wxASSERT(!(rightSel < leftSel));
96 if (!(leftSel <= state.m_x && state.m_x <= rightSel &&
97 distance < yTolerance))
98 return {};
99
100 // find nearest beat to sel0, sel1
101 static const double minPeriod = 0.05; // minimum beat period
102 stretchState.mBeatCenter = { 0, 0 };
103
104 auto t0 = GetT0(*pTrack, viewInfo);
105 auto t1 = GetT1(*pTrack, viewInfo);
106
107 if (t0 >= t1)
108 return {};
109
110 stretchState.mBeat0 = pTrack->NearestBeatTime( t0 );
111 stretchState.mOrigSel0Quantized = stretchState.mBeat0.first;
112
113 stretchState.mBeat1 = pTrack->NearestBeatTime( t1 );
114 stretchState.mOrigSel1Quantized = stretchState.mBeat1.first;
115
116 // If there is not (almost) a beat to stretch that is slower
117 // than 20 beats per second, don't stretch
118 if ( within( stretchState.mBeat0.second,
119 stretchState.mBeat1.second, 0.9 ) ||
120 ( stretchState.mBeat1.first - stretchState.mBeat0.first ) /
121 ( stretchState.mBeat1.second - stretchState.mBeat0.second )
122 < minPeriod )
123 return {};
124
125 auto selStart = viewInfo.PositionToTime( state.m_x, rect.x );
126 selStart = std::max(t0, std::min(t1, selStart));
127 stretchState.mBeatCenter = pTrack->NearestBeatTime( selStart );
128 if ( within( stretchState.mBeat0.second,
129 stretchState.mBeatCenter.second, 0.1 ) ) {
130 stretchState.mMode = stretchLeft;
131 stretchState.mLeftBeats = 0;
132 stretchState.mRightBeats =
133 stretchState.mBeat1.second - stretchState.mBeat0.second;
134 }
135 else if ( within( stretchState.mBeat1.second,
136 stretchState.mBeatCenter.second, 0.1 ) ) {
137 stretchState.mMode = stretchRight;
138 stretchState.mLeftBeats =
139 stretchState.mBeat1.second - stretchState.mBeat0.second;
140 stretchState.mRightBeats = 0;
141 }
142 else {
143 stretchState.mMode = stretchCenter;
144 stretchState.mLeftBeats =
145 stretchState.mBeat1.second - stretchState.mBeatCenter.second;
146 stretchState.mRightBeats =
147 stretchState.mBeatCenter.second - stretchState.mBeat0.second;
148 }
149
150 auto result = std::make_shared<StretchHandle>( pTrack, stretchState );
151 result = AssignUIHandlePtr(holder, result);
152 return result;
153}
bool within(A a, B b, DIST d)
Definition: TrackPanel.cpp:169
std::shared_ptr< Subclass > AssignUIHandlePtr(std::weak_ptr< Subclass > &holder, const std::shared_ptr< Subclass > &pNew)
Definition: UIHandle.h:159
static double GetT0(const Track &track, const ViewInfo &viewInfo)
static double GetT1(const Track &track, const ViewInfo &viewInfo)

References AssignUIHandlePtr(), ViewInfo::Get(), GetT0(), GetT1(), StretchHandle::StretchState::mBeat0, StretchHandle::StretchState::mBeat1, StretchHandle::StretchState::mBeatCenter, min(), StretchHandle::StretchState::mLeftBeats, StretchHandle::StretchState::mMode, StretchHandle::StretchState::mOrigSel0Quantized, StretchHandle::StretchState::mOrigSel1Quantized, StretchHandle::StretchState::mRightBeats, TrackPanelMouseState::rect, TrackPanelMouseState::state, stretchCenter, stretchLeft, stretchRight, and within().

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 217 of file StretchHandle.cpp.

219{
220 const bool unsafe = ProjectAudioIO::Get( *pProject ).IsAudioActive();
221 return HitPreview( mStretchState.mMode, unsafe );
222}
static HitTestPreview HitPreview(StretchEnum stretchMode, bool 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 224 of file StretchHandle.cpp.

227{
228 using namespace RefreshCode;
229
230 const bool unsafe = ProjectAudioIO::Get( *pProject ).IsAudioActive();
231 if (unsafe) {
232 this->Cancel(pProject);
233 return RefreshAll | Cancelled;
234 }
235
236 bool left = mStretchState.mMode == stretchLeft;
237 bool right = mStretchState.mMode == stretchRight;
238 auto &viewInfo = ViewInfo::Get( *pProject );
239 if (SyncLockState::Get(*pProject).IsSyncLocked() && (left || right)) {
240 for (auto track : SyncLock::Group(mpTrack.get())) {
241 if (track != mpTrack.get()) {
242 if (left) {
243 auto origT0 = mStretchState.mOrigSel0Quantized;
244 auto diff = viewInfo.selectedRegion.t0() - origT0;
245 if (diff > 0)
246 track->SyncLockAdjust(origT0 + diff, origT0);
247 else
248 track->SyncLockAdjust(origT0, origT0 - diff);
249 track->ShiftBy(diff);
250 }
251 else {
252 auto origT1 = mStretchState.mOrigSel1Quantized;
253 auto diff = viewInfo.selectedRegion.t1() - origT1;
254 track->SyncLockAdjust(origT1, origT1 + diff);
255 }
256 }
257 }
258 }
259
260 /* i18n-hint: (noun) The track that is used for MIDI notes which can be
261 dragged to change their duration.*/
262 ProjectHistory::Get( *pProject ).PushState(XO("Stretch Note Track"),
263 /* i18n-hint: In the history list, indicates a MIDI note has
264 been dragged to change its duration (stretch it). Using either past
265 or present tense is fine here. If unsure, go for whichever is
266 shorter.*/
267 XO("Stretch"),
269 return RefreshAll;
270}
void PushState(const TranslatableString &desc, const TranslatableString &shortDesc)
static TrackIterRange< Track > Group(Track *pTrack)
Definition: SyncLock.cpp:161
bool IsSyncLocked() const
Definition: SyncLock.cpp:43
static SyncLockState & Get(AudacityProject &project)
Definition: SyncLock.cpp:26

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 89 of file StretchHandle.h.

89{ return true; }

◆ Stretch()

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

Definition at line 288 of file StretchHandle.cpp.

290{
291 auto &viewInfo = ViewInfo::Get( *pProject );
292
293 if (pTrack == NULL && mpTrack != NULL)
294 pTrack = mpTrack.get();
295
296 if (pTrack) pTrack->TypeSwitch( [&](NoteTrack &nt) {
297 double moveto =
298 std::max(0.0, viewInfo.PositionToTime(mouseXCoordinate, trackLeftEdge));
299
300 double dur, left_dur, right_dur;
301
302 // check to make sure tempo is not higher than 20 beats per second
303 // (In principle, tempo can be higher, but not infinity.)
304 double minPeriod = 0.05; // minimum beat period
305
306 // make sure target duration is not too short
307 // Take quick exit if so, without changing the selection.
308 auto t0 = mStretchState.mBeat0.first;
309 auto t1 = mStretchState.mBeat1.first;
310 switch ( mStretchState.mMode ) {
311 case stretchLeft: {
312 dur = t1 - moveto;
313 if (dur < mStretchState.mRightBeats * minPeriod)
314 return;
317 nt.ShiftBy(moveto - t0);
318 mStretchState.mBeat0.first = moveto;
319 viewInfo.selectedRegion.setT0(moveto);
320 break;
321 }
322 case stretchRight: {
323 dur = moveto - t0;
324 if (dur < mStretchState.mLeftBeats * minPeriod)
325 return;
328 viewInfo.selectedRegion.setT1(moveto);
329 mStretchState.mBeat1.first = moveto;
330 break;
331 }
332 case stretchCenter: {
333 moveto = std::max(t0, std::min(t1, moveto));
334 left_dur = moveto - t0;
335 right_dur = t1 - moveto;
336 if ( left_dur < mStretchState.mLeftBeats * minPeriod ||
337 right_dur < mStretchState.mRightBeats * minPeriod )
338 return;
343 mStretchState.mBeatCenter.first = moveto;
344 break;
345 }
346 default:
347 wxASSERT(false);
348 break;
349 }
350 });
351}
void ShiftBy(double t)
Change start time by given duration.
Definition: Channel.h:317
A Track that is used for Midi notes. (Somewhat old code).
Definition: NoteTrack.h:86
bool StretchRegion(QuantizedTimeAndBeat t0, QuantizedTimeAndBeat t1, double newDur)
Definition: NoteTrack.cpp:632
R TypeSwitch(const Functions &...functions)
Definition: Track.h:436
QuantizedTimeAndBeat mBeatCenter
Definition: StretchHandle.h:44

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 99 of file StretchHandle.h.

Referenced by Click(), and Drag().

◆ mpTrack

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

Definition at line 98 of file StretchHandle.h.

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

◆ mStretchState

StretchState StretchHandle::mStretchState {}
private

Definition at line 101 of file StretchHandle.h.

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


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