Collaboration diagram for SubViewAdjuster:

[legend]

Public Types
enum	{ HotZoneSize = 5 }

Public Member Functions
	SubViewAdjuster (WaveTrackView &view)

void	FindPermutation ()

size_t	NVisible () const

bool	ModifyPermutation (bool top)

size_t	FindIndex (WaveTrackSubView &subView) const

std::pair< size_t, bool >	HitTest (WaveTrackSubView &subView, wxCoord yy, wxCoord top, wxCoord height)

std::vector< wxCoord >	ComputeHeights (wxCoord totalHeight)

void	UpdateViews (bool rollback)

Public Attributes
std::weak_ptr< WaveTrackView >	mwView

WaveTrackSubViewPtrs	mSubViews

WaveTrackSubViewPlacements	mOrigPlacements

WaveTrackSubViewPlacements	mNewPlacements

std::vector< size_t >	mPermutation

size_t	mFirstSubView {}

Detailed Description

Definition at line 107 of file WaveTrackView.cpp.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
HotZoneSize

Definition at line 109 of file WaveTrackView.cpp.

109{ HotZoneSize = 5 }; // so many pixels at top and bottom of each subview

SubViewAdjuster::HotZoneSize

@ HotZoneSize

Definition: WaveTrackView.cpp:109

Constructor & Destructor Documentation

◆ SubViewAdjuster()

SubViewAdjuster::SubViewAdjuster ( WaveTrackView & view )

inline

Definition at line 111 of file WaveTrackView.cpp.

      : mwView{
         std::static_pointer_cast<WaveTrackView>( view.shared_from_this() ) }
   {
      mSubViews = view.GetAllSubViews();
      mOrigPlacements = mNewPlacements = view.SavePlacements();
      FindPermutation();
   }

References FindPermutation(), WaveTrackView::GetAllSubViews(), mNewPlacements, mOrigPlacements, mSubViews, and WaveTrackView::SavePlacements().

Here is the call graph for this function:

Member Function Documentation

◆ ComputeHeights()

std::vector< wxCoord > SubViewAdjuster::ComputeHeights ( wxCoord totalHeight )

inline

Definition at line 224 of file WaveTrackView.cpp.

   {
      // Compute integer-valued heights
      float total = 0;
      for (const auto index : mPermutation ) {
         const auto &placement = mOrigPlacements[ index ];
         total += std::max( 0.f, placement.fraction );
      }
      float partial = 0;
      wxCoord lastCoord = 0;
      std::vector<wxCoord> result;
      for (const auto index : mPermutation ) {
         const auto &placement = mOrigPlacements[ index ];
         auto fraction = std::max( 0.f, placement.fraction );
         wxCoord coord = ( (partial + fraction ) / total ) * totalHeight;
         auto height = coord - lastCoord;
         result.emplace_back( height );
         mNewPlacements[ index ].fraction = height;
         lastCoord = coord;
         partial += fraction;
      }
      return result;
   }

References mNewPlacements, mOrigPlacements, and mPermutation.

Referenced by SubViewAdjustHandle::Click(), and SubViewRearrangeHandle::Click().

Here is the caller graph for this function:

◆ FindIndex()

size_t SubViewAdjuster::FindIndex ( WaveTrackSubView & subView ) const

inline

Definition at line 196 of file WaveTrackView.cpp.

   {
      const auto begin = mPermutation.begin(), end = mPermutation.end();
      auto iter = std::find_if( begin, end, [&](size_t ii){
         return mSubViews[ ii ].get() == &subView;
      } );
      return iter - begin;
   }

References PackedArray::begin(), PackedArray::end(), mPermutation, and mSubViews.

Referenced by HitTest().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindPermutation()

void SubViewAdjuster::FindPermutation ( )

inline

Definition at line 120 of file WaveTrackView.cpp.

   {
      // Find a certain sort of the sub-views
      auto size = mOrigPlacements.size();
      wxASSERT( mSubViews.size() == size );
      mPermutation.resize( size );
      const auto begin = mPermutation.begin(), end = mPermutation.end();
      std::iota( begin, end, 0 );
      static auto invisible = []( const WaveTrackSubViewPlacement &placement ){
         return placement.index < 0 || placement.fraction <= 0;
      };
      const auto comp = [this]( size_t ii, size_t jj ){
         auto &pi = mOrigPlacements[ii];
         bool iInvisible = invisible( pi );
 
         auto &pj = mOrigPlacements[jj];
         bool jInvisible = invisible( pj );
 
         // Sort the invisibles to the front, rest by index
         if ( iInvisible != jInvisible )
            return iInvisible;
         else if ( !iInvisible )
            return pi.index < pj.index;
         else
            // Minor sort among the invisible views by their type
            return mSubViews[ii]->SubViewType() < mSubViews[jj]->SubViewType();
      };
      std::sort( begin, end, comp );
      // Find the start of visible sub-views
      auto first = std::find_if( begin, end, [this](size_t ii){
         return !invisible( mOrigPlacements[ii] );
      } );
      mFirstSubView = first - begin;
   }

References PackedArray::begin(), PackedArray::end(), mFirstSubView, mOrigPlacements, mPermutation, mSubViews, and size.

Referenced by SubViewAdjuster().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HitTest()

std::pair< size_t, bool > SubViewAdjuster::HitTest	(	WaveTrackSubView &	subView,
		wxCoord	yy,
		wxCoord	top,
		wxCoord	height
	)

inline

Definition at line 206 of file WaveTrackView.cpp.

   {
      const auto index = FindIndex( subView );
      auto size = mPermutation.size();
      if ( index < (int)size ) {
         yy -= top;
         if ( yy >= 0 && yy < HotZoneSize && index > 0 )
            return { index, true }; // top hit
         if ( yy < height && yy >= height - HotZoneSize &&
            // Have not yet called ModifyPermutation; dragging bottom of
            // bottommost view allowed only if at least one view is invisible
            ( index < (int)size - 1 || mFirstSubView > 0 ) )
            return { index, false }; // bottom hit
      }
      return { size, false }; // not hit
   }

References FindIndex(), HotZoneSize, mFirstSubView, mPermutation, and size.

Here is the call graph for this function:

◆ ModifyPermutation()

bool SubViewAdjuster::ModifyPermutation ( bool top )

inline

Definition at line 158 of file WaveTrackView.cpp.

   {
      bool rotated = false;
      const auto pBegin = mPermutation.begin(), pEnd = mPermutation.end();
      auto pFirst = pBegin + mFirstSubView;
      if ( mFirstSubView > 0 ) {
         // In case of dragging the top edge of the topmost view, or the
         // bottom edge of the bottommost, decide which of the invisible
         // views can become visible, and reassign the sequence.
         // For definiteness, that choice depends on the subview type numbers;
         // see the sorting criteria above.
         --mFirstSubView;
         --pFirst;
         if ( top ) {
            // If you drag down the top, the greatest-numbered invisible
            // subview type will appear there.
            mNewPlacements[ *pFirst ].fraction = 0;
         }
         else {
            // If you drag up the bottom, let the least-numbered invisible
            // subview type appear there.
            mNewPlacements[ *pBegin ].fraction = 0;
            std::rotate( pBegin, pBegin + 1, pEnd );
            rotated = true;
         }
      }
      // Reassign index numbers to all sub-views and 0 fraction to invisibles
      for ( auto pIter = pBegin; pIter != pFirst; ++pIter ) {
         auto &placement = mNewPlacements[ *pIter ];
         placement.index = -1;
         placement.fraction = 0;
      }
      size_t index = 0;
      for ( auto pIter = pFirst; pIter != pEnd; ++pIter )
         mNewPlacements[ *pIter ].index = index++;
      return rotated;
   }

References mFirstSubView, mNewPlacements, and mPermutation.

Referenced by SubViewAdjustHandle::SubViewAdjustHandle().

Here is the caller graph for this function:

◆ NVisible()

size_t SubViewAdjuster::NVisible ( ) const

inline

Definition at line 155 of file WaveTrackView.cpp.

156 { return mPermutation.size() - mFirstSubView; }

References mFirstSubView, and mPermutation.

◆ UpdateViews()

void SubViewAdjuster::UpdateViews ( bool rollback )

inline

Definition at line 248 of file WaveTrackView.cpp.

   {
      auto pView = mwView.lock();
      if ( pView ) {
         auto pTrack = static_cast< WaveTrack* >( pView->FindTrack().get() );
         WaveTrackView::Get(*pTrack).RestorePlacements(
            rollback ? mOrigPlacements : mNewPlacements);
      }
   }