TimeShiftHandle.h

Go to the documentation of this file.

/**********************************************************************
 
Audacity: A Digital Audio Editor
 
TimeShiftHandle.h
 
Paul Licameli
 
**********************************************************************/
 
#ifndef __AUDACITY_TIMESHIFT_HANDLE__
#define __AUDACITY_TIMESHIFT_HANDLE__
 
#include <functional>
#include <unordered_map>
#include <vector>
 
#include "AttachedVirtualFunction.h"
#include "../../UIHandle.h"
 
class SnapManager;
class Track;
using TrackArray = std::vector<Track*>;
class TrackList;
 
class Track;
class TrackInterval;
 
class ViewInfo;
class wxMouseState;
 
class AUDACITY_DLL_API TrackShifter {
public:
   TrackShifter();
   TrackShifter(const TrackShifter&) PROHIBITED;
   TrackShifter &operator=(const TrackShifter&) PROHIBITED;
 
   virtual ~TrackShifter() = 0;
   virtual Track &GetTrack() const = 0;
 
   enum class HitTestResult {
      Miss,      
      Selection, 
      Intervals, 
      Track      
   };
 
   struct HitTestParams {
      wxRect rect;
      wxCoord xx, yy;
   };
 
 
   virtual HitTestResult HitTest(
      double time, 
      const ViewInfo &viewInfo,
      HitTestParams *pParams = nullptr 
   ) = 0;
 
   using Intervals = std::vector<TrackInterval>;
 
   const Intervals &FixedIntervals() const { return mFixed; }
 
   const Intervals &MovingIntervals() const { return mMoving; }
   
   void UnfixIntervals(
      std::function< bool( const TrackInterval& ) > pred );
 
   void UnfixAll();
 
 
   virtual void SelectInterval( const TrackInterval &interval );
 
   virtual bool SyncLocks() = 0;
 
 
   virtual double HintOffsetLarger( double desiredOffset );
 
 
   virtual double QuantizeOffset( double desiredOffset );
 
 
   virtual double AdjustOffsetSmaller( double desiredOffset );
 
 
   virtual bool MayMigrateTo( Track &otherTrack );
 
 
   virtual Intervals Detach();
 
 
   virtual bool AdjustFit(
      const Track &otherTrack,
      const Intervals &intervals, 
      double &desiredOffset, 
      double tolerance 
   );
 
 
   virtual bool Attach( Intervals intervals, double offset );
 
 
   virtual bool FinishMigration();
 
   virtual void DoHorizontalOffset( double offset );
 
   // This function is used by the keyboard interface for time shifting.
   // It adjusts t0 after the move to take into account
   // any rounding errors if this is necessary.
   virtual double AdjustT0(double t0) const;
 
protected:
   void CommonSelectInterval( const TrackInterval &interval );
 
   bool CommonMayMigrateTo( Track &otherTrack );
 
 
   void InitIntervals();
 
   bool AllFixed() const {
      return mAllFixed && mMoving.empty();
   }
 
   Intervals mFixed;
   Intervals mMoving;
 
private:
   bool mAllFixed = true; 
};
 
class CoarseTrackShifter final : public TrackShifter {
public:
   CoarseTrackShifter( Track &track );
   ~CoarseTrackShifter() override;
   Track &GetTrack() const override { return *mpTrack; }
 
   HitTestResult HitTest( double, const ViewInfo&, HitTestParams* ) override;
 
   bool SyncLocks() override;
 
private:
   std::shared_ptr<Track> mpTrack;
};
 
struct MakeTrackShifterTag;
using MakeTrackShifter = AttachedVirtualFunction<
   MakeTrackShifterTag, std::unique_ptr<TrackShifter>, Track, AudacityProject&>;
DECLARE_EXPORTED_ATTACHED_VIRTUAL(AUDACITY_DLL_API, MakeTrackShifter);
 
class ViewInfo;
 
struct AUDACITY_DLL_API ClipMoveState {
   ClipMoveState() = default;
 
   ClipMoveState(const ClipMoveState&) PROHIBITED;
   ClipMoveState& operator =(const ClipMoveState&) PROHIBITED;
 
   ClipMoveState(ClipMoveState&&) = default;
   ClipMoveState& operator =(ClipMoveState&&) = default;
 
