#include <WaveTrackAffordanceControls.h>

Inheritance diagram for WaveTrackAffordanceControls:

Collaboration diagram for WaveTrackAffordanceControls:

Public Member Functions
	WaveTrackAffordanceControls (const std::shared_ptr< Track > &pTrack)

std::vector< UIHandlePtr >	HitTest (const TrackPanelMouseState &state, const AudacityProject *pProject) override

void	Draw (TrackPanelDrawingContext &context, const wxRect &rect, unsigned iPass) override

IntervalIterator	GetSelectedInterval () const

unsigned	CaptureKey (wxKeyEvent &event, ViewInfo &viewInfo, wxWindow pParent, AudacityProject project) override

unsigned	KeyDown (wxKeyEvent &event, ViewInfo &viewInfo, wxWindow pParent, AudacityProject project) override

unsigned	Char (wxKeyEvent &event, ViewInfo &viewInfo, wxWindow pParent, AudacityProject project) override

unsigned	LoseFocus (AudacityProject *project) override

void	OnTextEditFinished (AudacityProject *project, const wxString &text) override

void	OnTextEditCancelled (AudacityProject *project) override

void	OnTextModified (AudacityProject *project, const wxString &text) override

void	OnTextContextMenu (AudacityProject *project, const wxPoint &position) override

unsigned	OnAffordanceClick (const TrackPanelMouseEvent &event, AudacityProject *project)

bool	OnTextCopy (AudacityProject &project)

bool	OnTextCut (AudacityProject &project)

bool	OnTextPaste (AudacityProject &project)

bool	OnTextSelect (AudacityProject &project)

void	StartEditSelectedClipName (AudacityProject &project)

void	StartEditSelectedClipSpeed (AudacityProject &project)

void	OnRenderClipStretching (AudacityProject &project) const

std::vector< MenuItem >	GetMenuItems (const wxRect &rect, const wxPoint pPosition, AudacityProject pProject) override
	Return a list of items for DoContextMenu() (empties for separators) More...

Public Member Functions inherited from CommonTrackCell
	CommonTrackCell (const std::shared_ptr< Track > &pTrack)
	Construct from a track. More...

	~CommonTrackCell ()

std::shared_ptr< Track >	DoFindTrack () override

void	Reparent (const std::shared_ptr< Track > &parent) override
	Object may be shared among tracks but hold a special back-pointer to one of them; reassign it. More...

Public Member Functions inherited from CommonTrackPanelCell
	CommonTrackPanelCell ()

virtual	~CommonTrackPanelCell ()=0

HitTestPreview	DefaultPreview (const TrackPanelMouseState &, const AudacityProject *) override

std::shared_ptr< Track >	FindTrack ()

std::shared_ptr< const Track >	FindTrack () const

virtual std::vector< MenuItem >	GetMenuItems (const wxRect &rect, const wxPoint pPosition, AudacityProject pProject)
	Return a list of items for DoContextMenu() (empties for separators) More...

Public Member Functions inherited from TrackPanelCell
	TrackPanelCell ()=default

	TrackPanelCell (const TrackPanelCell &)=delete

TrackPanelCell &	operator= (const TrackPanelCell &)=delete

virtual	~TrackPanelCell ()=0

virtual HitTestPreview	DefaultPreview (const TrackPanelMouseState &state, const AudacityProject *pProject)

virtual std::vector< UIHandlePtr >	HitTest (const TrackPanelMouseState &state, const AudacityProject *pProject)=0

virtual unsigned	HandleWheelRotation (const TrackPanelMouseEvent &event, AudacityProject *pProject)

virtual std::shared_ptr< TrackPanelCell >	ContextMenuDelegate ()

virtual unsigned	DoContextMenu (const wxRect &rect, wxWindow pParent, const wxPoint pPosition, AudacityProject *pProject)

virtual unsigned	CaptureKey (wxKeyEvent &event, ViewInfo &viewInfo, wxWindow pParent, AudacityProject project)

virtual unsigned	KeyDown (wxKeyEvent &event, ViewInfo &viewInfo, wxWindow pParent, AudacityProject project)

virtual unsigned	KeyUp (wxKeyEvent &event, ViewInfo &viewInfo, wxWindow pParent, AudacityProject project)

virtual unsigned	Char (wxKeyEvent &event, ViewInfo &viewInfo, wxWindow pParent, AudacityProject project)

