TrackArt Namespace Reference

Functions
AUDACITY_DLL_API wxRect	DrawClipAffordance (wxDC &dc, const wxRect &affordanceRect, bool highlight=false, bool selected=false)
AUDACITY_DLL_API bool	DrawClipTitle (wxDC &dc, const wxRect &titleRect, const wxString &title)
AUDACITY_DLL_API bool	DrawAudioClipTitle (wxDC &dc, const wxRect &titleRect, const wxString &title, double clipStretchRatio)
AUDACITY_DLL_API void	DrawClipEdges (wxDC &dc, const wxRect &clipRect, bool selected=false)
AUDACITY_DLL_API void	DrawClipFolded (wxDC &dc, const wxRect &rect)
AUDACITY_DLL_API void	DrawSyncLockTiles (TrackPanelDrawingContext &context, const wxRect &rect)
AUDACITY_DLL_API void	DrawBackgroundWithSelection (TrackPanelDrawingContext &context, const wxRect &rect, const Track *track, const wxBrush &selBrush, const wxBrush &unselBrush, bool useSelection=true)
AUDACITY_DLL_API void	DrawCursor (TrackPanelDrawingContext &context, const wxRect &rect, const Track *track)
AUDACITY_DLL_API void	DrawNegativeOffsetTrackArrows (TrackPanelDrawingContext &context, const wxRect &rect)
AUDACITY_DLL_API wxString	TruncateText (wxDC &dc, const wxString &text, const int maxWidth)

Variables
static constexpr int	ClipFrameRadius { 6 }

Function Documentation

DrawAudioClipTitle()

bool TrackArt::DrawAudioClipTitle	(	wxDC &	dc,
		const wxRect &	titleRect,
		const wxString &	title,
		double	clipStretchRatio
	)

Definition at line 333 of file TrackArt.cpp.

{
   const auto clipTitle = DoDrawAudioTitle(dc, titleRect, title);
   if (!clipTitle.has_value())
      return false;
   if (!TimeAndPitchInterface::IsPassThroughMode(clipStretchRatio))
   {
      const auto fullText = GetPlaybackSpeedFullText(clipStretchRatio);
      constexpr auto minSpaceBetweenTitleAndSpeed = 12; // pixels
      const auto remainingWidth = std::max(
         titleRect.GetWidth() - dc.GetTextExtent(clipTitle->text).GetWidth() -
            minSpaceBetweenTitleAndSpeed,
         0);
      const auto truncatedText =
         TrackArt::TruncateText(dc, fullText, remainingWidth);
      if (truncatedText.find('%') != std::string::npos)
         // Only show if there is room for the % sign, or else it can be hard to
         // interpret.
         dc.DrawLabel(
            TrackArt::TruncateText(dc, fullText, remainingWidth), titleRect,
            (clipTitle->alignment == HAlign::left ? wxALIGN_RIGHT :
                                                    wxALIGN_LEFT) |
               wxALIGN_CENTER_VERTICAL);
   }
   return true;
}

References anonymous_namespace{TrackArt.cpp}::DoDrawAudioTitle(), anonymous_namespace{TrackArt.cpp}::GetPlaybackSpeedFullText(), TimeAndPitchInterface::IsPassThroughMode(), Tuple::detail::npos(), title, and TruncateText().

Referenced by WaveTrackAffordanceControls::Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawBackgroundWithSelection()

void TrackArt::DrawBackgroundWithSelection	(	TrackPanelDrawingContext &	context,
		const wxRect &	rect,
		const Track *	track,
		const wxBrush &	selBrush,
		const wxBrush &	unselBrush,
		bool	useSelection = true
	)

Definition at line 704 of file TrackArt.cpp.

