anonymous_namespace{SelectMenus.cpp} Namespace Reference

Classes
struct	SeekInfo

Enumerations
enum	CursorDirection { DIRECTION_LEFT = -1 , DIRECTION_RIGHT = +1 }
enum	SelectionOperation { SELECTION_EXTEND , SELECTION_CONTRACT , CURSOR_MOVE }
enum	TimeUnit { TIME_UNIT_SECONDS , TIME_UNIT_PIXELS }

Functions
double	NearestZeroCrossing (AudacityProject &project, double t0)
bool	OnlyHandleKeyUp (const CommandContext &context)
void	SeekWhenAudioActive (double seekStep, wxLongLong &lastSelectionAdjustment)
double	GridMove (AudacityProject &project, double t, int minPix)
double	OffsetTime (AudacityProject &project, double t, double offset, TimeUnit timeUnit, int snapToTime)
void	MoveWhenAudioInactive (AudacityProject &project, double seekStep, TimeUnit timeUnit)
void	SeekWhenAudioInactive (AudacityProject &project, double seekStep, TimeUnit timeUnit, SelectionOperation operation)
void	SeekLeftOrRight (AudacityProject &project, double direction, SelectionOperation operation, SeekInfo &info)
void	DoCursorMove (AudacityProject &project, double seekStep, wxLongLong &lastSelectionAdjustment)
void	DoBoundaryMove (AudacityProject &project, int step, SeekInfo &info)
BaseItemSharedPtr	SelectMenu ()
BaseItemSharedPtr	ExtraSelectionMenu ()
BaseItemSharedPtr	CursorMenu ()
BaseItemSharedPtr	ExtraCursorMenu ()
BaseItemSharedPtr	ExtraSeekMenu ()

Variables
AttachedItem	sAttachment1
AttachedItem	sAttachment2
AttachedItem	sAttachment0
AttachedItem	sAttachment4
AttachedItem	sAttachment5

Enumeration Type Documentation

CursorDirection

enum anonymous_namespace{SelectMenus.cpp}::CursorDirection

Enumerator
DIRECTION_LEFT
DIRECTION_RIGHT

Definition at line 120 of file SelectMenus.cpp.

                     {
   DIRECTION_LEFT = -1,
   DIRECTION_RIGHT = +1
};

SelectionOperation

enum anonymous_namespace{SelectMenus.cpp}::SelectionOperation

Enumerator
SELECTION_EXTEND
SELECTION_CONTRACT
CURSOR_MOVE

Definition at line 125 of file SelectMenus.cpp.

                        {
    SELECTION_EXTEND,
    SELECTION_CONTRACT,
    CURSOR_MOVE
};

TimeUnit

enum anonymous_namespace{SelectMenus.cpp}::TimeUnit

Enumerator
TIME_UNIT_SECONDS
TIME_UNIT_PIXELS

Definition at line 131 of file SelectMenus.cpp.

              {
    TIME_UNIT_SECONDS,
    TIME_UNIT_PIXELS
};

Function Documentation

CursorMenu()

BaseItemSharedPtr anonymous_namespace{SelectMenus.cpp}::CursorMenu

(

)

Definition at line 1060 of file SelectMenus.cpp.

{
   using Options = CommandManager::Options;
   static const auto CanStopFlags = AudioIONotBusyFlag() | CanStopAudioStreamFlag();
 
   // JKC: ANSWER-ME: How is 'cursor to' different to 'Skip To' and how is it
   // useful?
   // GA: 'Skip to' moves the viewpoint to center of the track and preserves the
   // selection. 'Cursor to' does neither. 'Center at' might describe it better
   // than 'Skip'.
   static BaseItemSharedPtr menu{
   ( FinderScope{ findCommandHandler },
   Menu( wxT("Cursor"), XXO("&Cursor to"),
      Command( wxT("CursSelStart"), XXO("Selection Star&t"),
         FN(OnCursorSelStart),
         TimeSelectedFlag(),
         Options{}.LongName( XO("Cursor to Selection Start") ) ),
      Command( wxT("CursSelEnd"), XXO("Selection En&d"),
         FN(OnCursorSelEnd),
         TimeSelectedFlag(),
         Options{}.LongName( XO("Cursor to Selection End") ) ),
 
      Command( wxT("CursTrackStart"), XXO("Track &Start"),
         FN(OnCursorTrackStart),
         EditableTracksSelectedFlag(),
         Options{ wxT("J"), XO("Cursor to Track Start") } ),
      Command( wxT("CursTrackEnd"), XXO("Track &End"),
         FN(OnCursorTrackEnd),
         EditableTracksSelectedFlag(),
         Options{ wxT("K"), XO("Cursor to Track End") } ),
 
      Command( wxT("CursProjectStart"), XXO("&Project Start"),
         FN(OnSkipStart),
         CanStopFlags,
         Options{ wxT("Home"), XO("Cursor to Project Start") } ),
      Command( wxT("CursProjectEnd"), XXO("Project E&nd"), FN(OnSkipEnd),
         CanStopFlags,
         Options{ wxT("End"), XO("Cursor to Project End") } )
   ) ) };
   return menu;
}

References AudioIONotBusyFlag(), CanStopAudioStreamFlag(), anonymous_namespace{TimerRecordDialog.cpp}::CanStopFlags, MenuTable::Command(), EditableTracksSelectedFlag(), findCommandHandler(), FN, CommandManager::Options::LongName(), MenuTable::Menu(), TimeSelectedFlag(), wxT(), XO(), and XXO().

Here is the call graph for this function:

DoBoundaryMove()

void anonymous_namespace{SelectMenus.cpp}::DoBoundaryMove	(	AudacityProject &	project,
		int	step,
		SeekInfo &	info
	)

Definition at line 357 of file SelectMenus.cpp.

{
   auto &viewInfo = ViewInfo::Get( project );
   auto &tracks = TrackList::Get( project );
   auto &window = ProjectWindow::Get( project );
 
   // step is negative, then is moving left.  step positive, moving right.
   // Move the left/right selection boundary, to expand the selection
 
   // If the last adjustment was very recent, we are
   // holding the key down and should move faster.
   wxLongLong curtime = ::wxGetUTCTimeMillis();
   int pixels = step;
   if( curtime - info.mLastSelectionAdjustment < 50 )
   {
      pixels *= 4;
   }
   info.mLastSelectionAdjustment = curtime;
 
   // we used to have a parameter boundaryContract to say if expanding or
   // contracting.  it is no longer needed.
   bool bMoveT0 = (step < 0 );// ^ boundaryContract ;
 
   if( ProjectAudioIO::Get( project ).IsAudioActive() )
   {
      auto gAudioIO = AudioIO::Get();
      double indicator = gAudioIO->GetStreamTime();
      if( bMoveT0 )
         viewInfo.selectedRegion.setT0(indicator, false);
      else
         viewInfo.selectedRegion.setT1(indicator);
 
      ProjectHistory::Get( project ).ModifyState(false);
      return;
   }
 
   const double t0 = viewInfo.selectedRegion.t0();
   const double t1 = viewInfo.selectedRegion.t1();
   const double end = std::max( 
      tracks.GetEndTime(),
      viewInfo.GetScreenEndTime());
 
   double newT = viewInfo.OffsetTimeByPixels( bMoveT0 ? t0 : t1, pixels);
   // constrain to be in the track/screen limits.
   newT = std::max( 0.0, newT );
   newT = std::min( newT, end);
   // optionally constrain to be a contraction, i.e. so t0/t1 do not cross over
   //if( boundaryContract )
   //   newT = bMoveT0 ? std::min( t1, newT ) : std::max( t0, newT );
 
   // Actually move
   if( bMoveT0 )
      viewInfo.selectedRegion.setT0( newT );
   else 
      viewInfo.selectedRegion.setT1( newT );
 
   // Ensure it is visible
   window.ScrollIntoView(newT);
 
   ProjectHistory::Get( project ).ModifyState(false);
}

References PackedArray::end(), AudioIO::Get(), ProjectAudioIO::Get(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), ProjectWindow::Get(), ProjectAudioIO::IsAudioActive(), min(), anonymous_namespace{SelectMenus.cpp}::SeekInfo::mLastSelectionAdjustment, and ProjectHistory::ModifyState().

Referenced by SelectActions::Handler::OnSelSetExtendLeft(), and SelectActions::Handler::OnSelSetExtendRight().

Here is the call graph for this function:

Here is the caller graph for this function:

DoCursorMove()

void anonymous_namespace{SelectMenus.cpp}::DoCursorMove	(	AudacityProject &	project,
		double	seekStep,
		wxLongLong &	lastSelectionAdjustment
	)

Definition at line 341 of file SelectMenus.cpp.

{
   if (ProjectAudioIO::Get( project ).IsAudioActive()) {
      SeekWhenAudioActive(seekStep, lastSelectionAdjustment);
   }
   else
   {
      lastSelectionAdjustment = ::wxGetUTCTimeMillis();
      MoveWhenAudioInactive(project, seekStep, TIME_UNIT_SECONDS);
   }
 
   ProjectHistory::Get( project ).ModifyState(false);
}

References ProjectAudioIO::Get(), ProjectHistory::Get(), ProjectHistory::ModifyState(), MoveWhenAudioInactive(), SeekWhenAudioActive(), and TIME_UNIT_SECONDS.

