Audacity 3.2.0
Public Member Functions | Private Member Functions | Private Attributes | List of all members
EqualizationUI Class Reference

#include <EqualizationUI.h>

Inheritance diagram for EqualizationUI:
[legend]
Collaboration diagram for EqualizationUI:
[legend]

Public Member Functions

 EqualizationUI (EffectSettingsManager &manager, const wxWeakRef< wxWindow > &uiParent, const TranslatableString &name, EqualizationCurvesList &curvesList, int options)
 
bool ValidateUI (EffectSettings &settings)
 
void Init ()
 
void setCurve (int currentCurve)
 
void setCurve (const wxString &curveName)
 
std::unique_ptr< EffectEditorPopulateOrExchange (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)
 
void setCurve ()
 

Private Attributes

EffectSettingsManagermManager
 
const wxWeakRef< wxWindow > & mUIParent
 
EqualizationCurvesListmCurvesList
 
TranslatableString mName
 
const int mOptions
 
RulerPanelmdBRuler
 
RulerPanelmFreqRuler
 
bool mDisallowCustom { false }
 
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< EqualizationPanelmPanel {}
 
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 32 of file EqualizationUI.h.

Constructor & Destructor Documentation

◆ EqualizationUI()

EqualizationUI::EqualizationUI ( EffectSettingsManager manager,
const wxWeakRef< wxWindow > &  uiParent,
const TranslatableString name,
EqualizationCurvesList curvesList,
int  options 
)
inline

Definition at line 34 of file EqualizationUI.h.

38 : mManager{ manager }
39 , mUIParent{ uiParent }
40 , mName{ name }
41 , mCurvesList{ curvesList }
42 , mOptions{ options }
43 {}
const TranslatableString name
Definition: Distortion.cpp:76
static const AttachedProjectObjects::RegisteredFactory manager
EqualizationCurvesList & mCurvesList
EffectSettingsManager & mManager
const int mOptions
const wxWeakRef< wxWindow > & mUIParent
TranslatableString mName

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 57 of file EqualizationUI.h.

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

Referenced by PopulateOrExchange().

Here is the caller graph for this function:

◆ Init()

void EqualizationUI::Init ( )
inline

Definition at line 46 of file EqualizationUI.h.

46{ mBands.Init(); }
EqualizationBandSliders mBands

References EqualizationBandSliders::Init(), and mBands.

Referenced by EffectEqualization::Init().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ OnClear()

void EqualizationUI::OnClear ( wxCommandEvent &  event)
private

Definition at line 954 of file EqualizationUI.cpp.

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 925 of file EqualizationUI.cpp.

926{
927 // Select NEW curve
928 wxASSERT( mCurve != NULL );
929 setCurve( mCurve->GetCurrentSelection() );
932}
wxWeakRef< wxChoice > mCurve
EqualizationFilter & mParameters

References mCurve, mCurvesList, EqualizationParameters::mDrawMode, EqualizationCurvesList::mParameters, 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 862 of file EqualizationUI.cpp.

863{
865 UpdateDraw();
866}

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 868 of file EqualizationUI.cpp.

869{
872}

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 964 of file EqualizationUI.cpp.

965{
967 mPanel->Refresh(false);
968}
wxWeakRef< EqualizationPanel > mPanel
wxCheckBox * mGridOnOff

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 996 of file EqualizationUI.cpp.

997{
998 event.Skip();
999 if (mCurve)
1000 mCurve->SetStringSelection(mCurvesList.mParameters.mCurveName);
1001}

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

◆ OnInterp()

void EqualizationUI::OnInterp ( wxCommandEvent &  event)
private

Definition at line 850 of file EqualizationUI.cpp.

851{
852 auto &parameters = mCurvesList.mParameters;
853 bool bIsGraphic = !parameters.mDrawMode;
854 if (bIsGraphic)
855 {
856 mBands.GraphicEQ(parameters.mLogEnvelope);
858 }
859 parameters.mInterp = mInterpChoice->GetSelection();
860}
wxChoice * mInterpChoice

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 959 of file EqualizationUI.cpp.

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 970 of file EqualizationUI.cpp.

971{
972 auto &parameters = mCurvesList.mParameters;
973 auto &lin = parameters.mLin;
974 const auto &loFreq = parameters.mLoFreq;
975 const auto &hiFreq = parameters.mHiFreq;
976
977 lin = mLinFreq->IsChecked();
978 if(parameters.IsLinear()) //going from log to lin freq scale
979 {
981 mFreqRuler->ruler.SetRange(0, hiFreq);
983 lin = true;
984 }
985 else //going from lin to log freq scale
986 {
988 mFreqRuler->ruler.SetRange(loFreq, hiFreq);
990 lin = false;
991 }
992 mFreqRuler->Refresh(false);
994}
RulerPanel * mFreqRuler
wxCheckBox * mLinFreq
static const LinearUpdater & Instance()
static const LogarithmicUpdater & Instance()
void SetUpdater(const RulerUpdater *pUpdater)
Definition: Ruler.cpp:111
void SetRange(double min, double max)
Definition: Ruler.cpp:151
Ruler ruler
Definition: RulerPanel.h:79

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 937 of file EqualizationUI.cpp.

