Scrubber Class Reference

#include <Scrubbing.h>

Inheritance diagram for Scrubber:

Collaboration diagram for Scrubber:

Classes
class	ScrubPoller

Public Member Functions
	Scrubber (AudacityProject *project)
	Scrubber (const Scrubber &)=delete
Scrubber &	operator= (const Scrubber &)=delete
	~Scrubber ()
void	MarkScrubStart (wxCoord xx, bool smoothScrolling, bool seek)
bool	MaybeStartScrubbing (wxCoord xx)
bool	StartKeyboardScrubbing (double time0, bool backwards)
double	GetKeyboardScrubbingSpeed ()
void	ContinueScrubbingUI ()
void	ContinueScrubbingPoll ()
void	StopScrubbing ()
wxCoord	GetScrubStartPosition () const
bool	WasSpeedPlaying () const
bool	IsSpeedPlaying () const
bool	WasKeyboardScrubbing () const
bool	IsKeyboardScrubbing () const
void	SetBackwards (bool backwards)
bool	IsBackwards () const
bool	HasMark () const
bool	IsScrubbing () const
bool	IsScrollScrubbing () const
void	SetScrollScrubbing (bool value)
bool	ChoseSeeking () const
void	SetMayDragToSeek (bool value)
bool	MayDragToSeek () const
bool	TemporarilySeeks () const
bool	Seeks () const
bool	Scrubs () const
bool	ShowsBar () const
void	Cancel ()
bool	ShouldDrawScrubSpeed ()
double	FindScrubSpeed (bool seeking, double time) const
double	GetMaxScrubSpeed () const
void	HandleScrollWheel (int steps)
bool	CanScrub () const
void	PopulatePopupMenu (wxMenu &menu)
void	OnScrubOrSeek (bool seek)
void	OnScrub (const CommandContext &)
void	OnSeek (const CommandContext &)
void	OnToggleScrubRuler (const CommandContext &)
void	OnKeyboardScrubBackwards (const CommandContext &)
void	OnKeyboardScrubForwards (const CommandContext &)
void	DoKeyboardScrub (bool backwards, bool keyUp)
template<void(Scrubber::*)(const CommandContext &) pfn>
void	Thunk (wxCommandEvent &)
const TranslatableString &	GetUntranslatedStateString () const
wxString	StatusMessageForWave () const
void	Pause (bool paused)
bool	IsPaused () const
void	CheckMenuItems ()
bool	IsTransportingPinned () const
void	SetSeekPress (bool value)
Public Member Functions inherited from ClientData::Base
virtual	~Base ()

Static Public Member Functions
static Scrubber &	Get (AudacityProject &project)
static const Scrubber &	Get (const AudacityProject &project)
static bool	ShouldScrubPinned ()

Private Member Functions
void	UpdatePrefs () override
void	StartPolling ()
void	StopPolling ()
void	DoScrub (bool seek)
void	OnActivateOrDeactivateApp (wxActivateEvent &event)
void	ScrubPollerThread ()
void	JoinThread ()
Private Member Functions inherited from PrefsListener
	PrefsListener ()
virtual	~PrefsListener ()
virtual void	UpdatePrefs ()=0
virtual void	UpdateSelectedPrefs (int id)

Private Attributes
int	mScrubToken
int	mScrubSpeedDisplayCountdown
wxCoord	mScrubStartPosition
wxCoord	mLastScrubPosition {}
bool	mScrubSeekPress {}
bool	mSmoothScrollingScrub
bool	mPaused {}
bool	mSeeking {}
bool	mSpeedPlaying {true}
bool	mKeyboardScrubbing {}
bool	mBackwards {}
bool	mDragging {}
bool	mCancelled {}
int	mLogMaxScrubSpeed
AudacityProject *	mProject
std::unique_ptr< ScrubPoller >	mPoller
ScrubbingOptions	mOptions
double	mMaxSpeed { 1.0 }
bool	mShowScrubbing { false }
bool	mMayDragToSeek { false }

Additional Inherited Members
Static Private Member Functions inherited from PrefsListener
static void	Broadcast (int id=0)
	Call this static function to notify all PrefsListener objects. More...

Detailed Description

Definition at line 39 of file Scrubbing.h.

Constructor & Destructor Documentation

Scrubber() [1/2]

Scrubber::Scrubber ( AudacityProject *  project )

explicit

Definition at line 196 of file Scrubbing.cpp.

   : mScrubToken(-1)
   , mScrubSpeedDisplayCountdown(0)
   , mScrubStartPosition(-1)
   , mSmoothScrollingScrub(false)
   , mPaused(true)
   , mLogMaxScrubSpeed(0)
 
   , mProject(project)
   , mPoller { std::make_unique<ScrubPoller>(*this) }
   , mOptions {}
 
{
   if (wxTheApp)
      wxTheApp->Bind
      (wxEVT_ACTIVATE_APP,
       &Scrubber::OnActivateOrDeactivateApp, this);
 
   UpdatePrefs();
}

References OnActivateOrDeactivateApp(), and UpdatePrefs().

Here is the call graph for this function:

Scrubber() [2/2]

Scrubber::Scrubber ( const Scrubber &  )

delete

~Scrubber()

Scrubber::~Scrubber

(

)

Definition at line 227 of file Scrubbing.cpp.

{
   JoinThread();
}

References JoinThread().

Here is the call graph for this function:

Member Function Documentation

Cancel()

void Scrubber::Cancel ( )

inline

Definition at line 106 of file Scrubbing.h.

   { mCancelled = true; }

Referenced by OnActivateOrDeactivateApp().

Here is the caller graph for this function:

CanScrub()

bool Scrubber::CanScrub

(

)

const

Definition at line 1038 of file Scrubbing.cpp.

{
   // Recheck the same condition as enables the Scrub/Seek menu item.
   auto gAudioIO = AudioIO::Get();
   return !( gAudioIO->IsBusy() && gAudioIO->GetNumCaptureChannels() > 0 ) &&
      HasWaveDataPred( *mProject );
}

References AudioIO::Get(), HasWaveDataPred, and mProject.

Referenced by DoScrub().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckMenuItems()

void Scrubber::CheckMenuItems

(

)

Definition at line 1190 of file Scrubbing.cpp.

{
   auto &cm = CommandManager::Get( *mProject );
   for (const auto &item : menuItems()) {
      auto test = item.StatusTest;
      if (test)
         cm.Check(item.name, (this->*test)());
   }
}

References CommandManager::Get(), anonymous_namespace{Scrubbing.cpp}::menuItems(), and mProject.

Referenced by MarkScrubStart(), OnScrub(), OnScrubOrSeek(), OnSeek(), OnToggleScrubRuler(), and StopScrubbing().

Here is the call graph for this function:

Here is the caller graph for this function:

ChoseSeeking()

bool Scrubber::ChoseSeeking

(

)

const

Definition at line 784 of file Scrubbing.cpp.

{
   return
#if !defined(DRAG_SCRUB)
      // Drag always seeks
      mDragging ||
#endif
      mSeeking;
}

References mDragging, and mSeeking.

Referenced by Scrubs(), and Seeks().

Here is the caller graph for this function:

ContinueScrubbingPoll()

void Scrubber::ContinueScrubbingPoll

