TrackPanelResizeHandle Class Reference

#include <TrackPanelResizeHandle.h>

Inheritance diagram for TrackPanelResizeHandle:

Collaboration diagram for TrackPanelResizeHandle:

Public Member Functions
	TrackPanelResizeHandle (const std::shared_ptr< Track > &pTrack, int y)
TrackPanelResizeHandle &	operator= (const TrackPanelResizeHandle &)=default
virtual	~TrackPanelResizeHandle ()
std::shared_ptr< Track >	GetTrack () const
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
Public Member Functions inherited from UIHandle
virtual	~UIHandle ()=0
virtual void	Enter (bool forward, AudacityProject *pProject)
virtual bool	HasRotation () const
virtual bool	Rotate (bool forward)
virtual bool	HasEscape (AudacityProject *pProject) const
virtual bool	Escape (AudacityProject *pProject)
virtual bool	HandlesRightClick ()
	Whether the handle has any special right-button handling. More...
virtual Result	Click (const TrackPanelMouseEvent &event, AudacityProject *pProject)=0
virtual Result	Drag (const TrackPanelMouseEvent &event, AudacityProject *pProject)=0
virtual HitTestPreview	Preview (const TrackPanelMouseState &state, AudacityProject *pProject)=0
virtual Result	Release (const TrackPanelMouseEvent &event, AudacityProject *pProject, wxWindow *pParent)=0
virtual Result	Cancel (AudacityProject *pProject)=0
virtual bool	StopsOnKeystroke ()
virtual void	OnProjectChange (AudacityProject *pProject)
Result	GetChangeHighlight () const
void	SetChangeHighlight (Result val)
Public Member Functions inherited from TrackPanelDrawable
virtual	~TrackPanelDrawable ()=0
virtual void	Draw (TrackPanelDrawingContext &context, const wxRect &rect, unsigned iPass)
virtual wxRect	DrawingArea (TrackPanelDrawingContext &context, const wxRect &rect, const wxRect &panelRect, unsigned iPass)

Static Public Member Functions
static HitTestPreview	HitPreview (bool bLinked)
Static Public Member Functions inherited from UIHandle
static UIHandle::Result	NeedChangeHighlight (const UIHandle &, const UIHandle &)
Static Public Member Functions inherited from TrackPanelDrawable
static wxRect	MaximizeWidth (const wxRect &rect, const wxRect &panelRect)
static wxRect	MaximizeHeight (const wxRect &rect, const wxRect &panelRect)

Private Types
enum	Mode { IsResizing , IsResizingBetweenLinkedTracks , IsResizingBelowLinkedTracks }

Private Member Functions
	TrackPanelResizeHandle (const TrackPanelResizeHandle &)=delete

Private Attributes
Mode	mMode { IsResizing }
std::weak_ptr< Track >	mpTrack
bool	mInitialMinimized {}
int	mInitialTrackHeight {}
int	mInitialExpandedHeight {}
int	mInitialUpperTrackHeight {}
int	mInitialUpperExpandedHeight {}
int	mMouseClickY {}

Additional Inherited Members
Public Types inherited from UIHandle
using	Result = unsigned
using	Cell = TrackPanelCell
Protected Attributes inherited from UIHandle
Result	mChangeHighlight { 0 }

Detailed Description

Definition at line 18 of file TrackPanelResizeHandle.h.

Member Enumeration Documentation

Mode

enum TrackPanelResizeHandle::Mode

private

Enumerator
IsResizing
IsResizingBetweenLinkedTracks
IsResizingBelowLinkedTracks

Definition at line 50 of file TrackPanelResizeHandle.h.

             {
      IsResizing,
      IsResizingBetweenLinkedTracks,
      IsResizingBelowLinkedTracks,
   };

Constructor & Destructor Documentation

TrackPanelResizeHandle() [1/2]

TrackPanelResizeHandle::TrackPanelResizeHandle ( const TrackPanelResizeHandle &  )

privatedelete

TrackPanelResizeHandle() [2/2]

TrackPanelResizeHandle::TrackPanelResizeHandle ( const std::shared_ptr< Track > &  pTrack, int  y  )

explicit

Definition at line 84 of file TrackPanelResizeHandle.cpp.

   : mpTrack{ track }
   , mMouseClickY( y )
{
   // TODO: more-than-two-channels
 
   //STM:  Determine whether we should rescale one or two tracks
   auto channels = TrackList::Channels(track.get());
   auto last = *channels.rbegin();
   auto &lastView = TrackView::Get( *last );
   mInitialTrackHeight = lastView.GetHeight();
   mInitialExpandedHeight = lastView.GetExpandedHeight();
   mInitialMinimized = lastView.GetMinimized();
 
   if (channels.size() > 1) {
      auto first = *channels.begin();
      auto &firstView = TrackView::Get( *first );
 
      mInitialUpperTrackHeight = firstView.GetHeight();
      mInitialUpperExpandedHeight = firstView.GetExpandedHeight();
 
      if (track.get() == *channels.rbegin())
         // capturedTrack is the lowest track
         mMode = IsResizingBelowLinkedTracks;
      else
         // capturedTrack is not the lowest track
         mMode = IsResizingBetweenLinkedTracks;
   }
   else
      mMode = IsResizing;
}