Referenced by SelectActions::Handler::OnCursorLongJumpLeft(), SelectActions::Handler::OnCursorLongJumpRight(), SelectActions::Handler::OnCursorShortJumpLeft(), and SelectActions::Handler::OnCursorShortJumpRight().

Here is the call graph for this function:

Here is the caller graph for this function:

ExtraCursorMenu()

BaseItemSharedPtr anonymous_namespace{SelectMenus.cpp}::ExtraCursorMenu

(

)

Definition at line 1107 of file SelectMenus.cpp.

{
   using Options = CommandManager::Options;
   static BaseItemSharedPtr menu{
   ( FinderScope{ findCommandHandler },
   Menu( wxT("Cursor"), XXO("&Cursor"),
      Command( wxT("CursorLeft"), XXO("Cursor &Left"), FN(OnCursorLeft),
         TracksExistFlag() | TrackPanelHasFocus(),
         Options{ wxT("Left") }.WantKeyUp().AllowDup() ),
      Command( wxT("CursorRight"), XXO("Cursor &Right"), FN(OnCursorRight),
         TracksExistFlag() | TrackPanelHasFocus(),
         Options{ wxT("Right") }.WantKeyUp().AllowDup() ),
      Command( wxT("CursorShortJumpLeft"), XXO("Cursor Sh&ort Jump Left"),
         FN(OnCursorShortJumpLeft),
         TracksExistFlag() | TrackPanelHasFocus(), wxT(",") ),
      Command( wxT("CursorShortJumpRight"), XXO("Cursor Shor&t Jump Right"),
         FN(OnCursorShortJumpRight),
         TracksExistFlag() | TrackPanelHasFocus(), wxT(".") ),
      Command( wxT("CursorLongJumpLeft"), XXO("Cursor Long J&ump Left"),
         FN(OnCursorLongJumpLeft),
         TracksExistFlag() | TrackPanelHasFocus(), wxT("Shift+,") ),
      Command( wxT("CursorLongJumpRight"), XXO("Cursor Long Ju&mp Right"),
         FN(OnCursorLongJumpRight),
         TracksExistFlag() | TrackPanelHasFocus(), wxT("Shift+.") )
   ) ) };
   return menu;
}

References MenuTable::Command(), findCommandHandler(), FN, MenuTable::Menu(), TrackPanelHasFocus(), TracksExistFlag(), wxT(), and XXO().

Here is the call graph for this function:

ExtraSeekMenu()

BaseItemSharedPtr anonymous_namespace{SelectMenus.cpp}::ExtraSeekMenu

(

)

Definition at line 1140 of file SelectMenus.cpp.

{
   using Options = CommandManager::Options;
   static BaseItemSharedPtr menu{
   ( FinderScope{ findCommandHandler },
   Menu( wxT("Seek"), XXO("See&k"),
      Command( wxT("SeekLeftShort"), XXO("Short Seek &Left During Playback"),
         FN(OnSeekLeftShort), AudioIOBusyFlag(),
         Options{ wxT("Left") }.AllowDup() ),
      Command( wxT("SeekRightShort"),
         XXO("Short Seek &Right During Playback"), FN(OnSeekRightShort),
         AudioIOBusyFlag(),
         Options{ wxT("Right") }.AllowDup() ),
      Command( wxT("SeekLeftLong"), XXO("Long Seek Le&ft During Playback"),
         FN(OnSeekLeftLong), AudioIOBusyFlag(),
         Options{ wxT("Shift+Left") }.AllowDup() ),
      Command( wxT("SeekRightLong"), XXO("Long Seek Rig&ht During Playback"),
         FN(OnSeekRightLong), AudioIOBusyFlag(),
         Options{ wxT("Shift+Right") }.AllowDup() )
   ) ) };
   return menu;
}

References AudioIOBusyFlag(), MenuTable::Command(), findCommandHandler(), FN, MenuTable::Menu(), wxT(), and XXO().

Here is the call graph for this function:

ExtraSelectionMenu()

BaseItemSharedPtr anonymous_namespace{SelectMenus.cpp}::ExtraSelectionMenu

(

)

Definition at line 1011 of file SelectMenus.cpp.

