#include <LabelTrackView.h>

Inheritance diagram for LabelTrackView:

Collaboration diagram for LabelTrackView:

Classes
struct	Flags

struct	Index

Public Types
enum	: int { DefaultFontSize = 0 }

Public Types inherited from ChannelView
enum	: unsigned { DefaultHeight = 150 }

using	Refinement = std::vector< std::pair< wxCoord, std::shared_ptr< ChannelView > > >

Public Member Functions
	LabelTrackView (const std::shared_ptr< Channel > &pChannel)

	~LabelTrackView () override

bool	DoCaptureKey (AudacityProject &project, wxKeyEvent &event)

bool	DoKeyDown (AudacityProject &project, NotifyingSelectedRegion &sel, wxKeyEvent &event)
	KeyEvent is called for every keypress when over the label track. More...

bool	DoChar (AudacityProject &project, NotifyingSelectedRegion &sel, wxKeyEvent &event)

int	AddLabel (const SelectedRegion &region, const wxString &title={}, int restoreFocus=-1)

bool	IsTextSelected (AudacityProject &project) const

void	Draw (TrackPanelDrawingContext &context, const wxRect &r) const

bool	CutSelectedText (AudacityProject &project)

bool	CopySelectedText (AudacityProject &project)

bool	SelectAllText (AudacityProject &project)

bool	PasteSelectedText (AudacityProject &project, double sel0, double sel1)

void	ResetFlags ()

Flags	SaveFlags () const

void	RestoreFlags (const Flags &flags)

void	AddedLabel (const wxString &title, int pos)

void	DeletedLabel (int index)

bool	CalcCursorX (AudacityProject &project, int *x) const

void	ShowContextMenu (AudacityProject &project)

int	FindCursorPosition (int labelIndex, wxCoord xPos)
	convert pixel coordinate to character position in text box More...

int	GetCurrentCursorPosition () const

void	SetCurrentCursorPosition (int pos)

int	GetInitialCursorPosition () const

void	SetTextSelection (int labelIndex, int start=1, int end=1)

int	GetTextEditIndex (AudacityProject &project) const

void	ResetTextSelection ()

void	SetNavigationIndex (int index)

int	GetNavigationIndex (AudacityProject &project) const

Public Member Functions inherited from CommonChannelView
std::shared_ptr< TrackPanelCell >	ContextMenuDelegate () override

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

void	TimeShiftHitTest ()

virtual int	GetMinimizedHeight () const override

	ChannelView (const std::shared_ptr< Channel > &pChannel)

Public Member Functions inherited from ChannelView
	ChannelView (const std::shared_ptr< Channel > &pChannel)

virtual	~ChannelView ()=0

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

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

bool	GetMinimized () const

void	SetMinimized (bool minimized)

int	GetCumulativeHeightBefore () const

int	GetExpandedHeight () const

virtual int	GetMinimizedHeight () const =0

int	GetHeight () const

void	SetCumulativeHeightBefore (int y)
	Set cached value dependent on position within the track list. More...

void	SetExpandedHeight (int height)

std::shared_ptr< ChannelVRulerControls >	GetVRulerControls ()

std::shared_ptr< const ChannelVRulerControls >	GetVRulerControls () const

virtual std::shared_ptr< CommonTrackCell >	GetAffordanceControls ()

void	WriteXMLAttributes (XMLWriter &writer, size_t iChannel) const override
	Serialize persistent attributes. More...

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

virtual Refinement	GetSubViews (const wxRect &rect)

virtual bool	IsSpectral () const

virtual void	DoSetMinimized (bool isMinimized)

Public Member Functions inherited from CommonChannelCell
	CommonChannelCell (const std::shared_ptr< Channel > &pChannel)
	Construct from a channel. More...

	~CommonChannelCell ()

std::shared_ptr< Track >	DoFindTrack () override

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

template<typename Subtype = Channel>
auto	FindChannel () -> std::shared_ptr< Subtype >
	May return null. More...

template<typename Subtype = const Channel>
auto	FindChannel () const -> std::enable_if_t< std::is_const_v< Subtype >, std::shared_ptr< Subtype > >
	May return null. 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 ChannelAttachment
virtual	~ChannelAttachment ()

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

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

virtual void	WriteXMLAttributes (XMLWriter &writer, size_t iChannel) const
	Serialize persistent attributes. More...

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

Static Public Member Functions
static LabelTrackView &	Get (LabelTrack &)

static const LabelTrackView &	Get (const LabelTrack &)

static void	DoEditLabels (AudacityProject &project, LabelTrack *lt=nullptr, int index=-1)

static int	DialogForLabelName (AudacityProject &project, const SelectedRegion &region, const wxString &initialValue, wxString &value)

static wxFont	GetFont (const wxString &faceName, int size=DefaultFontSize)

static void	ResetFont ()

static void	OverGlyph (const LabelTrack &track, LabelTrackHit &hit, int x, int y)

static int	OverATextBox (const LabelTrack &track, int xx, int yy)

static bool	OverTextBox (const LabelStruct *pLabel, int x, int y)

Static Public Member Functions inherited from CommonChannelView
static void	GetEnvelopeValues (const Envelope &env, double aligned_time, double sampleDur, double *buffer, int bufferLen, int leftOffset, const ZoomInfo &zoomInfo)
	Get many envelope points for pixel columns at once, but don't assume uniform time per pixel. More...

Static Public Member Functions inherited from ChannelView
static ChannelView &	Get (Channel &channel)

static const ChannelView &	Get (const Channel &channel)

static ChannelView *	Find (Channel *pChannel)

static const ChannelView *	Find (const Channel *pChannel)

static int	GetChannelGroupHeight (const Track *pTrack)

static int	GetCumulativeHeight (const Channel *pChannel)

static int	GetCumulativeHeight (const Track *pTrack)

static int	GetTotalHeight (const TrackList &list)

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)

Static Public Attributes
static constexpr int	TextFramePadding { 2 }

static constexpr int	TextFrameYOffset { -1 }

static constexpr int	LabelBarHeight { 6 }

Private Member Functions
	LabelTrackView (const LabelTrackView &)=delete

LabelTrackView &	operator= (const LabelTrackView &)=delete

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

void	BindTo (LabelTrack *pParent)

std::vector< UIHandlePtr >	DetailedHitTest (const TrackPanelMouseState &state, const AudacityProject *pProject, int currentTool, bool bMultiTool) override

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

std::shared_ptr< ChannelVRulerControls >	DoGetVRulerControls () override

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

void	CreateCustomGlyphs ()

int	GetLabelIndex (double t, double t1)

void	CalcHighlightXs (int x1, int x2) const

void	OnContextMenu (AudacityProject &project, wxCommandEvent &evt)

void	ComputeTextPosition (const wxRect &r, int index) const

void	ComputeLayout (const wxRect &r, const ZoomInfo &zoomInfo) const

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

bool	IsValidIndex (const Index &index, AudacityProject &project) const

void	RemoveSelectedText ()

void	OnLabelAdded (const LabelTrackEvent &)

void	OnLabelDeleted (const LabelTrackEvent &)

void	OnLabelPermuted (const LabelTrackEvent &)

void	OnSelectionChange (const LabelTrackEvent &)

std::shared_ptr< LabelTrack >	FindLabelTrack ()

std::shared_ptr< const LabelTrack >	FindLabelTrack () const

Static Private Member Functions
static wxBitmap &	GetGlyph (int i)

static bool	IsTextClipSupported ()

static void	DrawLines (wxDC &dc, const LabelStruct &ls, const wxRect &r)

static void	DrawGlyphs (wxDC &dc, const LabelStruct &ls, const wxRect &r, int GlyphLeft, int GlyphRight)

static int	GetTextFrameHeight ()

static void	DrawText (wxDC &dc, const LabelStruct &ls, const wxRect &r)

static void	DrawTextBox (wxDC &dc, const LabelStruct &ls, const wxRect &r)

static void	DrawBar (wxDC &dc, const LabelStruct &ls, const wxRect &r)

static void	DrawHighlight (wxDC &dc, const LabelStruct &ls, int xPos1, int xPos2, int charHeight)
	Draws text-selected region within the label. More...

static void	calculateFontHeight (wxDC &dc)

Private Attributes
Index	mNavigationIndex { -1 }

Index	mTextEditIndex { -1 }
	Index of the current label text being edited. More...

wxString	mUndoLabel

int	mCurrentCursorPos

int	mInitialCursorPos
	current cursor position More...

int	mRestoreFocus {-2}
	initial cursor position More...

Observer::Subscription	mSubscription

std::weak_ptr< LabelGlyphHandle >	mGlyphHandle

std::weak_ptr< LabelTextHandle >	mTextHandle

int	mEditIndex

Static Private Attributes
static int	mIconHeight

static int	mIconWidth

static int	mTextHeight

static bool	mbGlyphsReady =false

static wxBitmap	mBoundaryGlyphs [NUM_GLYPH_CONFIGS *NUM_GLYPH_HIGHLIGHTS]

static int	mFontHeight =-1

static wxFont	msFont

Additional Inherited Members
Public Attributes inherited from CommonChannelView
std::weak_ptr< TimeShiftHandle >	mTimeShiftHandle

Public Attributes inherited from ChannelView
std::pair< int, int >	vrulerSize

virtual std::vector< UIHandlePtr >	DetailedHitTest (const TrackPanelMouseState &, const AudacityProject *pProject, int currentTool, bool bMultiTool)=0

virtual std::shared_ptr< ChannelVRulerControls >	DoGetVRulerControls ()=0

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

Protected Attributes inherited from CommonChannelView
std::weak_ptr< SelectHandle >	mSelectHandle

Protected Attributes inherited from ChannelView
std::shared_ptr< ChannelVRulerControls >	mpVRulerControls

Detailed Description

Definition at line 40 of file LabelTrackView.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum : int

Enumerator
DefaultFontSize

Definition at line 49 of file LabelTrackView.h.

49: int { DefaultFontSize = 0 }; //system preferred

LabelTrackView::DefaultFontSize

@ DefaultFontSize

Definition: LabelTrackView.h:49

Constructor & Destructor Documentation

◆ LabelTrackView() [1/2]

LabelTrackView::LabelTrackView ( const LabelTrackView & )

privatedelete

◆ LabelTrackView() [2/2]

LabelTrackView::LabelTrackView ( const std::shared_ptr< Channel > & pChannel )

explicit

Definition at line 100 of file LabelTrackView.cpp.

   : CommonChannelView{ pChannel }
{
   ResetFont();
   CreateCustomGlyphs();
   ResetFlags();
 
   // Events will be emitted by the track
   const auto pLabelTrack = FindLabelTrack();
   BindTo( pLabelTrack.get() );
}

References BindTo(), CreateCustomGlyphs(), FindLabelTrack(), ResetFlags(), and ResetFont().

Here is the call graph for this function:

◆ ~LabelTrackView()

LabelTrackView::~LabelTrackView ( )

override

Definition at line 112 of file LabelTrackView.cpp.

113{

114}

Member Function Documentation

◆ AddedLabel()

void LabelTrackView::AddedLabel	(	const wxString &	title,
		int	pos
	)

◆ AddLabel()

int LabelTrackView::AddLabel	(	const SelectedRegion &	region,
		const wxString &	title = `{}`,
		int	restoreFocus = `-1`
	)

Definition at line 2071 of file LabelTrackView.cpp.

{
   const auto pTrack = FindLabelTrack();
   mRestoreFocus = restoreFocus;
   auto pos = pTrack->AddLabel( selectedRegion, title );
   return pos;
}

References FindLabelTrack(), mRestoreFocus, and title.

Referenced by anonymous_namespace{LabelMenus.cpp}::DoAddLabel(), DoChar(), and PasteSelectedText().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BindTo()

void LabelTrackView::BindTo ( LabelTrack * pParent )

private

Definition at line 127 of file LabelTrackView.cpp.

{
   // Destroys any previous subscription to another track
   mSubscription = pParent->Subscribe([this](const LabelTrackEvent &e){
      switch (e.type) {
      case LabelTrackEvent::Addition:
         return OnLabelAdded(e);
      case LabelTrackEvent::Deletion:
         return OnLabelDeleted(e);
      case LabelTrackEvent::Permutation:
         return OnLabelPermuted(e);
      case LabelTrackEvent::Selection:
         return OnSelectionChange(e);
      default:
         return;
      }
   });
}

References mSubscription, Observer::Publisher< Message, NotifyAll >::Subscribe(), and LabelTrackEvent::type.

Referenced by LabelTrackView(), and Reparent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalcCursorX()

bool LabelTrackView::CalcCursorX	(	AudacityProject &	project,
		int *	x
	)		const

Definition at line 699 of file LabelTrackView.cpp.

{
   if (IsValidIndex(mTextEditIndex, project)) {
      wxMemoryDC dc;
 
      if (msFont.Ok()) {
         dc.SetFont(msFont);
      }
 
      const auto pTrack = FindLabelTrack();
      const auto &mLabels = pTrack->GetLabels();
 
      getXPos(mLabels[mTextEditIndex], dc, x, mCurrentCursorPos);
      *x += mIconWidth / 2;
      return true;
   }
 
   return false;
}

References FindLabelTrack(), anonymous_namespace{LabelTrackView.cpp}::getXPos(), IsValidIndex(), mCurrentCursorPos, mIconWidth, msFont, mTextEditIndex, and project.

Referenced by KeyDown(), and ShowContextMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalcHighlightXs()

void LabelTrackView::CalcHighlightXs	(	int *	x1,
		int *	x2
	)		const

private

Definition at line 719 of file LabelTrackView.cpp.

{
   wxMemoryDC dc;
 
   if (msFont.Ok()) {
      dc.SetFont(msFont);
   }
 
   int pos1 = mInitialCursorPos, pos2 = mCurrentCursorPos;
   if (pos1 > pos2)
      std::swap(pos1, pos2);
 
   const auto pTrack = FindLabelTrack();
   const auto &mLabels = pTrack->GetLabels();
   const auto &labelStruct = mLabels[mTextEditIndex];
 
   // find the left X pos of highlighted area
   getXPos(labelStruct, dc, x1, pos1);
   // find the right X pos of highlighted area
   getXPos(labelStruct, dc, x2, pos2);
}