938{
939 auto &curves = mCurvesList.mCurves;
941 curves, mCurve->GetSelection());
942 if (d.ShowModal()) {
943 wxGetTopLevelParent(mUIParent)->Layout();
944 setCurve(d.GetItem());
945 }
946
947 // Reload the curve names
948 UpdateCurves();
949
950 // Allow control to resize
951 mUIParent->Layout();
952}
EqualizationCurvesDialog manages the available preset curves.

References EqualizationCurvesDialog::GetItem(), mCurve, EqualizationCurvesList::mCurves, mCurvesList, mName, mOptions, mUIParent, 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 844 of file EqualizationUI.cpp.

845{
846 mUIParent->Layout();
847 event.Skip();
848}

References mUIParent.

◆ OnSliderDBMAX()

void EqualizationUI::OnSliderDBMAX ( wxCommandEvent &  event)
private

Definition at line 908 of file EqualizationUI.cpp.

909{
910 auto &dBMax = mCurvesList.mParameters.mdBMax;
911
912 float dB = mdBMaxSlider->GetValue();
913 if (dB != dBMax) {
914 dBMax = dB;
915 wxString tip;
916 tip.Printf(_("%d dB"), (int)dBMax);
917 mdBMaxSlider->SetToolTip(tip);
918 UpdateRuler();
919 }
920}
#define _(s)
Definition: Internat.h:73
wxSlider * mdBMaxSlider

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 894 of file EqualizationUI.cpp.

895{
896 auto &dBMin = mCurvesList.mParameters.mdBMin;
897
898 float dB = mdBMinSlider->GetValue();
899 if (dB != dBMin) {
900 dBMin = dB;
901 wxString tip;
902 tip.Printf(_("%d dB"), (int)dBMin);
903 mdBMinSlider->SetToolTip(tip);
904 UpdateRuler();
905 }
906}
wxSlider * mdBMinSlider

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 874 of file EqualizationUI.cpp.

875{
876 auto &M = mCurvesList.mParameters.mM;
877
878 size_t m = 2 * mMSlider->GetValue() + 1;
879 // Must be odd
880 wxASSERT( (m & 1) == 1 );
881
882 if (m != M) {
883 M = m;
884 wxString tip;
885 tip.Printf(wxT("%d"), (int)M);
886 mMText->SetLabel(tip);
887 mMText->SetName(mMText->GetLabel()); // fix for bug 577 (NVDA/Narrator screen readers do not read static text in dialogs)
888 mMSlider->SetToolTip(tip);
889
891 }
892}
wxT("CloseDown"))
wxStaticText * mMText
wxSlider * mMSlider

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 69 of file EqualizationUI.cpp.

