FrequencyPlotDialog Class Reference

Displays a spectrum plot of the waveform. Has options for selecting parameters of the plot. More...

#include <FreqWindow.h>

Inheritance diagram for FrequencyPlotDialog:

Collaboration diagram for FrequencyPlotDialog:

Public Member Functions
	FrequencyPlotDialog (wxWindow *parent, wxWindowID id, AudacityProject &project, const TranslatableString &title, const wxPoint &pos)
virtual	~FrequencyPlotDialog ()
bool	Show (bool show=true) override
Public Member Functions inherited from PlotSpectrumBase
	PlotSpectrumBase (AudacityProject &project)
Public Member Functions inherited from wxDialogWrapper
	wxDialogWrapper ()
	wxDialogWrapper (wxWindow *parent, wxWindowID id, const TranslatableString &title, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxDEFAULT_DIALOG_STYLE, const TranslatableString &name=XO("Dialog"))
bool	Create (wxWindow *parent, wxWindowID id, const TranslatableString &title, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxDEFAULT_DIALOG_STYLE, const TranslatableString &name=XO("Dialog"))
void	SetTitle (const TranslatableString &title)
void	SetLabel (const TranslatableString &title)
void	SetName (const TranslatableString &title)
void	SetName ()
Public Member Functions inherited from wxTabTraversalWrapper< wxDialog >
	wxTabTraversalWrapper (Args &&... args)
	wxTabTraversalWrapper (const wxTabTraversalWrapper &)=delete
	wxTabTraversalWrapper (wxTabTraversalWrapper &&)=delete
wxTabTraversalWrapper &	operator= (const wxTabTraversalWrapper &)=delete
wxTabTraversalWrapper &	operator= (wxTabTraversalWrapper &&)=delete
Public Member Functions inherited from PrefsListener
	PrefsListener ()
virtual	~PrefsListener ()
virtual void	UpdatePrefs ()=0

Private Member Functions
void	Populate ()
void	PlotMouseEvent (wxMouseEvent &event)
void	PlotPaint (wxPaintEvent &event)
void	OnCloseWindow (wxCloseEvent &event)
void	OnCloseButton (wxCommandEvent &event)
void	OnGetURL (wxCommandEvent &event)
void	OnSize (wxSizeEvent &event)
void	OnPanScroller (wxScrollEvent &event)
void	OnZoomSlider (wxCommandEvent &event)
void	OnAlgChoice (wxCommandEvent &event)
void	OnSizeChoice (wxCommandEvent &event)
void	OnFuncChoice (wxCommandEvent &event)
void	OnAxisChoice (wxCommandEvent &event)
void	OnExport (wxCommandEvent &event)
void	OnReplot (wxCommandEvent &event)
void	OnGridOnOff (wxCommandEvent &event)
void	OnRecalc (wxCommandEvent &event)
void	SendRecalcEvent ()
void	Recalc ()
void	DrawPlot ()
void	DrawBackground (wxMemoryDC &dc)
void	UpdatePrefs () override

Private Attributes
RulerPanel *	vRuler
RulerPanel *	hRuler
FreqPlot *	mFreqPlot
FreqGauge *	mProgress
wxRect	mPlotRect
wxFont	mFreqFont
std::unique_ptr< wxCursor >	mArrowCursor
std::unique_ptr< wxCursor >	mCrossCursor
wxButton *	mCloseButton
wxButton *	mExportButton
wxButton *	mReplotButton
wxCheckBox *	mGridOnOff
wxChoice *	mAlgChoice
wxChoice *	mSizeChoice
wxChoice *	mFuncChoice
wxChoice *	mAxisChoice
wxScrollBar *	mPanScroller
wxSlider *	mZoomSlider
wxTextCtrl *	mCursorText
wxTextCtrl *	mPeakText
bool	mLogAxis
float	mYMin
float	mYMax
float	mYStep
std::unique_ptr< wxBitmap >	mBitmap
int	mMouseX
int	mMouseY

Static Private Attributes
static const int	fontSize = 8

Friends
class	FreqPlot

Additional Inherited Members
Static Public Member Functions inherited from PrefsListener
static void	Broadcast (int id=0)
	Call this static function to notify all PrefsListener objects. More...
Protected Member Functions inherited from PlotSpectrumBase
bool	GetAudio ()
Protected Member Functions inherited from PrefsListener
virtual void	UpdateSelectedPrefs (int id)
Protected Attributes inherited from PlotSpectrumBase
AudacityProject *	mProject
std::unique_ptr< SpectrumAnalyst >	mAnalyst
bool	mDrawGrid
int	mSize
SpectrumAnalyst::Algorithm	mAlg
int	mFunc
int	mAxis
int	dBRange
double	mRate
size_t	mDataLen
ArrayOf< float >	mData
size_t	mWindowSize

Detailed Description

Displays a spectrum plot of the waveform. Has options for selecting parameters of the plot.

Has a feature that finds peaks and reports their value as you move the mouse around.

Definition at line 54 of file FreqWindow.h.

Constructor & Destructor Documentation

FrequencyPlotDialog()

FrequencyPlotDialog::FrequencyPlotDialog	(	wxWindow *	parent,
		wxWindowID	id,
		AudacityProject &	project,
		const TranslatableString &	title,
		const wxPoint &	pos
	)

Definition at line 187 of file FreqWindow.cpp.

    : PlotSpectrumBase { project }
    , wxDialogWrapper(
         parent, id, title, pos, wxDefaultSize,
         wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER | wxMAXIMIZE_BOX)
{
   SetName();
 
   mMouseX = 0;
   mMouseY = 0;
 
   Populate();
}

References project.

~FrequencyPlotDialog()

FrequencyPlotDialog::~FrequencyPlotDialog ( )

virtual

Definition at line 203 of file FreqWindow.cpp.

{
}

Member Function Documentation

DrawBackground()

void FrequencyPlotDialog::DrawBackground ( wxMemoryDC &  dc )

private

Definition at line 581 of file FreqWindow.cpp.

{
   Layout();
 
   mBitmap.reset();
 
   mPlotRect = mFreqPlot->GetClientRect();
 
   mBitmap = std::make_unique<wxBitmap>(mPlotRect.width, mPlotRect.height,24);
 
   dc.SelectObject(*mBitmap);
 
   dc.SetBackground(wxBrush(wxColour(254, 254, 254)));// DONT-THEME Mask colour.
   dc.Clear();
 
   dc.SetPen(*wxBLACK_PEN);
   dc.SetBrush(*wxWHITE_BRUSH);
   dc.DrawRectangle(mPlotRect);
 
   dc.SetFont(mFreqFont);
}