References TrackList::Channels(), TrackView::Get(), IsResizing, IsResizingBelowLinkedTracks, IsResizingBetweenLinkedTracks, mInitialExpandedHeight, mInitialMinimized, mInitialTrackHeight, mInitialUpperExpandedHeight, mInitialUpperTrackHeight, and mMode.

Here is the call graph for this function:

~TrackPanelResizeHandle()

TrackPanelResizeHandle::~TrackPanelResizeHandle ( )

virtual

Definition at line 52 of file TrackPanelResizeHandle.cpp.

{
}

Member Function Documentation

Cancel()

UIHandle::Result TrackPanelResizeHandle::Cancel ( AudacityProject *  pProject )

overridevirtual

Implements UIHandle.

Definition at line 260 of file TrackPanelResizeHandle.cpp.

{
   auto &tracks = TrackList::Get( *pProject );
   auto pTrack = tracks.Lock(mpTrack);
   if ( !pTrack )
      return RefreshCode::Cancelled;
 
 
   switch (mMode) {
   case IsResizing:
   {
      auto &view = TrackView::Get( *pTrack );
      view.SetExpandedHeight(mInitialExpandedHeight);
      view.SetMinimized( mInitialMinimized );
   }
   break;
   case IsResizingBetweenLinkedTracks:
   {
      Track *const next = * ++ tracks.Find(pTrack.get());
      auto
         &view = TrackView::Get( *pTrack ), &nextView = TrackView::Get( *next );
      view.SetExpandedHeight(mInitialUpperExpandedHeight);
      view.SetMinimized( mInitialMinimized );
      nextView.SetExpandedHeight(mInitialExpandedHeight);
      nextView.SetMinimized( mInitialMinimized );
   }
   break;
   case IsResizingBelowLinkedTracks:
   {
      Track *const prev = * -- tracks.Find(pTrack.get());
      auto
         &view = TrackView::Get( *pTrack ), &prevView = TrackView::Get( *prev );
      view.SetExpandedHeight(mInitialExpandedHeight);
      view.SetMinimized( mInitialMinimized );
      prevView.SetExpandedHeight(mInitialUpperExpandedHeight);
      prevView.SetMinimized(mInitialMinimized);
   }
   break;
   }
 
   return RefreshCode::RefreshAll;
}

References RefreshCode::Cancelled, ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Find(), TrackList::Get(), TrackView::Get(), IsResizing, IsResizingBelowLinkedTracks, IsResizingBetweenLinkedTracks, mInitialExpandedHeight, mInitialMinimized, mInitialUpperExpandedHeight, mMode, mpTrack, and RefreshCode::RefreshAll.

Here is the call graph for this function:

Click()

UIHandle::Result TrackPanelResizeHandle::Click ( const TrackPanelMouseEvent &  event, AudacityProject *  pProject  )

overridevirtual

Implements UIHandle.

Definition at line 56 of file TrackPanelResizeHandle.cpp.

{
   using namespace RefreshCode;
   if ( evt.event.LeftDClick() && mMode == IsResizingBetweenLinkedTracks ) {
      auto &tracks = TrackList::Get( *pProject );
      auto pTrack = tracks.Lock(mpTrack);
      if (pTrack &&
          !TrackView::Get(*pTrack).GetMinimized()) {
         auto range = TrackList::Channels( pTrack.get() );
         auto size = range.size();
         auto height = range.sum( [](const Track *pTrack){
            return TrackView::Get(*pTrack).GetHeight(); } );
         int ii = 1;
         int coord = 0;
         for ( const auto channel : range ) {
            int newCoord = ((double)ii++ /size) * height;
            TrackView::Get(*channel).SetExpandedHeight( newCoord - coord );
            coord = newCoord;
         }
         ProjectHistory::Get( *pProject ).ModifyState(false);
         // Do not start a drag
         return Cancelled | RefreshAll;
      }
   }
   return RefreshNone;
}

References RefreshCode::Cancelled, TrackList::Channels(), TrackPanelMouseEvent::event, ProjectHistory::Get(), TrackList::Get(), TrackView::Get(), TrackView::GetHeight(), TrackView::GetMinimized(), IsResizingBetweenLinkedTracks, mMode, ProjectHistory::ModifyState(), mpTrack, RefreshCode::RefreshAll, RefreshCode::RefreshNone, TrackView::SetExpandedHeight(), and size.

Here is the call graph for this function:

Drag()

UIHandle::Result TrackPanelResizeHandle::Drag ( const TrackPanelMouseEvent &  event, AudacityProject *  pProject  )

overridevirtual

Implements UIHandle.

Definition at line 117 of file TrackPanelResizeHandle.cpp.

{
   auto &tracks = TrackList::Get( *pProject );
   auto pTrack = tracks.Lock(mpTrack);
   if ( !pTrack )
      return RefreshCode::Cancelled;
 
   auto &view = TrackView::Get( *pTrack );
 
   const wxMouseEvent &event = evt.event;
 
   int delta = (event.m_y - mMouseClickY);
 
   // On first drag, jump out of minimized mode.  Initial height
   // will be height of minimized track.
   //
   // This used to be in HandleResizeClick(), but simply clicking
   // on a resize border would switch the minimized state.
   auto &data = TrackView::Get( *pTrack );
   if (data.GetMinimized()) {
      auto channels = TrackList::Channels( pTrack.get() );
      for (auto channel : channels) {
         auto &channelView = TrackView::Get( *channel );
         channelView.SetExpandedHeight(channelView.GetHeight());
         channelView.SetMinimized( false );
      }
 
      if (channels.size() > 1) {
         // Initial values must be reset since they weren't based on the
         // minimized heights.
         auto &channelView = TrackView::Get( **channels.begin() );
         mInitialUpperTrackHeight = channelView.GetHeight();
         mInitialTrackHeight = channelView.GetHeight();
      }
   }
 
   // Common pieces of code for MONO_WAVE_PAN and otherwise.
   auto doResizeBelow = [&] (Track *prev, bool WXUNUSED(vStereo)) {
      // TODO: more-than-two-channels
      
      auto &prevView = TrackView::Get( *prev );
 
      double proportion = static_cast < double >(mInitialTrackHeight)
      / (mInitialTrackHeight + mInitialUpperTrackHeight);
 
      int newTrackHeight = static_cast < int >
      (mInitialTrackHeight + delta * proportion);
 
      int newUpperTrackHeight = static_cast < int >
      (mInitialUpperTrackHeight + delta * (1.0 - proportion));
 
      //make sure neither track is smaller than its minimum height
      if (newTrackHeight < view.GetMinimizedHeight())
         newTrackHeight = view.GetMinimizedHeight();
      if (newUpperTrackHeight < prevView.GetMinimizedHeight())
         newUpperTrackHeight = prevView.GetMinimizedHeight();
 
      view.SetExpandedHeight(newTrackHeight);
      prevView.SetExpandedHeight(newUpperTrackHeight);
   };
 
   auto doResizeBetween = [&] (Track *next, bool WXUNUSED(vStereo)) {
      // TODO: more-than-two-channels
 
      auto &nextView = TrackView::Get( *next );
      int newUpperTrackHeight = mInitialUpperTrackHeight + delta;
      int newTrackHeight = mInitialTrackHeight - delta;
 
      // make sure neither track is smaller than its minimum height
      if (newTrackHeight < nextView.GetMinimizedHeight()) {
         newTrackHeight = nextView.GetMinimizedHeight();
         newUpperTrackHeight =
         mInitialUpperTrackHeight + mInitialTrackHeight - nextView.GetMinimizedHeight();
      }
      if (newUpperTrackHeight < view.GetMinimizedHeight()) {
         newUpperTrackHeight = view.GetMinimizedHeight();
         newTrackHeight =
         mInitialUpperTrackHeight + mInitialTrackHeight - view.GetMinimizedHeight();
      }
 
      view.SetExpandedHeight(newUpperTrackHeight);
      nextView.SetExpandedHeight(newTrackHeight);
   };
 
   auto doResize = [&] {
      int newTrackHeight = mInitialTrackHeight + delta;
      if (newTrackHeight < view.GetMinimizedHeight())
         newTrackHeight = view.GetMinimizedHeight();
      view.SetExpandedHeight(newTrackHeight);
   };
 
   //STM: We may be dragging one or two (stereo) tracks.
   // If two, resize proportionally if we are dragging the lower track, and
   // adjust compensatively if we are dragging the upper track.
 
   switch( mMode )
   {
      case IsResizingBelowLinkedTracks:
      {
         auto prev = * -- tracks.Find(pTrack.get());
         doResizeBelow(prev, false);
         break;
      }
      case IsResizingBetweenLinkedTracks:
      {
         auto next = * ++ tracks.Find(pTrack.get());
         doResizeBetween(next, false);
         break;
      }
      case IsResizing:
      {
         doResize();
         break;
      }
      default:
         // don't refresh in this case.
         return RefreshCode::RefreshNone;
   }
 
   return RefreshCode::RefreshAll;
}