References FindLabelTrack(), anonymous_namespace{LabelTrackView.cpp}::getXPos(), mCurrentCursorPos, mInitialCursorPos, msFont, mTextEditIndex, and anonymous_namespace{NoteTrack.cpp}::swap().

Referenced by Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculateFontHeight()

void LabelTrackView::calculateFontHeight ( wxDC & dc )

staticprivate

Definition at line 1010 of file LabelTrackView.cpp.

{
   int charDescent;
   int charLeading;
 
   // Calculate the width of the substring and add it to Xpos
   dc.GetTextExtent(wxT("(Test String)|[yp]"), NULL, &mFontHeight, &charDescent, &charLeading);
 
   // The cursor will have height charHeight.  We don't include the descender as
   // part of the height because for phonetic fonts this leads to cursors which are
   // too tall.  We don't include leading either - it is usually 0.
   // To make up for ignoring the descender height, we add one pixel above and below
   // using CursorExtraHeight so that the cursor is just a little taller than the
   // body of the characters.
   const int CursorExtraHeight=2;
   mFontHeight += CursorExtraHeight - (charLeading+charDescent);
}

References mFontHeight, and wxT().

Referenced by Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CaptureKey()

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

overrideprivatevirtual

Reimplemented from TrackPanelCell.

Definition at line 1408 of file LabelTrackView.cpp.

{
   event.Skip(!DoCaptureKey( *project, event ));
   return RefreshCode::RefreshNone;
}

References DoCaptureKey(), project, and RefreshCode::RefreshNone.

Here is the call graph for this function:

◆ Char()

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

overrideprivatevirtual

Reimplemented from TrackPanelCell.

Definition at line 1460 of file LabelTrackView.cpp.

{
   double bkpSel0 = viewInfo.selectedRegion.t0(),
      bkpSel1 = viewInfo.selectedRegion.t1();
   // Pass keystroke to labeltrack's handler and add to history if any
   // updates were done
 
   if (IsValidIndex(mTextEditIndex, *project) && !mTextEditIndex.IsModified()) {
      const auto pTrack = FindLabelTrack();
      const auto &mLabels = pTrack->GetLabels();
      auto labelStruct = mLabels[mTextEditIndex];
      auto &title = labelStruct.title;
      mUndoLabel = title;
   }
 
   if (DoChar( *project, viewInfo.selectedRegion, event )) {
      ProjectHistory::Get( *project ).PushState(XO("Modified Label"),
         XO("Label Edit"),
          mTextEditIndex.IsModified() ? UndoPush::CONSOLIDATE : UndoPush::NONE);
 
      mTextEditIndex.SetModified(true);
   }
 
   if (!mTextEditIndex.IsModified()) {
      mUndoLabel.clear();
   }
 
   // If selection modified, refresh
   // Otherwise, refresh track display if the keystroke was handled
   if (bkpSel0 != viewInfo.selectedRegion.t0() ||
      bkpSel1 != viewInfo.selectedRegion.t1())
      return RefreshCode::RefreshAll;
   else if (!event.GetSkipped())
      return RefreshCode::RefreshCell;
 
   return RefreshCode::RefreshNone;
}

References CONSOLIDATE, DoChar(), FindLabelTrack(), ProjectHistory::Get(), LabelTrackView::Index::IsModified(), IsValidIndex(), mTextEditIndex, mUndoLabel, NONE, project, ProjectHistory::PushState(), RefreshCode::RefreshAll, RefreshCode::RefreshCell, RefreshCode::RefreshNone, ViewInfo::selectedRegion, LabelTrackView::Index::SetModified(), NotifyingSelectedRegion::t0(), NotifyingSelectedRegion::t1(), title, and XO().

Here is the call graph for this function:

◆ ComputeLayout()

void LabelTrackView::ComputeLayout	(	const wxRect &	r,
		const ZoomInfo &	zoomInfo
	)		const

private

ComputeLayout determines which row each label should be placed on, and reserves space for it. Function assumes that the labels are sorted.

Definition at line 427 of file LabelTrackView.cpp.

{
   int xUsed[MAX_NUM_ROWS];
 
   int iRow;
   // Rows are the 'same' height as icons or as the text,
   // whichever is taller.
   const int yRowHeight = wxMax(mTextHeight,mIconHeight)+3;// pixels.
   // Extra space at end of rows.
   // We allow space for one half icon at the start and two
   // half icon widths for extra x for the text frame.
   // [we don't allow half a width space for the end icon since it is
   // allowed to be obscured by the text].
   const int xExtra= (3 * mIconWidth)/2;
 
   const int nRows = wxMin((r.height / yRowHeight) + 1, MAX_NUM_ROWS);
   // Initially none of the rows have been used.
   // So set a value that is less than any valid value.
   {
      // Bug 502: With dragging left of zeros, labels can be in 
      // negative space.  So set least possible value as starting point.
      const int xStart = INT_MIN;
      for (auto &x : xUsed)
         x = xStart;
   }
   int nRowsUsed=0;
 
   const auto pTrack = FindLabelTrack();
   const auto &mLabels = pTrack->GetLabels();
 
   { int i = -1; for (const auto &labelStruct : mLabels) { ++i;
      const int x = zoomInfo.TimeToPosition(labelStruct.getT0(), r.x);
      const int x1 = zoomInfo.TimeToPosition(labelStruct.getT1(), r.x);
      int y = r.y;
 
      labelStruct.x=x;
      labelStruct.x1=x1;
      labelStruct.y=-1;// -ve indicates nothing doing.
      iRow=0;
      // Our first preference is a row that ends where we start.
      // (This is to encourage merging of adjacent label boundaries).
      while( (iRow<nRowsUsed) && (xUsed[iRow] != x ))
         iRow++;
 
      // IF we didn't find one THEN
      // find any row that can take a span starting at x.
      if( iRow >= nRowsUsed )
      {
         iRow=0;
         while( (iRow<nRows) && (xUsed[iRow] > x ))
            iRow++;
      }
      // IF we found such a row THEN record a valid position.
      if( iRow<nRows )
      {
         // Possibly update the number of rows actually used.
         if( iRow >= nRowsUsed )
            nRowsUsed=iRow+1;
         // Record the position for this label
         y= r.y + iRow * yRowHeight +(yRowHeight/2)+1;
         labelStruct.y=y;
         // On this row we have used up to max of end marker and width.
         // Plus also allow space to show the start icon and
         // some space for the text frame.
         xUsed[iRow]=x+labelStruct.width+xExtra;
         if( xUsed[iRow] < x1 ) xUsed[iRow]=x1;
         ComputeTextPosition( r, i );
      }
   }}
}

References ComputeTextPosition(), FindLabelTrack(), MAX_NUM_ROWS, mIconHeight, mIconWidth, mTextHeight, and ZoomInfo::TimeToPosition().

Referenced by Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeTextPosition()

void LabelTrackView::ComputeTextPosition	(	const wxRect &	r,
		int	index
	)		const

private

Restore focus to this track when done editing

ComputeTextPosition is 'smart' about where to display the label text.

The text must be displayed between its endpoints x and x1 We'd also like it centered between them, and we'd like it on screen. It isn't always possible to achieve all of this, so we do the best we can.

This function has a number of tests and adjustments to the text start position. The tests later in the function will take priority over the ones earlier, so because centering is the first thing we do, it's the first thing we lose if we can't do everything we want to.

Definition at line 280 of file LabelTrackView.cpp.

{
   const auto pTrack = FindLabelTrack();
   const auto &mLabels = pTrack->GetLabels();
 
   const auto &labelStruct = mLabels[index];
 
   // xExtra is extra space
   // between the text and the endpoints.
   const int xExtra=mIconWidth;
   int x     = labelStruct.x;  // left endpoint
   int x1    = labelStruct.x1; // right endpoint.
   int width = labelStruct.width;
 
   int xText; // This is where the text will end up.
 
   // Will the text all fit at this zoom?
   bool bTooWideForScreen = width > (r.width-2*xExtra);
// bool bSimpleCentering = !bTooWideForScreen;
   bool bSimpleCentering = false;
 
   //TODO (possibly):
   // Add configurable options as to when to use simple
   // and when complex centering.
   //
   // Simple centering does its best to keep the text
   // centered between the label limits.
   //
   // Complex centering positions the text proportionally
   // to how far we are through the label.
   //
   // If we add preferences for this, we want to be able to
   // choose separately whether:
   //   a) Wide text labels centered simple/complex.
   //   b) Other text labels centered simple/complex.
   //
 
   if( bSimpleCentering )
   {
      // Center text between the two end points.
      xText = (x+x1-width)/2;
   }
   else
   {
      // Calculate xText position to make text line
      // scroll sideways evenly as r moves right.
 
      // xText is a linear function of r.x.
      // These variables are used to compute that function.
      int rx0,rx1,xText0,xText1;
 
      // Since we will be using a linear function,
      // we should blend smoothly between left and right
      // aligned text as r, the 'viewport' moves.
      if( bTooWideForScreen )
      {
         rx0=x;           // when viewport at label start.
         xText0=x+xExtra; // text aligned left.
         rx1=x1-r.width;  // when viewport end at label end
         xText1=x1-(width+xExtra); // text aligned right.
      }
      else
      {
         // when label start + width + extra spacing at viewport end..
         rx0=x-r.width+width+2*xExtra;
         // ..text aligned left.
         xText0=x+xExtra;
         // when viewport start + width + extra spacing at label end..
         rx1=x1-(width+2*xExtra);
         // ..text aligned right.
         xText1=x1-(width+xExtra);
      }
 
      if( rx1 > rx0 ) // Avoid divide by zero case.
      {
         // Compute the blend between left and right aligned.
 
         // Don't use:
         //
         // xText = xText0 + ((xText1-xText0)*(r.x-rx0))/(rx1-rx0);
         //
         // The problem with the above is that it integer-oveflows at
         // high zoom.
 
         // Instead use:
         xText = xText0 + (int)((xText1-xText0)*(((float)(r.x-rx0))/(rx1-rx0)));
      }
      else
      {
         // Avoid divide by zero by reverting to
         // simple centering.
         //
         // We could also fall into this case if x and x1
         // are swapped, in which case we'll end up
         // left aligned anyway because code later on
         // will catch that.
         xText = (x+x1-width)/2;
      }
   }
 
   // Is the text now appearing partly outside r?
   bool bOffLeft = xText < r.x+xExtra;
   bool bOffRight = xText > r.x+r.width-width-xExtra;
 
   // IF any part of the text is offscreen
   // THEN we may bring it back.
   if( bOffLeft == bOffRight )
   {
      //IF both sides on screen, THEN nothing to do.
      //IF both sides off screen THEN don't do
      //anything about it.
      //(because if we did, you'd never get to read
      //all the text by scrolling).
   }
   else if( bOffLeft != bTooWideForScreen)
   {
      // IF we're off on the left, OR we're
      // too wide for the screen and off on the right
      // (only) THEN align left.
      xText = r.x+xExtra;
   }
   else
   {
      // We're off on the right, OR we're
      // too wide and off on the left (only)
      // SO align right.
      xText =r.x+r.width-width-xExtra;
   }
 
   // But if we've taken the text out from its endpoints
   // we must move it back so that it's between the endpoints.
 
   // We test the left end point last because the
   // text might not even fit between the endpoints (at this
   // zoom factor), and in that case we'd like to position
   // the text at the left end point.
   if( xText > (x1-width-xExtra))
      xText=(x1-width-xExtra);
   if( xText < x+xExtra )
      xText=x+xExtra;
 
   labelStruct.xText = xText;
}

References FindLabelTrack(), and mIconWidth.

Referenced by ComputeLayout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopySelectedText()

bool LabelTrackView::CopySelectedText ( AudacityProject & project )

Copy the selected text in the text box

Returns: true if text is selected in text box, false otherwise

Definition at line 1099 of file LabelTrackView.cpp.

{
   if (!IsTextSelected(project))
      return false;
 
   const auto pTrack = FindLabelTrack();
   const auto &mLabels = pTrack->GetLabels();
 
   const auto &labelStruct = mLabels[mTextEditIndex];
 
   int init = mInitialCursorPos;
   int cur = mCurrentCursorPos;
   if (init > cur)
      std::swap(init, cur);
 
   if (init == cur)
      return false;
 
   // data for copying
   wxString data = labelStruct.title.Mid(init, cur-init);
 
   // copy the data on clipboard
   if (wxTheClipboard->Open()) {
      // Clipboard owns the data you give it
      wxTheClipboard->SetData(safenew wxTextDataObject(data));
      wxTheClipboard->Close();
   }
 
   return true;
}

References FindLabelTrack(), IsTextSelected(), mCurrentCursorPos, mInitialCursorPos, mTextEditIndex, project, safenew, and anonymous_namespace{NoteTrack.cpp}::swap().

Referenced by OnContextMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopyTo()

void LabelTrackView::CopyTo	(	Track &	track,
		size_t	iChannel
	)		const

overrideprivatevirtual

Copy state, for undo/redo purposes.

Parameters

iChannel position of the attachment's channel in the group The default does nothing

Reimplemented from ChannelAttachment.

Definition at line 146 of file LabelTrackView.cpp.

{
   assert(iChannel == 0);
   ChannelView::CopyTo(track, iChannel);
   auto &other = ChannelView::Get(*track.GetChannel(0));
   if (const auto pOther = dynamic_cast<const LabelTrackView*>(&other)) {
      pOther->mNavigationIndex = mNavigationIndex;
      pOther->mInitialCursorPos = mInitialCursorPos;
      pOther->mCurrentCursorPos = mCurrentCursorPos;
      pOther->mTextEditIndex = mTextEditIndex;
      pOther->mUndoLabel = mUndoLabel;
   }
}

References ChannelView::CopyTo(), ChannelView::Get(), ChannelGroup::GetChannel(), anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, mCurrentCursorPos, mInitialCursorPos, mNavigationIndex, mTextEditIndex, and mUndoLabel.

Here is the call graph for this function:

◆ CreateCustomGlyphs()

void LabelTrackView::CreateCustomGlyphs ( )

private

CreateCustomGlyphs() creates the mBoundaryGlyph array. It's a bit like painting by numbers!

Schematically the glyphs we want will 'look like': <O, O> and <O> for a left boundary to a label, a right boundary and both. we're creating all three glyphs using the one Xpm Spec.

When we hover over a glyph we highlight the inside of either the '<', the 'O' or the '>' or none, giving 3 x 4 = 12 combinations.

Two of those combinations aren't used, but treating them specially would make other code more complicated.

Definition at line 2211 of file LabelTrackView.cpp.

{
   int iConfig;
   int iHighlight;
   int index;
   const int nSpecRows =
      sizeof( GlyphXpmRegionSpec )/sizeof( GlyphXpmRegionSpec[0]);
   const char *XmpBmp[nSpecRows];
 
   // The glyphs are declared static wxIcon; so we only need
   // to create them once, no matter how many LabelTracks.
   if( mbGlyphsReady )
      return;
 
   // We're about to tweak the basic color spec to get 12 variations.
   for( iConfig=0;iConfig<NUM_GLYPH_CONFIGS;iConfig++)
   {
      for( iHighlight=0;iHighlight<NUM_GLYPH_HIGHLIGHTS;iHighlight++)
      {
         index = iConfig + NUM_GLYPH_CONFIGS * iHighlight;
         // Copy the basic spec...
         memcpy( XmpBmp, GlyphXpmRegionSpec, sizeof( GlyphXpmRegionSpec ));
         // The highlighted region (if any) is white...
         if( iHighlight==1 ) XmpBmp[5]="5 c #FFFFFF";
         if( iHighlight==2 ) XmpBmp[6]="6 c #FFFFFF";
         if( iHighlight==3 ) XmpBmp[7]="7 c #FFFFFF";
         // For left or right arrow the other side of the glyph
         // is the transparent color.
         if( iConfig==0) { XmpBmp[3]="3 c none"; XmpBmp[5]="5 c none"; }
         if( iConfig==1) { XmpBmp[4]="4 c none"; XmpBmp[7]="7 c none"; }
         // Create the icon from the tweaked spec.
         mBoundaryGlyphs[index] = wxBitmap(XmpBmp);
         // Create the mask
         // SetMask takes ownership
         mBoundaryGlyphs[index].SetMask(safenew wxMask(mBoundaryGlyphs[index], wxColour(192, 192, 192)));
      }
   }
 
   mIconWidth  = mBoundaryGlyphs[0].GetWidth();
   mIconHeight = mBoundaryGlyphs[0].GetHeight();
   mTextHeight = mIconHeight; // until proved otherwise...
   // The icon should have an odd width so that the
   // line goes exactly down the middle.
   wxASSERT( (mIconWidth %2)==1);
 
   mbGlyphsReady=true;
}

References GlyphXpmRegionSpec, mbGlyphsReady, mBoundaryGlyphs, mIconHeight, mIconWidth, mTextHeight, NUM_GLYPH_CONFIGS, NUM_GLYPH_HIGHLIGHTS, and safenew.

Referenced by LabelTrackView().

Here is the caller graph for this function:

◆ CutSelectedText()

bool LabelTrackView::CutSelectedText ( AudacityProject & project )

Cut the selected text in the text box

Returns: true if text is selected in text box, false otherwise

Definition at line 1046 of file LabelTrackView.cpp.

{
   if (!IsTextSelected( project ))
      return false;
 
   const auto pTrack = FindLabelTrack();
   const auto &mLabels = pTrack->GetLabels();
 
   wxString left, right;
   auto labelStruct = mLabels[mTextEditIndex];
   auto &text = labelStruct.title;
 
   if (!mTextEditIndex.IsModified()) {
      mUndoLabel = text;
   }
 
   int init = mInitialCursorPos;
   int cur = mCurrentCursorPos;
   if (init > cur)
      std::swap(init, cur);
 
   // data for cutting
   wxString data = text.Mid(init, cur - init);
 
   // get left-remaining text
   if (init > 0)
      left = text.Left(init);
 
   // get right-remaining text
   if (cur < (int)text.length())
      right = text.Mid(cur);
 
   // set title to the combination of the two remainders
   text = left + right;
 
   pTrack->SetLabel( mTextEditIndex, labelStruct );
 
   // copy data onto clipboard
   if (wxTheClipboard->Open()) {
      // Clipboard owns the data you give it
      wxTheClipboard->SetData(safenew wxTextDataObject(data));
      wxTheClipboard->Close();
   }
 
   // set cursor positions
   mInitialCursorPos = mCurrentCursorPos = left.length();
 
   mTextEditIndex.SetModified(true);
   return true;
}

References FindLabelTrack(), LabelTrackView::Index::IsModified(), IsTextSelected(), mCurrentCursorPos, mInitialCursorPos, mTextEditIndex, mUndoLabel, project, safenew, LabelTrackView::Index::SetModified(), and anonymous_namespace{NoteTrack.cpp}::swap().

Referenced by OnContextMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeletedLabel()

void LabelTrackView::DeletedLabel ( int index )

◆ DetailedHitTest()

std::vector< UIHandlePtr > LabelTrackView::DetailedHitTest	(	const TrackPanelMouseState &	state,
		const AudacityProject *	pProject,
		int	currentTool,
		bool	bMultiTool
	)

overrideprivatevirtual

Implements CommonChannelView.

Definition at line 180 of file LabelTrackView.cpp.

{
   UIHandlePtr result;
   std::vector<UIHandlePtr> results;
   const wxMouseState &state = st.state;
 
   const auto pTrack = FindLabelTrack();
   result = LabelGlyphHandle::HitTest(
      mGlyphHandle, state, pTrack, st.rect);
   if (result)
      results.push_back(result);
 
   result = LabelTextHandle::HitTest(
      mTextHandle, state, pTrack);
   if (result)
      results.push_back(result);
 
   return results;
}

References FindLabelTrack(), LabelGlyphHandle::HitTest(), LabelTextHandle::HitTest(), mGlyphHandle, mTextHandle, TrackPanelMouseState::rect, and TrackPanelMouseState::state.

Here is the call graph for this function:

◆ DialogForLabelName()

int LabelTrackView::DialogForLabelName	(	AudacityProject &	project,
		const SelectedRegion &	region,
		const wxString &	initialValue,
		wxString &	value
	)

static

Definition at line 2285 of file LabelTrackView.cpp.

{
   auto &trackFocus = TrackFocus::Get( project );
   auto &trackPanel = TrackPanel::Get( project );
   auto &viewInfo = ViewInfo::Get( project );
 
   wxPoint position =
      trackPanel.FindTrackRect( trackFocus.Get() ).GetBottomLeft();
   // The start of the text in the text box will be roughly in line with the label's position
   // if it's a point label, or the start of its region if it's a region label.
   position.x += viewInfo.GetLeftOffset()
      + std::max(0, static_cast<int>(viewInfo.TimeToPosition(region.t0())))
      - 39;
   position.y += 2;  // just below the bottom of the track
   position = trackPanel.ClientToScreen(position);
   auto &window = GetProjectFrame(project);
   AudacityTextEntryDialog dialog{ &window,
      XO("Name:"),
      XO("New label"),
      initialValue,
      wxOK | wxCANCEL,
      position };
 
   // keep the dialog within Audacity's window, so that the dialog is always fully visible
   wxRect dialogScreenRect = dialog.GetScreenRect();
   wxRect projScreenRect = window.GetScreenRect();
   wxPoint max = projScreenRect.GetBottomRight() + wxPoint{ -dialogScreenRect.width, -dialogScreenRect.height };
   if (dialogScreenRect.x > max.x) {
      position.x = max.x;
      dialog.Move(position);
   }
   if (dialogScreenRect.y > max.y) {
      position.y = max.y;
      dialog.Move(position);
   }
 
   dialog.SetInsertionPointEnd();      // because, by default, initial text is selected
   int status = dialog.ShowModal();
   if (status != wxID_CANCEL) {
      value = dialog.GetValue();
      value.Trim(true).Trim(false);
   }
 
   return status;
}

References TrackFocus::Get(), ViewInfo::Get(), TrackPanel::Get(), ZoomInfo::GetLeftOffset(), GetProjectFrame(), project, SelectedRegion::t0(), ZoomInfo::TimeToPosition(), and XO().

Referenced by anonymous_namespace{LabelMenus.cpp}::DoAddLabel(), and DoChar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoCaptureKey()

bool LabelTrackView::DoCaptureKey	(	AudacityProject &	project,
		wxKeyEvent &	event
	)

Definition at line 1339 of file LabelTrackView.cpp.

{
   int mods = event.GetModifiers();
   auto code = event.GetKeyCode();
   const auto pTrack = FindLabelTrack();
   const auto& mLabels = pTrack->GetLabels();
 
   // Allow hardcoded Ctrl+F2 for renaming the selected label,
   // if we have any labels
   if (code == WXK_F2 && mods == wxMOD_CONTROL && !mLabels.empty()) {
      return true;
   }
 
   // Check for modifiers and only allow shift
   if (mods != wxMOD_NONE && mods != wxMOD_SHIFT) {
      return false;
   }
 
   // Always capture the navigation keys, if we have any labels
   if ((code == WXK_TAB || code == WXK_NUMPAD_TAB) &&
       !mLabels.empty())
      return true;
 
   if (IsValidIndex(mTextEditIndex, project)) {
      if (IsGoodLabelEditKey(event)) {
         return true;
      }
   }
   else {
      bool typeToCreateLabel;
      gPrefs->Read(wxT("/GUI/TypeToCreateLabel"), &typeToCreateLabel, false);
      if (IsGoodLabelFirstKey(event) && typeToCreateLabel) {
 
 
// The commented out code can prevent label creation, causing bug 1551
// We should only be in DoCaptureKey IF this label track has focus,
// and in that case creating a Label is the expected/intended thing.
#if 0
         // If we're playing, don't capture if the selection is the same as the
         // playback region (this helps prevent label track creation from
         // stealing unmodified kbd. shortcuts)
         auto gAudioIO = AudioIOBase::Get();
         if (pProj->GetAudioIOToken() > 0 &&
               gAudioIO->IsStreamActive(pProj->GetAudioIOToken()))
         {
            double t0, t1;
            pProj->GetPlayRegion(&t0, &t1);
            if (pProj->mViewInfo.selectedRegion.t0() == t0 &&
                pProj->mViewInfo.selectedRegion.t1() == t1) {
               return false;
            }
         }
#endif
 
         // If there's a label there already don't capture
         auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
         if( GetLabelIndex(selectedRegion.t0(),
                           selectedRegion.t1()) != wxNOT_FOUND ) {
            return false;
         }
 
         return true;
      }
   }
 
   return false;
}

References FindLabelTrack(), AudioIOBase::Get(), ViewInfo::Get(), GetLabelIndex(), gPrefs, IsGoodLabelEditKey(), IsGoodLabelFirstKey(), IsValidIndex(), mTextEditIndex, project, audacity::BasicSettings::Read(), ViewInfo::selectedRegion, and wxT().

Referenced by CaptureKey().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoChar()

bool LabelTrackView::DoChar	(	AudacityProject &	project,
		NotifyingSelectedRegion &	sel,
		wxKeyEvent &	event
	)

OnChar is called for incoming characters – that's any keypress not handled by OnKeyDown.

Definition at line 1791 of file LabelTrackView.cpp.

{
   // Check for modifiers and only allow shift.
   //
   // We still need to check this or we will eat the top level menu accelerators
   // on Windows if our capture or key down handlers skipped the event.
   const int mods = event.GetModifiers();
   if (mods != wxMOD_NONE && mods != wxMOD_SHIFT) {
      event.Skip();
      return false;
   }
 
   // Only track true changes to the label
   //bool updated = false;
 
   // Cache the character
   wxChar charCode = event.GetUnicodeKey();
 
   // Skip if it's not a valid unicode character or a control character
   if (charCode == 0 || wxIscntrl(charCode)) {
      event.Skip();
      return false;
   }
   
   // If we've reached this point and aren't currently editing, add NEW label
   const auto pTrack = FindLabelTrack();
   if (!IsValidIndex(mTextEditIndex, project)) {
      // Don't create a NEW label for a space
      if (wxIsspace(charCode)) {
         event.Skip();
         return false;
      }
      bool useDialog;
      gPrefs->Read(wxT("/GUI/DialogForNameNewLabel"), &useDialog, false);
      auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
      if (useDialog) {
         wxString title;
         if (DialogForLabelName(
            project, selectedRegion, charCode, title) ==
             wxID_CANCEL) {
            return false;
         }
         pTrack->SetSelected(true);
         pTrack->AddLabel(selectedRegion, title);
         ProjectHistory::Get( project )
            .PushState(XO("Added label"), XO("Label"));
         return false;
      }
      else {
         pTrack->SetSelected(true);
         AddLabel( selectedRegion );
         ProjectHistory::Get( project )
            .PushState(XO("Added label"), XO("Label"));
      }
   }
 
   if (!IsValidIndex(mTextEditIndex, project))
      return false;
 
   //
   // Now we are definitely in a label; append the incoming character
   //
 
   // Test if cursor is in the end of string or not
   if (mInitialCursorPos != mCurrentCursorPos)
      RemoveSelectedText();
 
   const auto& mLabels = pTrack->GetLabels();
   auto labelStruct = mLabels[mTextEditIndex];
   auto& title = labelStruct.title;
 
   if (mCurrentCursorPos < (int)title.length()) {
      // Get substring on the righthand side of cursor
      wxString rightPart = title.Mid(mCurrentCursorPos);
      // Set title to substring on the lefthand side of cursor
      title = title.Left(mCurrentCursorPos);
      //append charcode
      title += charCode;
      //append the right part substring
      title += rightPart;
   }
   else
      //append charCode
      title += charCode;
 
   pTrack->SetLabel(mTextEditIndex, labelStruct );
 
   //moving cursor position forward
   mInitialCursorPos = ++mCurrentCursorPos;
   
   return true;
}

References AddLabel(), DialogForLabelName(), FindLabelTrack(), ProjectHistory::Get(), ViewInfo::Get(), gPrefs, IsValidIndex(), mCurrentCursorPos, mInitialCursorPos, mTextEditIndex, project, ProjectHistory::PushState(), audacity::BasicSettings::Read(), RemoveSelectedText(), ViewInfo::selectedRegion, title, wxT(), and XO().

Referenced by Char().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoEditLabels()

void LabelTrackView::DoEditLabels	(	AudacityProject &	project,
		LabelTrack *	lt = `nullptr`,
		int	index = `-1`
	)

static

Definition at line 2261 of file LabelTrackView.cpp.

{
   const auto &formats = ProjectNumericFormats::Get( project );
   auto format = formats.GetSelectionFormat(),
      freqFormat = formats.GetFrequencySelectionFormatName();
   auto &tracks = TrackList::Get( project );
   auto &viewInfo = ViewInfo::Get( project );
   auto &window = GetProjectFrame(project);
 
   LabelDialog dlg(&window, project, &tracks,
                   lt, index,
                   viewInfo,
                   format, freqFormat);
#ifdef __WXGTK__
   dlg.Raise();
#endif
 
   if (dlg.ShowModal() == wxID_OK) {
      ProjectHistory::Get( project )
         .PushState(XO("Edited labels"), XO("Label"));
   }
}

References anonymous_namespace{ExportPCM.cpp}::format, ProjectNumericFormats::Get(), ProjectHistory::Get(), ViewInfo::Get(), TrackList::Get(), GetProjectFrame(), project, ProjectHistory::PushState(), tracks, and XO().

Referenced by anonymous_namespace{LabelMenus.cpp}::OnEditLabels(), and ShowContextMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoGetVRulerControls()

std::shared_ptr< ChannelVRulerControls > LabelTrackView::DoGetVRulerControls ( )

overrideprivatevirtual

Implements ChannelView.

Definition at line 2341 of file LabelTrackView.cpp.

{
   return
      std::make_shared<LabelTrackVRulerControls>( shared_from_this() );
}

◆ DoKeyDown()

bool LabelTrackView::DoKeyDown	(	AudacityProject &	project,
		NotifyingSelectedRegion &	sel,
		wxKeyEvent &	event
	)

KeyEvent is called for every keypress when over the label track.

Definition at line 1500 of file LabelTrackView.cpp.

{
   // Only track true changes to the label
   bool updated = false;
 
   // Cache the keycode
   int keyCode = event.GetKeyCode();
   const int mods = event.GetModifiers();
 
   // Check for modifiers and only allow shift
   // except in the case of Ctrl + F2, so hardcoded Ctrl+F2 can
   // be used for renaming a label
   if ((keyCode != WXK_F2 && mods != wxMOD_NONE && mods != wxMOD_SHIFT)
      || (keyCode == WXK_F2 && mods != wxMOD_CONTROL)) {
      event.Skip();
      return updated;
   }
 
   // All editing keys are only active if we're currently editing a label
   const auto pTrack = FindLabelTrack();
   const auto &mLabels = pTrack->GetLabels();
   if (IsValidIndex(mTextEditIndex, project)) {
      // Do label text changes
      auto labelStruct = mLabels[mTextEditIndex];
      auto &title = labelStruct.title;
      wxUniChar wchar;
      bool more=true;
 
      switch (keyCode) {
 
      case WXK_BACK:
         {
            int len = title.length();
 
            //IF the label is not blank THEN get rid of a letter or letters according to cursor position
            if (len > 0)
            {
               // IF there are some highlighted letters, THEN DELETE them
               if (mInitialCursorPos != mCurrentCursorPos)
                  RemoveSelectedText();
               else
               {
                  // DELETE one codepoint leftwards
                  while ((mCurrentCursorPos > 0) && more) {
                     wchar = title.at( mCurrentCursorPos-1 );
                     title.erase(mCurrentCursorPos-1, 1);
                     mCurrentCursorPos--;
                     if( ((int)wchar > 0xDFFF) || ((int)wchar <0xDC00)){
                        pTrack->SetLabel(mTextEditIndex, labelStruct);
                        more = false;
                     }
                  }
               }
            }
            else
            {
               // ELSE no text in text box, so DELETE whole label.
               pTrack->DeleteLabel(mTextEditIndex);
               ResetTextSelection();
            }
            mInitialCursorPos = mCurrentCursorPos;
            updated = true;
         }
         break;
 
      case WXK_DELETE:
      case WXK_NUMPAD_DELETE:
         {
            int len = title.length();
 
            //If the label is not blank get rid of a letter according to cursor position
            if (len > 0)
            {
               // if there are some highlighted letters, DELETE them
               if (mInitialCursorPos != mCurrentCursorPos)
                  RemoveSelectedText();
               else
               {
                  // DELETE one codepoint rightwards
                  while ((mCurrentCursorPos < len) && more) {
                     wchar = title.at( mCurrentCursorPos );
                     title.erase(mCurrentCursorPos, 1);
                     if( ((int)wchar > 0xDBFF) || ((int)wchar <0xD800)){
                        pTrack->SetLabel(mTextEditIndex, labelStruct);
                        more = false;
                     }
                  }
               }
            }
            else
            {
               // DELETE whole label if no text in text box
               pTrack->DeleteLabel(mTextEditIndex);
               ResetTextSelection();
            }
            mInitialCursorPos = mCurrentCursorPos;
            updated = true;
         }
         break;
 
      case WXK_HOME:
      case WXK_NUMPAD_HOME:
         // Move cursor to beginning of label
         mCurrentCursorPos = 0;
         if (mods == wxMOD_SHIFT)
            ;
         else
            mInitialCursorPos = mCurrentCursorPos;
         break;
 
      case WXK_END:
      case WXK_NUMPAD_END:
         // Move cursor to end of label
         mCurrentCursorPos = (int)title.length();
         if (mods == wxMOD_SHIFT)
            ;
         else
            mInitialCursorPos = mCurrentCursorPos;
         break;
 
      case WXK_LEFT:
      case WXK_NUMPAD_LEFT:
         // Moving cursor left
         if (mods != wxMOD_SHIFT && mCurrentCursorPos != mInitialCursorPos)
            //put cursor to the left edge of selection
            mInitialCursorPos = mCurrentCursorPos =
               std::min(mInitialCursorPos, mCurrentCursorPos);
         else
         {
            while ((mCurrentCursorPos > 0) && more) {
               wchar = title.at(mCurrentCursorPos - 1);
               more = !(((int)wchar > 0xDFFF) || ((int)wchar < 0xDC00));
 
               --mCurrentCursorPos;
            }
            if (mods != wxMOD_SHIFT)
               mInitialCursorPos = mCurrentCursorPos;
         }
         
         break;
 
      case WXK_RIGHT:
      case WXK_NUMPAD_RIGHT:
         // Moving cursor right
         if(mods != wxMOD_SHIFT && mCurrentCursorPos != mInitialCursorPos)
            //put cursor to the right edge of selection
            mInitialCursorPos = mCurrentCursorPos =
               std::max(mInitialCursorPos, mCurrentCursorPos);
         else
         {
            while ((mCurrentCursorPos < (int)title.length()) && more) {
               wchar = title.at(mCurrentCursorPos);
               more = !(((int)wchar > 0xDBFF) || ((int)wchar < 0xD800));
 
               ++mCurrentCursorPos;
            }
            if (mods != wxMOD_SHIFT)
               mInitialCursorPos = mCurrentCursorPos;
         }
         break;
 
      case WXK_ESCAPE:
         if (mTextEditIndex.IsModified()) {
            title = mUndoLabel;
            pTrack->SetLabel(mTextEditIndex, labelStruct);
 
            ProjectHistory::Get( project ).PushState(XO("Modified Label"),
               XO("Label Edit"),
               mTextEditIndex.IsModified() ? UndoPush::CONSOLIDATE : UndoPush::NONE);
         }
 
      case WXK_RETURN:
      case WXK_NUMPAD_ENTER:
      case WXK_TAB:
         if (mRestoreFocus >= 0) {
            auto track = *TrackList::Get(project).Any()
               .begin().advance(mRestoreFocus);
            if (track)
               TrackFocus::Get( project ).Set(track);
            mRestoreFocus = -2;
         }
         SetNavigationIndex(mTextEditIndex);
         ResetTextSelection();
         break;
      case '\x10':   // OSX
      case WXK_MENU:
      case WXK_WINDOWS_MENU:
         ShowContextMenu( project );
         break;
 
      default:
         if (!IsGoodLabelEditKey(event)) {
            event.Skip();
         }
         break;
      }
   }
   else
   {
      // Do navigation
      switch (keyCode) {
 
      case WXK_ESCAPE:
          mNavigationIndex = -1;
          break;
      case WXK_TAB:
      case WXK_NUMPAD_TAB:
         if (!mLabels.empty()) {
            int len = (int) mLabels.size();
            // The case where the start of selection is the same as the
            // start of a label is handled separately so that if some labels
            // have the same start time, all labels are navigated.
            if (IsValidIndex(mNavigationIndex, project)
               && mLabels[mNavigationIndex].getT0() == newSel.t0())
            {
                if (event.ShiftDown()) {
                    --mNavigationIndex;
                }
                else {
                    ++mNavigationIndex;
                }
                mNavigationIndex = (mNavigationIndex + (int)mLabels.size()) % (int)mLabels.size();    // wrap round if necessary
            }
            else
            {
                if (event.ShiftDown()) {
                    //search for the first label starting from the end (and before selection)
                    mNavigationIndex = len - 1;
                    if (newSel.t0() > mLabels[0].getT0()) {
                        while (mNavigationIndex >= 0 &&
                            mLabels[mNavigationIndex].getT0() > newSel.t0()) {
                            --mNavigationIndex;
                        }
                    }
                }
                else {
                    //search for the first label starting from the beginning (and after selection)
                    mNavigationIndex = 0;
                    if (newSel.t0() < mLabels[len - 1].getT0()) {
                        while (mNavigationIndex < len &&
                            mLabels[mNavigationIndex].getT0() < newSel.t0()) {
                            ++mNavigationIndex;
                        }
                    }
                }
            }
 
            if (mNavigationIndex >= 0 && mNavigationIndex < len) {
               const auto &labelStruct = mLabels[mNavigationIndex];
               mCurrentCursorPos = labelStruct.title.length();
               mInitialCursorPos = mCurrentCursorPos;
               //Set the selection region to be equal to the selection bounds of the tabbed-to label.
               newSel = labelStruct.selectedRegion;
               Viewport::Get(project).ScrollIntoView(labelStruct.selectedRegion.t0());
               // message for screen reader
               /* i18n-hint:
                  String is replaced by the name of a label,
                  first number gives the position of that label in a sequence
                  of labels,
                  and the last number is the total number of labels in the sequence.
               */
               auto message = XO("%s %d of %d")
                  .Format(labelStruct.title, mNavigationIndex + 1, pTrack->GetNumLabels());
               TrackFocus::Get(project).MessageForScreenReader(message);
            }
            else {
               mNavigationIndex = -1;
            }
         }
         break;
      case WXK_F2:     // Must be Ctrl + F2 to have reached here
         // Hardcoded Ctrl+F2 activates editing of the label
         // pointed to by mNavigationIndex (if valid)
         if (IsValidIndex(mNavigationIndex, project)) {
             SetTextSelection(mNavigationIndex);
         }
         break;
      default:
         if (!IsGoodLabelFirstKey(event)) {
            event.Skip();
         }
         break;
      }
   }
 
   return updated;
}

References TrackList::Any(), CONSOLIDATE, FindLabelTrack(), TrackFocus::Get(), ProjectHistory::Get(), TrackList::Get(), Viewport::Get(), IsGoodLabelEditKey(), IsGoodLabelFirstKey(), LabelTrackView::Index::IsModified(), IsValidIndex(), mCurrentCursorPos, min(), mInitialCursorPos, mNavigationIndex, mRestoreFocus, mTextEditIndex, mUndoLabel, NONE, project, ProjectHistory::PushState(), RemoveSelectedText(), ResetTextSelection(), Viewport::ScrollIntoView(), SetNavigationIndex(), SetTextSelection(), ShowContextMenu(), NotifyingSelectedRegion::t0(), title, and XO().

Referenced by KeyDown().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Draw() [1/2]

void LabelTrackView::Draw	(	TrackPanelDrawingContext &	context,
		const wxRect &	r
	)		const

Draw calls other functions to draw the LabelTrack.

Parameters

dc	the device context
r	the LabelTrack rectangle.

Definition at line 765 of file LabelTrackView.cpp.