72{
73 auto &parameters = mCurvesList.mParameters;
74 const auto &M = parameters.mM;
75 const auto &loFreq = parameters.mLoFreq;
76 const auto &hiFreq = parameters.mHiFreq;
77 const auto &curves = mCurvesList.mCurves;
78
79 auto &drawMode = parameters.mDrawMode;
80
81 S.SetBorder(0);
82
83 S.SetSizerProportion(1);
84 S.Prop(1).StartMultiColumn(1, wxEXPAND);
85 {
86 S.SetStretchyCol(0);
87 //S.SetStretchyRow(0); // The 5px Top border
88 S.SetStretchyRow(1); // The Graph
89 S.SetStretchyRow(2); // The EQ sliders
90 szrV = S.GetSizer();
91
92 // -------------------------------------------------------------------
93 // ROW 0: Top border
94 // -------------------------------------------------------------------
95 S.AddSpace(5);
96
97 // -------------------------------------------------------------------
98 // ROW 1: Equalization panel and sliders for vertical scale
99 // -------------------------------------------------------------------
100 S.SetSizerProportion(1);
101 S.Prop(1).StartMultiColumn(3, wxEXPAND);
102 {
103 S.SetStretchyCol(1);
104 S.SetStretchyRow(0);
105 szr1 = S.GetSizer();
106
107 S.StartVerticalLay(wxEXPAND, 1);
108 {
109 // Inserted into sizer later, but the EQ panel needs to point to it
111 S.GetParent(), wxID_ANY, wxHORIZONTAL,
112 wxSize{ 100, 100 }, // Ruler can't handle small sizes
113 RulerPanel::Range{ loFreq, hiFreq },
115 XO("Hz"),
117 .Log(true)
118 .Flip(true)
119 .LabelEdges(true)
120 .TicksAtExtremes(true)
121 .TickColour( { 0, 0, 0 } )
122 );
123
125 S.GetParent(), wxID_ANY, wxVERTICAL,
126 wxSize{ 100, 100 }, // Ruler can't handle small sizes
127 RulerPanel::Range{ 60.0, -120.0 },
129 XO("dB"),
131 .LabelEdges(true)
132 .TicksAtExtremes(true)
133 .TickColour( { 0, 0, 0 } )
134 );
135
136 S.Prop(0).AddSpace(0, 1);
137 S.Prop(1)
138 .Position(wxEXPAND)
139 .AddWindow(mdBRuler);
140 S.AddSpace(0, 1);
141 }
142 S.EndVerticalLay();
143
144 parameters.ChooseEnvelope().Flatten(0.);
145 parameters.ChooseEnvelope().SetTrackLen(1.0);
146 mPanel = safenew EqualizationPanel(S.GetParent(), wxID_ANY,
148 S.Prop(1)
149 .Position(wxEXPAND)
150 .MinSize( { wxDefaultCoord, wxDefaultCoord } )
151 .AddWindow(mPanel);
152
153 S.SetBorder(5);
154 S.StartVerticalLay();
155 {
156 S.AddVariableText(XO("+ dB"), false, wxCENTER);
158 .Name(XO("Max dB"))
159 .Style(wxSL_VERTICAL | wxSL_INVERSE)
160 .AddSlider( {}, 30, 60, 0);
161#if wxUSE_ACCESSIBILITY
162 mdBMaxSlider->SetAccessible(safenew SliderAx(mdBMaxSlider, XO("%d dB")));
163#endif
164 BindTo(*mdBMaxSlider, wxEVT_SLIDER,
166
168 .Name(XO("Min dB"))
169 .Style(wxSL_VERTICAL | wxSL_INVERSE)
170 .AddSlider( {}, -30, -10, -120);
171 S.AddVariableText(XO("- dB"), false, wxCENTER);
172#if wxUSE_ACCESSIBILITY
173 mdBMinSlider->SetAccessible(safenew SliderAx(mdBMinSlider, XO("%d dB")));
174#endif
175 BindTo(*mdBMinSlider, wxEVT_SLIDER,
177 }
178 S.EndVerticalLay();
179 S.SetBorder(0);
180
181 // -------------------------------------------------------------------
182 // Frequency ruler below graph
183 // -------------------------------------------------------------------
184
185 // Column 1 is empty
186 S.AddSpace(1, 1);
187
188 S.SetBorder(1);
189 S.Prop(1)
190 .Position(wxEXPAND | wxALIGN_LEFT | wxALIGN_TOP | wxLEFT)
191 .AddWindow(mFreqRuler);
192 S.SetBorder(0);
193
194 // Column 3 is empty
195 S.AddSpace(1, 1);
196 }
197 S.EndMultiColumn();
198
199 // -------------------------------------------------------------------
200 // ROW 2: Graphic EQ
201 // -------------------------------------------------------------------
202 S.SetSizerProportion(1);
203 S.StartHorizontalLay(wxEXPAND, 1);
204 {
205 szrG = S.GetSizer();
206
207 // Panel used to host the sliders since they will be positioned manually.
208 //mGraphicPanel = S.Prop(1)
209 //.Position(wxEXPAND)
210 //.Size( { -1, 150 } )
211 //.StartPanel();
212 S.AddSpace(15,0);
213 {
215 S.AddSpace(15,0);
216 } //S.EndPanel();
217 }
218 S.EndHorizontalLay();
219
220 // -------------------------------------------------------------------
221 // ROW 4: Various controls
222 // -------------------------------------------------------------------
223 S.SetSizerProportion(1);
224 S.Prop(1).StartMultiColumn(7, wxALIGN_CENTER_HORIZONTAL);
225 {
226 S.SetBorder(5);
227
228 S.AddSpace(5, 5);
229
230 if( mOptions == kEqLegacy )
231 {
232 S.StartHorizontalLay(wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
233 {
234 S.AddPrompt(XXO("&EQ Type:"));
235 }
236 S.EndHorizontalLay();
237
238 S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 1);
239 {
240 S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 1);
241 {
242 mDraw = S
243 .Name(XO("Draw Curves"))
244 .AddRadioButton(XXO("&Draw"));
245 BindTo(*mDraw, wxEVT_RADIOBUTTON,
247
248 mGraphic = S
249 .Name(XO("Graphic EQ"))
250 .AddRadioButtonToGroup(XXO("&Graphic"));
251 BindTo(*mGraphic, wxEVT_RADIOBUTTON,
253 }
254 S.EndHorizontalLay();
255 }
256 S.EndHorizontalLay();
257 }
258
259 S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 0);
260 {
261 szrH = S.GetSizer();
262
263 S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 1);
264 {
265 szrI = S.GetSizer();
266
268 .Name(XO("Interpolation type"))
269 .AddChoice( {},
272 0 );
273#if wxUSE_ACCESSIBILITY
274 // so that name can be set on a standard control
276#endif
277 BindTo(*mInterpChoice, wxEVT_CHOICE,
279 }
280 S.EndHorizontalLay();
281
282 S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 1);
283 {
284 szrL = S.GetSizer();
285
286 mLinFreq = S
287 .Name(XO("Linear Frequency Scale"))
288 .AddCheckBox(XXO("Li&near Frequency Scale"), false);
289 BindTo(*mLinFreq, wxEVT_CHECKBOX,
291 }
292 S.EndHorizontalLay();
293 }
294 S.EndHorizontalLay();
295
296 // -------------------------------------------------------------------
297 // Filter length grouping
298 // -------------------------------------------------------------------
299
300 if( mOptions == kEqLegacy ){
301 S.StartHorizontalLay(wxEXPAND, 0);
302 {
303 S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 0);
304 {
305 S.AddPrompt(XXO("Length of &Filter:"));
306 }
307 S.EndHorizontalLay();
308
309 S.StartHorizontalLay(wxEXPAND, 1);
310 {
311 mMSlider = S
312 .Name(XO("Length of Filter"))
313 .Style(wxSL_HORIZONTAL)
314 .AddSlider( {}, (M - 1) / 2, 4095, 10);
315 BindTo(*mMSlider, wxEVT_SLIDER,
317 }
318 S.EndHorizontalLay();
319
320 S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 0);
321 {
322 wxString label;
323 label.Printf(wxT("%ld"), M);
324 mMText = S.Name( Verbatim( label ) )
325 // fix for bug 577 (NVDA/Narrator screen readers do not
326 // read static text in dialogs)
327 .AddVariableText( Verbatim( label ) );
328 }
329 S.EndHorizontalLay();
330 }
331 S.EndHorizontalLay();
332
333 S.AddSpace(1, 1);
334 }
335
336 S.AddSpace(5, 5);
337
338 if( mOptions == kEqLegacy ){
339 S.AddSpace(5, 5);
340 S.StartHorizontalLay(wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
341 {
342 S.AddPrompt(XXO("&Select Curve:"));
343 }
344 S.EndHorizontalLay();
345
346 S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 1);
347 {
348 S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 1);
349 {
350 mCurve = S
351 .Name(XO("Select Curve"))
352 .AddChoice( {},
353 [&curves]{
355 for (const auto &curve : curves)
356 names.push_back( Verbatim( curve.Name ) );
357 return names;
358 }()
359 );
360 BindTo(*mCurve, wxEVT_CHOICE,
362 }
363 S.EndHorizontalLay();
364 }
365 S.EndHorizontalLay();
366
367 const auto pButton = S
368 .AddButton(XXO("S&ave/Manage Curves..."));
369 BindTo(*pButton, wxEVT_BUTTON, &EqualizationUI::OnManage);
370 }
371
372 S.StartHorizontalLay(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 1);
373 {
374 auto pButton = S
375 .AddButton(XXO("Fla&tten"));
376 BindTo(*pButton, wxEVT_BUTTON, &EqualizationUI::OnClear);
377
378 pButton = S
379 .AddButton(XXO("&Invert"));
380 BindTo(*pButton, wxEVT_BUTTON, &EqualizationUI::OnInvert);
381
382 mGridOnOff = S
383 .Name(XO("Show grid lines"))
384 .AddCheckBox(XXO("Show g&rid lines"), false);
385 BindTo(*mGridOnOff, wxEVT_CHECKBOX,
387 }
388 S.EndHorizontalLay();
389
390 S.AddSpace(5, 5);
391 }
392 S.EndMultiColumn();
393 }
394 S.EndMultiColumn();
395
396 mUIParent->SetAutoLayout(false);
398 mUIParent->Layout();
399
401 drawMode = true;
403 drawMode = false;
404
405 // "show" settings for graphics mode before setting the size of the dialog
406 // as this needs more space than draw mode
407 szrV->Show(szrG,!drawMode); // eq sliders
408 szrH->Show(szrI,true); // interpolation choice
409 szrH->Show(szrL,false); // linear freq checkbox
410
412 mPanel->Show( false );
413 wxSize sz = szrV->GetMinSize();
414 sz += wxSize( 30, 0);
415 mUIParent->SetMinSize(sz);
416 }
417 else{
418 mPanel->Show( true );
419 szrV->Show(szr1, true);
420 // This sizing calculation is hacky.
421 // Rather than set the true minimum size we set a size we would
422 // like to have.
423 // This makes the default size of the dialog good, but has the
424 // downside that the user can't adjust the dialog smaller.
425 wxSize sz = szrV->GetMinSize();
426 sz += wxSize( 400, 100);
427 szrV->SetMinSize(sz);
428 }
430
431 return nullptr;
432}
const int kEqLegacy
const int kEqOptionCurve
const int kEqOptionGraphic
XO("Cut/Copy/Paste")
XXO("&Cut/Copy/Paste Toolbar")
#define safenew
Definition: MemoryX.h:10
TranslatableStrings Msgids(const EnumValueSymbol strings[], size_t nStrings)
Convenience function often useful when adding choice controls.
TranslatableString label
Definition: TagsEditor.cpp:164
static TranslatableStrings names
Definition: TagsEditor.cpp:152
#define S(N)
Definition: ToChars.cpp:64
TranslatableString Verbatim(wxString str)
Require calls to the one-argument constructor to go through this distinct global function name.
std::vector< TranslatableString > TranslatableStrings
EqualizationPanel is used with EqualizationDialog and controls a graph for EffectEqualization....
wxSizer * szrH
void OnSliderDBMAX(wxCommandEvent &event)
void OnDrawMode(wxCommandEvent &event)
void OnManage(wxCommandEvent &event)
void OnGraphicMode(wxCommandEvent &event)
wxRadioButton * mGraphic
wxSizer * szrV
void OnClear(wxCommandEvent &event)
void OnLinFreq(wxCommandEvent &event)
void OnInterp(wxCommandEvent &event)
void OnCurve(wxCommandEvent &event)
void BindTo(wxEvtHandler &src, const EventTag &eventType, void(Class::*pmf)(Event &))
void OnSliderDBMIN(wxCommandEvent &event)
wxSizer * szrG
void OnInvert(wxCommandEvent &event)
void OnSliderM(wxCommandEvent &event)
RulerPanel * mdBRuler
wxRadioButton * mDraw
void OnGridOnOff(wxCommandEvent &event)
static const IntFormat & Instance()
Definition: IntFormat.cpp:14
static const LinearDBFormat & Instance()
RulerPanel class allows you to work with a Ruler like any other wxWindow.
Definition: RulerPanel.h:19
std::pair< double, double > Range
Definition: RulerPanel.h:23
An alternative to using wxWindowAccessible, which in wxWidgets 3.1.1 contained GetParent() which was ...
void AddBandSliders(ShuttleGui &S)
static const EnumValueSymbol kInterpStrings[nInterpolations]
Options & LabelEdges(bool l)
Definition: RulerPanel.h:41
Options & Log(bool l)
Definition: RulerPanel.h:35