{
   const auto dc = &context.dc;
   const auto artist = TrackArtist::Get( context );
   const auto &selectedRegion = *artist->pSelectedRegion;
   const auto& zoomInfo = *artist->pZoomInfo;
 
 
   //MM: Draw background. We should optimize that a bit more.
   const double sel0 = useSelection ? selectedRegion.t0() : 0.0;
   const double sel1 = useSelection ? selectedRegion.t1() : 0.0;
 
   BeatsGridlinePainter gridlinePainter(zoomInfo, *track);
 
   dc->SetPen(*wxTRANSPARENT_PEN);
 
   auto drawBgRect = [dc, &gridlinePainter, artist, &rect](
                        const wxBrush& regularBrush,
                        const wxBrush& beatStrongBrush,
                        const wxBrush& beatWeakBrush, const wxRect& subRect)
   {
      if (!gridlinePainter.enabled)
      {
         // Track not selected; just draw background
         dc->SetBrush(regularBrush);
         dc->DrawRectangle(subRect);
      }
      else
      {
         gridlinePainter.DrawBackground(
            *dc, subRect, rect, beatStrongBrush, beatWeakBrush);
      }
   };
 
   if (SyncLock::IsSelectedOrSyncLockSelected(track))
   {
      // Rectangles before, within, after the selection
      wxRect before = rect;
      wxRect within = rect;
      wxRect after = rect;
 
      before.width = (int)(zoomInfo.TimeToPosition(sel0) );
      if (before.GetRight() > rect.GetRight()) {
         before.width = rect.width;
      }
 
      if (before.width > 0) {
         drawBgRect(unselBrush, artist->beatStrongBrush, artist->beatWeakBrush, before);
 
         within.x = 1 + before.GetRight();
      }
      within.width = rect.x + (int)(zoomInfo.TimeToPosition(sel1) ) - within.x -1;
 
      if (within.GetRight() > rect.GetRight()) {
         within.width = 1 + rect.GetRight() - within.x;
      }
 
      // Bug 2389 - Selection can disappear
      // This handles case where no waveform is visible.
      if (within.width < 1)
         within.width = 1;
 
      if (within.width > 0) {
         if (track->GetSelected()) {
            drawBgRect(selBrush, artist->beatStrongSelBrush, artist->beatWeakSelBrush, within);
         }
         else {
            // Per condition above, track must be sync-lock selected
            drawBgRect(
               unselBrush, artist->beatStrongBrush, artist->beatWeakBrush, within);
            DrawSyncLockTiles( context, within );
         }
 
         after.x = 1 + within.GetRight();
      }
      else {
         // `within` not drawn; start where it would have gone
         after.x = within.x;
      }
 
      after.width = 1 + rect.GetRight() - after.x;
      if (after.width > 0)
         drawBgRect(
            unselBrush, artist->beatStrongBrush, artist->beatWeakBrush, after);
   }
   else
   {
      drawBgRect(
         unselBrush, artist->beatStrongBrush, artist->beatWeakBrush, rect);
   }
 
   if (gridlinePainter.enabled)
      gridlinePainter.DrawSeparators(*dc, rect, artist->beatSepearatorPen, artist->barSepearatorPen);
}

References TrackPanelDrawingContext::dc, DrawSyncLockTiles(), TrackArtist::Get(), Track::GetSelected(), SyncLock::IsSelectedOrSyncLockSelected(), ZoomInfo::TimeToPosition(), and within().

Referenced by SpectrumView::DoDraw(), WaveformView::DoDraw(), LabelTrackView::Draw(), NoteTrackAffordanceControls::Draw(), NoteTrackView::Draw(), and WaveTrackAffordanceControls::Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawClipAffordance()

wxRect TrackArt::DrawClipAffordance	(	wxDC &	dc,
		const wxRect &	affordanceRect,
		bool	highlight = false,
		bool	selected = false
	)

Definition at line 201 of file TrackArt.cpp.

{
   //To make sure that roundings do not overlap each other
   auto clipFrameRadius = std::min(ClipFrameRadius, rect.width / 2);
 
   wxRect clipRect;
   bool hasClipRect = dc.GetClippingBox(clipRect);
   //Fix #1689: visual glitches appear on attempt to draw a rectangle
   //larger than 0x7FFFFFF pixels wide (value was discovered
   //by manual testing, and maybe depends on OS being used), but
   //it's very unlikely that such huge rectangle will be ever fully visible
   //on the screen, so we can safely reduce its size to be slightly larger than
   //clipping rectangle, and avoid that problem
   auto drawingRect = rect;
   if (hasClipRect)
   {
       //to make sure that rounding happends outside the clipping rectangle
       drawingRect.SetLeft(std::max(rect.GetLeft(), clipRect.GetLeft() - clipFrameRadius - 1));
       drawingRect.SetRight(std::min(rect.GetRight(), clipRect.GetRight() + clipFrameRadius + 1));
   }
 
   if (selected)
   {
      wxRect strokeRect{
         drawingRect.x - ClipSelectionStrokeSize,
         drawingRect.y,
         drawingRect.width + ClipSelectionStrokeSize * 2,
         drawingRect.height + clipFrameRadius };
      dc.SetBrush(*wxTRANSPARENT_BRUSH);
      AColor::UseThemeColour(&dc, clrClipAffordanceStroke, clrClipAffordanceStroke);
      dc.DrawRoundedRectangle(strokeRect, clipFrameRadius);
   }
 
   AColor::UseThemeColour(&dc, highlight ? clrClipAffordanceActiveBrush : clrClipAffordanceInactiveBrush, clrClipAffordanceOutlinePen);
   dc.DrawRoundedRectangle(
      wxRect(
         drawingRect.x,
         drawingRect.y + ClipSelectionStrokeSize,
         drawingRect.width,
         drawingRect.height + clipFrameRadius
      ), clipFrameRadius
   );
 
   auto titleRect = hasClipRect ?
      //avoid drawing text outside the clipping rectangle if possible
      GetAffordanceTitleRect(rect.Intersect(clipRect)) :
      GetAffordanceTitleRect(rect);
 
   return titleRect;
}