(

)

Definition at line 573 of file Scrubbing.cpp.

{
   // 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 mPaused.
 
   // Decide whether to skip play, because either mouse is down now,
   // or there was a left click event.  (This is then a delayed reaction, in a
   // timer callback, to a left click event detected elsewhere.)
   const bool seek = TemporarilySeeks() || Seeks();
 
   auto gAudioIO = AudioIO::Get();
   if (mPaused) {
      // When paused, make silent scrubs.
      mOptions.minSpeed = 0.0;
      mOptions.maxSpeed = mMaxSpeed;
      mOptions.adjustStart = false;
      mOptions.bySpeed = true;
      ScrubState::UpdateScrub(0, mOptions);
   }
   else if (mSpeedPlaying) {
      // default speed of 1.3 set, so that we can hear there is a problem
      // when playAtSpeedTB not found.
      double speed = 1.3;
      const auto &projectAudioIO = ProjectAudioIO::Get( *mProject );
      speed = projectAudioIO.GetPlaySpeed();
      mOptions.minSpeed = speed -0.01;
      mOptions.maxSpeed = speed +0.01;
      mOptions.adjustStart = false;
      mOptions.bySpeed = true;
      ScrubState::UpdateScrub(speed, mOptions);
   }
   else if (mKeyboardScrubbing) {
      mOptions.minSpeed = ScrubbingOptions::MinAllowedScrubSpeed();
      mOptions.maxSpeed = ScrubbingOptions::MaxAllowedScrubSpeed();
      mOptions.adjustStart = false;
      mOptions.bySpeed = true;
      double speed = GetKeyboardScrubbingSpeed();
      if (mBackwards)
         speed *= -1.0;
      ScrubState::UpdateScrub(speed, mOptions);
   } else {
      const wxMouseState state(::wxGetMouseState());
      auto &trackPanel = GetProjectPanel( *mProject );
      const wxPoint position = trackPanel.ScreenToClient(state.GetPosition());
      auto &viewInfo = ViewInfo::Get( *mProject );
#ifdef DRAG_SCRUB
      if (mDragging && mSmoothScrollingScrub) {
         const auto lastTime = ScrubState::GetLastScrubTime();
         const auto delta = mLastScrubPosition - position.x;
         const double time = viewInfo.OffsetTimeByPixels(lastTime, delta);
         mOptions.minSpeed = 0.0;
         mOptions.maxSpeed = mMaxSpeed;
         mOptions.adjustStart = true;
         mOptions.bySpeed = false;
         gAudioIO->UpdateScrub(time, mOptions);
         mLastScrubPosition = position.x;
      }
      else
#endif
      {
         const auto origin = viewInfo.GetLeftOffset();
         auto xx = position.x;
         if (!seek && !mSmoothScrollingScrub) {
            // If mouse is out-of-bounds, so that we scrub at maximum speed
            // toward the mouse position, then move the target time to a more
            // extreme position to avoid catching-up and halting before the
            // screen scrolls.
            auto width = viewInfo.GetTracksUsableWidth();
            auto delta = xx - origin;
            if (delta < 0)
               delta -= width;
            else if (delta >= width)
               delta += width;
            xx = origin + delta;
         }
         const double time = viewInfo.PositionToTime(xx, origin);
         mOptions.adjustStart = seek;
         mOptions.minSpeed = seek ? 1.0 : 0.0;
         mOptions.maxSpeed = seek ? 1.0 : mMaxSpeed;
 
         if (mSmoothScrollingScrub) {
            const double speed = FindScrubSpeed(seek, time);
            mOptions.bySpeed = true;
            ScrubState::UpdateScrub(speed, mOptions);
         }
         else {
            mOptions.bySpeed = false;
            ScrubState::UpdateScrub(time, mOptions);
         }
      }
   }
 
   mScrubSeekPress = false;
 
   // else, if seek requested, try again at a later time when we might
   // enqueue a long enough stutter
}

References ScrubbingOptions::adjustStart, ScrubbingOptions::bySpeed, FindScrubSpeed(), AudioIO::Get(), ProjectAudioIO::Get(), ViewInfo::Get(), GetKeyboardScrubbingSpeed(), ScrubState::GetLastScrubTime(), GetProjectPanel(), ScrubbingOptions::MaxAllowedScrubSpeed(), ScrubbingOptions::maxSpeed, mBackwards, mDragging, ScrubbingOptions::MinAllowedScrubSpeed(), ScrubbingOptions::minSpeed, mKeyboardScrubbing, mLastScrubPosition, mMaxSpeed, mOptions, mPaused, mProject, mScrubSeekPress, mSmoothScrollingScrub, mSpeedPlaying, Seeks(), TemporarilySeeks(), and ScrubState::UpdateScrub().

Referenced by MaybeStartScrubbing(), Scrubber::ScrubPoller::Notify(), and StartKeyboardScrubbing().

Here is the call graph for this function:

Here is the caller graph for this function:

ContinueScrubbingUI()

void Scrubber::ContinueScrubbingUI

(

)

Definition at line 672 of file Scrubbing.cpp.

{
   const wxMouseState state(::wxGetMouseState());
 
   if (mDragging && !state.LeftIsDown()) {
      // Dragging scrub can stop with mouse up
      // Stop and set cursor
      bool bShift = state.ShiftDown();
      auto &projectAudioManager = ProjectAudioManager::Get( *mProject );
      projectAudioManager.DoPlayStopSelect( true, bShift );
      projectAudioManager.Stop();
      return;
   }
 
   const bool seek = Seeks() || TemporarilySeeks();
 
   {
      // Show the correct status for seeking.
      bool backup = mSeeking;
      mSeeking = seek;
      mSeeking = backup;
   }
 
   if (seek)
      mScrubSpeedDisplayCountdown = 0;
 
   if (mSmoothScrollingScrub)
      ;
   else {
      if (mScrubSpeedDisplayCountdown > 0)
         --mScrubSpeedDisplayCountdown;
   }
}

References ProjectAudioManager::Get(), mDragging, mProject, mScrubSpeedDisplayCountdown, mSeeking, mSmoothScrollingScrub, Seeks(), and TemporarilySeeks().

Referenced by Scrubber::ScrubPoller::Notify().

Here is the call graph for this function:

Here is the caller graph for this function:

DoKeyboardScrub()

void Scrubber::DoKeyboardScrub	(	bool	backwards,
		bool	keyUp
	)

Definition at line 1046 of file Scrubbing.cpp.

{
   auto &project = *mProject;
 
   static double initT0 = 0;
   static double initT1 = 0;
 
   if (keyUp) {
      auto &scrubber = Scrubber::Get(project);
      if (scrubber.IsKeyboardScrubbing() && scrubber.IsBackwards() == backwards) {
         auto gAudioIO = AudioIO::Get();
         auto time = gAudioIO->GetStreamTime();
         auto &viewInfo = ViewInfo::Get(project);
         auto &selection = viewInfo.selectedRegion;
 
         // If the time selection has not changed during scrubbing
         // set the cursor position
         if (selection.t0() == initT0 && selection.t1() == initT1) {
            double endTime = TrackList::Get(project).GetEndTime();
            time = std::min(time, endTime);
            time = std::max(time, 0.0);
            selection.setTimes(time, time);
            ProjectHistory::Get(project).ModifyState(false);
         }
 
         scrubber.Cancel();
         ProjectAudioManager::Get(project).Stop();
      }
   }
   else {      // KeyDown
      auto gAudioIO = AudioIOBase::Get();
      auto &scrubber = Scrubber::Get(project);
      if (scrubber.IsKeyboardScrubbing() && scrubber.IsBackwards() != backwards) {
         // change direction
         scrubber.SetBackwards(backwards);
      }
      else if (!gAudioIO->IsBusy() && !scrubber.HasMark()) {
         auto &viewInfo = ViewInfo::Get(project);
         auto &selection = viewInfo.selectedRegion;
         double endTime = TrackList::Get(project).GetEndTime();
         double t0 = selection.t0();
    
         if ((!backwards && t0 >= 0 && t0 < endTime) ||
            (backwards && t0 > 0 && t0 <= endTime)) {
            initT0 = t0;
            initT1 = selection.t1();
            scrubber.StartKeyboardScrubbing(t0, backwards);
         }
      }
   }
}

References AudioIOBase::Get(), AudioIO::Get(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), ProjectAudioManager::Get(), Get(), TrackList::GetEndTime(), min(), ProjectHistory::ModifyState(), mProject, project, and ProjectAudioManager::Stop().

Referenced by OnKeyboardScrubBackwards(), and OnKeyboardScrubForwards().

Here is the call graph for this function:

Here is the caller graph for this function:

DoScrub()

void Scrubber::DoScrub ( bool  seek )

private

Definition at line 891 of file Scrubbing.cpp.

{
   if( !CanScrub() )
      return;
   const bool wasScrubbing = HasMark() || IsScrubbing();
   const bool scroll = ShouldScrubPinned();
   if (!wasScrubbing) {
      auto &tp = GetProjectPanel( *mProject );
      const auto &viewInfo = ViewInfo::Get( *mProject );
      wxCoord xx = tp.ScreenToClient(::wxGetMouseState().GetPosition()).x;
 
      // Limit x
      auto width = viewInfo.GetTracksUsableWidth();
      const auto offset = viewInfo.GetLeftOffset();
      xx = (std::max(offset, std::min(offset + width - 1, xx)));
 
      MarkScrubStart(xx, scroll, seek);
   }
   else if (mSeeking != seek) {
      // just switching mode
   }
   else {
      auto &projectAudioManager = ProjectAudioManager::Get( *mProject );
      projectAudioManager.Stop();
   }
}

References CanScrub(), ViewInfo::Get(), ProjectAudioManager::Get(), GetProjectPanel(), HasMark(), IsScrubbing(), MarkScrubStart(), min(), mProject, mSeeking, and ShouldScrubPinned().

Referenced by OnScrubOrSeek().

Here is the call graph for this function:

Here is the caller graph for this function:

FindScrubSpeed()

double Scrubber::FindScrubSpeed	(	bool	seeking,
		double	time
	)		const

Definition at line 823 of file Scrubbing.cpp.

{
   auto &viewInfo = ViewInfo::Get( *mProject );
   const double screen =
      viewInfo.GetScreenEndTime() - viewInfo.hpos;
   return (seeking ? FindSeekSpeed : FindScrubbingSpeed)
      (viewInfo, mMaxSpeed, screen, time);
}

References anonymous_namespace{Scrubbing.cpp}::FindScrubbingSpeed(), anonymous_namespace{Scrubbing.cpp}::FindSeekSpeed(), ViewInfo::Get(), mMaxSpeed, and mProject.

Referenced by ContinueScrubbingPoll(), and ScrubbingOverlay::OnTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

Get() [1/2]

Scrubber & Scrubber::Get ( AudacityProject &  project )

static

Definition at line 186 of file Scrubbing.cpp.

{
   return project.AttachedObjects::Get< Scrubber >( key );
}

References key, and project.

Referenced by AdornedRulerPanel::ScrubbingHandle::Cancel(), AdornedRulerPanel::ScrubbingHandle::Click(), DoKeyboardScrub(), ProjectAudioManager::DoPlayStopSelect(), Get(), ScrubbingOverlay::GetScrubber(), anonymous_namespace{AdornedRulerPanel.cpp}::PlayheadHandle::HitTest(), ControlToolBar::OnIdle(), AudacityApp::OnKeyDown(), ProjectAudioManager::OnPause(), PlayIndicatorOverlay::OnTimer(), AdornedRulerPanel::ScrubbingHandle::Preview(), ScrubForwarder::ScrubForwarder(), AdornedRulerPanel::ShowingScrubRuler(), AdornedRulerPanel::ShowScrubMenu(), ControlToolBar::StartScrollingIfPreferred(), ControlToolBar::StateForStatusBar(), ProjectAudioManager::Stop(), AdornedRulerPanel::TogglePinnedHead(), AdornedRulerPanel::ScrubbingRulerOverlay::Update(), and AdornedRulerPanel::TrackPanelGuidelineOverlay::Update().

Here is the caller graph for this function:

Get() [2/2]

const Scrubber & Scrubber::Get ( const AudacityProject &  project )

static

Definition at line 191 of file Scrubbing.cpp.

{
   return Get( const_cast< AudacityProject & >( project ) );
}

References Get(), and project.

Here is the call graph for this function:

GetKeyboardScrubbingSpeed()

double Scrubber::GetKeyboardScrubbingSpeed

(

)

Definition at line 559 of file Scrubbing.cpp.

{
   const double speedAtDefaultZoom = 0.5;
   const double maxSpeed = 3.0;
   const double minSpeed = 0.0625;
 
   auto &viewInfo = ViewInfo::Get(*mProject);
   double speed = speedAtDefaultZoom*viewInfo.GetDefaultZoom() / viewInfo.GetZoom();
   speed = std::min(speed, maxSpeed);
   speed = std::max(speed, minSpeed);
   return speed;
}

References ViewInfo::Get(), min(), and mProject.

Referenced by ContinueScrubbingPoll(), and StartKeyboardScrubbing().

Here is the call graph for this function:

Here is the caller graph for this function:

GetMaxScrubSpeed()

double Scrubber::GetMaxScrubSpeed ( ) const

inline

Definition at line 111 of file Scrubbing.h.

{ return mOptions.maxSpeed; }

Referenced by ScrubbingOverlay::OnTimer().

Here is the caller graph for this function:

GetScrubStartPosition()

wxCoord Scrubber::GetScrubStartPosition ( ) const

inline

Definition at line 72 of file Scrubbing.h.

   { return mScrubStartPosition; }

GetUntranslatedStateString()

const TranslatableString & Scrubber::GetUntranslatedStateString

(

)

const

Definition at line 987 of file Scrubbing.cpp.

{
   static TranslatableString empty;
 
   if (IsSpeedPlaying()) {
      return sPlayAtSpeedStatus;
   }
   else if (IsKeyboardScrubbing()) {
      return sKeyboardScrubbingStatus;
   }
   else if (HasMark()) {
      auto &item = FindMenuItem(Seeks() || TemporarilySeeks());
      return item.status;
   }
   else
      return empty;
}

References anonymous_namespace{Scrubbing.cpp}::FindMenuItem(), sKeyboardScrubbingStatus, and sPlayAtSpeedStatus.