References EqualizationBandSliders::AddBandSliders(), BindTo(), EqualizationCurvesList::ForceRecalc(), 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, 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:

◆ setCurve() [1/3]

void EqualizationUI::setCurve ( )
private

Definition at line 681 of file EqualizationUI.cpp.

682{
683 const auto &curves = mCurvesList.mCurves;
684 setCurve((int) curves.size() - 1);
685}

References EqualizationCurvesList::mCurves, mCurvesList, and setCurve().

Referenced by OnCurve(), OnManage(), setCurve(), and UpdateCurves().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ setCurve() [2/3]

void EqualizationUI::setCurve ( const wxString &  curveName)

Definition at line 687 of file EqualizationUI.cpp.

688{
689 const auto &curves = mCurvesList.mCurves;
690 unsigned i = 0;
691 for( i = 0; i < curves.size(); i++ )
692 if( curveName == curves[ i ].Name )
693 break;
694 if( i == curves.size())
695 {
697 XO("Requested curve not found, using 'unnamed'"),
698 XO("Curve not found"),
699 wxOK|wxICON_ERROR);
700 setCurve();
701 }
702 else
703 setCurve( i );
704}
int DoMessageBox(const TranslatableString &name, const TranslatableString &msg, const TranslatableString &titleStr, long style=wxOK|wxCENTRE)

References EQUtils::DoMessageBox(), EqualizationCurvesList::mCurves, mCurvesList, mName, setCurve(), and XO().

Here is the call graph for this function:

◆ setCurve() [3/3]

void EqualizationUI::setCurve ( int  currentCurve)

Definition at line 517 of file EqualizationUI.cpp.

518{
519 auto &parameters = mCurvesList.mParameters;
520 constexpr auto loFreqI = EqualizationFilter::loFreqI;
521
522 const auto &lin = parameters.mLin;
523 const auto &hiFreq = parameters.mHiFreq;
524 auto &curves = mCurvesList.mCurves;
525
526 // Set current choice
527 wxASSERT( currentCurve < (int) curves.size() );
528 mCurvesList.Select(currentCurve);
529
530 int numPoints = (int) curves[currentCurve].points.size();
531
532 auto &env = parameters.ChooseEnvelope();
533 env.Flatten(0.);
534 env.SetTrackLen(1.0);
535
536 // Handle special case of no points.
537 if (numPoints == 0) {
539 return;
540 }
541
542 double when, value;
543
544 // Handle special case 1 point.
545 if (numPoints == 1) {
546 // only one point, so ensure it is in range then return.
547 when = curves[currentCurve].points[0].Freq;
548 if (lin) {
549 when = when / hiFreq;
550 }
551 else { // log scale
552 // We don't go below loFreqI (20 Hz) in log view.
553 double loLog = log10((double)loFreqI);
554 double hiLog = log10(hiFreq);
555 double denom = hiLog - loLog;
556 when =
557 (log10(std::max<double>(loFreqI, when))
558 - loLog) / denom;
559 }
560 value = curves[currentCurve].points[0].dB;
561 env.Insert(std::min(1.0, std::max(0.0, when)), value);
563 return;
564 }
565
566 // We have at least two points, so ensure they are in frequency order.
567 std::sort(curves[currentCurve].points.begin(),
568 curves[currentCurve].points.end());
569
570 if (curves[currentCurve].points[0].Freq < 0) {
571 // Corrupt or invalid curve, so bail.
573 return;
574 }
575
576 if(lin) { // linear Hz scale
577 for(int pointCount = 0; pointCount < numPoints; pointCount++) {
578 when = curves[currentCurve].points[pointCount].Freq / hiFreq;
579 value = curves[currentCurve].points[pointCount].dB;
580 if(when <= 1) {
581 env.Insert(when, value);
582 if (when == 1)
583 break;
584 }
585 else {
586 // There are more points at higher freqs,
587 // so interpolate next one then stop.
588 when = 1.0;
589 double nextDB = curves[currentCurve].points[pointCount].dB;
590 if (pointCount > 0) {
591 double nextF = curves[currentCurve].points[pointCount].Freq;
592 double lastF = curves[currentCurve].points[pointCount-1].Freq;
593 double lastDB = curves[currentCurve].points[pointCount-1].dB;
594 value = lastDB +
595 ((nextDB - lastDB) *
596 ((hiFreq - lastF) / (nextF - lastF)));
597 }
598 else
599 value = nextDB;
600 env.Insert(when, value);
601 break;
602 }
603 }
604 }
605 else { // log Hz scale
606 double loLog = log10((double) loFreqI);
607 double hiLog = log10(hiFreq);
608 double denom = hiLog - loLog;
609 int firstAbove20Hz;
610
611 // log scale EQ starts at 20 Hz (threshold of hearing).
612 // so find the first point (if any) above 20 Hz.
613 for (firstAbove20Hz = 0; firstAbove20Hz < numPoints; firstAbove20Hz++) {
614 if (curves[currentCurve].points[firstAbove20Hz].Freq > loFreqI)
615 break;
616 }
617
618 if (firstAbove20Hz == numPoints) {
619 // All points below 20 Hz, so just use final point.
620 when = 0.0;
621 value = curves[currentCurve].points[numPoints-1].dB;
622 env.Insert(when, value);
624 return;
625 }
626
627 if (firstAbove20Hz > 0) {
628 // At least one point is before 20 Hz and there are more
629 // beyond 20 Hz, so interpolate the first
630 double prevF = curves[currentCurve].points[firstAbove20Hz-1].Freq;
631 prevF = log10(std::max(1.0, prevF)); // log zero is bad.
632 double prevDB = curves[currentCurve].points[firstAbove20Hz-1].dB;
633 double nextF = log10(curves[currentCurve].points[firstAbove20Hz].Freq);
634 double nextDB = curves[currentCurve].points[firstAbove20Hz].dB;
635 when = 0.0;
636 value = nextDB - ((nextDB - prevDB) * ((nextF - loLog) / (nextF - prevF)));
637 env.Insert(when, value);
638 }
639
640 // Now get the rest.
641 for(int pointCount = firstAbove20Hz; pointCount < numPoints; pointCount++)
642 {
643 double flog = log10(curves[currentCurve].points[pointCount].Freq);
644 wxASSERT(curves[currentCurve].points[pointCount].Freq >= loFreqI);
645
646 when = (flog - loLog)/denom;
647 value = curves[currentCurve].points[pointCount].dB;
648 if(when <= 1.0) {
649 env.Insert(when, value);
650 }
651 else {
652 // This looks weird when adjusting curve in Draw mode if
653 // there is a point off-screen.
654
655 /*
656 // we have a point beyond fs/2. Insert it so that env code can use it.
657 // but just this one, we have no use for the rest
658 env.SetTrackLen(when); // can't Insert if the envelope isn't long enough
659 env.Insert(when, value);
660 break;
661 */
662
663 // interpolate the final point instead
664 when = 1.0;
665 if (pointCount > 0) {
666 double lastDB = curves[currentCurve].points[pointCount-1].dB;
667 double logLastF =
668 log10(curves[currentCurve].points[pointCount-1].Freq);
669 value = lastDB +
670 ((value - lastDB) *
671 ((log10(hiFreq) - logLastF) / (flog - logLastF)));
672 }
673 env.Insert(when, value);
674 break;
675 }
676 }
677 }
679}
int min(int a, int b)
static constexpr int loFreqI

References EqualizationCurvesList::ForceRecalc(), EqualizationFilter::loFreqI, EqualizationCurvesList::mCurves, mCurvesList, min(), EqualizationCurvesList::mParameters, and EqualizationCurvesList::Select().

Referenced by EffectEqualization::Init(), and EffectEqualization::VisitSettings().

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 434 of file EqualizationUI.cpp.

435{
436 auto &parameters = mCurvesList.mParameters;
437 const auto &lin = parameters.mLin;
438 const auto &drawGrid = parameters.mDrawGrid;
439 const auto &M = parameters.mM;
440 const auto &dBMin = parameters.mdBMin;
441 const auto &dBMax = parameters.mdBMax;
442 const auto &interp = parameters.mInterp;
443
444 auto &drawMode = parameters.mDrawMode;
445
446 // Set log or lin freq scale (affects interpolation as well)
447 mLinFreq->SetValue( lin );
448 wxCommandEvent dummyEvent;
449 OnLinFreq(dummyEvent); // causes a CalcFilter
450
451 mGridOnOff->SetValue( drawGrid ); // checks/unchecks the box on the interface
452
453 if( mMSlider )
454 mMSlider->SetValue((M - 1) / 2);
455
456 mdBMinSlider->SetValue((int)dBMin);
457 mdBMaxSlider->SetValue((int)dBMax);
458
459 // Reload the curve names
460 UpdateCurves();
461
462 // Set graphic interpolation mode
463 mInterpChoice->SetSelection(interp);
464
465 // Override draw mode, if we're not displaying the radio buttons.
467 drawMode = true;
469 drawMode = false;
470
471 if( mDraw )
472 mDraw->SetValue(drawMode);
473 szrV->Show(szr1,mOptions != kEqOptionGraphic); // Graph
474 szrV->Show(szrG,!drawMode); // eq sliders
475 szrH->Show(szrI,mOptions == kEqLegacy ); // interpolation choice
476 szrH->Show(szrL, drawMode); // linear freq checkbox
477 if( mGraphic)
478 mGraphic->SetValue(!drawMode);
479 mGridOnOff->Show( drawMode );
480
481 // Set Graphic (Fader) or Draw mode
482 if (!drawMode)
484
485 UpdateRuler();
486
487 mUIParent->Layout();
488 wxGetTopLevelParent(mUIParent)->Layout();
489
490 return true;
491}

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 713 of file EqualizationUI.cpp.

714{
715 auto &parameters = mCurvesList.mParameters;
716 auto &curveName = parameters.mCurveName;
717 const auto &curves = mCurvesList.mCurves;
718
719 // Reload the curve names
720 if( mCurve )
721 mCurve->Clear();
722 bool selectedCurveExists = false;
723 for (size_t i = 0, cnt = curves.size(); i < cnt; i++)
724 {
725 if (curveName == curves[ i ].Name)
726 selectedCurveExists = true;
727 if( mCurve )
728 mCurve->Append(curves[ i ].Name);
729 }
730 // In rare circumstances, curveName may not exist (bug 1891)
731 if (!selectedCurveExists)
732 curveName = curves[ (int)curves.size() - 1 ].Name;
733 if( mCurve )
734 mCurve->SetStringSelection(curveName);
735
736 // Allow the control to resize
737 if( mCurve )
738 mCurve->SetMinSize({-1, -1});
739
740 // Set initial curve
741 setCurve( curveName );
742}

References mCurve, EqualizationParameters::mCurveName, EqualizationCurvesList::mCurves, mCurvesList, EqualizationCurvesList::mParameters, and 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 744 of file EqualizationUI.cpp.

745{
746 auto &parameters = mCurvesList.mParameters;
747 const auto &lin = parameters.mLin;
748 auto &linEnvelope = parameters.mLinEnvelope;
749 auto &logEnvelope = parameters.mLogEnvelope;
750 const auto &hiFreq = parameters.mHiFreq;
751
752 size_t numPoints = logEnvelope.GetNumberOfPoints();
753 Doubles when{ numPoints };
754 Doubles value{ numPoints };
755 double deltadB = 0.1;
756 double dx, dy, dx1, dy1, err;
757
758 logEnvelope.GetPoints( when.get(), value.get(), numPoints );
759
760 // set 'unnamed' as the selected curve
762
763 bool flag = true;
764 while (flag)
765 {
766 flag = false;
767 int numDeleted = 0;
768 logEnvelope.GetPoints( when.get(), value.get(), numPoints );
769 for (size_t j = 0; j + 2 < numPoints; j++)
770 {
771 dx = when[j+2+numDeleted] - when[j+numDeleted];
772 dy = value[j+2+numDeleted] - value[j+numDeleted];
773 dx1 = when[j+numDeleted+1] - when[j+numDeleted];
774 dy1 = dy * dx1 / dx;
775 err = fabs(value[j+numDeleted+1] - (value[j+numDeleted] + dy1));
776 if( err < deltadB )
777 { // within < deltadB dB?
778 logEnvelope.Delete(j+1);
779 numPoints--;
780 numDeleted++;
781 flag = true;
782 }
783 }
784 }
785
786 if(lin) // do not use IsLinear() here
787 {
790 mFreqRuler->ruler.SetRange(0, hiFreq);
791 }
792
793 szrV->Show(szrG,false);
794 szrH->Show(szrI,false);
795 szrH->Show(szrL,true);
796
797 mUIParent->Layout();
798 wxGetTopLevelParent(mUIParent)->Layout();
799 mCurvesList.ForceRecalc(); // it may have changed slightly due to the deletion of points
800}
static std::once_flag flag

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 802 of file EqualizationUI.cpp.

803{
804 auto &parameters = mCurvesList.mParameters;
805 const auto &lin = parameters.mLin;
806 auto &linEnvelope = parameters.mLinEnvelope;
807 auto &logEnvelope = parameters.mLogEnvelope;
808 const auto &loFreq = parameters.mLoFreq;
809 const auto &hiFreq = parameters.mHiFreq;
810
811 auto &drawMode = parameters.mDrawMode;
812
813 if(lin) //going from lin to log freq scale - do not use IsLinear() here
814 { // add some extra points to the linear envelope for the graphic to follow
815 double step = pow(2., 1./12.); // twelve steps per octave
816 double when,value;
817 for(double freq=10.; freq<hiFreq; freq*=step)
818 {
819 when = freq/hiFreq;
820 value = linEnvelope.GetValue(when);
821 linEnvelope.Insert(when, value);
822 }
823
826 mFreqRuler->ruler.SetRange(loFreq, hiFreq);
827 }
828
829 mBands.ErrMin(); //move sliders to minimise error
830
831 szrV->Show(szrG,true); // eq sliders
832 szrH->Show(szrI,mOptions == kEqLegacy ); // interpolation choice
833 szrH->Show(szrL,false); // linear freq checkbox
834
835 mUIParent->Layout();
836 wxGetTopLevelParent(mUIParent)->Layout();
837 mUIParent->Layout();
838 wxGetTopLevelParent(mUIParent)->Layout();
839
840 mBands.GraphicEQ(logEnvelope);
841 drawMode = false;
842}

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 493 of file EqualizationUI.cpp.

494{
495 const auto &parameters = mCurvesList.mParameters;
496 const auto &dBMin = parameters.mdBMin;
497 const auto &dBMax = parameters.mdBMax;
498
499 // Refresh ruler when values have changed
500 int w1, w2, h;
501 mdBRuler->ruler.GetMaxSize(&w1, &h);
502 mdBRuler->ruler.SetRange(dBMax, dBMin);
503 mdBRuler->ruler.GetMaxSize(&w2, &h);
504 if( w1 != w2 ) // Reduces flicker
505 {
506 mdBRuler->SetSize(wxSize(w2,h));
507 mFreqRuler->Refresh(false);
508 }
509 mdBRuler->Refresh(false);
510
511 mPanel->Refresh(false);
512}
void GetMaxSize(wxCoord *width, wxCoord *height)
Definition: Ruler.cpp:613

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 41 of file EqualizationUI.cpp.