{
   auto &dc = context.dc;
   const auto artist = TrackArtist::Get( context );
   const auto &zoomInfo = *artist->pZoomInfo;
   const auto &pendingTracks = *artist->pPendingTracks;
 
   auto pHit = findHit( artist->parent );
 
   if(msFont.Ok())
      dc.SetFont(msFont);
 
   if (mFontHeight == -1)
      calculateFontHeight(dc);
 
   if (!FindChannel())
      return;
   const auto &track = static_cast<const LabelTrack&>(
      pendingTracks.SubstitutePendingChangedChannel(*FindChannel()));
   const auto &mLabels = track.GetLabels();
 
   TrackArt::DrawBackgroundWithSelection(context, r, track,
      AColor::labelSelectedBrush, AColor::labelUnselectedBrush,
      SyncLock::IsSelectedOrSyncLockSelected(track));
 
   wxCoord textWidth, textHeight;
 
   // Get the text widths.
   // TODO: Make more efficient by only re-computing when a
   // text label title changes.
   for (const auto &labelStruct : mLabels) {
      dc.GetTextExtent(labelStruct.title, &textWidth, &textHeight);
      labelStruct.width = textWidth;
   }
 
   // TODO: And this only needs to be done once, but we
   // do need the dc to do it.
   // We need to set mTextHeight to something sensible,
   // guarding against the case where there are no
   // labels or all are empty strings, which for example
   // happens with a NEW label track.
   mTextHeight = dc.GetFontMetrics().ascent + dc.GetFontMetrics().descent;
   const int yFrameHeight = mTextHeight + TextFramePadding * 2;
 
   ComputeLayout( r, zoomInfo );
   dc.SetTextForeground(theTheme.Colour( clrLabelTrackText));
   dc.SetBackgroundMode(wxTRANSPARENT);
   dc.SetBrush(AColor::labelTextNormalBrush);
   dc.SetPen(AColor::labelSurroundPen);
   int GlyphLeft;
   int GlyphRight;
   // Now we draw the various items in this order,
   // so that the correct things overpaint each other.
 
   // Draw vertical lines that show where the end positions are.
   for (const auto &labelStruct : mLabels)
      DrawLines( dc, labelStruct, r );
 
   // Draw the end glyphs.
   { int i = -1; for (const auto &labelStruct : mLabels) { ++i;
      GlyphLeft=0;
      GlyphRight=1;
      if( pHit && i == pHit->mMouseOverLabelLeft )
         GlyphLeft = (pHit->mEdge & 4) ? 6:9;
      if( pHit && i == pHit->mMouseOverLabelRight )
         GlyphRight = (pHit->mEdge & 4) ? 7:4;
      DrawGlyphs( dc, labelStruct, r, GlyphLeft, GlyphRight );
   }}
 
   auto &project = *artist->parent->GetProject();
 
   // Draw the label boxes.
   {
#ifdef EXPERIMENTAL_TRACK_PANEL_HIGHLIGHTING
      bool highlightTrack = false;
      auto target = dynamic_cast<LabelTextHandle*>(context.target.get());
      highlightTrack = target &&
         target->FindTrack().get() == FindTrack().get();
#endif
      int i = -1; for (const auto &labelStruct : mLabels) { ++i;
         bool highlight = false;
#ifdef EXPERIMENTAL_TRACK_PANEL_HIGHLIGHTING
         highlight = highlightTrack && target->GetLabelNum() == i;
#endif
         
         dc.SetBrush(mNavigationIndex == i || (pHit && pHit->mMouseOverLabel == i) 
            ? AColor::labelTextEditBrush : AColor::labelTextNormalBrush);
         DrawBar(dc, labelStruct, r);
 
         bool selected = mTextEditIndex == i;
 
         if (selected)
            dc.SetBrush(AColor::labelTextEditBrush);
         else if (highlight)
            dc.SetBrush(AColor::uglyBrush);
         else
            dc.SetBrush(AColor::labelTextNormalBrush);
         DrawTextBox(dc, labelStruct, r);
 
         dc.SetBrush(AColor::labelTextNormalBrush);
      }
   }
 
   // Draw highlights
   if ( (mInitialCursorPos != mCurrentCursorPos) && IsValidIndex(mTextEditIndex, project))
   {
      int xpos1, xpos2;
      CalcHighlightXs(&xpos1, &xpos2);
      DrawHighlight(dc, mLabels[mTextEditIndex],
         xpos1, xpos2, dc.GetFontMetrics().ascent + dc.GetFontMetrics().descent);
   }
 
   // Draw the text and the label boxes.
   { int i = -1; for (const auto &labelStruct : mLabels) { ++i;
      if(mTextEditIndex == i )
         dc.SetBrush(AColor::labelTextEditBrush);
      DrawText( dc, labelStruct, r );
      if(mTextEditIndex == i )
         dc.SetBrush(AColor::labelTextNormalBrush);
   }}
 
   // Draw the cursor, if there is one.
   if(mInitialCursorPos == mCurrentCursorPos && IsValidIndex(mTextEditIndex, project))
   {
      const auto &labelStruct = mLabels[mTextEditIndex];
      int xPos = labelStruct.xText;
 
      if( mCurrentCursorPos > 0)
      {
         // Calculate the width of the substring and add it to Xpos
         int partWidth;
         dc.GetTextExtent(labelStruct.title.Left(mCurrentCursorPos), &partWidth, NULL);
         xPos += partWidth;
      }
 
      wxPen currentPen = dc.GetPen();
      const int CursorWidth=2;
      currentPen.SetWidth(CursorWidth);
      const auto top = labelStruct.y - (LabelBarHeight + yFrameHeight) / 2 + (yFrameHeight - mFontHeight) / 2 + TextFrameYOffset;
      AColor::Line(dc,
                   xPos-1, top,
                   xPos-1, top + mFontHeight);
      currentPen.SetWidth(1);
   }
}

References CalcHighlightXs(), calculateFontHeight(), ThemeBase::Colour(), ComputeLayout(), TrackPanelDrawingContext::dc, TrackArt::DrawBackgroundWithSelection(), DrawBar(), DrawGlyphs(), DrawHighlight(), DrawLines(), DrawText(), DrawTextBox(), CommonChannelCell::FindChannel(), anonymous_namespace{LabelTrackView.cpp}::findHit(), CommonTrackPanelCell::FindTrack(), LabelTextHandle::FindTrack(), TrackArtist::Get(), LabelTrack::GetLabels(), SyncLock::IsSelectedOrSyncLockSelected(), IsValidIndex(), LabelBarHeight, AColor::labelSelectedBrush, AColor::labelSurroundPen, AColor::labelTextEditBrush, AColor::labelTextNormalBrush, AColor::labelUnselectedBrush, AColor::Line(), mCurrentCursorPos, mFontHeight, mInitialCursorPos, mNavigationIndex, msFont, mTextEditIndex, mTextHeight, project, TrackPanelDrawingContext::target, TextFramePadding, TextFrameYOffset, theTheme, and AColor::uglyBrush.

Referenced by Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Draw() [2/2]

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

overrideprivatevirtual

Reimplemented from TrackPanelDrawable.

Definition at line 912 of file LabelTrackView.cpp.

{
   if ( iPass == TrackArtist::PassTracks )
      Draw( context, rect );
   CommonChannelView::Draw(context, rect, iPass);
}

References Draw(), TrackPanelDrawable::Draw(), and TrackArtist::PassTracks.

Here is the call graph for this function:

◆ DrawBar()

void LabelTrackView::DrawBar	(	wxDC &	dc,
		const LabelStruct &	ls,
		const wxRect &	r
	)

staticprivate

Definition at line 645 of file LabelTrackView.cpp.

{
   //If y is positive then it is the center line for the
   //text we are about to draw.
   const int xBarShorten = mIconWidth + 4;
   auto& y = ls.y;
   if (y == -1)
     return;
 
   auto& x = ls.x;
   auto& x1 = ls.x1;
   const int xStart = wxMax(r.x, x + xBarShorten / 2);
   const int xEnd = wxMin(r.x + r.width, x1 - xBarShorten / 2);
   const int xWidth = xEnd - xStart;
 
   if ((xStart < (r.x + r.width)) && (xEnd > r.x) && (xWidth > 0))
   {
      wxRect bar(xStart, y - (LabelBarHeight - GetTextFrameHeight()) / 2,
         xWidth, LabelBarHeight);
      if (x1 > x + xBarShorten)
         dc.DrawRectangle(bar);
   }
}

References GetTextFrameHeight(), LabelBarHeight, mIconWidth, LabelStruct::x, LabelStruct::x1, and LabelStruct::y.

Referenced by Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DrawGlyphs()

void LabelTrackView::DrawGlyphs	(	wxDC &	dc,
		const LabelStruct &	ls,
		const wxRect &	r,
		int	GlyphLeft,
		int	GlyphRight
	)

staticprivate

DrawGlyphs draws the wxIcons at the start and end of a label.

Parameters

dc	the device context
r	the LabelTrack rectangle.

Definition at line 553 of file LabelTrackView.cpp.

{
   auto &y = ls.y;
 
   const int xHalfWidth=mIconWidth/2;
   const int yStart=y-mIconHeight/2+(mTextHeight+3)/2;
 
   // If y == -1, nothing to draw
   if( y == -1 )
      return;
 
   auto &x = ls.x;
   auto &x1 = ls.x1;
 
   if((x  >= r.x) && (x  <= (r.x+r.width)))
      dc.DrawBitmap(GetGlyph(GlyphLeft), x-xHalfWidth,yStart, true);
   // The extra test commented out here would suppress right hand markers
   // when they overlap the left hand marker (e.g. zoomed out) or to the left.
   if((x1 >= r.x) && (x1 <= (r.x+r.width)) /*&& (x1>x+mIconWidth)*/)
      dc.DrawBitmap(GetGlyph(GlyphRight), x1-xHalfWidth,yStart, true);
}

References GetGlyph(), mIconHeight, mIconWidth, mTextHeight, LabelStruct::x, LabelStruct::x1, and LabelStruct::y.

Referenced by Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DrawHighlight()

void LabelTrackView::DrawHighlight	(	wxDC &	dc,
		const LabelStruct &	ls,
		int	xPos1,
		int	xPos2,
		int	charHeight
	)

staticprivate

Draws text-selected region within the label.

Definition at line 670 of file LabelTrackView.cpp.

{
   const int yFrameHeight = mTextHeight + TextFramePadding * 2;
   
   dc.SetPen(*wxTRANSPARENT_PEN);
   wxBrush curBrush = dc.GetBrush();
   curBrush.SetColour(wxString(wxT("BLUE")));
   auto top = ls.y + TextFrameYOffset - (LabelBarHeight + yFrameHeight) / 2 + (yFrameHeight - charHeight) / 2;
   if (xPos1 < xPos2)
      dc.DrawRectangle(xPos1-1, top, xPos2-xPos1+1, charHeight);
   else
      dc.DrawRectangle(xPos2-1, top, xPos1-xPos2+1, charHeight);
}

References LabelBarHeight, mTextHeight, TextFramePadding, TextFrameYOffset, wxT(), and LabelStruct::y.

Referenced by Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DrawLines()

void LabelTrackView::DrawLines	(	wxDC &	dc,
		const LabelStruct &	ls,
		const wxRect &	r
	)

staticprivate

Draw vertical lines that go exactly through the position of the start or end of a label.

Parameters

dc	the device context
r	the LabelTrack rectangle.

Definition at line 502 of file LabelTrackView.cpp.

{
   auto &x = ls.x;
   auto &x1 = ls.x1;
   auto &y = ls.y;
 
   // Bug 2388 - Point label and range label can appear identical
   // If the start and end times are not actually the same, but they 
   // would appear so when drawn as lines at current zoom, be sure to draw 
   // two lines - i.e. displace the second line slightly.
   if (ls.getT0() != ls.getT1()) {
      if (x == x1)
         x1++;
   }
 
   // How far out from the centre line should the vertical lines
   // start, i.e. what is the y position of the icon?
   // We adjust this so that the line encroaches on the icon
   // slightly (there is white space in the design).
   const int yIconStart = y - (mIconHeight /2)+1+(mTextHeight+3)/2;
   const int yIconEnd   = yIconStart + mIconHeight-2;
 
   // If y is positive then it is the center line for the
   // Label.
   if( y >= 0 )
   {
      if((x  >= r.x) && (x  <= (r.x+r.width)))
      {
         // Draw line above and below left dragging widget.
         AColor::Line(dc, x, r.y,  x, yIconStart - 1);
         AColor::Line(dc, x, yIconEnd, x, r.y + r.height);
      }
      if((x1 >= r.x) && (x1 <= (r.x+r.width)))
      {
         // Draw line above and below right dragging widget.
         AColor::Line(dc, x1, r.y,  x1, yIconStart - 1);
         AColor::Line(dc, x1, yIconEnd, x1, r.y + r.height);
      }
   }
   else
   {
      // Draw the line, even though the widget is off screen
      AColor::Line(dc, x, r.y,  x, r.y + r.height);
      AColor::Line(dc, x1, r.y,  x1, r.y + r.height);
   }
}

References LabelStruct::getT0(), LabelStruct::getT1(), AColor::Line(), mIconHeight, mTextHeight, LabelStruct::x, LabelStruct::x1, and LabelStruct::y.

Referenced by Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DrawText()

void LabelTrackView::DrawText	(	wxDC &	dc,
		const LabelStruct &	ls,
		const wxRect &	r
	)

staticprivate

Draw the text of the label and also draw a long thin rectangle for its full extent from x to x1 and a rectangular frame behind the text itself.

Parameters

dc	the device context
r	the LabelTrack rectangle.

Definition at line 588 of file LabelTrackView.cpp.

{
   const int yFrameHeight = mTextHeight + TextFramePadding * 2;
   //If y is positive then it is the center line for the
   //text we are about to draw.
   //if it isn't, nothing to draw.
 
   auto &y = ls.y;
   if( y == -1 )
      return;
 
   // Draw frame for the text...
   // We draw it half an icon width left of the text itself.
   {
      auto &xText = ls.xText;
      const int xStart=wxMax(r.x,xText-mIconWidth/2);
      const int xEnd=wxMin(r.x+r.width,xText+ls.width+mIconWidth/2);
      const int xWidth = xEnd-xStart;
 
      if( (xStart < (r.x+r.width)) && (xEnd > r.x) && (xWidth>0))
      {
         // Now draw the text itself.
         auto pos = y - LabelBarHeight - yFrameHeight + TextFrameYOffset +
            (yFrameHeight - mFontHeight) / 2 + dc.GetFontMetrics().ascent;
         dc.DrawText(ls.title, xText, pos);
      }
   }
 
}

References LabelBarHeight, mFontHeight, mIconWidth, mTextHeight, TextFramePadding, TextFrameYOffset, LabelStruct::title, LabelStruct::width, LabelStruct::xText, and LabelStruct::y.

Referenced by Draw().

Here is the caller graph for this function:

◆ DrawTextBox()

void LabelTrackView::DrawTextBox	(	wxDC &	dc,
		const LabelStruct &	ls,
		const wxRect &	r
	)

staticprivate

Definition at line 618 of file LabelTrackView.cpp.

{
   // In drawing the bar and the frame, we compute the clipping
   // to the viewport ourselves.  Under Win98 the GDI does its
   // calculations in 16 bit arithmetic, and so gets it completely
   // wrong at higher zooms where the bar can easily be
   // more than 65536 pixels wide.
 
   // Draw bar for label extent...
   // We don't quite draw from x to x1 because we allow
   // half an icon width at each end.
    const auto textFrameHeight = GetTextFrameHeight();
    auto& xText = ls.xText;
    const int xStart = wxMax(r.x, xText - mIconWidth / 2);
    const int xEnd = wxMin(r.x + r.width, xText + ls.width + mIconWidth / 2);
    const int xWidth = xEnd - xStart;
 
    if ((xStart < (r.x + r.width)) && (xEnd > r.x) && (xWidth > 0))
    {
       wxRect frame(
          xStart, ls.y - (textFrameHeight + LabelBarHeight) / 2 + TextFrameYOffset,
          xWidth, textFrameHeight);
       dc.DrawRectangle(frame);
    }
}

