SelectionState Class Reference

#include <SelectionState.h>

Inheritance diagram for SelectionState:

Collaboration diagram for SelectionState:

Public Member Functions
	SelectionState ()=default
	SelectionState (const SelectionState &)=delete
SelectionState &	operator= (const SelectionState &)=delete
void	SelectTrack (Track &track, bool selected, bool updateLastPicked)
void	SelectRangeOfTracks (TrackList &tracks, Track &sTrack, Track &eTrack)
void	SelectNone (TrackList &tracks)
void	ChangeSelectionOnShiftClick (TrackList &tracks, Track &track)
void	HandleListSelection (TrackList &tracks, ViewInfo &viewInfo, Track &track, bool shift, bool ctrl, bool syncLocked)
Public Member Functions inherited from ClientData::Base
virtual	~Base ()

Static Public Member Functions
static SelectionState &	Get (AudacityProject &project)
static const SelectionState &	Get (const AudacityProject &project)
static void	SelectTrackLength (ViewInfo &viewInfo, Track &track, bool syncLocked)

Private Attributes
std::weak_ptr< Track >	mLastPickedTrack

Friends
class	SelectionStateChanger

Detailed Description

Definition at line 21 of file SelectionState.h.

Constructor & Destructor Documentation

SelectionState() [1/2]

SelectionState::SelectionState ( )

default

SelectionState() [2/2]

SelectionState::SelectionState ( const SelectionState &  )

delete

Member Function Documentation

ChangeSelectionOnShiftClick()

void SelectionState::ChangeSelectionOnShiftClick	(	TrackList &	tracks,
		Track &	track
	)

Definition at line 107 of file SelectionState.cpp.

{
   // We will either extend from the first or from the last.
   auto pExtendFrom = tracks.Lock(mLastPickedTrack);
 
   if (!pExtendFrom) {
      auto trackRange = tracks.Selected();
      auto pFirst = *trackRange.begin();
 
      // If our track is at or after the first, extend from the first.
      if (pFirst) {
         auto begin = tracks.begin(),
            iterT = tracks.Find(&track),
            iterF = tracks.Find(pFirst);
         auto indT = std::distance(begin, iterT),
            indF = std::distance(begin, iterF);
         if (indT >= indF)
            pExtendFrom = pFirst->SharedPointer();
      }
 
      // Our track was earlier than the first.  Extend from the last.
      if (!pExtendFrom)
         pExtendFrom = Track::SharedPointer(*trackRange.rbegin());
   }
   // Either it's null, or mLastPickedTrack, or the first or last of
   // Selected()
   assert(!pExtendFrom || pExtendFrom->IsLeader());
 
   SelectNone(tracks);
   if (pExtendFrom)
      SelectRangeOfTracks(tracks, track, *pExtendFrom);
   else
      SelectTrack(track, true, true);
   mLastPickedTrack = pExtendFrom;
}

References PackedArray::begin(), mLastPickedTrack, SelectNone(), SelectRangeOfTracks(), SelectTrack(), Track::SharedPointer(), and tracks.

Referenced by HandleListSelection().

Here is the call graph for this function:

Here is the caller graph for this function:

Get() [1/2]

SelectionState & SelectionState::Get ( AudacityProject &  project )

static

Definition at line 22 of file SelectionState.cpp.

{
   return project.AttachedObjects::Get< SelectionState >( key );
}

References key, and project.

Referenced by LabelGlyphHandle::Click(), SelectHandle::Click(), BackgroundHandle::Click(), ExportAudioDialog::DoExportSplitByTracks(), SelectUtilities::DoListSelection(), anonymous_namespace{NavigationMenus.cpp}::DoNextTrack(), anonymous_namespace{NavigationMenus.cpp}::DoPrevTrack(), SelectHandle::Drag(), Get(), LabelGlyphHandle::HandleGlyphDragRelease(), NavigationActions::Handler::OnToggle(), and AffordanceHandle::Release().

Here is the caller graph for this function:

Get() [2/2]

const SelectionState & SelectionState::Get ( const AudacityProject &  project )

static

Definition at line 27 of file SelectionState.cpp.

{
   return Get( const_cast< AudacityProject & >( project ) );
}

References Get(), and project.

Here is the call graph for this function:

HandleListSelection()

void SelectionState::HandleListSelection	(	TrackList &	tracks,
		ViewInfo &	viewInfo,
		Track &	track,
		bool	shift,
		bool	ctrl,
		bool	syncLocked
	)

Precondition

track.IsLeader()

Definition at line 144 of file SelectionState.cpp.

{
   assert(track.IsLeader());
   // AS: If the shift button is being held down, invert
   //  the selection on this track.
   if (ctrl)
      SelectTrack(track, !track.GetSelected(), true);
   else {
      if (shift && mLastPickedTrack.lock())
         ChangeSelectionOnShiftClick(tracks, track);
      else {
         SelectNone(tracks);
         SelectTrack(track, true, true);
         SelectTrackLength(viewInfo, track, syncLocked);
      }
   }
}

