void NormalizeDialog::PopulateOrExchange(ShuttleGui & S)
{
wxTextValidator vld(wxFILTER_NUMERIC);
S.StartHorizontalLay(wxCENTER, false);
{
S.AddTitle(_("by Dominic Mazzoni"));
}
S.EndHorizontalLay();
S.StartHorizontalLay(wxCENTER, false);
{
// Add a little space
}
S.EndHorizontalLay();
S.StartTwoColumn();
{
S.StartVerticalLay(false);
{
mDCCheckBox = S.Id(ID_DC_REMOVE).AddCheckBox(_("Remove any DC offset (center on 0.0 vertically)"),
mDC ? wxT("true") : wxT("false"));
mGainCheckBox = S.Id(ID_NORMALIZE_AMPLITUDE).AddCheckBox(_("Normalize maximum amplitude to:"),
mGain ? wxT("true") : wxT("false"));
S.StartHorizontalLay(wxALIGN_CENTER, false);
{
mLevelTextCtrl = S.Id(ID_LEVEL_TEXT).AddTextBox(wxT(""), wxT(""), 10);
mLevelTextCtrl->SetValidator(vld);
mLevelTextCtrl->SetName(_("Maximum amplitude dB"));
mLeveldB = S.AddVariableText(_("dB"), false,
wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
mWarning = S.AddVariableText( wxT(""), false,
wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
}
S.EndHorizontalLay();
mStereoIndCheckBox = S.AddCheckBox(_("Normalize stereo channels independently"),
mStereoInd ? wxT("true") : wxT("false"));
}
S.EndVerticalLay();
}
S.EndTwoColumn();
}
void EffectTruncSilence::PopulateOrExchange(ShuttleGui & S)
{
wxASSERT(kNumActions == WXSIZEOF(kActionStrings));
wxArrayString actionChoices;
for (int i = 0; i < kNumActions; i++)
{
actionChoices.Add(wxGetTranslation(kActionStrings[i]));
}
S.AddSpace(0, 5);
S.StartStatic(_("Detect Silence"));
{
S.StartMultiColumn(3, wxALIGN_CENTER_HORIZONTAL);
{
// Threshold
mTruncDbChoice = S.AddChoice(_("Level:"), wxT(""), &mDbChoices);
mTruncDbChoice->SetValidator(wxGenericValidator(&mTruncDbChoiceIndex));
S.SetSizeHints(-1, -1);
S.AddSpace(0); // 'choices' already includes units.
// Ignored silence
FloatingPointValidator<double> vldDur(3, &mInitialAllowedSilence, NUM_VAL_NO_TRAILING_ZEROES);
vldDur.SetRange(MIN_Minimum, MAX_Minimum);
mInitialAllowedSilenceT = S.AddTextBox(_("Duration:"), wxT(""), 12);
mInitialAllowedSilenceT->SetValidator(vldDur);
S.AddUnits(wxT("seconds"));
}
S.EndMultiColumn();
}
S.EndStatic();
S.StartStatic(_("Action"));
{
S.StartHorizontalLay();
{
// Action choices
mActionChoice = S.AddChoice(wxT(""), wxT(""), &actionChoices);
mActionChoice->SetValidator(wxGenericValidator(&mActionIndex));
S.SetSizeHints(-1, -1);
}
S.EndHorizontalLay();
S.StartMultiColumn(3, wxALIGN_CENTER_HORIZONTAL);
{
// Truncation / Compression factor
FloatingPointValidator<double> vldTrunc(3, &mTruncLongestAllowedSilence, NUM_VAL_NO_TRAILING_ZEROES);
vldTrunc.SetRange(MIN_Truncate, MAX_Truncate);
mTruncLongestAllowedSilenceT = S.AddTextBox(_("Truncate to:"), wxT(""), 12);
mTruncLongestAllowedSilenceT->SetValidator(vldTrunc);
S.AddUnits(wxT("seconds"));
FloatingPointValidator<double> vldComp(3, &mSilenceCompressPercent, NUM_VAL_NO_TRAILING_ZEROES);
vldComp.SetRange(MIN_Compress, MAX_Compress);
mSilenceCompressPercentT = S.AddTextBox(_("Compress to:"), wxT(""), 12);
mSilenceCompressPercentT->SetValidator(vldComp);
S.AddUnits(wxT("percent"));
}
S.EndMultiColumn();
S.StartMultiColumn(2, wxALIGN_CENTER_HORIZONTAL);
{
mIndependent = S.AddCheckBox(_("Truncate tracks independently"),
mbIndependent ? wxT("true") : wxT("false"));
}
S.EndMultiColumn();
}
S.EndStatic();
UpdateUI();
}
void EffectCompressor::PopulateOrExchange(ShuttleGui & S)
{
S.SetBorder(5);
S.StartHorizontalLay(wxEXPAND, true);
{
S.SetBorder(10);
mPanel = safenew EffectCompressorPanel(S.GetParent(),
mThresholdDB,
mNoiseFloorDB,
mRatio);
mPanel->SetMinSize(wxSize(400, 200));
S.Prop(true).AddWindow(mPanel, wxEXPAND | wxALL);
S.SetBorder(5);
}
S.EndHorizontalLay();
S.StartStatic(wxT(""));
{
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol(1);
mThresholdLabel = S.AddVariableText(_("Threshold:"), true,
wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
S.SetStyle(wxSL_HORIZONTAL);
mThresholdSlider = S.Id(ID_Threshold).AddSlider(wxT(""),
DEF_Threshold * SCL_Threshold,
MAX_Threshold * SCL_Threshold,
MIN_Threshold * SCL_Threshold);
mThresholdSlider->SetName(_("Threshold"));
mThresholdText = S.AddVariableText(wxT("XXX dB"), true,
wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
mNoiseFloorLabel = S.AddVariableText(_("Noise Floor:"), true,
wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
S.SetStyle(wxSL_HORIZONTAL);
mNoiseFloorSlider = S.Id(ID_NoiseFloor).AddSlider(wxT(""),
DEF_NoiseFloor / SCL_NoiseFloor,
MAX_NoiseFloor / SCL_NoiseFloor,
MIN_NoiseFloor / SCL_NoiseFloor);
mNoiseFloorSlider->SetName(_("Noise Floor"));
mNoiseFloorText = S.AddVariableText(wxT("XXX dB"), true,
wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
mRatioLabel = S.AddVariableText(_("Ratio:"), true,
wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
S.SetStyle(wxSL_HORIZONTAL);
mRatioSlider = S.Id(ID_Ratio).AddSlider(wxT(""),
DEF_Ratio * SCL_Ratio,
MAX_Ratio * SCL_Ratio,
MIN_Ratio * SCL_Ratio);
mRatioSlider->SetName(_("Ratio"));
mRatioSlider->SetPageSize(5);
mRatioText = S.AddVariableText(wxT("XXXX:1"), true,
wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
/* i18n-hint: Particularly in percussion, sounds can be regarded as having
* an 'attack' phase where the sound builds up and a 'decay' where the
* sound dies away. So this means 'onset duration'. */
mAttackLabel = S.AddVariableText(_("Attack Time:"), true,
wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
S.SetStyle(wxSL_HORIZONTAL);
mAttackSlider = S.Id(ID_Attack).AddSlider(wxT(""),
DEF_AttackTime * SCL_AttackTime,
MAX_AttackTime * SCL_AttackTime,
MIN_AttackTime * SCL_AttackTime);
mAttackSlider->SetName(_("Attack Time"));
mAttackText = S.AddVariableText(wxT("XXXX secs"), true,
wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
mDecayLabel = S.AddVariableText(_("Release Time:"), true,
wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
S.SetStyle(wxSL_HORIZONTAL);
mDecaySlider = S.Id(ID_Decay).AddSlider(wxT(""),
DEF_ReleaseTime * SCL_ReleaseTime,
MAX_ReleaseTime * SCL_ReleaseTime,
MIN_ReleaseTime * SCL_ReleaseTime);
mDecaySlider->SetName(_("Release Time"));
mDecayText = S.AddVariableText(wxT("XXXX secs"), true,
wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
}
S.EndMultiColumn();
}
S.EndStatic();
S.StartHorizontalLay(wxCENTER, false);
{
/* i18n-hint: Make-up, i.e. correct for any reduction, rather than fabricate it.*/
mGainCheckBox = S.AddCheckBox(_("Make-up gain for 0 dB after compressing"),
DEF_Normalize ? wxT("true") : wxT("false"));
mPeakCheckBox = S.AddCheckBox(_("Compress based on Peaks"),
DEF_UsePeak ? wxT("true") : wxT("false"));
}
S.EndHorizontalLay();
}
void VampEffect::PopulateOrExchange(ShuttleGui & S)
{
Vamp::Plugin::ProgramList programs = mPlugin->getPrograms();
mParameters = mPlugin->getParameterDescriptors();
auto count = mParameters.size();
mToggles.reinit( count );
mSliders.reinit( count );
mFields.reinit( count );
mLabels.reinit( count );
mChoices.reinit( count );
mValues.reinit( count );
S.SetStyle(wxVSCROLL | wxTAB_TRAVERSAL);
wxScrolledWindow *scroller = S.StartScroller(2);
{
S.StartStatic(_("Plugin Settings"));
{
S.StartMultiColumn(5, wxEXPAND);
{
S.SetStretchyCol(3);
if (!programs.empty())
{
wxString currentProgram = wxString::FromUTF8(mPlugin->getCurrentProgram().c_str());
wxArrayStringEx choices;
for (size_t i = 0, cnt = programs.size(); i < cnt; i++)
{
choices.push_back(wxString::FromUTF8(programs[i].c_str()));
}
S.AddPrompt(_("Program"));
S.Id(ID_Program);
mProgram = S.AddChoice(
{},
choices,
choices.Index( currentProgram )
);
mProgram->SetName(_("Program"));
mProgram->SetSizeHints(-1, -1);
wxSizer *s = mProgram->GetContainingSizer();
s->GetItem(mProgram)->SetFlag(wxEXPAND | wxALIGN_CENTER_VERTICAL | wxALL);
S.AddSpace(1, 1);
S.AddSpace(1, 1);
S.AddSpace(1, 1);
}
for (size_t p = 0; p < count; p++)
{
wxString tip = wxString::FromUTF8(mParameters[p].description.c_str());
wxString unit = wxString::FromUTF8(mParameters[p].unit.c_str());
float value = mPlugin->getParameter(mParameters[p].identifier);
mToggles[p] = NULL;
mChoices[p] = NULL;
mSliders[p] = NULL;
mFields[p] = NULL;
mValues[p] = 0.0;
wxString labelText = wxString::FromUTF8(mParameters[p].name.c_str());
if (!unit.empty())
{
labelText += wxT(" (") + unit + wxT(")");
}
S.AddPrompt(labelText + wxT(":"));
if (mParameters[p].isQuantized &&
mParameters[p].quantizeStep == 1.0 &&
mParameters[p].minValue == 0.0 &&
mParameters[p].maxValue == 1.0)
{
S.Id(ID_Toggles + p);
mToggles[p] = S.AddCheckBox( {},
value > 0.5);
mToggles[p]->SetName(labelText);
if (!tip.empty())
{
mToggles[p]->SetToolTip(tip);
}
wxSizer *s = mToggles[p]->GetContainingSizer();
s->GetItem(mToggles[p])->SetFlag(wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL);
S.AddSpace(1, 1);
S.AddSpace(1, 1);
S.AddSpace(1, 1);
}
else if (mParameters[p].isQuantized &&
mParameters[p].quantizeStep == 1.0 &&
!mParameters[p].valueNames.empty())
{
wxArrayStringEx choices;
int selected = -1;
for (size_t i = 0, cnt = mParameters[p].valueNames.size(); i < cnt; i++)
{
wxString choice = wxString::FromUTF8(mParameters[p].valueNames[i].c_str());
if (size_t(value - mParameters[p].minValue + 0.5) == i)
{
selected = i;
}
choices.push_back(choice);
}
S.Id(ID_Choices + p);
mChoices[p] = S.AddChoice( {}, choices, selected );
mChoices[p]->SetName(labelText);
mChoices[p]->SetSizeHints(-1, -1);
if (!tip.empty())
{
mChoices[p]->SetToolTip(tip);
}
wxSizer *s = mChoices[p]->GetContainingSizer();
s->GetItem(mChoices[p])->SetFlag(wxEXPAND | wxALIGN_CENTER_VERTICAL | wxALL);
S.AddSpace(1, 1);
S.AddSpace(1, 1);
S.AddSpace(1, 1);
}
else
{
mValues[p] = value;
FloatingPointValidator<float> vld(6, &mValues[p]);
vld.SetRange(mParameters[p].minValue, mParameters[p].maxValue);
float range = mParameters[p].maxValue - mParameters[p].minValue;
auto style = range < 10 ? NumValidatorStyle::THREE_TRAILING_ZEROES :
range < 100 ? NumValidatorStyle::TWO_TRAILING_ZEROES :
NumValidatorStyle::ONE_TRAILING_ZERO;
vld.SetStyle(style);
S.Id(ID_Texts + p);
mFields[p] = S.AddTextBox( {}, wxT(""), 12);
mFields[p]->SetName(labelText);
mFields[p]->SetValidator(vld);
if (!tip.empty())
{
mFields[p]->SetToolTip(tip);
}
wxSizer *s = mFields[p]->GetContainingSizer();
s->GetItem(mFields[p])->SetFlag(wxALIGN_CENTER_VERTICAL | wxALL);
wxString str = Internat::ToDisplayString(mParameters[p].minValue);
S.AddPrompt(str);
S.SetStyle(wxSL_HORIZONTAL);
S.Id(ID_Sliders + p);
mSliders[p] = S.AddSlider( {}, 0, 1000, 0);
mSliders[p]->SetName(labelText);
mSliders[p]->SetSizeHints(150, -1);
if (!tip.empty())
{
mSliders[p]->SetToolTip(tip);
}
str = Internat::ToDisplayString(mParameters[p].maxValue);
S.AddUnits(str);
}
}
}
S.EndMultiColumn();
}
S.EndStatic();
}
S.EndScroller();
scroller->SetScrollRate(0, 20);
return;
}
void EffectChangePitch::PopulateOrExchange(ShuttleGui & S)
{
DeduceFrequencies(); // Set frequency-related control values based on sample.
wxArrayString pitch;
for (int ii = 0; ii < 12; ++ii)
pitch.Add( PitchName( ii, PitchNameChoice::Both ) );
S.SetBorder(5);
S.StartVerticalLay(0);
{
S.StartVerticalLay();
{
S.AddTitle(_("Change Pitch without Changing Tempo"));
S.AddTitle(
wxString::Format(_("Estimated Start Pitch: %s%d (%.3f Hz)"),
pitch[m_nFromPitch], m_nFromOctave, m_FromFrequency));
}
S.EndVerticalLay();
/* i18n-hint: (noun) Musical pitch.*/
S.StartStatic(_("Pitch"));
{
S.StartMultiColumn(6, wxALIGN_CENTER); // 6 controls, because each AddChoice adds a wxStaticText and a wxChoice.
{
m_pChoice_FromPitch = S.Id(ID_FromPitch).AddChoice(_("from"), wxT(""), &pitch);
m_pChoice_FromPitch->SetName(_("from"));
m_pChoice_FromPitch->SetSizeHints(80, -1);
m_pSpin_FromOctave = S.Id(ID_FromOctave).AddSpinCtrl( {}, m_nFromOctave, INT_MAX, INT_MIN);
m_pSpin_FromOctave->SetName(_("from Octave"));
m_pSpin_FromOctave->SetSizeHints(50, -1);
m_pChoice_ToPitch = S.Id(ID_ToPitch).AddChoice(_("to"), wxT(""), &pitch);
m_pChoice_ToPitch->SetName(_("to"));
m_pChoice_ToPitch->SetSizeHints(80, -1);
m_pSpin_ToOctave =
S.Id(ID_ToOctave).AddSpinCtrl( {}, m_nToOctave, INT_MAX, INT_MIN);
m_pSpin_ToOctave->SetName(_("to Octave"));
m_pSpin_ToOctave->SetSizeHints(50, -1);
}
S.EndMultiColumn();
S.StartHorizontalLay(wxALIGN_CENTER);
{
FloatingPointValidator<double> vldSemitones(2, &m_dSemitonesChange, NumValidatorStyle::TWO_TRAILING_ZEROES);
m_pTextCtrl_SemitonesChange =
S.Id(ID_SemitonesChange).AddTextBox(_("Semitones (half-steps):"), wxT(""), 12);
m_pTextCtrl_SemitonesChange->SetName(_("Semitones (half-steps)"));
m_pTextCtrl_SemitonesChange->SetValidator(vldSemitones);
}
S.EndHorizontalLay();
}
S.EndStatic();
S.StartStatic(_("Frequency"));
{
S.StartMultiColumn(5, wxALIGN_CENTER); // 5, because AddTextBox adds a wxStaticText and a wxTextCtrl.
{
FloatingPointValidator<double> vldFromFrequency(3, &m_FromFrequency, NumValidatorStyle::THREE_TRAILING_ZEROES);
vldFromFrequency.SetMin(0.0);
m_pTextCtrl_FromFrequency = S.Id(ID_FromFrequency).AddTextBox(_("from"), wxT(""), 12);
m_pTextCtrl_FromFrequency->SetName(_("from (Hz)"));
m_pTextCtrl_FromFrequency->SetValidator(vldFromFrequency);
FloatingPointValidator<double> vldToFrequency(3, &m_ToFrequency, NumValidatorStyle::THREE_TRAILING_ZEROES);
vldToFrequency.SetMin(0.0);
m_pTextCtrl_ToFrequency = S.Id(ID_ToFrequency).AddTextBox(_("to"), wxT(""), 12);
m_pTextCtrl_ToFrequency->SetName(_("to (Hz)"));
m_pTextCtrl_ToFrequency->SetValidator(vldToFrequency);
S.AddUnits(_("Hz"));
}
S.EndMultiColumn();
S.StartHorizontalLay(wxALIGN_CENTER);
{
FloatingPointValidator<double> vldPercentage(3, &m_dPercentChange, NumValidatorStyle::THREE_TRAILING_ZEROES);
vldPercentage.SetRange(MIN_Percentage, MAX_Percentage);
m_pTextCtrl_PercentChange = S.Id(ID_PercentChange).AddTextBox(_("Percent Change:"), wxT(""), 12);
m_pTextCtrl_PercentChange->SetValidator(vldPercentage);
}
S.EndHorizontalLay();
S.StartHorizontalLay(wxEXPAND);
{
S.SetStyle(wxSL_HORIZONTAL);
m_pSlider_PercentChange = S.Id(ID_PercentChange)
.AddSlider( {}, 0, (int)kSliderMax, (int)MIN_Percentage);
m_pSlider_PercentChange->SetName(_("Percent Change"));
}
S.EndHorizontalLay();
}
S.EndStatic();
#if USE_SBSMS
S.StartMultiColumn(2);
{
mUseSBSMSCheckBox = S.AddCheckBox(_("Use high quality stretching (slow)"),
mUseSBSMS? wxT("true") : wxT("false"));
mUseSBSMSCheckBox->SetValidator(wxGenericValidator(&mUseSBSMS));
}
S.EndMultiColumn();
#endif
}
S.EndVerticalLay();
return;
}
void EffectTruncSilence::PopulateOrExchange(ShuttleGui & S)
{
wxASSERT(nActions == WXSIZEOF(kActionStrings));
S.AddSpace(0, 5);
S.StartStatic(_("Detect Silence"));
{
S.StartMultiColumn(3, wxALIGN_CENTER_HORIZONTAL);
{
// Threshold
FloatingPointValidator<double> vldThreshold(3, &mThresholdDB,
NumValidatorStyle::NO_TRAILING_ZEROES);
vldThreshold.SetRange(MIN_Threshold, MAX_Threshold);
mThresholdText = S.AddTextBox(_("Threshold:"), wxT(""), 0);
mThresholdText->SetValidator(vldThreshold);
S.AddUnits(_("dB"));
// Ignored silence
FloatingPointValidator<double> vldDur(3, &mInitialAllowedSilence, NumValidatorStyle::NO_TRAILING_ZEROES);
vldDur.SetRange(MIN_Minimum, MAX_Minimum);
mInitialAllowedSilenceT = S.AddTextBox(_("Duration:"), wxT(""), 12);
mInitialAllowedSilenceT->SetValidator(vldDur);
S.AddUnits(_("seconds"));
}
S.EndMultiColumn();
}
S.EndStatic();
S.StartStatic(_("Action"));
{
S.StartHorizontalLay();
{
// Action choices
auto actionChoices = LocalizedStrings(kActionStrings, nActions);
mActionChoice = S.AddChoice( {}, wxT(""), &actionChoices);
mActionChoice->SetValidator(wxGenericValidator(&mActionIndex));
S.SetSizeHints(-1, -1);
}
S.EndHorizontalLay();
S.StartMultiColumn(3, wxALIGN_CENTER_HORIZONTAL);
{
// Truncation / Compression factor
FloatingPointValidator<double> vldTrunc(3, &mTruncLongestAllowedSilence, NumValidatorStyle::NO_TRAILING_ZEROES);
vldTrunc.SetRange(MIN_Truncate, MAX_Truncate);
mTruncLongestAllowedSilenceT = S.AddTextBox(_("Truncate to:"), wxT(""), 12);
mTruncLongestAllowedSilenceT->SetValidator(vldTrunc);
S.AddUnits(_("seconds"));
FloatingPointValidator<double> vldComp(3, &mSilenceCompressPercent, NumValidatorStyle::NO_TRAILING_ZEROES);
vldComp.SetRange(MIN_Compress, MAX_Compress);
mSilenceCompressPercentT = S.AddTextBox(_("Compress to:"), wxT(""), 12);
mSilenceCompressPercentT->SetValidator(vldComp);
S.AddUnits(_("%"));
}
S.EndMultiColumn();
S.StartMultiColumn(2, wxALIGN_CENTER_HORIZONTAL);
{
mIndependent = S.AddCheckBox(_("Truncate tracks independently"),
mbIndependent ? wxT("true") : wxT("false"));
}
S.EndMultiColumn();
}
S.EndStatic();
UpdateUI();
}