References GetTextFrameHeight(), LabelBarHeight, mIconWidth, TextFrameYOffset, LabelStruct::width, LabelStruct::xText, and LabelStruct::y.

Referenced by Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindCursorPosition()

int LabelTrackView::FindCursorPosition	(	int	labelIndex,
		wxCoord	xPos
	)

convert pixel coordinate to character position in text box

uses GetTextExtent to find the character position corresponding to the x pixel position.

Definition at line 923 of file LabelTrackView.cpp.

{
   int result = -1;
   wxMemoryDC dc;
   if(msFont.Ok())
      dc.SetFont(msFont);
 
   // A bool indicator to see if set the cursor position or not
   bool finished = false;
   int charIndex = 1;
   int partWidth;
   int oneWidth;
   double bound;
   wxString subString;
 
   const auto pTrack = FindLabelTrack();
   const auto &mLabels = pTrack->GetLabels();
   const auto &labelStruct = mLabels[labelIndex];
   const auto &title = labelStruct.title;
   const int length = title.length();
   while (!finished && (charIndex < length + 1))
   {
      int unichar = (int)title.at( charIndex-1 );
      if( (0xDC00 <= unichar) && (unichar <= 0xDFFF)){
         charIndex++;
         continue;
      }
      subString = title.Left(charIndex);
      // Get the width of substring
      dc.GetTextExtent(subString, &partWidth, NULL);
 
      // Get the width of the last character
      dc.GetTextExtent(subString.Right(1), &oneWidth, NULL);
      bound = labelStruct.xText + partWidth - oneWidth * 0.5;
 
      if (xPos <= bound)
      {
         // Found
         result = charIndex - 1;
         finished = true;
      }
      else
      {
         // Advance
         charIndex++;
      }
   }
   if (!finished)
      // Cursor should be in the last position
      result = length;
 
   return result;
}

References FindLabelTrack(), msFont, and title.

Here is the call graph for this function:

◆ FindLabelTrack() [1/2]

std::shared_ptr< LabelTrack > LabelTrackView::FindLabelTrack ( )

private

Definition at line 170 of file LabelTrackView.cpp.

{
   return FindChannel<LabelTrack>();
}

Referenced by AddLabel(), CalcCursorX(), CalcHighlightXs(), Char(), ComputeLayout(), ComputeTextPosition(), CopySelectedText(), CutSelectedText(), DetailedHitTest(), DoCaptureKey(), DoChar(), DoKeyDown(), FindCursorPosition(), FindLabelTrack(), GetLabelIndex(), IsValidIndex(), KeyDown(), LabelTrackView(), OnContextMenu(), OnLabelAdded(), OnLabelDeleted(), OnLabelPermuted(), OnSelectionChange(), PasteSelectedText(), RemoveSelectedText(), Reparent(), SelectAllText(), and ShowContextMenu().

Here is the caller graph for this function:

◆ FindLabelTrack() [2/2]

std::shared_ptr< const LabelTrack > LabelTrackView::FindLabelTrack ( ) const

private

Definition at line 175 of file LabelTrackView.cpp.

{
   return const_cast<LabelTrackView*>(this)->FindLabelTrack();
}

References FindLabelTrack().

Here is the call graph for this function:

◆ Get() [1/2]

const LabelTrackView & LabelTrackView::Get ( const LabelTrack & track )

static

Definition at line 165 of file LabelTrackView.cpp.

{
   return static_cast<const LabelTrackView&>(ChannelView::Get(track));
}

References ChannelView::Get().

Here is the call graph for this function:

◆ Get() [2/2]

LabelTrackView & LabelTrackView::Get ( LabelTrack & track )

static

Definition at line 160 of file LabelTrackView.cpp.

{
   return static_cast<LabelTrackView&>(ChannelView::Get(track));
}

References ChannelView::Get().

Referenced by SetLabelCommand::Apply(), LabelDefaultClickHandle::Click(), anonymous_namespace{EditMenus.cpp}::CutCopyAvailableFlag(), anonymous_namespace{LabelMenus.cpp}::DoAddLabel(), anonymous_namespace{EditMenus.cpp}::DoPasteText(), LabelTextHandle::Drag(), LabelGlyphHandle::HandleGlyphClick(), LabelGlyphHandle::HandleGlyphDragRelease(), LabelTextHandle::HandleTextClick(), LabelTextHandle::HandleTextDragRelease(), LabelTrackShifter::HitTest(), anonymous_namespace{EditMenus.cpp}::OnCopy(), anonymous_namespace{EditMenus.cpp}::OnCut(), anonymous_namespace{LabelMenus.cpp}::OnPasteNewLabel(), SelectActions::Handler::OnSelectAll(), LabelDefaultClickHandle::RestoreState(), LabelDefaultClickHandle::SaveState(), and LabelDialog::TransferDataFromWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCurrentCursorPosition()

int LabelTrackView::GetCurrentCursorPosition ( ) const

inline

Definition at line 225 of file LabelTrackView.h.

225{ return mCurrentCursorPos; }

◆ GetFont()

wxFont LabelTrackView::GetFont	(	const wxString &	faceName,
		int	size = `DefaultFontSize`
	)

static

Definition at line 243 of file LabelTrackView.cpp.

{
   wxFontEncoding encoding;
   if (faceName.empty())
      encoding = wxFONTENCODING_DEFAULT;
   else
      encoding = wxFONTENCODING_SYSTEM;
   
   auto fontInfo = size == 0 ? wxFontInfo() : wxFontInfo(size);
   fontInfo
      .Encoding(encoding)
      .FaceName(faceName);
 
   return wxFont(fontInfo);
}

References size.

Referenced by LabelTrackMenuTable::OnSetFont(), and ResetFont().

Here is the caller graph for this function:

◆ GetGlyph()

wxBitmap & LabelTrackView::GetGlyph ( int i )

staticprivate

Definition at line 2151 of file LabelTrackView.cpp.

{
   return theTheme.Bitmap( i + bmpLabelGlyph0);
}

References ThemeBase::Bitmap(), and theTheme.

Referenced by DrawGlyphs().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetInitialCursorPosition()

int LabelTrackView::GetInitialCursorPosition ( ) const

inline

Definition at line 227 of file LabelTrackView.h.

227{ return mInitialCursorPos; }

◆ GetLabelIndex()

int LabelTrackView::GetLabelIndex	(	double	t,
		double	t1
	)

private

Definition at line 2045 of file LabelTrackView.cpp.

{
   //We'd have liked to have times in terms of samples,
   //because then we're doing an intrger comparison.
   //Never mind.  Instead we look for near enough.
   //This level of (in)accuracy is only a problem if we
   //deal with sounds in the MHz range.
   const double delta = 1.0e-7;
   const auto pTrack = FindLabelTrack();
   const auto &mLabels = pTrack->GetLabels();
   { int i = -1; for (const auto &labelStruct : mLabels) { ++i;
      if( fabs( labelStruct.getT0() - t ) > delta )
         continue;
      if( fabs( labelStruct.getT1() - t1 ) > delta )
         continue;
      return i;
   }}
 
   return wxNOT_FOUND;
}

References FindLabelTrack().

Referenced by DoCaptureKey().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetNavigationIndex()

int LabelTrackView::GetNavigationIndex ( AudacityProject & project ) const

Definition at line 1003 of file LabelTrackView.cpp.

{
    if (IsValidIndex(mNavigationIndex, project))
        return mNavigationIndex;
    return -1;
}

References IsValidIndex(), mNavigationIndex, and project.

Referenced by LabelTrackShifter::HitTest().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetTextEditIndex()

int LabelTrackView::GetTextEditIndex ( AudacityProject & project ) const

Definition at line 987 of file LabelTrackView.cpp.

{
    if (IsValidIndex(mTextEditIndex, project))
        return mTextEditIndex;
    return -1;
}

References IsValidIndex(), mTextEditIndex, and project.

Referenced by anonymous_namespace{EditMenus.cpp}::DoPasteText().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetTextFrameHeight()

int LabelTrackView::GetTextFrameHeight ( )

staticprivate

Definition at line 577 of file LabelTrackView.cpp.

{
    return mTextHeight + TextFramePadding * 2;
}

References mTextHeight, and TextFramePadding.

Referenced by DrawBar(), and DrawTextBox().

Here is the caller graph for this function:

◆ IsTextClipSupported()

bool LabelTrackView::IsTextClipSupported ( )

staticprivate

Returns: true if the text data is available in the clipboard, false otherwise

Definition at line 1202 of file LabelTrackView.cpp.

{
   return wxTheClipboard->IsSupported(wxDF_UNICODETEXT);
}

Referenced by PasteSelectedText(), and ShowContextMenu().

Here is the caller graph for this function:

◆ IsTextSelected()

bool LabelTrackView::IsTextSelected ( AudacityProject & project ) const

Definition at line 1039 of file LabelTrackView.cpp.

{
   return mCurrentCursorPos != mInitialCursorPos && IsValidIndex(mTextEditIndex, project);
}

References IsValidIndex(), mCurrentCursorPos, mInitialCursorPos, mTextEditIndex, and project.

Referenced by CopySelectedText(), anonymous_namespace{EditMenus.cpp}::CutCopyAvailableFlag(), CutSelectedText(), and ShowContextMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsValidIndex()

bool LabelTrackView::IsValidIndex	(	const Index &	index,
		AudacityProject &	project
	)		const

private

Definition at line 1028 of file LabelTrackView.cpp.

{
    if (index == -1)
       return false;
    // may make delayed update of mutable mSelIndex after track selection change
    auto track = FindLabelTrack();
    if (track->GetSelected() || (TrackFocus::Get(project).Get() == track.get()))
       return index >= 0 && index < static_cast<int>(track->GetLabels().size());
    return false;
}