virtual unsigned	LoseFocus (AudacityProject *project)

Public Member Functions inherited from TrackPanelNode
	TrackPanelNode ()

virtual	~TrackPanelNode ()=0

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)

Public Member Functions inherited from TrackAttachment
virtual	~TrackAttachment ()

virtual void	CopyTo (Track &track) const
	Copy state, for undo/redo purposes. More...

virtual void	Reparent (const std::shared_ptr< Track > &parent)
	Object may be shared among tracks but hold a special back-pointer to one of them; reassign it. More...

virtual void	WriteXMLAttributes (XMLWriter &) const
	Serialize persistent attributes. More...

virtual bool	HandleXMLAttribute (const std::string_view &attr, const XMLAttributeValueView &valueView)
	Deserialize an attribute, returning true if recognized. More...

Public Member Functions inherited from ClientData::Base
virtual	~Base ()

Public Member Functions inherited from TextEditDelegate
virtual	~TextEditDelegate ()

virtual void	OnTextEditFinished (AudacityProject *project, const wxString &text)=0

virtual void	OnTextEditCancelled (AudacityProject *project)=0

virtual void	OnTextModified (AudacityProject *project, const wxString &text)=0

virtual void	OnTextContextMenu (AudacityProject *project, const wxPoint &position)=0

Private Types
using	IntervalIterator = ChannelGroup::IntervalIterator< WaveTrack::Interval >

Private Member Functions
bool	IsIntervalVisible (const IntervalIterator &it) const noexcept

bool	StartEditClipName (AudacityProject &project, IntervalIterator it)
	Starts in-place clip name editing or shows a Clip Name Edit dialog, depending on prefs. More...

void	ResetClipNameEdit ()

void	OnTrackListEvent (const TrackListEvent &evt)

void	OnSelectionChange (NotifyingSelectedRegionMessage)

unsigned	ExitTextEditing ()

std::shared_ptr< TextEditHelper >	MakeTextEditHelper (const wxString &text)

Private Attributes
IntervalIterator	mFocusInterval

std::weak_ptr< ClipOverflowButtonHandle >	mOverflowButtonHandle

std::weak_ptr< ClipPitchAndSpeedButtonHandle >	mPitchButtonHandle

std::weak_ptr< ClipPitchAndSpeedButtonHandle >	mSpeedButtonHandle

std::weak_ptr< WaveTrackAffordanceHandle >	mAffordanceHandle

std::weak_ptr< TrackPanelResizeHandle >	mResizeHandle

std::weak_ptr< WaveClipTitleEditHandle >	mTitleEditHandle

std::weak_ptr< SelectHandle >	mSelectHandle

std::weak_ptr< WaveClipAdjustBorderHandle >	mClipBorderAdjustHandle

IntervalIterator	mEditedInterval

std::shared_ptr< TextEditHelper >	mTextEditHelper

wxFont	mClipNameFont

std::vector< IntervalIterator >	mVisibleIntervals

Observer::Subscription	mTrackListEventSubscription

Observer::Subscription	mSelectionChangeSubscription

Additional Inherited Members
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)

Protected Member Functions inherited from CommonTrackPanelCell
virtual std::shared_ptr< Track >	DoFindTrack ()=0

unsigned	DoContextMenu (const wxRect &rect, wxWindow pParent, const wxPoint pPosition, AudacityProject *pProject) override

unsigned	HandleWheelRotation (const TrackPanelMouseEvent &event, AudacityProject *pProject) override

Detailed Description

Definition at line 38 of file WaveTrackAffordanceControls.h.

Member Typedef Documentation

◆ IntervalIterator

using WaveTrackAffordanceControls::IntervalIterator = ChannelGroup::IntervalIterator<WaveTrack::Interval>

private

Definition at line 43 of file WaveTrackAffordanceControls.h.

Constructor & Destructor Documentation

◆ WaveTrackAffordanceControls()

WaveTrackAffordanceControls::WaveTrackAffordanceControls ( const std::shared_ptr< Track > & pTrack )