References mBitmap, mFreqFont, mFreqPlot, and mPlotRect.

Referenced by DrawPlot().

Here is the caller graph for this function:

DrawPlot()

void FrequencyPlotDialog::DrawPlot ( )

private

Definition at line 603 of file FreqWindow.cpp.

{
   if (!mData || mDataLen < mWindowSize || mAnalyst->GetProcessedSize() == 0) {
      wxMemoryDC memDC;
 
      vRuler->ruler.SetUpdater(&LinearUpdater::Instance());
      vRuler->ruler.SetRange(0.0, -dBRange);
 
      hRuler->ruler.SetUpdater(&LinearUpdater::Instance());
      hRuler->ruler.SetRange(0, 1);
 
      DrawBackground(memDC);
 
      if (mDataLen < mWindowSize) {
         wxString msg = _("Not enough data selected.");
         wxSize sz = memDC.GetTextExtent(msg);
         memDC.DrawText(msg,
                        (mPlotRect.GetWidth() - sz.GetWidth()) / 2,
                        (mPlotRect.GetHeight() - sz.GetHeight()) / 2);
      }
 
      memDC.SelectObject(wxNullBitmap);
 
      mFreqPlot->Refresh();
 
      Refresh();
 
      return;
   }
 
   float yRange = mYMax - mYMin;
   float yTotal = yRange * ((float) mZoomSlider->GetValue() / 100.0f);
 
   int sTotal = yTotal * 100;
   int sRange = yRange * 100;
   int sPos = mPanScroller->GetThumbPosition() + ((mPanScroller->GetThumbSize() - sTotal) / 2);
    mPanScroller->SetScrollbar(sPos, sTotal, sRange, sTotal);
 
   float yMax = mYMax - ((float)sPos / 100);
   float yMin = yMax - yTotal;
 
   // Set up y axis ruler
 
   if (mAlg == SpectrumAnalyst::Spectrum) {
      vRuler->ruler.SetUnits(XO("dB"));
      vRuler->ruler.SetFormat(&LinearDBFormat::Instance());
   } else {
      vRuler->ruler.SetUnits({});
      vRuler->ruler.SetFormat(&RealFormat::LinearInstance());
   }
   int w1, w2, h;
   vRuler->ruler.GetMaxSize(&w1, &h);
   vRuler->ruler.SetRange(yMax, yMin); // Note inversion for vertical.
   vRuler->ruler.GetMaxSize(&w2, &h);
   if( w1 != w2 )   // Reduces flicker
   {
      vRuler->SetMinSize(wxSize(w2,h));
      Layout();
   }
   vRuler->Refresh(false);
 
   wxMemoryDC memDC;
   DrawBackground(memDC);
 
   // Get the plot dimensions
   //
   // Must be done after setting the vertical ruler above since the
   // the width could change.
   wxRect r = mPlotRect;
 
   // Set up x axis ruler
 
   int width = r.width - 2;
 
   float xMin, xMax, xRatio, xStep;
 
   if (mAlg == SpectrumAnalyst::Spectrum) {
      xMin = mRate / mWindowSize;
      xMax = mRate / 2;
      xRatio = xMax / xMin;
      if (mLogAxis)
      {
         xStep = pow(2.0f, (log(xRatio) / log(2.0f)) / width);
         hRuler->ruler.SetUpdater(&LogarithmicUpdater::Instance());
      }
      else
      {
         xStep = (xMax - xMin) / width;
         hRuler->ruler.SetUpdater(&LinearUpdater::Instance());
      }
      hRuler->ruler.SetUnits(XO("Hz"));
   } else {
      xMin = 0;
      xMax = mAnalyst->GetProcessedSize() / mRate;
      xStep = (xMax - xMin) / width;
      hRuler->ruler.SetUpdater(&LinearUpdater::Instance());
      /* i18n-hint: short form of 'seconds'.*/
      hRuler->ruler.SetUnits(XO("s"));
   }
   hRuler->ruler.SetRange(xMin, xMax-xStep);
   hRuler->Refresh(false);
 
   // Draw the plot
   if (mAlg == SpectrumAnalyst::Spectrum)
      memDC.SetPen(wxPen(theTheme.Colour( clrHzPlot ), 1, wxPENSTYLE_SOLID));
   else
      memDC.SetPen(wxPen(theTheme.Colour( clrWavelengthPlot), 1, wxPENSTYLE_SOLID));
 
   float xPos = xMin;
 
   for (int i = 0; i < width; i++) {
      float y;
 
      if (mLogAxis)
         y = mAnalyst->GetProcessedValue(xPos, xPos * xStep);
      else
         y = mAnalyst->GetProcessedValue(xPos, xPos + xStep);
 
      float ynorm = (y - yMin) / yTotal;
 
      int lineheight = (int)(ynorm * (r.height - 1));
 
      if (lineheight > r.height - 2)
         lineheight = r.height - 2;
 
      if (ynorm > 0.0)
         AColor::Line(memDC, r.x + 1 + i, r.y + r.height - 1 - lineheight,
                        r.x + 1 + i, r.y + r.height - 1);
 
      if (mLogAxis)
         xPos *= xStep;
      else
         xPos += xStep;
   }
 
   // Outline the graph
   memDC.SetPen(*wxBLACK_PEN);
   memDC.SetBrush(*wxTRANSPARENT_BRUSH);
   memDC.DrawRectangle(r);
 
   if(mDrawGrid)
   {
      hRuler->ruler.DrawGrid(memDC, r.height, true, true, 1, 1);
      vRuler->ruler.DrawGrid(memDC, r.width, true, true, 1, 1);
   }
 
   memDC.SelectObject( wxNullBitmap );
 
   mFreqPlot->Refresh();
}

References _, ThemeBase::Colour(), PlotSpectrumBase::dBRange, DrawBackground(), Ruler::DrawGrid(), Ruler::GetMaxSize(), hRuler, LinearDBFormat::Instance(), LinearUpdater::Instance(), LogarithmicUpdater::Instance(), AColor::Line(), RealFormat::LinearInstance(), PlotSpectrumBase::mAlg, PlotSpectrumBase::mAnalyst, PlotSpectrumBase::mData, PlotSpectrumBase::mDataLen, PlotSpectrumBase::mDrawGrid, mFreqPlot, mLogAxis, mPanScroller, mPlotRect, PlotSpectrumBase::mRate, PlotSpectrumBase::mWindowSize, mYMax, mYMin, mZoomSlider, RulerPanel::ruler, Ruler::SetFormat(), Ruler::SetRange(), Ruler::SetUnits(), Ruler::SetUpdater(), SpectrumAnalyst::Spectrum, theTheme, vRuler, and XO().

Referenced by OnAxisChoice(), OnGridOnOff(), OnPanScroller(), OnSize(), OnZoomSlider(), and Recalc().

Here is the call graph for this function:

Here is the caller graph for this function:

OnAlgChoice()

void FrequencyPlotDialog::OnAlgChoice ( wxCommandEvent &  event )

private

Definition at line 780 of file FreqWindow.cpp.

{
   mAlg = SpectrumAnalyst::Algorithm(mAlgChoice->GetSelection());
 
   // Log-frequency axis works for spectrum plots only.
   if (mAlg == SpectrumAnalyst::Spectrum) {
      mAxisChoice->Enable(true);
      mLogAxis = mAxisChoice->GetSelection() ? true : false;
   }
   else {
      mAxisChoice->Disable();
      mLogAxis = false;
   }
 
   SendRecalcEvent();
}

References PlotSpectrumBase::mAlg, mAlgChoice, mAxisChoice, mLogAxis, SendRecalcEvent(), and SpectrumAnalyst::Spectrum.

Here is the call graph for this function:

OnAxisChoice()

void FrequencyPlotDialog::OnAxisChoice ( wxCommandEvent &  event )

private

Definition at line 811 of file FreqWindow.cpp.

{
   mLogAxis = mAxisChoice->GetSelection() ? true : false;
   DrawPlot();
}

References DrawPlot(), mAxisChoice, and mLogAxis.

Here is the call graph for this function:

OnCloseButton()

void FrequencyPlotDialog::OnCloseButton ( wxCommandEvent &  event )

private

Definition at line 925 of file FreqWindow.cpp.

{
   gPrefs->Write(wxT("/FrequencyPlotDialog/DrawGrid"), mDrawGrid);
   gPrefs->Write(wxT("/FrequencyPlotDialog/SizeChoice"), mSizeChoice->GetSelection());
   gPrefs->Write(wxT("/FrequencyPlotDialog/AlgChoice"), mAlgChoice->GetSelection());
   gPrefs->Write(wxT("/FrequencyPlotDialog/FuncChoice"), mFuncChoice->GetSelection());
   gPrefs->Write(wxT("/FrequencyPlotDialog/AxisChoice"), mAxisChoice->GetSelection());
   gPrefs->Flush();
   mData.reset();
   Show(false);
}

References audacity::BasicSettings::Flush(), gPrefs, mAlgChoice, mAxisChoice, PlotSpectrumBase::mData, PlotSpectrumBase::mDrawGrid, mFuncChoice, mSizeChoice, Show(), audacity::BasicSettings::Write(), and wxT().

Here is the call graph for this function:

OnCloseWindow()

void FrequencyPlotDialog::OnCloseWindow ( wxCloseEvent &  event )

private

Definition at line 920 of file FreqWindow.cpp.

{
   Show(false);
}

References Show().

Here is the call graph for this function:

OnExport()

void FrequencyPlotDialog::OnExport ( wxCommandEvent &  event )

private

Definition at line 999 of file FreqWindow.cpp.

{
   wxString fName = _("spectrum.txt");
 
   fName = SelectFile(FileNames::Operation::Export,
      XO("Export Spectral Data As:"),
      wxEmptyString,
      fName,
      wxT("txt"),
      { FileNames::TextFiles, FileNames::AllFiles },
      wxFD_SAVE | wxRESIZE_BORDER,
      this);
 
   if (fName.empty())
      return;
 
   wxFFileOutputStream ffStream{ fName };
   if (!ffStream.IsOk()) {
      AudacityMessageBox( XO("Couldn't write to file: %s").Format( fName ) );
      return;
   }
 
  wxTextOutputStream ss(ffStream);
 
   const int processedSize = mAnalyst->GetProcessedSize();
   const float *const processed = mAnalyst->GetProcessed();
   if (mAlgChoice->GetSelection() == 0) {
      ss
         << XO("Frequency (Hz)\tLevel (dB)") << '\n';
      for (int i = 1; i < processedSize; i++)
         ss
            << wxString::Format(wxT("%f\t%f\n"),
               i * mRate / mWindowSize, processed[i] );
   }
   else {
      ss
         << XO("Lag (seconds)\tFrequency (Hz)\tLevel") << '\n';
      for (int i = 1; i < processedSize; i++)
         ss
            << wxString::Format(wxT("%f\t%f\t%f\n"),
               i / mRate, mRate / i, processed[i] );
   }
}

References _, FileNames::AllFiles, AudacityMessageBox(), mAlgChoice, PlotSpectrumBase::mAnalyst, PlotSpectrumBase::mRate, PlotSpectrumBase::mWindowSize, SelectFile(), FileNames::TextFiles, wxT(), and XO().

Here is the call graph for this function:

OnFuncChoice()

void FrequencyPlotDialog::OnFuncChoice ( wxCommandEvent &  event )

private

Definition at line 806 of file FreqWindow.cpp.

{
   SendRecalcEvent();
}

References SendRecalcEvent().

Here is the call graph for this function:

OnGetURL()

void FrequencyPlotDialog::OnGetURL ( wxCommandEvent &  event )

private

Definition at line 538 of file FreqWindow.cpp.

{
   // Original help page is back on-line (March 2016), but the manual should be more reliable.
   // http://www.eramp.com/WCAG_2_audio_contrast_tool_help.htm
   HelpSystem::ShowHelp(this, L"Plot_Spectrum");
}

References HelpSystem::ShowHelp().

Here is the call graph for this function:

OnGridOnOff()

void FrequencyPlotDialog::OnGridOnOff ( wxCommandEvent &  event )

private

Definition at line 1052 of file FreqWindow.cpp.

{
   mDrawGrid = mGridOnOff->IsChecked();
 
   DrawPlot();
}

References DrawPlot(), PlotSpectrumBase::mDrawGrid, and mGridOnOff.

Here is the call graph for this function:

OnPanScroller()

void FrequencyPlotDialog::OnPanScroller ( wxScrollEvent &  event )

private

Definition at line 770 of file FreqWindow.cpp.

{
   DrawPlot();
}

References DrawPlot().

Here is the call graph for this function:

OnRecalc()

void FrequencyPlotDialog::OnRecalc ( wxCommandEvent &  event )

private

Definition at line 1059 of file FreqWindow.cpp.

{
   Recalc();
}

References Recalc().

Here is the call graph for this function:

OnReplot()

void FrequencyPlotDialog::OnReplot ( wxCommandEvent &  event )

private

Definition at line 1043 of file FreqWindow.cpp.

{
   dBRange = DecibelScaleCutoff.Read();
   if(dBRange < 90.)
      dBRange = 90.;
   GetAudio();
   SendRecalcEvent();
}

References PlotSpectrumBase::dBRange, DecibelScaleCutoff, PlotSpectrumBase::GetAudio(), Setting< T >::Read(), and SendRecalcEvent().

Here is the call graph for this function:

OnSize()

void FrequencyPlotDialog::OnSize ( wxSizeEvent &  event )

private

Definition at line 572 of file FreqWindow.cpp.

{
   Layout();
 
   DrawPlot();
 
   Refresh(true);
}

References DrawPlot().

Here is the call graph for this function:

OnSizeChoice()

void FrequencyPlotDialog::OnSizeChoice ( wxCommandEvent &  event )

private

Definition at line 797 of file FreqWindow.cpp.

{
   long windowSize = 0;
   mSizeChoice->GetStringSelection().ToLong(&windowSize);
   mWindowSize = windowSize;
 
   SendRecalcEvent();
}

References mSizeChoice, PlotSpectrumBase::mWindowSize, and SendRecalcEvent().

Here is the call graph for this function:

OnZoomSlider()

void FrequencyPlotDialog::OnZoomSlider ( wxCommandEvent &  event )

private

Definition at line 775 of file FreqWindow.cpp.

{
   DrawPlot();
}

References DrawPlot().

Here is the call graph for this function:

PlotMouseEvent()

void FrequencyPlotDialog::PlotMouseEvent ( wxMouseEvent &  event )

private

Definition at line 755 of file FreqWindow.cpp.

{
   if (event.Moving() && (event.m_x != mMouseX || event.m_y != mMouseY)) {
      mMouseX = event.m_x;
      mMouseY = event.m_y;
 
      if (mPlotRect.Contains(mMouseX, mMouseY))
         mFreqPlot->SetCursor(*mCrossCursor);
      else
         mFreqPlot->SetCursor(*mArrowCursor);
 
      mFreqPlot->Refresh(false);
   }
}

References mArrowCursor, mCrossCursor, mFreqPlot, mMouseX, mMouseY, and mPlotRect.

Referenced by FreqPlot::OnMouseEvent().

Here is the caller graph for this function:

PlotPaint()

void FrequencyPlotDialog::PlotPaint ( wxPaintEvent &  event )

private

Definition at line 817 of file FreqWindow.cpp.

{
   wxPaintDC dc( (wxWindow *) event.GetEventObject() );
 
   dc.DrawBitmap( *mBitmap, 0, 0, true );
   // Fix for Bug 1226 "Plot Spectrum freezes... if insufficient samples selected"
   if (!mData || mDataLen < mWindowSize)
      return;
 
   dc.SetFont(mFreqFont);
 
   wxRect r = mPlotRect;
 
   int width = r.width - 2;
 
   float xMin, xMax, xRatio, xStep;
 
   if (mAlg == SpectrumAnalyst::Spectrum) {
      xMin = mRate / mWindowSize;
      xMax = mRate / 2;
      xRatio = xMax / xMin;
      if (mLogAxis)
         xStep = pow(2.0f, (log(xRatio) / log(2.0f)) / width);
      else
         xStep = (xMax - xMin) / width;
   } else {
      xMin = 0;
      xMax = mAnalyst->GetProcessedSize() / mRate;
      xStep = (xMax - xMin) / width;
   }
 
   float xPos = xMin;
 
   // Find the peak nearest the cursor and plot it
   if ( r.Contains(mMouseX, mMouseY) && (mMouseX!=0) && (mMouseX!=r.width-1) ) {
      if (mLogAxis)
         xPos = xMin * pow(xStep, mMouseX - (r.x + 1));
      else
         xPos = xMin + xStep * (mMouseX - (r.x + 1));
 
      float bestValue = 0;
      float bestpeak = mAnalyst->FindPeak(xPos, &bestValue);
 
      int px;
      if (mLogAxis)
         px = (int)(log(bestpeak / xMin) / log(xStep));
      else
         px = (int)((bestpeak - xMin) * width / (xMax - xMin));
 
      dc.SetPen(wxPen(wxColour(255, 32, 32), 1, wxPENSTYLE_SOLID));
      AColor::Line(dc, r.x + 1 + px, r.y, r.x + 1 + px, r.y + r.height);
 
       // print out info about the cursor location
 
      float value;
 
      if (mLogAxis) {
         xPos = xMin * pow(xStep, mMouseX - (r.x + 1));
         value = mAnalyst->GetProcessedValue(xPos, xPos * xStep);
      } else {
         xPos = xMin + xStep * (mMouseX - (r.x + 1));
         value = mAnalyst->GetProcessedValue(xPos, xPos + xStep);
      }
 
      TranslatableString cursor;
      TranslatableString peak;
 
      if (mAlg == SpectrumAnalyst::Spectrum) {
         auto xp = PitchName_Absolute(FreqToMIDInote(xPos));
         auto pp = PitchName_Absolute(FreqToMIDInote(bestpeak));
         /* i18n-hint: The %d's are replaced by numbers, the %s by musical notes, e.g. A#*/
         cursor = XO("%d Hz (%s) = %d dB")
            .Format( (int)(xPos + 0.5), xp, (int)(value + 0.5));
         /* i18n-hint: The %d's are replaced by numbers, the %s by musical notes, e.g. A#*/
         peak = XO("%d Hz (%s) = %.1f dB")
            .Format( (int)(bestpeak + 0.5), pp, bestValue );
      } else if (xPos > 0.0 && bestpeak > 0.0) {
         auto xp = PitchName_Absolute(FreqToMIDInote(1.0 / xPos));
         auto pp = PitchName_Absolute(FreqToMIDInote(1.0 / bestpeak));
         /* i18n-hint: The %d's are replaced by numbers, the %s by musical notes, e.g. A#
          * the %.4f are numbers, and 'sec' should be an abbreviation for seconds */
         cursor = XO("%.4f sec (%d Hz) (%s) = %f")
            .Format( xPos, (int)(1.0 / xPos + 0.5), xp, value );
         /* i18n-hint: The %d's are replaced by numbers, the %s by musical notes, e.g. A#
          * the %.4f are numbers, and 'sec' should be an abbreviation for seconds */
         peak = XO("%.4f sec (%d Hz) (%s) = %.3f")
            .Format( bestpeak, (int)(1.0 / bestpeak + 0.5), pp, bestValue );
      }
      mCursorText->SetValue( cursor.Translation() );
      mPeakText->SetValue( peak.Translation() );
   }
   else {
      mCursorText->SetValue(wxT(""));
      mPeakText->SetValue(wxT(""));
   }
 
 
   // Outline the graph
   dc.SetPen(*wxBLACK_PEN);
   dc.SetBrush(*wxTRANSPARENT_BRUSH);
   dc.DrawRectangle(r);
}

References FreqToMIDInote(), AColor::Line(), PlotSpectrumBase::mAlg, PlotSpectrumBase::mAnalyst, mBitmap, mCursorText, PlotSpectrumBase::mData, PlotSpectrumBase::mDataLen, mFreqFont, mLogAxis, mMouseX, mMouseY, mPeakText, mPlotRect, PlotSpectrumBase::mRate, PlotSpectrumBase::mWindowSize, PitchName_Absolute(), SpectrumAnalyst::Spectrum, TranslatableString::Translation(), wxT(), and XO().

Referenced by FreqPlot::OnPaint().

Here is the call graph for this function:

Here is the caller graph for this function:

Populate()

void FrequencyPlotDialog::Populate ( )

private

Definition at line 207 of file FreqWindow.cpp.

{
   SetTitle(FrequencyAnalysisTitle);
 
   TranslatableStrings algChoices{
      XO("Spectrum") ,
      XO("Standard Autocorrelation") ,
      XO("Cuberoot Autocorrelation") ,
      XO("Enhanced Autocorrelation") ,
        /* i18n-hint: This is a technical term, derived from the word
         * "spectrum".  Do not translate it unless you are sure you
         * know the correct technical word in your language. */
      XO("Cepstrum") ,
   };
 
   TranslatableStrings sizeChoices{
      Verbatim( "128" ) ,
      Verbatim( "256" ) ,
      Verbatim( "512" ) ,
      Verbatim( "1024" ) ,
      Verbatim( "2048" ) ,
      Verbatim( "4096" ) ,
      Verbatim( "8192" ) ,
      Verbatim( "16384" ) ,
      Verbatim( "32768" ) ,
      Verbatim( "65536" ) ,
      Verbatim( "131072" ) ,
   };
 
   TranslatableStrings funcChoices;
   for (int i = 0, cnt = NumWindowFuncs(); i < cnt; i++)
   {
      funcChoices.push_back(
         /* i18n-hint: This refers to a "window function",
          * such as Hann or Rectangular, used in the
          * Frequency analyze dialog box. */
         XO("%s window").Format( WindowFuncName(i) ) );
   }
 
   TranslatableStrings axisChoices{
      XO("Linear frequency") ,
      XO("Log frequency") ,
   };
 
   mFreqFont = wxFont(fontSize, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
   mArrowCursor = std::make_unique<wxCursor>(wxCURSOR_ARROW);
   mCrossCursor = std::make_unique<wxCursor>(wxCURSOR_CROSS);
 
   long size;
   // reinterpret one of the verbatim strings above as a number
   sizeChoices[mSize].MSGID().GET().ToLong(&size);
   mWindowSize = size;
 
   dBRange = DecibelScaleCutoff.Read();
   if(dBRange < 90.)
      dBRange = 90.;
 
   ShuttleGui S(this, eIsCreating);
 
   S.SetBorder(0);
 
   S.AddSpace(5);
 
   S.SetSizerProportion(1);
   S.StartMultiColumn(3, wxEXPAND);
   {
      S.SetStretchyCol(1);
      S.SetStretchyRow(0);
 
      // -------------------------------------------------------------------
      // ROW 1: Freq response panel and sliders for vertical scale
      // -------------------------------------------------------------------
 
      S.StartVerticalLay(2);
      {
         vRuler = safenew RulerPanel(
            S.GetParent(), wxID_ANY, wxVERTICAL,
            wxSize{ 100, 100 }, // Ruler can't handle small sizes
            RulerPanel::Range{ 0.0, -dBRange },
            LinearDBFormat::Instance(),
            XO("dB"),
            RulerPanel::Options{}
               .LabelEdges(true)
               .TickColour( theTheme.Colour( clrGraphLabels ) )
         );
 
         S.AddSpace(wxDefaultCoord, 1);
         S.Prop(1)
            .Position(wxALIGN_RIGHT | wxALIGN_TOP)
            .AddWindow(vRuler);
         S.AddSpace(wxDefaultCoord, 1);
      }
      S.EndVerticalLay();
 
      mFreqPlot = safenew FreqPlot(S.GetParent(), wxID_ANY);
      S.Prop(1)
         .Position(wxEXPAND)
         .MinSize( { wxDefaultCoord, FREQ_WINDOW_HEIGHT } )
         .AddWindow(mFreqPlot);
 
      S.StartHorizontalLay(wxEXPAND, 0);
      {
         S.StartVerticalLay();
         {
            mPanScroller = safenew wxScrollBar(S.GetParent(), FreqPanScrollerID,
               wxDefaultPosition, wxDefaultSize, wxSB_VERTICAL);
#if wxUSE_ACCESSIBILITY
            // so that name can be set on a standard control
            mPanScroller->SetAccessible(safenew WindowAccessible(mPanScroller));
#endif
            S.Prop(1);
            S
               .Name(XO("Scroll"))
               .Position( wxALIGN_LEFT | wxTOP)
               .AddWindow(mPanScroller);
         }
         S.EndVerticalLay();
 
         S.StartVerticalLay();
         {
            wxStaticBitmap *zi = safenew wxStaticBitmap(S.GetParent(), wxID_ANY, wxBitmap(ZoomIn));
            S.Position(wxALIGN_CENTER)
               .AddWindow(zi);
 
            S.AddSpace(5);
 
            mZoomSlider = safenew wxSliderWrapper(S.GetParent(), FreqZoomSliderID, 100, 1, 100,
               wxDefaultPosition, wxDefaultSize, wxSL_VERTICAL);
            S.Prop(1);
            S
               .Name(XO("Zoom"))
               .Position(wxALIGN_CENTER_HORIZONTAL)
               .AddWindow(mZoomSlider);
#if wxUSE_ACCESSIBILITY
            // so that name can be set on a standard control
            mZoomSlider->SetAccessible(safenew WindowAccessible(mZoomSlider));
#endif
 
            S.AddSpace(5);
 
            wxStaticBitmap *zo = safenew wxStaticBitmap(S.GetParent(), wxID_ANY, wxBitmap(ZoomOut));
            S.Position(wxALIGN_CENTER)
               .AddWindow(zo);
         }
         S.EndVerticalLay();
 
         S.AddSpace(5, wxDefaultCoord);
      }
      S.EndHorizontalLay();
 
      // -------------------------------------------------------------------
      // ROW 2: Frequency ruler
      // -------------------------------------------------------------------
 
      S.AddSpace(1);
 
      S.StartHorizontalLay(wxEXPAND, 0);
      {
         hRuler  = safenew RulerPanel(
            S.GetParent(), wxID_ANY, wxHORIZONTAL,
            wxSize{ 100, 100 }, // Ruler can't handle small sizes
            RulerPanel::Range{ 10, 20000 },
            RealFormat::LinearInstance(),
            XO("Hz"),
            RulerPanel::Options{}
               .Log(true)
               .Flip(true)
               .LabelEdges(true)
               .TickColour( theTheme.Colour( clrGraphLabels ) )
         );
 
         S.AddSpace(1, wxDefaultCoord);
         S.Prop(1)
            .Position(wxALIGN_LEFT | wxALIGN_TOP)
            .AddWindow(hRuler);
         S.AddSpace(1, wxDefaultCoord);
      }
      S.EndHorizontalLay();
 
      S.AddSpace(1);
 
      // -------------------------------------------------------------------
      // ROW 3: Spacer
      // -------------------------------------------------------------------
 
      S.AddSpace(5);
      S.AddSpace(5);
      S.AddSpace(5);
 
      // -------------------------------------------------------------------
      // ROW 4: Info
      // -------------------------------------------------------------------
 
      S.AddSpace(1);
 
      S.StartHorizontalLay(wxEXPAND);
      {
         S.SetSizerProportion(1);
         S.StartMultiColumn(6);
         S.SetStretchyCol(1);
         S.SetStretchyCol(3);
         {
            S.AddPrompt(XXO("Cursor:"));
 
            mCursorText = S.Style(wxTE_READONLY)
               .AddTextBox( {}, wxT(""), 10);
 
            S.AddPrompt(XXO("Peak:"));
 
            mPeakText = S.Style(wxTE_READONLY)
               .AddTextBox( {}, wxT(""), 10);
            S.AddSpace(5);
 
            mGridOnOff = S.Id(GridOnOffID).AddCheckBox(XXO("&Grids"), mDrawGrid);
         }
         S.EndMultiColumn();
      }
      S.EndHorizontalLay();
 
      S.AddSpace(1);
   }
   S.EndMultiColumn();
 
   // -------------------------------------------------------------------
   // ROW 5: Spacer
   // -------------------------------------------------------------------
 
   S.AddSpace(5);
 
   S.SetBorder(2);
   S.SetSizerProportion(0);
   S.StartMultiColumn(9, wxALIGN_CENTER);
   {
      // ----------------------------------------------------------------
      // ROW 6: Algorithm, Size, Export, Replot
      // ----------------------------------------------------------------
 
      S.AddSpace(5);
 
      mAlgChoice = S.Id(FreqAlgChoiceID).Focus()
         .MinSize( { wxDefaultCoord, wxDefaultCoord } )
         .AddChoice(XXO("&Algorithm:"), algChoices, mAlg);
 
      S.AddSpace(5);
 
      mSizeChoice = S.Id(FreqSizeChoiceID)
         .MinSize( { wxDefaultCoord, wxDefaultCoord } )
         .AddChoice(XXO("&Size:"), sizeChoices, mSize);
 
      S.AddSpace(5);
 
      mExportButton = S.Id(FreqExportButtonID).AddButton(XXO("&Export..."));
 
      S.AddSpace(5);
 
      // ----------------------------------------------------------------
      // ROW 7: Function, Axis, Grids, Close
      // ----------------------------------------------------------------
 
      S.AddSpace(5);
 
      mFuncChoice = S.Id(FreqFuncChoiceID)
         .MinSize( { wxDefaultCoord, wxDefaultCoord } )
         .AddChoice(XXO("&Function:"), funcChoices, mFunc);
      mFuncChoice->MoveAfterInTabOrder(mSizeChoice);
 
      S.AddSpace(5);
 
      mAxisChoice = S.Id(FreqAxisChoiceID)
         .MinSize( { wxDefaultCoord, wxDefaultCoord } )
         .AddChoice(XXO("&Axis:"), axisChoices, mAxis);
      mAxisChoice->MoveAfterInTabOrder(mFuncChoice);
 
      S.AddSpace(5);
 
      mReplotButton = S.Id(ReplotButtonID).AddButton(XXO("&Replot..."));
 
      S.AddSpace(5);
 
      //mCloseButton = S.Id(wxID_CANCEL).AddButton(XO("&Close"));
 
      //S.AddSpace(5);
   }
   S.EndMultiColumn();
   S.AddStandardButtons( eHelpButton | eCloseButton );
 
   // -------------------------------------------------------------------
   // ROW 8: Spacer
   // -------------------------------------------------------------------
 
   S.AddSpace(5);
 
   mProgress = safenew FreqGauge(S.GetParent(), wxID_ANY); //, wxST_SIZEGRIP);
   S.Position(wxEXPAND)
      .AddWindow(mProgress);
 
   // Log-frequency axis works for spectrum plots only.
   if (mAlg != SpectrumAnalyst::Spectrum)
   {
      mAxis = 0;
      mAxisChoice->Disable();
   }
   mLogAxis = mAxis != 0;
 
   mCloseButton = static_cast<wxButton*>(FindWindowById( wxID_CANCEL ));
   mCloseButton->SetDefault();
 
   Layout();
   Fit();
   // Bug 1607:
   Center();
 
   SetMinSize(GetSize());
 
#if defined(__WXGTK__)
   // This should be rechecked with wx3.
   //
   // The scrollbar (focus some reason) doesn't allow tabbing past it
   // because it can't receive focus.  So, convince it otherwise.
   //
   // Unfortunately, this still doesn't let you adjust the scrollbar
   // from the keyboard.  Near as I can tell, wxWGTK is capturing the
   // keyboard input, so the GTK widget doesn't see it, preventing
   // the normal scroll events from being generated.
   //
   // I guess the only way round it would be to handle key actions
   // ourselves, but we'll leave that for a future date.
//   gtk_widget_set_can_focus(mPanScroller->m_widget, true);
#endif
}

References ThemeBase::Colour(), PlotSpectrumBase::dBRange, DecibelScaleCutoff, eCloseButton, eHelpButton, eIsCreating, fontSize, FREQ_WINDOW_HEIGHT, FreqAlgChoiceID, FreqAxisChoiceID, FreqExportButtonID, FreqFuncChoiceID, FreqPanScrollerID, FreqPlot, FreqSizeChoiceID, FrequencyAnalysisTitle, FreqZoomSliderID, GridOnOffID, hRuler, LinearDBFormat::Instance(), RulerPanel::Options::LabelEdges(), RealFormat::LinearInstance(), RulerPanel::Options::Log(), PlotSpectrumBase::mAlg, mAlgChoice, mArrowCursor, PlotSpectrumBase::mAxis, mAxisChoice, mCloseButton, mCrossCursor, mCursorText, PlotSpectrumBase::mDrawGrid, mExportButton, mFreqFont, mFreqPlot, PlotSpectrumBase::mFunc, mFuncChoice, mGridOnOff, mLogAxis, mPanScroller, mPeakText, mProgress, mReplotButton, PlotSpectrumBase::mSize, mSizeChoice, PlotSpectrumBase::mWindowSize, mZoomSlider, NumWindowFuncs(), Setting< T >::Read(), ReplotButtonID, S, safenew, wxDialogWrapper::SetTitle(), size, SpectrumAnalyst::Spectrum, theTheme, Verbatim(), vRuler, WindowFuncName(), wxT(), XO(), XXO(), ZoomIn, and ZoomOut.

Referenced by UpdatePrefs().

Here is the call graph for this function:

Here is the caller graph for this function:

Recalc()

void FrequencyPlotDialog::Recalc ( )

private

Definition at line 943 of file FreqWindow.cpp.

{
   if (!mData || mDataLen < mWindowSize) {
      DrawPlot();
      return;
   }
 
   SpectrumAnalyst::Algorithm alg =
      SpectrumAnalyst::Algorithm(mAlgChoice->GetSelection());
   int windowFunc = mFuncChoice->GetSelection();
 
   wxWindow *hadFocus = FindFocus();
   // In wxMac, the skipped window MUST be a top level window.  I'd originally made it
   // just the mProgress window with the idea of preventing user interaction with the
   // controls while the plot was being recalculated.  This doesn't appear to be necessary
   // so just use the top level window instead.
   {
      std::optional<wxWindowDisabler> blocker;
      if (IsShown())
         blocker.emplace(this);
      wxYieldIfNeeded();
 
      auto first = true;
      auto progress = [&](long long num, long long den) {
         if (first) {
            mProgress->SetRange(den);
            first = false;
         }
         mProgress->SetValue(num);
      };
 
      mAnalyst->Calculate(alg, windowFunc, mWindowSize, mRate,
         mData.get(), mDataLen,
         &mYMin, &mYMax, std::move(progress));
 
      mProgress->Reset();
   }
   if (hadFocus) {
      hadFocus->SetFocus();
   }
 
   if (alg == SpectrumAnalyst::Spectrum) {
      if(mYMin < -dBRange)
         mYMin = -dBRange;
      if(mYMax <= -dBRange)
         mYMax = -dBRange + 10.; // it's all out of range, but show a scale.
      else
         mYMax += .5;
   }
 
   // Prime the scrollbar
   mPanScroller->SetScrollbar(0, (mYMax - mYMin) * 100, (mYMax - mYMin) * 100, 1);
 
   DrawPlot();
}

References PlotSpectrumBase::dBRange, DrawPlot(), BasicUI::FindFocus(), mAlgChoice, PlotSpectrumBase::mAnalyst, PlotSpectrumBase::mData, PlotSpectrumBase::mDataLen, mFuncChoice, mPanScroller, mProgress, PlotSpectrumBase::mRate, PlotSpectrumBase::mWindowSize, mYMax, mYMin, FreqGauge::Reset(), FreqGauge::SetRange(), FreqGauge::SetValue(), and SpectrumAnalyst::Spectrum.

Referenced by OnRecalc(), and Show().

Here is the call graph for this function:

Here is the caller graph for this function:

SendRecalcEvent()

void FrequencyPlotDialog::SendRecalcEvent ( )

private

Definition at line 937 of file FreqWindow.cpp.

{
   wxCommandEvent e(EVT_FREQWINDOW_RECALC, wxID_ANY);
   GetEventHandler()->AddPendingEvent(e);
}

Referenced by OnAlgChoice(), OnFuncChoice(), OnReplot(), and OnSizeChoice().

Here is the caller graph for this function:

Show()

bool FrequencyPlotDialog::Show ( bool  show = true )

override

Definition at line 545 of file FreqWindow.cpp.

{
   if (!show)
   {
      mFreqPlot->SetCursor(*mArrowCursor);
   }
 
   bool shown = IsShown();
 
   if (show && !shown)
   {
      dBRange = DecibelScaleCutoff.Read();
      if(dBRange < 90.)
         dBRange = 90.;
      if (!GetAudio())
         return false;
      // Don't send an event.  We need the recalc right away.
      // so that mAnalyst is valid when we paint.
      //SendRecalcEvent();
      Recalc();
   }
 
   bool res = wxDialogWrapper::Show(show);
 
   return res;
}

References PlotSpectrumBase::dBRange, DecibelScaleCutoff, PlotSpectrumBase::GetAudio(), mArrowCursor, mFreqPlot, Setting< T >::Read(), Recalc(), and ExportProgressUI::Show().

Referenced by OnCloseButton(), OnCloseWindow(), anonymous_namespace{FreqWindow.cpp}::OnPlotSpectrum(), and UpdatePrefs().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdatePrefs()

void FrequencyPlotDialog::UpdatePrefs ( )

overrideprivatevirtual

Implements PrefsListener.

Definition at line 1064 of file FreqWindow.cpp.

{
   bool shown = IsShown();
   if (shown) {
      Show(false);
   }
 
   auto zoomSlider = mZoomSlider->GetValue();
   auto drawGrid = mGridOnOff->GetValue();
   auto sizeChoice = mSizeChoice->GetStringSelection();
   auto algChoice = mAlgChoice->GetSelection();
   auto funcChoice = mFuncChoice->GetSelection();
   auto axisChoice = mAxisChoice->GetSelection();
 
   SetSizer(nullptr);
   DestroyChildren();
 
   Populate();
 
   mZoomSlider->SetValue(zoomSlider);
 
   mDrawGrid = drawGrid;
   mGridOnOff->SetValue(drawGrid);
 
   long windowSize = 0;
   sizeChoice.ToLong(&windowSize);
   mWindowSize = windowSize;
   mSizeChoice->SetStringSelection(sizeChoice);
 
   mAlg = static_cast<SpectrumAnalyst::Algorithm>(algChoice);
   mAlgChoice->SetSelection(algChoice);
 
   mFunc = funcChoice;
   mFuncChoice->SetSelection(funcChoice);
 
   mAxis = axisChoice;
   mAxisChoice->SetSelection(axisChoice);
 
   if (shown) {
      Show(true);
   }
}

References PlotSpectrumBase::mAlg, mAlgChoice, PlotSpectrumBase::mAxis, mAxisChoice, PlotSpectrumBase::mDrawGrid, PlotSpectrumBase::mFunc, mFuncChoice, mGridOnOff, mSizeChoice, PlotSpectrumBase::mWindowSize, mZoomSlider, Populate(), and Show().

Here is the call graph for this function:

Friends And Related Function Documentation

FreqPlot

friend class FreqPlot

friend

Definition at line 140 of file FreqWindow.h.

Referenced by Populate().

Member Data Documentation

fontSize

const int FrequencyPlotDialog::fontSize = 8

staticprivate

Definition at line 98 of file FreqWindow.h.

Referenced by Populate().

hRuler

RulerPanel* FrequencyPlotDialog::hRuler

private

Definition at line 104 of file FreqWindow.h.

Referenced by DrawPlot(), and Populate().

mAlgChoice

wxChoice* FrequencyPlotDialog::mAlgChoice

private

Definition at line 119 of file FreqWindow.h.

Referenced by OnAlgChoice(), OnCloseButton(), OnExport(), Populate(), Recalc(), and UpdatePrefs().

mArrowCursor

std::unique_ptr<wxCursor> FrequencyPlotDialog::mArrowCursor

private

Definition at line 112 of file FreqWindow.h.

Referenced by PlotMouseEvent(), Populate(), and Show().

mAxisChoice

wxChoice* FrequencyPlotDialog::mAxisChoice

private

Definition at line 122 of file FreqWindow.h.

Referenced by OnAlgChoice(), OnAxisChoice(), OnCloseButton(), Populate(), and UpdatePrefs().

mBitmap

std::unique_ptr<wxBitmap> FrequencyPlotDialog::mBitmap

private

Definition at line 133 of file FreqWindow.h.

Referenced by DrawBackground(), and PlotPaint().

mCloseButton

wxButton* FrequencyPlotDialog::mCloseButton

private

Definition at line 115 of file FreqWindow.h.

Referenced by Populate().

mCrossCursor

std::unique_ptr<wxCursor> FrequencyPlotDialog::mCrossCursor

private

Definition at line 113 of file FreqWindow.h.

Referenced by PlotMouseEvent(), and Populate().

mCursorText

wxTextCtrl* FrequencyPlotDialog::mCursorText

private

Definition at line 125 of file FreqWindow.h.

Referenced by PlotPaint(), and Populate().

mExportButton

wxButton* FrequencyPlotDialog::mExportButton

private

Definition at line 116 of file FreqWindow.h.

Referenced by Populate().

mFreqFont

wxFont FrequencyPlotDialog::mFreqFont

private

Definition at line 110 of file FreqWindow.h.

Referenced by DrawBackground(), PlotPaint(), and Populate().

mFreqPlot

FreqPlot* FrequencyPlotDialog::mFreqPlot

private

Definition at line 105 of file FreqWindow.h.

Referenced by DrawBackground(), DrawPlot(), PlotMouseEvent(), Populate(), and Show().

mFuncChoice

wxChoice* FrequencyPlotDialog::mFuncChoice

private

Definition at line 121 of file FreqWindow.h.

Referenced by OnCloseButton(), Populate(), Recalc(), and UpdatePrefs().

mGridOnOff

wxCheckBox* FrequencyPlotDialog::mGridOnOff

private

Definition at line 118 of file FreqWindow.h.

Referenced by OnGridOnOff(), Populate(), and UpdatePrefs().

mLogAxis

bool FrequencyPlotDialog::mLogAxis

private

Definition at line 128 of file FreqWindow.h.

Referenced by DrawPlot(), OnAlgChoice(), OnAxisChoice(), PlotPaint(), and Populate().

mMouseX

int FrequencyPlotDialog::mMouseX

private

Definition at line 135 of file FreqWindow.h.

Referenced by PlotMouseEvent(), and PlotPaint().

mMouseY

int FrequencyPlotDialog::mMouseY

private

Definition at line 136 of file FreqWindow.h.

Referenced by PlotMouseEvent(), and PlotPaint().

mPanScroller

wxScrollBar* FrequencyPlotDialog::mPanScroller

private

Definition at line 123 of file FreqWindow.h.

Referenced by DrawPlot(), Populate(), and Recalc().

mPeakText

wxTextCtrl* FrequencyPlotDialog::mPeakText

private

Definition at line 126 of file FreqWindow.h.

Referenced by PlotPaint(), and Populate().

mPlotRect

wxRect FrequencyPlotDialog::mPlotRect

private

Definition at line 108 of file FreqWindow.h.

Referenced by DrawBackground(), DrawPlot(), PlotMouseEvent(), and PlotPaint().

mProgress

FreqGauge* FrequencyPlotDialog::mProgress

private

Definition at line 106 of file FreqWindow.h.

Referenced by Populate(), and Recalc().

mReplotButton

wxButton* FrequencyPlotDialog::mReplotButton

private

Definition at line 117 of file FreqWindow.h.

Referenced by Populate().

mSizeChoice

wxChoice* FrequencyPlotDialog::mSizeChoice

private

Definition at line 120 of file FreqWindow.h.

Referenced by OnCloseButton(), OnSizeChoice(), Populate(), and UpdatePrefs().

mYMax

float FrequencyPlotDialog::mYMax

private

Definition at line 130 of file FreqWindow.h.

Referenced by DrawPlot(), and Recalc().

mYMin

float FrequencyPlotDialog::mYMin

private

Definition at line 129 of file FreqWindow.h.

Referenced by DrawPlot(), and Recalc().

mYStep

float FrequencyPlotDialog::mYStep

private

Definition at line 131 of file FreqWindow.h.

mZoomSlider

wxSlider* FrequencyPlotDialog::mZoomSlider

private

Definition at line 124 of file FreqWindow.h.

Referenced by DrawPlot(), Populate(), and UpdatePrefs().

vRuler

RulerPanel* FrequencyPlotDialog::vRuler

private

Definition at line 103 of file FreqWindow.h.

Referenced by DrawPlot(), and Populate().

---

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

• FreqWindow.h
• FreqWindow.cpp