Referenced by ControlToolBar::StateForStatusBar().

Here is the call graph for this function:

Here is the caller graph for this function:

HandleScrollWheel()

void Scrubber::HandleScrollWheel

(

int

steps

)

Definition at line 832 of file Scrubbing.cpp.

{
   if (steps == 0)
      return;
 
   const int newLogMaxScrubSpeed = mLogMaxScrubSpeed + steps;
   static const double maxScrubSpeedBase =
      pow(2.0, 1.0 / ScrubSpeedStepsPerOctave);
   double newSpeed = pow(maxScrubSpeedBase, newLogMaxScrubSpeed);
   if (newSpeed >= ScrubbingOptions::MinAllowedScrubSpeed() &&
       newSpeed <= ScrubbingOptions::MaxAllowedScrubSpeed()) {
      mLogMaxScrubSpeed = newLogMaxScrubSpeed;
      mMaxSpeed = newSpeed;
      if (!mSmoothScrollingScrub)
         // Show the speed for one second
         mScrubSpeedDisplayCountdown = kOneSecondCountdown + 1;
   }
}

References kOneSecondCountdown, ScrubbingOptions::MaxAllowedScrubSpeed(), ScrubbingOptions::MinAllowedScrubSpeed(), mLogMaxScrubSpeed, mMaxSpeed, mScrubSpeedDisplayCountdown, mSmoothScrollingScrub, and ScrubSpeedStepsPerOctave.

Here is the call graph for this function:

HasMark()

bool Scrubber::HasMark ( ) const

inline

Definition at line 89 of file Scrubbing.h.

   { return GetScrubStartPosition() >= 0; }

Referenced by DoScrub(), IsTransportingPinned(), ScrubbingOverlay::OnTimer(), anonymous_namespace{AdornedRulerPanel.cpp}::ScrubbingMessage(), Scrubs(), Seeks(), StartKeyboardScrubbing(), and StopScrubbing().

Here is the caller graph for this function:

IsBackwards()

bool Scrubber::IsBackwards ( ) const

inline

Definition at line 85 of file Scrubbing.h.

   { return mBackwards;}

IsKeyboardScrubbing()

bool Scrubber::IsKeyboardScrubbing ( ) const

inline

Definition at line 81 of file Scrubbing.h.

   { return IsScrubbing() && mKeyboardScrubbing; }

Referenced by ScrubbingOverlay::OnTimer().

Here is the caller graph for this function:

IsPaused()

bool Scrubber::IsPaused

(

)

const

Definition at line 856 of file Scrubbing.cpp.

{
   return mPaused;
}

References mPaused.

IsScrollScrubbing()

bool Scrubber::IsScrollScrubbing ( ) const

inline

Definition at line 93 of file Scrubbing.h.

   { return mSmoothScrollingScrub; }

Referenced by ScrubbingOverlay::Draw(), and ScrubbingOverlay::OnTimer().

Here is the caller graph for this function:

IsScrubbing()

bool Scrubber::IsScrubbing

(

)

const

Definition at line 768 of file Scrubbing.cpp.

{
   if (mScrubToken <= 0)
      return false;
   auto &projectAudioIO = ProjectAudioIO::Get( *mProject );
   if (mScrubToken == projectAudioIO.GetAudioIOToken() &&
            projectAudioIO.IsAudioActive())
      return true;
   else {
      const_cast<Scrubber&>(*this).mScrubToken = -1;
      const_cast<Scrubber&>(*this).mScrubStartPosition = -1;
      const_cast<Scrubber&>(*this).mSmoothScrollingScrub = false;
      return false;
   }
}

References ProjectAudioIO::Get(), mProject, mScrubStartPosition, mScrubToken, and mSmoothScrollingScrub.

Referenced by anonymous_namespace{AdornedRulerPanel.cpp}::ContinueScrubbingMessage(), DoScrub(), MaybeStartScrubbing(), OnActivateOrDeactivateApp(), ScrubbingOverlay::OnTimer(), Scrubs(), Seeks(), and ShouldDrawScrubSpeed().

Here is the call graph for this function:

Here is the caller graph for this function:

IsSpeedPlaying()

bool Scrubber::IsSpeedPlaying ( ) const

inline

Definition at line 77 of file Scrubbing.h.

   { return IsScrubbing() && mSpeedPlaying; }

Referenced by ScrubbingOverlay::OnTimer().

Here is the caller graph for this function:

IsTransportingPinned()

bool Scrubber::IsTransportingPinned

(

)

const

Definition at line 706 of file Scrubbing.cpp.

{
   if (!TracksPrefs::GetPinnedHeadPreference())
      return false;
   return
     !(HasMark() &&
       !WasSpeedPlaying() &&
       !ShouldScrubPinned());
}

References TracksPrefs::GetPinnedHeadPreference(), HasMark(), ShouldScrubPinned(), and WasSpeedPlaying().

Here is the call graph for this function:

JoinThread()

void Scrubber::JoinThread ( )

private

Definition at line 217 of file Scrubbing.cpp.

{
#ifdef USE_SCRUB_THREAD
   if (mThread.joinable()) {
      mFinishThread.store(true, std::memory_order_release);
      mThread.join();
   }
#endif
}

Referenced by StopPolling(), and ~Scrubber().

Here is the caller graph for this function:

MarkScrubStart()

void Scrubber::MarkScrubStart	(	wxCoord	xx,
		bool	smoothScrolling,
		bool	seek
	)

Definition at line 303 of file Scrubbing.cpp.

{
   // Don't actually start scrubbing, but collect some information
   // needed for the decision to start scrubbing later when handling
   // drag events.
   mSmoothScrollingScrub  = smoothScrolling;
 
   auto &projectAudioManager = ProjectAudioManager::Get( *mProject );
 
   // Stop any play in progress
   // Bug 1492: mCancelled to stop us collapsing the selected region.
   mCancelled = true;
   projectAudioManager.Stop();
   mCancelled = false;
 
   // Usually the timer handler of TrackPanel does this, but we do this now,
   // so that same timer does not StopPlaying() again after this function and destroy
   // scrubber state
   ProjectAudioIO::Get( *mProject ).SetAudioIOToken(0);
 
   mSeeking = seek;
   CheckMenuItems();
 
   // Commented out for Bug 1421
   //   mSeeking
   //   ? ControlToolBar::PlayAppearance::Seek
   //   : ControlToolBar::PlayAppearance::Scrub);
 
   mScrubStartPosition = xx;
   mCancelled = false;
}

References CheckMenuItems(), ProjectAudioIO::Get(), ProjectAudioManager::Get(), mCancelled, mProject, mScrubStartPosition, mSeeking, mSmoothScrollingScrub, and ProjectAudioIO::SetAudioIOToken().

Referenced by DoScrub().

Here is the call graph for this function:

Here is the caller graph for this function:

MaybeStartScrubbing()

bool Scrubber::MaybeStartScrubbing

(

wxCoord

xx

)

Definition at line 349 of file Scrubbing.cpp.