Definition at line 152 of file WaveTrackAffordanceControls.cpp.

    : CommonTrackCell{ pTrack }
    , mClipNameFont{ wxFontInfo{} }
{
   if (auto trackList = pTrack->GetOwner()) {
      if (auto pProject = trackList->GetOwner()) {
         mTrackListEventSubscription = PendingTracks(*pProject).Subscribe(
            *this, &WaveTrackAffordanceControls::OnTrackListEvent);
         if(auto project = trackList->GetOwner())
         {
            auto& viewInfo = ViewInfo::Get(*project);
            mSelectionChangeSubscription =
            viewInfo.selectedRegion.Subscribe(
               *this,
               &WaveTrackAffordanceControls::OnSelectionChange);
         }
      }
   }
}

References ViewInfo::Get(), mSelectionChangeSubscription, mTrackListEventSubscription, OnSelectionChange(), OnTrackListEvent(), project, and Observer::Publisher< Message, NotifyAll >::Subscribe().

Here is the call graph for this function:

Member Function Documentation

◆ CaptureKey()

unsigned WaveTrackAffordanceControls::CaptureKey	(	wxKeyEvent &	event,
		ViewInfo &	viewInfo,
		wxWindow *	pParent,
		AudacityProject *	project
	)

overridevirtual

Reimplemented from TrackPanelCell.

Definition at line 484 of file WaveTrackAffordanceControls.cpp.

{
    if (!mTextEditHelper
       || !mTextEditHelper->CaptureKey(event.GetKeyCode(), event.GetModifiers()))
       // Handle the event if it can be processed by the text editor (if any)
       event.Skip();
    return RefreshCode::RefreshNone;
}

References mTextEditHelper, and RefreshCode::RefreshNone.

◆ Char()

unsigned WaveTrackAffordanceControls::Char	(	wxKeyEvent &	event,
		ViewInfo &	viewInfo,
		wxWindow *	pParent,
		AudacityProject *	project
	)

overridevirtual

Reimplemented from TrackPanelCell.

Definition at line 509 of file WaveTrackAffordanceControls.cpp.

{
    if (mTextEditHelper && mTextEditHelper->OnChar(event.GetUnicodeKey(), project))
        return RefreshCode::RefreshCell;
    return RefreshCode::RefreshNone;
}

References mTextEditHelper, project, RefreshCode::RefreshCell, and RefreshCode::RefreshNone.

◆ Draw()

void WaveTrackAffordanceControls::Draw	(	TrackPanelDrawingContext &	context,
		const wxRect &	rect,
		unsigned	iPass
	)

overridevirtual

Reimplemented from TrackPanelDrawable.

Definition at line 273 of file WaveTrackAffordanceControls.cpp.

{
   if (iPass == TrackArtist::PassBackground) {
      const auto track = FindTrack().get();
      if (!track)
         return;
      const auto artist = TrackArtist::Get(context);
      const auto &pendingTracks = *artist->pPendingTracks;
      
      // Color the background of the affordance rectangle (only one per track)
      // as for the topmost channel
      TrackArt::DrawBackgroundWithSelection(context,
         rect, **track->Channels().begin(),
         artist->clipAffordanceBackgroundSelBrush,
         artist->clipAffordanceBackgroundBrush,
         true, true);
      
      mVisibleIntervals.clear();
      
      auto &waveTrack = static_cast<WaveTrack&>(
         pendingTracks.SubstitutePendingChangedTrack(*track));
      const auto& zoomInfo = *artist->pZoomInfo;
      {
         wxDCClipper dcClipper(context.dc, rect);
         
         context.dc.SetTextBackground(wxTransparentColor);
         context.dc.SetTextForeground(theTheme.Colour(clrClipNameText));
         context.dc.SetFont(mClipNameFont);
         
         auto px = context.lastState.m_x;
         auto py = context.lastState.m_y;
         
         const auto overflowHandle = mOverflowButtonHandle.lock();
         const auto &intervals = waveTrack.Intervals();
         for(auto it = intervals.begin(); it != intervals.end(); ++it)
         {
             auto interval = *it;
             const auto& clip = *interval;
             const auto clipRect = ClipParameters::GetClipRect(
                clip, zoomInfo, rect);
 
             if(!WaveChannelView::ClipDetailsVisible(clip, zoomInfo, rect))
             {
                TrackArt::DrawClipFolded(context.dc, clipRect);
                continue;
             }
 
             const auto selected = GetSelectedInterval() == it;
             const auto highlightAffordance =
                 !overflowHandle && (selected || clipRect.Contains(px, py));
             auto affordanceRect = TrackArt::DrawClipAffordance(
                context.dc, clipRect, highlightAffordance, selected);
 
             if (
                const auto overflowButtonRect =
                   LowlitClipButton::DrawOnClip<ClipButtonId::Overflow>(
                      { clip, zoomInfo, rect }, context.dc))
                affordanceRect.width -= overflowButtonRect->width;
             if (
                const auto speedButtonRect =
                   LowlitClipButton::DrawOnClip<ClipButtonId::Speed>(
                      { clip, zoomInfo, rect }, context.dc))
                affordanceRect.width -= speedButtonRect->width;
             if (
                const auto pitchButtonRect =
                   LowlitClipButton::DrawOnClip<ClipButtonId::Pitch>(
                      { clip, zoomInfo, rect }, context.dc))
                affordanceRect.width -= pitchButtonRect->width;
 
                if (mTextEditHelper && mEditedInterval == it)
                {
                   if (!mTextEditHelper->Draw(context.dc, affordanceRect))
                   {
                      mTextEditHelper->Cancel(nullptr);
                      TrackArt::DrawClipTitle(
                         context.dc, affordanceRect, interval->GetName());
                   }
                }
                else if (TrackArt::DrawClipTitle(
                            context.dc, affordanceRect, interval->GetName()))
                   mVisibleIntervals.push_back(it);
         }
      }      
   }
}