{
   using Options = CommandManager::Options;
   static BaseItemSharedPtr menu{
   ( FinderScope{ findCommandHandler },
   Menu( wxT("Select"), XXO("&Selection"),
      Command( wxT("SnapToOff"), XXO("Snap-To &Off"), FN(OnSnapToOff),
         AlwaysEnabledFlag ),
      Command( wxT("SnapToNearest"), XXO("Snap-To &Nearest"),
         FN(OnSnapToNearest), AlwaysEnabledFlag ),
      Command( wxT("SnapToPrior"), XXO("Snap-To &Prior"), FN(OnSnapToPrior),
         AlwaysEnabledFlag ),
      Command( wxT("SelStart"), XXO("Selection to &Start"), FN(OnSelToStart),
         AlwaysEnabledFlag, wxT("Shift+Home") ),
      Command( wxT("SelEnd"), XXO("Selection to En&d"), FN(OnSelToEnd),
         AlwaysEnabledFlag, wxT("Shift+End") ),
      Command( wxT("SelExtLeft"), XXO("Selection Extend &Left"),
         FN(OnSelExtendLeft),
         TracksExistFlag() | TrackPanelHasFocus(),
         Options{ wxT("Shift+Left") }.WantKeyUp().AllowDup() ),
      Command( wxT("SelExtRight"), XXO("Selection Extend &Right"),
         FN(OnSelExtendRight),
         TracksExistFlag() | TrackPanelHasFocus(),
         Options{ wxT("Shift+Right") }.WantKeyUp().AllowDup() ),
      Command( wxT("SelSetExtLeft"), XXO("Set (or Extend) Le&ft Selection"),
         FN(OnSelSetExtendLeft),
         TracksExistFlag() | TrackPanelHasFocus() ),
      Command( wxT("SelSetExtRight"), XXO("Set (or Extend) Rig&ht Selection"),
         FN(OnSelSetExtendRight),
         TracksExistFlag() | TrackPanelHasFocus() ),
      Command( wxT("SelCntrLeft"), XXO("Selection Contract L&eft"),
         FN(OnSelContractLeft),
         TracksExistFlag() | TrackPanelHasFocus(),
         Options{ wxT("Ctrl+Shift+Right") }.WantKeyUp() ),
      Command( wxT("SelCntrRight"), XXO("Selection Contract R&ight"),
         FN(OnSelContractRight),
         TracksExistFlag() | TrackPanelHasFocus(),
         Options{ wxT("Ctrl+Shift+Left") }.WantKeyUp() )
   ) ) };
   return menu;
}

References AlwaysEnabledFlag, MenuTable::Command(), findCommandHandler(), FN, MenuTable::Menu(), TrackPanelHasFocus(), TracksExistFlag(), wxT(), and XXO().

Here is the call graph for this function:

GridMove()

double anonymous_namespace{SelectMenus.cpp}::GridMove	(	AudacityProject &	project,
		double	t,
		int	minPix
	)

Definition at line 164 of file SelectMenus.cpp.

{
   auto &formats = ProjectNumericFormats::Get(project);
   auto rate = ProjectRate::Get(project).GetRate();
   auto &viewInfo = ViewInfo::Get( project );
   auto format = formats.GetSelectionFormat();
 
   NumericConverter nc(NumericConverter::TIME, format, t, rate);
 
   // Try incrementing/decrementing the value; if we've moved far enough we're
   // done
   double result;
   minPix >= 0 ? nc.Increment() : nc.Decrement();
   result = nc.GetValue();
   if (std::abs(viewInfo.TimeToPosition(result) - viewInfo.TimeToPosition(t))
       >= abs(minPix))
       return result;
 
   // Otherwise, move minPix pixels, then snap to the time.
   result = viewInfo.OffsetTimeByPixels(t, minPix);
   nc.SetValue(result);
   result = nc.GetValue();
   return result;
}

References NumericConverter::Decrement(), format, ProjectNumericFormats::Get(), ProjectRate::Get(), ViewInfo::Get(), ProjectRate::GetRate(), NumericConverter::GetValue(), NumericConverter::Increment(), NumericConverter::SetValue(), and NumericConverter::TIME.

Referenced by OffsetTime().

Here is the call graph for this function:

Here is the caller graph for this function:

MoveWhenAudioInactive()

void anonymous_namespace{SelectMenus.cpp}::MoveWhenAudioInactive	(	AudacityProject &	project,
		double	seekStep,
		TimeUnit	timeUnit
	)

Definition at line 206 of file SelectMenus.cpp.

