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
constexpr auto	GetWindowSize (double projectRate)
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, SnapMode snapMode)
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)
auto	SelectMenu ()
auto	ExtraSelectionMenu ()
auto	CursorMenu ()
auto	ExtraCursorMenu ()
auto	ExtraSeekMenu ()

Variables
AttachedItem	sAttachment1 { Indirect(SelectMenu()) }
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 132 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 137 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 143 of file SelectMenus.cpp.

              {
    TIME_UNIT_SECONDS,
    TIME_UNIT_PIXELS
};

Function Documentation

CursorMenu()

auto anonymous_namespace{SelectMenus.cpp}::CursorMenu

(

)

Definition at line 1091 of file SelectMenus.cpp.

{
   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 auto menu = std::shared_ptr{
   ( 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, MenuRegistry::Command, EditableTracksSelectedFlag(), findCommandHandler(), FN, MenuRegistry::Options::LongName(), MenuRegistry::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 368 of file SelectMenus.cpp.

{
   auto &viewInfo = ViewInfo::Get(project);
   auto &tracks = TrackList::Get(project);
   auto &viewport = Viewport::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
   viewport.ScrollIntoView(newT);
 
   ProjectHistory::Get( project ).ModifyState(false);
}

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

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 352 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(), project, 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()

auto anonymous_namespace{SelectMenus.cpp}::ExtraCursorMenu

(

)

Definition at line 1136 of file SelectMenus.cpp.

{
   static auto menu = std::shared_ptr{
   ( 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 MenuRegistry::Command, findCommandHandler(), FN, MenuRegistry::Menu, TrackPanelHasFocus(), TracksExistFlag(), wxT(), and XXO().

Here is the call graph for this function:

ExtraSeekMenu()

auto anonymous_namespace{SelectMenus.cpp}::ExtraSeekMenu

(

)

Definition at line 1167 of file SelectMenus.cpp.

{
   static auto menu = std::shared_ptr{
   ( 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(), MenuRegistry::Command, findCommandHandler(), FN, MenuRegistry::Menu, wxT(), and XXO().

Here is the call graph for this function:

ExtraSelectionMenu()

auto anonymous_namespace{SelectMenus.cpp}::ExtraSelectionMenu

(

)

Definition at line 1044 of file SelectMenus.cpp.

{
   static auto menu = std::shared_ptr{
   ( 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, MenuRegistry::Command, findCommandHandler(), FN, MenuRegistry::Menu, TrackPanelHasFocus(), TracksExistFlag(), wxT(), and XXO().

Here is the call graph for this function:

GetWindowSize()

constexpr auto anonymous_namespace{SelectMenus.cpp}::GetWindowSize ( double  projectRate )

constexpr

Definition at line 31 of file SelectMenus.cpp.

{
   return size_t(std::max(1.0, projectRate / 100));
}

Referenced by NearestZeroCrossing(), and SelectActions::Handler::OnZeroCrossing().

Here is the caller graph for this function:

GridMove()

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

Definition at line 176 of file SelectMenus.cpp.

{
   auto& projectSnap = ProjectSnap::Get(project);
   auto &viewInfo = ViewInfo::Get( project );
 
   auto result = projectSnap.SingleStep(t, minPix >= 0).time;
 
   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);
   return projectSnap.SnapTime(result).time;
}

References ProjectSnap::Get(), ViewInfo::Get(), and project.

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 210 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 = ProjectSnap::Get(project);
   auto &viewport = Viewport::Get(project);
 
   // If TIME_UNIT_SECONDS, snap-to will be off.
   auto snapMode = settings.GetSnapMode();
 
   // Move the cursor
   // Already in cursor mode?
   if (viewInfo.selectedRegion.isPoint())
   {
      double newT = OffsetTime(
         project, viewInfo.selectedRegion.t0(), seekStep, timeUnit, snapMode);
      // constrain.
      newT = std::max(0.0, newT);
      // 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.
      constexpr auto maySwapBoundaries = false;
      if (seekStep < 0)
      {
         if (snapMode != SnapMode::SNAP_OFF)
            viewInfo.selectedRegion.setT0(
               settings.SnapTime(viewInfo.selectedRegion.t0()).time,
               maySwapBoundaries);
         viewInfo.selectedRegion.collapseToT0();
      }
      else
      {
         if (snapMode != SnapMode::SNAP_OFF)
            viewInfo.selectedRegion.setT1(
               settings.SnapTime(viewInfo.selectedRegion.t1()).time,
               maySwapBoundaries);
         viewInfo.selectedRegion.collapseToT1();
      }
      trackPanel.Refresh(false);
   }
 
   // Make sure NEW position is in view
   viewport.ScrollIntoView(viewInfo.selectedRegion.t1());
   return;
}

References ProjectSnap::Get(), ViewInfo::Get(), TrackList::Get(), Viewport::Get(), AdornedRulerPanel::Get(), TrackPanel::Get(), OffsetTime(), project, anonymous_namespace{TimeTrackVRulerControls.cpp}::ruler(), settings(), SNAP_OFF, and tracks.

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 36 of file SelectMenus.cpp.

{
   auto rate = ProjectRate::Get(project).GetRate();
   auto &tracks = TrackList::Get( project );
 
   // Window is 1/100th of a second.
   auto windowSize = GetWindowSize(rate);
   Floats dist{ windowSize, true };
 
   int nTracks = 0;
   for (auto one : tracks.Selected<const WaveTrack>()) {
      const auto nChannels = one->NChannels();
      auto oneWindowSize = size_t(std::max(1.0, one->GetRate() / 100));
      Floats buffer1{ oneWindowSize };
      Floats buffer2{ oneWindowSize };
      float *const buffers[]{ buffer1.get(), buffer2.get() };
      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(0, nChannels, buffers,
         s - (int)oneWindowSize/2, oneWindowSize, false, FillFormat::fillTwo);
 
 
      // Looking for actual crossings.  Update dist
      for (size_t iChannel = 0; iChannel < nChannels; ++iChannel) {
         const auto oneDist = buffers[iChannel];
         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(), GetWindowSize(), anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, min(), project, and tracks.

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,
		SnapMode	snapMode
	)

Definition at line 194 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 (snapMode == SnapMode::SNAP_OFF)
        return viewInfo.OffsetTimeByPixels(t, (int)offset);
 
    return GridMove(project, t, (int)offset);
}

References ViewInfo::Get(), GridMove(), project, 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 117 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, CommandContext::project, and 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 314 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, project, 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 155 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 269 of file SelectMenus.cpp.

{
   auto &viewInfo = ViewInfo::Get(project);
   auto &tracks = TrackList::Get(project);
   const auto &settings = ProjectSnap::Get(project);
   auto &viewport = Viewport::Get(project);
 
   if (operation == CURSOR_MOVE)
   {
      MoveWhenAudioInactive( project, seekStep, timeUnit);
      return;
   }
 
   auto snapMode = settings.GetSnapMode();
   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, snapMode);
   // 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
   viewport.ScrollIntoView(newT);
}

References CURSOR_MOVE, details::end(), ProjectSnap::Get(), ViewInfo::Get(), TrackList::Get(), Viewport::Get(), min(), MoveWhenAudioInactive(), OffsetTime(), project, SELECTION_CONTRACT, SELECTION_EXTEND, settings(), and tracks.

Referenced by SeekLeftOrRight().

Here is the call graph for this function:

Here is the caller graph for this function:

SelectMenu()

auto anonymous_namespace{SelectMenus.cpp}::SelectMenu

(

)

Definition at line 954 of file SelectMenus.cpp.

{
   static auto menu = std::shared_ptr{
   ( 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, MenuRegistry::Command, EditableTracksSelectedFlag(), findCommandHandler(), FN, IsSyncLockedFlag(), MenuRegistry::Options::LongName(), MenuRegistry::Menu, MenuRegistry::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:

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

Definition at line 1132 of file SelectMenus.cpp.

sAttachment1

AttachedItem anonymous_namespace{SelectMenus.cpp}::sAttachment1 { Indirect(SelectMenu()) }

Definition at line 1042 of file SelectMenus.cpp.

sAttachment2

AttachedItem anonymous_namespace{SelectMenus.cpp}::sAttachment2

Initial value:

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

Definition at line 1085 of file SelectMenus.cpp.

sAttachment4

AttachedItem anonymous_namespace{SelectMenus.cpp}::sAttachment4

Initial value:

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

Definition at line 1163 of file SelectMenus.cpp.

sAttachment5

AttachedItem anonymous_namespace{SelectMenus.cpp}::sAttachment5

Initial value:

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

Definition at line 1189 of file SelectMenus.cpp.