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 ChannelGroupInterval;
class SnapManager;
class Track;
using TrackArray = std::vector<Track*>;
class TrackList;
 
class Track;
 
class ViewInfo;
class wxMouseState;
 
class AUDACITY_DLL_API TrackShifter {
public:
   TrackShifter();
   TrackShifter(const TrackShifter&) = delete;
   TrackShifter &operator=(const TrackShifter&) = delete;
 
   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<std::shared_ptr<ChannelGroupInterval>>;
 
   const Intervals &FixedIntervals() const { return mFixed; }
 
   const Intervals &MovingIntervals() const { return mMoving; }
   
   void UnfixIntervals(std::function<bool(const ChannelGroupInterval&)> pred);
 
   void UnfixAll();
 
 
   struct TimeInterval {
      TimeInterval(double start, double end)
         : mStart{ start }, mEnd{ std::max(start, end) }
      {}
      
      double Start() const { return mStart; }
      double End() const { return mEnd; }
   private:
      const double mStart;
      const double mEnd;
   };
 
 
   virtual void SelectInterval(TimeInterval 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(TimeInterval 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:
   const 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&) = delete;
   ClipMoveState& operator =(const ClipMoveState&) = delete;
 
   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 ChannelGroupInterval *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:
   TimeShiftHandle(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();
 
   std::shared_ptr<const Track> FindTrack() const override;
 
   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;
 
   std::shared_ptr<Track> GetTrack() const;
 
protected:
   //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, 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