References WaveChannelView::ClipDetailsVisible(), ThemeBase::Colour(), TrackPanelDrawingContext::dc, TrackArt::DrawBackgroundWithSelection(), TrackArt::DrawClipAffordance(), TrackArt::DrawClipFolded(), TrackArt::DrawClipTitle(), CommonTrackPanelCell::FindTrack(), TrackArtist::Get(), ClipParameters::GetClipRect(), GetSelectedInterval(), TrackPanelDrawingContext::lastState, mClipNameFont, mEditedInterval, mOverflowButtonHandle, mTextEditHelper, mVisibleIntervals, TrackArtist::PassBackground, and theTheme.

Here is the call graph for this function:

◆ ExitTextEditing()

unsigned WaveTrackAffordanceControls::ExitTextEditing ( )

private

Definition at line 566 of file WaveTrackAffordanceControls.cpp.

{
    using namespace RefreshCode;
    if (mTextEditHelper)
    {
        if (auto trackList = FindTrack()->GetOwner())
        {
            mTextEditHelper->Finish(trackList->GetOwner());
        }
        ResetClipNameEdit();
        return RefreshCell;
    }
    return RefreshNone;
}

References CommonTrackPanelCell::FindTrack(), mTextEditHelper, RefreshCode::RefreshCell, RefreshCode::RefreshNone, and ResetClipNameEdit().

Referenced by LoseFocus(), OnAffordanceClick(), OnSelectionChange(), and OnTrackListEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMenuItems()

auto WaveTrackAffordanceControls::GetMenuItems	(	const wxRect &	rect,
		const wxPoint *	pPosition,
		AudacityProject *	pProject
	)

overridevirtual

Return a list of items for DoContextMenu() (empties for separators)

If the vector is empty (as in the default), there is no context menu.

Commands are invoked with temporary selection fields of CommandContext set to a point selected region at the mouse pick, and the cell's track.

A function may be given, but if it is null, then the command can be found by name in the CommandManager.

An item in the list with no command name marks a menu separator.

The menu item is enabled only if it contains a true flag, but if looked up in the command manager, it must also satisfy the command manager's conditions.

Reimplemented from CommonTrackPanelCell.

Definition at line 709 of file WaveTrackAffordanceControls.cpp.

{
   return WaveClipUIUtilities::GetWaveClipMenuItems();
}

References WaveClipUIUtilities::GetWaveClipMenuItems().

Here is the call graph for this function:

◆ GetSelectedInterval()

auto WaveTrackAffordanceControls::GetSelectedInterval ( ) const

Definition at line 403 of file WaveTrackAffordanceControls.cpp.

{
    if (auto handle = mAffordanceHandle.lock())
    {
        return handle->Clicked() ? mFocusInterval : IntervalIterator{};
    }
    return {};
}

References mAffordanceHandle, and mFocusInterval.

Referenced by Draw().

Here is the caller graph for this function:

◆ HitTest()