References RefreshCode::Cancelled, TrackList::Channels(), TrackPanelMouseEvent::event, ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Find(), TrackList::Get(), TrackView::Get(), IsResizing, IsResizingBelowLinkedTracks, IsResizingBetweenLinkedTracks, mInitialTrackHeight, mInitialUpperTrackHeight, mMode, mMouseClickY, mpTrack, RefreshCode::RefreshAll, and RefreshCode::RefreshNone.

Here is the call graph for this function:

GetTrack()

std::shared_ptr< Track > TrackPanelResizeHandle::GetTrack ( ) const

inline

Definition at line 31 of file TrackPanelResizeHandle.h.

{ return mpTrack.lock(); }

References mpTrack.

HitPreview()

HitTestPreview TrackPanelResizeHandle::HitPreview ( bool  bLinked )

static

When in the resize area we can adjust size or relative size.

Definition at line 25 of file TrackPanelResizeHandle.cpp.

{
   // TODO: more-than-two-channels-message
 
   static wxCursor resizeCursor{ wxCURSOR_SIZENS };
 
   // Check to see whether it is the first channel of a stereo track
   if (bLinked) {
      // If we are in the label we got here 'by mistake' and we're
      // not actually in the resize area at all.  (The resize area
      // is shorter when it is between stereo tracks).
 
      return {
         XO(
"Click and drag to adjust relative size of stereo tracks, double-click to make heights equal"),
         &resizeCursor
      };
   }
   else {
      return {
         XO("Click and drag to resize the track."),
         &resizeCursor
      };
   }
}

References XO().

Referenced by Preview().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

TrackPanelResizeHandle & TrackPanelResizeHandle::operator= ( const TrackPanelResizeHandle &  )

default

Preview()

HitTestPreview TrackPanelResizeHandle::Preview ( const TrackPanelMouseState &  state, AudacityProject *  pProject  )

overridevirtual

Implements UIHandle.

Definition at line 240 of file TrackPanelResizeHandle.cpp.

{
   return HitPreview(mMode == IsResizingBetweenLinkedTracks);
}

References HitPreview(), IsResizingBetweenLinkedTracks, and mMode.

Here is the call graph for this function:

Release()

UIHandle::Result TrackPanelResizeHandle::Release ( const TrackPanelMouseEvent &  event, AudacityProject *  pProject, wxWindow *  pParent  )

overridevirtual

This happens when the button is released from a drag. Since we actually took care of resizing the track when we got drag events, all we have to do here is clean up. We also modify the undo state (the action doesn't become undo-able, but it gets merged with the previous undo-able event).

Implements UIHandle.

Definition at line 246 of file TrackPanelResizeHandle.cpp.

{
   ProjectHistory::Get( *pProject ).ModifyState(false);
   return RefreshCode::FixScrollbars;
}

References RefreshCode::FixScrollbars, ProjectHistory::Get(), and ProjectHistory::ModifyState().

Here is the call graph for this function:

Member Data Documentation

mInitialExpandedHeight

int TrackPanelResizeHandle::mInitialExpandedHeight {}

private

Definition at line 61 of file TrackPanelResizeHandle.h.

Referenced by Cancel(), and TrackPanelResizeHandle().

mInitialMinimized

bool TrackPanelResizeHandle::mInitialMinimized {}

private

Definition at line 59 of file TrackPanelResizeHandle.h.

Referenced by Cancel(), and TrackPanelResizeHandle().

mInitialTrackHeight

int TrackPanelResizeHandle::mInitialTrackHeight {}

private

Definition at line 60 of file TrackPanelResizeHandle.h.

Referenced by Drag(), and TrackPanelResizeHandle().

mInitialUpperExpandedHeight

int TrackPanelResizeHandle::mInitialUpperExpandedHeight {}

private

Definition at line 63 of file TrackPanelResizeHandle.h.

Referenced by Cancel(), and TrackPanelResizeHandle().

mInitialUpperTrackHeight

int TrackPanelResizeHandle::mInitialUpperTrackHeight {}

private

Definition at line 62 of file TrackPanelResizeHandle.h.

Referenced by Drag(), and TrackPanelResizeHandle().

mMode

Mode TrackPanelResizeHandle::mMode { IsResizing }

private

Definition at line 55 of file TrackPanelResizeHandle.h.

Referenced by Cancel(), Click(), Drag(), Preview(), and TrackPanelResizeHandle().

mMouseClickY

int TrackPanelResizeHandle::mMouseClickY {}

private

Definition at line 65 of file TrackPanelResizeHandle.h.

Referenced by Drag().

mpTrack

std::weak_ptr<Track> TrackPanelResizeHandle::mpTrack

private

Definition at line 57 of file TrackPanelResizeHandle.h.

Referenced by Cancel(), Click(), Drag(), and GetTrack().

---

The documentation for this class was generated from the following files:

• TrackPanelResizeHandle.h
• TrackPanelResizeHandle.cpp