2010-01-23 19:44:49 +00:00
|
|
|
/**********************************************************************
|
|
|
|
|
|
|
|
Audacity: A Digital Audio Editor
|
|
|
|
|
|
|
|
Phaser.cpp
|
|
|
|
|
|
|
|
Effect programming:
|
2013-06-21 22:23:47 +00:00
|
|
|
Nasca Octavian Paul (Paul Nasca)
|
2010-01-23 19:44:49 +00:00
|
|
|
|
|
|
|
UI programming:
|
|
|
|
Dominic Mazzoni (with the help of wxDesigner)
|
|
|
|
Vaughan Johnson (Preview)
|
|
|
|
|
|
|
|
*******************************************************************//**
|
|
|
|
|
|
|
|
\class EffectPhaser
|
2015-05-09 16:36:54 +00:00
|
|
|
\brief An Effect that changes frequencies in a time varying manner.
|
2010-01-23 19:44:49 +00:00
|
|
|
|
|
|
|
*//*******************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
#include "../Audacity.h"
|
2015-06-18 14:24:36 +00:00
|
|
|
#include "Phaser.h"
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
#include <math.h>
|
|
|
|
|
|
|
|
#include <wx/intl.h>
|
|
|
|
|
2015-06-18 14:24:36 +00:00
|
|
|
#include "../ShuttleGui.h"
|
2015-04-17 03:53:42 +00:00
|
|
|
#include "../widgets/valnum.h"
|
|
|
|
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
enum
|
|
|
|
{
|
|
|
|
ID_Stages = 10000,
|
|
|
|
ID_DryWet,
|
|
|
|
ID_Freq,
|
|
|
|
ID_Phase,
|
|
|
|
ID_Depth,
|
|
|
|
ID_Feedback
|
|
|
|
};
|
|
|
|
|
2015-04-19 03:49:05 +00:00
|
|
|
// Define keys, defaults, minimums, and maximums for the effect parameters
|
|
|
|
//
|
|
|
|
// Name Type Key Def Min Max Scale
|
|
|
|
Param( Stages, int, XO("Stages"), 2, 2, NUM_STAGES, 1 );
|
|
|
|
Param( DryWet, int, XO("DryWet"), 128, 0, 255, 1 );
|
2015-07-20 15:29:26 +00:00
|
|
|
Param( Freq, double, XO("Freq"), 0.4, 0.001,4.0, 10.0 );
|
|
|
|
Param( Phase, double, XO("Phase"), 0.0, 0.0, 360.0, 1 );
|
2015-04-19 03:49:05 +00:00
|
|
|
Param( Depth, int, XO("Depth"), 100, 0, 255, 1 );
|
|
|
|
Param( Feedback, int, XO("Feedback"), 0, -100, 100, 1 );
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
//
|
|
|
|
#define phaserlfoshape 4.0
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
// How many samples are processed before recomputing the lfo value again
|
|
|
|
#define lfoskipsamples 20
|
2010-01-23 19:44:49 +00:00
|
|
|
|
|
|
|
//
|
|
|
|
// EffectPhaser
|
|
|
|
//
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
BEGIN_EVENT_TABLE(EffectPhaser, wxEvtHandler)
|
|
|
|
EVT_SLIDER(ID_Stages, EffectPhaser::OnStagesSlider)
|
|
|
|
EVT_SLIDER(ID_DryWet, EffectPhaser::OnDryWetSlider)
|
|
|
|
EVT_SLIDER(ID_Freq, EffectPhaser::OnFreqSlider)
|
|
|
|
EVT_SLIDER(ID_Phase, EffectPhaser::OnPhaseSlider)
|
|
|
|
EVT_SLIDER(ID_Depth, EffectPhaser::OnDepthSlider)
|
|
|
|
EVT_SLIDER(ID_Feedback, EffectPhaser::OnFeedbackSlider)
|
|
|
|
EVT_TEXT(ID_Stages, EffectPhaser::OnStagesText)
|
|
|
|
EVT_TEXT(ID_DryWet, EffectPhaser::OnDryWetText)
|
|
|
|
EVT_TEXT(ID_Freq, EffectPhaser::OnFreqText)
|
|
|
|
EVT_TEXT(ID_Phase, EffectPhaser::OnPhaseText)
|
|
|
|
EVT_TEXT(ID_Depth, EffectPhaser::OnDepthText)
|
|
|
|
EVT_TEXT(ID_Feedback, EffectPhaser::OnFeedbackText)
|
|
|
|
END_EVENT_TABLE()
|
2010-01-23 19:44:49 +00:00
|
|
|
|
|
|
|
EffectPhaser::EffectPhaser()
|
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
mStages = DEF_Stages;
|
|
|
|
mDryWet = DEF_DryWet;
|
|
|
|
mFreq = DEF_Freq;
|
|
|
|
mPhase = DEF_Phase;
|
|
|
|
mDepth = DEF_Depth;
|
|
|
|
mFeedback = DEF_Feedback;
|
2015-05-15 11:47:51 +00:00
|
|
|
|
|
|
|
SetLinearEffectFlag(true);
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
EffectPhaser::~EffectPhaser()
|
|
|
|
{
|
2014-06-03 20:30:19 +00:00
|
|
|
}
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
// IdentInterface implementation
|
|
|
|
|
|
|
|
wxString EffectPhaser::GetSymbol()
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
return PHASER_PLUGIN_SYMBOL;
|
|
|
|
}
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
wxString EffectPhaser::GetDescription()
|
|
|
|
{
|
2015-04-19 03:49:05 +00:00
|
|
|
return XO("Combines phase-shifted signals with the original signal");
|
2015-04-17 03:53:42 +00:00
|
|
|
}
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
// EffectIdentInterface implementation
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
EffectType EffectPhaser::GetType()
|
|
|
|
{
|
|
|
|
return EffectTypeProcess;
|
|
|
|
}
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
// EffectClientInterface implementation
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
int EffectPhaser::GetAudioInCount()
|
|
|
|
{
|
|
|
|
return 1;
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
int EffectPhaser::GetAudioOutCount()
|
2014-06-03 20:30:19 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
return 1;
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
bool EffectPhaser::ProcessInitialize(sampleCount WXUNUSED(totalLen), ChannelNames chanMap)
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
for (int j = 0; j < mStages; j++)
|
|
|
|
{
|
2014-06-03 20:30:19 +00:00
|
|
|
old[j] = 0;
|
2015-04-17 03:53:42 +00:00
|
|
|
}
|
2010-01-23 19:44:49 +00:00
|
|
|
|
|
|
|
skipcount = 0;
|
|
|
|
gain = 0;
|
|
|
|
fbout = 0;
|
2015-04-17 03:53:42 +00:00
|
|
|
lfoskip = mFreq * 2 * M_PI / mSampleRate;
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
phase = mPhase * M_PI / 180;
|
|
|
|
if (chanMap[0] == ChannelNameFrontRight)
|
|
|
|
{
|
|
|
|
phase += M_PI;
|
|
|
|
}
|
2010-01-23 19:44:49 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
sampleCount EffectPhaser::ProcessBlock(float **inBlock, float **outBlock, sampleCount blockLen)
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
float *ibuf = inBlock[0];
|
|
|
|
float *obuf = outBlock[0];
|
2014-06-03 20:30:19 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
for (sampleCount i = 0; i < blockLen; i++)
|
|
|
|
{
|
|
|
|
double in = ibuf[i];
|
2014-06-03 20:30:19 +00:00
|
|
|
|
2015-07-20 15:29:26 +00:00
|
|
|
double m = in + fbout * mFeedback / 101; // Feedback must be less than 100% to avoid infinite gain.
|
2015-04-17 03:53:42 +00:00
|
|
|
|
|
|
|
if (((skipcount++) % lfoskipsamples) == 0)
|
|
|
|
{
|
2010-01-23 19:44:49 +00:00
|
|
|
//compute sine between 0 and 1
|
2015-04-17 03:53:42 +00:00
|
|
|
gain = (1.0 + cos(skipcount * lfoskip + phase)) / 2.0;
|
2014-06-03 20:30:19 +00:00
|
|
|
|
2010-01-23 19:44:49 +00:00
|
|
|
// change lfo shape
|
2015-04-23 16:30:38 +00:00
|
|
|
gain = expm1(gain * phaserlfoshape) / expm1(phaserlfoshape);
|
2014-06-03 20:30:19 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
// attenuate the lfo
|
|
|
|
gain = 1.0 - gain / 255.0 * mDepth;
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
2015-04-17 03:53:42 +00:00
|
|
|
|
2010-01-23 19:44:49 +00:00
|
|
|
// phasing routine
|
2015-04-17 03:53:42 +00:00
|
|
|
for (int j = 0; j < mStages; j++)
|
|
|
|
{
|
|
|
|
double tmp = old[j];
|
2010-01-23 19:44:49 +00:00
|
|
|
old[j] = gain * tmp + m;
|
|
|
|
m = tmp - gain * old[j];
|
|
|
|
}
|
|
|
|
fbout = m;
|
2014-06-03 20:30:19 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
obuf[i] = (float) ((m * mDryWet + in * (255 - mDryWet)) / 255);
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
2014-06-03 20:30:19 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
return blockLen;
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
bool EffectPhaser::GetAutomationParameters(EffectAutomationParameters & parms)
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
parms.Write(KEY_Stages, mStages);
|
|
|
|
parms.Write(KEY_DryWet, mDryWet);
|
|
|
|
parms.Write(KEY_Freq, mFreq);
|
|
|
|
parms.Write(KEY_Phase, mPhase);
|
|
|
|
parms.Write(KEY_Depth, mDepth);
|
|
|
|
parms.Write(KEY_Feedback, mFeedback);
|
|
|
|
|
|
|
|
return true;
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
bool EffectPhaser::SetAutomationParameters(EffectAutomationParameters & parms)
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
ReadAndVerifyInt(Stages);
|
|
|
|
ReadAndVerifyInt(DryWet);
|
|
|
|
ReadAndVerifyDouble(Freq);
|
|
|
|
ReadAndVerifyDouble(Phase);
|
|
|
|
ReadAndVerifyInt(Depth);
|
|
|
|
ReadAndVerifyInt(Feedback);
|
|
|
|
|
|
|
|
if (Stages & 1) // must be even, but don't complain about it
|
|
|
|
{
|
|
|
|
Stages &= ~1;
|
|
|
|
}
|
|
|
|
|
|
|
|
mFreq = Freq;
|
|
|
|
mFeedback = Feedback;
|
|
|
|
mStages = Stages;
|
|
|
|
mDryWet = DryWet;
|
|
|
|
mDepth = Depth;
|
|
|
|
mPhase = Phase;
|
2013-06-21 22:10:50 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Effect implementation
|
|
|
|
|
|
|
|
void EffectPhaser::PopulateOrExchange(ShuttleGui & S)
|
|
|
|
{
|
2010-01-23 19:44:49 +00:00
|
|
|
S.SetBorder(5);
|
2015-07-20 15:29:26 +00:00
|
|
|
S.AddSpace(0, 5);
|
2010-01-23 19:44:49 +00:00
|
|
|
|
|
|
|
S.StartMultiColumn(3, wxEXPAND);
|
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
S.SetStretchyCol(2);
|
|
|
|
|
|
|
|
IntegerValidator<int> vldStages(&mStages);
|
|
|
|
vldStages.SetRange(MIN_Stages, MAX_Stages);
|
2015-07-20 15:29:26 +00:00
|
|
|
mStagesT = S.Id(ID_Stages).AddTextBox(_("Stages:"), wxT(""), 15);
|
2015-04-17 03:53:42 +00:00
|
|
|
mStagesT->SetValidator(vldStages);
|
|
|
|
|
2010-01-23 19:44:49 +00:00
|
|
|
S.SetStyle(wxSL_HORIZONTAL);
|
2015-04-17 03:53:42 +00:00
|
|
|
mStagesS = S.Id(ID_Stages).AddSlider(wxT(""), DEF_Stages * SCL_Stages, MAX_Stages * SCL_Stages, MIN_Stages * SCL_Stages);
|
|
|
|
mStagesS->SetName(_("Stages"));
|
|
|
|
mStagesS->SetLineSize(2);
|
|
|
|
mStagesS->SetMinSize(wxSize(100, -1));
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
IntegerValidator<int> vldDryWet(&mDryWet);
|
|
|
|
vldDryWet.SetRange(MIN_DryWet, MAX_DryWet);
|
2015-07-20 15:29:26 +00:00
|
|
|
mDryWetT = S.Id(ID_DryWet).AddTextBox(_("Dry/Wet:"), wxT(""), 15);
|
2015-04-17 03:53:42 +00:00
|
|
|
mDryWetT->SetValidator(vldDryWet);
|
|
|
|
|
2010-01-23 19:44:49 +00:00
|
|
|
S.SetStyle(wxSL_HORIZONTAL);
|
2015-04-17 03:53:42 +00:00
|
|
|
mDryWetS = S.Id(ID_DryWet).AddSlider(wxT(""), DEF_DryWet * SCL_DryWet, MAX_DryWet * SCL_DryWet, MIN_DryWet * SCL_DryWet);
|
|
|
|
mDryWetS->SetName(_("Dry Wet"));
|
|
|
|
mDryWetS->SetMinSize(wxSize(100, -1));
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-07-20 15:29:26 +00:00
|
|
|
FloatingPointValidator<double> vldFreq(5, &mFreq, NUM_VAL_ONE_TRAILING_ZERO);
|
2015-04-17 03:53:42 +00:00
|
|
|
vldFreq.SetRange(MIN_Freq, MAX_Freq);
|
2015-07-20 15:29:26 +00:00
|
|
|
mFreqT = S.Id(ID_Freq).AddTextBox(_("LFO Frequency (Hz):"), wxT(""), 15);
|
2015-04-17 03:53:42 +00:00
|
|
|
mFreqT->SetValidator(vldFreq);
|
|
|
|
|
2010-01-23 19:44:49 +00:00
|
|
|
S.SetStyle(wxSL_HORIZONTAL);
|
2015-07-20 15:29:26 +00:00
|
|
|
mFreqS = S.Id(ID_Freq).AddSlider(wxT(""), DEF_Freq * SCL_Freq, MAX_Freq * SCL_Freq, 0.0);
|
2015-04-17 03:53:42 +00:00
|
|
|
mFreqS ->SetName(_("LFO frequency in hertz"));
|
|
|
|
mFreqS ->SetMinSize(wxSize(100, -1));
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
FloatingPointValidator<double> vldPhase(1, &mPhase);
|
|
|
|
vldPhase.SetRange(MIN_Phase, MAX_Phase);
|
2015-07-20 15:29:26 +00:00
|
|
|
mPhaseT = S.Id(ID_Phase).AddTextBox(_("LFO Start Phase (deg.):"), wxT(""), 15);
|
2015-04-17 03:53:42 +00:00
|
|
|
mPhaseT->SetValidator(vldPhase);
|
|
|
|
|
2010-01-23 19:44:49 +00:00
|
|
|
S.SetStyle(wxSL_HORIZONTAL);
|
2015-04-17 03:53:42 +00:00
|
|
|
mPhaseS = S.Id(ID_Phase).AddSlider(wxT(""), DEF_Phase * SCL_Phase, MAX_Phase * SCL_Phase, MIN_Phase * SCL_Phase);
|
|
|
|
mPhaseS->SetName(_("LFO start phase in degrees"));
|
|
|
|
mPhaseS->SetLineSize(10);
|
|
|
|
mPhaseS->SetMinSize(wxSize(100, -1));
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
IntegerValidator<int> vldDepth(&mDepth);
|
|
|
|
vldDepth.SetRange(MIN_Depth, MAX_Depth);
|
2015-07-20 15:29:26 +00:00
|
|
|
mDepthT = S.Id(ID_Depth).AddTextBox(_("Depth:"), wxT(""), 15);
|
2015-04-17 03:53:42 +00:00
|
|
|
mDepthT->SetValidator(vldDepth);
|
|
|
|
|
2010-01-23 19:44:49 +00:00
|
|
|
S.SetStyle(wxSL_HORIZONTAL);
|
2015-04-17 03:53:42 +00:00
|
|
|
mDepthS = S.Id(ID_Depth).AddSlider(wxT(""), DEF_Depth * SCL_Depth, MAX_Depth * SCL_Depth, MIN_Depth * SCL_Depth);
|
|
|
|
mDepthS->SetName(_("Depth in percent"));
|
|
|
|
mDepthS->SetMinSize(wxSize(100, -1));
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
IntegerValidator<int> vldFeedback(&mFeedback);
|
|
|
|
vldFeedback.SetRange(MIN_Feedback, MAX_Feedback);
|
2015-07-20 15:29:26 +00:00
|
|
|
mFeedbackT = S.Id(ID_Feedback).AddTextBox(_("Feedback (%):"), wxT(""), 15);
|
2015-04-17 03:53:42 +00:00
|
|
|
mFeedbackT->SetValidator(vldFeedback);
|
|
|
|
|
2010-01-23 19:44:49 +00:00
|
|
|
S.SetStyle(wxSL_HORIZONTAL);
|
2015-04-17 03:53:42 +00:00
|
|
|
mFeedbackS = S.Id(ID_Feedback).AddSlider(wxT(""), DEF_Feedback * SCL_Feedback, MAX_Feedback * SCL_Feedback, MIN_Feedback * SCL_Feedback);
|
|
|
|
mFeedbackS->SetName(_("Feedback in percent"));
|
|
|
|
mFeedbackS->SetLineSize(10);
|
|
|
|
mFeedbackS->SetMinSize(wxSize(100, -1));
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
S.EndMultiColumn();
|
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
bool EffectPhaser::TransferDataToWindow()
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
if (!mUIParent->TransferDataToWindow())
|
|
|
|
{
|
|
|
|
return false;
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-23 07:03:31 +00:00
|
|
|
mStagesS->SetValue((int) (mStages * SCL_Stages));
|
|
|
|
mDryWetS->SetValue((int) (mDryWet * SCL_DryWet));
|
|
|
|
mFreqS->SetValue((int) (mFreq * SCL_Freq));
|
|
|
|
mPhaseS->SetValue((int) (mPhase * SCL_Phase));
|
|
|
|
mDepthS->SetValue((int) (mDepth * SCL_Depth));
|
|
|
|
mFeedbackS->SetValue((int) (mFeedback * SCL_Feedback));
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
return true;
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
bool EffectPhaser::TransferDataFromWindow()
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
if (!mUIParent->Validate() || !mUIParent->TransferDataFromWindow())
|
|
|
|
{
|
|
|
|
return false;
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
if (mStages & 1) // must be even
|
|
|
|
{
|
|
|
|
mStages &= ~1;
|
2015-04-23 07:03:31 +00:00
|
|
|
mStagesT->GetValidator()->TransferToWindow();
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
return true;
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
// EffectPhaser implementation
|
2010-01-23 19:44:49 +00:00
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
void EffectPhaser::OnStagesSlider(wxCommandEvent & evt)
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-23 07:03:31 +00:00
|
|
|
mStages = (evt.GetInt() / SCL_Stages) & ~1; // must be even;
|
2015-04-17 03:53:42 +00:00
|
|
|
mStagesT->GetValidator()->TransferToWindow();
|
|
|
|
EnableApply(mUIParent->Validate());
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
void EffectPhaser::OnDryWetSlider(wxCommandEvent & evt)
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
mDryWet = evt.GetInt() / SCL_DryWet;
|
|
|
|
mDryWetT->GetValidator()->TransferToWindow();
|
|
|
|
EnableApply(mUIParent->Validate());
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
void EffectPhaser::OnFreqSlider(wxCommandEvent & evt)
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
mFreq = (double) evt.GetInt() / SCL_Freq;
|
2015-07-20 15:29:26 +00:00
|
|
|
if (mFreq < MIN_Freq) mFreq = MIN_Freq;
|
2015-04-17 03:53:42 +00:00
|
|
|
mFreqT->GetValidator()->TransferToWindow();
|
|
|
|
EnableApply(mUIParent->Validate());
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
void EffectPhaser::OnPhaseSlider(wxCommandEvent & evt)
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
int val = ((evt.GetInt() + 5) / 10) * 10; // round to nearest multiple of 10
|
|
|
|
val = val > MAX_Phase * SCL_Phase ? MAX_Phase * SCL_Phase : val;
|
|
|
|
mPhaseS->SetValue(val);
|
|
|
|
mPhase = (double) val / SCL_Phase;
|
|
|
|
mPhaseT->GetValidator()->TransferToWindow();
|
|
|
|
EnableApply(mUIParent->Validate());
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
void EffectPhaser::OnDepthSlider(wxCommandEvent & evt)
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
mDepth = evt.GetInt() / SCL_Depth;
|
|
|
|
mDepthT->GetValidator()->TransferToWindow();
|
|
|
|
EnableApply(mUIParent->Validate());
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
void EffectPhaser::OnFeedbackSlider(wxCommandEvent & evt)
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
int val = evt.GetInt();
|
|
|
|
val = ((val + (val > 0 ? 5 : -5)) / 10) * 10; // round to nearest multiple of 10
|
|
|
|
val = val > MAX_Feedback * SCL_Feedback ? MAX_Feedback * SCL_Feedback : val;
|
|
|
|
mFeedbackS->SetValue(val);
|
|
|
|
mFeedback = val / SCL_Feedback;
|
|
|
|
mFeedbackT->GetValidator()->TransferToWindow();
|
|
|
|
EnableApply(mUIParent->Validate());
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
void EffectPhaser::OnStagesText(wxCommandEvent & WXUNUSED(evt))
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
if (!EnableApply(mUIParent->TransferDataFromWindow()))
|
|
|
|
{
|
|
|
|
return;
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
2015-04-17 03:53:42 +00:00
|
|
|
|
|
|
|
mStagesS->SetValue((int) (mStages * SCL_Stages));
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
void EffectPhaser::OnDryWetText(wxCommandEvent & WXUNUSED(evt))
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
if (!EnableApply(mUIParent->TransferDataFromWindow()))
|
|
|
|
{
|
|
|
|
return;
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
2015-04-17 03:53:42 +00:00
|
|
|
|
|
|
|
mDryWetS->SetValue((int) (mDryWet * SCL_DryWet));
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
void EffectPhaser::OnFreqText(wxCommandEvent & WXUNUSED(evt))
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
if (!EnableApply(mUIParent->TransferDataFromWindow()))
|
|
|
|
{
|
|
|
|
return;
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
2015-04-17 03:53:42 +00:00
|
|
|
|
|
|
|
mFreqS->SetValue((int) (mFreq * SCL_Freq));
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
void EffectPhaser::OnPhaseText(wxCommandEvent & WXUNUSED(evt))
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
if (!EnableApply(mUIParent->TransferDataFromWindow()))
|
|
|
|
{
|
|
|
|
return;
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
2015-04-17 03:53:42 +00:00
|
|
|
|
|
|
|
mPhaseS->SetValue((int) (mPhase * SCL_Phase));
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
void EffectPhaser::OnDepthText(wxCommandEvent & WXUNUSED(evt))
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
if (!EnableApply(mUIParent->TransferDataFromWindow()))
|
|
|
|
{
|
|
|
|
return;
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
2015-04-17 03:53:42 +00:00
|
|
|
|
|
|
|
mDepthS->SetValue((int) (mDepth * SCL_Depth));
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
void EffectPhaser::OnFeedbackText(wxCommandEvent & WXUNUSED(evt))
|
2010-01-23 19:44:49 +00:00
|
|
|
{
|
2015-04-17 03:53:42 +00:00
|
|
|
if (!EnableApply(mUIParent->TransferDataFromWindow()))
|
|
|
|
{
|
|
|
|
return;
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-17 03:53:42 +00:00
|
|
|
mFeedbackS->SetValue((int) (mFeedback * SCL_Feedback));
|
2010-01-23 19:44:49 +00:00
|
|
|
}
|