{
   if (mScrubStartPosition < 0)
      return false;
   if (IsScrubbing())
      return false;
#ifdef USE_SCRUB_THREAD
   if (mThread.joinable())
      return false;
#endif
   else {
      const auto state = ::wxGetMouseState();
      mDragging = state.LeftIsDown();
 
      auto gAudioIO = AudioIO::Get();
      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 = xx;
      if (abs(mScrubStartPosition - position) >= SCRUBBING_PIXEL_TOLERANCE) {
         auto &viewInfo = ViewInfo::Get(*mProject);
         auto &projectAudioManager = ProjectAudioManager::Get(*mProject);
         double maxTime = TrackList::Get(*mProject).GetEndTime();
         const int leftOffset = viewInfo.GetLeftOffset();
         double time0 = std::min(maxTime,
            viewInfo.PositionToTime(mScrubStartPosition, leftOffset)
         );
         double time1 = std::min(maxTime,
            viewInfo.PositionToTime(position, leftOffset)
         );
         if (time1 != time0) {
            if (busy) {
               position = mScrubStartPosition;
               projectAudioManager.Stop();
               mScrubStartPosition = position;
            }
 
#ifdef DRAG_SCRUB
            if (mDragging && mSmoothScrollingScrub) {
               auto delta = time0 - time1;
               time0 = std::max(0.0, std::min(maxTime,
                  viewInfo.h +
                     (viewInfo.GetScreenEndTime() - viewInfo.h)
                        * TracksPrefs::GetPinnedHeadPositionPreference()
               ));
               time1 = time0 + delta;
            }
#endif
            mSpeedPlaying = false;
            mKeyboardScrubbing = false;
            auto options =
               ProjectAudioIO::GetDefaultOptions(*mProject);
 
#ifndef USE_SCRUB_THREAD
            // Yuck, we either have to poll "by hand" when scrub polling doesn't
            // work with a thread, or else yield to timer messages, but that would
            // execute too much else
            options.playbackStreamPrimer = [this](){
               ContinueScrubbingPoll();
               return ScrubPollInterval;
            };
#endif
            options.playNonWaveTracks = false;
            options.envelope = nullptr;
            mOptions.delay = ScrubPollInterval;
            mOptions.isKeyboardScrubbing = false;
            mOptions.initSpeed = 0;
            mOptions.minSpeed = 0.0;
#ifdef USE_TRANSCRIPTION_TOOLBAR
            if (!mAlwaysSeeking) {
               // Take the starting speed limit from the transcription toolbar,
               // but it may be varied during the scrub.
               mMaxSpeed = mOptions.maxSpeed =
                  ProjectSettings::Get( *mProject ).GetPlaySpeed();
            }
#else
            // That idea seems unpopular... just make it one for move-scrub,
            // but big for drag-scrub
#ifdef DRAG_SCRUB
            mMaxSpeed = mOptions.maxSpeed = mDragging ? MaxDragSpeed : 1.0;
#else
            mMaxSpeed = mOptions.maxSpeed = 1.0;
#endif
 
#endif
            mOptions.minTime = 0;
            mOptions.maxTime =
               std::max(0.0, TrackList::Get(*mProject).GetEndTime());
            mOptions.minStutterTime =
#ifdef DRAG_SCRUB
               mDragging ? PlaybackPolicy::Duration{} :
#endif
               std::max(PlaybackPolicy::Duration{}, MinStutter);
 
            const bool backwards = time1 < time0;
            static const double maxScrubSpeedBase =
               pow(2.0, 1.0 / ScrubSpeedStepsPerOctave);
            mLogMaxScrubSpeed = floor(0.5 +
               log(mMaxSpeed) / log(maxScrubSpeedBase)
            );
            mScrubSpeedDisplayCountdown = 0;
 
            // Must start the thread and poller first or else PlayPlayRegion
            // will insert some silence
            StartPolling();
            auto cleanup = finally([this]{
               if (mScrubToken < 0)
                  StopPolling();
            });
 
            options.policyFactory = ScrubbingPlaybackPolicyFactory(mOptions);
            mScrubToken =
               projectAudioManager.PlayPlayRegion(
                  SelectedRegion(time0, time1), options,
                  PlayMode::normalPlay, backwards);
            if (mScrubToken <= 0) {
               // Bug1627 (part of it):
               // infinite error spew when trying to start scrub:
               // If failed for reasons of audio device problems, do not try
               // again with repeated timer ticks.
               mScrubStartPosition = -1;
               return false;
            }
         }
      }
      else
         // Wait to test again
         ;
 
      if (IsScrubbing()) {
         mLastScrubPosition = xx;
      }
 
      // Return true whether we started scrub, or are still waiting to decide.
      return true;
   }
}

References ContinueScrubbingPoll(), ScrubbingOptions::delay, AudioIO::Get(), ViewInfo::Get(), TrackList::Get(), ProjectAudioManager::Get(), ProjectSettings::Get(), ProjectAudioIO::GetDefaultOptions(), TrackList::GetEndTime(), TracksPrefs::GetPinnedHeadPositionPreference(), ScrubbingOptions::initSpeed, ScrubbingOptions::isKeyboardScrubbing, IsScrubbing(), ScrubbingOptions::maxSpeed, ScrubbingOptions::maxTime, mDragging, min(), ScrubbingOptions::minSpeed, MinStutter, ScrubbingOptions::minStutterTime, ScrubbingOptions::minTime, mKeyboardScrubbing, mLastScrubPosition, mLogMaxScrubSpeed, mMaxSpeed, mOptions, mProject, mScrubSpeedDisplayCountdown, mScrubStartPosition, mScrubToken, mSmoothScrollingScrub, mSpeedPlaying, normalPlay, SCRUBBING_PIXEL_TOLERANCE, ScrubbingPlaybackPolicyFactory(), ScrubPollInterval, ScrubSpeedStepsPerOctave, StartPolling(), and StopPolling().

Referenced by ScrubbingOverlay::OnTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

MayDragToSeek()

bool Scrubber::MayDragToSeek ( ) const

inline

Definition at line 100 of file Scrubbing.h.

{ return mMayDragToSeek; }

Referenced by TemporarilySeeks().

Here is the caller graph for this function:

OnActivateOrDeactivateApp()

void Scrubber::OnActivateOrDeactivateApp ( wxActivateEvent &  event )

private

Definition at line 861 of file Scrubbing.cpp.

{
   // First match priority logic...
   // Pause if Pause down, or not scrubbing.
   if (!mProject)
      Pause(true);
   else if (ProjectAudioManager::Get( *mProject ).Paused())
      Pause( true );
   else if (!IsScrubbing())
      Pause( true );
 
   // Stop keyboard scrubbing if losing focus
   else if (mKeyboardScrubbing && !event.GetActive()) {
      Cancel();
      ProjectAudioManager::Get(*mProject).Stop();
   }
 
   // Speed playing does not pause if losing focus.
   else if (mSpeedPlaying)
      Pause( false );
 
   // But scrub and seek do.
   else if (!event.GetActive())
      Pause( true );
   else
      Pause(false);
 
   event.Skip();
}

References Cancel(), ProjectAudioManager::Get(), IsScrubbing(), mKeyboardScrubbing, mProject, mSpeedPlaying, Pause(), ProjectAudioManager::Paused(), and ProjectAudioManager::Stop().

Referenced by Scrubber().

Here is the call graph for this function:

Here is the caller graph for this function:

OnKeyboardScrubBackwards()

void Scrubber::OnKeyboardScrubBackwards

(

const CommandContext &

context

)

Definition at line 1098 of file Scrubbing.cpp.

{
   auto evt = context.pEvt;
   if (evt)
      DoKeyboardScrub(true, evt->GetEventType() == wxEVT_KEY_UP);
   else {              // called from menu, so simulate keydown and keyup
      DoKeyboardScrub(true, false);
      DoKeyboardScrub(true, true);
   }
}

References DoKeyboardScrub(), and CommandContext::pEvt.

Referenced by anonymous_namespace{Scrubbing.cpp}::KeyboardScrubbingItems().

Here is the call graph for this function:

Here is the caller graph for this function:

OnKeyboardScrubForwards()

void Scrubber::OnKeyboardScrubForwards

(

const CommandContext &

context

)

Definition at line 1109 of file Scrubbing.cpp.

{
   auto evt = context.pEvt;
   if (evt)
      DoKeyboardScrub(false, evt->GetEventType() == wxEVT_KEY_UP);
   else {              // called from menu, so simulate keydown and keyup
      DoKeyboardScrub(false, false);
      DoKeyboardScrub(false, true);
   }
}

References DoKeyboardScrub(), and CommandContext::pEvt.

Referenced by anonymous_namespace{Scrubbing.cpp}::KeyboardScrubbingItems().

Here is the call graph for this function:

Here is the caller graph for this function:

OnScrub()

void Scrubber::OnScrub

(

const CommandContext &

)

Definition at line 926 of file Scrubbing.cpp.

{
   OnScrubOrSeek(false);
   CheckMenuItems();
}

References CheckMenuItems(), and OnScrubOrSeek().

Referenced by anonymous_namespace{Scrubbing.cpp}::menuItems().

Here is the call graph for this function:

Here is the caller graph for this function:

OnScrubOrSeek()

void Scrubber::OnScrubOrSeek

(

bool

seek

)

Definition at line 918 of file Scrubbing.cpp.

{
   DoScrub(seek);
 
   mSeeking = seek;
   CheckMenuItems();
}

References CheckMenuItems(), DoScrub(), and mSeeking.

Referenced by OnScrub(), and OnSeek().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSeek()

void Scrubber::OnSeek

(

const CommandContext &

)

Definition at line 932 of file Scrubbing.cpp.

{
   OnScrubOrSeek(true);
   CheckMenuItems();
}

References CheckMenuItems(), and OnScrubOrSeek().

Referenced by anonymous_namespace{Scrubbing.cpp}::menuItems().

Here is the call graph for this function:

Here is the caller graph for this function:

OnToggleScrubRuler()

void Scrubber::OnToggleScrubRuler

(

const CommandContext &

)

Definition at line 962 of file Scrubbing.cpp.

{
   mShowScrubbing = !mShowScrubbing;
   WriteScrubEnabledPref(mShowScrubbing);
   gPrefs->Flush();
   CheckMenuItems();
}

References CheckMenuItems(), audacity::BasicSettings::Flush(), gPrefs, mShowScrubbing, and anonymous_namespace{Scrubbing.cpp}::WriteScrubEnabledPref().

Referenced by anonymous_namespace{Scrubbing.cpp}::menuItems().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

Scrubber & Scrubber::operator= ( const Scrubber &  )

delete

Pause()

void Scrubber::Pause

(

bool

paused

)

Definition at line 851 of file Scrubbing.cpp.

{
   mPaused = paused;
}

References mPaused.

Referenced by OnActivateOrDeactivateApp().

Here is the caller graph for this function:

PopulatePopupMenu()

void Scrubber::PopulatePopupMenu

(

wxMenu &

menu

)

Definition at line 1174 of file Scrubbing.cpp.

{
   int id = CMD_ID;
   auto &cm = CommandManager::Get( *mProject );
   for (const auto &item : menuItems()) {
      if (cm.GetEnabled(item.name)) {
         auto test = item.StatusTest;
         menu.Append(id, item.label.Translation(), wxString{},
                     test ? wxITEM_CHECK : wxITEM_NORMAL);
         if(test && (this->*test)())
            menu.FindItem(id)->Check();
      }
      ++id;
   }
}

References CMD_ID, CommandManager::Get(), id, anonymous_namespace{Scrubbing.cpp}::menuItems(), and mProject.

Here is the call graph for this function:

ScrubPollerThread()

void Scrubber::ScrubPollerThread ( )

private

Referenced by StartPolling().

Here is the caller graph for this function:

Scrubs()

bool Scrubber::Scrubs

(

)

const

Definition at line 805 of file Scrubbing.cpp.

{
   if( Seeks() )
      return false;
   return (HasMark() || IsScrubbing()) && !ChoseSeeking();
}

References ChoseSeeking(), HasMark(), IsScrubbing(), and Seeks().

Referenced by anonymous_namespace{Scrubbing.cpp}::menuItems(), and StatusMessageForWave().

Here is the call graph for this function:

Here is the caller graph for this function:

Seeks()

bool Scrubber::Seeks

(

)

const

Definition at line 800 of file Scrubbing.cpp.

{
   return (HasMark() || IsScrubbing()) && ChoseSeeking();
}

References ChoseSeeking(), HasMark(), and IsScrubbing().

Referenced by anonymous_namespace{AdornedRulerPanel.cpp}::ContinueScrubbingMessage(), ContinueScrubbingPoll(), ContinueScrubbingUI(), anonymous_namespace{Scrubbing.cpp}::menuItems(), ScrubbingOverlay::OnTimer(), Scrubs(), ShouldDrawScrubSpeed(), and StatusMessageForWave().

Here is the call graph for this function:

Here is the caller graph for this function:

SetBackwards()

void Scrubber::SetBackwards ( bool  backwards )

inline

Definition at line 83 of file Scrubbing.h.

   { mBackwards = backwards;}

SetMayDragToSeek()

void Scrubber::SetMayDragToSeek ( bool  value )

inline

Definition at line 99 of file Scrubbing.h.

{ mMayDragToSeek = value; }

SetScrollScrubbing()

void Scrubber::SetScrollScrubbing ( bool  value )

inline

Definition at line 95 of file Scrubbing.h.

   { mSmoothScrollingScrub = value; }

SetSeekPress()

void Scrubber::SetSeekPress ( bool  value )

inline

Definition at line 146 of file Scrubbing.h.

{ mScrubSeekPress = value; }

ShouldDrawScrubSpeed()

bool Scrubber::ShouldDrawScrubSpeed

(

)

Definition at line 812 of file Scrubbing.cpp.

{
   return IsScrubbing() &&
      !mPaused && (
         // Draw for (non-scroll) scrub, sometimes, but never for seek
         (!(Seeks() || TemporarilySeeks()) && mScrubSpeedDisplayCountdown > 0)
         // Draw always for scroll-scrub and for scroll-seek
         || mSmoothScrollingScrub
      );
}

References IsScrubbing(), mPaused, mScrubSpeedDisplayCountdown, mSmoothScrollingScrub, Seeks(), and TemporarilySeeks().

Referenced by ScrubbingOverlay::DoGetRectangle(), ScrubbingOverlay::Draw(), and ScrubbingOverlay::OnTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