{
   auto &viewInfo = ViewInfo::Get( project );
   auto &trackPanel = TrackPanel::Get( project );
   auto &tracks = TrackList::Get( project );
   auto &ruler = AdornedRulerPanel::Get( project );
   const auto &settings = ProjectSettings::Get( project );
   auto &window = ProjectWindow::Get( project );
 
   // If TIME_UNIT_SECONDS, snap-to will be off.
   int snapToTime = settings.GetSnapTo();
   const double t0 = viewInfo.selectedRegion.t0();
   const double end = std::max( 
      tracks.GetEndTime(),
      viewInfo.GetScreenEndTime());
 
   // Move the cursor
   // Already in cursor mode?
   if( viewInfo.selectedRegion.isPoint() )
   {
      double newT = OffsetTime(project,
         t0, seekStep, timeUnit, snapToTime);
      // constrain.
      newT = std::max(0.0, newT);
      newT = std::min(newT, end);
      // Move 
      viewInfo.selectedRegion.setT0(
         newT,
         false); // do not swap selection boundaries
      viewInfo.selectedRegion.collapseToT0();
 
      // Move the visual cursor, avoiding an unnecessary complete redraw
      trackPanel.DrawOverlays(false);
      ruler.DrawOverlays(false);
   }
   else
   {
      // Transition to cursor mode.
      if( seekStep < 0 )
         viewInfo.selectedRegion.collapseToT0();
      else
         viewInfo.selectedRegion.collapseToT1();
      trackPanel.Refresh(false);
   }
 
   // Make sure NEW position is in view
   window.ScrollIntoView(viewInfo.selectedRegion.t1());
   return;
}

References PackedArray::end(), ViewInfo::Get(), TrackList::Get(), AdornedRulerPanel::Get(), ProjectSettings::Get(), ProjectWindow::Get(), TrackPanel::Get(), min(), OffsetTime(), anonymous_namespace{TimeTrackVRulerControls.cpp}::ruler(), and settings().

Referenced by DoCursorMove(), and SeekWhenAudioInactive().

Here is the call graph for this function:

Here is the caller graph for this function:

NearestZeroCrossing()

double anonymous_namespace{SelectMenus.cpp}::NearestZeroCrossing	(	AudacityProject &	project,
		double	t0
	)

Definition at line 30 of file SelectMenus.cpp.

{
   auto rate = ProjectRate::Get(project).GetRate();
   auto &tracks = TrackList::Get( project );
 
   // Window is 1/100th of a second.
   auto windowSize = size_t(std::max(1.0, rate / 100));
   Floats dist{ windowSize, true };
 
   int nTracks = 0;
   for (auto one : tracks.Selected< const WaveTrack >()) {
      auto oneWindowSize = size_t(std::max(1.0, one->GetRate() / 100));
      Floats oneDist{ oneWindowSize };
      auto s = one->TimeToLongSamples(t0);
      // fillTwo to ensure that missing values are treated as 2, and hence do
      // not get used as zero crossings.
      one->GetFloats(oneDist.get(),
               s - (int)oneWindowSize/2, oneWindowSize, fillTwo);
 
 
      // Looking for actual crossings.
      double prev = 2.0;
      for(size_t i=0; i<oneWindowSize; i++){
         float fDist = fabs( oneDist[i]); // score is absolute value
         if( prev * oneDist[i] > 0 ) // both same sign?  No good.
            fDist = fDist + 0.4; // No good if same sign.
         else if( prev > 0.0 )
            fDist = fDist + 0.1; // medium penalty for downward crossing.
         prev = oneDist[i];
         oneDist[i] = fDist;
      }
 
      // TODO: The mixed rate zero crossing code is broken,
      // if oneWindowSize > windowSize we'll miss out some
      // samples - so they will still be zero, so we'll use them.
      for(size_t i = 0; i < windowSize; i++) {
         size_t j;
         if (windowSize != oneWindowSize)
            j = i * (oneWindowSize-1) / (windowSize-1);
         else
            j = i;
 
         dist[i] += oneDist[j];
         // Apply a small penalty for distance from the original endpoint
         // We'll always prefer an upward  
         dist[i] +=
            0.1 * (abs(int(i) - int(windowSize/2))) / float(windowSize/2);
      }
      nTracks++;
   }
 
   // Find minimum
   int argmin = 0;
   float min = 3.0;
   for(size_t i=0; i<windowSize; i++) {
      if (dist[i] < min) {
         argmin = i;
         min = dist[i];
      }
   }
 
   // If we're worse than 0.2 on average, on one track, then no good.
   if(( nTracks == 1 ) && ( min > (0.2*nTracks) ))
      return t0;
   // If we're worse than 0.6 on average, on multi-track, then no good.
   if(( nTracks > 1 ) && ( min > (0.6*nTracks) ))
      return t0;
 
   return t0 + (argmin - (int)windowSize/2) / rate;
}

References fillTwo, ProjectRate::Get(), TrackList::Get(), ProjectRate::GetRate(), and min().

Referenced by SelectActions::Handler::OnZeroCrossing().

Here is the call graph for this function:

Here is the caller graph for this function:

OffsetTime()

double anonymous_namespace{SelectMenus.cpp}::OffsetTime	(	AudacityProject &	project,
		double	t,
		double	offset,
		TimeUnit	timeUnit,
		int	snapToTime
	)

