Scrub speed as overlay; scrub event handling details out of TrackPanel.cpp

src/Project.cpp

@@ -937,8 +937,7 @@ AudacityProject::AudacityProject(wxWindow * parent, wxWindowID id,
    // attach its timer event handler later (so that its handler is invoked
    // earlier)
    mScrubOverlay = std::make_unique<ScrubbingOverlay>(this);
-#else
+   mScrubber = std::make_unique<Scrubber>(this);
-   mScrubOverlay = NULL;
 #endif
 
    // This must follow construction of *mScrubOverlay, because it must
@@ -952,7 +951,9 @@ AudacityProject::AudacityProject(wxWindow * parent, wxWindowID id,
    // Add the overlays, in the sequence in which they will be painted
    mTrackPanel->AddOverlay(mIndicatorOverlay.get());
    mTrackPanel->AddOverlay(mCursorOverlay.get());
+#ifdef EXPERIMENTAL_SCRUBBING_BASIC
    mTrackPanel->AddOverlay(mScrubOverlay.get());
+#endif
 
    // LLL: When Audacity starts or becomes active after returning from
    //      another application, the first window that can accept focus
@@ -1082,7 +1083,9 @@ AudacityProject::~AudacityProject()
    }
 
    if(mTrackPanel) {
+#ifdef EXPERIMENTAL_SCRUBBING_BASIC
       mTrackPanel->RemoveOverlay(mScrubOverlay.get());
+#endif
       mTrackPanel->RemoveOverlay(mCursorOverlay.get());
       mTrackPanel->RemoveOverlay(mIndicatorOverlay.get());
    }

src/Project.h

@@ -73,6 +73,7 @@ class DeviceToolBar;
 class EditToolBar;
 class MeterToolBar;
 class MixerToolBar;
+class Scrubber;
 class SelectionBar;
 class SpectralSelectionBar;
 class Toolbar;
@@ -709,7 +710,15 @@ public:
 
    // TrackPanelOverlay objects
    std::unique_ptr<TrackPanelOverlay> 
-      mIndicatorOverlay, mCursorOverlay, mScrubOverlay;
+      mIndicatorOverlay, mCursorOverlay;
+
+#ifdef EXPERIMENTAL_SCRUBBING_BASIC
+   std::unique_ptr<TrackPanelOverlay> mScrubOverlay;
+   std::unique_ptr<Scrubber> mScrubber;
+public:
+   Scrubber &GetScrubber() { return *mScrubber; }
+   const Scrubber &GetScrubber() const { return *mScrubber; }
+#endif
 
    DECLARE_EVENT_TABLE()
 };

src/TrackPanel.cpp

@@ -198,6 +198,9 @@ is time to refresh some aspect of the screen.
 #include "toolbars/ControlToolBar.h"
 #include "toolbars/ToolsToolBar.h"
 
+// To do:  eliminate this!
+#include "tracks/ui/Scrubbing.h"
+
 #define ZOOMLIMIT 0.001f
 
 //This loads the appropriate set of cursors, depending on platform.
@@ -268,20 +271,6 @@ enum {
    kBottomMargin = kShadowThickness + kBorderThickness,
    kLeftMargin = kLeftInset + kBorderThickness,
    kRightMargin = kRightInset + kShadowThickness + kBorderThickness,
-
-   kTimerInterval = 50, // milliseconds
-   kOneSecondCountdown = 1000 / kTimerInterval,
-};
-
-enum {
-   // PRL:
-   // Mouse must move at least this far to distinguish ctrl-drag to scrub
-   // from ctrl-click for playback.
-   SCRUBBING_PIXEL_TOLERANCE = 10,
-
-#ifdef EXPERIMENTAL_SCRUBBING_SCROLL_WHEEL
-   ScrubSpeedStepsPerOctave = 4,
-#endif
 };
 
 // Is the distance between A and B less than D?
@@ -583,30 +572,7 @@ TrackPanel::TrackPanel(wxWindow * parent, wxWindowID id,
    mSelStartValid = false;
    mSelStart = 0;
 
-#ifdef EXPERIMENTAL_SCRUBBING_BASIC
-   mScrubToken = -1;
-   mScrubStartClockTimeMillis = -1;
-   mScrubStartPosition = -1;
-   mMaxScrubSpeed = 1.0;
-   mScrubSpeedDisplayCountdown = 0;
-   mScrubHasFocus = false;
-   mScrubSeekPress = false;
-#endif
-
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-   mSmoothScrollingScrub = false;
-#endif
-
-#ifdef EXPERIMENTAL_SCRUBBING_SCROLL_WHEEL
-   mLogMaxScrubSpeed = 0;
-#endif
-
    mInitialTrackSelection = new std::vector<bool>;
-
-   if (wxTheApp)
-      wxTheApp->Connect
-         (wxEVT_ACTIVATE_APP,
-          wxActivateEventHandler(TrackPanel::OnActivateOrDeactivateApp), NULL, this);
 }
 
 