ShouldScrubPinned()

bool Scrubber::ShouldScrubPinned ( )

static

Definition at line 149 of file Scrubbing.cpp.

{
   return TracksPrefs::GetPinnedHeadPreference() &&
      !PlaybackPrefs::GetUnpinnedScrubbingPreference();
}

References TracksPrefs::GetPinnedHeadPreference(), and PlaybackPrefs::GetUnpinnedScrubbingPreference().

Referenced by AdornedRulerPanel::ScrubbingHandle::Click(), DoScrub(), and IsTransportingPinned().

Here is the call graph for this function:

Here is the caller graph for this function:

ShowsBar()

bool Scrubber::ShowsBar

(

)

const

Definition at line 763 of file Scrubbing.cpp.

{
   return mShowScrubbing;
}

References mShowScrubbing.

Referenced by anonymous_namespace{Scrubbing.cpp}::menuItems().

Here is the caller graph for this function:

StartKeyboardScrubbing()

bool Scrubber::StartKeyboardScrubbing	(	double	time0,
		bool	backwards
	)

Definition at line 492 of file Scrubbing.cpp.

{
   if (HasMark() || AudioIO::Get()->IsBusy())
      return false;
#ifdef USE_SCRUB_THREAD
   if (mThread.joinable())
      return false;
#endif
   
   mScrubStartPosition = 0;   // so that HasMark() is true
   mSpeedPlaying = false;
   mKeyboardScrubbing = true;
   mBackwards = backwards;
   mMaxSpeed = ScrubbingOptions::MaxAllowedScrubSpeed();
   mDragging = false;
 
   auto options = DefaultSpeedPlayOptions(*mProject);
 
#ifndef USE_SCRUB_THREAD
   // Yuck, we either have to poll "by hand" when scrub polling doesn't
   // work with a thread, or else yield to timer messages, but that would
   // execute too much else
   options.playbackStreamPrimer = [this]() {
      ContinueScrubbingPoll();
      return ScrubPollInterval;
   };
#endif
 
   options.playNonWaveTracks = false;
   options.envelope = nullptr;
 
   // delay and minStutterTime are used in AudioIO::AllocateBuffers() for setting the
   // values of mPlaybackQueueMinimum and mPlaybackSamplesToCopy respectively.
   mOptions.delay = ScrubPollInterval;
   mOptions.minStutterTime = mOptions.delay;
 
   mOptions.initSpeed = GetKeyboardScrubbingSpeed();
   if (backwards)
      mOptions.initSpeed *= -1.0;
   mOptions.minSpeed = ScrubbingOptions::MinAllowedScrubSpeed();
   mOptions.maxSpeed = ScrubbingOptions::MaxAllowedScrubSpeed();
   mOptions.minTime = 0;
   mOptions.maxTime = std::max(0.0, TrackList::Get(*mProject).GetEndTime());
   mOptions.bySpeed = true;
   mOptions.adjustStart = false;
   mOptions.isKeyboardScrubbing = true;
 
   // Must start the thread and poller first or else PlayPlayRegion
   // will insert some silence
   StartPolling();
   auto cleanup = finally([this] {
      if (mScrubToken < 0)
         StopPolling();
   });
 
   options.policyFactory = ScrubbingPlaybackPolicyFactory(mOptions);
   mScrubToken =
      ProjectAudioManager::Get(*mProject).PlayPlayRegion(
         SelectedRegion(time0, backwards ? mOptions.minTime : mOptions.maxTime),
         options,
         PlayMode::normalPlay,
         backwards);
 
   return true;
}

References ScrubbingOptions::adjustStart, ScrubbingOptions::bySpeed, ContinueScrubbingPoll(), DefaultSpeedPlayOptions(), ScrubbingOptions::delay, AudioIO::Get(), TrackList::Get(), ProjectAudioManager::Get(), TrackList::GetEndTime(), GetKeyboardScrubbingSpeed(), HasMark(), ScrubbingOptions::initSpeed, ScrubbingOptions::isKeyboardScrubbing, ScrubbingOptions::MaxAllowedScrubSpeed(), ScrubbingOptions::maxSpeed, ScrubbingOptions::maxTime, mBackwards, mDragging, ScrubbingOptions::MinAllowedScrubSpeed(), ScrubbingOptions::minSpeed, ScrubbingOptions::minStutterTime, ScrubbingOptions::minTime, mKeyboardScrubbing, mMaxSpeed, mOptions, mProject, mScrubStartPosition, mScrubToken, mSpeedPlaying, normalPlay, ProjectAudioManager::PlayPlayRegion(), ScrubbingPlaybackPolicyFactory(), ScrubPollInterval, StartPolling(), and StopPolling().

Here is the call graph for this function:

StartPolling()

void Scrubber::StartPolling ( )

private

Precondition

!mThread.joinable() (when defined(USE_SCRUB_THREAD))

Definition at line 716 of file Scrubbing.cpp.

{
   mPaused = false;
   
#ifdef USE_SCRUB_THREAD
   assert(!mThread.joinable());
   mFinishThread.store(false, std::memory_order_relaxed);
   mThread = std::thread{
      std::mem_fn( &Scrubber::ScrubPollerThread ), std::ref(*this) };
#endif
 
   mPoller->Start( 0.9 *
      std::chrono::duration<double, std::milli>{ScrubPollInterval}.count());
}

References mPaused, mPoller, ScrubPollerThread(), and ScrubPollInterval.

Referenced by MaybeStartScrubbing(), and StartKeyboardScrubbing().

Here is the call graph for this function:

Here is the caller graph for this function:

StatusMessageForWave()

wxString Scrubber::StatusMessageForWave

(

)

const

Definition at line 1005 of file Scrubbing.cpp.

{
   wxString result;
 
   if(  Seeks() )
      result = _("Move mouse pointer to Seek");
   else if( Scrubs() )
      result = _("Move mouse pointer to Scrub");
   return result;
}

References _, Scrubs(), and Seeks().

Here is the call graph for this function:

StopPolling()

void Scrubber::StopPolling ( )

private

Definition at line 731 of file Scrubbing.cpp.

{
   mPaused = true;
 
#ifdef USE_SCRUB_THREAD
   JoinThread();
#endif
   
   mPoller->Stop();
}

References JoinThread(), mPaused, and mPoller.

Referenced by MaybeStartScrubbing(), StartKeyboardScrubbing(), and StopScrubbing().

Here is the call graph for this function:

Here is the caller graph for this function:

StopScrubbing()

void Scrubber::StopScrubbing

(

)

Definition at line 742 of file Scrubbing.cpp.

{
   auto gAudioIO = AudioIO::Get();
   ScrubState::StopScrub();
   StopPolling();
 
   if (HasMark() && !mCancelled) {
      const wxMouseState state(::wxGetMouseState());
      // Stop and set cursor
      bool bShift = state.ShiftDown();
      auto &projectAudioManager = ProjectAudioManager::Get( *mProject );
      projectAudioManager.DoPlayStopSelect(true, bShift);
   }
 
   mScrubStartPosition = -1;
   mDragging = false;
   mSeeking = false;
 
   CheckMenuItems();
}