   using ShifterMap = std::unordered_map<Track*, std::unique_ptr<TrackShifter>>;
   
   void Init(
      AudacityProject &project,
      Track &capturedTrack, //<! pHit if not null associates with this track
      TrackShifter::HitTestResult hitTestResult, 
      std::unique_ptr<TrackShifter> pHit, 
      double clickTime,
      const ViewInfo &viewInfo,
      TrackList &trackList, bool syncLocked );
 
 
   const TrackInterval *CapturedInterval() const;
 
 
   double DoSlideHorizontal( double desiredSlideAmount );
 
   void DoHorizontalOffset( double offset );
 
   std::shared_ptr<Track> mCapturedTrack;
 
   bool initialized{ false };
   bool movingSelection {};
   bool wasMoved{ false };
   double hSlideAmount {};
   ShifterMap shifters;
   wxInt64 snapLeft { -1 }, snapRight { -1 };
 
   int mMouseClickX{};
 
   void clear()
   {
      initialized = false;
      wasMoved = false;
      movingSelection = false;
      hSlideAmount = 0;
      shifters.clear();
      snapLeft = snapRight = -1;
      mMouseClickX = 0;
   }
};
 
class AUDACITY_DLL_API TimeShiftHandle : public UIHandle
{
   TimeShiftHandle(const TimeShiftHandle&) = delete;
   static HitTestPreview HitPreview
      (const AudacityProject *pProject, bool unsafe);
 
public:
   explicit TimeShiftHandle
   ( const std::shared_ptr<Track> &pTrack, bool gripHit );
 
   TimeShiftHandle &operator=(TimeShiftHandle&&) = default;
 
   bool IsGripHit() const { return mGripHit; }
 
   static UIHandlePtr HitAnywhere
      (std::weak_ptr<TimeShiftHandle> &holder,
       const std::shared_ptr<Track> &pTrack, bool gripHit);
   static UIHandlePtr HitTest
      (std::weak_ptr<TimeShiftHandle> &holder,
       const wxMouseState &state, const wxRect &rect,
       const std::shared_ptr<Track> &pTrack);
 
   virtual ~TimeShiftHandle();
 
   void Enter(bool forward, AudacityProject *) override;
 
   Result Click
      (const TrackPanelMouseEvent &event, AudacityProject *pProject) override;
 
   Result Drag
      (const TrackPanelMouseEvent &event, AudacityProject *pProject) override;
 
   HitTestPreview Preview
      (const TrackPanelMouseState &state, AudacityProject *pProject)
      override;
 
   Result Release
      (const TrackPanelMouseEvent &event, AudacityProject *pProject,
       wxWindow *pParent) override;
 
   Result Cancel(AudacityProject *pProject) override;
 
   bool StopsOnKeystroke() override { return true; }
 
   bool Clicked() const;
 
protected:
   std::shared_ptr<Track> GetTrack() const;
   //There were attempt to move clip/track horizontally, or to move it vertically
   bool WasMoved() const;
private:
 
   // Try to move clips from one track to another with offset, allowing 1px tolerance,
   // that will move intervals and reset the origin
   void DoSlideVertical(
      ViewInfo &viewInfo, wxCoord xx,
      TrackList &trackList,
      const std::shared_ptr<Track>& dstTrack, double& desiredSlideAmount );
 
   // TrackPanelDrawable implementation
   void Draw(
      TrackPanelDrawingContext &context,
      const wxRect &rect, unsigned iPass ) override;
 
   wxRect DrawingArea(
      TrackPanelDrawingContext &,
      const wxRect &rect, const wxRect &panelRect, unsigned iPass ) override;
 
   wxRect mRect{};
 
   bool mDidSlideVertically{};
   bool mSlideUpDownOnly{};
 
   bool mSnapPreferRightEdge{};
 
   // Handles snapping the selection boundaries or track boundaries to
   // line up with existing tracks or labels.  mSnapLeft and mSnapRight
   // are the horizontal index of pixels to display user feedback
   // guidelines so the user knows when such snapping is taking place.
   std::shared_ptr<SnapManager> mSnapManager{};
 
   ClipMoveState mClipMoveState{};
   bool mGripHit {};
};
 
#endif