42{
43 const auto &parameters = mCurvesList.mParameters;
44 const auto &curveName = parameters.mCurveName;
45 auto &logEnvelope = parameters.mLogEnvelope;
46 const auto &curves = mCurvesList.mCurves;
47
48 // If editing a macro, we don't want to be using the unnamed curve so
49 // we offer to save it.
50
51 if (mDisallowCustom && curveName == wxT("unnamed"))
52 {
53 // PRL: This is unreachable. mDisallowCustom is always false.
54
56 mName,
57 XO("To use this filter curve in a macro, please choose a new name for it.\nChoose the 'Save/Manage Curves...' button and rename the 'unnamed' curve, then use that one."),
58 XO("Filter Curve EQ needs a different name") );
59 return false;
60 }
61
62 EQCurveWriter{ curves }.SaveCurves();
63
64 parameters.SaveConfig(mManager);
65
66 return true;
67}
Serializer of curves into XML files.
void SaveCurves(const wxString &fileName={})

References EQUtils::DoMessageBox(), EQCurveWriter::SaveCurves(), wxT(), and XO().

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

◆ mCurve

wxWeakRef<wxChoice> EqualizationUI::mCurve {}
private

Definition at line 117 of file EqualizationUI.h.

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

◆ mCurvesList

EqualizationCurvesList& EqualizationUI::mCurvesList
private

◆ mdBMaxSlider

wxSlider* EqualizationUI::mdBMaxSlider
private

Definition at line 122 of file EqualizationUI.h.

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

◆ mdBMinSlider

wxSlider* EqualizationUI::mdBMinSlider
private

Definition at line 121 of file EqualizationUI.h.

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

◆ mdBRuler

RulerPanel* EqualizationUI::mdBRuler
private

Definition at line 91 of file EqualizationUI.h.

Referenced by PopulateOrExchange(), and UpdateRuler().

◆ mDisallowCustom

bool EqualizationUI::mDisallowCustom { false }
private

Definition at line 94 of file EqualizationUI.h.

◆ mDraw

wxRadioButton* EqualizationUI::mDraw {}
private

Definition at line 112 of file EqualizationUI.h.

Referenced by PopulateOrExchange(), and TransferDataToWindow().

◆ mFreqRuler

RulerPanel* EqualizationUI::mFreqRuler
private

◆ mGraphic

wxRadioButton* EqualizationUI::mGraphic {}
private

Definition at line 113 of file EqualizationUI.h.

Referenced by PopulateOrExchange(), and TransferDataToWindow().

◆ mGridOnOff

wxCheckBox* EqualizationUI::mGridOnOff
private

Definition at line 115 of file EqualizationUI.h.

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

◆ mInterpChoice

wxChoice* EqualizationUI::mInterpChoice
private

Definition at line 116 of file EqualizationUI.h.

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

◆ mLeftSpacer

wxSizerItem* EqualizationUI::mLeftSpacer
private

Definition at line 108 of file EqualizationUI.h.

◆ mLinFreq

wxCheckBox* EqualizationUI::mLinFreq
private

Definition at line 114 of file EqualizationUI.h.

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

◆ mManage

wxButton* EqualizationUI::mManage
private

Definition at line 118 of file EqualizationUI.h.

◆ mManager

EffectSettingsManager& EqualizationUI::mManager
private

Definition at line 85 of file EqualizationUI.h.

◆ mMSlider

wxSlider* EqualizationUI::mMSlider {}
private

Definition at line 120 of file EqualizationUI.h.

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

◆ mMText

wxStaticText* EqualizationUI::mMText
private

Definition at line 119 of file EqualizationUI.h.

Referenced by OnSliderM(), and PopulateOrExchange().

◆ mName

TranslatableString EqualizationUI::mName
private

Definition at line 88 of file EqualizationUI.h.

Referenced by OnManage(), and setCurve().

◆ mOptions

const int EqualizationUI::mOptions
private

Definition at line 89 of file EqualizationUI.h.

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

◆ mPanel

wxWeakRef<EqualizationPanel> EqualizationUI::mPanel {}
private

Definition at line 110 of file EqualizationUI.h.

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

◆ mUIParent

const wxWeakRef<wxWindow>& EqualizationUI::mUIParent
private

◆ szr1

wxSizer* EqualizationUI::szr1
private

Definition at line 102 of file EqualizationUI.h.

Referenced by PopulateOrExchange(), and TransferDataToWindow().

◆ szr2

wxSizer* EqualizationUI::szr2
private

Definition at line 103 of file EqualizationUI.h.

◆ szr3

wxSizer* EqualizationUI::szr3
private

Definition at line 104 of file EqualizationUI.h.

◆ szr4

wxSizer* EqualizationUI::szr4
private

Definition at line 105 of file EqualizationUI.h.

◆ szr5

wxSizer* EqualizationUI::szr5
private

Definition at line 106 of file EqualizationUI.h.

◆ szrC

wxSizer* EqualizationUI::szrC
private

Definition at line 96 of file EqualizationUI.h.

◆ szrG

wxSizer* EqualizationUI::szrG
private

◆ szrH

wxSizer* EqualizationUI::szrH
private

◆ szrI

wxSizer* EqualizationUI::szrI
private

◆ szrL

wxSizer* EqualizationUI::szrL
private

◆ szrV

wxSizer* EqualizationUI::szrV
private

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