References ClipFrameRadius, ClipSelectionStrokeSize, anonymous_namespace{TrackArt.cpp}::GetAffordanceTitleRect(), min(), and AColor::UseThemeColour().

Referenced by NoteTrackAffordanceControls::Draw(), and WaveTrackAffordanceControls::Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawClipEdges()

void TrackArt::DrawClipEdges	(	wxDC &	dc,
		const wxRect &	clipRect,
		bool	selected = false
	)

Definition at line 362 of file TrackArt.cpp.

{
   dc.SetBrush(*wxTRANSPARENT_BRUSH);
   {
      AColor::UseThemeColour(&dc, -1, clrClipAffordanceOutlinePen);
      AColor::Line(dc,
         clipRect.GetLeft(), clipRect.GetTop(),
         clipRect.GetLeft(), clipRect.GetBottom());
      AColor::Line(dc,
         clipRect.GetRight(), clipRect.GetTop(),
         clipRect.GetRight(), clipRect.GetBottom());
   }
   if(selected)
   {
      if constexpr (ClipSelectionStrokeSize == 1)
      {
         AColor::UseThemeColour(&dc, -1, clrClipAffordanceStroke);
         AColor::Line(dc,
            clipRect.GetLeft() - ClipSelectionStrokeSize, clipRect.GetTop(),
            clipRect.GetLeft() - ClipSelectionStrokeSize, clipRect.GetBottom());
         AColor::Line(dc,
            clipRect.GetRight() + ClipSelectionStrokeSize, clipRect.GetTop(),
            clipRect.GetRight() + ClipSelectionStrokeSize, clipRect.GetBottom());
      }
      else if constexpr (ClipSelectionStrokeSize > 1)
      {
         AColor::UseThemeColour(&dc, clrClipAffordanceStroke, clrClipAffordanceStroke);
         dc.DrawRectangle(wxRect(
            clipRect.GetLeft() - ClipSelectionStrokeSize, clipRect.GetTop(),
            ClipSelectionStrokeSize, clipRect.GetHeight()));
         dc.DrawRectangle(wxRect(
            clipRect.GetRight() + 1, clipRect.GetTop(),
            ClipSelectionStrokeSize, clipRect.GetHeight()));
      }
   }
}

References ClipSelectionStrokeSize, AColor::Line(), and AColor::UseThemeColour().

Referenced by anonymous_namespace{SpectrumView.cpp}::DrawClipSpectrum(), anonymous_namespace{WaveformView.cpp}::DrawClipWaveform(), and anonymous_namespace{NoteTrackView.cpp}::DrawNoteTrack().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawClipFolded()

void TrackArt::DrawClipFolded	(	wxDC &	dc,
		const wxRect &	rect
	)

Definition at line 399 of file TrackArt.cpp.

{
   AColor::UseThemeColour(&dc, clrClipAffordanceOutlinePen);
   dc.DrawRectangle(rect);
}

References AColor::UseThemeColour().

Referenced by WaveTrackAffordanceControls::Draw(), anonymous_namespace{SpectrumView.cpp}::DrawClipSpectrum(), and anonymous_namespace{WaveformView.cpp}::DrawClipWaveform().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawClipTitle()

bool TrackArt::DrawClipTitle	(	wxDC &	dc,
		const wxRect &	titleRect,
		const wxString &	title
	)