@@ -614,11 +580,6 @@ TrackPanel::~TrackPanel()
 {
    mTimer.Stop();
 
-   if (wxTheApp)
-       wxTheApp->Disconnect
-      (wxEVT_ACTIVATE_APP,
-       wxActivateEventHandler(TrackPanel::OnActivateOrDeactivateApp), NULL, this);
-
    // Unregister for tracklist updates
    mTracks->Disconnect(EVT_TRACKLIST_UPDATED,
                        wxCommandEventHandler(TrackPanel::OnTrackListUpdated),
@@ -1015,12 +976,6 @@ void TrackPanel::OnTimer(wxTimerEvent& )
       p->GetEventHandler()->ProcessEvent(e);
    }
 
-   const double playPos = gAudioIO->GetStreamTime();
-
-#ifdef EXPERIMENTAL_SCRUBBING_BASIC
-   TimerUpdateScrubbing(playPos);
-#endif
-
    DrawOverlays(false);
 
    if(IsAudioActive() && gAudioIO->GetNumCaptureChannels()) {
@@ -1611,7 +1566,7 @@ void TrackPanel::SetCursorAndTipWhenSelectTool( Track * t,
    // But don't change the cursor when scrubbing.
    SelectionBoundary boundary =
 #ifdef EXPERIMENTAL_SCRUBBING_BASIC
-      IsScrubbing()
+      GetProject()->GetScrubber().IsScrubbing()
       ? SBNone
       :
 #endif
@@ -1905,276 +1860,6 @@ void TrackPanel::HandleSelect(wxMouseEvent & event)
    SelectionHandleDrag(event, t);
 }
 
-
-// Made obsolete by scrubbing:
-#ifndef EXPERIMENTAL_SCRUBBING_BASIC
-void TrackPanel::StartOrJumpPlayback(wxMouseEvent &event)
-{
-   AudacityProject *p = GetActiveProject();
-   if (p) {
-      double clicktime = mViewInfo->PositionToTime(event.m_x, GetLeftOffset());
-      const double t1 = mViewInfo->selectedRegion.t1();
-      // Play to end of selection, or if that is not right of the pick, end of track
-      double endtime = clicktime < t1 ? t1 : mViewInfo->total;
-
-      //Behavior should differ depending upon whether we are
-      //currently in playback mode or not.
-
-      bool busy = gAudioIO->IsBusy();
-      if (!busy)
-      {
-         //If we aren't currently playing back, start playing back at
-         //the clicked point
-         ControlToolBar * ctb = p->GetControlToolBar();
-         //ctb->SetPlay(true);// Not needed as done in PlayPlayRegion
-         ctb->PlayPlayRegion
-            (SelectedRegion(clicktime, endtime), p->GetDefaultPlayOptions());
-      }
-      else
-      {
-         //If we are playing back, stop and move playback
-         //to the clicked point.
-         //This unpauses paused audio as well.  The right thing to do might be to
-         //leave it paused but move the point.  This would probably
-         //require a NEW method in ControlToolBar: SetPause();
-         ControlToolBar * ctb = p->GetControlToolBar();
-         ctb->StopPlaying();
-         ctb->PlayPlayRegion(SelectedRegion(clicktime, endtime), p->GetDefaultPlayOptions());
-      }
-   }
-}
-#endif
-
-
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-double TrackPanel::FindScrubSpeed(double timeAtMouse) const
-{
-   // Map a time (which was mapped from a mouse position)
-   // to a speed.
-   // Map times to positive and negative speeds,
-   // with the time at the midline of the screen mapping to 0,
-   // and the extremes to the maximum scrub speed.
-
-   // Width of visible track area, in time terms:
-   const double screen = GetScreenEndTime() - mViewInfo->h;
-   const double origin = mViewInfo->h + screen / 2.0;
-
-   // There are various snapping zones that are this fraction of screen:
-   const double snap = 0.05;
-
-   // By shrinking denom a bit, we make margins left and right
-   // that snap to maximum and negative maximum speeds.
-   const double factor = 1.0 - (snap * 2);
-   const double denom = factor * screen / 2.0;
-   double fraction = std::min(1.0, fabs(timeAtMouse - origin) / denom);
-
-   // Snap to 1.0 and -1.0
-   const double unity = 1.0 / mMaxScrubSpeed;
-   const double tolerance = snap / factor;
-   // Make speeds near 1 available too by remapping fractions outside
-   // this snap zone
-   if (fraction <= unity - tolerance)
-      fraction *= unity / (unity - tolerance);
-   else if (fraction < unity + tolerance)
-      fraction = unity;
-   else
-      fraction = unity + (fraction - (unity + tolerance)) *
-      (1.0 - unity) / (1.0 - (unity + tolerance));
-
-   double result = fraction * mMaxScrubSpeed;
-   if (timeAtMouse < origin)
-      result *= -1.0;
-   return result;
-}
-
-double TrackPanel::FindSeekSpeed(double timeAtMouse) const
-{
-   // Map a time (which was mapped from a mouse position)
-   // to a signed skip speed: a multiplier of the stutter duration,
-   // by which to advance the play position.
-   // (The stutter will play at unit speed.)
-
-   // Times near the midline of the screen map to skip-less play,
-   // and the extremes to a value proportional to maximum scrub speed.
-
-   // If the maximum scrubbing speed defaults to 1.0 when you begin to scroll-scrub,
-   // the extreme skipping for scroll-seek needs to be larger to be useful.
-   static const double ARBITRARY_MULTIPLIER = 10.0;
-   const double extreme = std::max(1.0, mMaxScrubSpeed * ARBITRARY_MULTIPLIER);
-
-   // Width of visible track area, in time terms:
-   const double screen = GetScreenEndTime() - mViewInfo->h;
-   const double halfScreen = screen / 2.0;
-   const double origin = mViewInfo->h + halfScreen;
-
-   // The snapping zone is this fraction of screen, on each side of the
-   // center line:
-   const double snap = 0.05;
-   const double fraction =
-      std::max(snap, std::min(1.0, fabs(timeAtMouse - origin) / halfScreen));
-
-   double result = 1.0 + ((fraction - snap) / (1.0 - snap)) * (extreme - 1.0);
-   if (timeAtMouse < origin)
-      result *= -1.0;
-   return result;
-}
-#endif
-
-#ifdef EXPERIMENTAL_SCRUBBING_BASIC
-bool TrackPanel::PollIsSeeking()
-{
-   return ::wxGetMouseState().LeftIsDown();
-}
-
-bool TrackPanel::IsScrubbing()
-{
-   if (mScrubToken <= 0)
-      return false;
-   else if (mScrubToken == GetProject()->GetAudioIOToken())
-      return true;
-   else {
-      mScrubToken = -1;
-      mScrubStartPosition = -1;
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-      mSmoothScrollingScrub = false;
-#endif
-      return false;
-   }
-}
-
-void TrackPanel::MarkScrubStart(
-   wxCoord xx
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-   , bool smoothScrolling
-#endif
-)
-{
-   // Don't actually start scrubbing, but collect some information
-   // needed for the decision to start scrubbing later when handling
-   // drag events.
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-   mSmoothScrollingScrub = smoothScrolling;
-#endif
-   mScrubStartPosition = xx;
-   mScrubStartClockTimeMillis = ::wxGetLocalTimeMillis();
-}
-
-bool TrackPanel::MaybeStartScrubbing(wxMouseEvent &event)
-{
-   if (IsScrubbing())
-      return false;
-   else if (mScrubStartPosition >= 0) {
-      const bool busy = gAudioIO->IsBusy();
-      if (busy && gAudioIO->GetNumCaptureChannels() > 0) {
-         // Do not stop recording, and don't try to start scrubbing after
-         // recording stops
-         mScrubStartPosition = -1;
-         return false;
-      }
-
-      wxCoord position = event.m_x;
-      AudacityProject *p = GetActiveProject();
-      if (p &&
-         abs(mScrubStartPosition - position) >= SCRUBBING_PIXEL_TOLERANCE) {
-         ControlToolBar * ctb = p->GetControlToolBar();
-         double maxTime = p->GetTracks()->GetEndTime();
-         double time0 = std::min(maxTime,
-            mViewInfo->PositionToTime(mScrubStartPosition, GetLeftOffset())
-         );
-         double time1 = std::min(maxTime,
-            mViewInfo->PositionToTime(position, GetLeftOffset())
-         );
-         if (time1 != time0)
-         {
-            if (busy)
-               ctb->StopPlaying();
-
-            AudioIOStartStreamOptions options(p->GetDefaultPlayOptions());
-            options.timeTrack = NULL;
-            options.scrubDelay = (kTimerInterval / 1000.0);
-            options.scrubStartClockTimeMillis = mScrubStartClockTimeMillis;
-            options.minScrubStutter = 0.2;
-#if 0
-            // Take the starting speed limit from the transcription toolbar,
-            // but it may be varied during the scrub.
-            mMaxScrubSpeed = options.maxScrubSpeed =
-               p->GetTranscriptionToolBar()->GetPlaySpeed();
-#else
-            // That idea seems unpopular... just make it one
-            mMaxScrubSpeed = options.maxScrubSpeed = 1.0;
-#endif
-            options.maxScrubTime = mTracks->GetEndTime();
-            const bool cutPreview = false;
-            const bool backwards = time1 < time0;
-#ifdef EXPERIMENTAL_SCRUBBING_SCROLL_WHEEL
-            static const double maxScrubSpeedBase =
-               pow(2.0, 1.0 / ScrubSpeedStepsPerOctave);
-            mLogMaxScrubSpeed = floor(0.5 +
-               log(mMaxScrubSpeed) / log(maxScrubSpeedBase)
-            );
-#endif
-            mScrubSpeedDisplayCountdown = 0;
-            mScrubToken =
-               ctb->PlayPlayRegion(SelectedRegion(time0, time1), options, cutPreview, backwards);
-         }
-      }
-      else
-         // Wait to test again
-         mScrubStartClockTimeMillis = ::wxGetLocalTimeMillis();
-
-      if (IsScrubbing()) {
-         mScrubHasFocus = true;
-         //mMouseCapture = IsMiddleButtonScrubbing;
-         //CaptureMouse();
-      }
-      return IsScrubbing();
-   }
-   else
-      return false;
-}
-
-bool TrackPanel::ContinueScrubbing(wxCoord position, bool hasFocus, bool seek)
-{
-   // When we don't have focus, enqueue silent scrubs until we regain focus.
-   if (!hasFocus)
-      return gAudioIO->EnqueueScrubBySignedSpeed(0, mMaxScrubSpeed, false);
-
-   const double time = mViewInfo->PositionToTime(position, GetLeftOffset());
-
-   if (seek)
-      // Cause OnTimer() to suppress the speed display
-      mScrubSpeedDisplayCountdown = 1;
-
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-   if (mSmoothScrollingScrub) {
-      const double speed = seek ? FindSeekSpeed(time) : FindScrubSpeed(time);
-      return gAudioIO->EnqueueScrubBySignedSpeed(speed, mMaxScrubSpeed, seek);
-   }
-   else
-#endif
-      return gAudioIO->EnqueueScrubByPosition
-      (time, seek ? 1.0 : mMaxScrubSpeed, seek);
-}
-
-bool TrackPanel::StopScrubbing()
-{
-   if (IsScrubbing())
-   {
-      if (gAudioIO->IsBusy()) {
-         AudacityProject *p = GetActiveProject();
-         if (p) {
-            ControlToolBar * ctb = p->GetControlToolBar();
-            ctb->StopPlaying();
-         }
-      }
-      return true;
-   }
-   else
-      return false;
-}
-#endif
-
-
 /// This method gets called when we're handling selection
 /// and the mouse was just clicked.
 void TrackPanel::SelectionHandleClick(wxMouseEvent & event,
@@ -2302,7 +1987,7 @@ void TrackPanel::SelectionHandleClick(wxMouseEvent & event,
          event.LeftDClick() ||
 #endif
          event.LeftDown()) {
-         MarkScrubStart(
+         GetProject()->GetScrubber().MarkScrubStart(
             event.m_x
 #ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
             , event.LeftDClick()
@@ -2313,7 +1998,7 @@ void TrackPanel::SelectionHandleClick(wxMouseEvent & event,
 
 #else
 
-      StartOrJumpPlayback(event);
+      // StartOrJumpPlayback(event);
 
 #endif
 
@@ -3038,11 +2723,11 @@ void TrackPanel::Stretch(int mouseXCoordinate, int trackLeftEdge,
 void TrackPanel::SelectionHandleDrag(wxMouseEvent & event, Track *clickedTrack)
 {
 #ifdef EXPERIMENTAL_SCRUBBING_BASIC
-   if (mScrubStartPosition >= 0) {
+   Scrubber &scrubber = GetProject()->GetScrubber();
-      MaybeStartScrubbing(event);
+   if (scrubber.IsScrubbing() ||
+       GetProject()->GetScrubber().MaybeStartScrubbing(event))
       // Do nothing more, don't change selection
       return;
-   }
 #endif
 
    // AS: If we're not in the process of selecting (set in
@@ -5885,7 +5570,7 @@ void TrackPanel::HandleWheelRotation(wxMouseEvent & event)
 #ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
        // Don't pan during smooth scrolling.  That would conflict with keeping
        // the play indicator centered.
-       && !mSmoothScrollingScrub
+       && !GetProject()->GetScrubber().IsScrollScrubbing()
 #endif
       )
    {
@@ -5917,7 +5602,7 @@ void TrackPanel::HandleWheelRotation(wxMouseEvent & event)
       wxCoord xx;
       double center_h;
 #ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-      if (mSmoothScrollingScrub) {
+      if (GetProject()->GetScrubber().IsScrollScrubbing()) {
          // Expand or contract about the center, ignoring mouse position
          center_h = mViewInfo->h + (GetScreenEndTime() - mViewInfo->h) / 2.0;
          xx = mViewInfo->TimeToPosition(center_h, trackLeftEdge);
@@ -5953,21 +5638,8 @@ void TrackPanel::HandleWheelRotation(wxMouseEvent & event)
    else
    {
 #ifdef EXPERIMENTAL_SCRUBBING_SCROLL_WHEEL
-      if (IsScrubbing()) {
+      if (GetProject()->GetScrubber().IsScrubbing()) {
-         const int newLogMaxScrubSpeed = mLogMaxScrubSpeed + steps;
+         GetProject()->GetScrubber().HandleScrollWheel(steps);
-         static const double maxScrubSpeedBase =
-            pow(2.0, 1.0 / ScrubSpeedStepsPerOctave);
-         double newSpeed = pow(maxScrubSpeedBase, newLogMaxScrubSpeed);
-         if (newSpeed >= AudioIO::GetMinScrubSpeed() &&
-             newSpeed <= AudioIO::GetMaxScrubSpeed()) {
-            mLogMaxScrubSpeed = newLogMaxScrubSpeed;
-            mMaxScrubSpeed = newSpeed;
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-            if (!mSmoothScrollingScrub)
-#endif
-               // Show the speed for one second
-               mScrubSpeedDisplayCountdown = kOneSecondCountdown + 1;
-         }
       }
       else
 #endif
@@ -6718,12 +6390,12 @@ void TrackPanel::HandleTrackSpecificMouseEvent(wxMouseEvent & event)
    }
 
 #ifdef EXPERIMENTAL_SCRUBBING_BASIC
-   if (IsScrubbing() &&
+   if (GetProject()->GetScrubber().IsScrubbing() &&
        GetRect().Contains(event.GetPosition()) &&
        (!pTrack ||
         pTrack->GetKind() == Track::Wave)) {
       if (event.LeftDown()) {
-         mScrubSeekPress = true;
+         GetProject()->GetScrubber().SetSeeking();
          return;
       }
       else if (event.LeftIsDown())
@@ -7241,204 +6913,6 @@ void TrackPanel::DrawEverythingElse(wxDC * dc,
    }
 }
 
-#ifdef EXPERIMENTAL_SCRUBBING_BASIC
-bool TrackPanel::ShouldDrawScrubSpeed()
-{
-   return IsScrubbing() &&
-      mScrubHasFocus &&
-      ((!PollIsSeeking() && mScrubSpeedDisplayCountdown > 0)
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-      // Draw always for scroll-scrub and for scroll-seek
-      || mSmoothScrollingScrub
-#endif
-   );
-}
-
-void TrackPanel::TimerUpdateScrubbing(double playPos)
-{
-   if (!IsScrubbing()) {
-      mNextScrubRect = wxRect();
-      return;
-   }
-
-   // Call ContinueScrubbing() here in the timer handler
-   // rather than in SelectionHandleDrag()
-   // so that even without drag events, we can instruct the play head to
-   // keep approaching the mouse cursor, when its maximum speed is limited.
-
-   // Thus scrubbing relies mostly on periodic polling of mouse and keys,
-   // not event notifications.  But there are a few event handlers that
-   // leave messages for this routine, in mScrubSeekPress and in mScrubHasFocus.
-
-   // Seek only when the pointer is in the panel.  Else, scrub.
-   const wxMouseState state(::wxGetMouseState());
-   const wxPoint position = ScreenToClient(state.GetPosition());
-   const bool inPanel = GetRect().Contains(position);
-   const bool seek = inPanel && (mScrubSeekPress || PollIsSeeking());
-   if (ContinueScrubbing(position.x, mScrubHasFocus, seek))
-      mScrubSeekPress = false;
-   // else, if seek requested, try again at a later time when we might
-   // enqueue a long enough stutter
-
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-   if (mSmoothScrollingScrub)
-      ;
-   else
-#endif
-   {
-      if (mScrubSpeedDisplayCountdown > 0)
-         --mScrubSpeedDisplayCountdown;
-   }
-
-   if (!ShouldDrawScrubSpeed()) {
-      mNextScrubRect = wxRect();
-   }
-   else {
-      int panelWidth, panelHeight;
-      GetSize(&panelWidth, &panelHeight);
-
-      // Where's the mouse?
-      int xx, yy;
-      ::wxGetMousePosition(&xx, &yy);
-      ScreenToClient(&xx, &yy);
-
-      const bool seeking = PollIsSeeking();
-
-      // Find the text
-      const double speed =
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-         mSmoothScrollingScrub
-         ? seeking
-            ? FindSeekSpeed(mViewInfo->PositionToTime(xx, GetLeftOffset()))
-            : FindScrubSpeed(mViewInfo->PositionToTime(xx, GetLeftOffset()))
-         :
-#endif
-            mMaxScrubSpeed;
-
-      const wxChar *format =
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-         mSmoothScrollingScrub
-         ? seeking
-            ? wxT("%+.2fX")
-            : wxT("%+.2f")
-         :
-#endif
-            wxT("%.2f");
-
-      mNextScrubSpeedText = wxString::Format(format, speed);
-
-      // Find the origin for drawing text
-      wxCoord width, height;
-      {
-         wxClientDC dc(this);
-         static const wxFont labelFont(24, wxSWISS, wxNORMAL, wxNORMAL);
-         dc.SetFont(labelFont);
-         dc.GetTextExtent(mNextScrubSpeedText, &width, &height);
-      }
-      xx = std::max(0, std::min(panelWidth - width, xx - width / 2));
-
-      // Put the text above the cursor, if it fits.
-      enum { offset = 20 };
-      yy -= height + offset;
-      if (yy < 0)
-         yy += height + 2 * offset;
-      yy = std::max(0, std::min(panelHeight - height, yy));
-
-      mNextScrubRect = wxRect(xx, yy, width, height);
-   }
-
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-   if (mSmoothScrollingScrub) {
-      // Pan the view, so that we center the play indicator.
-      const int posX = mViewInfo->TimeToPosition(playPos);
-      int width;
-      GetTracksUsableArea(&width, NULL);
-      const int deltaX = posX - width / 2;
-      mViewInfo->h =
-         mViewInfo->OffsetTimeByPixels(mViewInfo->h, deltaX, true);
-      if (!mViewInfo->bScrollBeyondZero)
-         // Can't scroll too far left
-         mViewInfo->h = std::max(0.0, mViewInfo->h);
-      Refresh(false);
-   }
-#endif
-}
-
-std::pair<wxRect, bool> TrackPanel::GetScrubSpeedRectangle()
-{
-   wxRect rect(mLastScrubRect);
-#if defined(__WXMAC__)
-   rect.Inflate(1, 0);
-#endif
-
-   const bool outdated =
-      (mLastScrubRect != mNextScrubRect) ||
-      (!mLastScrubRect.IsEmpty() && !ShouldDrawScrubSpeed()) ||
-      (mLastScrubSpeedText != mNextScrubSpeedText);
-   return std::make_pair(
-      rect,
-      outdated
-   );
-}
-
-void TrackPanel::UndrawScrubSpeed(wxDC & dc)
-{
-   if (!mLastScrubRect.IsEmpty())
-#if defined(__WXMAC__)
-      // On OSX, if a HiDPI resolution is being used, the line will actually take up
-      // more than 1 pixel (even though it is drawn as 1), so we restore the surrounding
-      // pixels as well.  (This is because the wxClientDC doesn't know about the scaling.)
-      dc.Blit(
-         mLastScrubRect.GetX() - 1, mLastScrubRect.GetY(),
-         mLastScrubRect.GetWidth() + 3, mLastScrubRect.GetHeight(),
-         &mBackingDC,
-         mLastScrubRect.GetX() - 1, mLastScrubRect.GetY());
-#else
-      dc.Blit(
-         mLastScrubRect.GetX(), mLastScrubRect.GetY(),
-         mLastScrubRect.GetWidth(), mLastScrubRect.GetHeight(),
-         &mBackingDC,
-         mLastScrubRect.GetX(), mLastScrubRect.GetY());
-#endif
-}
-
-void TrackPanel::DoDrawScrubSpeed(wxDC &dc)
-{
-   if (!ShouldDrawScrubSpeed())
-      return;
-
-   mLastScrubRect = mNextScrubRect;
-   mLastScrubSpeedText = mNextScrubSpeedText;
-   const bool seeking = PollIsSeeking();
-   if (// Draw for (non-scroll) scrub, sometimes, but never for seek
-       (!seeking && mScrubSpeedDisplayCountdown > 0)
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-      // Draw always for scroll-scrub and for scroll-seek
-      || mSmoothScrollingScrub
-#endif
-
-   ) {
-      static const wxFont labelFont(24, wxSWISS, wxNORMAL, wxNORMAL);
-      dc.SetFont(labelFont);
-
-      // These two colors were previously saturated red and green.  However 
-      // we have a rule to try to only use red for reserved purposes of
-      //  (a) Recording
-      //  (b) Error alerts
-      // So they were changed to 'orange' and 'lime'.
-      static const wxColour clrNoScroll(215, 162, 0), clrScroll(0, 204, 153);
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-      if (mSmoothScrollingScrub)
-         dc.SetTextForeground(clrScroll);
-      else
-#endif
-         dc.SetTextForeground(clrNoScroll);
-
-      dc.DrawText(mLastScrubSpeedText, mLastScrubRect.GetX(), mLastScrubRect.GetY());
-   }
-}
-#endif
-
 /// Draw zooming indicator that shows the region that will
 /// be zoomed into when the user clicks and drags with a
 /// zoom cursor.  Handles both vertical and horizontal
@@ -9334,18 +8808,6 @@ void TrackPanel::OnKillFocus(wxFocusEvent & WXUNUSED(event))
    Refresh( false);
 }
 
-void TrackPanel::OnActivateOrDeactivateApp(wxActivateEvent &event)
-{
-#ifdef EXPERIMENTAL_SCRUBBING_BASIC
-   if (event.GetActive())
-      mScrubHasFocus = IsScrubbing();
-   else
-      mScrubHasFocus = false;
-#endif
-
-   event.Skip();
-}
-
 /**********************************************************************
 
   TrackInfo code is destined to move out of this file.

src/TrackPanel.h

@@ -74,6 +74,11 @@ enum class UndoPush : unsigned char;
 
 DECLARE_EXPORTED_EVENT_TYPE(AUDACITY_DLL_API, EVT_TRACK_PANEL_TIMER, -1);
 
+enum {
+   kTimerInterval = 50, // milliseconds
+   kOneSecondCountdown = 1000 / kTimerInterval,
+};
+
 class AUDACITY_DLL_API TrackInfo
 {
 public:
@@ -161,7 +166,6 @@ class AUDACITY_DLL_API TrackPanel final : public wxPanel {
 
    virtual void OnSetFocus(wxFocusEvent & event);
    virtual void OnKillFocus(wxFocusEvent & event);
-   virtual void OnActivateOrDeactivateApp(wxActivateEvent & event);
 
    virtual void OnContextMenu(wxContextMenuEvent & event);
 
@@ -251,15 +255,6 @@ class AUDACITY_DLL_API TrackPanel final : public wxPanel {
    virtual bool IsOverCutline(WaveTrack * track, wxRect &rect, wxMouseEvent &event);
    virtual void HandleTrackSpecificMouseEvent(wxMouseEvent & event);
 
-#ifdef EXPERIMENTAL_SCRUBBING_BASIC
-   bool ShouldDrawScrubSpeed();
-   virtual void TimerUpdateScrubbing(double playPos);
-   // Second member of pair indicates whether the cursor is out of date:
-   virtual std::pair<wxRect, bool> GetScrubSpeedRectangle();
-   virtual void UndrawScrubSpeed(wxDC & dc);
-   virtual void DoDrawScrubSpeed(wxDC & dc);
-#endif
-
    virtual void ScrollDuringDrag();
 
    // Working out where to dispatch the event to.
@@ -299,31 +294,7 @@ class AUDACITY_DLL_API TrackPanel final : public wxPanel {
    virtual void HandleSelect(wxMouseEvent & event);
    virtual void SelectionHandleDrag(wxMouseEvent &event, Track *pTrack);
 
-   // Made obsolete by scrubbing:
-#ifndef EXPERIMENTAL_SCRUBBING_BASIC
-   void StartOrJumpPlayback(wxMouseEvent &event);
-#endif
-
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-   double FindScrubSpeed(double timeAtMouse) const;
-   double FindSeekSpeed(double timeAtMouse) const;
-#endif
-
-#ifdef EXPERIMENTAL_SCRUBBING_BASIC
-   static bool PollIsSeeking();
-   bool IsScrubbing();
-   void MarkScrubStart(
-      wxCoord xx
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-      , bool smoothScrolling
-#endif
-   );
-   bool MaybeStartScrubbing(wxMouseEvent &event);
-   bool ContinueScrubbing(wxCoord position, bool hasFocus, bool seek);
-public:
-   bool StopScrubbing();
 protected:
-#endif
 
    virtual void SelectionHandleClick(wxMouseEvent &event,
                                      Track* pTrack, wxRect rect);
@@ -788,27 +759,6 @@ protected:
    int mMoveDownThreshold;
    int mRearrangeCount;
 
-#ifdef EXPERIMENTAL_SCRUBBING_BASIC
-   int mScrubToken;
-   wxLongLong mScrubStartClockTimeMillis;
-   wxCoord mScrubStartPosition;
-   double mMaxScrubSpeed;
-   int mScrubSpeedDisplayCountdown;
-   bool mScrubHasFocus;
-   bool mScrubSeekPress;
-
-   wxRect mLastScrubRect, mNextScrubRect;
-   wxString mLastScrubSpeedText, mNextScrubSpeedText;
-#endif
-
-#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
-   bool mSmoothScrollingScrub;
-#endif
-
-#ifdef EXPERIMENTAL_SCRUBBING_SCROLL_WHEEL
-   int mLogMaxScrubSpeed;
-#endif
-
    std::unique_ptr<wxCursor>
       mArrowCursor, mPencilCursor, mSelectCursor,
       mResizeCursor, mSlideCursor, mEnvelopeCursor, // doubles as the center frequency cursor

src/toolbars/ToolsToolBar.cpp

@@ -52,13 +52,15 @@
 #include "../AllThemeResources.h"
 #include "../ImageManipulation.h"
 #include "../Project.h"
-#ifdef EXPERIMENTAL_SCRUBBING_BASIC
-#include "../TrackPanel.h"
-#endif
 #include "../Theme.h"
-#include "../widgets/AButton.h"
 
 #include "../Experimental.h"
+#ifdef EXPERIMENTAL_SCRUBBING_BASIC
+#include "../tracks/ui/Scrubbing.h"
+#endif
+
+#include "../widgets/AButton.h"
+
 
 IMPLEMENT_CLASS(ToolsToolBar, ToolBar);
 
@@ -219,13 +221,9 @@ void ToolsToolBar::SetCurrentTool(int tool, bool show)
 
 #ifdef EXPERIMENTAL_SCRUBBING_BASIC
    if (tool != selectTool) {
-      AudacityProject *p = GetActiveProject();
+      AudacityProject *const p = GetActiveProject();
-      if (p) {
+      if (p)
-         TrackPanel *tp = p->GetTrackPanel();
+         p->GetScrubber().StopScrubbing();
-         if (tp) {
-            tp->StopScrubbing();
-         }
-      }
    }
 #endif
 
@@ -294,13 +292,9 @@ void ToolsToolBar::OnTool(wxCommandEvent & evt)
 
 #ifdef EXPERIMENTAL_SCRUBBING_BASIC
    if (0 != mCurrentTool) {
-      AudacityProject *p = GetActiveProject();
+      AudacityProject *const p = GetActiveProject();
-      if (p) {
+      if (p)
-         TrackPanel *tp = p->GetTrackPanel();
+         p->GetScrubber().StopScrubbing();
-         if (tp) {
-            tp->StopScrubbing();
-         }
-      }
    }
 #endif
 

src/tracks/ui/Scrubbing.cpp

@@ -9,16 +9,385 @@ Paul Licameli split from TrackPanel.cpp
 **********************************************************************/
 
 #include "Scrubbing.h"
+#include "../../Experimental.h"
 
+#include "../../AudioIO.h"
 #include "../../Project.h"
 #include "../../TrackPanel.h"
 #include "../../TrackPanelCell.h"
 #include "../../TrackPanelCellIterator.h"
+#include "../../toolbars/ControlToolBar.h"
+
+#include <algorithm>
 
 #include <wx/dc.h>
 
+enum {
+   // PRL:
+   // Mouse must move at least this far to distinguish ctrl-drag to scrub
+   // from ctrl-click for playback.
+   SCRUBBING_PIXEL_TOLERANCE = 10,
+
+#ifdef EXPERIMENTAL_SCRUBBING_SCROLL_WHEEL
+   ScrubSpeedStepsPerOctave = 4,
+#endif
+};
+
+namespace {
+   bool PollIsSeeking()
+   {
+      return ::wxGetMouseState().LeftIsDown();
+   }
+
+   double FindScrubbingSpeed(const ViewInfo &viewInfo, double maxScrubSpeed, double screen, double timeAtMouse)
+   {
+      // Map a time (which was mapped from a mouse position)
+      // to a speed.
+      // Map times to positive and negative speeds,
+      // with the time at the midline of the screen mapping to 0,
+      // and the extremes to the maximum scrub speed.
+
+      // Width of visible track area, in time terms:
+      const double origin = viewInfo.h + screen / 2.0;
+
+      // There are various snapping zones that are this fraction of screen:
+      const double snap = 0.05;
+
+      // By shrinking denom a bit, we make margins left and right
+      // that snap to maximum and negative maximum speeds.
+      const double factor = 1.0 - (snap * 2);
+      const double denom = factor * screen / 2.0;
+      double fraction = std::min(1.0, fabs(timeAtMouse - origin) / denom);
+
+      // Snap to 1.0 and -1.0
+      const double unity = 1.0 / maxScrubSpeed;
+      const double tolerance = snap / factor;
+      // Make speeds near 1 available too by remapping fractions outside
+      // this snap zone
+      if (fraction <= unity - tolerance)
+         fraction *= unity / (unity - tolerance);
+      else if (fraction < unity + tolerance)
+         fraction = unity;
+      else
+         fraction = unity + (fraction - (unity + tolerance)) *
+         (1.0 - unity) / (1.0 - (unity + tolerance));
+
+      double result = fraction * maxScrubSpeed;
+      if (timeAtMouse < origin)
+         result *= -1.0;
+      return result;
+   }
+
+   double FindSeekSpeed(const ViewInfo &viewInfo, double maxScrubSpeed, double screen, double timeAtMouse)
+   {
+      // Map a time (which was mapped from a mouse position)
+      // to a signed skip speed: a multiplier of the stutter duration,
+      // by which to advance the play position.
+      // (The stutter will play at unit speed.)
+
+      // Times near the midline of the screen map to skip-less play,
+      // and the extremes to a value proportional to maximum scrub speed.
+
+      // If the maximum scrubbing speed defaults to 1.0 when you begin to scroll-scrub,
+      // the extreme skipping for scroll-seek needs to be larger to be useful.
+      static const double ARBITRARY_MULTIPLIER = 10.0;
+      const double extreme = std::max(1.0, maxScrubSpeed * ARBITRARY_MULTIPLIER);
+
+      // Width of visible track area, in time terms:
+      const double halfScreen = screen / 2.0;
+      const double origin = viewInfo.h + halfScreen;
+
+      // The snapping zone is this fraction of screen, on each side of the
+      // center line:
+      const double snap = 0.05;
+      const double fraction =
+         std::max(snap, std::min(1.0, fabs(timeAtMouse - origin) / halfScreen));
+
+      double result = 1.0 + ((fraction - snap) / (1.0 - snap)) * (extreme - 1.0);
+      if (timeAtMouse < origin)
+         result *= -1.0;
+      return result;
+   }
+}
+
+Scrubber::Scrubber(AudacityProject *project)
+   : mScrubToken(-1)
+   , mScrubStartClockTimeMillis(-1)
+   , mScrubHasFocus(false)
+   , mScrubSpeedDisplayCountdown(0)
+   , mScrubStartPosition(-1)
+   , mMaxScrubSpeed(-1.0)
+   , mScrubSeekPress(false)
+#ifdef EXPERIMENTAL_SCRUBBING_SCROLL_WHEEL
+   , mSmoothScrollingScrub(false)
+   , mLogMaxScrubSpeed(0)
+#endif
+
+   , mProject(project)
+{
+   if (wxTheApp)
+      wxTheApp->Connect
+      (wxEVT_ACTIVATE_APP,
+      wxActivateEventHandler(Scrubber::OnActivateOrDeactivateApp), NULL, this);
+}
+
+Scrubber::~Scrubber()
+{
+   if (wxTheApp)
+      wxTheApp->Disconnect
+      (wxEVT_ACTIVATE_APP,
+      wxActivateEventHandler(Scrubber::OnActivateOrDeactivateApp), NULL, this);
+}
+
+void Scrubber::MarkScrubStart(
+   wxCoord xx
+#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
+   , bool smoothScrolling
+#endif
+)
+{
+   // Don't actually start scrubbing, but collect some information
+   // needed for the decision to start scrubbing later when handling
+   // drag events.
+#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
+   mSmoothScrollingScrub = smoothScrolling;
+#endif
+   mScrubStartPosition = xx;
+   mScrubStartClockTimeMillis = ::wxGetLocalTimeMillis();
+}
+
+#ifdef EXPERIMENTAL_SCRUBBING_SUPPORT
+bool Scrubber::MaybeStartScrubbing(const wxMouseEvent &event)
+{
+   if (mScrubStartPosition < 0)
+      return false;
+   if (IsScrubbing())
+      return false;
+   else {
+      const bool busy = gAudioIO->IsBusy();
+      if (busy && gAudioIO->GetNumCaptureChannels() > 0) {
+         // Do not stop recording, and don't try to start scrubbing after
+         // recording stops
+         mScrubStartPosition = -1;
+         return false;
+      }
+
+      wxCoord position = event.m_x;
+      if (abs(mScrubStartPosition - position) >= SCRUBBING_PIXEL_TOLERANCE) {
+         const ViewInfo &viewInfo = mProject->GetViewInfo();
+         TrackPanel *const trackPanel = mProject->GetTrackPanel();
+         ControlToolBar * const ctb = mProject->GetControlToolBar();
+         double maxTime = mProject->GetTracks()->GetEndTime();
+         const int leftOffset = trackPanel->GetLeftOffset();
+         double time0 = std::min(maxTime,
+            viewInfo.PositionToTime(mScrubStartPosition, leftOffset)
+         );
+         double time1 = std::min(maxTime,
+            viewInfo.PositionToTime(position, leftOffset)
+         );
+         if (time1 != time0)
+         {
+            if (busy)
+               ctb->StopPlaying();
+
+            AudioIOStartStreamOptions options(mProject->GetDefaultPlayOptions());
+            options.timeTrack = NULL;
+            options.scrubDelay = (kTimerInterval / 1000.0);
+            options.scrubStartClockTimeMillis = mScrubStartClockTimeMillis;
+            options.minScrubStutter = 0.2;
+#if 0
+            // Take the starting speed limit from the transcription toolbar,
+            // but it may be varied during the scrub.
+            mMaxScrubSpeed = options.maxScrubSpeed =
+               p->GetTranscriptionToolBar()->GetPlaySpeed();
+#else
+            // That idea seems unpopular... just make it one
+            mMaxScrubSpeed = options.maxScrubSpeed = 1.0;
+#endif
+            options.maxScrubTime = mProject->GetTracks()->GetEndTime();
+            const bool cutPreview = false;
+            const bool backwards = time1 < time0;
+#ifdef EXPERIMENTAL_SCRUBBING_SCROLL_WHEEL
+            static const double maxScrubSpeedBase =
+               pow(2.0, 1.0 / ScrubSpeedStepsPerOctave);
+            mLogMaxScrubSpeed = floor(0.5 +
+               log(mMaxScrubSpeed) / log(maxScrubSpeedBase)
+            );
+#endif
+            mScrubSpeedDisplayCountdown = 0;
+            mScrubToken =
+               ctb->PlayPlayRegion(SelectedRegion(time0, time1), options, cutPreview, backwards);
+         }
+      }
+      else
+         // Wait to test again
+         mScrubStartClockTimeMillis = ::wxGetLocalTimeMillis();
+
+      if (IsScrubbing())
+         mScrubHasFocus = true;
+
+      // Return true whether we started scrub, or are still waiting to decide.
+      return true;
+   }
+}
+
+void Scrubber::ContinueScrubbing()
+{
+   // Thus scrubbing relies mostly on periodic polling of mouse and keys,
+   // not event notifications.  But there are a few event handlers that
+   // leave messages for this routine, in mScrubSeekPress and in mScrubHasFocus.
+
+   // Seek only when the pointer is in the panel.  Else, scrub.
+   const wxMouseState state(::wxGetMouseState());
+   TrackPanel *const trackPanel = mProject->GetTrackPanel();
+   const wxPoint position = trackPanel->ScreenToClient(state.GetPosition());
+   const bool inPanel = trackPanel->GetRect().Contains(position);
+   const bool seek = inPanel && (mScrubSeekPress || PollIsSeeking());
+   // When we don't have focus, enqueue silent scrubs until we regain focus.
+   bool result = false;
+   if (!mScrubHasFocus)
+      result = gAudioIO->EnqueueScrubBySignedSpeed(0, mMaxScrubSpeed, false);
+   else {
+      const double time = mProject->GetViewInfo().PositionToTime(position.x, trackPanel->GetLeftOffset());
+
+      if (seek)
+         // Cause OnTimer() to suppress the speed display
+         mScrubSpeedDisplayCountdown = 1;
+
+#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
+      if (mSmoothScrollingScrub) {
+         const double speed = FindScrubSpeed(seek, time);
+         result = gAudioIO->EnqueueScrubBySignedSpeed(speed, mMaxScrubSpeed, seek);
+      }
+      else
+#endif
+         result = gAudioIO->EnqueueScrubByPosition
+         (time, seek ? 1.0 : mMaxScrubSpeed, seek);
+   }
+
+   if (result)
+      mScrubSeekPress = false;
+   // else, if seek requested, try again at a later time when we might
+   // enqueue a long enough stutter
+
+#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
+   if (mSmoothScrollingScrub)
+      ;
+   else
+#endif
+   {
+      if (mScrubSpeedDisplayCountdown > 0)
+         --mScrubSpeedDisplayCountdown;
+   }
+
+#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
+   if (mSmoothScrollingScrub) {
+      // Pan the view, so that we center the play indicator.
+
+      ViewInfo &viewInfo = mProject->GetViewInfo();
+      TrackPanel *const trackPanel = mProject->GetTrackPanel();
+      const int posX = viewInfo.TimeToPosition(viewInfo.mRecentStreamTime);
+      int width;
+      trackPanel->GetTracksUsableArea(&width, NULL);
+      const int deltaX = posX - width / 2;
+      viewInfo.h =
+         viewInfo.OffsetTimeByPixels(viewInfo.h, deltaX, true);
+      if (!viewInfo.bScrollBeyondZero)
+         // Can't scroll too far left
+         viewInfo.h = std::max(0.0, viewInfo.h);
+      trackPanel->Refresh(false);
+   }
+#endif
+}
+
+bool Scrubber::StopScrubbing()
+{
+   if (IsScrubbing())
+   {
+      if (gAudioIO->IsBusy()) {
+         ControlToolBar *const ctb = mProject->GetControlToolBar();
+         ctb->StopPlaying();
+      }
+      return true;
+   }
+   else
+      return false;
+}
+
+bool Scrubber::IsScrubbing() const
+{
+   if (mScrubToken <= 0)
+      return false;
+   else if (mScrubToken == mProject->GetAudioIOToken())
+      return true;
+   else {
+      const_cast<Scrubber&>(*this).mScrubToken = -1;
+      const_cast<Scrubber&>(*this).mScrubStartPosition = -1;
+#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
+      const_cast<Scrubber&>(*this).mSmoothScrollingScrub = false;
+#endif
+      return false;
+   }
+}
+
+bool Scrubber::ShouldDrawScrubSpeed()
+{
+   return IsScrubbing() &&
+      mScrubHasFocus && (
+      // Draw for (non-scroll) scrub, sometimes, but never for seek
+      (!PollIsSeeking() && mScrubSpeedDisplayCountdown > 0)
+#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
+      // Draw always for scroll-scrub and for scroll-seek
+       || mSmoothScrollingScrub
+#endif
+      );
+}
+
+double Scrubber::FindScrubSpeed(bool seeking, double time) const
+{
+   ViewInfo &viewInfo = mProject->GetViewInfo();
+   const double screen = mProject->GetScreenEndTime() - viewInfo.h;
+   return (seeking ? FindSeekSpeed : FindScrubbingSpeed)
+      (viewInfo, mMaxScrubSpeed, screen, time);
+}
+
+void Scrubber::HandleScrollWheel(int steps)
+{
+   const int newLogMaxScrubSpeed = mLogMaxScrubSpeed + steps;
+   static const double maxScrubSpeedBase =
+      pow(2.0, 1.0 / ScrubSpeedStepsPerOctave);
+   double newSpeed = pow(maxScrubSpeedBase, newLogMaxScrubSpeed);
+   if (newSpeed >= AudioIO::GetMinScrubSpeed() &&
+      newSpeed <= AudioIO::GetMaxScrubSpeed()) {
+      mLogMaxScrubSpeed = newLogMaxScrubSpeed;
+      mMaxScrubSpeed = newSpeed;
+#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
+      if (!mSmoothScrollingScrub)
+#endif
+         // Show the speed for one second
+         mScrubSpeedDisplayCountdown = kOneSecondCountdown + 1;
+   }
+}
+
+void Scrubber::OnActivateOrDeactivateApp(wxActivateEvent &event)
+{
+   if (event.GetActive())
+      mScrubHasFocus = IsScrubbing();
+   else
+      mScrubHasFocus = false;
+
+   event.Skip();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// class ScrubbingOverlay is responsible for drawing the speed numbers
+
 ScrubbingOverlay::ScrubbingOverlay(AudacityProject *project)
    : mProject(project)
+   , mLastScrubRect()
+   , mNextScrubRect()
+   , mLastScrubSpeedText()
+   , mNextScrubSpeedText()
 {
    mProject->Connect(EVT_TRACK_PANEL_TIMER,
       wxCommandEventHandler(ScrubbingOverlay::OnTimer),
@@ -36,18 +405,130 @@ ScrubbingOverlay::~ScrubbingOverlay()
 
 std::pair<wxRect, bool> ScrubbingOverlay::DoGetRectangle(wxSize)
 {
-   return std::make_pair(wxRect(), false);
+   wxRect rect(mLastScrubRect);
+   const bool outdated =
+      (mLastScrubRect != mNextScrubRect) ||
+      (!mLastScrubRect.IsEmpty() && !GetScrubber().ShouldDrawScrubSpeed()) ||
+      (mLastScrubSpeedText != mNextScrubSpeedText);
+   return std::make_pair(
+      rect,
+      outdated
+   );
 }
 
 void ScrubbingOverlay::Draw
-   (wxDC &dc, TrackPanelCellIterator begin, TrackPanelCellIterator end)
+   (wxDC &dc, TrackPanelCellIterator, TrackPanelCellIterator)
 {
+   mLastScrubRect = mNextScrubRect;
+   mLastScrubSpeedText = mNextScrubSpeedText;
+
+   Scrubber &scrubber = GetScrubber();
+   if (!scrubber.ShouldDrawScrubSpeed())
+      return;
+
+   static const wxFont labelFont(24, wxSWISS, wxNORMAL, wxNORMAL);
+   dc.SetFont(labelFont);
+
+   // These two colors were previously saturated red and green.  However
+   // we have a rule to try to only use red for reserved purposes of
+   //  (a) Recording
+   //  (b) Error alerts
+   // So they were changed to 'orange' and 'lime'.
+   static const wxColour clrNoScroll(215, 162, 0), clrScroll(0, 204, 153);
+#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
+   if (scrubber.IsScrollScrubbing())
+      dc.SetTextForeground(clrScroll);
+   else
+#endif
+      dc.SetTextForeground(clrNoScroll);
+
+   dc.DrawText(mLastScrubSpeedText, mLastScrubRect.GetX(), mLastScrubRect.GetY());
 }
 
+
 void ScrubbingOverlay::OnTimer(wxCommandEvent &event)
 {
    // Let other listeners get the notification
    event.Skip();
 
-   // To do: move code here
+   Scrubber &scrubber = GetScrubber();
+   if (!GetScrubber().IsScrubbing()) {
+      mNextScrubRect = wxRect();
+      return;
+   }
+
+   // Call ContinueScrubbing() here in the timer handler
+   // rather than in SelectionHandleDrag()
+   // so that even without drag events, we can instruct the play head to
+   // keep approaching the mouse cursor, when its maximum speed is limited.
+   scrubber.ContinueScrubbing();
+
+   if (!scrubber.ShouldDrawScrubSpeed()) {
+      mNextScrubRect = wxRect();
+   }
+   else {
+      TrackPanel *const trackPanel = mProject->GetTrackPanel();
+      int panelWidth, panelHeight;
+      trackPanel->GetSize(&panelWidth, &panelHeight);
+
+      // Where's the mouse?
+      int xx, yy;
+      ::wxGetMousePosition(&xx, &yy);
+      trackPanel->ScreenToClient(&xx, &yy);
+
+      const bool seeking = PollIsSeeking();
+
+      // Find the text
+      const double maxScrubSpeed = GetScrubber().GetMaxScrubSpeed();
+      const double speed =
+#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
+         scrubber.IsScrollScrubbing()
+         ? scrubber.FindScrubSpeed
+            (seeking, mProject->GetViewInfo().PositionToTime(xx, trackPanel->GetLeftOffset()))
+         :
+#endif
+            maxScrubSpeed;
+
+      const wxChar *format =
+#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
+         scrubber.IsScrollScrubbing()
+         ? seeking
+            ? wxT("%+.2fX")
+            : wxT("%+.2f")
+         :
+#endif
+            wxT("%.2f");
+
+      mNextScrubSpeedText = wxString::Format(format, speed);
+
+      // Find the origin for drawing text
+      wxCoord width, height;
+      {
+         wxClientDC dc(trackPanel);
+         static const wxFont labelFont(24, wxSWISS, wxNORMAL, wxNORMAL);
+         dc.SetFont(labelFont);
+         dc.GetTextExtent(mNextScrubSpeedText, &width, &height);
+      }
+      xx = std::max(0, std::min(panelWidth - width, xx - width / 2));
+
+      // Put the text above the cursor, if it fits.
+      enum { offset = 20 };
+      yy -= height + offset;
+      if (yy < 0)
+         yy += height + 2 * offset;
+      yy = std::max(0, std::min(panelHeight - height, yy));
+
+      mNextScrubRect = wxRect(xx, yy, width, height);
+   }
 }
+
+const Scrubber &ScrubbingOverlay::GetScrubber() const
+{
+   return mProject->GetScrubber();
+}
+
+Scrubber &ScrubbingOverlay::GetScrubber()
+{
+   return mProject->GetScrubber();
+}
+#endif

src/tracks/ui/Scrubbing.h

@@ -12,12 +12,65 @@ Paul Licameli split from TrackPanel.cpp
 #define __AUDACITY_SCRUBBING__
 
 #include <wx/event.h>
+#include <wx/longlong.h>
 
+#include "../../Experimental.h"
 #include "../../TrackPanelOverlay.h"
 
 class AudacityProject;
 
-class ScrubbingOverlay : public wxEvtHandler, public TrackPanelOverlay
+// Scrub state object
+class Scrubber : public wxEvtHandler
+{
+public:
+   Scrubber(AudacityProject *project);
+   ~Scrubber();
+
+   void MarkScrubStart(
+      wxCoord xx
+#ifdef EXPERIMENTAL_SCRUBBING_SMOOTH_SCROLL
+      , bool smoothScrolling
+#endif
+   );
+   // Returns true iff the event should be considered consumed by this:
+   bool MaybeStartScrubbing(const wxMouseEvent &event);
+   void ContinueScrubbing();
+   bool StopScrubbing();
+
+   bool IsScrubbing() const;
+   bool IsScrollScrubbing() const // If true, implies IsScrubbing()
+   { return mSmoothScrollingScrub; }
+
+   bool ShouldDrawScrubSpeed();
+   double FindScrubSpeed(bool seeking, double time) const;
+   double GetMaxScrubSpeed() const { return mMaxScrubSpeed; }
+
+   void HandleScrollWheel(int steps);
+
+   void SetSeeking() { mScrubSeekPress = true; }
+
+private:
+   int mScrubToken;
+   wxLongLong mScrubStartClockTimeMillis;
+   bool mScrubHasFocus;
+   int mScrubSpeedDisplayCountdown;
+   wxCoord mScrubStartPosition;
+   double mMaxScrubSpeed;
+   bool mScrubSeekPress;
+   bool mSmoothScrollingScrub;
+
+#ifdef EXPERIMENTAL_SCRUBBING_SCROLL_WHEEL
+   int mLogMaxScrubSpeed;
+#endif
+
+private:
+   void OnActivateOrDeactivateApp(wxActivateEvent & event);
+
+   AudacityProject *mProject;
+};
+
+// Specialist in drawing the scrub speed, and listening for certain events
+class ScrubbingOverlay final : public wxEvtHandler, public TrackPanelOverlay
 {
 public:
    ScrubbingOverlay(AudacityProject *project);
@@ -30,7 +83,13 @@ private:
 
    void OnTimer(wxCommandEvent &event);
 
+   const Scrubber &GetScrubber() const;
+   Scrubber &GetScrubber();
+
    AudacityProject *mProject;
+
+   wxRect mLastScrubRect, mNextScrubRect;
+   wxString mLastScrubSpeedText, mNextScrubSpeedText;
 };
 
 #endif