Definition at line 190 of file SelectMenus.cpp.

{
   auto &viewInfo = ViewInfo::Get( project );
 
    if (timeUnit == TIME_UNIT_SECONDS)
        return t + offset; // snapping is currently ignored for non-pixel moves
 
    if (snapToTime == SNAP_OFF)
        return viewInfo.OffsetTimeByPixels(t, (int)offset);
 
    return GridMove(project, t, (int)offset);
}

References ViewInfo::Get(), GridMove(), SNAP_OFF, and TIME_UNIT_SECONDS.

Referenced by MoveWhenAudioInactive(), and SeekWhenAudioInactive().

Here is the call graph for this function:

Here is the caller graph for this function:

OnlyHandleKeyUp()

bool anonymous_namespace{SelectMenus.cpp}::OnlyHandleKeyUp

(

const CommandContext &

context

)

Definition at line 105 of file SelectMenus.cpp.

{
   auto &project = context.project;
   auto evt = context.pEvt;
   bool bKeyUp = (evt) && evt->GetEventType() == wxEVT_KEY_UP;
 
   if( ProjectAudioIO::Get( project ).IsAudioActive() )
      return bKeyUp;
   if( !bKeyUp )
      return false;
 
   ProjectHistory::Get( project ).ModifyState(false);
   return true;
}

References ProjectAudioIO::Get(), ProjectHistory::Get(), ProjectAudioIO::IsAudioActive(), ProjectHistory::ModifyState(), CommandContext::pEvt, and CommandContext::project.

Referenced by SelectActions::Handler::OnCursorLeft(), SelectActions::Handler::OnCursorRight(), SelectActions::Handler::OnSelContractLeft(), SelectActions::Handler::OnSelContractRight(), SelectActions::Handler::OnSelExtendLeft(), and SelectActions::Handler::OnSelExtendRight().

Here is the call graph for this function:

Here is the caller graph for this function:

SeekLeftOrRight()

void anonymous_namespace{SelectMenus.cpp}::SeekLeftOrRight	(	AudacityProject &	project,
		double	direction,
		SelectionOperation	operation,
		SeekInfo &	info
	)

Definition at line 303 of file SelectMenus.cpp.

{
   // PRL:  What I found and preserved, strange though it be:
   // During playback:  jump depends on preferences and is independent of the
   // zoom and does not vary if the key is held
   // Else: jump depends on the zoom and gets bigger if the key is held
 
   if( ProjectAudioIO::Get( project ).IsAudioActive() )
   {
      if( operation == CURSOR_MOVE )
         SeekWhenAudioActive( info.mSeekShort * direction,
            info.mLastSelectionAdjustment );
      else if( operation == SELECTION_EXTEND )
         SeekWhenAudioActive( info.mSeekLong * direction,
            info.mLastSelectionAdjustment );
      // Note: no action for CURSOR_CONTRACT
      return;
   }
 
   // If the last adjustment was very recent, we are
   // holding the key down and should move faster.
   const wxLongLong curtime = ::wxGetUTCTimeMillis();
   enum { MIN_INTERVAL = 50 };
   const bool fast =
      (curtime - info.mLastSelectionAdjustment < MIN_INTERVAL);
 
   info.mLastSelectionAdjustment = curtime;
 
   // How much faster should the cursor move if shift is down?
   enum { LARGER_MULTIPLIER = 4 };
   const double seekStep = (fast ? LARGER_MULTIPLIER : 1.0) * direction;
 
   SeekWhenAudioInactive( project, seekStep, TIME_UNIT_PIXELS, operation);
}

References CURSOR_MOVE, ProjectAudioIO::Get(), anonymous_namespace{SelectMenus.cpp}::SeekInfo::mLastSelectionAdjustment, anonymous_namespace{SelectMenus.cpp}::SeekInfo::mSeekLong, anonymous_namespace{SelectMenus.cpp}::SeekInfo::mSeekShort, SeekWhenAudioActive(), SeekWhenAudioInactive(), SELECTION_EXTEND, and TIME_UNIT_PIXELS.

Referenced by SelectActions::Handler::OnCursorLeft(), SelectActions::Handler::OnCursorRight(), SelectActions::Handler::OnSeekLeftLong(), SelectActions::Handler::OnSeekLeftShort(), SelectActions::Handler::OnSeekRightLong(), SelectActions::Handler::OnSeekRightShort(), SelectActions::Handler::OnSelContractLeft(), SelectActions::Handler::OnSelContractRight(), SelectActions::Handler::OnSelExtendLeft(), and SelectActions::Handler::OnSelExtendRight().

Here is the call graph for this function:

Here is the caller graph for this function:

SeekWhenAudioActive()

void anonymous_namespace{SelectMenus.cpp}::SeekWhenAudioActive	(	double	seekStep,
		wxLongLong &	lastSelectionAdjustment
	)

Definition at line 143 of file SelectMenus.cpp.

{
   auto gAudioIO = AudioIO::Get();
#ifdef EXPERIMENTAL_IMPROVED_SEEKING
   if (gAudioIO->GetLastPlaybackTime() < lastSelectionAdjustment) {
      // Allow time for the last seek to output a buffer before
      // discarding samples again
      // Do not advance mLastSelectionAdjustment
      return;
   }
#endif
   lastSelectionAdjustment = ::wxGetUTCTimeMillis();
 
   gAudioIO->SeekStream(seekStep);
}

References AudioIO::Get().

Referenced by DoCursorMove(), and SeekLeftOrRight().

Here is the call graph for this function:

Here is the caller graph for this function:

SeekWhenAudioInactive()

void anonymous_namespace{SelectMenus.cpp}::SeekWhenAudioInactive	(	AudacityProject &	project,
		double	seekStep,
		TimeUnit	timeUnit,
		SelectionOperation	operation
	)

Definition at line 257 of file SelectMenus.cpp.

{
   auto &viewInfo = ViewInfo::Get( project );
   auto &tracks = TrackList::Get( project );
   const auto &settings = ProjectSettings::Get( project );
   auto &window = ProjectWindow::Get( project );
 
   if( operation == CURSOR_MOVE )
   {
      MoveWhenAudioInactive( project, seekStep, timeUnit);
      return;
   }
 
   int snapToTime = settings.GetSnapTo();
   const double t0 = viewInfo.selectedRegion.t0();
   const double t1 = viewInfo.selectedRegion.t1();
   const double end = std::max( 
      tracks.GetEndTime(),
      viewInfo.GetScreenEndTime());
 
   // Is it t0 or t1 moving?
   bool bMoveT0 = (operation == SELECTION_CONTRACT && seekStep > 0) ||
      (operation == SELECTION_EXTEND && seekStep < 0);
   // newT is where we want to move to
   double newT = OffsetTime( project,
      bMoveT0 ? t0 : t1, seekStep, timeUnit, snapToTime);
   // constrain to be in the track/screen limits.
   newT = std::max( 0.0, newT );
   newT = std::min( newT, end);
   // optionally constrain to be a contraction, i.e. so t0/t1 do not cross over
   if( operation == SELECTION_CONTRACT )
      newT = bMoveT0 ? std::min( t1, newT ) : std::max( t0, newT );
 
   // Actually move
   if( bMoveT0 )
      viewInfo.selectedRegion.setT0( newT );
   else 
      viewInfo.selectedRegion.setT1( newT );
 
   // Ensure it is visible
   window.ScrollIntoView(newT);
}

References CURSOR_MOVE, PackedArray::end(), ViewInfo::Get(), TrackList::Get(), ProjectSettings::Get(), ProjectWindow::Get(), min(), MoveWhenAudioInactive(), OffsetTime(), SELECTION_CONTRACT, SELECTION_EXTEND, and settings().

Referenced by SeekLeftOrRight().

Here is the call graph for this function:

Here is the caller graph for this function:

SelectMenu()

BaseItemSharedPtr anonymous_namespace{SelectMenus.cpp}::SelectMenu

(

)

Definition at line 917 of file SelectMenus.cpp.

