diff --git a/src/TrackPanel.cpp b/src/TrackPanel.cpp
index 59a7bd199..36246b858 100644
--- a/src/TrackPanel.cpp
+++ b/src/TrackPanel.cpp
@@ -1881,7 +1881,7 @@ void TrackPanel::HandleSelect(wxMouseEvent & event)
                selectedClip->GetOffset(), selectedClip->GetEndTime());
          }
          //Also, capture this track for dragging until we up-click.
-         mCapturedClipArray.push_back(TrackClip(w, selectedClip));
+         mClipMoveState.capturedClipArray.push_back(TrackClip(w, selectedClip));
 
          mMouseCapture = IsSliding;
 
@@ -3325,7 +3325,7 @@ void TrackPanel::ForwardEventToEnvelope(wxMouseEvent & event)
    }
 }
 
-void TrackPanel::HandleSlide(wxMouseEvent & event)
+void TrackPanel::HandleSlide( wxMouseEvent & event )
 {
    if (event.LeftDown())
       StartSlide(event);
@@ -3343,17 +3343,17 @@ void TrackPanel::HandleSlide(wxMouseEvent & event)
       mSnapManager.reset();
 
       // Do not draw yellow lines
-      if (mSnapLeft != -1 || mSnapRight != -1) {
-         mSnapLeft = mSnapRight = -1;
+      if ( mClipMoveState.snapLeft != -1 || mClipMoveState.snapRight != -1) {
+         mClipMoveState.snapLeft = mClipMoveState.snapRight = -1;
          Refresh(false);
       }
 
-      if (!mDidSlideVertically && mHSlideAmount==0)
+      if (!mDidSlideVertically && mClipMoveState.hSlideAmount == 0)
          return;
 
-      for (size_t i = 0; i < mCapturedClipArray.size(); i++)
+      for (size_t i = 0; i < mClipMoveState.capturedClipArray.size(); i++)
       {
-         TrackClip &trackClip = mCapturedClipArray[i];
+         TrackClip &trackClip = mClipMoveState.capturedClipArray[i];
          WaveClip* pWaveClip = trackClip.clip;
          // Note that per TrackPanel::AddClipsToCaptured(Track *t, double t0, double t1),
          // in the non-WaveTrack case, the code adds a NULL clip to mCapturedClipArray,
@@ -3380,14 +3380,14 @@ void TrackPanel::HandleSlide(wxMouseEvent & event)
          consolidate = false;
       }
       else {
-         wxString direction = mHSlideAmount>0 ?
+         wxString direction = mClipMoveState.hSlideAmount > 0 ?
             /* i18n-hint: a direction as in left or right.*/
             _("right") :
             /* i18n-hint: a direction as in left or right.*/
             _("left");
          /* i18n-hint: %s is a direction like left or right */
          msg.Printf(_("Time shifted tracks/clips %s %.02f seconds"),
-                    direction.c_str(), fabs(mHSlideAmount));
+                    direction.c_str(), fabs( mClipMoveState.hSlideAmount ));
          consolidate = true;
       }
       MakeParentPushState(msg, _("Time-Shift"),
@@ -3443,10 +3443,9 @@ namespace {
 /// Prepare for sliding.
 void TrackPanel::StartSlide(wxMouseEvent & event)
 {
-   mHSlideAmount = 0.0;
-   mDidSlideVertically = false;
+   mClipMoveState = ClipMoveState{};
 
-   mTrackExclusions.clear();
+   mDidSlideVertically = false;
 
    const auto foundCell = FindCell(event.m_x, event.m_y);
    auto &vt = foundCell.pTrack;
@@ -3459,7 +3458,7 @@ void TrackPanel::StartSlide(wxMouseEvent & event)
 
    double clickTime =
       mViewInfo->PositionToTime(event.m_x, GetLeftOffset());
-   mCapturedClipIsSelection =
+   mClipMoveState.capturedClipIsSelection =
       (vt->GetSelected() &&
       clickTime > mViewInfo->selectedRegion.t0() &&
       clickTime < mViewInfo->selectedRegion.t1());
@@ -3475,12 +3474,12 @@ void TrackPanel::StartSlide(wxMouseEvent & event)
    {
 #ifdef USE_MIDI
       if (!wt)
-         mCapturedClip = NULL;
+         mClipMoveState.capturedClip = NULL;
       else
 #endif
       {
-         mCapturedClip = wt->GetClipAtX(event.m_x);
-         if (mCapturedClip == NULL)
+         mClipMoveState.capturedClip = wt->GetClipAtX(event.m_x);
+         if (mClipMoveState.capturedClip == NULL)
             return;
       }
 
@@ -3488,8 +3487,8 @@ void TrackPanel::StartSlide(wxMouseEvent & event)
       CreateListOfCapturedClips(clickTime);
 
    } else {
-      mCapturedClip = NULL;
-      mCapturedClipArray.clear();
+      mClipMoveState.capturedClip = NULL;
+      mClipMoveState.capturedClipArray.clear();
       mCapturedTrack = vt;
    }
 
@@ -3505,15 +3504,15 @@ void TrackPanel::StartSlide(wxMouseEvent & event)
 
    mSnapManager = std::make_unique<SnapManager>(GetTracks(),
                                   mViewInfo,
-                                  &mCapturedClipArray,
-                                  &mTrackExclusions,
+                                  &mClipMoveState.capturedClipArray,
+                                  &mClipMoveState.trackExclusions,
                                   true); // don't snap to time
-   mSnapLeft = -1;
-   mSnapRight = -1;
+   mClipMoveState.snapLeft = -1;
+   mClipMoveState.snapRight = -1;
    mSnapPreferRightEdge = false;
-   if (mCapturedClip) {
-      if (fabs(mSelStart - mCapturedClip->GetEndTime()) <
-          fabs(mSelStart - mCapturedClip->GetStartTime()))
+   if (mClipMoveState.capturedClip) {
+      if (fabs(mSelStart - mClipMoveState.capturedClip->GetEndTime()) <
+          fabs(mSelStart - mClipMoveState.capturedClip->GetStartTime()))
          mSnapPreferRightEdge = true;
    }
 
@@ -3522,36 +3521,41 @@ void TrackPanel::StartSlide(wxMouseEvent & event)
 
 void TrackPanel::CreateListOfCapturedClips(double clickTime)
 {
+   auto &state = mClipMoveState;
+   auto &trackList = *GetTracks();
+   auto &capturedTrack = *mCapturedTrack;
+
 // The captured clip is the focus, but we need to create a list
    // of all clips that have to move, also...
 
-   mCapturedClipArray.clear();
+   state.capturedClipArray.clear();
 
    // First, if click was in selection, capture selected clips; otherwise
    // just the clicked-on clip
-   if (mCapturedClipIsSelection) {
-      TrackListIterator iter(GetTracks());
+   if ( state.capturedClipIsSelection ) {
+      TrackListIterator iter( &trackList );
       for (Track *t = iter.First(); t; t = iter.Next()) {
          if (t->GetSelected()) {
             AddClipsToCaptured(t, true);
             if (t->GetKind() != Track::Wave)
-               mTrackExclusions.push_back(t);
+               state.trackExclusions.push_back(t);
          }
       }
    }
    else {
-      mCapturedClipArray.push_back(TrackClip(mCapturedTrack, mCapturedClip));
+      state.capturedClipArray.push_back
+         (TrackClip( &capturedTrack, state.capturedClip ));
 
       // Check for stereo partner
-      Track *partner = mCapturedTrack->GetLink();
+      Track *partner = capturedTrack.GetLink();
       WaveTrack *wt;
-      if (mCapturedClip &&
+      if (state.capturedClip &&
             // Assume linked track is wave or null
             nullptr != (wt = static_cast<WaveTrack*>(partner))) {
          WaveClip *const clip = FindClipAtTime(wt, clickTime);
 
          if (clip)
-            mCapturedClipArray.push_back(TrackClip(partner, clip));
+            state.capturedClipArray.push_back(TrackClip(partner, clip));
       }
    }
 
@@ -3562,34 +3566,34 @@ void TrackPanel::CreateListOfCapturedClips(double clickTime)
       // clips are considered (the effect is like recursion and terminates
       // because AddClipsToCaptured doesn't add duplicate clips); to remove
       // this behavior just store the array size beforehand.
-      for (unsigned int i = 0; i < mCapturedClipArray.size(); ++i) {
+      for (unsigned int i = 0; i < state.capturedClipArray.size(); ++i) {
          // Capture based on tracks that have clips -- that means we
          // don't capture based on links to label tracks for now (until
          // we can treat individual labels as clips)
-         if (mCapturedClipArray[i].clip) {
+         if ( state.capturedClipArray[i].clip ) {
             // Iterate over sync-lock group tracks.
-            SyncLockedTracksIterator git(GetTracks());
-            for (Track *t = git.StartWith(mCapturedClipArray[i].track);
+            SyncLockedTracksIterator git( &trackList );
+            for (Track *t = git.StartWith( state.capturedClipArray[i].track  );
                   t; t = git.Next() )
             {
                AddClipsToCaptured(t,
-                     mCapturedClipArray[i].clip->GetStartTime(),
-                     mCapturedClipArray[i].clip->GetEndTime() );
+                     state.capturedClipArray[i].clip->GetStartTime(),
+                     state.capturedClipArray[i].clip->GetEndTime() );
                if (t->GetKind() != Track::Wave)
-                  mTrackExclusions.push_back(t);
+                  state.trackExclusions.push_back(t);
             }
          }
 #ifdef USE_MIDI
          // Capture additional clips from NoteTracks
-         Track *nt = mCapturedClipArray[i].track;
+         Track *nt = state.capturedClipArray[i].track;
          if (nt->GetKind() == Track::Note) {
             // Iterate over sync-lock group tracks.
-            SyncLockedTracksIterator git(GetTracks());
+            SyncLockedTracksIterator git( &trackList );
             for (Track *t = git.StartWith(nt); t; t = git.Next())
             {
                AddClipsToCaptured(t, nt->GetStartTime(), nt->GetEndTime());
                if (t->GetKind() != Track::Wave)
-                  mTrackExclusions.push_back(t);
+                  state.trackExclusions.push_back(t);
             }
          }
 #endif
@@ -3611,6 +3615,8 @@ void TrackPanel::AddClipsToCaptured(Track *t, bool withinSelection)
 // Adds a track's clips to mCapturedClipArray within a specified time
 void TrackPanel::AddClipsToCaptured(Track *t, double t0, double t1)
 {
+   auto &state = mClipMoveState;
+
    if (t->GetKind() == Track::Wave)
    {
       for(const auto &clip: static_cast<WaveTrack*>(t)->GetClips())
@@ -3619,15 +3625,15 @@ void TrackPanel::AddClipsToCaptured(Track *t, double t0, double t1)
          {
             // Avoid getting clips that were already captured
             bool newClip = true;
-            for (unsigned int i = 0; i < mCapturedClipArray.size(); ++i) {
-               if (mCapturedClipArray[i].clip == clip.get()) {
+            for (unsigned int i = 0; i < state.capturedClipArray.size(); ++i) {
+               if ( state.capturedClipArray[i].clip == clip.get() ) {
                   newClip = false;
                   break;
                }
             }
 
             if (newClip)
-               mCapturedClipArray.push_back(TrackClip(t, clip.get()));
+               state.capturedClipArray.push_back( TrackClip(t, clip.get()) );
          }
       }
    }
@@ -3638,8 +3644,8 @@ void TrackPanel::AddClipsToCaptured(Track *t, double t0, double t1)
 
       // Avoid adding a track twice
       bool newClip = true;
-      for (unsigned int i = 0; i < mCapturedClipArray.size(); ++i) {
-         if (mCapturedClipArray[i].track == t) {
+      for ( unsigned int i = 0; i < state.capturedClipArray.size(); ++i ) {
+         if ( state.capturedClipArray[i].track == t ) {
             newClip = false;
             break;
          }
@@ -3653,7 +3659,7 @@ void TrackPanel::AddClipsToCaptured(Track *t, double t0, double t1)
                return;
          }
 #endif
-         mCapturedClipArray.push_back(TrackClip(t, NULL));
+         state.capturedClipArray.push_back(TrackClip(t, NULL));
       }
    }
 }
@@ -3686,30 +3692,32 @@ void TrackPanel::DoSlide(wxMouseEvent & event)
    // happens relative to the original horizontal position of
    // each clip...
 #ifdef USE_MIDI
-   if (mCapturedClipArray.size())
+   if ( mClipMoveState.capturedClipArray.size() )
 #else
-   if (mCapturedClip)
+   if ( mClipMoveState.capturedClip )
 #endif
    {
-      for(i=0; i<mCapturedClipArray.size(); i++) {
-         if (mCapturedClipArray[i].clip)
-            mCapturedClipArray[i].clip->Offset(-mHSlideAmount);
+      for ( i = 0; i < mClipMoveState.capturedClipArray.size(); ++i ) {
+         if ( mClipMoveState.capturedClipArray[i].clip )
+            mClipMoveState.capturedClipArray[i].clip->Offset
+               ( -mClipMoveState.hSlideAmount );
          else
-            mCapturedClipArray[i].track->Offset(-mHSlideAmount);
+            mClipMoveState.capturedClipArray[i].track->Offset
+               ( -mClipMoveState.hSlideAmount );
       }
    }
    else {
-      mCapturedTrack->Offset(-mHSlideAmount);
+      mCapturedTrack->Offset( -mClipMoveState.hSlideAmount );
       Track* link = mCapturedTrack->GetLink();
       if (link)
-         link->Offset(-mHSlideAmount);
+         link->Offset( -mClipMoveState.hSlideAmount );
    }
 
-   if (mCapturedClipIsSelection) {
+   if ( mClipMoveState.capturedClipIsSelection ) {
       // Slide the selection, too
-      mViewInfo->selectedRegion.move(-mHSlideAmount);
+      mViewInfo->selectedRegion.move( -mClipMoveState.hSlideAmount );
    }
-   mHSlideAmount = 0.0;
+   mClipMoveState.hSlideAmount = 0.0;
 
    // Implement sliding within the track(s)
    double desiredSlideAmount;
@@ -3729,11 +3737,13 @@ void TrackPanel::DoSlide(wxMouseEvent & event)
             mtw->GetRate();  // set it to a sample point
       }
       // Adjust desiredSlideAmount using SnapManager
-      if (mSnapManager && mCapturedClipArray.size()) {
+      if (mSnapManager && mClipMoveState.capturedClipArray.size()) {
          trySnap = true;
-         if (mCapturedClip) {
-            clipLeft = mCapturedClip->GetStartTime() + desiredSlideAmount;
-            clipRight = mCapturedClip->GetEndTime() + desiredSlideAmount;
+         if ( mClipMoveState.capturedClip ) {
+            clipLeft = mClipMoveState.capturedClip->GetStartTime()
+               + desiredSlideAmount;
+            clipRight = mClipMoveState.capturedClip->GetEndTime()
+               + desiredSlideAmount;
          }
          else {
             clipLeft = mCapturedTrack->GetStartTime() + desiredSlideAmount;
@@ -3748,9 +3758,9 @@ void TrackPanel::DoSlide(wxMouseEvent & event)
             desiredSlideAmount = rint(mtw->GetRate() * desiredSlideAmount) /
                mtw->GetRate();  // set it to a sample point
          }
-         if (mSnapManager && mCapturedClip) {
-            clipLeft = mCapturedClip->GetStartTime() + desiredSlideAmount;
-            clipRight = mCapturedClip->GetEndTime() + desiredSlideAmount;
+         if (mSnapManager && mClipMoveState.capturedClip) {
+            clipLeft = mClipMoveState.capturedClip->GetStartTime() + desiredSlideAmount;
+            clipRight = mClipMoveState.capturedClip->GetEndTime() + desiredSlideAmount;
          }
       }
 #endif
@@ -3773,17 +3783,19 @@ void TrackPanel::DoSlide(wxMouseEvent & event)
          }
 
          // Take whichever one snapped (if any) and compute the NEW desiredSlideAmount
-         mSnapLeft = -1;
-         mSnapRight = -1;
+         mClipMoveState.snapLeft = -1;
+         mClipMoveState.snapRight = -1;
          if (newClipLeft != clipLeft) {
             double difference = (newClipLeft - clipLeft);
             desiredSlideAmount += difference;
-            mSnapLeft = mViewInfo->TimeToPosition(newClipLeft, GetLeftOffset());
+            mClipMoveState.snapLeft =
+               mViewInfo->TimeToPosition(newClipLeft, GetLeftOffset());
          }
          else if (newClipRight != clipRight) {
             double difference = (newClipRight - clipRight);
             desiredSlideAmount += difference;
-            mSnapRight = mViewInfo->TimeToPosition(newClipRight, GetLeftOffset());
+            mClipMoveState.snapRight =
+               mViewInfo->TimeToPosition(newClipRight, GetLeftOffset());
          }
       }
    }
@@ -3794,14 +3806,14 @@ void TrackPanel::DoSlide(wxMouseEvent & event)
 
    // If the mouse is over a track that isn't the captured track,
    // decide which tracks the captured clips should go to.
-   if (mCapturedClip && mouseTrack != mCapturedTrack /*&&
-       !mCapturedClipIsSelection*/)
+   if ( mClipMoveState.capturedClip && mouseTrack != mCapturedTrack /*&&
+       !mCapturedClipIsSelection*/ )
    {
       const int diff =
          TrackPosition(*mTracks, mouseTrack) -
          TrackPosition(*mTracks, mCapturedTrack);
-      for (unsigned ii = 0, nn = mCapturedClipArray.size(); ii < nn; ++ii) {
-         TrackClip &trackClip = mCapturedClipArray[ii];
+      for ( unsigned ii = 0, nn = mClipMoveState.capturedClipArray.size(); ii < nn; ++ii ) {
+         TrackClip &trackClip = mClipMoveState.capturedClipArray[ii];
          if (trackClip.clip) {
             // Move all clips up or down by an equal count of audio tracks.
             Track *const pSrcTrack = trackClip.track;
@@ -3826,8 +3838,9 @@ void TrackPanel::DoSlide(wxMouseEvent & event)
       // Having passed that test, remove clips temporarily from their
       // tracks, so moving clips don't interfere with each other
       // when we call CanInsertClip()
-      for (unsigned ii = 0, nn = mCapturedClipArray.size(); ii < nn;  ++ii) {
-         TrackClip &trackClip = mCapturedClipArray[ii];
+      for ( unsigned ii = 0,
+            nn = mClipMoveState.capturedClipArray.size(); ii < nn;  ++ii ) {
+         TrackClip &trackClip = mClipMoveState.capturedClipArray[ii];
          WaveClip *const pSrcClip = trackClip.clip;
          if (pSrcClip)
             trackClip.holder =
@@ -3838,8 +3851,9 @@ void TrackPanel::DoSlide(wxMouseEvent & event)
 
       // Now check that the move is possible
       bool ok = true;
-      for (unsigned ii = 0, nn = mCapturedClipArray.size(); ok && ii < nn; ++ii) {
-         TrackClip &trackClip = mCapturedClipArray[ii];
+      for ( unsigned ii = 0,
+            nn = mClipMoveState.capturedClipArray.size(); ok && ii < nn; ++ii) {
+         TrackClip &trackClip = mClipMoveState.capturedClipArray[ii];
          WaveClip *const pSrcClip = trackClip.clip;
          if (pSrcClip)
             ok = trackClip.dstTrack->CanInsertClip(pSrcClip);
@@ -3847,8 +3861,9 @@ void TrackPanel::DoSlide(wxMouseEvent & event)
       
       if (!ok) {
          // Failure -- put clips back where they were
-         for (unsigned ii = 0, nn = mCapturedClipArray.size(); ii < nn;  ++ii) {
-            TrackClip &trackClip = mCapturedClipArray[ii];
+         for ( unsigned ii = 0,
+               nn = mClipMoveState.capturedClipArray.size(); ii < nn; ++ii) {
+            TrackClip &trackClip = mClipMoveState.capturedClipArray[ii];
             WaveClip *const pSrcClip = trackClip.clip;
             if (pSrcClip)
                // Assume track is wave because it has a clip
@@ -3859,8 +3874,9 @@ void TrackPanel::DoSlide(wxMouseEvent & event)
       }
       else {
          // Do the vertical moves of clips
-         for (unsigned ii = 0, nn = mCapturedClipArray.size(); ii < nn; ++ii) {
-            TrackClip &trackClip = mCapturedClipArray[ii];
+         for ( unsigned ii = 0,
+               nn = mClipMoveState.capturedClipArray.size(); ii < nn; ++ii) {
+            TrackClip &trackClip = mClipMoveState.capturedClipArray[ii];
             WaveClip *const pSrcClip = trackClip.clip;
             if (pSrcClip) {
                const auto dstTrack = trackClip.dstTrack;
@@ -3885,19 +3901,19 @@ void TrackPanel::DoSlide(wxMouseEvent & event)
       return;
    }
 
-   mHSlideAmount = desiredSlideAmount;
+   mClipMoveState.hSlideAmount = desiredSlideAmount;
 
    DoSlideHorizontal();
 
 
-   if (mCapturedClipIsSelection) {
+   if ( mClipMoveState.capturedClipIsSelection ) {
       // Slide the selection, too
-      mViewInfo->selectedRegion.move(mHSlideAmount);
+      mViewInfo->selectedRegion.move( mClipMoveState.hSlideAmount );
    }
 
    if (slidVertically) {
       // NEW origin
-      mHSlideAmount = 0;
+      mClipMoveState.hSlideAmount = 0;
    }
 
    Refresh(false);
@@ -3905,98 +3921,106 @@ void TrackPanel::DoSlide(wxMouseEvent & event)
 
 void TrackPanel::DoSlideHorizontal()
 {
+   auto &state = mClipMoveState;
+   auto &trackList = *GetTracks();
+   auto &capturedTrack = *mCapturedTrack;
+
 #ifdef USE_MIDI
-   if (mCapturedClipArray.size())
+   if ( state.capturedClipArray.size() )
 #else
-   if (mCapturedClip)
+   if ( state.capturedClip )
 #endif
    {
       double allowed;
       double initialAllowed;
-      double safeBigDistance = 1000 + 2.0 * (mTracks->GetEndTime() -
-                                             mTracks->GetStartTime());
+      double safeBigDistance = 1000 + 2.0 * ( trackList.GetEndTime() -
+                                              trackList.GetStartTime() );
 
       do { // loop to compute allowed, does not actually move anything yet
-         initialAllowed = mHSlideAmount;
+         initialAllowed = state.hSlideAmount;
 
          unsigned int i, j;
-         for(i=0; i<mCapturedClipArray.size(); i++) {
-            WaveTrack *track = (WaveTrack *)mCapturedClipArray[i].track;
-            WaveClip *clip = mCapturedClipArray[i].clip;
+         for ( i = 0; i < state.capturedClipArray.size(); ++i ) {
+            WaveTrack *track = (WaveTrack *)state.capturedClipArray[i].track;
+            WaveClip *clip = state. capturedClipArray[i].clip;
 
             if (clip) { // only audio clips are used to compute allowed
                // Move all other selected clips totally out of the way
                // temporarily because they're all moving together and
                // we want to find out if OTHER clips are in the way,
                // not one of the moving ones
-               for(j=0; j<mCapturedClipArray.size(); j++) {
-                  WaveClip *clip2 = mCapturedClipArray[j].clip;
+               for ( j = 0; j < state.capturedClipArray.size(); j++ ) {
+                  WaveClip *clip2 = state.capturedClipArray[j].clip;
                   if (clip2 && clip2 != clip)
                      clip2->Offset(-safeBigDistance);
                }
 
-               if (track->CanOffsetClip(clip, mHSlideAmount, &allowed)) {
-                  if (mHSlideAmount != allowed) {
-                     mHSlideAmount = allowed;
-                     mSnapLeft = mSnapRight = -1; // see bug 1067
+               if ( track->CanOffsetClip(clip, state.hSlideAmount, &allowed) ) {
+                  if ( state.hSlideAmount != allowed ) {
+                     state.hSlideAmount = allowed;
+                     state.snapLeft = state.snapRight = -1; // see bug 1067
                   }
                }
                else {
-                  mHSlideAmount = 0.0;
-                  mSnapLeft = mSnapRight = -1; // see bug 1067
+                  state.hSlideAmount = 0.0;
+                  state.snapLeft = state.snapRight = -1; // see bug 1067
                }
 
-               for(j=0; j<mCapturedClipArray.size(); j++) {
-                  WaveClip *clip2 = mCapturedClipArray[j].clip;
+               for ( j = 0; j < state.capturedClipArray.size(); ++j ) {
+                  WaveClip *clip2 = state.capturedClipArray[j].clip;
                   if (clip2 && clip2 != clip)
                      clip2->Offset(safeBigDistance);
                }
             }
          }
-      } while (mHSlideAmount != initialAllowed);
+      } while ( state.hSlideAmount != initialAllowed );
 
-      if (mHSlideAmount != 0.0) { // finally, here is where clips are moved
+      if ( state.hSlideAmount != 0.0 ) { // finally, here is where clips are moved
          unsigned int i;
-         for(i=0; i<mCapturedClipArray.size(); i++) {
-            Track *track = mCapturedClipArray[i].track;
-            WaveClip *clip = mCapturedClipArray[i].clip;
+         for ( i = 0; i < state.capturedClipArray.size(); ++i ) {
+            Track *track = state.capturedClipArray[i].track;
+            WaveClip *clip = state.capturedClipArray[i].clip;
             if (clip)
-               clip->Offset(mHSlideAmount);
+               clip->Offset( state.hSlideAmount );
             else
-               track->Offset(mHSlideAmount);
+               track->Offset( state.hSlideAmount );
          }
       }
    }
    else {
       // For Shift key down, or
       // For non wavetracks, specifically label tracks ...
-      mCapturedTrack->Offset(mHSlideAmount);
-      Track* link = mCapturedTrack->GetLink();
+      capturedTrack.Offset( state.hSlideAmount );
+      Track* link = capturedTrack.GetLink();
       if (link)
-         link->Offset(mHSlideAmount);
+         link->Offset( state.hSlideAmount );
    }
 }
 
 void TrackPanel::OnClipMove(bool right)
 {
+   auto &viewInfo = *mViewInfo;
+   auto &state = mClipMoveState;
    auto track = GetFocusedTrack();
 
 
    // just dealing with clips in wave tracks for the moment. Note tracks??
    if (track && track->GetKind() == Track::Wave) {
       auto wt = static_cast<WaveTrack*>(track);
-      mCapturedClip = wt->GetClipAtTime(mViewInfo->selectedRegion.t0());
-      if (mCapturedClip == nullptr)
+      auto t0 = viewInfo.selectedRegion.t0();
+
+      state.capturedClip = wt->GetClipAtTime( t0 );
+      if (state.capturedClip == nullptr)
          return;
       
       mCapturedTrack = track;
-      mCapturedClipIsSelection = track->GetSelected() && !mViewInfo->selectedRegion.isPoint();
-      mTrackExclusions.clear();
+      state.capturedClipIsSelection =
+         track->GetSelected() && !viewInfo.selectedRegion.isPoint();
+      state.trackExclusions.clear();
 
-      auto t0 = mViewInfo->selectedRegion.t0();
       CreateListOfCapturedClips( t0 );
 
-      auto newT0 = mViewInfo->OffsetTimeByPixels( t0, ( right ? 1 : -1 ) );
+      auto newT0 = viewInfo.OffsetTimeByPixels( t0, ( right ? 1 : -1 ) );
       auto desiredSlideAmount = newT0 - t0;
 
       // set it to a sample point, and minimum of 1 sample point
@@ -4008,23 +4032,23 @@ void TrackPanel::OnClipMove(bool right)
       if (!right)
          desiredSlideAmount *= -1;
 
-      mHSlideAmount = desiredSlideAmount;
+      state.hSlideAmount = desiredSlideAmount;
       DoSlideHorizontal();
 
       // update t0 and t1. There is the possibility that the updated
       // t0 may no longer be within the clip due to rounding errors,
       // so t0 is adjusted so that it is.
-      if (newT0 < mCapturedClip->GetStartTime())
-         newT0 = mCapturedClip->GetStartTime();
-      if (newT0 > mCapturedClip->GetEndTime())
-         newT0 = mCapturedClip->GetEndTime();
-      double diff = mViewInfo->selectedRegion.duration();
-      mViewInfo->selectedRegion.setTimes(newT0, newT0 + diff);
+      if (newT0 < state.capturedClip->GetStartTime())
+         newT0 = state.capturedClip->GetStartTime();
+      if (newT0 > state.capturedClip->GetEndTime())
+         newT0 = state.capturedClip->GetEndTime();
+      double diff = viewInfo.selectedRegion.duration();
+      viewInfo.selectedRegion.setTimes(newT0, newT0 + diff);
 
-      ScrollIntoView(mViewInfo->selectedRegion.t0());
+      ScrollIntoView( newT0 );
       Refresh(false);
 
-      if (mHSlideAmount == 0.0)
+      if (state.hSlideAmount == 0.0)
          MessageForScreenReader( _("clip not moved"));
    }
 }
diff --git a/src/TrackPanel.h b/src/TrackPanel.h
index b3157c218..6a3eb11e3 100644
--- a/src/TrackPanel.h
+++ b/src/TrackPanel.h
@@ -155,6 +155,15 @@ private:
 const int DragThreshold = 3;// Anything over 3 pixels is a drag, else a click.
 
 
+struct ClipMoveState {
+   WaveClip *capturedClip {};
+   bool capturedClipIsSelection {};
+   TrackArray trackExclusions {};
+   double hSlideAmount {};
+   TrackClipArray capturedClipArray {};
+   wxInt64 snapLeft { -1 }, snapRight { -1 };
+};
+
 class AUDACITY_DLL_API TrackPanel final : public OverlayPanel {
  public:
 
@@ -658,10 +667,7 @@ protected:
 
    Track *mCapturedTrack;
    Envelope *mCapturedEnvelope;
-   WaveClip *mCapturedClip;
-   TrackClipArray mCapturedClipArray;
-   TrackArray mTrackExclusions;
-   bool mCapturedClipIsSelection;
+   ClipMoveState mClipMoveState;
    WaveTrackLocation mCapturedTrackLocation;
    wxRect mCapturedTrackLocationRect;
    wxRect mCapturedRect;
@@ -678,10 +684,6 @@ protected:
    wxBaseArrayDouble mSlideSnapToPoints;
    wxArrayInt mSlideSnapLinePixels;
 
-   // The amount that clips are sliding horizontally; this allows
-   // us to undo the slide and then slide it by another amount
-   double mHSlideAmount;
-
    bool mDidSlideVertically;
 
    bool mRedrawAfterStop;
@@ -707,8 +709,20 @@ protected:
    bool mSnapPreferRightEdge;
 
 public:
-   wxInt64 GetSnapLeft () const { return mSnapLeft ; }
-   wxInt64 GetSnapRight() const { return mSnapRight; }
+   wxInt64 GetSnapLeft () const
+   {
+      if ( mMouseCapture == IsSliding )
+         return mClipMoveState.snapLeft ;
+      else
+         return mSnapLeft ;
+   }
+   wxInt64 GetSnapRight() const
+   {
+      if ( mMouseCapture == IsSliding )
+         return mClipMoveState.snapRight;
+      else
+         return mSnapRight;
+   }
 
 protected: