EqualizationUI Class Reference

#include <EqualizationUI.h>

Inheritance diagram for EqualizationUI:

Collaboration diagram for EqualizationUI:

Public Member Functions
	EqualizationUI (EffectUIServices &uiServices, const wxWeakRef< wxWindow > &uiParent, const TranslatableString &name, EqualizationCurvesList &curvesList, int options)
bool	ValidateUI (EffectSettings &settings)
std::unique_ptr< EffectEditor >	PopulateOrExchange (ShuttleGui &S, EffectInstance &instance, EffectSettingsAccess &access, const EffectOutputs *pOutputs)
bool	TransferDataToWindow (const EffectSettings &settings)

Private Member Functions
template<typename EventTag , typename Class , typename Event >
void	BindTo (wxEvtHandler &src, const EventTag &eventType, void(Class::*pmf)(Event &))
void	UpdateCurves ()
void	UpdateRuler ()
void	UpdateDraw ()
void	UpdateGraphic ()
void	OnSize (wxSizeEvent &event)
void	OnInterp (wxCommandEvent &event)
void	OnSliderM (wxCommandEvent &event)
void	OnSliderDBMAX (wxCommandEvent &event)
void	OnSliderDBMIN (wxCommandEvent &event)
void	OnDrawMode (wxCommandEvent &event)
void	OnGraphicMode (wxCommandEvent &event)
void	OnCurve (wxCommandEvent &event)
void	OnManage (wxCommandEvent &event)
void	OnClear (wxCommandEvent &event)
void	OnInvert (wxCommandEvent &event)
void	OnGridOnOff (wxCommandEvent &event)
void	OnLinFreq (wxCommandEvent &event)
void	OnIdle (wxIdleEvent &event)

Private Attributes
EffectUIServices &	mUIServices
const wxWeakRef< wxWindow > &	mUIParent
EqualizationCurvesList &	mCurvesList
TranslatableString	mName
const int	mOptions
RulerPanel *	mdBRuler
RulerPanel *	mFreqRuler
wxSizer *	szrC
wxSizer *	szrG
wxSizer *	szrV
wxSizer *	szrH
wxSizer *	szrI
wxSizer *	szrL
wxSizer *	szr1
wxSizer *	szr2
wxSizer *	szr3
wxSizer *	szr4
wxSizer *	szr5
wxSizerItem *	mLeftSpacer
wxWeakRef< EqualizationPanel >	mPanel {}
wxRadioButton *	mDraw {}
wxRadioButton *	mGraphic {}
wxCheckBox *	mLinFreq
wxCheckBox *	mGridOnOff
wxChoice *	mInterpChoice
wxWeakRef< wxChoice >	mCurve {}
wxButton *	mManage
wxStaticText *	mMText
wxSlider *	mMSlider {}
wxSlider *	mdBMinSlider
wxSlider *	mdBMaxSlider
EqualizationBandSliders	mBands { mCurvesList }

Detailed Description

Definition at line 33 of file EqualizationUI.h.

Constructor & Destructor Documentation

EqualizationUI()

EqualizationUI::EqualizationUI ( EffectUIServices &  uiServices, const wxWeakRef< wxWindow > &  uiParent, const TranslatableString &  name, EqualizationCurvesList &  curvesList, int  options  )

inline

Definition at line 35 of file EqualizationUI.h.

      : mUIServices{ uiServices }
      , mUIParent{ uiParent }
      , mName{ name }
      , mCurvesList{ curvesList }
      , mOptions{ options }
   {}

Member Function Documentation

BindTo()

template<typename EventTag , typename Class , typename Event >

void EqualizationUI::BindTo ( wxEvtHandler &  src, const EventTag &  eventType, void(Class::*)(Event &)  pmf  )

inlineprivate

Definition at line 56 of file EqualizationUI.h.

   {
      src.Bind(eventType, pmf, static_cast<Class *>(this));
   }

Referenced by PopulateOrExchange().

Here is the caller graph for this function:

OnClear()

void EqualizationUI::OnClear ( wxCommandEvent &  event )

private

Definition at line 803 of file EqualizationUI.cpp.

{
   mBands.Flatten();
}

References EqualizationBandSliders::Flatten(), and mBands.

Referenced by PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

OnCurve()

void EqualizationUI::OnCurve ( wxCommandEvent &  event )

private

Definition at line 774 of file EqualizationUI.cpp.

{
   // Select NEW curve
   wxASSERT( mCurve != NULL );
   mCurvesList.setCurve( mCurve->GetCurrentSelection() );
   if( !mCurvesList.mParameters.mDrawMode )
      UpdateGraphic();
}

References mCurve, mCurvesList, EqualizationParameters::mDrawMode, EqualizationCurvesList::mParameters, EqualizationCurvesList::setCurve(), and UpdateGraphic().

Referenced by PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

OnDrawMode()

void EqualizationUI::OnDrawMode ( wxCommandEvent &  event )

private

Definition at line 711 of file EqualizationUI.cpp.

{
   mCurvesList.mParameters.mDrawMode = true;
   UpdateDraw();
}

References mCurvesList, EqualizationParameters::mDrawMode, EqualizationCurvesList::mParameters, and UpdateDraw().

Referenced by PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

OnGraphicMode()

void EqualizationUI::OnGraphicMode ( wxCommandEvent &  event )

private

Definition at line 717 of file EqualizationUI.cpp.

{
   mCurvesList.mParameters.mDrawMode = false;
   UpdateGraphic();
}

References mCurvesList, EqualizationParameters::mDrawMode, EqualizationCurvesList::mParameters, and UpdateGraphic().

Referenced by PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

OnGridOnOff()

void EqualizationUI::OnGridOnOff ( wxCommandEvent &  event )

private

Definition at line 813 of file EqualizationUI.cpp.

{
   mCurvesList.mParameters.mDrawGrid = mGridOnOff->IsChecked();
   mPanel->Refresh(false);
}

References mCurvesList, EqualizationParameters::mDrawGrid, mGridOnOff, mPanel, and EqualizationCurvesList::mParameters.

Referenced by PopulateOrExchange().

Here is the caller graph for this function:

OnIdle()

void EqualizationUI::OnIdle ( wxIdleEvent &  event )

private

Definition at line 845 of file EqualizationUI.cpp.

{
   event.Skip();
   if (mCurve)
      mCurve->SetStringSelection(mCurvesList.mParameters.mCurveName);
}

References mCurve, EqualizationParameters::mCurveName, mCurvesList, and EqualizationCurvesList::mParameters.

OnInterp()

void EqualizationUI::OnInterp ( wxCommandEvent &  event )

private

Definition at line 699 of file EqualizationUI.cpp.

{
   auto &parameters = mCurvesList.mParameters;
   bool bIsGraphic = !parameters.mDrawMode;
   if (bIsGraphic)
   {
      mBands.GraphicEQ(parameters.mLogEnvelope);
      mCurvesList.EnvelopeUpdated();
   }
   parameters.mInterp = mInterpChoice->GetSelection();
}

References EqualizationCurvesList::EnvelopeUpdated(), EqualizationBandSliders::GraphicEQ(), mBands, mCurvesList, EqualizationParameters::mDrawMode, mInterpChoice, and EqualizationCurvesList::mParameters.

Referenced by PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

OnInvert()

void EqualizationUI::OnInvert ( wxCommandEvent &  event )

private

Definition at line 808 of file EqualizationUI.cpp.

{
   mBands.Invert();
}

References EqualizationBandSliders::Invert(), and mBands.

Referenced by PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

OnLinFreq()

void EqualizationUI::OnLinFreq ( wxCommandEvent &  event )

private

Definition at line 819 of file EqualizationUI.cpp.

{
   auto &parameters = mCurvesList.mParameters;
   auto &lin = parameters.mLin;
   const auto &loFreq = parameters.mLoFreq;
   const auto &hiFreq = parameters.mHiFreq;
 
   lin = mLinFreq->IsChecked();
   if(parameters.IsLinear())  //going from log to lin freq scale
   {
      mFreqRuler->ruler.SetUpdater(&LinearUpdater::Instance());
      mFreqRuler->ruler.SetRange(0, hiFreq);
      mBands.EnvLogToLin();
      lin = true;
   }
   else  //going from lin to log freq scale
   {
      mFreqRuler->ruler.SetUpdater(&LogarithmicUpdater::Instance());
      mFreqRuler->ruler.SetRange(loFreq, hiFreq);
      mBands.EnvLinToLog();
      lin = false;
   }
   mFreqRuler->Refresh(false);
   mCurvesList.ForceRecalc();
}

References EqualizationBandSliders::EnvLinToLog(), EqualizationBandSliders::EnvLogToLin(), EqualizationCurvesList::ForceRecalc(), LinearUpdater::Instance(), LogarithmicUpdater::Instance(), mBands, mCurvesList, mFreqRuler, EqualizationParameters::mLin, mLinFreq, EqualizationCurvesList::mParameters, RulerPanel::ruler, Ruler::SetRange(), and Ruler::SetUpdater().

Referenced by PopulateOrExchange(), and TransferDataToWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

OnManage()

void EqualizationUI::OnManage ( wxCommandEvent &  event )

private

Definition at line 786 of file EqualizationUI.cpp.

{
   auto &curves = mCurvesList.mCurves;
   EqualizationCurvesDialog d(mUIParent, mName, mOptions,
      curves, mCurve->GetSelection());
   if (d.ShowModal()) {
      wxGetTopLevelParent(mUIParent)->Layout();
      mCurvesList.setCurve(d.GetItem());
   }
 
   // Reload the curve names
   UpdateCurves();
 
   // Allow control to resize
   mUIParent->Layout();
}

References EqualizationCurvesDialog::GetItem(), mCurve, EqualizationCurvesList::mCurves, mCurvesList, mName, mOptions, mUIParent, EqualizationCurvesList::setCurve(), and UpdateCurves().

Referenced by PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSize()

void EqualizationUI::OnSize ( wxSizeEvent &  event )

private

Definition at line 693 of file EqualizationUI.cpp.

{
   mUIParent->Layout();
   event.Skip();
}

References mUIParent.

OnSliderDBMAX()

void EqualizationUI::OnSliderDBMAX ( wxCommandEvent &  event )

private

Definition at line 757 of file EqualizationUI.cpp.

{
   auto &dBMax = mCurvesList.mParameters.mdBMax;
 
   float dB = mdBMaxSlider->GetValue();
   if (dB != dBMax) {
      dBMax = dB;
      wxString tip;
      tip.Printf(_("%d dB"), (int)dBMax);
      mdBMaxSlider->SetToolTip(tip);
      UpdateRuler();
   }
}

References _, mCurvesList, EqualizationParameters::mdBMax, mdBMaxSlider, EqualizationCurvesList::mParameters, and UpdateRuler().

Referenced by PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSliderDBMIN()

void EqualizationUI::OnSliderDBMIN ( wxCommandEvent &  event )

private

Definition at line 743 of file EqualizationUI.cpp.

{
   auto &dBMin = mCurvesList.mParameters.mdBMin;
 
   float dB = mdBMinSlider->GetValue();
   if (dB != dBMin) {
      dBMin = dB;
      wxString tip;
      tip.Printf(_("%d dB"), (int)dBMin);
      mdBMinSlider->SetToolTip(tip);
      UpdateRuler();
   }
}

References _, mCurvesList, EqualizationParameters::mdBMin, mdBMinSlider, EqualizationCurvesList::mParameters, and UpdateRuler().

Referenced by PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSliderM()

void EqualizationUI::OnSliderM ( wxCommandEvent &  event )

private

Definition at line 723 of file EqualizationUI.cpp.

{
   auto &M = mCurvesList.mParameters.mM;
 
   size_t m = 2 * mMSlider->GetValue() + 1;
   // Must be odd
   wxASSERT( (m & 1) == 1 );
 
   if (m != M) {
      M = m;
      wxString tip;
      tip.Printf(wxT("%d"), (int)M);
      mMText->SetLabel(tip);
      mMText->SetName(mMText->GetLabel()); // fix for bug 577 (NVDA/Narrator screen readers do not read static text in dialogs)
      mMSlider->SetToolTip(tip);
 
      mCurvesList.ForceRecalc();
   }
}

References EqualizationCurvesList::ForceRecalc(), mCurvesList, EqualizationParameters::mM, mMSlider, mMText, EqualizationCurvesList::mParameters, and wxT().

Referenced by PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

PopulateOrExchange()

std::unique_ptr< EffectEditor > EqualizationUI::PopulateOrExchange	(	ShuttleGui &	S,
		EffectInstance &	instance,
		EffectSettingsAccess &	access,
		const EffectOutputs *	pOutputs
	)

Definition at line 108 of file EqualizationUI.cpp.

{
   mBands.Init();
 
   auto &parameters = mCurvesList.mParameters;
   const auto &M = parameters.mM;
   const auto &loFreq = parameters.mLoFreq;
   const auto &hiFreq = parameters.mHiFreq;
   const auto &curves = mCurvesList.mCurves;
 
   auto &drawMode = parameters.mDrawMode;
 
   S.SetBorder(0);
 
   S.SetSizerProportion(1);
   S.Prop(1).StartMultiColumn(1, wxEXPAND);
   {
      S.SetStretchyCol(0);
      //S.SetStretchyRow(0); // The 5px Top border
      S.SetStretchyRow(1);   // The Graph
      S.SetStretchyRow(2);   // The EQ sliders
      szrV = S.GetSizer();
 
      // -------------------------------------------------------------------
      // ROW 0: Top border
      // -------------------------------------------------------------------
      S.AddSpace(5);
 
      // -------------------------------------------------------------------
      // ROW 1: Equalization panel and sliders for vertical scale
      // -------------------------------------------------------------------
      S.SetSizerProportion(1);
      S.Prop(1).StartMultiColumn(3, wxEXPAND);
      {
         S.SetStretchyCol(1);
         S.SetStretchyRow(0);
         szr1 = S.GetSizer();
 
         S.StartVerticalLay(wxEXPAND, 1);
         {
            // Inserted into sizer later, but the EQ panel needs to point to it
            mFreqRuler  = safenew RulerPanel(
               S.GetParent(), wxID_ANY, wxHORIZONTAL,
               wxSize{ 100, 100 }, // Ruler can't handle small sizes
               RulerPanel::Range{ loFreq, hiFreq },
               IntFormat::Instance(),
               XO("Hz"),
               RulerPanel::Options{}
                  .Log(true)
                  .Flip(true)
                  .LabelEdges(true)
                  .TicksAtExtremes(true)
                  .TickColour( { 0, 0, 0 } )
            );
 
            mdBRuler = safenew RulerPanel(
               S.GetParent(), wxID_ANY, wxVERTICAL,
               wxSize{ 100, 100 }, // Ruler can't handle small sizes
               RulerPanel::Range{ 60.0, -120.0 },
               LinearDBFormat::Instance(),
               XO("dB"),
               RulerPanel::Options{}
                  .LabelEdges(true)
                  .TicksAtExtremes(true)
                  .TickColour( { 0, 0, 0 } )
            );
 
            S.Prop(0).AddSpace(0, 1);
            S.Prop(1)
               .Position(wxEXPAND)
               .AddWindow(mdBRuler);
            S.AddSpace(0, 1);
         }
         S.EndVerticalLay();
 
         parameters.ChooseEnvelope().Flatten(0.);
         parameters.ChooseEnvelope().SetTrackLen(1.0);
         mPanel = safenew EqualizationPanel(S.GetParent(), wxID_ANY,
            mCurvesList, *mFreqRuler, *mdBRuler);
         S.Prop(1)
            .Position(wxEXPAND)
            .MinSize( { wxDefaultCoord, wxDefaultCoord } )
            .AddWindow(mPanel);
 
         S.SetBorder(5);
         S.StartVerticalLay();
         {
            S.AddVariableText(XO("+ dB"), false, wxCENTER);
            mdBMaxSlider = S
               .Name(XO("Max dB"))
               .Style(wxSL_VERTICAL | wxSL_INVERSE)
               .AddSlider( {}, 30, 60, 0);
#if wxUSE_ACCESSIBILITY
            mdBMaxSlider->SetAccessible(safenew SliderAx(mdBMaxSlider, XO("%d dB")));
#endif
            BindTo(*mdBMaxSlider, wxEVT_SLIDER,
               &EqualizationUI::OnSliderDBMAX);
 
            mdBMinSlider = S
               .Name(XO("Min dB"))
               .Style(wxSL_VERTICAL | wxSL_INVERSE)
               .AddSlider( {}, -30, -10, -120);
            S.AddVariableText(XO("- dB"), false, wxCENTER);
#if wxUSE_ACCESSIBILITY
            mdBMinSlider->SetAccessible(safenew SliderAx(mdBMinSlider, XO("%d dB")));
#endif
            BindTo(*mdBMinSlider, wxEVT_SLIDER,
               &EqualizationUI::OnSliderDBMIN);
         }
         S.EndVerticalLay();
         S.SetBorder(0);
 
         // -------------------------------------------------------------------
         // Frequency ruler below graph
         // -------------------------------------------------------------------
 
         // Column 1 is empty
         S.AddSpace(1, 1);
 
         S.SetBorder(1);
         S.Prop(1)
            .Position(wxEXPAND | wxALIGN_LEFT | wxALIGN_TOP | wxLEFT)
            .AddWindow(mFreqRuler);
         S.SetBorder(0);
 
         // Column 3 is empty
         S.AddSpace(1, 1);
      }
      S.EndMultiColumn();
 
      // -------------------------------------------------------------------
      // ROW 2: Graphic EQ
      // -------------------------------------------------------------------
      S.SetSizerProportion(1);
      S.StartHorizontalLay(wxEXPAND, 1);
      {
         szrG = S.GetSizer();
 
         // Panel used to host the sliders since they will be positioned manually.
         //mGraphicPanel = S.Prop(1)
            //.Position(wxEXPAND)
            //.Size( { -1, 150 } )
            //.StartPanel();
         S.AddSpace(15,0);
         {
         mBands.AddBandSliders(S);
         S.AddSpace(15,0);
         } //S.EndPanel();
      }
      S.EndHorizontalLay();
 
      // -------------------------------------------------------------------
      // ROW 4: Various controls
      // -------------------------------------------------------------------
      S.SetSizerProportion(1);
      S.Prop(1).StartMultiColumn(7, wxALIGN_CENTER_HORIZONTAL);
      {
         S.SetBorder(5);
 
         S.AddSpace(5, 5);
 
         if( mOptions == kEqLegacy )
         {
            S.StartHorizontalLay(wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
            {
               S.AddPrompt(XXO("&EQ Type:"));
            }
            S.EndHorizontalLay();
 
            S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 1);
            {
               S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 1);
               {
                  mDraw = S
                     .Name(XO("Draw Curves"))
                     .AddRadioButton(XXO("&Draw"));
                  BindTo(*mDraw, wxEVT_RADIOBUTTON,
                     &EqualizationUI::OnDrawMode);
 
                  mGraphic = S
                     .Name(XO("Graphic EQ"))
                     .AddRadioButtonToGroup(XXO("&Graphic"));
                  BindTo(*mGraphic, wxEVT_RADIOBUTTON,
                     &EqualizationUI::OnGraphicMode);
               }
               S.EndHorizontalLay();
            }
            S.EndHorizontalLay();
         }
 
         S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 0);
         {
            szrH = S.GetSizer();
 
            S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 1);
            {
               szrI = S.GetSizer();
 
               mInterpChoice = S
                  .Name(XO("Interpolation type"))
                  .AddChoice( {},
                     Msgids(EqualizationParameters::kInterpStrings,
                        EqualizationParameters::nInterpolations),
                     0 );
#if wxUSE_ACCESSIBILITY
               // so that name can be set on a standard control
               mInterpChoice->SetAccessible(safenew WindowAccessible(mInterpChoice));
#endif
               BindTo(*mInterpChoice, wxEVT_CHOICE,
                  &EqualizationUI::OnInterp);
            }
            S.EndHorizontalLay();
 
            S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 1);
            {
               szrL = S.GetSizer();
 
               mLinFreq = S
                  .Name(XO("Linear Frequency Scale"))
                  .AddCheckBox(XXO("Li&near Frequency Scale"), false);
               BindTo(*mLinFreq, wxEVT_CHECKBOX,
                  &EqualizationUI::OnLinFreq);
            }
            S.EndHorizontalLay();
         }
         S.EndHorizontalLay();
 
         // -------------------------------------------------------------------
         // Filter length grouping
         // -------------------------------------------------------------------
 
         if( mOptions == kEqLegacy ){
            S.StartHorizontalLay(wxEXPAND, 0);
            {
               S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 0);
               {
                  S.AddPrompt(XXO("Length of &Filter:"));
               }
               S.EndHorizontalLay();
 
               S.StartHorizontalLay(wxEXPAND, 1);
               {
                  mMSlider = S
                     .Name(XO("Length of Filter"))
                     .Style(wxSL_HORIZONTAL)
                     .AddSlider( {}, (M - 1) / 2, 4095, 10);
                  BindTo(*mMSlider, wxEVT_SLIDER,
                     &EqualizationUI::OnSliderM);
               }
               S.EndHorizontalLay();
 
               S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 0);
               {
                  wxString label;
                  label.Printf(wxT("%ld"), M);
                  mMText = S.Name( Verbatim( label ) )
                  // fix for bug 577 (NVDA/Narrator screen readers do not
                  // read static text in dialogs)
                     .AddVariableText( Verbatim( label ) );
               }
               S.EndHorizontalLay();
            }
            S.EndHorizontalLay();
 
            S.AddSpace(1, 1);
         }
 
         S.AddSpace(5, 5);
 
         if( mOptions == kEqLegacy ){
            S.AddSpace(5, 5);
            S.StartHorizontalLay(wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
            {
               S.AddPrompt(XXO("&Select Curve:"));
            }
            S.EndHorizontalLay();
 
            S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 1);
            {
               S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 1);
               {
                  mCurve = S
                     .Name(XO("Select Curve"))
                     .AddChoice( {},
                        [&curves]{
                           TranslatableStrings names;
                           for (const auto &curve : curves)
                              names.push_back( Verbatim( curve.Name ) );
                           return names;
                        }()
                     );
                  BindTo(*mCurve, wxEVT_CHOICE,
                     &EqualizationUI::OnCurve);
               }
               S.EndHorizontalLay();
            }
            S.EndHorizontalLay();
 
            const auto pButton = S
               .AddButton(XXO("S&ave/Manage Curves..."));
            BindTo(*pButton, wxEVT_BUTTON, &EqualizationUI::OnManage);
         }
 
         S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 1);
         {
            auto pButton = S
               .AddButton(XXO("Fla&tten"));
            BindTo(*pButton, wxEVT_BUTTON, &EqualizationUI::OnClear);
 
            pButton = S
               .AddButton(XXO("&Invert"));
            BindTo(*pButton, wxEVT_BUTTON, &EqualizationUI::OnInvert);
 
            mGridOnOff = S
               .Name(XO("Show grid lines"))
               .AddCheckBox(XXO("Show g&rid lines"), false);
            BindTo(*mGridOnOff, wxEVT_CHECKBOX,
               &EqualizationUI::OnGridOnOff);
         }
         S.EndHorizontalLay();
 
         S.AddSpace(5, 5);
      }
      S.EndMultiColumn();
   }
   S.EndMultiColumn();
 
   mUIParent->SetAutoLayout(false);
   if( mOptions != kEqOptionGraphic)
      mUIParent->Layout();
 
   if( mOptions == kEqOptionCurve)
      drawMode = true;
   if( mOptions == kEqOptionGraphic)
      drawMode = false;
 
   // "show" settings for graphics mode before setting the size of the dialog
   // as this needs more space than draw mode
   szrV->Show(szrG,!drawMode);  // eq sliders
   szrH->Show(szrI,true);  // interpolation choice
   szrH->Show(szrL,false); // linear freq checkbox
 
   if( mOptions == kEqOptionGraphic){
      mPanel->Show( false );
      wxSize sz = szrV->GetMinSize();
      sz += wxSize( 30, 0);
      mUIParent->SetMinSize(sz);
   }
   else{
      mPanel->Show( true );
      szrV->Show(szr1, true);
      // This sizing calculation is hacky.
      // Rather than set the true minimum size we set a size we would
      // like to have.
      // This makes the default size of the dialog good, but has the
      // downside that the user can't adjust the dialog smaller.
      wxSize sz = szrV->GetMinSize();
      sz += wxSize( 400, 100);
      szrV->SetMinSize(sz);
   }
   mCurvesList.ForceRecalc();
 
   return std::make_unique<EqualizationUIEditor>(*this, mUIServices, access, mUIParent);
}

References EqualizationBandSliders::AddBandSliders(), BindTo(), EqualizationCurvesList::ForceRecalc(), EqualizationBandSliders::Init(), IntFormat::Instance(), LinearDBFormat::Instance(), kEqLegacy, kEqOptionCurve, kEqOptionGraphic, EqualizationParameters::kInterpStrings, label, RulerPanel::Options::LabelEdges(), RulerPanel::Options::Log(), mBands, mCurve, EqualizationCurvesList::mCurves, mCurvesList, mdBMaxSlider, mdBMinSlider, mdBRuler, mDraw, mFreqRuler, mGraphic, mGridOnOff, mInterpChoice, mLinFreq, EqualizationParameters::mM, mMSlider, mMText, mOptions, mPanel, EqualizationCurvesList::mParameters, Msgids(), mUIParent, mUIServices, names, EqualizationParameters::nInterpolations, OnClear(), OnCurve(), OnDrawMode(), OnGraphicMode(), OnGridOnOff(), OnInterp(), OnInvert(), OnLinFreq(), OnManage(), OnSliderDBMAX(), OnSliderDBMIN(), OnSliderM(), S, safenew, szr1, szrG, szrH, szrI, szrL, szrV, Verbatim(), wxT(), XO(), and XXO().

Referenced by EffectEqualization::PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

TransferDataToWindow()

bool EqualizationUI::TransferDataToWindow

(

const EffectSettings &

settings

)

Definition at line 475 of file EqualizationUI.cpp.

{
   auto &parameters = mCurvesList.mParameters;
   const auto &lin = parameters.mLin;
   const auto &drawGrid = parameters.mDrawGrid;
   const auto &M = parameters.mM;
   const auto &dBMin = parameters.mdBMin;
   const auto &dBMax = parameters.mdBMax;
   const auto &interp = parameters.mInterp;
 
   auto &drawMode = parameters.mDrawMode;
 
   // Set log or lin freq scale (affects interpolation as well)
   mLinFreq->SetValue( lin );
   wxCommandEvent dummyEvent;
   OnLinFreq(dummyEvent);  // causes a CalcFilter
 
   mGridOnOff->SetValue( drawGrid ); // checks/unchecks the box on the interface
 
   if( mMSlider )
      mMSlider->SetValue((M - 1) / 2);
 
   mdBMinSlider->SetValue((int)dBMin);
   mdBMaxSlider->SetValue((int)dBMax);
 
   // Reload the curve names
   UpdateCurves();
 
   // Set graphic interpolation mode
   mInterpChoice->SetSelection(interp);
 
   // Override draw mode, if we're not displaying the radio buttons.
   if( mOptions == kEqOptionCurve)
      drawMode = true;
   if( mOptions == kEqOptionGraphic)
      drawMode = false;
 
   if( mDraw )
      mDraw->SetValue(drawMode);
   szrV->Show(szr1,mOptions != kEqOptionGraphic); // Graph
   szrV->Show(szrG,!drawMode);    // eq sliders
   szrH->Show(szrI,mOptions == kEqLegacy );    // interpolation choice
   szrH->Show(szrL, drawMode);    // linear freq checkbox
   if( mGraphic)
      mGraphic->SetValue(!drawMode);
   mGridOnOff->Show( drawMode );
 
   // Set Graphic (Fader) or Draw mode
   if (!drawMode)
      UpdateGraphic();
 
   UpdateRuler();
 
   mUIParent->Layout();
   wxGetTopLevelParent(mUIParent)->Layout();
 
   return true;
}

References kEqLegacy, kEqOptionCurve, kEqOptionGraphic, mCurvesList, mdBMaxSlider, mdBMinSlider, mDraw, mGraphic, mGridOnOff, mInterpChoice, EqualizationParameters::mLin, mLinFreq, mMSlider, mOptions, EqualizationCurvesList::mParameters, mUIParent, OnLinFreq(), szr1, szrG, szrH, szrI, szrL, szrV, UpdateCurves(), UpdateGraphic(), and UpdateRuler().

Referenced by EffectEqualization::TransferDataToWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateCurves()

void EqualizationUI::UpdateCurves ( )

private

Definition at line 562 of file EqualizationUI.cpp.

{
   auto &parameters = mCurvesList.mParameters;
   auto &curveName = parameters.mCurveName;
   const auto &curves = mCurvesList.mCurves;
 
   // Reload the curve names
   if( mCurve )
      mCurve->Clear();
   bool selectedCurveExists = false;
   for (size_t i = 0, cnt = curves.size(); i < cnt; i++)
   {
      if (curveName == curves[ i ].Name)
         selectedCurveExists = true;
      if( mCurve )
         mCurve->Append(curves[ i ].Name);
   }
   // In rare circumstances, curveName may not exist (bug 1891)
   if (!selectedCurveExists)
      curveName = curves[ (int)curves.size() - 1 ].Name;
   if( mCurve )
      mCurve->SetStringSelection(curveName);
 
   // Allow the control to resize
   if( mCurve )
      mCurve->SetMinSize({-1, -1});
 
   // Set initial curve
   mCurvesList.setCurve( curveName );
}

References mCurve, EqualizationParameters::mCurveName, EqualizationCurvesList::mCurves, mCurvesList, EqualizationCurvesList::mParameters, and EqualizationCurvesList::setCurve().

Referenced by OnManage(), and TransferDataToWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateDraw()

void EqualizationUI::UpdateDraw ( )

private

Definition at line 593 of file EqualizationUI.cpp.

{
   auto &parameters = mCurvesList.mParameters;
   const auto &lin = parameters.mLin;
   auto &linEnvelope = parameters.mLinEnvelope;
   auto &logEnvelope = parameters.mLogEnvelope;
   const auto &hiFreq = parameters.mHiFreq;
 
   size_t numPoints = logEnvelope.GetNumberOfPoints();
   Doubles when{ numPoints };
   Doubles value{ numPoints };
   double deltadB = 0.1;
   double dx, dy, dx1, dy1, err;
 
   logEnvelope.GetPoints( when.get(), value.get(), numPoints );
 
   // set 'unnamed' as the selected curve
   mCurvesList.EnvelopeUpdated();
 
   bool flag = true;
   while (flag)
   {
      flag = false;
      int numDeleted = 0;
      logEnvelope.GetPoints( when.get(), value.get(), numPoints );
      for (size_t j = 0; j + 2 < numPoints; j++)
      {
         dx = when[j+2+numDeleted] - when[j+numDeleted];
         dy = value[j+2+numDeleted] - value[j+numDeleted];
         dx1 = when[j+numDeleted+1] - when[j+numDeleted];
         dy1 = dy * dx1 / dx;
         err = fabs(value[j+numDeleted+1] - (value[j+numDeleted] + dy1));
         if( err < deltadB )
         {   // within < deltadB dB?
            logEnvelope.Delete(j+1);
            numPoints--;
            numDeleted++;
            flag = true;
         }
      }
   }
 
   if(lin) // do not use IsLinear() here
   {
      mBands.EnvLogToLin();
      mFreqRuler->ruler.SetUpdater(&LinearUpdater::Instance());
      mFreqRuler->ruler.SetRange(0, hiFreq);
   }
 
   szrV->Show(szrG,false);
   szrH->Show(szrI,false);
   szrH->Show(szrL,true);
 
   mUIParent->Layout();
   wxGetTopLevelParent(mUIParent)->Layout();
   mCurvesList.ForceRecalc();     // it may have changed slightly due to the deletion of points
}

References EqualizationCurvesList::EnvelopeUpdated(), EqualizationBandSliders::EnvLogToLin(), flag, EqualizationCurvesList::ForceRecalc(), LinearUpdater::Instance(), mBands, mCurvesList, mFreqRuler, EqualizationParameters::mLin, EqualizationCurvesList::mParameters, mUIParent, RulerPanel::ruler, Ruler::SetRange(), Ruler::SetUpdater(), szrG, szrH, szrI, szrL, and szrV.

Referenced by OnDrawMode().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateGraphic()

void EqualizationUI::UpdateGraphic ( )

private

Definition at line 651 of file EqualizationUI.cpp.

{
   auto &parameters = mCurvesList.mParameters;
   const auto &lin = parameters.mLin;
   auto &linEnvelope = parameters.mLinEnvelope;
   auto &logEnvelope = parameters.mLogEnvelope;
   const auto &loFreq = parameters.mLoFreq;
   const auto &hiFreq = parameters.mHiFreq;
 
   auto &drawMode = parameters.mDrawMode;
 
   if(lin)  //going from lin to log freq scale - do not use IsLinear() here
   {  // add some extra points to the linear envelope for the graphic to follow
      double step = pow(2., 1./12.);   // twelve steps per octave
      double when,value;
      for(double freq=10.; freq<hiFreq; freq*=step)
      {
         when = freq/hiFreq;
         value = linEnvelope.GetValue(when);
         linEnvelope.Insert(when, value);
      }
 
      mBands.EnvLinToLog();
      mFreqRuler->ruler.SetUpdater(&LogarithmicUpdater::Instance());
      mFreqRuler->ruler.SetRange(loFreq, hiFreq);
   }
 
   mBands.ErrMin();                  //move sliders to minimise error
 
   szrV->Show(szrG,true);  // eq sliders
   szrH->Show(szrI,mOptions == kEqLegacy );  // interpolation choice
   szrH->Show(szrL,false); // linear freq checkbox
 
   mUIParent->Layout();
   wxGetTopLevelParent(mUIParent)->Layout();
   mUIParent->Layout();
   wxGetTopLevelParent(mUIParent)->Layout();
 
   mBands.GraphicEQ(logEnvelope);
   drawMode = false;
}

References EqualizationBandSliders::EnvLinToLog(), EqualizationBandSliders::ErrMin(), EqualizationBandSliders::GraphicEQ(), LogarithmicUpdater::Instance(), kEqLegacy, mBands, mCurvesList, mFreqRuler, EqualizationParameters::mLin, mOptions, EqualizationCurvesList::mParameters, mUIParent, RulerPanel::ruler, Ruler::SetRange(), Ruler::SetUpdater(), szrG, szrH, szrI, szrL, and szrV.

Referenced by OnCurve(), OnGraphicMode(), and TransferDataToWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateRuler()

void EqualizationUI::UpdateRuler ( )

private

Definition at line 534 of file EqualizationUI.cpp.

{
   const auto &parameters = mCurvesList.mParameters;
   const auto &dBMin = parameters.mdBMin;
   const auto &dBMax = parameters.mdBMax;
 
   // Refresh ruler when values have changed
   int w1, w2, h;
   mdBRuler->ruler.GetMaxSize(&w1, &h);
   mdBRuler->ruler.SetRange(dBMax, dBMin);
   mdBRuler->ruler.GetMaxSize(&w2, &h);
   if( w1 != w2 )   // Reduces flicker
   {
      mdBRuler->SetSize(wxSize(w2,h));
      mFreqRuler->Refresh(false);
   }
   mdBRuler->Refresh(false);
 
   mPanel->Refresh(false);
}

References Ruler::GetMaxSize(), mCurvesList, EqualizationParameters::mdBMin, mdBRuler, mFreqRuler, mPanel, EqualizationCurvesList::mParameters, RulerPanel::ruler, and Ruler::SetRange().

Referenced by OnSliderDBMAX(), OnSliderDBMIN(), and TransferDataToWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

ValidateUI()

bool EqualizationUI::ValidateUI

(

EffectSettings &

settings

)

Definition at line 94 of file EqualizationUI.cpp.

{
   auto& parameters = mCurvesList.mParameters;
   const auto &curveName = parameters.mCurveName;
   auto &logEnvelope = parameters.mLogEnvelope;
   const auto &curves = mCurvesList.mCurves;
 
   EQCurveWriter{ curves }.SaveCurves();
 
   parameters.SaveConfig();
 
   return true;
}

References EqualizationParameters::mCurveName, EqualizationCurvesList::mCurves, mCurvesList, EqualizationCurvesList::mParameters, and EQCurveWriter::SaveCurves().

Referenced by EffectEqualization::ValidateUI().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mBands

EqualizationBandSliders EqualizationUI::mBands { mCurvesList }

private

Definition at line 118 of file EqualizationUI.h.

Referenced by OnClear(), OnInterp(), OnInvert(), OnLinFreq(), PopulateOrExchange(), UpdateDraw(), and UpdateGraphic().

mCurve

wxWeakRef<wxChoice> EqualizationUI::mCurve {}

private

Definition at line 112 of file EqualizationUI.h.

Referenced by OnCurve(), OnIdle(), OnManage(), PopulateOrExchange(), and UpdateCurves().

mCurvesList

EqualizationCurvesList& EqualizationUI::mCurvesList

private

Definition at line 84 of file EqualizationUI.h.

Referenced by OnCurve(), OnDrawMode(), OnGraphicMode(), OnGridOnOff(), OnIdle(), OnInterp(), OnLinFreq(), OnManage(), OnSliderDBMAX(), OnSliderDBMIN(), OnSliderM(), PopulateOrExchange(), TransferDataToWindow(), UpdateCurves(), UpdateDraw(), UpdateGraphic(), UpdateRuler(), and ValidateUI().

mdBMaxSlider

wxSlider* EqualizationUI::mdBMaxSlider

private

Definition at line 117 of file EqualizationUI.h.

Referenced by OnSliderDBMAX(), PopulateOrExchange(), and TransferDataToWindow().

mdBMinSlider

wxSlider* EqualizationUI::mdBMinSlider

private

Definition at line 116 of file EqualizationUI.h.

Referenced by OnSliderDBMIN(), PopulateOrExchange(), and TransferDataToWindow().

mdBRuler

RulerPanel* EqualizationUI::mdBRuler

private

Definition at line 88 of file EqualizationUI.h.

Referenced by PopulateOrExchange(), and UpdateRuler().

mDraw

wxRadioButton* EqualizationUI::mDraw {}

private

Definition at line 107 of file EqualizationUI.h.

Referenced by PopulateOrExchange(), and TransferDataToWindow().

mFreqRuler

RulerPanel* EqualizationUI::mFreqRuler

private

Definition at line 89 of file EqualizationUI.h.

Referenced by OnLinFreq(), PopulateOrExchange(), UpdateDraw(), UpdateGraphic(), and UpdateRuler().

mGraphic

wxRadioButton* EqualizationUI::mGraphic {}

private

Definition at line 108 of file EqualizationUI.h.

Referenced by PopulateOrExchange(), and TransferDataToWindow().

mGridOnOff

wxCheckBox* EqualizationUI::mGridOnOff

private

Definition at line 110 of file EqualizationUI.h.

Referenced by OnGridOnOff(), PopulateOrExchange(), and TransferDataToWindow().

mInterpChoice

wxChoice* EqualizationUI::mInterpChoice

private

Definition at line 111 of file EqualizationUI.h.

Referenced by OnInterp(), PopulateOrExchange(), and TransferDataToWindow().

mLeftSpacer

wxSizerItem* EqualizationUI::mLeftSpacer

private

Definition at line 103 of file EqualizationUI.h.

mLinFreq

wxCheckBox* EqualizationUI::mLinFreq

private

Definition at line 109 of file EqualizationUI.h.

Referenced by OnLinFreq(), PopulateOrExchange(), and TransferDataToWindow().

mManage

wxButton* EqualizationUI::mManage

private

Definition at line 113 of file EqualizationUI.h.

mMSlider

wxSlider* EqualizationUI::mMSlider {}

private

Definition at line 115 of file EqualizationUI.h.

Referenced by OnSliderM(), PopulateOrExchange(), and TransferDataToWindow().

mMText

wxStaticText* EqualizationUI::mMText

private

Definition at line 114 of file EqualizationUI.h.

Referenced by OnSliderM(), and PopulateOrExchange().

mName

TranslatableString EqualizationUI::mName

private

Definition at line 85 of file EqualizationUI.h.

Referenced by OnManage().

mOptions

const int EqualizationUI::mOptions

private

Definition at line 86 of file EqualizationUI.h.

Referenced by OnManage(), PopulateOrExchange(), TransferDataToWindow(), and UpdateGraphic().

mPanel

wxWeakRef<EqualizationPanel> EqualizationUI::mPanel {}

private

Definition at line 105 of file EqualizationUI.h.

Referenced by OnGridOnOff(), PopulateOrExchange(), and UpdateRuler().

mUIParent

const wxWeakRef<wxWindow>& EqualizationUI::mUIParent

private

Definition at line 83 of file EqualizationUI.h.

Referenced by OnManage(), OnSize(), PopulateOrExchange(), TransferDataToWindow(), UpdateDraw(), and UpdateGraphic().

mUIServices

EffectUIServices& EqualizationUI::mUIServices

private

Definition at line 82 of file EqualizationUI.h.

Referenced by PopulateOrExchange().

szr1

wxSizer* EqualizationUI::szr1

private

Definition at line 97 of file EqualizationUI.h.

Referenced by PopulateOrExchange(), and TransferDataToWindow().

szr2

wxSizer* EqualizationUI::szr2

private

Definition at line 98 of file EqualizationUI.h.

szr3

wxSizer* EqualizationUI::szr3

private

Definition at line 99 of file EqualizationUI.h.

szr4

wxSizer* EqualizationUI::szr4

private

Definition at line 100 of file EqualizationUI.h.

szr5

wxSizer* EqualizationUI::szr5

private

Definition at line 101 of file EqualizationUI.h.

szrC

wxSizer* EqualizationUI::szrC

private

Definition at line 91 of file EqualizationUI.h.

szrG

wxSizer* EqualizationUI::szrG

private

Definition at line 92 of file EqualizationUI.h.

Referenced by PopulateOrExchange(), TransferDataToWindow(), UpdateDraw(), and UpdateGraphic().

szrH

wxSizer* EqualizationUI::szrH

private

Definition at line 94 of file EqualizationUI.h.

Referenced by PopulateOrExchange(), TransferDataToWindow(), UpdateDraw(), and UpdateGraphic().

szrI

wxSizer* EqualizationUI::szrI

private

Definition at line 95 of file EqualizationUI.h.

Referenced by PopulateOrExchange(), TransferDataToWindow(), UpdateDraw(), and UpdateGraphic().

szrL

wxSizer* EqualizationUI::szrL

private

Definition at line 96 of file EqualizationUI.h.

Referenced by PopulateOrExchange(), TransferDataToWindow(), UpdateDraw(), and UpdateGraphic().

szrV

wxSizer* EqualizationUI::szrV

private

Definition at line 93 of file EqualizationUI.h.

Referenced by PopulateOrExchange(), TransferDataToWindow(), UpdateDraw(), and UpdateGraphic().

---

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

• EqualizationUI.h
• EqualizationUI.cpp