Audacity  2.2.2
TrackPanel.h
Go to the documentation of this file.
1 /**********************************************************************
2 
3  Audacity: A Digital Audio Editor
4 
5  TrackPanel.h
6 
7  Dominic Mazzoni
8 
9 **********************************************************************/
10 
11 #ifndef __AUDACITY_TRACK_PANEL__
12 #define __AUDACITY_TRACK_PANEL__
13 
14 #include "MemoryX.h"
15 #include <vector>
16 
17 #include <wx/timer.h>
18 
19 #include "Experimental.h"
20 
21 #include "HitTestResult.h"
22 
23 #include "SelectedRegion.h"
24 
25 #include "widgets/OverlayPanel.h"
26 
27 #include "SelectionState.h"
28 
29 class wxMenu;
30 class wxRect;
31 
32 class LabelTrack;
33 class SpectrumAnalyst;
34 class Track;
35 class TrackList;
36 class TrackPanel;
37 class TrackPanelCell;
38 class TrackArtist;
39 class Ruler;
40 class SnapManager;
41 class AdornedRulerPanel;
42 class LWSlider;
43 class ControlToolBar; //Needed because state of controls can affect what gets drawn.
44 class ToolsToolBar; //Needed because state of controls can affect what gets drawn.
45 class MixerBoard;
46 class AudacityProject;
47 
48 class TrackPanelAx;
52 
53 class ViewInfo;
54 
55 class NoteTrack;
56 class WaveTrack;
57 class WaveClip;
58 class UIHandle;
59 using UIHandlePtr = std::shared_ptr<UIHandle>;
60 
61 // Declared elsewhere, to reduce compilation dependencies
62 class TrackPanelListener;
63 
65 
66 enum class UndoPush : unsigned char;
67 
68 wxDECLARE_EXPORTED_EVENT(AUDACITY_DLL_API,
69  EVT_TRACK_PANEL_TIMER, wxCommandEvent);
70 
71 enum {
72  kTimerInterval = 50, // milliseconds
73 };
74 
75 
76 class AUDACITY_DLL_API TrackInfo
77 {
78 public:
79  TrackInfo(TrackPanel * pParentIn);
80  ~TrackInfo();
81  void ReCreateSliders();
82 
83  static unsigned MinimumTrackHeight();
84 
85  struct TCPLine;
86 
87  static void DrawItems
88  ( TrackPanelDrawingContext &context,
89  const wxRect &rect, const Track &track );
90 
91  static void DrawItems
92  ( TrackPanelDrawingContext &context,
93  const wxRect &rect, const Track *pTrack,
94  const std::vector<TCPLine> &topLines,
95  const std::vector<TCPLine> &bottomLines );
96 
97  static void CloseTitleDrawFunction
98  ( TrackPanelDrawingContext &context,
99  const wxRect &rect, const Track *pTrack );
100 
101  static void MinimizeSyncLockDrawFunction
102  ( TrackPanelDrawingContext &context,
103  const wxRect &rect, const Track *pTrack );
104 
105  static void MidiControlsDrawFunction
106  ( TrackPanelDrawingContext &context,
107  const wxRect &rect, const Track *pTrack );
108 
109  template<typename TrackClass>
110  static void SliderDrawFunction
111  ( LWSlider *(*Selector)
112  (const wxRect &sliderRect, const TrackClass *t, bool captured,
113  wxWindow*),
114  wxDC *dc, const wxRect &rect, const Track *pTrack,
115  bool captured, bool highlight );
116 
117  static void PanSliderDrawFunction
118  ( TrackPanelDrawingContext &context,
119  const wxRect &rect, const Track *pTrack );
120 
121  static void GainSliderDrawFunction
122  ( TrackPanelDrawingContext &context,
123  const wxRect &rect, const Track *pTrack );
124 
125 #ifdef EXPERIMENTAL_MIDI_OUT
126  static void VelocitySliderDrawFunction
127  ( TrackPanelDrawingContext &context,
128  const wxRect &rect, const Track *pTrack );
129 #endif
130 
131  static void MuteOrSoloDrawFunction
132  ( wxDC *dc, const wxRect &rect, const Track *pTrack, bool down,
133  bool captured, bool solo, bool hit );
134 
135  static void WideMuteDrawFunction
136  ( TrackPanelDrawingContext &context,
137  const wxRect &rect, const Track *pTrack );
138 
139  static void WideSoloDrawFunction
140  ( TrackPanelDrawingContext &context,
141  const wxRect &rect, const Track *pTrack );
142 
143  static void MuteAndSoloDrawFunction
144  ( TrackPanelDrawingContext &context,
145  const wxRect &rect, const Track *pTrack );
146 
147  static void StatusDrawFunction
148  ( const wxString &string, wxDC *dc, const wxRect &rect );
149 
150  static void Status1DrawFunction
151  ( TrackPanelDrawingContext &context,
152  const wxRect &rect, const Track *pTrack );
153 
154  static void Status2DrawFunction
155  ( TrackPanelDrawingContext &context,
156  const wxRect &rect, const Track *pTrack );
157 
158 public:
159  int GetTrackInfoWidth() const;
160  static void SetTrackInfoFont(wxDC *dc);
161 
162 
163  void DrawBackground(wxDC * dc, const wxRect & rect, bool bSelected, bool bHasMuteSolo, const int labelw, const int vrul) const;
164  void DrawBordersWithin(wxDC * dc, const wxRect & rect, const Track &track ) const;
165 
166  static void GetCloseBoxHorizontalBounds( const wxRect & rect, wxRect &dest );
167  static void GetCloseBoxRect(const wxRect & rect, wxRect &dest);
168 
169  static void GetTitleBarHorizontalBounds( const wxRect & rect, wxRect &dest );
170  static void GetTitleBarRect(const wxRect & rect, wxRect &dest);
171 
172  static void GetNarrowMuteHorizontalBounds
173  ( const wxRect & rect, wxRect &dest );
174  static void GetNarrowSoloHorizontalBounds
175  ( const wxRect & rect, wxRect &dest );
176  static void GetWideMuteSoloHorizontalBounds
177  ( const wxRect & rect, wxRect &dest );
178  static void GetMuteSoloRect
179  (const wxRect & rect, wxRect &dest, bool solo, bool bHasSoloButton,
180  const Track *pTrack);
181 
182  static void GetSliderHorizontalBounds( const wxPoint &topleft, wxRect &dest );
183 
184  static void GetGainRect(const wxPoint & topLeft, wxRect &dest);
185 
186  static void GetPanRect(const wxPoint & topLeft, wxRect &dest);
187 
188 #ifdef EXPERIMENTAL_MIDI_OUT
189  static void GetVelocityRect(const wxPoint & topLeft, wxRect &dest);
190 #endif
191 
192  static void GetMinimizeHorizontalBounds( const wxRect &rect, wxRect &dest );
193  static void GetMinimizeRect(const wxRect & rect, wxRect &dest);
194 
195  static void GetSyncLockHorizontalBounds( const wxRect &rect, wxRect &dest );
196  static void GetSyncLockIconRect(const wxRect & rect, wxRect &dest);
197 
198 #ifdef USE_MIDI
199  static void GetMidiControlsHorizontalBounds
200  ( const wxRect &rect, wxRect &dest );
201  static void GetMidiControlsRect(const wxRect & rect, wxRect &dest);
202 #endif
203 
204  static bool HideTopItem( const wxRect &rect, const wxRect &subRect,
205  int allowance = 0 );
206 
207  static unsigned DefaultNoteTrackHeight();
208  static unsigned DefaultWaveTrackHeight();
209 
210  static LWSlider * GainSlider
211  (const wxRect &sliderRect, const WaveTrack *t, bool captured,
212  wxWindow *pParent);
213  static LWSlider * PanSlider
214  (const wxRect &sliderRect, const WaveTrack *t, bool captured,
215  wxWindow *pParent);
216 
217 #ifdef EXPERIMENTAL_MIDI_OUT
218  static LWSlider * VelocitySlider
219  (const wxRect &sliderRect, const NoteTrack *t, bool captured,
220  wxWindow *pParent);
221 #endif
222 
223 private:
224  void UpdatePrefs();
225 
227  static wxFont gFont;
228  // These are on separate lines to work around an MSVC 2013 compiler bug.
229  static std::unique_ptr<LWSlider> gGainCaptured;
230  static std::unique_ptr<LWSlider> gPanCaptured;
231  static std::unique_ptr<LWSlider> gGain;
232  static std::unique_ptr<LWSlider> gPan;
233 #ifdef EXPERIMENTAL_MIDI_OUT
234  static std::unique_ptr<LWSlider> gVelocityCaptured;
235  static std::unique_ptr<LWSlider> gVelocity;
236 #endif
237 
238  friend class TrackPanel;
239 };
240 
241 
242 const int DragThreshold = 3;// Anything over 3 pixels is a drag, else a click.
243 
244 
245 class AUDACITY_DLL_API TrackPanel final : public OverlayPanel {
246  public:
247 
248  TrackPanel(wxWindow * parent,
249  wxWindowID id,
250  const wxPoint & pos,
251  const wxSize & size,
252  const std::shared_ptr<TrackList> &tracks,
253  ViewInfo * viewInfo,
254  TrackPanelListener * listener,
255  AdornedRulerPanel * ruler );
256 
257  virtual ~ TrackPanel();
258 
260 
261  void UpdatePrefs();
262  void ApplyUpdatedTheme();
263 
264  void OnPaint(wxPaintEvent & event);
265  void OnMouseEvent(wxMouseEvent & event);
266  void OnCaptureLost(wxMouseCaptureLostEvent & event);
267  void OnCaptureKey(wxCommandEvent & event);
268  void OnKeyDown(wxKeyEvent & event);
269  void OnChar(wxKeyEvent & event);
270  void OnKeyUp(wxKeyEvent & event);
271 
272  void OnSetFocus(wxFocusEvent & event);
273  void OnKillFocus(wxFocusEvent & event);
274 
275  void OnContextMenu(wxContextMenuEvent & event);
276 
277  void OnPlayback(wxCommandEvent &);
278  void OnTrackListResizing(wxCommandEvent & event);
279  void OnTrackListDeletion(wxCommandEvent & event);
280  void UpdateViewIfNoTracks(); // Call this to update mViewInfo, etc, after track(s) removal, before Refresh().
281 
282  double GetMostRecentXPos();
283 
284  void OnIdle(wxIdleEvent & event);
285  void OnTimer(wxTimerEvent& event);
286 
287  int GetLeftOffset() const { return GetLabelWidth() + 1;}
288 
289  // Width and height, relative to upper left corner at (GetLeftOffset(), 0)
290  // Either argument may be NULL
291  void GetTracksUsableArea(int *width, int *height) const;
292 
293  void Refresh
294  (bool eraseBackground = true, const wxRect *rect = (const wxRect *) NULL)
295  override;
296 
297  void RefreshTrack(Track *trk, bool refreshbacking = true);
298 
299  void DisplaySelection();
300 
301  // These two are neither used nor defined as of Nov-2011
302  // void SetSelectionFormat(int iformat)
303  // void SetSnapTo(int snapto)
304 
305  void HandleInterruptedDrag();
306  void Uncapture( wxMouseState *pState = nullptr );
307  bool CancelDragging();
308  bool HandleEscapeKey(bool down);
309  void UpdateMouseState(const wxMouseState &state);
310  void HandleModifierKey();
311  void HandlePageUpKey();
312  void HandlePageDownKey();
313  AudacityProject * GetProject() const;
314 
315  void ScrollIntoView(double pos);
316  void ScrollIntoView(int x);
317 
318  void OnTrackMenu(Track *t = NULL);
319  Track * GetFirstSelectedTrack();
320  bool IsMouseCaptured();
321 
322  void EnsureVisible(Track * t);
323  void VerticalScroll( float fracPosition);
324 
325  Track *GetFocusedTrack();
326  void SetFocusedTrack(Track *t);
327 
328  void HandleCursorForPresentMouseState(bool doHit = true);
329 
330  void UpdateVRulers();
331  void UpdateVRuler(Track *t);
332  void UpdateTrackVRuler(const Track *t);
333  void UpdateVRulerSize();
334 
335  // Returns the time corresponding to the pixel column one past the track area
336  // (ignoring any fisheye)
337  double GetScreenEndTime() const;
338 
339  protected:
340  bool IsAudioActive();
341  void HandleClick( const TrackPanelMouseEvent &tpmEvent );
342 
343 public:
344  size_t GetTrackCount() const;
345  size_t GetSelectedTrackCount() const;
346 
347 protected:
348  void UpdateSelectionDisplay();
349 
350 public:
351  void UpdateAccessibility();
352  void MessageForScreenReader(const wxString& message);
353 
354  // MM: Handle mouse wheel rotation
355  void HandleWheelRotation( TrackPanelMouseEvent &tpmEvent );
356 
357  void MakeParentRedrawScrollbars();
358 
359  // If label, rectangle includes track control panel only.
360  // If !label, rectangle includes all of that, and the vertical ruler, and
361  // the proper track area.
362  wxRect FindTrackRect( const Track * target, bool label );
363 
364 protected:
365  void MakeParentModifyState(bool bWantsAutoSave); // if true, writes auto-save file. Should set only if you really want the state change restored after
366  // a crash, as it can take many seconds for large (eg. 10 track-hours) projects
367 
368  // Find track info by coordinate
369  struct FoundCell {
370  std::shared_ptr<Track> pTrack;
371  std::shared_ptr<TrackPanelCell> pCell;
372  wxRect rect;
373  };
374  FoundCell FindCell(int mouseX, int mouseY);
375 
376  void HandleMotion( wxMouseState &state, bool doHit = true );
377  void HandleMotion
378  ( const TrackPanelMouseState &tpmState, bool doHit = true );
379 
380  int GetVRulerWidth() const;
381  int GetVRulerOffset() const { return mTrackInfo.GetTrackInfoWidth(); }
382 
383 public:
384  int GetLabelWidth() const { return mTrackInfo.GetTrackInfoWidth() + GetVRulerWidth(); }
385 
386 // JKC Nov-2011: These four functions only used from within a dll such as mod-track-panel
387 // They work around some messy problems with constructors.
388  const TrackList * GetTracks() const { return mTracks.get(); }
389  TrackList * GetTracks() { return mTracks.get(); }
390  ViewInfo * GetViewInfo(){ return mViewInfo;}
391  TrackPanelListener * GetListener(){ return mListener;}
392  AdornedRulerPanel * GetRuler(){ return mRuler;}
393 // JKC and here is a factory function which just does 'NEW' in standard Audacity.
394  // Precondition: parent != NULL
395  static TrackPanel *(*FactoryFunction)(wxWindow * parent,
396  wxWindowID id,
397  const wxPoint & pos,
398  const wxSize & size,
399  const std::shared_ptr<TrackList> &tracks,
400  ViewInfo * viewInfo,
401  TrackPanelListener * listener,
402  AdornedRulerPanel * ruler);
403 
404 protected:
405  void DrawTracks(wxDC * dc);
406 
407  void DrawEverythingElse(TrackPanelDrawingContext &context,
408  const wxRegion & region,
409  const wxRect & clip);
410  void DrawOutside
411  (TrackPanelDrawingContext &context,
412  Track *t, const wxRect & rec);
413 
414  void HighlightFocusedTrack (wxDC* dc, const wxRect &rect);
415  void DrawShadow (Track *t, wxDC* dc, const wxRect & rect);
416  void DrawBordersAroundTrack(Track *t, wxDC* dc, const wxRect & rect, const int labelw, const int vrul);
417  void DrawOutsideOfTrack
418  (TrackPanelDrawingContext &context,
419  Track *t, const wxRect & rect);
420 
421 public:
422  // Set the object that performs catch-all event handling when the pointer
423  // is not in any track or ruler or control panel.
424  void SetBackgroundCell
425  (const std::shared_ptr< TrackPanelCell > &pCell);
426  std::shared_ptr< TrackPanelCell > GetBackgroundCell();
427 
428 public:
429  // Accessors...
430  static bool HasSoloButton(){ return gSoloPref!=wxT("None");}
431 
432 protected:
433 
435 
436 public:
437 
438  LWSlider *GainSlider( const WaveTrack *wt );
439  LWSlider *PanSlider( const WaveTrack *wt );
440 #ifdef EXPERIMENTAL_MIDI_OUT
441  LWSlider *VelocitySlider( const NoteTrack *nt );
442 #endif
443 
444  TrackInfo *GetTrackInfo() { return &mTrackInfo; }
445  const TrackInfo *GetTrackInfo() const { return &mTrackInfo; }
446 
447 protected:
449 
450  std::shared_ptr<TrackList> mTracks;
452 
454 
455  std::unique_ptr<TrackArtist> mTrackArtist;
456 
457  class AUDACITY_DLL_API AudacityTimer final : public wxTimer {
458  public:
459  void Notify() override{
460  // (From Debian)
461  //
462  // Don't call parent->OnTimer(..) directly here, but instead post
463  // an event. This ensures that this is a pure wxWidgets event
464  // (no GDK event behind it) and that it therefore isn't processed
465  // within the YieldFor(..) of the clipboard operations (workaround
466  // for Debian bug #765341).
467  // QueueEvent() will take ownership of the event
468  parent->GetEventHandler()->QueueEvent(safenew wxTimerEvent(*this));
469  }
471  } mTimer;
472 
474 
476 
477 #ifdef EXPERIMENTAL_SPECTRAL_EDITING
478 
479 protected:
480 
481 #endif
482 
484 
485  wxMouseState mLastMouseState;
486 
489 
490  friend class TrackPanelAx;
491 
492 #if wxUSE_ACCESSIBILITY
493  TrackPanelAx *mAx{};
494 #else
495  std::unique_ptr<TrackPanelAx> mAx;
496 #endif
497 
498 public:
499  TrackPanelAx &GetAx() { return *mAx; }
500 
501 protected:
502 
503  static wxString gSoloPref;
504 
505  // The screenshot class needs to access internals
506  friend class ScreenshotCommand;
507 
508  SelectedRegion mLastDrawnSelectedRegion {};
509 
510  public:
511  wxSize vrulerSize;
512 
513  protected:
514  std::weak_ptr<TrackPanelCell> mLastCell;
515  std::vector<UIHandlePtr> mTargets;
516  size_t mTarget {};
517  unsigned mMouseOverUpdateFlags{};
518 
519  public:
521  {
522  if (mTargets.size())
523  return mTargets[mTarget];
524  else
525  return {};
526  }
527 
528  protected:
530  {
531  // Forget the rotation of hit test candidates when the mouse moves from
532  // cell to cell or outside of the TrackPanel entirely.
533  mLastCell.reset();
534  mTargets.clear();
535  mTarget = 0;
536  mMouseOverUpdateFlags = 0;
537  }
538 
539  bool HasRotation();
540  bool HasEscape();
541 
542  bool ChangeTarget(bool forward, bool cycle);
543 
544  std::weak_ptr<Track> mpClickedTrack;
546 
547  std::shared_ptr<TrackPanelCell> mpBackground;
548 
549  bool mEnableTab{};
550 
551  DECLARE_EVENT_TABLE()
552 
553  // friending GetInfoCommand allow automation to get sizes of the
554  // tracks, track control panel and such.
555  friend class GetInfoCommand;
556 };
557 
558 // See big pictorial comment in TrackPanel for explanation of these numbers
559 enum : int {
569 };
570 
571 enum : int {
573  kTrackInfoBtnSize = 18, // widely used dimension, usually height
578 };
579 
580 #ifdef USE_MIDI
581 enum : int {
582  kMidiCellWidth = (kTrackInfoWidth / 4) - 2,
583  kMidiCellHeight = kTrackInfoBtnSize
584 };
585 #endif
586 
587 #endif
int GetLabelWidth() const
Definition: TrackPanel.h:384
A ToolBar that has the main Transport buttons.
A list of TrackListNode items.
Definition: Track.h:619
This class handles the actual rendering of WaveTracks (both waveforms and spectra), NoteTracks, LabelTracks and TimeTracks.
Definition: TrackArtist.h:50
static wxFont gFont
Definition: TrackPanel.h:227
const TrackInfo * GetTrackInfo() const
Definition: TrackPanel.h:445
const TrackList * GetTracks() const
Definition: TrackPanel.h:388
std::shared_ptr< TrackPanelCell > pCell
Definition: TrackPanel.h:371
ViewInfo is used mainly to hold the zooming, selection and scroll information. It also has some statu...
Definition: ViewInfo.h:141
const int DragThreshold
Definition: TrackPanel.h:242
A now badly named class which is used to give access to a subset of the TrackPanel methods from all o...
std::shared_ptr< Track > pTrack
Definition: TrackPanel.h:370
std::shared_ptr< TrackList > mTracks
Definition: TrackPanel.h:450
std::weak_ptr< TrackPanelCell > mLastCell
Definition: TrackPanel.h:514
int mMouseMostRecentX
Definition: TrackPanel.h:487
wxString label
Definition: Tags.cpp:727
static bool HasSoloButton()
Definition: TrackPanel.h:430
static std::unique_ptr< LWSlider > gPanCaptured
Definition: TrackPanel.h:230
static wxString gSoloPref
Definition: TrackPanel.h:503
Timer class dedicated to infomring the TrackPanel that it is time to refresh some aspect of the scree...
Definition: TrackPanel.h:457
#define safenew
Definition: Audacity.h:230
UIHandlePtr Target()
Definition: TrackPanel.h:520
void ClearTargets()
Definition: TrackPanel.h:529
A LabelTrack is a Track that holds labels (LabelStruct).
Definition: LabelTrack.h:113
void OnTrackMenu(const CommandContext &context)
TrackList * GetTracks()
Definition: TrackPanel.h:389
ViewInfo * mViewInfo
Definition: TrackPanel.h:451
void Notify() override
Definition: TrackPanel.h:459
AudacityProject provides the main window, with tools and tracks contained within it.
Definition: Project.h:176
enum UndoPush unsigned char wxDECLARE_EXPORTED_EVENT(AUDACITY_DLL_API, EVT_TRACK_PANEL_TIMER, wxCommandEvent)
wxSize vrulerSize
Definition: TrackPanel.h:511
TrackInfo * GetTrackInfo()
Definition: TrackPanel.h:444
Defines a selected portion of a project.
UIHandlePtr mUIHandle
Definition: TrackPanel.h:545
The TrackInfo is shown to the side of a track It has the menus, pan and gain controls displayed in it...
Definition: TrackPanel.h:76
The TrackPanel class coordinates updates and operations on the main part of the screen which contains...
Definition: TrackPanel.h:245
TrackPanel * pParent
Definition: TrackPanel.h:226
Lightweight version of ASlider. In other words it does not have a window permanently associated with ...
Definition: ASlider.h:73
This allows multiple clips to be a part of one WaveTrack.
Definition: WaveClip.h:176
UndoPush
Definition: UndoManager.h:82
A Track that contains audio waveform data.
Definition: WaveTrack.h:60
Fundamental data object of Audacity, placed in the TrackPanel. Classes derived form it include the Wa...
Definition: Track.h:102
TrackPanelAx & GetAx()
Definition: TrackPanel.h:499
TrackInfo mTrackInfo
Definition: TrackPanel.h:434
Helper to TrackPanel to give accessibility.
Definition: TrackPanelAx.h:25
Implements a command for capturing various areas of the screen or project window. It's one big if-els...
std::shared_ptr< UIHandle > UIHandlePtr
Definition: TrackPanel.h:59
TrackPanelListener * mListener
Definition: TrackPanel.h:448
Used for finding the peaks, for snapping to peaks.
Definition: FreqWindow.h:44
int mTimeCount
Definition: TrackPanel.h:473
TrackPanelListener * GetListener()
Definition: TrackPanel.h:391
int mMouseMostRecentY
Definition: TrackPanel.h:488
Used to display a Ruler.
Definition: Ruler.h:32
std::unique_ptr< TrackArtist > mTrackArtist
Definition: TrackPanel.h:455
bool mRefreshBacking
Definition: TrackPanel.h:475
A kind of ToolBar with Tools on it.
Definition: ToolsToolBar.h:49
bool mRedrawAfterStop
Definition: TrackPanel.h:483
static std::unique_ptr< LWSlider > gPan
Definition: TrackPanel.h:232
std::shared_ptr< TrackPanelCell > mpBackground
Definition: TrackPanel.h:547
This is an Audacity Specific ruler panel which additionally has border, selection markers...
Definition: Ruler.h:316
static void OnChar(wxKeyEvent &event)
Definition: Contrast.cpp:155
std::vector< UIHandlePtr > mTargets
Definition: TrackPanel.h:515
int GetLeftOffset() const
Definition: TrackPanel.h:287
AdornedRulerPanel * GetRuler()
Definition: TrackPanel.h:392
std::unique_ptr< TrackPanelAx > mAx
Definition: TrackPanel.h:495
wxMouseState mLastMouseState
Definition: TrackPanel.h:485
AdornedRulerPanel * mRuler
Definition: TrackPanel.h:453
std::weak_ptr< Track > mpClickedTrack
Definition: TrackPanel.h:544
static std::unique_ptr< LWSlider > gGain
Definition: TrackPanel.h:231
static std::unique_ptr< LWSlider > gGainCaptured
Definition: TrackPanel.h:229
Command which outputs a list of available menu commands on the status channel.
int GetVRulerOffset() const
Definition: TrackPanel.h:381
ViewInfo * GetViewInfo()
Definition: TrackPanel.h:390
A Track that is used for Midi notes. (Somewhat old code).