{
   using Options = CommandManager::Options;
   static BaseItemSharedPtr menu{
   ( FinderScope{ findCommandHandler },
   /* i18n-hint: (verb) It's an item on a menu. */
   Menu( wxT("Select"), XXO("&Select"),
      Section( "Basic",
         Command( wxT("SelectAll"), XXO("&All"), FN(OnSelectAll),
            TracksExistFlag(),
            Options{ wxT("Ctrl+A"), XO("Select All") } ),
         Command( wxT("SelectNone"), XXO("&None"), FN(OnSelectNone),
            TracksExistFlag(),
            Options{ wxT("Ctrl+Shift+A"), XO("Select None") } ),
 
 
         Menu( wxT("Tracks"), XXO("&Tracks"),
            Command( wxT("SelAllTracks"), XXO("In All &Tracks"),
               FN(OnSelectAllTracks),
               TracksExistFlag(),
               wxT("Ctrl+Shift+K") ),
            Command( wxT("SelSyncLockTracks"), XXO("In All &Sync-Locked Tracks"),
               FN(OnSelectSyncLockSel),
               EditableTracksSelectedFlag() | IsSyncLockedFlag(),
               Options{ wxT("Ctrl+Shift+Y"), XO("Select Sync-Locked") } )
         ),
 
 
         Menu( wxT("Region"), XXO("R&egion"),
            Section( "",
               Command( wxT("SetLeftSelection"), XXO("&Left at Playback Position"),
                  FN(OnSetLeftSelection), TracksExistFlag(),
                  Options{ wxT("["), XO("Set Selection Left at Play Position") } ),
               Command( wxT("SetRightSelection"), XXO("&Right at Playback Position"),
                  FN(OnSetRightSelection), TracksExistFlag(),
                  Options{ wxT("]"), XO("Set Selection Right at Play Position") } ),
               Command( wxT("SelTrackStartToCursor"), XXO("Track &Start to Cursor"),
                  FN(OnSelectStartCursor), AlwaysEnabledFlag,
                  Options{ wxT("Shift+J"), XO("Select Track Start to Cursor") } ),
               Command( wxT("SelCursorToTrackEnd"), XXO("Cursor to Track &End"),
                  FN(OnSelectCursorEnd), AlwaysEnabledFlag,
                  Options{ wxT("Shift+K"), XO("Select Cursor to Track End") } ),
               Command( wxT("SelTrackStartToEnd"), XXO("Track Start to En&d"),
                  FN(OnSelectTrackStartToEnd), AlwaysEnabledFlag,
                  Options{}.LongName( XO("Select Track Start to End") ) )
            ),
 
            Section( "",
               // GA: Audacity had 'Store Re&gion' here previously. There is no
               // one-step way to restore the 'Saved Cursor Position' in Select Menu,
               // so arguably using the word 'Selection' to do duty for both saving
               // the region or the cursor is better. But it does not belong in a
               // 'Region' submenu.
               Command( wxT("SelSave"), XXO("S&tore Selection"), FN(OnSelectionSave),
                  WaveTracksSelectedFlag() ),
               // Audacity had 'Retrieve Regio&n' here previously.
               Command( wxT("SelRestore"), XXO("Retrieve Selectio&n"),
                  FN(OnSelectionRestore), TracksExistFlag() )
            )
         )
 
 
      ),
 
      Section( "",
         Command( wxT("SelCursorStoredCursor"),
            XXO("Cursor to Stored &Cursor Position"),
            FN(OnSelectCursorStoredCursor), TracksExistFlag(),
            Options{}.LongName( XO("Select Cursor to Stored") ) ),
 
         Command( wxT("StoreCursorPosition"), XXO("Store Cursor Pos&ition"),
            FN(OnCursorPositionStore),
            WaveTracksExistFlag() )
         // Save cursor position is used in some selections.
         // Maybe there should be a restore for it?
      ),
 
      Section( "",
         Command( wxT("ZeroCross"), XXO("At &Zero Crossings"),
            FN(OnZeroCrossing), EditableTracksSelectedFlag(),
            Options{ wxT("Z"), XO("Select Zero Crossing") } )
      )
   ) ) };
   return menu;
}

References AlwaysEnabledFlag, MenuTable::Command(), EditableTracksSelectedFlag(), findCommandHandler(), FN, IsSyncLockedFlag(), CommandManager::Options::LongName(), MenuTable::Menu(), MenuTable::Section(), TracksExistFlag(), WaveTracksExistFlag(), WaveTracksSelectedFlag(), wxT(), XO(), and XXO().

Here is the call graph for this function:

Variable Documentation

sAttachment0

AttachedItem anonymous_namespace{SelectMenus.cpp}::sAttachment0

Initial value:

{
   wxT("Transport/Basic"),
   Shared( CursorMenu() )
}

Definition at line 1102 of file SelectMenus.cpp.

sAttachment1

AttachedItem anonymous_namespace{SelectMenus.cpp}::sAttachment1

Initial value:

{
   wxT(""),
   Shared( SelectMenu() )
}

Definition at line 1006 of file SelectMenus.cpp.

sAttachment2

AttachedItem anonymous_namespace{SelectMenus.cpp}::sAttachment2

Initial value:

{
   wxT("Optional/Extra/Part1"),
   Shared( ExtraSelectionMenu() )
}

Definition at line 1053 of file SelectMenus.cpp.

sAttachment4

AttachedItem anonymous_namespace{SelectMenus.cpp}::sAttachment4

Initial value:

{
   wxT("Optional/Extra/Part2"),
   Shared( ExtraCursorMenu() )
}

Definition at line 1135 of file SelectMenus.cpp.

sAttachment5

AttachedItem anonymous_namespace{SelectMenus.cpp}::sAttachment5

Initial value:

{
   wxT("Optional/Extra/Part1"),
   Shared( ExtraSeekMenu() )
}

Definition at line 1163 of file SelectMenus.cpp.