References CheckMenuItems(), AudioIO::Get(), ProjectAudioManager::Get(), HasMark(), mCancelled, mDragging, mProject, mScrubStartPosition, mSeeking, StopPolling(), and ScrubState::StopScrub().

Here is the call graph for this function:

TemporarilySeeks()

bool Scrubber::TemporarilySeeks

(

)

const

Definition at line 794 of file Scrubbing.cpp.

{
   return mScrubSeekPress ||
      (::wxGetMouseState().LeftIsDown() && MayDragToSeek());
}

References MayDragToSeek(), and mScrubSeekPress.

Referenced by ContinueScrubbingPoll(), ContinueScrubbingUI(), ScrubbingOverlay::OnTimer(), and ShouldDrawScrubSpeed().

Here is the call graph for this function:

Here is the caller graph for this function:

Thunk()

template<void(Scrubber::*)(const CommandContext &) pfn>

void Scrubber::Thunk ( wxCommandEvent &  )

inline

Definition at line 132 of file Scrubbing.h.

         { (this->*pfn)(*mProject); }

UpdatePrefs()

void Scrubber::UpdatePrefs ( )

overrideprivatevirtual

Implements PrefsListener.

Definition at line 957 of file Scrubbing.cpp.

{
   mShowScrubbing = ReadScrubEnabledPref();
}

References mShowScrubbing, and anonymous_namespace{Scrubbing.cpp}::ReadScrubEnabledPref().

Referenced by Scrubber().

Here is the call graph for this function:

Here is the caller graph for this function:

WasKeyboardScrubbing()

bool Scrubber::WasKeyboardScrubbing ( ) const

inline

Definition at line 79 of file Scrubbing.h.

   { return mKeyboardScrubbing; }

WasSpeedPlaying()

bool Scrubber::WasSpeedPlaying ( ) const

inline

Definition at line 75 of file Scrubbing.h.

   { return mSpeedPlaying;}

Referenced by IsTransportingPinned().

Here is the caller graph for this function:

Member Data Documentation

mBackwards

bool Scrubber::mBackwards {}

private

Definition at line 172 of file Scrubbing.h.

Referenced by ContinueScrubbingPoll(), and StartKeyboardScrubbing().

mCancelled

bool Scrubber::mCancelled {}

private

Definition at line 175 of file Scrubbing.h.

Referenced by MarkScrubStart(), and StopScrubbing().

mDragging

bool Scrubber::mDragging {}

private

Definition at line 173 of file Scrubbing.h.

Referenced by ChoseSeeking(), ContinueScrubbingPoll(), ContinueScrubbingUI(), MaybeStartScrubbing(), StartKeyboardScrubbing(), and StopScrubbing().

mKeyboardScrubbing

bool Scrubber::mKeyboardScrubbing {}

private

Definition at line 171 of file Scrubbing.h.

Referenced by ContinueScrubbingPoll(), MaybeStartScrubbing(), OnActivateOrDeactivateApp(), and StartKeyboardScrubbing().

mLastScrubPosition

wxCoord Scrubber::mLastScrubPosition {}

private

Definition at line 164 of file Scrubbing.h.

Referenced by ContinueScrubbingPoll(), and MaybeStartScrubbing().

mLogMaxScrubSpeed

int Scrubber::mLogMaxScrubSpeed

private

Definition at line 177 of file Scrubbing.h.

Referenced by HandleScrollWheel(), and MaybeStartScrubbing().

mMaxSpeed

double Scrubber::mMaxSpeed { 1.0 }

private

Definition at line 196 of file Scrubbing.h.

Referenced by ContinueScrubbingPoll(), FindScrubSpeed(), HandleScrollWheel(), MaybeStartScrubbing(), and StartKeyboardScrubbing().

mMayDragToSeek

bool Scrubber::mMayDragToSeek { false }

private

Definition at line 199 of file Scrubbing.h.

mOptions

ScrubbingOptions Scrubber::mOptions

private

Definition at line 195 of file Scrubbing.h.

Referenced by ContinueScrubbingPoll(), MaybeStartScrubbing(), and StartKeyboardScrubbing().

mPaused

bool Scrubber::mPaused {}

private

Definition at line 168 of file Scrubbing.h.

Referenced by ContinueScrubbingPoll(), IsPaused(), Pause(), ShouldDrawScrubSpeed(), StartPolling(), and StopPolling().

mPoller

std::unique_ptr<ScrubPoller> Scrubber::mPoller

private

Definition at line 193 of file Scrubbing.h.

Referenced by StartPolling(), and StopPolling().

mProject

AudacityProject* Scrubber::mProject

private

Definition at line 179 of file Scrubbing.h.

Referenced by CanScrub(), CheckMenuItems(), ContinueScrubbingPoll(), ContinueScrubbingUI(), DoKeyboardScrub(), DoScrub(), FindScrubSpeed(), GetKeyboardScrubbingSpeed(), IsScrubbing(), MarkScrubStart(), MaybeStartScrubbing(), OnActivateOrDeactivateApp(), PopulatePopupMenu(), StartKeyboardScrubbing(), and StopScrubbing().

mScrubSeekPress

bool Scrubber::mScrubSeekPress {}

private

Definition at line 165 of file Scrubbing.h.

Referenced by ContinueScrubbingPoll(), and TemporarilySeeks().

mScrubSpeedDisplayCountdown

int Scrubber::mScrubSpeedDisplayCountdown

private

Definition at line 162 of file Scrubbing.h.

Referenced by ContinueScrubbingUI(), HandleScrollWheel(), MaybeStartScrubbing(), and ShouldDrawScrubSpeed().

mScrubStartPosition

wxCoord Scrubber::mScrubStartPosition

private

Definition at line 163 of file Scrubbing.h.

Referenced by IsScrubbing(), MarkScrubStart(), MaybeStartScrubbing(), StartKeyboardScrubbing(), and StopScrubbing().

mScrubToken

int Scrubber::mScrubToken

private

Definition at line 161 of file Scrubbing.h.

Referenced by IsScrubbing(), MaybeStartScrubbing(), and StartKeyboardScrubbing().

mSeeking

bool Scrubber::mSeeking {}

private

Definition at line 169 of file Scrubbing.h.

Referenced by ChoseSeeking(), ContinueScrubbingUI(), DoScrub(), MarkScrubStart(), OnScrubOrSeek(), and StopScrubbing().

mShowScrubbing

bool Scrubber::mShowScrubbing { false }

private

Definition at line 198 of file Scrubbing.h.

Referenced by OnToggleScrubRuler(), ShowsBar(), and UpdatePrefs().

mSmoothScrollingScrub

bool Scrubber::mSmoothScrollingScrub

private

Definition at line 166 of file Scrubbing.h.

Referenced by ContinueScrubbingPoll(), ContinueScrubbingUI(), HandleScrollWheel(), IsScrubbing(), MarkScrubStart(), MaybeStartScrubbing(), and ShouldDrawScrubSpeed().

mSpeedPlaying

bool Scrubber::mSpeedPlaying {true}

private

Definition at line 170 of file Scrubbing.h.

Referenced by ContinueScrubbingPoll(), MaybeStartScrubbing(), OnActivateOrDeactivateApp(), and StartKeyboardScrubbing().

---

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

• Scrubbing.h
• Scrubbing.cpp