std::vector< UIHandlePtr > WaveTrackAffordanceControls::HitTest	(	const TrackPanelMouseState &	state,
		const AudacityProject *	pProject
	)

overridevirtual

Implements TrackPanelCell.

Definition at line 172 of file WaveTrackAffordanceControls.cpp.

{
    std::vector<UIHandlePtr> results;
 
    const auto px = state.state.m_x;
    const auto py = state.state.m_y;
    const wxPoint mousePoint { px, py };
 
    const auto rect = state.rect;
 
    auto track = std::static_pointer_cast<WaveTrack>(FindTrack());
    if (!track)
       return {};
 
    {
        auto handle = WaveClipAdjustBorderHandle::HitAnywhere(
            mClipBorderAdjustHandle,
            track,
            pProject,
            state);
 
        if (handle)
            results.push_back(handle);
    }
 
    if (mTextEditHelper && mTextEditHelper->GetBBox().Contains(px, py))
    {
        results.push_back(
            AssignUIHandlePtr(
                mTitleEditHandle,
                std::make_shared<WaveClipTitleEditHandle>(
                    mTextEditHelper, track)
            )
        );
    }
 
    auto &waveTrack = static_cast<WaveTrack&>(
       PendingTracks::Get(*pProject).SubstitutePendingChangedTrack(*track));
    auto& zoomInfo = ViewInfo::Get(*pProject);
    const auto &intervals = waveTrack.Intervals();
    for(auto it = intervals.begin(); it != intervals.end(); ++it)
    {
        if (it == mEditedInterval)
            continue;
 
        const auto clip = (*it);
        if (LowlitClipButton::HitTest<ClipButtonId::Overflow>(
               { *clip, zoomInfo, rect }, mousePoint))
        {
           results.push_back(AssignUIHandlePtr(
              mOverflowButtonHandle, std::make_shared<ClipOverflowButtonHandle>(
                                        track, *it, weak_from_this())));
           mFocusInterval = it;
           break;
        }
        else if (LowlitClipButton::HitTest<ClipButtonId::Pitch>(
                    { *clip, zoomInfo, rect }, mousePoint))
        {
           results.push_back(AssignUIHandlePtr(
              mPitchButtonHandle,
              std::make_shared<ClipPitchAndSpeedButtonHandle>(
                 ClipPitchAndSpeedButtonHandle::Type::Pitch, track, *it)));
           mFocusInterval = it;
           break;
        }
        else if (LowlitClipButton::HitTest<ClipButtonId::Speed>(
                    { *clip, zoomInfo, rect }, mousePoint))
        {
           results.push_back(AssignUIHandlePtr(
              mSpeedButtonHandle,
              std::make_shared<ClipPitchAndSpeedButtonHandle>(
                 ClipPitchAndSpeedButtonHandle::Type::Speed, track, *it)));
           mFocusInterval = it;
           break;
        }
        else if (WaveChannelView::HitTest(
                    *clip, zoomInfo, state.rect, mousePoint))
        {
           results.push_back(AssignUIHandlePtr(
              mAffordanceHandle,
              std::make_shared<WaveTrackAffordanceHandle>(track, clip)));
           mFocusInterval = it;
           break;
        }
    }
 
    const auto& settings = ProjectSettings::Get(*pProject);
    const auto currentTool = settings.GetTool();
    if (currentTool == ToolCodes::multiTool || currentTool == ToolCodes::selectTool)
    {
        results.push_back(
            SelectHandle::HitTest(
                mSelectHandle, state, pProject,
                WaveChannelView::GetFirst(*track).shared_from_this()
            )
        );
    }
 
    return results;
}

References AssignUIHandlePtr(), CommonTrackPanelCell::FindTrack(), ViewInfo::Get(), PendingTracks::Get(), ProjectSettings::Get(), WaveChannelView::GetFirst(), WaveClipAdjustBorderHandle::HitAnywhere(), WaveChannelView::HitTest(), SelectHandle::HitTest(), mAffordanceHandle, mClipBorderAdjustHandle, mEditedInterval, mFocusInterval, mOverflowButtonHandle, mPitchButtonHandle, mSelectHandle, mSpeedButtonHandle, mTextEditHelper, mTitleEditHandle, ToolCodes::multiTool, ClipPitchAndSpeedButtonHandle::Pitch, TrackPanelMouseState::rect, ToolCodes::selectTool, settings(), ClipPitchAndSpeedButtonHandle::Speed, TrackPanelMouseState::state, and PendingTracks::SubstitutePendingChangedTrack().