Definition at line 327 of file TrackArt.cpp.

{
   return DoDrawAudioTitle(dc, titleRect, title).has_value();
}

References anonymous_namespace{TrackArt.cpp}::DoDrawAudioTitle(), and title.

Referenced by NoteTrackAffordanceControls::Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawCursor()

void TrackArt::DrawCursor	(	TrackPanelDrawingContext &	context,
		const wxRect &	rect,
		const Track *	track
	)

Definition at line 802 of file TrackArt.cpp.

{
   const auto dc = &context.dc;
   const auto artist = TrackArtist::Get(context);
   const auto& selectedRegion = *artist->pSelectedRegion;
 
   if (selectedRegion.isPoint())
   {
       const auto& zoomInfo = *artist->pZoomInfo;
       auto x = static_cast<int>(zoomInfo.TimeToPosition(selectedRegion.t0(), rect.x));
       if (x >= rect.GetLeft() && x <= rect.GetRight())
       {
          AColor::CursorColor(dc);
          AColor::Line(*dc, x, rect.GetTop(), x, rect.GetBottom());
       }
   }
}

References AColor::CursorColor(), TrackPanelDrawingContext::dc, TrackArtist::Get(), AColor::Line(), and ZoomInfo::TimeToPosition().

Referenced by anonymous_namespace{TrackPanel.cpp}::ChannelStack::Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawNegativeOffsetTrackArrows()

void TrackArt::DrawNegativeOffsetTrackArrows	(	TrackPanelDrawingContext &	context,
		const wxRect &	rect
	)

Definition at line 136 of file TrackArt.cpp.

{
   auto &dc = context.dc;
 
   // Draws two black arrows on the left side of the track to
   // indicate the user that the track has been time-shifted
   // to the left beyond t=0.0.
 
   dc.SetPen(*wxBLACK_PEN);
   AColor::Line(dc,
                rect.x + 2, rect.y + 6,
                rect.x + 8, rect.y + 6);
   AColor::Line(dc,
                rect.x + 2, rect.y + 6,
                rect.x + 6, rect.y + 2);
   AColor::Line(dc,
                rect.x + 2, rect.y + 6,
                rect.x + 6, rect.y + 10);
   AColor::Line(dc,
                rect.x + 2, rect.y + rect.height - 8,
                rect.x + 8, rect.y + rect.height - 8);
   AColor::Line(dc,
                rect.x + 2, rect.y + rect.height - 8,
                rect.x + 6, rect.y + rect.height - 4);
   AColor::Line(dc,
                rect.x + 2, rect.y + rect.height - 8,
                rect.x + 6, rect.y + rect.height - 12);
}

References TrackPanelDrawingContext::dc, and AColor::Line().

Referenced by anonymous_namespace{WaveformView.cpp}::DrawClipWaveform(), and anonymous_namespace{NoteTrackView.cpp}::DrawNoteTrack().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawSyncLockTiles()

void TrackArt::DrawSyncLockTiles	(	TrackPanelDrawingContext &	context,
		const wxRect &	rect
	)

Definition at line 418 of file TrackArt.cpp.