References ChangeSelectionOnShiftClick(), Track::GetSelected(), Track::IsLeader(), mLastPickedTrack, SelectNone(), SelectTrack(), SelectTrackLength(), and tracks.

Here is the call graph for this function:

operator=()

SelectionState & SelectionState::operator= ( const SelectionState &  )

delete

SelectNone()

void SelectionState::SelectNone

(

TrackList &

tracks

)

Definition at line 101 of file SelectionState.cpp.

{
   for (auto t : tracks)
      SelectTrack(*t, false, false);
}

References SelectTrack(), and tracks.

Referenced by ChangeSelectionOnShiftClick(), BackgroundHandle::Click(), and HandleListSelection().

Here is the call graph for this function:

Here is the caller graph for this function:

SelectRangeOfTracks()

void SelectionState::SelectRangeOfTracks	(	TrackList &	tracks,
		Track &	sTrack,
		Track &	eTrack
	)

Definition at line 80 of file SelectionState.cpp.

{
   Track *sTrack = &rsTrack, *eTrack = &reTrack;
   // Swap the track pointers if needed
   auto begin = tracks.begin(),
      iterS = tracks.Find(sTrack),
      iterE = tracks.Find(eTrack);
   // Be sure to substitute the leaders for given tracks
   sTrack = *iterS;
   eTrack = *iterE;
   auto indS = std::distance(begin, iterS),
      indE = std::distance(begin, iterE);
   if (indE < indS)
      std::swap(sTrack, eTrack);
 
   for (auto track :
        tracks.Any().StartingWith(sTrack).EndingAfter(eTrack))
      SelectTrack(*track, true, false);
}

References PackedArray::begin(), SelectTrack(), anonymous_namespace{NoteTrack.cpp}::swap(), and tracks.

Referenced by ChangeSelectionOnShiftClick().

Here is the call graph for this function:

Here is the caller graph for this function:

SelectTrack()

void SelectionState::SelectTrack	(	Track &	track,
		bool	selected,
		bool	updateLastPicked
	)

Precondition

track.IsLeader()

Definition at line 52 of file SelectionState.cpp.

{
   assert(track.IsLeader());
   //bool wasCorrect = (selected == track.GetSelected());
 
   track.SetSelected(selected);
 
   if (updateLastPicked)
      mLastPickedTrack = track.SharedPointer();
 
//The older code below avoids an anchor on an unselected track.
 
   /*
   if (selected) {
      // This handles the case of linked tracks, selecting all channels
      mTracks->Select(pTrack, true);
      if (updateLastPicked)
         mLastPickedTrack = Track::Pointer( pTrack );
   }
   else {
      mTracks->Select(pTrack, false);
      if (updateLastPicked && pTrack == mLastPickedTrack.lock().get())
         mLastPickedTrack.reset();
   }
*/
}

References Track::IsLeader(), mLastPickedTrack, Track::SetSelected(), and Track::SharedPointer().

Referenced by ChangeSelectionOnShiftClick(), HandleListSelection(), SelectNone(), and SelectRangeOfTracks().

Here is the call graph for this function:

Here is the caller graph for this function:

SelectTrackLength()

void SelectionState::SelectTrackLength ( ViewInfo &  viewInfo, Track &  track, bool  syncLocked  )

static

Set selection length to the length of a track – but if sync-lock is turned on, use the largest possible selection in the sync-lock group. If it's a stereo track, do the same for the stereo channels.

Precondition

track.IsLeader()

Definition at line 32 of file SelectionState.cpp.

{
   assert(track.IsLeader());
   auto trackRange = syncLocked
   // If we have a sync-lock group and sync-lock linking is on,
   // check the sync-lock group tracks.
   ? SyncLock::Group(&track)
 
   // Otherwise, check for one track
   : TrackList::SingletonRange(&track);
 
   auto minOffset = trackRange.min(&Track::GetStartTime);
   auto maxEnd = trackRange.max(&Track::GetEndTime);
 
   // PRL: double click or click on track control.
   // should this select all frequencies too?  I think not.
   viewInfo.selectedRegion.setTimes(minOffset, maxEnd);
}

References ChannelGroup::GetEndTime(), ChannelGroup::GetStartTime(), SyncLock::Group(), Track::IsLeader(), ViewInfo::selectedRegion, NotifyingSelectedRegion::setTimes(), and TrackList::SingletonRange().

Referenced by SelectHandle::Click(), HandleListSelection(), and NoteTrackAffordanceHandle::SelectAt().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

SelectionStateChanger

friend class SelectionStateChanger

friend

Definition at line 60 of file SelectionState.h.

Member Data Documentation

mLastPickedTrack

std::weak_ptr<Track> SelectionState::mLastPickedTrack

private

Invariant

mLastPickedTrack.expired() || mLastPickedTrack.lock()->IsLeader()

Definition at line 66 of file SelectionState.h.

Referenced by ChangeSelectionOnShiftClick(), HandleListSelection(), SelectTrack(), and SelectionStateChanger::~SelectionStateChanger().

---

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

• SelectionState.h
• SelectionState.cpp