Here is the call graph for this function:

◆ IsIntervalVisible()

bool WaveTrackAffordanceControls::IsIntervalVisible ( const IntervalIterator & it ) const

privatenoexcept

Definition at line 359 of file WaveTrackAffordanceControls.cpp.

{
    return std::find(mVisibleIntervals.begin(),
                     mVisibleIntervals.end(),
                     it) != mVisibleIntervals.end();
}

Referenced by StartEditClipName().

Here is the caller graph for this function:

◆ KeyDown()

unsigned WaveTrackAffordanceControls::KeyDown	(	wxKeyEvent &	event,
		ViewInfo &	viewInfo,
		wxWindow *	pParent,
		AudacityProject *	project
	)

overridevirtual

Reimplemented from TrackPanelCell.

Definition at line 494 of file WaveTrackAffordanceControls.cpp.

{
    auto keyCode = event.GetKeyCode();
 
    if (mTextEditHelper)
    {
       if (!mTextEditHelper->OnKeyDown(keyCode, event.GetModifiers(), project)
          && !TextEditHelper::IsGoodEditKeyCode(keyCode))
          event.Skip();
 
       return RefreshCode::RefreshCell;
    }
    return RefreshCode::RefreshNone;
}

References TextEditHelper::IsGoodEditKeyCode(), mTextEditHelper, project, RefreshCode::RefreshCell, and RefreshCode::RefreshNone.

Here is the call graph for this function:

◆ LoseFocus()

unsigned WaveTrackAffordanceControls::LoseFocus ( AudacityProject * project )

overridevirtual

Reimplemented from TrackPanelCell.

Definition at line 516 of file WaveTrackAffordanceControls.cpp.

{
   return ExitTextEditing();
}

References ExitTextEditing().

Here is the call graph for this function:

◆ MakeTextEditHelper()

std::shared_ptr< TextEditHelper > WaveTrackAffordanceControls::MakeTextEditHelper ( const wxString & text )

private

Definition at line 701 of file WaveTrackAffordanceControls.cpp.

{
    auto helper = std::make_shared<TextEditHelper>(shared_from_this(), text, mClipNameFont);
    helper->SetTextColor(theTheme.Colour(clrClipNameText));
    helper->SetTextSelectionColor(theTheme.Colour(clrClipNameTextSelection));
    return helper;
}

References ThemeBase::Colour(), mClipNameFont, and theTheme.

Referenced by StartEditClipName().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OnAffordanceClick()

unsigned WaveTrackAffordanceControls::OnAffordanceClick	(	const TrackPanelMouseEvent &	event,
		AudacityProject *	project
	)

Definition at line 621 of file WaveTrackAffordanceControls.cpp.

{
    auto& viewInfo = ViewInfo::Get(*project);
    if (mTextEditHelper)
    {
        if (auto interval = *mEditedInterval)
        {
            auto affordanceRect = ClipParameters::GetClipRect(*interval, viewInfo, event.rect);
            if (!affordanceRect.Contains(event.event.GetPosition()))
               return ExitTextEditing();
        }
    }
    else if (auto interval = *mFocusInterval)
    {
        if (event.event.LeftDClick())
        {
            auto affordanceRect = ClipParameters::GetClipRect(*interval, viewInfo, event.rect);
            if (affordanceRect.Contains(event.event.GetPosition()) &&
                StartEditClipName(*project, mFocusInterval))
            {
                event.event.Skip(false);
                return RefreshCode::RefreshCell;
            }
        }
    }
    return RefreshCode::RefreshNone;
}

References TrackPanelMouseEvent::event, ExitTextEditing(), ViewInfo::Get(), ClipParameters::GetClipRect(), mEditedInterval, mFocusInterval, mTextEditHelper, project, TrackPanelMouseEvent::rect, RefreshCode::RefreshCell, RefreshCode::RefreshNone, and StartEditClipName().

Here is the call graph for this function:

◆ OnRenderClipStretching()

void WaveTrackAffordanceControls::OnRenderClipStretching ( AudacityProject & project ) const

Definition at line 674 of file WaveTrackAffordanceControls.cpp.

