Audacity  3.0.3
ToneGen.cpp
Go to the documentation of this file.
1 /**********************************************************************
2 
3  Audacity: A Digital Audio Editor
4 
5  ToneGen.cpp
6 
7  Steve Jolly
8  James Crook (Adapted for 'Chirps')
9 
10  This class implements a tone generator effect.
11 
12 *******************************************************************//*******************************************************************/
20 
21 
22 #include "ToneGen.h"
23 #include "LoadEffects.h"
24 
25 #include <math.h>
26 #include <float.h>
27 
28 #include <wx/choice.h>
29 #include <wx/intl.h>
30 #include <wx/valgen.h>
31 
32 #include "../Project.h"
33 #include "../ProjectSettings.h"
34 #include "../Shuttle.h"
35 #include "../ShuttleGui.h"
36 #include "../widgets/valnum.h"
37 #include "../widgets/NumericTextCtrl.h"
38 
40 {
44 };
45 
47 {
48  // These are acceptable dual purpose internal/visible names
49  { XO("Linear") },
50  { XO("Logarithmic") }
51 };
52 
54 {
60 };
61 
63 {
64  { XO("Sine") },
65  { XO("Square") },
66  { XO("Sawtooth") },
67  { XO("Square, no alias") }
68 };
69 
70 // Define keys, defaults, minimums, and maximums for the effect parameters
71 //
72 // Name Type Key Def Min Max Scale
73 Param( StartFreq, double, wxT("StartFreq"), 440.0, 1.0, DBL_MAX, 1 );
74 Param( EndFreq, double, wxT("EndFreq"), 1320.0, 1.0, DBL_MAX, 1 );
75 Param( StartAmp, double, wxT("StartAmp"), 0.8, 0.0, 1.0, 1 );
76 Param( EndAmp, double, wxT("EndAmp"), 0.1, 0.0, 1.0, 1 );
77 Param( Frequency, double, wxT("Frequency"), 440.0, 1.0, DBL_MAX, 1 );
78 Param( Amplitude, double, wxT("Amplitude"), 0.8, 0.0, 1.0, 1 );
79 Param( Waveform, int, wxT("Waveform"), 0, 0, nWaveforms - 1, 1 );
80 Param( Interp, int, wxT("Interpolation"), 0, 0, nInterpolations - 1, 1 );
81 
82 //
83 // EffectToneGen
84 //
85 
87 { XO("Chirp") };
88 
90 
92 { XO("Tone") };
93 
95 
96 BEGIN_EVENT_TABLE(EffectToneGen, wxEvtHandler)
97  EVT_TEXT(wxID_ANY, EffectToneGen::OnControlUpdate)
99 
101 {
102  wxASSERT(nWaveforms == WXSIZEOF(kWaveStrings));
103  wxASSERT(nInterpolations == WXSIZEOF(kInterStrings));
104 
105  mChirp = isChirp;
106 
107  mWaveform = DEF_Waveform;
108  mFrequency[0] = DEF_StartFreq;
109  mFrequency[1] = DEF_EndFreq;
110  mAmplitude[0] = DEF_StartAmp;
111  mAmplitude[1] = DEF_EndAmp;
112  mInterpolation = DEF_Interp;
113 
114  // Chirp varies over time so must use selected duration.
115  // TODO: When previewing, calculate only the first 'preview length'.
116  if (isChirp)
117  SetLinearEffectFlag(false);
118  else
119  SetLinearEffectFlag(true);
120 }
121 
123 {
124 }
125 
126 // ComponentInterface implementation
127 
129 {
130  return mChirp
133 }
134 
136 {
137  return mChirp
138  ? XO("Generates an ascending or descending tone of one of four types")
139  : XO("Generates a constant frequency tone of one of four types");
140 }
141 
143 {
144  return mChirp
145  ? L"Chirp"
146  : L"Tone";
147 }
148 
149 // EffectDefinitionInterface implementation
150 
152 {
153  return EffectTypeGenerate;
154 }
155 
156 // EffectClientInterface implementation
157 
159 {
160  return 1;
161 }
162 
163 bool EffectToneGen::ProcessInitialize(sampleCount WXUNUSED(totalLen), ChannelNames WXUNUSED(chanMap))
164 {
165  mPositionInCycles = 0.0;
166  mSample = 0;
167 
168  return true;
169 }
170 
171 size_t EffectToneGen::ProcessBlock(float **WXUNUSED(inBlock), float **outBlock, size_t blockLen)
172 {
173  float *buffer = outBlock[0];
174  double throwaway = 0; //passed to modf but never used
175  double f = 0.0;
176  double a, b;
177  int k;
178 
179  double frequencyQuantum;
180  double BlendedFrequency;
181  double BlendedAmplitude;
182  double BlendedLogFrequency = 0.0;
183 
184  // calculate delta, and reposition from where we left
185  auto doubleSampleCount = mSampleCnt.as_double();
186  auto doubleSample = mSample.as_double();
187  double amplitudeQuantum =
188  (mAmplitude[1] - mAmplitude[0]) / doubleSampleCount;
189  BlendedAmplitude = mAmplitude[0] +
190  amplitudeQuantum * doubleSample;
191 
192  // precalculations:
193  double pre2PI = 2.0 * M_PI;
194  double pre4divPI = 4.0 / M_PI;
195 
196  // initial setup should calculate deltas
198  {
199  // this for log interpolation
200  mLogFrequency[0] = log10(mFrequency[0]);
201  mLogFrequency[1] = log10(mFrequency[1]);
202  // calculate delta, and reposition from where we left
203  frequencyQuantum = (mLogFrequency[1] - mLogFrequency[0]) / doubleSampleCount;
204  BlendedLogFrequency = mLogFrequency[0] + frequencyQuantum * doubleSample;
205  BlendedFrequency = pow(10.0, BlendedLogFrequency);
206  }
207  else
208  {
209  // this for regular case, linear interpolation
210  frequencyQuantum = (mFrequency[1] - mFrequency[0]) / doubleSampleCount;
211  BlendedFrequency = mFrequency[0] + frequencyQuantum * doubleSample;
212  }
213 
214  // synth loop
215  for (decltype(blockLen) i = 0; i < blockLen; i++)
216  {
217  switch (mWaveform)
218  {
219  case kSine:
220  f = sin(pre2PI * mPositionInCycles / mSampleRate);
221  break;
222  case kSquare:
223  f = (modf(mPositionInCycles / mSampleRate, &throwaway) < 0.5) ? 1.0 : -1.0;
224  break;
225  case kSawtooth:
226  f = (2.0 * modf(mPositionInCycles / mSampleRate + 0.5, &throwaway)) - 1.0;
227  break;
228  case kSquareNoAlias: // Good down to 110Hz @ 44100Hz sampling.
229  //do fundamental (k=1) outside loop
230  b = (1.0 + cos((pre2PI * BlendedFrequency) / mSampleRate)) / pre4divPI; //scaling
231  f = pre4divPI * sin(pre2PI * mPositionInCycles / mSampleRate);
232  for (k = 3; (k < 200) && (k * BlendedFrequency < mSampleRate / 2.0); k += 2)
233  {
234  //Hann Window in freq domain
235  a = 1.0 + cos((pre2PI * k * BlendedFrequency) / mSampleRate);
236  //calc harmonic, apply window, scale to amplitude of fundamental
237  f += a * sin(pre2PI * mPositionInCycles / mSampleRate * k) / (b * k);
238  }
239  }
240  // insert value in buffer
241  buffer[i] = (float) (BlendedAmplitude * f);
242  // update freq,amplitude
243  mPositionInCycles += BlendedFrequency;
244  BlendedAmplitude += amplitudeQuantum;
246  {
247  BlendedLogFrequency += frequencyQuantum;
248  BlendedFrequency = pow(10.0, BlendedLogFrequency);
249  }
250  else
251  {
252  BlendedFrequency += frequencyQuantum;
253  }
254  }
255 
256  // update external placeholder
257  mSample += blockLen;
258 
259  return blockLen;
260 }
261 
263  if( mChirp ){
264  S.SHUTTLE_PARAM( mFrequency[0], StartFreq );
265  S.SHUTTLE_PARAM( mFrequency[1], EndFreq );
266  S.SHUTTLE_PARAM( mAmplitude[0], StartAmp );
267  S.SHUTTLE_PARAM( mAmplitude[1], EndAmp );
268  } else {
269  S.SHUTTLE_PARAM( mFrequency[0], Frequency );
270  S.SHUTTLE_PARAM( mAmplitude[0], Amplitude );
271  // Slightly hacky way to set freq and ampl
272  // since we do this whatever query to params was made.
273  mFrequency[1] = mFrequency[0];
274  mAmplitude[1] = mAmplitude[0];
275  }
276  S.SHUTTLE_ENUM_PARAM( mWaveform, Waveform, kWaveStrings, nWaveforms );
277  S.SHUTTLE_ENUM_PARAM( mInterpolation, Interp, kInterStrings, nInterpolations );
278 
279 
280 // double freqMax = (FindProject() ? FindProject()->GetRate() : 44100.0) / 2.0;
281 // mFrequency[1] = TrapDouble(mFrequency[1], MIN_EndFreq, freqMax);
282 
283 
284  return true;
285 }
286 
288 {
289  if (mChirp)
290  {
291  parms.Write(KEY_StartFreq, mFrequency[0]);
292  parms.Write(KEY_EndFreq, mFrequency[1]);
293  parms.Write(KEY_StartAmp, mAmplitude[0]);
294  parms.Write(KEY_EndAmp, mAmplitude[1]);
295  }
296  else
297  {
298  parms.Write(KEY_Frequency, mFrequency[0]);
299  parms.Write(KEY_Amplitude, mAmplitude[0]);
300  }
301 
302  parms.Write(KEY_Waveform, kWaveStrings[mWaveform].Internal());
303  parms.Write(KEY_Interp, kInterStrings[mInterpolation].Internal());
304 
305  return true;
306 }
307 
309 {
312  if (mChirp)
313  {
314  ReadAndVerifyDouble(StartFreq);
315  ReadAndVerifyDouble(EndFreq);
316  ReadAndVerifyDouble(StartAmp);
317  ReadAndVerifyDouble(EndAmp);
318  mFrequency[0] = StartFreq;
319  mFrequency[1] = EndFreq;
320  mAmplitude[0] = StartAmp;
321  mAmplitude[1] = EndAmp;
322  }
323  else
324  {
325  ReadAndVerifyDouble(Frequency);
326  ReadAndVerifyDouble(Amplitude);
327  mFrequency[0] = Frequency;
328  mFrequency[1] = Frequency;
329  mAmplitude[0] = Amplitude;
330  mAmplitude[1] = Amplitude;
331  }
332 
334  mInterpolation = Interp;
335 
336  double freqMax =
337  (FindProject()
339  : 44100.0)
340  / 2.0;
341  mFrequency[1] = TrapDouble(mFrequency[1], MIN_EndFreq, freqMax);
342 
343  return true;
344 }
345 
346 // Effect implementation
347 
349 {
350  wxTextCtrl *t;
351 
352  S.StartMultiColumn(2, wxCENTER);
353  {
354  S.Validator<wxGenericValidator>(&mWaveform)
355  .AddChoice(XXO("&Waveform:"),
357 
358  if (mChirp)
359  {
360  S.AddFixedText( {} );
361  S.StartHorizontalLay(wxEXPAND);
362  {
363  S.StartHorizontalLay(wxLEFT, 50);
364  {
365  S.AddTitle(XO("Start"));
366  }
367  S.EndHorizontalLay();
368 
369  S.StartHorizontalLay(wxLEFT, 50);
370  {
371  S.AddTitle(XO("End"));
372  }
373  S.EndHorizontalLay();
374  }
375  S.EndHorizontalLay();
376 
377  S.AddPrompt(XXO("&Frequency (Hz):"));
378  S.StartHorizontalLay(wxEXPAND);
379  {
380  S.StartHorizontalLay(wxLEFT, 50);
381  {
382  t = S.Name(XO("Frequency Hertz Start"))
383  .Validator<FloatingPointValidator<double>>(
384  6, &mFrequency[0],
385  NumValidatorStyle::NO_TRAILING_ZEROES,
386  MIN_StartFreq,
387  mProjectRate / 2.0
388  )
389  .AddTextBox( {}, wxT(""), 12);
390  }
391  S.EndHorizontalLay();
392 
393  S.StartHorizontalLay(wxLEFT, 50);
394  {
395  t = S.Name(XO("Frequency Hertz End"))
396  .Validator<FloatingPointValidator<double>>(
397  6, &mFrequency[1],
398  NumValidatorStyle::NO_TRAILING_ZEROES,
399  MIN_EndFreq,
400  mProjectRate / 2.0
401  )
402  .AddTextBox( {}, wxT(""), 12);
403  }
404  S.EndHorizontalLay();
405  }
406  S.EndHorizontalLay();
407 
408  S.AddPrompt(XXO("&Amplitude (0-1):"));
409  S.StartHorizontalLay(wxEXPAND);
410  {
411  S.StartHorizontalLay(wxLEFT, 50);
412  {
413  t = S.Name(XO("Amplitude Start"))
414  .Validator<FloatingPointValidator<double>>(
415  6, &mAmplitude[0], NumValidatorStyle::NO_TRAILING_ZEROES,
416  MIN_StartAmp, MAX_StartAmp
417  )
418  .AddTextBox( {}, wxT(""), 12);
419  }
420  S.EndHorizontalLay();
421 
422  S.StartHorizontalLay(wxLEFT, 50);
423  {
424  t = S.Name(XO("Amplitude End"))
425  .Validator<FloatingPointValidator<double>>(
426  6, &mAmplitude[1], NumValidatorStyle::NO_TRAILING_ZEROES,
427  MIN_EndAmp, MAX_EndAmp
428  )
429  .AddTextBox( {}, wxT(""), 12);
430  }
431  S.EndHorizontalLay();
432  }
433  S.EndHorizontalLay();
434 
435  S.Validator<wxGenericValidator>(&mInterpolation)
436  .AddChoice(XXO("I&nterpolation:"),
438  }
439  else
440  {
441  t = S.Validator<FloatingPointValidator<double>>(
442  6, &mFrequency[0], NumValidatorStyle::NO_TRAILING_ZEROES,
443  MIN_Frequency,
444  mProjectRate / 2.0
445  )
446  .AddTextBox(XXO("&Frequency (Hz):"), wxT(""), 12);
447 
448  t = S.Validator<FloatingPointValidator<double>>(
449  6, &mAmplitude[0], NumValidatorStyle::NO_TRAILING_ZEROES,
450  MIN_Amplitude, MAX_Amplitude
451  )
452  .AddTextBox(XXO("&Amplitude (0-1):"), wxT(""), 12);
453  }
454 
455  S.AddPrompt(XXO("&Duration:"));
457  NumericTextCtrl(S.GetParent(), wxID_ANY,
460  GetDuration(),
461  mProjectRate,
463  .AutoPos(true));
464  S.Name(XO("Duration"))
465  .Position(wxALIGN_LEFT | wxALL)
467  }
468  S.EndMultiColumn();
469 
470  return;
471 }
472 
474 {
475  if (!mUIParent->TransferDataToWindow())
476  {
477  return false;
478  }
479 
481 
482  return true;
483 }
484 
486 {
487  if (!mUIParent->Validate() || !mUIParent->TransferDataFromWindow())
488  {
489  return false;
490  }
491 
492  if (!mChirp)
493  {
494  mFrequency[1] = mFrequency[0];
495  mAmplitude[1] = mAmplitude[0];
496  }
497 
499 
500  return true;
501 }
502 
503 // EffectToneGen implementation
504 
505 void EffectToneGen::OnControlUpdate(wxCommandEvent & WXUNUSED(evt))
506 {
507  if (!EnableApply(mUIParent->TransferDataFromWindow()))
508  {
509  return;
510  }
511 }
Effect::mSampleCnt
sampleCount mSampleCnt
Definition: Effect.h:482
EffectToneGen::mSample
sampleCount mSample
Definition: ToneGen.h:62
TranslatableString
Holds a msgid for the translation catalog; may also bind format arguments.
Definition: TranslatableString.h:32
CommandParameters
CommandParameters, derived from wxFileConfig, is essentially doing the same things as the Shuttle cla...
Definition: EffectAutomationParameters.h:67
Effect::FindProject
const AudacityProject * FindProject() const
Definition: Effect.cpp:2271
Effect::GetDuration
double GetDuration() override
Definition: Effect.cpp:815
Effect::EnableApply
virtual bool EnableApply(bool enable=true)
Definition: Effect.cpp:1925
EffectToneGen::OnControlUpdate
void OnControlUpdate(wxCommandEvent &evt)
Definition: ToneGen.cpp:505
NumericTextCtrl::Options::AutoPos
Options & AutoPos(bool enable)
Definition: NumericTextCtrl.h:190
kSquareNoAlias
@ kSquareNoAlias
Definition: ToneGen.cpp:58
EffectToneGen::GetDescription
TranslatableString GetDescription() override
Definition: ToneGen.cpp:135
ShuttleGuiBase::AddTitle
void AddTitle(const TranslatableString &Prompt, int wrapWidth=0)
Centred text string.
Definition: ShuttleGui.cpp:281
EffectToneGen::ProcessInitialize
bool ProcessInitialize(sampleCount totalLen, ChannelNames chanMap=NULL) override
Definition: ToneGen.cpp:163
EffectToneGen::GetType
EffectType GetType() override
Definition: ToneGen.cpp:151
EffectTypeGenerate
@ EffectTypeGenerate
Definition: EffectInterface.h:58
EffectTone::Symbol
static const ComponentInterfaceSymbol Symbol
Definition: ToneGen.h:90
EffectToneGen::mChirp
bool mChirp
Definition: ToneGen.h:58
Validator
A Validator is an object which checks whether a wxVariant satisfies a certain criterion....
Definition: Validators.h:53
XO
#define XO(s)
Definition: Internat.h:31
EffectToneGen::SetAutomationParameters
bool SetAutomationParameters(CommandParameters &parms) override
Definition: ToneGen.cpp:308
ProjectSettings::Get
static ProjectSettings & Get(AudacityProject &project)
Definition: ProjectSettings.cpp:40
ShuttleParams
Shuttle that deals with parameters. This is a base class with lots of virtual functions that do nothi...
Definition: Shuttle.h:62
ShuttleGuiBase::EndMultiColumn
void EndMultiColumn()
Definition: ShuttleGui.cpp:1238
EffectToneGen::mToneDurationT
NumericTextCtrl * mToneDurationT
Definition: ToneGen.h:73
anonymous_namespace{ToneGen.cpp}::reg
BuiltinEffectsModule::Registration< EffectChirp > reg
Definition: ToneGen.cpp:89
NumericTextCtrl
Definition: NumericTextCtrl.h:172
NumericTextCtrl::SetValue
void SetValue(double newValue)
Definition: NumericTextCtrl.cpp:1472
anonymous_namespace{ToneGen.cpp}::reg2
BuiltinEffectsModule::Registration< EffectTone > reg2
Definition: ToneGen.cpp:94
ComponentInterfaceSymbol
ComponentInterfaceSymbol pairs a persistent string identifier used internally with an optional,...
Definition: ComponentInterfaceSymbol.h:27
NumericTextCtrl::Options
Definition: NumericTextCtrl.h:178
EffectToneGen::~EffectToneGen
virtual ~EffectToneGen()
Definition: ToneGen.cpp:122
EffectToneGen::DefineParams
bool DefineParams(ShuttleParams &S) override
Definition: ToneGen.cpp:262
kSquare
@ kSquare
Definition: ToneGen.cpp:56
Effect::mProjectRate
double mProjectRate
Definition: Effect.h:458
ReadAndVerifyEnum
#define ReadAndVerifyEnum(name, list, listSize)
Definition: Effect.h:621
kInterStrings
static const EnumValueSymbol kInterStrings[nInterpolations]
Definition: ToneGen.cpp:46
EffectToneGen::mWaveform
int mWaveform
Definition: ToneGen.h:67
XXO
#define XXO(s)
Definition: Internat.h:44
EffectToneGen::mLogFrequency
double mLogFrequency[2]
Definition: ToneGen.h:71
END_EVENT_TABLE
END_EVENT_TABLE()
ShuttleGuiBase::EndHorizontalLay
void EndHorizontalLay()
Definition: ShuttleGui.cpp:1177
sampleCount::as_double
double as_double() const
Definition: SampleCount.h:45
ShuttleGuiBase::StartHorizontalLay
void StartHorizontalLay(int PositionFlags=wxALIGN_CENTRE, int iProp=1)
Definition: ShuttleGui.cpp:1167
EffectChirp::Symbol
static const ComponentInterfaceSymbol Symbol
Definition: ToneGen.h:81
kLinear
@ kLinear
Definition: ToneGen.cpp:41
ShuttleGuiBase::StartMultiColumn
void StartMultiColumn(int nCols, int PositionFlags=wxALIGN_LEFT)
Definition: ShuttleGui.cpp:1229
ShuttleGuiBase::AddFixedText
void AddFixedText(const TranslatableString &Str, bool bCenter=false, int wrapWidth=0)
Definition: ShuttleGui.cpp:440
NumericConverter::TIME
@ TIME
Definition: NumericTextCtrl.h:52
EffectToneGen::mFrequency
double mFrequency[2]
Definition: ToneGen.h:69
ShuttleGuiBase::GetParent
wxWindow * GetParent()
Definition: ShuttleGui.h:496
ShuttleGui::Validator
ShuttleGui & Validator(const Factory &f)
Definition: ShuttleGui.h:678
ShuttleGuiBase::AddWindow
wxWindow * AddWindow(wxWindow *pWindow, int PositionFlags=wxALIGN_CENTRE)
Definition: ShuttleGui.cpp:299
EffectToneGen::PopulateOrExchange
void PopulateOrExchange(ShuttleGui &S) override
Definition: ToneGen.cpp:348
nWaveforms
@ nWaveforms
Definition: ToneGen.cpp:59
Param
Param(StartFreq, double, wxT("StartFreq"), 440.0, 1.0, DBL_MAX, 1)
ChannelNames
enum ChannelName * ChannelNames
Msgids
TranslatableStrings Msgids(const EnumValueSymbol strings[], size_t nStrings)
Convenience function often useful when adding choice controls.
Definition: ShuttleGui.cpp:2510
ReadAndVerifyDouble
#define ReadAndVerifyDouble(name)
Definition: Effect.h:633
EffectToneGen::TransferDataToWindow
bool TransferDataToWindow() override
Definition: ToneGen.cpp:473
EffectToneGen::mInterpolation
int mInterpolation
Definition: ToneGen.h:68
LoadEffects.h
Effect::SetDuration
void SetDuration(double duration) override
Definition: Effect.cpp:837
EffectToneGen::GetSymbol
ComponentInterfaceSymbol GetSymbol() override
Definition: ToneGen.cpp:128
ShuttleGui::Name
ShuttleGui & Name(const TranslatableString &name)
Definition: ShuttleGui.h:663
Effect::mSampleRate
double mSampleRate
Definition: Effect.h:460
EffectToneGen
An Effect that can generate a sine, square or sawtooth wave. An extended mode of EffectToneGen suppor...
Definition: ToneGen.h:22
BuiltinEffectsModule::Registration
Definition: LoadEffects.h:40
ShuttleGui::Position
ShuttleGui & Position(int flags)
Definition: ShuttleGui.h:712
EffectToneGen::mPositionInCycles
double mPositionInCycles
Definition: ToneGen.h:63
Effect::mUIParent
wxWindow * mUIParent
Definition: Effect.h:478
TaggedIdentifier< ManualPageIDTag >
sampleCount
Positions or offsets within audio files need a wide type.
Definition: SampleCount.h:18
kWaveforms
kWaveforms
Definition: ToneGen.cpp:54
ProjectSettings::GetRate
double GetRate() const
Definition: ProjectSettings.cpp:168
ExceptionType::Internal
@ Internal
Indicates internal failure from Audacity.
EffectToneGen::GetAudioOutCount
unsigned GetAudioOutCount() override
Definition: ToneGen.cpp:158
EffectToneGen::ProcessBlock
size_t ProcessBlock(float **inBlock, float **outBlock, size_t blockLen) override
Definition: ToneGen.cpp:171
M_PI
#define M_PI
Definition: Distortion.cpp:29
EffectToneGen::TransferDataFromWindow
bool TransferDataFromWindow() override
Definition: ToneGen.cpp:485
EffectToneGen::GetAutomationParameters
bool GetAutomationParameters(CommandParameters &parms) override
Definition: ToneGen.cpp:287
kInterpolations
kInterpolations
Definition: Equalization.cpp:150
TrapDouble
double TrapDouble(double x, double min, double max)
Definition: Effect.h:564
Effect::GetDurationFormat
NumericFormatSymbol GetDurationFormat() override
Definition: Effect.cpp:825
ShuttleGuiBase::AddPrompt
void AddPrompt(const TranslatableString &Prompt, int wrapWidth=0)
Right aligned text string.
Definition: ShuttleGui.cpp:238
EffectType
EffectType
Definition: EffectInterface.h:55
safenew
#define safenew
Definition: MemoryX.h:10
EffectToneGen::mAmplitude
double mAmplitude[2]
Definition: ToneGen.h:70
kSine
@ kSine
Definition: ToneGen.cpp:55
NumericConverter::GetValue
double GetValue()
Definition: NumericTextCtrl.cpp:1172
EffectToneGen::ManualPage
ManualPageID ManualPage() override
Definition: ToneGen.cpp:142
nInterpolations
@ nInterpolations
Definition: ToneGen.cpp:43
ToneGen.h
kSawtooth
@ kSawtooth
Definition: ToneGen.cpp:57
kLogarithmic
@ kLogarithmic
Definition: ToneGen.cpp:42
WaveTrackViewConstants::Waveform
@ Waveform
Definition: WaveTrackViewConstants.h:24
ShuttleGui
Derived from ShuttleGuiBase, an Audacity specific class for shuttling data to and from GUI.
Definition: ShuttleGui.h:631
kWaveStrings
static const EnumValueSymbol kWaveStrings[nWaveforms]
Definition: ToneGen.cpp:62