Audacity 3.2.0
Wahwah.cpp
Go to the documentation of this file.
1/**********************************************************************
2
3 Audacity: A Digital Audio Editor
4
5 Wahwah.cpp
6
7 Effect programming:
8 Nasca Octavian Paul (Paul Nasca)
9
10 UI programming:
11 Dominic Mazzoni (with the help of wxDesigner)
12 Vaughan Johnson (Preview)
13
14*******************************************************************//*******************************************************************/
20
21
22#include "Wahwah.h"
23#include "LoadEffects.h"
24
25#include <math.h>
26
27#include <wx/intl.h>
28#include <wx/slider.h>
29
30#include "../ShuttleGui.h"
31#include "../widgets/valnum.h"
32
34{
37 > parameters;
38 return parameters;
39}
40
41// How many samples are processed before recomputing the lfo value again
42#define lfoskipsamples 30
43
44//
45// EffectWahwah
46//
47
49{ XO("Wahwah") };
50
52
55{
58 : EffectUIValidator{ effect, access }
60 {}
61 virtual ~Validator() = default;
62
63 Effect& GetEffect() const { return static_cast<Effect&>(mEffect); }
64
65 bool ValidateUI() override;
66 bool UpdateUI() override;
67
69
70 void OnFreqSlider(wxCommandEvent& evt);
71 void OnPhaseSlider(wxCommandEvent& evt);
72 void OnDepthSlider(wxCommandEvent& evt);
73 void OnResonanceSlider(wxCommandEvent& evt);
74 void OnFreqOffSlider(wxCommandEvent& evt);
75 void OnGainSlider(wxCommandEvent& evt);
76
77 void OnFreqText(wxCommandEvent& evt);
78 void OnPhaseText(wxCommandEvent& evt);
79 void OnDepthText(wxCommandEvent& evt);
80 void OnResonanceText(wxCommandEvent& evt);
81 void OnFreqOffText(wxCommandEvent& evt);
82 void OnGainText(wxCommandEvent& evt);
83
84 wxTextCtrl* mFreqT;
85 wxTextCtrl* mPhaseT;
86 wxTextCtrl* mDepthT;
87 wxTextCtrl* mResT;
88 wxTextCtrl* mFreqOfsT;
89 wxTextCtrl* mOutGainT;
90
91 wxSlider* mFreqS;
92 wxSlider* mPhaseS;
93 wxSlider* mDepthS;
94 wxSlider* mResS;
95 wxSlider* mFreqOfsS;
96 wxSlider* mOutGainS;
97
98
100
102 {
103 Effect& actualEffect = static_cast<Effect&>(mEffect);
104 actualEffect.EnableApply(actualEffect.GetUIParent()->Validate());
105 }
106
108 {
109 Effect& actualEffect = static_cast<Effect&>(mEffect);
110 return actualEffect.EnableApply(actualEffect.GetUIParent()->TransferDataFromWindow());
111 }
112};
113
114
116{
118 (
119 [this](EffectSettings& settings)
120 {
121 // pass back the modified settings to the MessageBuffer
123 }
124 );
125
126 return true;
127}
128
129
133{
134 explicit Instance(const PerTrackEffect& effect)
135 : PerTrackEffect::Instance{ effect }
136 {}
137
138 bool ProcessInitialize(EffectSettings &settings, double sampleRate,
139 sampleCount totalLen, ChannelNames chanMap) override;
140
142 const float* const* inBlock, float* const* outBlock, size_t blockLen) override;
143
144 //bool ProcessFinalize(void) override;
145
146 bool RealtimeInitialize(EffectSettings& settings, double) override;
147
149 unsigned numChannels, float sampleRate) override;
150
151 bool RealtimeFinalize(EffectSettings& settings) noexcept override;
152
153 size_t RealtimeProcess(size_t group, EffectSettings& settings,
154 const float* const* inbuf, float* const* outbuf, size_t numSamples)
155 override;
156
157
158 void InstanceInit(EffectSettings& settings, EffectWahwahState& data, float sampleRate);
159
161 const float* const* inBlock, float* const* outBlock, size_t blockLen);
162
164 std::vector<EffectWahwahState> mSlaves;
165};
166
167
168std::shared_ptr<EffectInstance> EffectWahwah::MakeInstance() const
169{
170 return std::make_shared<Instance>(*this);
171}
172
174{
176}
177
179{
180}
181
182// ComponentInterface implementation
183
185{
186 return Symbol;
187}
188
190{
191 return XO("Rapid tone quality variations, like that guitar sound so popular in the 1970's");
192}
193
195{
196 return L"Wahwah";
197}
198
199// EffectDefinitionInterface implementation
200
202{
203 return EffectTypeProcess;
204}
205
207{
209}
210
212{
213 return 1;
214}
215
217{
218 return 1;
219}
220
222 double sampleRate, sampleCount, ChannelNames chanMap)
223{
224 InstanceInit(settings, mMaster, sampleRate);
225 if (chanMap[0] == ChannelNameFrontRight)
226 mMaster.phase += M_PI;
227 return true;
228}
229
231 const float *const *inBlock, float *const *outBlock, size_t blockLen)
232{
233 return InstanceProcess(settings, mMaster, inBlock, outBlock, blockLen);
234}
235
237{
238 SetBlockSize(512);
239 mSlaves.clear();
240 return true;
241}
242
244 EffectSettings &settings, unsigned, float sampleRate)
245{
246 EffectWahwahState slave;
247
248 InstanceInit(settings, slave, sampleRate);
249
250 mSlaves.push_back(slave);
251
252 return true;
253}
254
256{
257 mSlaves.clear();
258
259 return true;
260}
261
263 const float *const *inbuf, float *const *outbuf, size_t numSamples)
264{
265 if (group >= mSlaves.size())
266 return 0;
267 return InstanceProcess(settings, mSlaves[group], inbuf, outbuf, numSamples);
268}
269
270// Effect implementation
271
272std::unique_ptr<EffectUIValidator> EffectWahwah::PopulateOrExchange(
274{
275 auto& settings = access.Get();
276 auto& myEffSettings = GetSettings(settings);
277 auto result = std::make_unique<Validator>(*this, access, myEffSettings);
278 result->PopulateOrExchange(S);
279 return result;
280}
281
283{
284 auto& ms = mSettings;
285
286 S.SetBorder(5);
287 S.AddSpace(0, 5);
288
289 S.StartMultiColumn(3, wxEXPAND);
290 {
291 S.SetStretchyCol(2);
292
293 mFreqT = S
294 .Validator<FloatingPointValidator<double>>(
295 5, &ms.mFreq, NumValidatorStyle::ONE_TRAILING_ZERO, Freq.min, Freq.max)
296 .AddTextBox(XXO("LFO Freq&uency (Hz):"), L"", 12);
297 BindTo(*mFreqT, wxEVT_TEXT, &Validator::OnFreqText);
298
299 mFreqS = S
300 .Name(XO("LFO frequency in hertz"))
301 .Style(wxSL_HORIZONTAL)
302 .MinSize( { 100, -1 } )
303 .AddSlider( {}, Freq.def * Freq.scale, Freq.max * Freq.scale, Freq.min * Freq.scale);
304 BindTo(*mFreqS, wxEVT_SLIDER, &Validator::OnFreqSlider);
305
306 mPhaseT = S
307 .Validator<FloatingPointValidator<double>>(
308 1, &ms.mPhase, NumValidatorStyle::DEFAULT, Phase.min, Phase.max)
309 .AddTextBox(XXO("LFO Sta&rt Phase (deg.):"), L"", 12);
310 BindTo(*mPhaseT, wxEVT_TEXT, &Validator::OnPhaseText);
311
312 mPhaseS = S
313 .Name(XO("LFO start phase in degrees"))
314 .Style(wxSL_HORIZONTAL)
315 .MinSize( { 100, -1 } )
316 .AddSlider( {}, Phase.def * Phase.scale, Phase.max * Phase.scale, Phase.min * Phase.scale);
317 mPhaseS->SetLineSize(10);
318 BindTo(*mPhaseS, wxEVT_SLIDER, &Validator::OnPhaseSlider);
319
320 mDepthT = S
321 .Validator<IntegerValidator<int>>(
322 &ms.mDepth, NumValidatorStyle::DEFAULT, Depth.min, Depth.max)
323 .AddTextBox(XXO("Dept&h (%):"), L"", 12);
324 BindTo(*mDepthT, wxEVT_TEXT, &Validator::OnDepthText);
325
326 mDepthS = S
327 .Name(XO("Depth in percent"))
328 .Style(wxSL_HORIZONTAL)
329 .MinSize( { 100, -1 } )
330 .AddSlider( {}, Depth.def * Depth.scale, Depth.max * Depth.scale, Depth.min * Depth.scale);
331 BindTo(*mDepthS, wxEVT_SLIDER, &Validator::OnDepthSlider);
332
333 mResT = S
334 .Validator<FloatingPointValidator<double>>(
335 1, &ms.mRes, NumValidatorStyle::DEFAULT, Res.min, Res.max)
336 .AddTextBox(XXO("Reso&nance:"), L"", 12);
337 BindTo(*mResT, wxEVT_TEXT, &Validator::OnResonanceText);
338
339 mResS = S
340 .Name(XO("Resonance"))
341 .Style(wxSL_HORIZONTAL)
342 .MinSize( { 100, -1 } )
343 .AddSlider( {}, Res.def * Res.scale, Res.max * Res.scale, Res.min * Res.scale);
344 BindTo(*mResS, wxEVT_SLIDER, &Validator::OnResonanceSlider);
345
346 mFreqOfsT = S
347 .Validator<IntegerValidator<int>>(
348 &ms.mFreqOfs, NumValidatorStyle::DEFAULT, FreqOfs.min, FreqOfs.max)
349 .AddTextBox(XXO("Wah Frequency Offse&t (%):"), L"", 12);
350 BindTo(*mFreqOfsT, wxEVT_TEXT, &Validator::OnFreqOffText);
351
352 mFreqOfsS = S
353 .Name(XO("Wah frequency offset in percent"))
354 .Style(wxSL_HORIZONTAL)
355 .MinSize( { 100, -1 } )
357 BindTo(*mFreqOfsS, wxEVT_SLIDER, &Validator::OnFreqOffSlider);
358
359 mOutGainT = S
360 .Validator<FloatingPointValidator<double>>(
361 1, &ms.mOutGain, NumValidatorStyle::DEFAULT, OutGain.min, OutGain.max)
362 .AddTextBox(XXO("&Output gain (dB):"), L"", 12);
363 BindTo(*mOutGainT, wxEVT_TEXT, &Validator::OnGainText);
364
365 mOutGainS = S
366 .Name(XO("Output gain (dB)"))
367 .Style(wxSL_HORIZONTAL)
368 .MinSize( { 100, -1 } )
370 BindTo(*mOutGainS, wxEVT_SLIDER, &Validator::OnGainSlider);
371 }
372 S.EndMultiColumn();
373}
374
376{
377 // get the settings from the MessageBuffer and write them to our local copy
378 const auto& settings = mAccess.Get();
379
380 mSettings = GetSettings(settings);
381
382 auto& ms = mSettings;
383
384 mFreqS->SetValue((int)(ms.mFreq * Freq.scale));
385 mPhaseS->SetValue((int)(ms.mPhase * Phase.scale));
386 mDepthS->SetValue((int)(ms.mDepth * Depth.scale));
387 mResS->SetValue((int)(ms.mRes * Res.scale));
388 mFreqOfsS->SetValue((int)(ms.mFreqOfs * FreqOfs.scale));
389 mOutGainS->SetValue((int)(ms.mOutGain * OutGain.scale));
390
391 return true;
392}
393
394// EffectWahwah implementation
395
397{
398 auto& ms = GetSettings(settings);
399
400 data.samplerate = sampleRate;
401 data.lfoskip = ms.mFreq * 2 * M_PI / sampleRate;
402 data.skipcount = 0;
403 data.xn1 = 0;
404 data.xn2 = 0;
405 data.yn1 = 0;
406 data.yn2 = 0;
407 data.b0 = 0;
408 data.b1 = 0;
409 data.b2 = 0;
410 data.a0 = 0;
411 data.a1 = 0;
412 data.a2 = 0;
413
414 data.depth = ms.mDepth / 100.0;
415 data.freqofs = ms.mFreqOfs / 100.0;
416 data.phase = ms.mPhase * M_PI / 180.0;
417 data.outgain = DB_TO_LINEAR(ms.mOutGain);
418}
419
421 EffectWahwahState & data,
422 const float *const *inBlock, float *const *outBlock, size_t blockLen)
423{
424 auto& ms = GetSettings(settings);
425
426 const float *ibuf = inBlock[0];
427 float *obuf = outBlock[0];
428 double frequency, omega, sn, cs, alpha;
429 double in, out;
430
431 data.lfoskip = ms.mFreq * 2 * M_PI / data.samplerate;
432 data.depth = ms.mDepth / 100.0;
433 data.freqofs = ms.mFreqOfs / 100.0;
434
435 data.phase = ms.mPhase * M_PI / 180.0;
436 data.outgain = DB_TO_LINEAR(ms.mOutGain);
437
438 for (decltype(blockLen) i = 0; i < blockLen; i++)
439 {
440 in = (double) ibuf[i];
441
442 if ((data.skipcount++) % lfoskipsamples == 0)
443 {
444 frequency = (1 + cos(data.skipcount * data.lfoskip + data.phase)) / 2;
445 frequency = frequency * data.depth * (1 - data.freqofs) + data.freqofs;
446 frequency = exp((frequency - 1) * 6);
447 omega = M_PI * frequency;
448 sn = sin(omega);
449 cs = cos(omega);
450 alpha = sn / (2 * ms.mRes);
451 data.b0 = (1 - cs) / 2;
452 data.b1 = 1 - cs;
453 data.b2 = (1 - cs) / 2;
454 data.a0 = 1 + alpha;
455 data.a1 = -2 * cs;
456 data.a2 = 1 - alpha;
457 };
458 out = (data.b0 * in + data.b1 * data.xn1 + data.b2 * data.xn2 - data.a1 * data.yn1 - data.a2 * data.yn2) / data.a0;
459 data.xn2 = data.xn1;
460 data.xn1 = in;
461 data.yn2 = data.yn1;
462 data.yn1 = out;
463 out *= data.outgain;
464
465 obuf[i] = (float) out;
466 }
467
468 return blockLen;
469}
470
472{
473 auto& ms = mSettings;
474
475 ms.mFreq = (double)evt.GetInt() / Freq.scale;
476 mFreqT->GetValidator()->TransferToWindow();
477
478 EnableApplyFromValidate();
479 ValidateUI();
480}
481
483{
484 auto& ms = mSettings;
485
486 int val = ((evt.GetInt() + 5) / 10) * 10; // round to nearest multiple of 10
487 val = val > Phase.max * Phase.scale ? Phase.max * Phase.scale : val;
488 mPhaseS->SetValue(val);
489 ms.mPhase = (double)val / Phase.scale;
490 mPhaseT->GetValidator()->TransferToWindow();
491
492 EnableApplyFromValidate();
493 ValidateUI();
494}
495
497{
498 auto& ms = mSettings;
499
500 ms.mDepth = evt.GetInt() / Depth.scale;
501 mDepthT->GetValidator()->TransferToWindow();
502
503 EnableApplyFromValidate();
504 ValidateUI();
505}
506
508{
509 auto& ms = mSettings;
510
511 ms.mRes = (double)evt.GetInt() / Res.scale;
512 mResT->GetValidator()->TransferToWindow();
513
514 EnableApplyFromValidate();
515 ValidateUI();
516}
517
519{
520 auto& ms = mSettings;
521
522 ms.mFreqOfs = evt.GetInt() / FreqOfs.scale;
523 mFreqOfsT->GetValidator()->TransferToWindow();
524
525 EnableApplyFromValidate();
526 ValidateUI();
527}
528
530{
531 auto& ms = mSettings;
532
533 ms.mOutGain = evt.GetInt() / OutGain.scale;
534 mOutGainT->GetValidator()->TransferToWindow();
535
536 EnableApplyFromValidate();
537 ValidateUI();
538}
539
540void EffectWahwah::Validator::OnFreqText(wxCommandEvent& WXUNUSED(evt))
541{
542 auto& ms = mSettings;
543
544 if (!EnableApplyFromTransferDataToWindow())
545 {
546 return;
547 }
548
549 mFreqS->SetValue((int)(ms.mFreq * Freq.scale));
550 ValidateUI();
551}
552
553void EffectWahwah::Validator::OnPhaseText(wxCommandEvent& WXUNUSED(evt))
554{
555 auto& ms = mSettings;
556
557 if (!EnableApplyFromTransferDataToWindow())
558 {
559 return;
560 }
561
562 mPhaseS->SetValue((int)(ms.mPhase * Phase.scale));
563 ValidateUI();
564}
565
566void EffectWahwah::Validator::OnDepthText(wxCommandEvent& WXUNUSED(evt))
567{
568 auto& ms = mSettings;
569
570 if (!EnableApplyFromTransferDataToWindow())
571 {
572 return;
573 }
574
575 mDepthS->SetValue((int)(ms.mDepth * Depth.scale));
576 ValidateUI();
577}
578
579void EffectWahwah::Validator::OnResonanceText(wxCommandEvent& WXUNUSED(evt))
580{
581 auto& ms = mSettings;
582
583 if (!EnableApplyFromTransferDataToWindow())
584 {
585 return;
586 }
587
588 mResS->SetValue((int)(ms.mRes * Res.scale));
589 ValidateUI();
590}
591
592void EffectWahwah::Validator::OnFreqOffText(wxCommandEvent& WXUNUSED(evt))
593{
594 auto& ms = mSettings;
595
596 if (!EnableApplyFromTransferDataToWindow())
597 {
598 return;
599 }
600
601 mFreqOfsS->SetValue((int)(ms.mFreqOfs * FreqOfs.scale));
602 ValidateUI();
603}
604
605void EffectWahwah::Validator::OnGainText(wxCommandEvent& WXUNUSED(evt))
606{
607 auto& ms = mSettings;
608
609 if (!EnableApplyFromTransferDataToWindow())
610 {
611 return;
612 }
613
614 mOutGainS->SetValue((int)(ms.mOutGain * OutGain.scale));
615 ValidateUI();
616}
#define M_PI
Definition: Distortion.cpp:29
EffectType
@ EffectTypeProcess
enum ChannelName * ChannelNames
@ ChannelNameFrontRight
#define XXO(s)
Definition: Internat.h:44
#define XO(s)
Definition: Internat.h:31
#define DB_TO_LINEAR(x)
Definition: MemoryX.h:535
#define S(N)
Definition: ToChars.cpp:64
static Settings & settings()
Definition: TrackInfo.cpp:87
#define lfoskipsamples
Definition: Wahwah.cpp:42
Generates EffectParameterMethods overrides from variadic template arguments.
ComponentInterfaceSymbol pairs a persistent string identifier used internally with an optional,...
void SetLinearEffectFlag(bool linearEffectFlag)
Definition: EffectBase.cpp:218
RealtimeSince
In which versions of Audacity was an effect realtime capable?
Base class for many of the effects in Audacity.
Definition: Effect.h:29
bool EnableApply(bool enable=true)
Definition: Effect.cpp:613
wxWindow * GetUIParent()
Definition: Effect.h:273
bool ValidateUI(EffectSettings &) override
Definition: Effect.cpp:313
Performs effect computation.
Inherit to add a state variable to an EffectInstance subclass.
Interface for manipulations of an Effect's settings.
void ModifySettings(Function &&function)
Do a correct read-modify-write of settings.
virtual const EffectSettings & Get()=0
EffectUIClientInterface is an abstract base class to populate a UI and validate UI values....
Interface for transferring values from a panel of effect controls.
EffectSettingsAccess & mAccess
EffectUIClientInterface & mEffect
static constexpr EffectParameter Freq
Definition: Wahwah.h:108
static constexpr EffectParameter FreqOfs
Definition: Wahwah.h:112
unsigned GetAudioOutCount() const override
How many output buffers to allocate at once.
Definition: Wahwah.cpp:216
static constexpr EffectParameter Res
Definition: Wahwah.h:111
static constexpr EffectParameter Depth
Definition: Wahwah.h:110
unsigned GetAudioInCount() const override
How many input buffers to allocate at once.
Definition: Wahwah.cpp:211
const EffectParameterMethods & Parameters() const override
Definition: Wahwah.cpp:33
static const ComponentInterfaceSymbol Symbol
Definition: Wahwah.h:74
std::unique_ptr< EffectUIValidator > PopulateOrExchange(ShuttleGui &S, EffectInstance &instance, EffectSettingsAccess &access) override
Add controls to effect panel; always succeeds.
Definition: Wahwah.cpp:272
ComponentInterfaceSymbol GetSymbol() const override
Definition: Wahwah.cpp:184
ManualPageID ManualPage() const override
Name of a page in the Audacity alpha manual, default is empty.
Definition: Wahwah.cpp:194
EffectType GetType() const override
Type determines how it behaves.
Definition: Wahwah.cpp:201
virtual ~EffectWahwah()
Definition: Wahwah.cpp:178
std::shared_ptr< EffectInstance > MakeInstance() const override
Make an object maintaining short-term state of an Effect.
Definition: Wahwah.cpp:168
static constexpr EffectParameter Phase
Definition: Wahwah.h:109
TranslatableString GetDescription() const override
Definition: Wahwah.cpp:189
static constexpr EffectParameter OutGain
Definition: Wahwah.h:113
RealtimeSince RealtimeSupport() const override
Since which version of Audacity has the effect supported realtime?
Definition: Wahwah.cpp:206
double yn2
Definition: Wahwah.h:34
double freqofs
Definition: Wahwah.h:29
double xn2
Definition: Wahwah.h:34
float samplerate
Definition: Wahwah.h:27
unsigned long skipcount
Definition: Wahwah.h:33
double yn1
Definition: Wahwah.h:34
double outgain
Definition: Wahwah.h:31
double xn1
Definition: Wahwah.h:34
double phase
Definition: Wahwah.h:30
double depth
Definition: Wahwah.h:28
double lfoskip
Definition: Wahwah.h:32
static EffectWahwahSettings & GetSettings(EffectSettings &settings)
Assume settings originated from MakeSettings() and copies thereof.
Definition: Effect.h:296
Base class for many of the effects in Audacity.
Derived from ShuttleGuiBase, an Audacity specific class for shuttling data to and from GUI.
Definition: ShuttleGui.h:628
Holds a msgid for the translation catalog; may also bind format arguments.
Positions or offsets within audio files need a wide type.
Definition: SampleCount.h:18
BuiltinEffectsModule::Registration< EffectWahwah > reg
Definition: Wahwah.cpp:51
const Type scale
Scaling factor, for slider control.
Definition: Shuttle.h:32
const Type def
Default value.
Definition: Shuttle.h:29
const Type min
Minimum value.
Definition: Shuttle.h:30
const Type max
Maximum value.
Definition: Shuttle.h:31
Externalized state of a plug-in.
bool RealtimeAddProcessor(EffectSettings &settings, unsigned numChannels, float sampleRate) override
Definition: Wahwah.cpp:243
bool ProcessInitialize(EffectSettings &settings, double sampleRate, sampleCount totalLen, ChannelNames chanMap) override
Definition: Wahwah.cpp:221
void InstanceInit(EffectSettings &settings, EffectWahwahState &data, float sampleRate)
Definition: Wahwah.cpp:396
size_t RealtimeProcess(size_t group, EffectSettings &settings, const float *const *inbuf, float *const *outbuf, size_t numSamples) override
Definition: Wahwah.cpp:262
bool RealtimeInitialize(EffectSettings &settings, double) override
Definition: Wahwah.cpp:236
EffectWahwahState mMaster
Definition: Wahwah.cpp:163
size_t InstanceProcess(EffectSettings &settings, EffectWahwahState &data, const float *const *inBlock, float *const *outBlock, size_t blockLen)
Definition: Wahwah.cpp:420
size_t ProcessBlock(EffectSettings &settings, const float *const *inBlock, float *const *outBlock, size_t blockLen) override
Called for destructive effect computation.
Definition: Wahwah.cpp:230
Instance(const PerTrackEffect &effect)
Definition: Wahwah.cpp:134
std::vector< EffectWahwahState > mSlaves
Definition: Wahwah.cpp:164
bool RealtimeFinalize(EffectSettings &settings) noexcept override
Definition: Wahwah.cpp:255
void OnFreqSlider(wxCommandEvent &evt)
Definition: Wahwah.cpp:471
wxTextCtrl * mDepthT
Definition: Wahwah.cpp:86
void OnPhaseSlider(wxCommandEvent &evt)
Definition: Wahwah.cpp:482
void OnGainSlider(wxCommandEvent &evt)
Definition: Wahwah.cpp:529
void OnResonanceSlider(wxCommandEvent &evt)
Definition: Wahwah.cpp:507
void PopulateOrExchange(ShuttleGui &S)
Definition: Wahwah.cpp:282
void OnGainText(wxCommandEvent &evt)
Definition: Wahwah.cpp:605
bool EnableApplyFromTransferDataToWindow()
Definition: Wahwah.cpp:107
wxSlider * mOutGainS
Definition: Wahwah.cpp:96
void OnFreqText(wxCommandEvent &evt)
Definition: Wahwah.cpp:540
void EnableApplyFromValidate()
Definition: Wahwah.cpp:101
wxSlider * mPhaseS
Definition: Wahwah.cpp:92
Effect & GetEffect() const
Definition: Wahwah.cpp:63
wxTextCtrl * mFreqT
Definition: Wahwah.cpp:84
void OnFreqOffText(wxCommandEvent &evt)
Definition: Wahwah.cpp:592
wxTextCtrl * mResT
Definition: Wahwah.cpp:87
wxTextCtrl * mFreqOfsT
Definition: Wahwah.cpp:88
void OnFreqOffSlider(wxCommandEvent &evt)
Definition: Wahwah.cpp:518
wxTextCtrl * mPhaseT
Definition: Wahwah.cpp:85
void OnDepthSlider(wxCommandEvent &evt)
Definition: Wahwah.cpp:496
wxSlider * mDepthS
Definition: Wahwah.cpp:93
bool UpdateUI() override
Update appearance of the panel for changes in settings.
Definition: Wahwah.cpp:375
Validator(EffectUIClientInterface &effect, EffectSettingsAccess &access, const EffectWahwahSettings &settings)
Definition: Wahwah.cpp:56
EffectWahwahSettings mSettings
Definition: Wahwah.cpp:99
void OnPhaseText(wxCommandEvent &evt)
Definition: Wahwah.cpp:553
wxTextCtrl * mOutGainT
Definition: Wahwah.cpp:89
virtual ~Validator()=default
wxSlider * mFreqOfsS
Definition: Wahwah.cpp:95
void OnResonanceText(wxCommandEvent &evt)
Definition: Wahwah.cpp:579
bool ValidateUI() override
Get settings data from the panel; may make error dialogs and return false.
Definition: Wahwah.cpp:115
void OnDepthText(wxCommandEvent &evt)
Definition: Wahwah.cpp:566