{
   const auto [track, it] = SelectedIntervalOfFocusedTrack(project);
 
   if (track != FindTrack())
      return;
 
   auto interval = *it;
 
   if (!interval || !interval->HasPitchOrSpeed())
      return;
 
   TimeStretching::WithClipRenderingProgress(
      [track = track, interval = interval](const ProgressReporter& progress) {
         track->ApplyPitchAndSpeed(
            { { interval->GetPlayStartTime(), interval->GetPlayEndTime() } },
            progress);
      },
      XO("Applying..."));
 
   ProjectHistory::Get(project).PushState(
      XO("Rendered time-stretched audio"), XO("Render"));
 
   WaveClipUIUtilities::SelectClip(project, *interval);
}

References CommonTrackPanelCell::FindTrack(), ProjectHistory::Get(), project, ProjectHistory::PushState(), WaveClipUIUtilities::SelectClip(), anonymous_namespace{WaveTrackAffordanceControls.cpp}::SelectedIntervalOfFocusedTrack(), TimeStretching::WithClipRenderingProgress(), and XO().

Here is the call graph for this function:

◆ OnSelectionChange()

void WaveTrackAffordanceControls::OnSelectionChange ( NotifyingSelectedRegionMessage )

private

Definition at line 561 of file WaveTrackAffordanceControls.cpp.

{
    ExitTextEditing();
}

References ExitTextEditing().

Referenced by WaveTrackAffordanceControls().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OnTextContextMenu()

void WaveTrackAffordanceControls::OnTextContextMenu	(	AudacityProject *	project,
		const wxPoint &	position
	)

overridevirtual

Implements TextEditDelegate.

Definition at line 545 of file WaveTrackAffordanceControls.cpp.

546{

547}

◆ OnTextCopy()

bool WaveTrackAffordanceControls::OnTextCopy ( AudacityProject & project )

Definition at line 581 of file WaveTrackAffordanceControls.cpp.

{
   if (mTextEditHelper)
   {
      mTextEditHelper->CopySelectedText(project);
      return true;
   }
   return false;
}

References mTextEditHelper, and project.

Referenced by WaveChannelView::CopySelectedText().

Here is the caller graph for this function:

◆ OnTextCut()

bool WaveTrackAffordanceControls::OnTextCut ( AudacityProject & project )

Definition at line 591 of file WaveTrackAffordanceControls.cpp.

{
   if (mTextEditHelper)
   {
      mTextEditHelper->CutSelectedText(project);
      return true;
   }
   return false;
}

References mTextEditHelper, and project.

Referenced by WaveChannelView::CutSelectedText().

Here is the caller graph for this function:

◆ OnTextEditCancelled()

void WaveTrackAffordanceControls::OnTextEditCancelled ( AudacityProject * project )

overridevirtual

Implements TextEditDelegate.

Definition at line 535 of file WaveTrackAffordanceControls.cpp.

{
    ResetClipNameEdit();
}

References ResetClipNameEdit().

Here is the call graph for this function:

◆ OnTextEditFinished()

void WaveTrackAffordanceControls::OnTextEditFinished	(	AudacityProject *	project,
		const wxString &	text
	)

overridevirtual

Implements TextEditDelegate.

Definition at line 521 of file WaveTrackAffordanceControls.cpp.

{
    if (auto interval = *mEditedInterval)
    {
        if (text != interval->GetName()) {
            interval->SetName(text);
 
            ProjectHistory::Get(*project).PushState(XO("Modified Clip Name"),
                XO("Clip Name Edit"));
        }
    }
    ResetClipNameEdit();
}

References ProjectHistory::Get(), mEditedInterval, ProjectHistory::PushState(), ResetClipNameEdit(), and XO().

Here is the call graph for this function:

◆ OnTextModified()

void WaveTrackAffordanceControls::OnTextModified	(	AudacityProject *	project,
		const wxString &	text
	)

overridevirtual

Implements TextEditDelegate.

Definition at line 540 of file WaveTrackAffordanceControls.cpp.

{
    //Nothing to do
}

◆ OnTextPaste()

bool WaveTrackAffordanceControls::OnTextPaste ( AudacityProject & project )

Definition at line 601 of file WaveTrackAffordanceControls.cpp.

{
   if (mTextEditHelper)
   {
      mTextEditHelper->PasteSelectedText(project);
      return true;
   }
   return false;
}

References mTextEditHelper, and project.