References FindLabelTrack(), TrackFocus::Get(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get(), and project.

Referenced by CalcCursorX(), Char(), DoCaptureKey(), DoChar(), DoKeyDown(), Draw(), GetNavigationIndex(), GetTextEditIndex(), IsTextSelected(), KeyDown(), OnContextMenu(), PasteSelectedText(), SelectAllText(), and ShowContextMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ KeyDown()

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

overrideprivatevirtual

Reimplemented from TrackPanelCell.

Definition at line 1415 of file LabelTrackView.cpp.

{
   double bkpSel0 = viewInfo.selectedRegion.t0(),
      bkpSel1 = viewInfo.selectedRegion.t1();
 
   if (IsValidIndex(mTextEditIndex, *project) && !mTextEditIndex.IsModified()) {
      const auto pTrack = FindLabelTrack();
      const auto &mLabels = pTrack->GetLabels();
      auto labelStruct = mLabels[mTextEditIndex];
      auto &title = labelStruct.title;
      mUndoLabel = title;
   }
 
   // Pass keystroke to labeltrack's handler and add to history if any
   // updates were done
   if (DoKeyDown( *project, viewInfo.selectedRegion, event )) {
      ProjectHistory::Get( *project ).PushState(XO("Modified Label"),
         XO("Label Edit"),
         mTextEditIndex.IsModified() ? UndoPush::CONSOLIDATE : UndoPush::NONE);
 
      mTextEditIndex.SetModified(true);
   }
 
   if (!mTextEditIndex.IsModified()) {
      mUndoLabel.clear();
   }
 
   // Make sure caret is in view
   int x;
   if (CalcCursorX( *project, &x ))
      Viewport::Get(*project).ScrollIntoView(x);
 
   // If selection modified, refresh
   // Otherwise, refresh track display if the keystroke was handled
   if (bkpSel0 != viewInfo.selectedRegion.t0() ||
      bkpSel1 != viewInfo.selectedRegion.t1())
      return RefreshCode::RefreshAll;
   else if (!event.GetSkipped())
      return  RefreshCode::RefreshCell;
 
   return RefreshCode::RefreshNone;
}

References CalcCursorX(), CONSOLIDATE, DoKeyDown(), FindLabelTrack(), ProjectHistory::Get(), Viewport::Get(), LabelTrackView::Index::IsModified(), IsValidIndex(), mTextEditIndex, mUndoLabel, NONE, project, ProjectHistory::PushState(), RefreshCode::RefreshAll, RefreshCode::RefreshCell, RefreshCode::RefreshNone, Viewport::ScrollIntoView(), ViewInfo::selectedRegion, LabelTrackView::Index::SetModified(), NotifyingSelectedRegion::t0(), NotifyingSelectedRegion::t1(), title, and XO().

Here is the call graph for this function:

◆ OnContextMenu()

void LabelTrackView::OnContextMenu	(	AudacityProject &	project,
		wxCommandEvent &	evt
	)

private

Cut selected text if cut menu item is selected

Copy selected text if copy menu item is selected

paste selected text if paste menu item is selected

DELETE selected label

Definition at line 1958 of file LabelTrackView.cpp.

{
   auto &selectedRegion = ViewInfo::Get( project ).selectedRegion;
 
   switch (evt.GetId())
   {
   case OnCutSelectedTextID:
      if (CutSelectedText( project ))
      {
         ProjectHistory::Get( project ).PushState(XO("Modified Label"),
                      XO("Label Edit"),
                      mTextEditIndex.IsModified() ? UndoPush::CONSOLIDATE : UndoPush::NONE);
      }
      break;
 
   case OnCopySelectedTextID:
      CopySelectedText( project );
      break;
 
   case OnPasteSelectedTextID:
      if (PasteSelectedText(
         project, selectedRegion.t0(), selectedRegion.t1() ))
      {
         ProjectHistory::Get( project ).PushState(XO("Modified Label"),
                      XO("Label Edit"),
                      mTextEditIndex.IsModified() ? UndoPush::CONSOLIDATE : UndoPush::NONE);
      }
      break;
 
   case OnDeleteSelectedLabelID: {
      if (IsValidIndex(mTextEditIndex, project))
      {
         const auto pTrack = FindLabelTrack();
         pTrack->DeleteLabel(mTextEditIndex);
         ProjectHistory::Get( project ).PushState(XO("Deleted Label"),
                      XO("Label Edit"),
                      UndoPush::CONSOLIDATE);
      }
   }
      break;
 
   case OnEditSelectedLabelID: {
      // Bug #2571: See above
      if (IsValidIndex(mTextEditIndex, project))
         mEditIndex = mTextEditIndex;
   }
      break;
   }
}

References CONSOLIDATE, CopySelectedText(), CutSelectedText(), FindLabelTrack(), ProjectHistory::Get(), ViewInfo::Get(), LabelTrackView::Index::IsModified(), IsValidIndex(), mEditIndex, mTextEditIndex, NONE, OnCopySelectedTextID, OnCutSelectedTextID, OnDeleteSelectedLabelID, OnEditSelectedLabelID, OnPasteSelectedTextID, PasteSelectedText(), project, ProjectHistory::PushState(), ViewInfo::selectedRegion, and XO().

Referenced by ShowContextMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OnLabelAdded()

void LabelTrackView::OnLabelAdded ( const LabelTrackEvent & e )

private

Definition at line 2080 of file LabelTrackView.cpp.

{
   if (e.mpTrack.lock() != FindLabelTrack())
      return;
 
   const auto &title = e.mTitle;
   const auto pos = e.mPresentPosition;
 
   mInitialCursorPos = mCurrentCursorPos = title.length();
 
   // restoreFocus is -2 e.g. from Nyquist label creation, when we should not
   // even lose the focus and open the label to edit in the first place.
   // -1 means we don't need to restore it to anywhere.
   // 0 or above is the track to restore to after editing the label is complete.
   if( mRestoreFocus >= -1 )
       mTextEditIndex = pos;
 
   if( mRestoreFocus < 0 )
      mRestoreFocus = -2;
}

References FindLabelTrack(), mCurrentCursorPos, mInitialCursorPos, LabelTrackEvent::mPresentPosition, LabelTrackEvent::mpTrack, mRestoreFocus, mTextEditIndex, LabelTrackEvent::mTitle, and title.

Here is the call graph for this function:

◆ OnLabelDeleted()

void LabelTrackView::OnLabelDeleted ( const LabelTrackEvent & e )

private

Definition at line 2101 of file LabelTrackView.cpp.

{
   if (e.mpTrack.lock() != FindLabelTrack())
      return;
 
   auto index = e.mFormerPosition;
 
   // IF we've deleted the selected label
   // THEN set no label selected.
   if (mTextEditIndex == index)
      ResetTextSelection();
   
   // IF we removed a label before the selected label
   // THEN the NEW selected label number is one less.
   else if( index < mTextEditIndex)
      --mTextEditIndex;//NB: Keep cursor selection region
}

References FindLabelTrack(), LabelTrackEvent::mFormerPosition, LabelTrackEvent::mpTrack, mTextEditIndex, and ResetTextSelection().

Here is the call graph for this function:

◆ OnLabelPermuted()

void LabelTrackView::OnLabelPermuted ( const LabelTrackEvent & e )

private

Definition at line 2119 of file LabelTrackView.cpp.

{
   if (e.mpTrack.lock() != FindLabelTrack())
      return;
 
   auto former = e.mFormerPosition;
   auto present = e.mPresentPosition;
 
   auto fix = [&](Index& index) {
       if (index == former)
           index = present;
       else if (former < index && index <= present)
           --index;
       else if (former > index && index >= present)
           ++index;
   };
   fix(mNavigationIndex);
   fix(mTextEditIndex);
}

References FindLabelTrack(), LabelTrackEvent::mFormerPosition, mNavigationIndex, LabelTrackEvent::mPresentPosition, LabelTrackEvent::mpTrack, and mTextEditIndex.

Here is the call graph for this function:

◆ OnSelectionChange()

void LabelTrackView::OnSelectionChange ( const LabelTrackEvent & e )

private

Definition at line 2139 of file LabelTrackView.cpp.

{
   if (e.mpTrack.lock() != FindLabelTrack())
      return;
 
   if (!FindLabelTrack()->GetSelected())
   {
       SetNavigationIndex(-1);
       ResetTextSelection();
   }
}

References FindLabelTrack(), LabelTrackEvent::mpTrack, ResetTextSelection(), and SetNavigationIndex().

Here is the call graph for this function:

◆ operator=()

LabelTrackView & LabelTrackView::operator= ( const LabelTrackView & )

privatedelete

◆ OverATextBox()

int LabelTrackView::OverATextBox	(	const LabelTrack &	track,
		int	xx,
		int	yy
	)

static

Definition at line 1278 of file LabelTrackView.cpp.

{
   const auto pTrack = &track;
   const auto &mLabels = pTrack->GetLabels();
   for (int nn = (int)mLabels.size(); nn--;) {
      const auto &labelStruct = mLabels[nn];
      if ( OverTextBox( &labelStruct, xx, yy ) )
         return nn;
   }
 
   return -1;
}

References LabelTrack::GetLabels(), and OverTextBox().

Referenced by LabelTextHandle::HandleTextClick(), LabelTrackShifter::HitTest(), and LabelTextHandle::HitTest().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OverGlyph()

void LabelTrackView::OverGlyph	(	const LabelTrack &	track,
		LabelTrackHit &	hit,
		int	x,
		int	y
	)

static

TODO: Investigate what happens with large numbers of labels, might need a binary search rather than a linear one.

Definition at line 1210 of file LabelTrackView.cpp.

{
   //Determine the NEW selection.
   int result=0;
   const int d1=10; //distance in pixels, used for have we hit drag handle.
   const int d2=5;  //distance in pixels, used for have we hit drag handle center.
 
   //If not over a label, reset it
   hit.mMouseOverLabelLeft  = -1;
   hit.mMouseOverLabelRight = -1;
   hit.mMouseOverLabel = -1;
   hit.mEdge = 0;
 
   const auto pTrack = &track;
   const auto &mLabels = pTrack->GetLabels();
   { int i = -1; for (const auto &labelStruct : mLabels) { ++i;
      // give text box better priority for selecting
      // reset selection state
      if (OverTextBox(&labelStruct, x, y))
      {
         result = 0;
         hit.mMouseOverLabel = -1;
         hit.mMouseOverLabelLeft = -1;
         hit.mMouseOverLabelRight = -1;
         break;
      }
   
      //over left or right selection bound
      //Check right bound first, since it is drawn after left bound,
      //so give it precedence for matching/highlighting.
      if( abs(labelStruct.y - (y - (mTextHeight+3)/2)) < d1 &&
               abs(labelStruct.x1 - d2 -x) < d1)
      {
         hit.mMouseOverLabelRight = i;
         if(abs(labelStruct.x1 - x) < d2 )
         {
            result |= 4;
            // If left and right co-incident at this resolution, then we drag both.
            // We were more stringent about co-incidence here in the past.
            if( abs(labelStruct.x1-labelStruct.x) < 5.0 )
            {
               result |=1;
               hit.mMouseOverLabelLeft = i;
            }
         }
         result |= 2;
      }
      // Use else-if here rather than else to avoid detecting left and right
      // of the same label.
      else if(   abs(labelStruct.y - (y - (mTextHeight+3)/2)) < d1 &&
            abs(labelStruct.x + d2 - x) < d1 )
      {
         hit.mMouseOverLabelLeft = i;
         if(abs(labelStruct.x - x) < d2 )
            result |= 4;
         result |= 1;
      }
      else if (x >= labelStruct.x && x <= labelStruct.x1 &&
         abs(y - (labelStruct.y + mTextHeight / 2)) < d1)
      {
         hit.mMouseOverLabel = i;
         result = 3;
      }
   }}
   hit.mEdge = result;
}

References LabelTrack::GetLabels(), LabelTrackHit::mEdge, LabelTrackHit::mMouseOverLabel, LabelTrackHit::mMouseOverLabelLeft, LabelTrackHit::mMouseOverLabelRight, mTextHeight, and OverTextBox().

Referenced by LabelGlyphHandle::HandleGlyphClick(), and LabelGlyphHandle::HitTest().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OverTextBox()

bool LabelTrackView::OverTextBox	(	const LabelStruct *	pLabel,
		int	x,
		int	y
	)

static

Definition at line 1292 of file LabelTrackView.cpp.

{
   if( (pLabel->xText-(mIconWidth/2) < x) &&
            (x<pLabel->xText+pLabel->width+(mIconWidth/2)) &&
            (abs(pLabel->y-y)<mIconHeight/2))
   {
      return true;
   }
   return false;
}

References mIconHeight, mIconWidth, LabelStruct::width, LabelStruct::xText, and LabelStruct::y.

Referenced by LabelTextHandle::Drag(), LabelTextHandle::HandleTextClick(), LabelTextHandle::HandleTextDragRelease(), OverATextBox(), and OverGlyph().

Here is the caller graph for this function:

◆ PasteSelectedText()

bool LabelTrackView::PasteSelectedText	(	AudacityProject &	project,
		double	sel0,
		double	sel1
	)

Paste the text on the clipboard to text box

Returns: true if mouse is clicked in text box, false otherwise

Definition at line 1133 of file LabelTrackView.cpp.

{
   const auto pTrack = FindLabelTrack();
 
   if (!IsValidIndex(mTextEditIndex, project))
      SetTextSelection(AddLabel(SelectedRegion(sel0, sel1)));
 
   wxString text, left, right;
 
   // if text data is available
   if (IsTextClipSupported()) {
      if (wxTheClipboard->Open()) {
         wxTextDataObject data;
         wxTheClipboard->GetData(data);
         wxTheClipboard->Close();
         text = data.GetText();
      }
 
      if (!mTextEditIndex.IsModified()) {
         mUndoLabel = text;
      }
 
      // Convert control characters to blanks
      for (int i = 0; i < (int)text.length(); i++) {
         if (wxIscntrl(text[i])) {
            text[i] = wxT(' ');
         }
      }
   }
 
   const auto &mLabels = pTrack->GetLabels();
   auto labelStruct = mLabels[mTextEditIndex];
   auto &title = labelStruct.title;
   int cur = mCurrentCursorPos, init = mInitialCursorPos;
   if (init > cur)
      std::swap(init, cur);
   left = title.Left(init);
   if (cur < (int)title.length())
      right = title.Mid(cur);
 
   title = left + text + right;
 
   pTrack->SetLabel(mTextEditIndex, labelStruct );
 
   mInitialCursorPos =  mCurrentCursorPos = left.length() + text.length();
 
   mTextEditIndex.SetModified(true);
   return true;
}

References AddLabel(), FindLabelTrack(), LabelTrackView::Index::IsModified(), IsTextClipSupported(), IsValidIndex(), mCurrentCursorPos, mInitialCursorPos, mTextEditIndex, mUndoLabel, project, LabelTrackView::Index::SetModified(), SetTextSelection(), anonymous_namespace{NoteTrack.cpp}::swap(), title, and wxT().

Referenced by OnContextMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveSelectedText()

void LabelTrackView::RemoveSelectedText ( )

private

Definition at line 2013 of file LabelTrackView.cpp.

{
   wxString left, right;
 
   int init = mInitialCursorPos;
   int cur = mCurrentCursorPos;
   if (init > cur)
      std::swap(init, cur);
 
   const auto pTrack = FindLabelTrack();
   const auto &mLabels = pTrack->GetLabels();
   auto labelStruct = mLabels[mTextEditIndex];
   auto &title = labelStruct.title;
 
   if (init > 0)
      left = title.Left(init);
 
   if (cur < (int)title.length())
      right = title.Mid(cur);
 
   title = left + right;
   pTrack->SetLabel( mTextEditIndex, labelStruct );
   mInitialCursorPos = mCurrentCursorPos = left.length();
}

References FindLabelTrack(), mCurrentCursorPos, mInitialCursorPos, mTextEditIndex, anonymous_namespace{NoteTrack.cpp}::swap(), and title.

Referenced by DoChar(), and DoKeyDown().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Reparent()

void LabelTrackView::Reparent	(	const std::shared_ptr< Track > &	parent,
		size_t	iChannel
	)

overrideprivatevirtual

Object may be shared among tracks but hold a special back-pointer to one of them; reassign it.

Parameters

iChannel position of the attachment's channel in the group The default does nothing

Reimplemented from ChannelAttachment.

Definition at line 116 of file LabelTrackView.cpp.

{
   assert(iChannel == 0);
   auto oldParent = FindLabelTrack();
   auto newParent = track_cast<LabelTrack*>(parent.get());
   if (oldParent.get() != newParent)
      BindTo( newParent );
   CommonChannelView::Reparent(parent, iChannel);
}

References BindTo(), FindLabelTrack(), anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, and ChannelView::Reparent().

Here is the call graph for this function:

◆ ResetFlags()

void LabelTrackView::ResetFlags ( )

Definition at line 219 of file LabelTrackView.cpp.

{
   mInitialCursorPos = 1;
   mCurrentCursorPos = 1;
   mTextEditIndex = -1;
   mNavigationIndex = -1;
}

References mCurrentCursorPos, mInitialCursorPos, mNavigationIndex, and mTextEditIndex.

Referenced by LabelTrackView().

Here is the caller graph for this function:

◆ ResetFont()

void LabelTrackView::ResetFont ( )

static

Definition at line 259 of file LabelTrackView.cpp.

{
   mFontHeight = -1;
   wxString facename = gPrefs->Read(wxT("/GUI/LabelFontFacename"), wxT(""));
   int size = gPrefs->Read(wxT("/GUI/LabelFontSize"), static_cast<int>(DefaultFontSize));
   msFont = GetFont(facename, size);
}

References DefaultFontSize, GetFont(), gPrefs, mFontHeight, msFont, audacity::BasicSettings::Read(), size, and wxT().

Referenced by LabelTrackView(), and LabelTrackMenuTable::OnSetFont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ResetTextSelection()

void LabelTrackView::ResetTextSelection ( )

Definition at line 993 of file LabelTrackView.cpp.

{
    mTextEditIndex = -1;
    mCurrentCursorPos = 1;
    mInitialCursorPos = 1;
}

References mCurrentCursorPos, mInitialCursorPos, and mTextEditIndex.

Referenced by DoKeyDown(), OnLabelDeleted(), anonymous_namespace{LabelMenus.cpp}::OnPasteNewLabel(), OnSelectionChange(), and LabelDialog::TransferDataFromWindow().

Here is the caller graph for this function:

◆ RestoreFlags()

void LabelTrackView::RestoreFlags ( const Flags & flags )

Definition at line 235 of file LabelTrackView.cpp.

{
   mInitialCursorPos = flags.mInitialCursorPos;
   mCurrentCursorPos = flags.mCurrentCursorPos;
   mNavigationIndex = flags.mNavigationIndex;
   mTextEditIndex = flags.mTextEditIndex;
}

References LabelTrackView::Flags::mCurrentCursorPos, mCurrentCursorPos, LabelTrackView::Flags::mInitialCursorPos, mInitialCursorPos, LabelTrackView::Flags::mNavigationIndex, mNavigationIndex, LabelTrackView::Flags::mTextEditIndex, and mTextEditIndex.

◆ SaveFlags()

LabelTrackView::Flags LabelTrackView::SaveFlags ( ) const

Definition at line 227 of file LabelTrackView.cpp.

{
   return {
      mInitialCursorPos, mCurrentCursorPos, mNavigationIndex,
      mTextEditIndex, mUndoLabel
   };
}

References mCurrentCursorPos, mInitialCursorPos, mNavigationIndex, mTextEditIndex, and mUndoLabel.

◆ SelectAllText()

bool LabelTrackView::SelectAllText ( AudacityProject & project )

Definition at line 1184 of file LabelTrackView.cpp.

{
    if (!IsValidIndex(mTextEditIndex, project))
        return false;
 
    const auto pTrack = FindLabelTrack();
 
    const auto& mLabels = pTrack->GetLabels();
    auto labelStruct = mLabels[mTextEditIndex];
    auto& title = labelStruct.title;
 
    mInitialCursorPos = 0;
    mCurrentCursorPos = title.Length();
 
    return true;
}

References FindLabelTrack(), IsValidIndex(), mCurrentCursorPos, mInitialCursorPos, mTextEditIndex, project, and title.

Here is the call graph for this function:

◆ SetCurrentCursorPosition()

void LabelTrackView::SetCurrentCursorPosition ( int pos )

Definition at line 977 of file LabelTrackView.cpp.

{
   mCurrentCursorPos = pos;
}

References mCurrentCursorPos.

◆ SetNavigationIndex()

void LabelTrackView::SetNavigationIndex ( int index )

Definition at line 999 of file LabelTrackView.cpp.

{
    mNavigationIndex = index;
}

References mNavigationIndex.

Referenced by DoKeyDown(), and OnSelectionChange().

Here is the caller graph for this function:

◆ SetTextSelection()

void LabelTrackView::SetTextSelection	(	int	labelIndex,
		int	start = `1`,
		int	end = `1`
	)

Sets the label with specified index for editing, optionally selection may be specified with [start, end]

Definition at line 981 of file LabelTrackView.cpp.

{
    mTextEditIndex = labelIndex;
    mInitialCursorPos = start;
    mCurrentCursorPos = end;
}

References details::end(), mCurrentCursorPos, mInitialCursorPos, and mTextEditIndex.

Referenced by DoKeyDown(), and PasteSelectedText().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ShowContextMenu()

void LabelTrackView::ShowContextMenu ( AudacityProject & project )

Definition at line 1895 of file LabelTrackView.cpp.

{
   wxWindow *parent = wxWindow::FindFocus();
 
   // Bug 2044.  parent can be nullptr after a context switch.
   if( !parent )
      parent = &GetProjectFrame(project);
 
   if( parent )
   {
      wxMenu menu;
      menu.Bind(wxEVT_MENU,
         [this, &project]( wxCommandEvent &event ){
            OnContextMenu( project, event ); }
      );
 
      menu.Append(OnCutSelectedTextID, _("Cu&t Label text"));
      menu.Append(OnCopySelectedTextID, _("&Copy Label text"));
      menu.Append(OnPasteSelectedTextID, _("&Paste"));
      menu.Append(OnDeleteSelectedLabelID, _("&Delete Label"));
      menu.Append(OnEditSelectedLabelID, _("&Edit Label..."));
 
      menu.Enable(OnCutSelectedTextID, IsTextSelected( project ));
      menu.Enable(OnCopySelectedTextID, IsTextSelected( project ));
      menu.Enable(OnPasteSelectedTextID, IsTextClipSupported());
      menu.Enable(OnDeleteSelectedLabelID, true);
      menu.Enable(OnEditSelectedLabelID, true);
 
      if(!IsValidIndex(mTextEditIndex, project)) {
         return;
      }
 
      const auto pTrack = FindLabelTrack();
      const LabelStruct *ls = pTrack->GetLabel(mTextEditIndex);
 
      wxClientDC dc(parent);
 
      if (msFont.Ok())
      {
         dc.SetFont(msFont);
      }
 
      int x = 0;
      bool success = CalcCursorX( project, &x );
      wxASSERT(success);
      static_cast<void>(success); // Suppress unused variable warning if debug mode is disabled
 
      // Bug #2571: Hackage alert! For some reason wxGTK does not like
      // displaying the LabelDialog from within the PopupMenu "context".
      // So, workaround it by editing the label AFTER the popup menu is
      // closed. It's really ugly, but it works.  :-(
      mEditIndex = -1;
      BasicMenu::Handle{ &menu }.Popup(
         wxWidgetsWindowPlacement{ parent },
         { x, ls->y + (mIconHeight / 2) - 1 }
      );
      if (mEditIndex >= 0)
      {
         DoEditLabels( project, FindLabelTrack().get(), mEditIndex );
      }
   }
}

References _, CalcCursorX(), DoEditLabels(), BasicUI::FindFocus(), FindLabelTrack(), GetProjectFrame(), IsTextClipSupported(), IsTextSelected(), IsValidIndex(), mEditIndex, mIconHeight, msFont, mTextEditIndex, OnContextMenu(), OnCopySelectedTextID, OnCutSelectedTextID, OnDeleteSelectedLabelID, OnEditSelectedLabelID, OnPasteSelectedTextID, BasicMenu::Handle::Popup(), project, and LabelStruct::y.

Referenced by DoKeyDown().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ LabelBarHeight

constexpr int LabelTrackView::LabelBarHeight { 6 }

staticconstexpr

Definition at line 52 of file LabelTrackView.h.

Referenced by Draw(), DrawBar(), DrawHighlight(), DrawText(), and DrawTextBox().

◆ mbGlyphsReady

bool LabelTrackView::mbGlyphsReady =false

staticprivate

Definition at line 199 of file LabelTrackView.h.

Referenced by CreateCustomGlyphs().

◆ mBoundaryGlyphs

wxBitmap LabelTrackView::mBoundaryGlyphs

staticprivate

We have several variants of the icons (highlighting). The icons are draggable, and you can drag one boundary or all boundaries at the same timecode depending on whether you click the centre (for all) or the arrow part (for one). Currently we have twelve variants but we're only using six.

Definition at line 200 of file LabelTrackView.h.

Referenced by CreateCustomGlyphs().

◆ mCurrentCursorPos

int LabelTrackView::mCurrentCursorPos

mutableprivate

Definition at line 203 of file LabelTrackView.h.

Referenced by CalcCursorX(), CalcHighlightXs(), CopySelectedText(), CopyTo(), CutSelectedText(), DoChar(), DoKeyDown(), Draw(), IsTextSelected(), OnLabelAdded(), PasteSelectedText(), RemoveSelectedText(), ResetFlags(), ResetTextSelection(), RestoreFlags(), SaveFlags(), SelectAllText(), SetCurrentCursorPosition(), and SetTextSelection().

◆ mEditIndex

int LabelTrackView::mEditIndex

private

Definition at line 268 of file LabelTrackView.h.

Referenced by OnContextMenu(), and ShowContextMenu().

◆ mFontHeight

int LabelTrackView::mFontHeight =-1

staticprivate

Definition at line 202 of file LabelTrackView.h.

Referenced by calculateFontHeight(), Draw(), DrawText(), and ResetFont().

◆ mGlyphHandle

std::weak_ptr<LabelGlyphHandle> LabelTrackView::mGlyphHandle

private

Definition at line 262 of file LabelTrackView.h.

Referenced by DetailedHitTest().

◆ mIconHeight

int LabelTrackView::mIconHeight

staticprivate

Definition at line 195 of file LabelTrackView.h.

Referenced by ComputeLayout(), CreateCustomGlyphs(), DrawGlyphs(), DrawLines(), OverTextBox(), and ShowContextMenu().

◆ mIconWidth

int LabelTrackView::mIconWidth

staticprivate

Definition at line 196 of file LabelTrackView.h.

Referenced by CalcCursorX(), ComputeLayout(), ComputeTextPosition(), CreateCustomGlyphs(), DrawBar(), DrawGlyphs(), DrawText(), DrawTextBox(), and OverTextBox().

◆ mInitialCursorPos

int LabelTrackView::mInitialCursorPos

mutableprivate

current cursor position

Definition at line 204 of file LabelTrackView.h.

Referenced by CalcHighlightXs(), CopySelectedText(), CopyTo(), CutSelectedText(), DoChar(), DoKeyDown(), Draw(), IsTextSelected(), OnLabelAdded(), PasteSelectedText(), RemoveSelectedText(), ResetFlags(), ResetTextSelection(), RestoreFlags(), SaveFlags(), SelectAllText(), and SetTextSelection().

◆ mNavigationIndex

Index LabelTrackView::mNavigationIndex { -1 }

mutableprivate

Keeps track of the currently selected label (not same as selection region) used for navigation between labels

Definition at line 189 of file LabelTrackView.h.

Referenced by CopyTo(), DoKeyDown(), Draw(), GetNavigationIndex(), OnLabelPermuted(), ResetFlags(), RestoreFlags(), SaveFlags(), and SetNavigationIndex().

◆ mRestoreFocus

int LabelTrackView::mRestoreFocus {-2}

private

initial cursor position

Definition at line 207 of file LabelTrackView.h.

Referenced by AddLabel(), DoKeyDown(), and OnLabelAdded().

◆ msFont

wxFont LabelTrackView::msFont

staticprivate

Definition at line 265 of file LabelTrackView.h.

Referenced by CalcCursorX(), CalcHighlightXs(), Draw(), FindCursorPosition(), ResetFont(), and ShowContextMenu().

◆ mSubscription

Observer::Subscription LabelTrackView::mSubscription

private

Definition at line 257 of file LabelTrackView.h.

Referenced by BindTo().

◆ mTextEditIndex

Index LabelTrackView::mTextEditIndex { -1 }

mutableprivate

Index of the current label text being edited.

Definition at line 191 of file LabelTrackView.h.

Referenced by CalcCursorX(), CalcHighlightXs(), Char(), CopySelectedText(), CopyTo(), CutSelectedText(), DoCaptureKey(), DoChar(), DoKeyDown(), Draw(), GetTextEditIndex(), IsTextSelected(), KeyDown(), OnContextMenu(), OnLabelAdded(), OnLabelDeleted(), OnLabelPermuted(), PasteSelectedText(), RemoveSelectedText(), ResetFlags(), ResetTextSelection(), RestoreFlags(), SaveFlags(), SelectAllText(), SetTextSelection(), and ShowContextMenu().

◆ mTextHandle

std::weak_ptr<LabelTextHandle> LabelTrackView::mTextHandle

private

Definition at line 263 of file LabelTrackView.h.

Referenced by DetailedHitTest().

◆ mTextHeight

int LabelTrackView::mTextHeight

staticprivate

Definition at line 197 of file LabelTrackView.h.

Referenced by ComputeLayout(), CreateCustomGlyphs(), Draw(), DrawGlyphs(), DrawHighlight(), DrawLines(), DrawText(), GetTextFrameHeight(), and OverGlyph().

◆ mUndoLabel

wxString LabelTrackView::mUndoLabel

mutableprivate

Definition at line 193 of file LabelTrackView.h.

Referenced by Char(), CopyTo(), CutSelectedText(), DoKeyDown(), KeyDown(), PasteSelectedText(), and SaveFlags().

◆ TextFramePadding

constexpr int LabelTrackView::TextFramePadding { 2 }

staticconstexpr

Definition at line 50 of file LabelTrackView.h.

Referenced by Draw(), DrawHighlight(), DrawText(), and GetTextFrameHeight().

◆ TextFrameYOffset

constexpr int LabelTrackView::TextFrameYOffset { -1 }

staticconstexpr

Definition at line 51 of file LabelTrackView.h.

Referenced by Draw(), DrawHighlight(), DrawText(), and DrawTextBox().

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ LabelTrackView() [1/2]

◆ LabelTrackView() [2/2]

◆ ~LabelTrackView()

Member Function Documentation

◆ AddedLabel()

◆ AddLabel()

◆ BindTo()

◆ CalcCursorX()

◆ CalcHighlightXs()

◆ calculateFontHeight()

◆ CaptureKey()

◆ Char()

◆ ComputeLayout()

◆ ComputeTextPosition()

◆ CopySelectedText()

◆ CopyTo()

◆ CreateCustomGlyphs()

◆ CutSelectedText()

◆ DeletedLabel()

◆ DetailedHitTest()

◆ DialogForLabelName()

◆ DoCaptureKey()

◆ DoChar()

◆ DoEditLabels()

◆ DoGetVRulerControls()

◆ DoKeyDown()

◆ Draw() [1/2]

◆ Draw() [2/2]

◆ DrawBar()

◆ DrawGlyphs()

◆ DrawHighlight()

◆ DrawLines()

◆ DrawText()

◆ DrawTextBox()

◆ FindCursorPosition()

◆ FindLabelTrack() [1/2]

◆ FindLabelTrack() [2/2]

◆ Get() [1/2]

◆ Get() [2/2]

◆ GetCurrentCursorPosition()

◆ GetFont()

◆ GetGlyph()

◆ GetInitialCursorPosition()

◆ GetLabelIndex()

◆ GetNavigationIndex()

◆ GetTextEditIndex()

◆ GetTextFrameHeight()

◆ IsTextClipSupported()

◆ IsTextSelected()

◆ IsValidIndex()

◆ KeyDown()

◆ OnContextMenu()

◆ OnLabelAdded()

◆ OnLabelDeleted()

◆ OnLabelPermuted()

◆ OnSelectionChange()

◆ operator=()

◆ OverATextBox()

◆ OverGlyph()

◆ OverTextBox()

◆ PasteSelectedText()

◆ RemoveSelectedText()

◆ Reparent()

◆ ResetFlags()

◆ ResetFont()

◆ ResetTextSelection()