{
   const auto dc = &context.dc;
 
   wxBitmap syncLockBitmap(theTheme.Image(bmpSyncLockSelTile));
 
   // Grid spacing is a bit smaller than actual image size
   int gridW = syncLockBitmap.GetWidth() - 6;
   int gridH = syncLockBitmap.GetHeight() - 8;
 
   // Horizontal position within the grid, modulo its period
   int blockX = (rect.x / gridW) % 5;
 
   // Amount to offset drawing of first column
   int xOffset = rect.x % gridW;
   if (xOffset < 0) xOffset += gridW;
 
   // Check if we're missing an extra column to the left (this can happen
   // because the tiles are bigger than the grid spacing)
   bool extraCol = false;
   if (syncLockBitmap.GetWidth() - gridW > xOffset) {
      extraCol = true;
      xOffset += gridW;
      blockX = (blockX - 1) % 5;
   }
   // Make sure blockX is non-negative
   if (blockX < 0) blockX += 5;
 
   int xx = 0;
   while (xx < rect.width) {
      int width = syncLockBitmap.GetWidth() - xOffset;
      if (xx + width > rect.width)
         width = rect.width - xx;
 
      //
      // Draw each row in this column
      //
 
      // Vertical position in the grid, modulo its period
      int blockY = (rect.y / gridH) % 5;
 
      // Amount to offset drawing of first row
      int yOffset = rect.y % gridH;
      if (yOffset < 0) yOffset += gridH;
 
      // Check if we're missing an extra row on top (this can happen because
      // the tiles are bigger than the grid spacing)
      bool extraRow = false;
      if (syncLockBitmap.GetHeight() - gridH > yOffset) {
         extraRow = true;
         yOffset += gridH;
         blockY = (blockY - 1) % 5;
      }
      // Make sure blockY is non-negative
      if (blockY < 0) blockY += 5;
 
      int yy = 0;
      while (yy < rect.height)
      {
         int height = syncLockBitmap.GetHeight() - yOffset;
         if (yy + height > rect.height)
            height = rect.height - yy;
 
         // AWD: draw blocks according to our pattern
         if ((blockX == 0 && blockY == 0) || (blockX == 2 && blockY == 1) ||
             (blockX == 4 && blockY == 2) || (blockX == 1 && blockY == 3) ||
             (blockX == 3 && blockY == 4))
         {
 
            // Do we need to get a sub-bitmap?
            if (width != syncLockBitmap.GetWidth() || height != syncLockBitmap.GetHeight()) {
               wxBitmap subSyncLockBitmap =
                  syncLockBitmap.GetSubBitmap(wxRect(xOffset, yOffset, width, height));
               dc->DrawBitmap(subSyncLockBitmap, rect.x + xx, rect.y + yy, true);
            }
            else {
               dc->DrawBitmap(syncLockBitmap, rect.x + xx, rect.y + yy, true);
            }
         }
 
         // Updates for next row
         if (extraRow) {
            // Second offset row, still at y = 0; no more extra rows
            yOffset -= gridH;
            extraRow = false;
         }
         else {
            // Move on in y, no more offset rows
            yy += gridH - yOffset;
            yOffset = 0;
         }
         blockY = (blockY + 1) % 5;
      }
 
      // Updates for next column
      if (extraCol) {
         // Second offset column, still at x = 0; no more extra columns
         xOffset -= gridW;
         extraCol = false;
      }
      else {
         // Move on in x, no more offset rows
         xx += gridW - xOffset;
         xOffset = 0;
      }
      blockX = (blockX + 1) % 5;
   }
}

References TrackPanelDrawingContext::dc, ThemeBase::Image(), and theTheme.

Referenced by DrawBackgroundWithSelection(), and anonymous_namespace{WaveformView.cpp}::DrawWaveformBackground().

Here is the call graph for this function:

Here is the caller graph for this function:

TruncateText()

wxString TrackArt::TruncateText	(	wxDC &	dc,
		const wxString &	text,
		const int	maxWidth
	)

Definition at line 166 of file TrackArt.cpp.

{
   static const wxString ellipsis = "\u2026";
 
   if (dc.GetTextExtent(text).GetWidth() <= maxWidth)
       return text;
 
   auto left = 0;
   //no need to check text + '...'
   auto right = static_cast<int>(text.Length() - 2);
 
   while (left <= right)
   {
      auto middle = (left + right) / 2;
      auto str = text.SubString(0, middle).Trim() + ellipsis;
      auto strWidth = dc.GetTextExtent(str).GetWidth();
      if (strWidth < maxWidth)
         //if left == right (== middle), then exit loop
         //with right equals to the last known index for which
         //strWidth < maxWidth
         left = middle + 1;
      else if (strWidth > maxWidth)
         //if right == left (== middle), then exit loop with
         //right equals to (left - 1), which is the last known
         //index for which (strWidth < maxWidth) or -1
         right = middle - 1;
      else
         return str;
   }
   if (right >= 0)
      return text.SubString(0, right).Trim() + ellipsis;
 
   return wxEmptyString;
}

References str.

Referenced by anonymous_namespace{TrackArt.cpp}::DoDrawAudioTitle(), DrawAudioClipTitle(), and AButton::OnPaint().

Here is the caller graph for this function:

Variable Documentation

ClipFrameRadius

constexpr int TrackArt::ClipFrameRadius { 6 }

staticconstexpr

Definition at line 22 of file TrackArt.h.

Referenced by DrawClipAffordance(), and anonymous_namespace{TrackArt.cpp}::GetAffordanceTitleRect().