Referenced by WaveChannelView::PasteText().

Here is the caller graph for this function:

◆ OnTextSelect()

bool WaveTrackAffordanceControls::OnTextSelect ( AudacityProject & project )

Definition at line 611 of file WaveTrackAffordanceControls.cpp.

{
   if (mTextEditHelper)
   {
      mTextEditHelper->SelectAll();
      return true;
   }
   return false;
}

References mTextEditHelper.

Referenced by WaveChannelView::SelectAllText().

Here is the caller graph for this function:

◆ OnTrackListEvent()

void WaveTrackAffordanceControls::OnTrackListEvent ( const TrackListEvent & evt )

private

Definition at line 555 of file WaveTrackAffordanceControls.cpp.

{
    if (evt.mType == TrackListEvent::SELECTION_CHANGE)
       ExitTextEditing();
}

References ExitTextEditing(), TrackListEvent::mType, and TrackListEvent::SELECTION_CHANGE.

Referenced by WaveTrackAffordanceControls().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ResetClipNameEdit()

void WaveTrackAffordanceControls::ResetClipNameEdit ( )

private

Definition at line 549 of file WaveTrackAffordanceControls.cpp.

{
    mTextEditHelper.reset();
    mEditedInterval = {};
}

References mEditedInterval, and mTextEditHelper.

Referenced by ExitTextEditing(), OnTextEditCancelled(), and OnTextEditFinished().

Here is the caller graph for this function:

◆ StartEditClipName()

bool WaveTrackAffordanceControls::StartEditClipName	(	AudacityProject &	project,
		IntervalIterator	it
	)

private

Starts in-place clip name editing or shows a Clip Name Edit dialog, depending on prefs.

Parameters

clip	to be edited. Should belong to the same `WaveTrack` as returned by `FindTrack()`

Definition at line 366 of file WaveTrackAffordanceControls.cpp.

{
    bool useDialog{ false };
    gPrefs->Read(wxT("/GUI/DialogForNameNewLabel"), &useDialog, false);
 
    auto interval = *it;
    if(!interval)
        return false;
 
    if (useDialog)
    {
        SetWaveClipNameCommand Command;
        auto oldName = interval->GetName();
        Command.mName = oldName;
        auto result = Command.PromptUser(project);
        if (result && Command.mName != oldName)
        {
            interval->SetName(Command.mName);
            ProjectHistory::Get(project).PushState(XO("Modified Clip Name"),
                XO("Clip Name Edit"));
        }
    }
    else if(it != mEditedInterval)
    {
        if(!IsIntervalVisible(it))
           return false;
 
        if (mTextEditHelper)
            mTextEditHelper->Finish(&project);
 
        mEditedInterval = it;
        mTextEditHelper = MakeTextEditHelper(interval->GetName());
    }
 
    return true;
}

References MenuRegistry::Command, ProjectHistory::Get(), gPrefs, IsIntervalVisible(), MakeTextEditHelper(), mEditedInterval, mTextEditHelper, project, ProjectHistory::PushState(), audacity::BasicSettings::Read(), wxT(), and XO().

Referenced by OnAffordanceClick(), and StartEditSelectedClipName().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StartEditSelectedClipName()

void WaveTrackAffordanceControls::StartEditSelectedClipName ( AudacityProject & project )

Definition at line 649 of file WaveTrackAffordanceControls.cpp.

{
   auto [track, it] = SelectedIntervalOfFocusedTrack(project);
   if(track != FindTrack())
      return;
   StartEditClipName(project, it);
}

References CommonTrackPanelCell::FindTrack(), project, anonymous_namespace{WaveTrackAffordanceControls.cpp}::SelectedIntervalOfFocusedTrack(), and StartEditClipName().

Here is the call graph for this function:

◆ StartEditSelectedClipSpeed()

void WaveTrackAffordanceControls::StartEditSelectedClipSpeed ( AudacityProject & project )

Definition at line 657 of file WaveTrackAffordanceControls.cpp.

{
   constexpr auto wholeInterval = false;
   auto [track, it] = SelectedIntervalOfFocusedTrack(project, wholeInterval);
 
   if (track != FindTrack())
      return;
 
   auto interval = *it;
 
   if (!interval)
      return;
 
   PitchAndSpeedDialog::Get(project).Retarget(track, interval).SetFocus({});
}