void SetTrackVisualsCommand::PopulateOrExchange(ShuttleGui & S)
{
SetTrackBase::PopulateOrExchange( S );
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol( 2 );
S.Optional( bHasHeight ).TieNumericTextBox( _("Height:"), mHeight );
S.Optional( bHasColour ).TieChoice( _("Colour:"), mColour,
LocalizedStrings( kColourStrings, nColours ) );
S.Optional( bHasDisplayType ).TieChoice( _("Display:"), mDisplayType,
LocalizedStrings( kDisplayTypeStrings, nDisplayTypes ) );
S.Optional( bHasScaleType ).TieChoice( _("Scale:"), mScaleType,
LocalizedStrings( kScaleTypeStrings, nScaleTypes ) );
S.Optional( bHasVZoom ).TieChoice( _("VZoom:"), mVZoom,
LocalizedStrings( kZoomTypeStrings, nZoomTypes ) );
S.Optional( bHasVZoomTop ).TieTextBox( _("VZoom Top:"), mVZoomTop );
S.Optional( bHasVZoomBottom ).TieTextBox( _("VZoom Bottom:"), mVZoomBottom );
}
S.EndMultiColumn();
S.StartMultiColumn(2, wxEXPAND);
{
S.SetStretchyCol( 1 );
S.Optional( bHasUseSpecPrefs ).TieCheckBox( _("Use Spectral Prefs"), bUseSpecPrefs );
S.Optional( bHasSpectralSelect ).TieCheckBox( _("Spectral Select"), bSpectralSelect);
S.Optional( bHasGrayScale ).TieCheckBox( _("Gray Scale"), bGrayScale );
}
S.EndMultiColumn();
}
void MacroCommandDialog::PopulateOrExchange(ShuttleGui &S)
{
S.StartVerticalLay(true);
{
S.StartMultiColumn(4, wxEXPAND);
{
S.SetStretchyCol(1);
mCommand = S.AddTextBox(_("&Command"), wxT(""), 20);
mCommand->SetEditable(false);
mEditParams = S.Id(EditParamsButtonID).AddButton(_("&Edit Parameters"));
mEditParams->Enable(false); // disable button as box is empty
mUsePreset = S.Id(UsePresetButtonID).AddButton(_("&Use Preset"));
mUsePreset->Enable(false); // disable button as box is empty
}
S.EndMultiColumn();
S.StartMultiColumn(2, wxEXPAND);
{
S.SetStretchyCol(1);
mParameters = S.AddTextBox(_("&Parameters"), wxT(""), 0);
mParameters->SetEditable(false);
wxString prompt{_("&Details")};
S.Prop(0).AddPrompt(prompt);
mDetails = S.AddTextWindow( wxT(""));
mDetails->SetEditable(false);
mDetails->SetName(wxStripMenuCodes(prompt));
}
S.EndMultiColumn();
S.Prop(10).StartStatic(_("Choose command"), true);
{
S.SetStyle(wxSUNKEN_BORDER | wxLC_LIST | wxLC_SINGLE_SEL);
mChoices = S.Id(CommandsListID).AddListControl();
}
S.EndStatic();
}
S.EndVerticalLay();
S.AddStandardButtons( eOkButton | eCancelButton | eHelpButton);
PopulateCommandList();
if (mChoices->GetItemCount() > 0) {
// set first item to be selected (and the focus when the
// list first becomes the focus)
mChoices->SetItemState(0, wxLIST_STATE_FOCUSED | wxLIST_STATE_SELECTED,
wxLIST_STATE_FOCUSED | wxLIST_STATE_SELECTED);
}
SetMinSize(wxSize(780, 560));
Fit();
Center();
}
void SetTrackStatusCommand::PopulateOrExchange(ShuttleGui & S)
{
SetTrackBase::PopulateOrExchange( S );
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol( 2 );
S.Optional( bHasTrackName ).TieTextBox( _("Name:"), mTrackName );
}
S.EndMultiColumn();
S.StartMultiColumn(2, wxEXPAND);
{
S.SetStretchyCol( 1 );
S.Optional( bHasSelected ).TieCheckBox( _("Selected"), bSelected );
S.Optional( bHasFocused ).TieCheckBox( _("Focused"), bFocused);
}
S.EndMultiColumn();
}
void SetTrackAudioCommand::PopulateOrExchange(ShuttleGui & S)
{
SetTrackBase::PopulateOrExchange( S );
S.StartMultiColumn(2, wxEXPAND);
{
S.SetStretchyCol( 1 );
S.Optional( bHasMute ).TieCheckBox( _("Mute"), bMute);
S.Optional( bHasSolo ).TieCheckBox( _("Solo"), bSolo);
}
S.EndMultiColumn();
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol( 2 );
S.Optional( bHasGain ).TieSlider( _("Gain:"), mGain, 36.0,-36.0);
S.Optional( bHasPan ).TieSlider( _("Pan:"), mPan, 100.0, -100.0);
}
S.EndMultiColumn();
}
void ClickRemovalDialog::PopulateOrExchange(ShuttleGui & S)
{
wxTextValidator vld(wxFILTER_INCLUDE_CHAR_LIST);
vld.SetIncludes(wxArrayString(10, numbers));
S.StartHorizontalLay(wxCENTER, false);
{
S.AddTitle(_("Click and Pop Removal by Craig DeForest"));
}
S.EndHorizontalLay();
S.StartHorizontalLay(wxCENTER, false);
{
// Add a little space
}
S.EndHorizontalLay();
S.StartMultiColumn(3, wxEXPAND);
S.SetStretchyCol(2);
{
// Threshold
mThreshT = S.Id(ID_THRESH_TEXT).AddTextBox(_("Select threshold (lower is more sensitive):"),
wxT(""),
10);
mThreshT->SetValidator(vld);
S.SetStyle(wxSL_HORIZONTAL);
mThreshS = S.Id(ID_THRESH_SLIDER).AddSlider(wxT(""),
0,
MAX_THRESHOLD);
mThreshS->SetName(_("Select threshold"));
mThreshS->SetRange(MIN_THRESHOLD, MAX_THRESHOLD);
#if defined(__WXGTK__)
// Force a minimum size since wxGTK allows it to go to zero
mThreshS->SetMinSize(wxSize(100, -1));
#endif
// Click width
mWidthT = S.Id(ID_WIDTH_TEXT).AddTextBox(_("Max spike width (higher is more sensitive):"),
wxT(""),
10);
mWidthT->SetValidator(vld);
S.SetStyle(wxSL_HORIZONTAL);
mWidthS = S.Id(ID_WIDTH_SLIDER).AddSlider(wxT(""),
0,
MAX_CLICK_WIDTH);
mWidthS->SetName(_("Max spike width"));
mWidthS->SetRange(MIN_CLICK_WIDTH, MAX_CLICK_WIDTH);
#if defined(__WXGTK__)
// Force a minimum size since wxGTK allows it to go to zero
mWidthS->SetMinSize(wxSize(100, -1));
#endif
}
S.EndMultiColumn();
return;
}
void BatchCommandDialog::PopulateOrExchange(ShuttleGui &S)
{
S.StartVerticalLay(true);
{
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol(1);
mCommand = S.AddTextBox(_("&Command"), wxT(""), 20);
mCommand->SetEditable(false);
mEditParams = S.Id(EditParamsButtonID).AddButton(_("&Edit Parameters"));
mEditParams->Enable( false ); // disable button as box is empty
}
S.EndMultiColumn();
S.StartMultiColumn(2, wxEXPAND);
{
S.SetStretchyCol(1);
mParameters = S.AddTextBox(_("&Parameters"), wxT(""), 0);
mParameters->SetEditable(false);
}
S.EndMultiColumn();
S.StartStatic(_("C&hoose command"), true);
{
S.SetStyle(wxSUNKEN_BORDER | wxLC_LIST | wxLC_SINGLE_SEL);
mChoices = S.Id(CommandsListID).AddListControl();
}
S.EndStatic();
}
S.EndVerticalLay();
S.AddStandardButtons();
for(int i=0;i<99;i++)
{
mChoices->InsertItem( i, wxString::Format(wxT("Item%02i"),i));
}
PopulateCommandList();
SetSize(350, 400);
SetSizeHints(GetSize());
Center();
}
void SelectFrequenciesCommand::PopulateOrExchange(ShuttleGui & S)
{
S.AddSpace(0, 5);
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol( 2 );
S.Optional( bHasTop ).TieTextBox(_("High:"), mTop);
S.Optional( bHasBottom ).TieTextBox(_("Low:"), mBottom);
}
S.EndMultiColumn();
}
/// Create the dialog contents, or exchange data with it.
void SmartRecordPrefs::PopulateOrExchange( ShuttleGui & S)
{
S.StartStatic( _("Pause Recording on Silence") );
{
S.TieCheckBox( _("Pause Recording on Silence"), wxT("/AudioIO/PauseRecOnSilence"),false);
S.StartMultiColumn(2, wxEXPAND);
S.SetStretchyCol(1);
S.TieSlider(_("Silence level (dB):"), wxT("/AudioIO/SilenceLevel"), -50, 0, -60);
S.EndMultiColumn();
}
S.EndStatic();
}
void BassBoostDialog::PopulateOrExchange(ShuttleGui & S)
{
wxTextValidator vld(wxFILTER_INCLUDE_CHAR_LIST);
vld.SetIncludes(wxArrayString(10, numbers));
S.StartHorizontalLay(wxCENTER, false);
{
S.AddTitle(_("by Nasca Octavian Paul"));
}
S.EndHorizontalLay();
S.StartHorizontalLay(wxCENTER, false);
{
// Add a little space
}
S.EndHorizontalLay();
S.StartMultiColumn(3, wxEXPAND);
S.SetStretchyCol(2);
{
// Frequency
mFreqT = S.Id(ID_FREQ_TEXT).AddTextBox(_("Frequency (Hz):"),
wxT(""),
10);
mFreqT->SetValidator(vld);
S.SetStyle(wxSL_HORIZONTAL);
mFreqS = S.Id(ID_FREQ_SLIDER).AddSlider(wxT(""),
0,
FREQ_MAX);
mFreqS->SetName(_("Frequency Hertz"));
mFreqS->SetRange(FREQ_MIN, FREQ_MAX);
// Boost
mBoostT = S.Id(ID_BOOST_TEXT).AddTextBox(_("Boost (dB):"),
wxT(""),
10);
mBoostT->SetValidator(vld);
S.SetStyle(wxSL_HORIZONTAL);
mBoostS = S.Id(ID_BOOST_SLIDER).AddSlider(wxT(""),
0,
BOOST_MAX);
mBoostS->SetName(_("Boost dB"));
mBoostS->SetRange(BOOST_MIN, BOOST_MAX);
}
S.EndMultiColumn();
return;
}
void SoundActivatedRecord::PopulateOrExchange(ShuttleGui & S)
{
S.SetBorder(5);
int dBRange;
S.StartVerticalLay();
{
S.StartMultiColumn(2, wxEXPAND);
S.SetStretchyCol(1);
dBRange = gPrefs->Read(ENV_DB_KEY, ENV_DB_RANGE);
S.TieSlider(_("Activation level (dB):"), wxT("/AudioIO/SilenceLevel"), -50, 0, -dBRange);
S.EndMultiColumn();
}
S.EndVerticalLay();
S.AddStandardButtons();
}
void SelectTimeCommand::PopulateOrExchange(ShuttleGui & S)
{
S.AddSpace(0, 5);
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol( 2 );
S.Optional( bHasT0 ).TieTextBox(_("Start Time:"), mT0);
S.Optional( bHasT1 ).TieTextBox(_("End Time:"), mT1);
// Chooses what time is relative to.
S.Optional( bHasRelativeSpec ).TieChoice(
_("Relative To:"),
mRelativeTo, LocalizedStrings( kRelativeTo, nRelativeTos ));
}
S.EndMultiColumn();
}
void SetTrackBase::PopulateOrExchange(ShuttleGui & S)
{
static_cast<void>(S);
#ifdef USE_OWN_TRACK_SELECTION
if( !mbPromptForTracks )
return;
S.AddSpace(0, 5);
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol( 2 );
S.Optional( bHasTrackIndex ).TieNumericTextBox( _("Track Index:"), mTrackIndex );
S.Optional( bHasChannelIndex).TieNumericTextBox( _("Channel Index:"), mChannelIndex );
}
S.EndMultiColumn();
#endif
}
void DirectoriesPrefs::PopulateOrExchange(ShuttleGui & S)
{
S.SetBorder(2);
S.StartStatic(_("Temporary files directory"));
{
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol(1);
S.Id(TempDirID);
mTempDir = S.TieTextBox(_("&Location:"),
wxT("/Directories/TempDir"),
wxT(""),
30);
S.Id(ChooseButtonID);
S.AddButton(_("C&hoose..."));
S.AddFixedText(_("Free Space:"));
mFreeSpace = S.AddVariableText(wxT(""));
}
S.EndMultiColumn();
}
S.EndStatic();
#ifdef DEPRECATED_AUDIO_CACHE
// See http://bugzilla.audacityteam.org/show_bug.cgi?id=545.
S.StartStatic(_("Audio cache"));
{
S.TieCheckBox(_("Play and/or record using &RAM (useful for slow drives)"),
wxT("/Directories/CacheBlockFiles"),
false);
S.StartTwoColumn();
{
S.TieNumericTextBox(_("Mi&nimum Free Memory (MB):"),
wxT("/Directories/CacheLowMem"),
16,
9);
}
S.EndTwoColumn();
S.AddVariableText(_("If the available system memory falls below this value, audio will no longer\nbe cached in memory and will be written to disk."))->Wrap(600);
}
S.EndStatic();
#endif // DEPRECATED_AUDIO_CACHE
}
void SplashDialog::Populate( ShuttleGui & S )
{
this->SetBackgroundColour(theTheme.Colour( clrAboutBoxBackground ));
bool bShow;
gPrefs->Read(wxT("/GUI/ShowSplashScreen"), &bShow, true );
S.StartVerticalLay(1);
//v For now, change to AudacityLogoWithName via old-fashioned ways, not Theme.
m_pLogo = new wxBitmap((const char **) AudacityLogoWithName_xpm); //v
// JKC: Resize to 50% of size. Later we may use a smaller xpm as
// our source, but this allows us to tweak the size - if we want to.
// It also makes it easier to revert to full size if we decide to.
const float fScale=0.5f;// smaller size.
wxImage RescaledImage( m_pLogo->ConvertToImage() );
// wxIMAGE_QUALITY_HIGH not supported by wxWidgets 2.6.1, or we would use it here.
RescaledImage.Rescale( int(LOGOWITHNAME_WIDTH * fScale), int(LOGOWITHNAME_HEIGHT *fScale) );
wxBitmap RescaledBitmap( RescaledImage );
m_pIcon =
new wxStaticBitmap(S.GetParent(), -1,
//*m_pLogo, //v theTheme.Bitmap(bmpAudacityLogoWithName),
RescaledBitmap,
wxDefaultPosition,
wxSize(int(LOGOWITHNAME_WIDTH*fScale), int(LOGOWITHNAME_HEIGHT*fScale)));
S.Prop(0).AddWindow( m_pIcon );
mpHtml = new LinkingHtmlWindow(S.GetParent(), -1,
wxDefaultPosition,
wxSize(506, 280),
wxHW_SCROLLBAR_AUTO | wxSUNKEN_BORDER );
mpHtml->SetPage(HelpText( wxT("welcome") ));
S.Prop(1).AddWindow( mpHtml, wxEXPAND );
S.Prop(0).StartMultiColumn(2, wxEXPAND);
S.SetStretchyCol( 1 );// Column 1 is stretchy...
{
S.SetBorder( 5 );
S.Id( DontShowID).AddCheckBox( _("Don't show this again at start up"), bShow ? wxT("false") : wxT("true") );
wxButton *ok = new wxButton(S.GetParent(), wxID_OK);
ok->SetDefault();
S.SetBorder( 5 );
S.Prop(0).AddWindow( ok, wxALIGN_RIGHT| wxALL );
}
S.EndVerticalLay();
}
void PopulateOrExchange(ShuttleGui & S)
{
wxString text;
S.SetBorder(10);
S.StartVerticalLay(true);
{
text.Printf(_("Audacity needs the file '%s' to import and export audio via FFmpeg."), mName.c_str());
S.AddTitle(text);
S.SetBorder(3);
S.StartHorizontalLay(wxALIGN_LEFT, true);
{
text.Printf(_("Location of '%s':"), mName.c_str());
S.AddTitle(text);
}
S.EndHorizontalLay();
S.StartMultiColumn(2, wxEXPAND);
S.SetStretchyCol(0);
{
if (mLibPath.GetFullPath().IsEmpty()) {
text.Printf(_("To find '%s', click here -->"), mName.c_str());
mPathText = S.AddTextBox(wxT(""), text, 0);
}
else {
mPathText = S.AddTextBox(wxT(""), mLibPath.GetFullPath(), 0);
}
S.Id(ID_FFMPEG_BROWSE).AddButton(_("Browse..."), wxALIGN_RIGHT);
S.AddVariableText(_("To get a free copy of FFmpeg, click here -->"), true);
S.Id(ID_FFMPEG_DLOAD).AddButton(_("Download"), wxALIGN_RIGHT);
}
S.EndMultiColumn();
S.AddStandardButtons();
}
S.EndVerticalLay();
Layout();
Fit();
SetMinSize(GetSize());
Center();
return;
}
void SelectTracksCommand::PopulateOrExchange(ShuttleGui & S)
{
S.AddSpace(0, 5);
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol( 2 );
S.Optional( bHasFirstTrack).TieTextBox(_("First Track:"),mFirstTrack);
S.Optional( bHasNumTracks).TieTextBox(_("Track Count:"),mNumTracks);
}
S.EndMultiColumn();
S.StartMultiColumn(2, wxALIGN_CENTER);
{
// Always used, so no check box.
S.TieChoice( _("Mode:"), mMode, LocalizedStrings( kModes, nModes ));
}
S.EndMultiColumn();
}
void ExportOGGOptions::PopulateOrExchange(ShuttleGui & S)
{
S.StartVerticalLay();
{
S.StartHorizontalLay(wxEXPAND);
{
S.SetSizerProportion(1);
S.StartMultiColumn(2, wxCENTER);
{
S.SetStretchyCol(1);
S.Prop(1).TieSlider(_("Quality:"), mOggQualityUnscaled, 10);
}
S.EndMultiColumn();
}
S.EndHorizontalLay();
}
S.EndVerticalLay();
}
void DirectoriesPrefs::PopulateOrExchange(ShuttleGui & S)
{
S.SetBorder(2);
S.StartStatic(_("Temporary files directory"));
{
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol(1);
S.Id(TempDirID);
mTempDir = S.TieTextBox(_("Location:"),
wxT("/Directories/TempDir"),
wxT(""),
30);
S.Id(ChooseButtonID);
S.AddButton(_("Choose..."));
S.AddFixedText(_("Free Space:"));
mFreeSpace = S.AddVariableText(wxT(""));
}
S.EndMultiColumn();
}
S.EndStatic();
S.StartStatic(_("Audio cache"));
{
S.TieCheckBox(_("Play and/or record using RAM (useful for slow drives)"),
wxT("/Directories/CacheBlockFiles"),
false);
S.StartTwoColumn();
{
S.TieTextBox(_("Minimum Free Memory (MB):"),
wxT("/Directories/CacheLowMem"),
16,
9);
}
S.EndTwoColumn();
S.AddVariableText(_("If the available system memory falls below this value, audio will no longer\nbe cached in memory and will be written to disk."))->Wrap(600);
}
S.EndStatic();
}
void EffectReverb::PopulateOrExchange(ShuttleGui & S)
{
S.AddSpace(0, 5);
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol(2);
#define SpinSlider(n, p) \
m ## n ## T = S.Id(ID_ ## n). \
AddSpinCtrl( p, DEF_ ## n, MAX_ ## n, MIN_ ## n); \
S.SetStyle(wxSL_HORIZONTAL); \
m ## n ## S = S.Id(ID_ ## n). \
AddSlider(wxT(""), DEF_ ## n, MAX_ ## n, MIN_ ## n);
SpinSlider(RoomSize, _("&Room Size (%):"));
SpinSlider(PreDelay, _("&Pre-delay (ms):"));
SpinSlider(Reverberance, _("Rever&berance (%):"));
SpinSlider(HfDamping, _("Da&mping (%):"));
SpinSlider(ToneLow, _("Tone &Low (%):"));
SpinSlider(ToneHigh, _("Tone &High (%):"));
SpinSlider(WetGain, _("Wet &Gain (dB):"));
SpinSlider(DryGain, _("Dr&y Gain (dB):"));
SpinSlider(StereoWidth, _("Stereo Wid&th (%):"));
#undef SpinSlider
}
S.EndMultiColumn();
S.StartHorizontalLay(wxCENTER, false);
{
mWetOnlyC = S.Id(ID_WetOnly).
AddCheckBox(_("Wet O&nly"), DEF_WetOnly ? wxT("true") : wxT("false"));
}
S.EndHorizontalLay();
return;
}
void EffectWahwah::PopulateOrExchange(ShuttleGui & S)
{
S.SetBorder(5);
S.AddSpace(0, 5);
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol(2);
FloatingPointValidator<double> vldfreq(5, &mFreq, NumValidatorStyle::ONE_TRAILING_ZERO);
vldfreq.SetRange(MIN_Freq, MAX_Freq);
mFreqT = S.Id(ID_Freq).AddTextBox(_("LFO Freq&uency (Hz):"), wxT(""), 12);
mFreqT->SetValidator(vldfreq);
S.SetStyle(wxSL_HORIZONTAL);
mFreqS = S.Id(ID_Freq).AddSlider( {}, DEF_Freq * SCL_Freq, MAX_Freq * SCL_Freq, MIN_Freq * SCL_Freq);
mFreqS->SetName(_("LFO frequency in hertz"));
mFreqS->SetMinSize(wxSize(100, -1));
FloatingPointValidator<double> vldphase(1, &mPhase);
vldphase.SetRange(MIN_Phase, MAX_Phase);
mPhaseT = S.Id(ID_Phase).AddTextBox(_("LFO Sta&rt Phase (deg.):"), wxT(""), 12);
mPhaseT->SetValidator(vldphase);
S.SetStyle(wxSL_HORIZONTAL);
mPhaseS = S.Id(ID_Phase).AddSlider( {}, 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));
IntegerValidator<int> vlddepth(&mDepth);
vlddepth.SetRange(MIN_Depth, MAX_Depth);
mDepthT = S.Id(ID_Depth).AddTextBox(_("Dept&h (%):"), wxT(""), 12);
mDepthT->SetValidator(vlddepth);
S.SetStyle(wxSL_HORIZONTAL);
mDepthS = S.Id(ID_Depth).AddSlider( {}, DEF_Depth * SCL_Depth, MAX_Depth * SCL_Depth, MIN_Depth * SCL_Depth);
mDepthS->SetName(_("Depth in percent"));
mDepthS->SetMinSize(wxSize(100, -1));
FloatingPointValidator<double> vldres(1, &mRes);
vldres.SetRange(MIN_Res, MAX_Res);
mResT = S.Id(ID_Res).AddTextBox(_("Reso&nance:"), wxT(""), 12);
mResT->SetValidator(vldres);
S.SetStyle(wxSL_HORIZONTAL);
mResS = S.Id(ID_Res).AddSlider( {}, DEF_Res * SCL_Res, MAX_Res * SCL_Res, MIN_Res * SCL_Res);
mResS->SetName(_("Resonance"));
mResS->SetMinSize(wxSize(100, -1));
IntegerValidator<int> vldfreqoffset(&mFreqOfs);
vldfreqoffset.SetRange(MIN_FreqOfs, MAX_FreqOfs);
mFreqOfsT = S.Id(ID_FreqOfs).AddTextBox(_("Wah Frequency Offse&t (%):"), wxT(""), 12);
mFreqOfsT->SetValidator(vldfreqoffset);
S.SetStyle(wxSL_HORIZONTAL);
mFreqOfsS = S.Id(ID_FreqOfs).AddSlider( {}, DEF_FreqOfs * SCL_FreqOfs, MAX_FreqOfs * SCL_FreqOfs, MIN_FreqOfs * SCL_FreqOfs);
mFreqOfsT->SetName(_("Wah frequency offset in percent"));
mFreqOfsT->SetMinSize(wxSize(100, -1));
FloatingPointValidator<double> vldoutgain(1, &mOutGain);
vldoutgain.SetRange(MIN_OutGain, MAX_OutGain);
mOutGainT = S.Id(ID_OutGain).AddTextBox(_("&Output gain (dB):"), wxT(""), 12);
mOutGainT->SetValidator(vldoutgain);
S.SetStyle(wxSL_HORIZONTAL);
mOutGainS = S.Id(ID_OutGain).AddSlider( {}, DEF_OutGain * SCL_OutGain, MAX_OutGain * SCL_OutGain, MIN_OutGain * SCL_OutGain);
mOutGainS->SetName(_("Output gain (dB)"));
mOutGainS->SetMinSize(wxSize(100, -1));
}
S.EndMultiColumn();
}
void EffectPhaser::PopulateOrExchange(ShuttleGui & S)
{
S.SetBorder(5);
S.AddSpace(0, 5);
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol(2);
IntegerValidator<int> vldStages(&mStages);
vldStages.SetRange(MIN_Stages, MAX_Stages);
mStagesT = S.Id(ID_Stages).AddTextBox(_("&Stages:"), wxT(""), 15);
mStagesT->SetValidator(vldStages);
S.SetStyle(wxSL_HORIZONTAL);
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));
IntegerValidator<int> vldDryWet(&mDryWet);
vldDryWet.SetRange(MIN_DryWet, MAX_DryWet);
mDryWetT = S.Id(ID_DryWet).AddTextBox(_("&Dry/Wet:"), wxT(""), 15);
mDryWetT->SetValidator(vldDryWet);
S.SetStyle(wxSL_HORIZONTAL);
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));
FloatingPointValidator<double> vldFreq(5, &mFreq, NUM_VAL_ONE_TRAILING_ZERO);
vldFreq.SetRange(MIN_Freq, MAX_Freq);
mFreqT = S.Id(ID_Freq).AddTextBox(_("LFO Freq&uency (Hz):"), wxT(""), 15);
mFreqT->SetValidator(vldFreq);
S.SetStyle(wxSL_HORIZONTAL);
mFreqS = S.Id(ID_Freq).AddSlider(wxT(""), DEF_Freq * SCL_Freq, MAX_Freq * SCL_Freq, 0.0);
mFreqS ->SetName(_("LFO frequency in hertz"));
mFreqS ->SetMinSize(wxSize(100, -1));
FloatingPointValidator<double> vldPhase(1, &mPhase);
vldPhase.SetRange(MIN_Phase, MAX_Phase);
mPhaseT = S.Id(ID_Phase).AddTextBox(_("LFO Sta&rt Phase (deg.):"), wxT(""), 15);
mPhaseT->SetValidator(vldPhase);
S.SetStyle(wxSL_HORIZONTAL);
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));
IntegerValidator<int> vldDepth(&mDepth);
vldDepth.SetRange(MIN_Depth, MAX_Depth);
mDepthT = S.Id(ID_Depth).AddTextBox(_("Dept&h:"), wxT(""), 15);
mDepthT->SetValidator(vldDepth);
S.SetStyle(wxSL_HORIZONTAL);
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));
IntegerValidator<int> vldFeedback(&mFeedback);
vldFeedback.SetRange(MIN_Feedback, MAX_Feedback);
mFeedbackT = S.Id(ID_Feedback).AddTextBox(_("Feedbac&k (%):"), wxT(""), 15);
mFeedbackT->SetValidator(vldFeedback);
S.SetStyle(wxSL_HORIZONTAL);
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));
FloatingPointValidator<double> vldoutgain(1, &mOutGain);
vldoutgain.SetRange(MIN_OutGain, MAX_OutGain);
mOutGainT = S.Id(ID_OutGain).AddTextBox(_("&Output gain (dB):"), wxT(""), 12);
mOutGainT->SetValidator(vldoutgain);
S.SetStyle(wxSL_HORIZONTAL);
mOutGainS = S.Id(ID_OutGain).AddSlider(wxT(""), DEF_OutGain * SCL_OutGain, MAX_OutGain * SCL_OutGain, MIN_OutGain * SCL_OutGain);
mOutGainS->SetName(_("Output gain (dB)"));
mOutGainS->SetMinSize(wxSize(100, -1));
}
S.EndMultiColumn();
}
void PhaserDialog::PopulateOrExchange(ShuttleGui & S)
{
wxTextValidator vld(wxFILTER_NUMERIC);
S.SetBorder(5);
S.StartMultiColumn(3, wxEXPAND);
{
wxSlider *s;
wxTextCtrl * tempTC;
S.SetStretchyCol(1);
tempTC = S.Id(ID_PHASER_STAGESTEXT).AddTextBox(_("Stages:"), wxT(""), 12);
S.SetStyle(wxSL_HORIZONTAL);
tempTC->SetValidator(vld);
s = S.Id(ID_PHASER_STAGESSLIDER).AddSlider(wxT(""), 2, STAGES_MAX, STAGES_MIN);
s->SetName(_("Stages"));
#if defined(__WXGTK__)
s->SetMinSize(wxSize(100, -1));
#endif
tempTC = S.Id(ID_PHASER_DRYWETTEXT).AddTextBox(_("Dry/Wet:"), wxT(""), 12);
S.SetStyle(wxSL_HORIZONTAL);
tempTC->SetValidator(vld);
s = S.Id(ID_PHASER_DRYWETSLIDER).AddSlider(wxT(""), 0, DRYWET_MAX, DRYWET_MIN);
s->SetName(_("Dry Wet"));
#if defined(__WXGTK__)
s->SetMinSize(wxSize(100, -1));
#endif
tempTC = S.Id(ID_PHASER_FREQTEXT).AddTextBox(_("LFO Frequency (Hz):"), wxT(""), 12);
S.SetStyle(wxSL_HORIZONTAL);
tempTC->SetValidator(vld);
s = S.Id(ID_PHASER_FREQSLIDER).AddSlider(wxT(""), 100, FREQ_MAX, FREQ_MIN);
s->SetName(_("LFO frequency in hertz"));
#if defined(__WXGTK__)
s->SetMinSize(wxSize(100, -1));
#endif
tempTC = S.Id(ID_PHASER_PHASETEXT).AddTextBox(_("LFO Start Phase (deg.):"), wxT(""), 12);
S.SetStyle(wxSL_HORIZONTAL);
tempTC->SetValidator(vld);
s = S.Id(ID_PHASER_PHASESLIDER).AddSlider(wxT(""), 0, PHASE_MAX, PHASE_MIN);
s->SetName(_("LFO start phase in degrees"));
s->SetLineSize(10);
#if defined(__WXGTK__)
s->SetMinSize(wxSize(100, -1));
#endif
tempTC = S.Id(ID_PHASER_DEPTHTEXT).AddTextBox(_("Depth:"), wxT(""), 12);
S.SetStyle(wxSL_HORIZONTAL);
tempTC->SetValidator(vld);
s = S.Id(ID_PHASER_DEPTHSLIDER).AddSlider(wxT(""), 0, DEPTH_MAX, DEPTH_MIN);
s->SetName(_("Depth in percent"));
#if defined(__WXGTK__)
s->SetMinSize(wxSize(100, -1));
#endif
tempTC = S.Id(ID_PHASER_FEEDBACKTEXT).AddTextBox(_("Feedback (%):"), wxT(""), 12);
S.SetStyle(wxSL_HORIZONTAL);
tempTC->SetValidator(vld);
s = S.Id(ID_PHASER_FEEDBACKSLIDER).AddSlider(wxT(""), 0, FB_MAX, FB_MIN);
s->SetName(_("Feedback in percent"));
s->SetLineSize(10);
#if defined(__WXGTK__)
s->SetMinSize(wxSize(100, -1));
#endif
}
S.EndMultiColumn();
}
void AudioIOPrefs::PopulateOrExchange( ShuttleGui & S )
{
/// \todo
/// JKC: I think setting paths in gPrefs is bad practice.
/// Suppose we are using gPrefs from elsewhere at the same time?
/// Change these all to full paths?
gPrefs->SetPath(wxT("/AudioIO"));
S.SetBorder( 2 );
S.StartHorizontalLay(wxEXPAND, 0 );
S.StartStatic( _("Playback"),1 );
{
S.StartMultiColumn(2, wxEXPAND);
S.SetStretchyCol(1);
S.TieChoice( _("Device") + wxString(wxT(":")), wxT("PlaybackDevice"),
wxT(""), mmPlayNames, mmPlayLabels );
S.AddPrompt( _("Using:") );
wxString ver = _("Portaudio v");
#if USE_PORTAUDIO_V19
ver += wxT("19");
#else
ver += wxT("18");
#endif
S.AddFixedText( ver );
S.EndMultiColumn();
}
S.EndStatic();
S.StartStatic( _("Recording"), 1 );
{
S.StartMultiColumn(2, wxEXPAND);
S.SetStretchyCol(1);
S.TieChoice( _("Device") + wxString(wxT(":")), wxT("RecordingDevice"),
wxT(""), mmRecordNames, mmRecordLabels );
S.TieChoice( _("Channels") + wxString(wxT(":")), wxT("RecordChannels"),
2, mmChannelNames, mmChannelLabels );
S.EndMultiColumn();
}
S.EndStatic();
S.EndHorizontalLay();
S.StartStatic( _("Playthrough") );
{
S.TieCheckBox( _("&Play other tracks while recording new one"),
wxT("Duplex"),true);
#ifdef __MACOSX__
S.TieCheckBox( _("&Hardware Playthrough (Play new track while recording it)"),
wxT("Playthrough"),false);
#endif
S.TieCheckBox( _("&Software Playthrough (Play new track while recording it)"),
wxT("SWPlaythrough"),false);
}
S.EndStatic();
S.StartHorizontalLay( wxEXPAND, 0 );
S.StartStatic( _("Cut Preview"),1 );
{
S.StartThreeColumn();
S.TieTextBox( _("Play before cut region:"), wxT("CutPreviewBeforeLen"),1.0,9);
S.AddUnits( _("seconds") );
S.TieTextBox( _("Play after cut region:"),wxT("CutPreviewAfterLen"), 1.0,9);
S.AddUnits( _("seconds") );
S.EndThreeColumn();
}
S.EndStatic();
S.StartStatic( _("Latency"),1 );
{
S.StartThreeColumn();
#if USE_PORTAUDIO_V19
// only show the following controls if we use Portaudio v19, because
// for Portaudio v19 we always use default buffer sizes
S.TieTextBox( _("Audio to buffer:"),wxT("LatencyDuration"),100.0,9);
S.AddUnits( _("milliseconds") );
#endif
S.TieTextBox( _("Latency correction:"),wxT("LatencyCorrection"),0.0,9);
S.AddUnits( _("milliseconds") );
S.EndThreeColumn();
}
S.EndStatic();
S.EndHorizontalLay();
S.StartHorizontalLay( wxEXPAND, 0 );
S.StartStatic( _("Seek Time"),1 );
{
S.StartThreeColumn();
S.TieTextBox( _("Short period:"), wxT("SeekShortPeriod"),1.0,9);
S.AddUnits( _("seconds") );
S.TieTextBox( _("Long period:"),wxT("SeekLongPeriod"), 15.0,9);
S.AddUnits( _("seconds") );
S.EndThreeColumn();
}
S.EndStatic();
S.StartStatic( _("Effects Preview"),1 );
{
S.StartThreeColumn();
S.TieTextBox( _("Play when previewing:"), wxT("EffectsPreviewLen"), 3.0,9);
S.AddUnits( _("seconds") );
S.EndThreeColumn();
}
gPrefs->SetPath(wxT("/"));
}
void SplashDialog::Populate( ShuttleGui & S )
{
//#if ((AUDACITY_BRANDING == BRAND_JAMLING__EASY) || (AUDACITY_BRANDING == BRAND_JAMLING__FULL))
// this->SetBackgroundColour(wxColour(rrr, ggg, bbb)); // same as waveform color
//#else
// this->SetBackgroundColour(theTheme.Colour( clrAboutBoxBackground ));
//#endif
this->SetBackgroundColour(theTheme.Colour( clrAboutBoxBackground ));
bool bShow;
gPrefs->Read(wxT("/GUI/ShowSplashScreen"), &bShow, true );
S.StartVerticalLay(1);
wxImage buttonImageUp;
wxImage buttonImageOver;
wxSize buttonSize;
wxBitmap* pButtonBitmap;
wxBitmap* pButtonBitmapOver;
//vvv Change this compile flag when other brands are supported.
#if ((AUDACITY_BRANDING == BRAND_JAMLING__EASY) || (AUDACITY_BRANDING == BRAND_JAMLING__FULL))
//vvv Compiles only BRAND_JAMLING__EASY or BRAND_JAMLING__FULL
// because we don't load any other company_logo*_xpm consts yet.
pButtonBitmap = new wxBitmap(company_logo_xpm);
buttonImageUp = pButtonBitmap->ConvertToImage();
pButtonBitmapOver = new wxBitmap(company_logo_over_xpm);
buttonImageOver = pButtonBitmapOver->ConvertToImage();
buttonSize = wxSize(pButtonBitmap->GetWidth(), pButtonBitmap->GetHeight());
mButton_Logo =
new AButton(this, ID_BUTTON_LOGO,
wxDefaultPosition, buttonSize,
&buttonImageUp, &buttonImageOver,
&buttonImageUp, &buttonImageUp, //v other images?
true);
#else
//vvv For now, change to AudacityLogoWithName via old-fashioned ways, not Theme.
pButtonBitmap = //vvv theTheme.Bitmap(bmpAudacityLogoWithName)
new wxBitmap((const char **) AudacityLogoWithName_xpm);
buttonImageUp = pButtonBitmap->ConvertToImage();
// JKC: Resize to 50% of size. Later we may use a smaller xpm as
// our source, but this allows us to tweak the size - if we want to.
// It also makes it easier to revert to full size if we decide to.
const float fScale=0.5f;// smaller size.
buttonSize = wxSize(LOGOWITHNAME_WIDTH * fScale, LOGOWITHNAME_HEIGHT * fScale);
// wxIMAGE_QUALITY_HIGH not supported by wxWidgets 2.6.x, or we would use it here.
buttonImageUp.Rescale(buttonSize.GetWidth(), buttonSize.GetHeight());
buttonImageOver = buttonImageUp.Copy();
buttonImageOver.RotateHue(-0.01);
mButton_Logo =
new AButton(this, ID_BUTTON_LOGO,
wxDefaultPosition, buttonSize,
&buttonImageUp, &buttonImageOver,
&buttonImageUp, &buttonImageUp, //v other images?
true);
#endif
S.Prop(0).AddWindow(mButton_Logo);
mpHtml = new LinkingHtmlWindow(S.GetParent(), -1,
wxDefaultPosition,
wxSize(kWidth, 280),
wxHW_SCROLLBAR_AUTO | wxSUNKEN_BORDER );
mpHtml->SetPage(HelpText( wxT("welcome") ));
S.Prop(1).AddWindow( mpHtml, wxEXPAND );
S.Prop(0).StartMultiColumn(2, wxEXPAND);
S.SetStretchyCol( 1 );// Column 1 is stretchy...
{
S.SetBorder( 5 );
S.Id( DontShowID).AddCheckBox( _("Don't show this again at start up"), bShow ? wxT("false") : wxT("true") );
wxButton *ok = new wxButton(S.GetParent(), wxID_OK);
ok->SetDefault();
ok->SetFocus();
S.SetBorder( 5 );
S.Prop(0).AddWindow( ok, wxALIGN_RIGHT| wxALL );
}
S.EndVerticalLay();
}
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 ExportMultiple::PopulateOrExchange(ShuttleGui& S)
{
S.SetBorder(5);
S.StartMultiColumn(4, true);
{
wxArrayString formats;
for (size_t i = 0; i < mPlugins.GetCount(); i++) {
formats.Add(mPlugins[i]->GetDescription());
}
S.AddPrompt(_("Export format:"));
mFormat = S.Id(FormatID)
.TieChoice(wxT(""),
wxT("/Export/MultipleFormat"),
gPrefs->Read(wxT("/Export/Format"), wxT("WAV")),
formats,
formats);
S.Id(OptionsID).AddButton(_("Options..."));
S.AddVariableText(wxT(""), false);
S.AddPrompt(_("Export location:"));
mDir = S.Id(DirID)
.TieTextBox(wxT(""),
wxT("/Export/MultiplePath"),
gPrefs->Read(wxT("/Export/Path"), ::wxGetCwd()),
64);
S.Id(ChooseID).AddButton(_("Choose..."));
S.Id(CreateID).AddButton(_("Create"));
}
S.EndMultiColumn();
S.StartHorizontalLay(wxEXPAND, true);
{
S.SetBorder(5);
S.StartStatic(_("Split files based on:"), true);
{
S.StartMultiColumn(2, false);
S.SetStretchyCol(1);
{
// Row 1
S.SetBorder(1);
mLabel = S.Id(LabelID)
.AddRadioButton(wxT(""));
S.SetBorder(3);
mLabelLabel = S.AddVariableText(_("Labels"), false);
// Row 2
S.AddVariableText(wxT(""), false);
mFirst = S.Id(FirstID)
.AddCheckBox(_("Include audio before first label"), wxT("false"));
// Row 3
S.AddVariableText(wxT(""), false);
S.StartHorizontalLay(wxEXPAND, false);
{
mFirstFileLabel = S.AddVariableText(_("First file name:"), true);
mFirstFileName = S.Id(FirstFileNameID)
.TieTextBox(wxT(""),
wxT("/Export/MultipleFirstName"),
wxT(""),
30);
}
S.EndHorizontalLay();
// Row 4
S.SetBorder(1);
mTrack = S.Id(TrackID)
.AddRadioButtonToGroup(wxT(""));
S.SetBorder(3);
mTrackLabel = S.AddVariableText(_("Tracks"), false);
}
S.EndMultiColumn();
}
S.EndStatic();
S.SetBorder(5);
S.StartStatic(_("Name files:"), false);
{
S.StartMultiColumn(2, false);
S.SetStretchyCol(1);
{
// Row 1
S.SetBorder(1);
mByName = S.Id(ByNameID)
.AddRadioButton(wxT(""));
S.SetBorder(3);
mByNameLabel = S.AddVariableText(_("Using Label/Track Name"), false);
// Row 2
S.SetBorder(1);
mByNumber = S.Id(ByNumberID)
.AddRadioButtonToGroup(wxT(""));
S.SetBorder(3);
mByNumberLabel = S.AddVariableText(_("Numbering consecutively"), false);
// Row 3
S.AddVariableText(wxT(""), false);
S.StartHorizontalLay(wxEXPAND, false);
{
mPrefixLabel = S.AddVariableText(_("File name prefix:"), true);
mPrefix = S.Id(PrefixID)
.TieTextBox(wxT(""),
wxT("/Export/MultiplePrefix"),
wxT(""),
30);
}
S.EndHorizontalLay();
}
S.EndMultiColumn();
}
S.EndStatic();
}
S.EndHorizontalLay();
S.SetBorder(5);
S.StartHorizontalLay(wxEXPAND, false);
{
mOverwrite = S.Id(OverwriteID)
.AddCheckBox(_("Overwrite existing files"), wxT("true"));
}
S.EndHorizontalLay();
S.StartHorizontalLay(wxALIGN_CENTER, false);
{
#if defined(__WXGTK20__) || defined(__WXMAC__)
S.Id(wxID_CANCEL).AddButton(_("&Cancel"));
mExport = S.Id(wxID_OK).AddButton(_("E&xport"));
#else
mExport = S.Id(wxID_OK).AddButton(_("E&xport"));
S.Id(wxID_CANCEL).AddButton(_("&Cancel"));
#endif
mExport->SetDefault();
}
S.EndHorizontalLay();
}
void BassTrebleDialog::PopulateOrExchange(ShuttleGui & S)
{
S.StartStatic(wxT(""));
{
S.StartMultiColumn(3, wxEXPAND);
S.SetStretchyCol(2);
{
#ifdef __WXGTK__
// BoxSizer is to make first mnemonic work, on Linux.
wxPanel* cPanel = new wxPanel( this, wxID_ANY );
wxBoxSizer* cSizer = new wxBoxSizer(wxVERTICAL);
cPanel->SetSizer(cSizer);
#endif
wxTextValidator vld(wxFILTER_NUMERIC);
// Bass control
mBassT = S.Id(ID_BASS_TEXT).AddTextBox(_("&Bass (dB):"), wxT(""), 10);
mBassT->SetName(_("Bass (dB):"));
mBassT->SetValidator(vld);
S.SetStyle(wxSL_HORIZONTAL);
mBassS = S.Id(ID_BASS_SLIDER).AddSlider(wxT(""), 0, BASS_MAX, BASS_MIN);
mBassS->SetName(_("Bass"));
mBassS->SetRange(BASS_MIN, BASS_MAX);
mBassS->SetPageSize(30);
// Treble control
mTrebleT = S.Id(ID_TREBLE_TEXT).AddTextBox(_("&Treble (dB):"), wxT(""), 10);
mTrebleT->SetValidator(vld);
S.SetStyle(wxSL_HORIZONTAL);
mTrebleS = S.Id(ID_TREBLE_SLIDER).AddSlider(wxT(""), 0, TREBLE_MAX, TREBLE_MIN);
mTrebleS->SetName(_("Treble"));
mTrebleS->SetRange(TREBLE_MIN, TREBLE_MAX);
mTrebleS->SetPageSize(30);
// Level control
mLevelT = S.Id(ID_LEVEL_TEXT).AddTextBox(_("&Level (dB):"), wxT(""), 10);
mLevelT->SetValidator(vld);
S.SetStyle(wxSL_HORIZONTAL);
mLevelS = S.Id(ID_LEVEL_SLIDER).AddSlider(wxT(""), 0, LEVEL_MAX, LEVEL_MIN);
mLevelS->SetName(_("Level"));
mLevelS->SetRange(LEVEL_MIN, LEVEL_MAX);
mLevelS->SetPageSize(30);
}
S.EndMultiColumn();
}
S.EndStatic();
// Normalize checkbox
S.StartHorizontalLay(wxLEFT, true);
{
mNormalizeCheckBox = S.Id(ID_NORMALIZE).AddCheckBox(_("&Enable level control"),
mbNormalize ? wxT("true") : wxT("false"));
mWarning = S.AddVariableText( wxT(""), false,
wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
}
S.EndHorizontalLay();
}
void QualityPrefs::PopulateOrExchange(ShuttleGui & S)
{
S.SetBorder(2);
S.StartStatic(_("Sampling"));
{
S.StartMultiColumn(2);
{
S.AddPrompt(_("Default Sample &Rate:"));
S.StartMultiColumn(2);
{
// If the value in Prefs isn't in the list, then we want
// the last item, 'Other...' to be shown.
S.SetNoMatchSelector(mSampleRateNames.GetCount() - 1);
// First the choice...
// We make sure it uses the ID we want, so that we get changes
S.Id(ID_SAMPLE_RATE_CHOICE);
// We make sure we have a pointer to it, so that we can drive it.
mSampleRates = S.TieChoice(wxT(""),
wxT("/SamplingRate/DefaultProjectSampleRate"),
AudioIO::GetOptimalSupportedSampleRate(),
mSampleRateNames,
mSampleRateLabels);
S.SetSizeHints(mSampleRateNames);
// Now do the edit box...
mOtherSampleRate = S.TieNumericTextBox(wxT(""),
mOtherSampleRateValue,
15);
}
S.EndHorizontalLay();
S.TieChoice(_("Default Sample &Format:"),
wxT("/SamplingRate/DefaultProjectSampleFormat"),
floatSample,
mSampleFormatNames,
mSampleFormatLabels);
S.SetSizeHints(mSampleFormatNames);
}
S.EndMultiColumn();
}
S.EndStatic();
S.StartStatic(_("Real-time Conversion"));
{
S.StartMultiColumn(2, wxEXPAND);
{
S.SetStretchyCol(2);
S.TieChoice(_("Sample Rate Con&verter:"),
Resample::GetFastMethodKey(),
Resample::GetFastMethodDefault(),
mConverterNames,
mConverterLabels),
S.SetSizeHints(mConverterNames);
S.TieChoice(_("&Dither:"),
wxT("/Quality/DitherAlgorithm"),
Dither::none,
mDitherNames,
mDitherLabels);
S.SetSizeHints(mDitherNames);
}
S.EndMultiColumn();
}
S.EndStatic();
S.StartStatic(_("High-quality Conversion"));
{
S.StartMultiColumn(2);
{
S.TieChoice(_("Sample Rate Conver&ter:"),
Resample::GetBestMethodKey(),
Resample::GetBestMethodDefault(),
mConverterNames,
mConverterLabels),
S.SetSizeHints(mConverterNames);
S.TieChoice(_("Dit&her:"),
wxT("/Quality/HQDitherAlgorithm"),
Dither::shaped,
mDitherNames,
mDitherLabels);
S.SetSizeHints(mDitherNames);
}
S.EndMultiColumn();
}
S.EndStatic();
}
/// Normally in classes derived from PrefsPanel this function
/// is used both to populate the panel and to exchange data with it.
/// With KeyConfigPrefs all the exchanges are handled specially,
/// so this is only used in populating the panel.
void KeyConfigPrefs::PopulateOrExchange(ShuttleGui & S)
{
S.SetBorder(2);
S.StartStatic(_("Key Bindings"), 1);
{
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol(1);
S.StartHorizontalLay(wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 0);
{
S.AddTitle(_("View by:"));
S.StartRadioButtonGroup(wxT("/Prefs/KeyConfig/ViewBy"), wxT("tree"));
{
mViewByTree = S.Id(ViewByTreeID).TieRadioButton(_("&Tree"), wxT("tree"));
mViewByTree->SetName(_("View by tree"));
mViewByName = S.Id(ViewByNameID).TieRadioButton(_("&Name"), wxT("name"));
mViewByName->SetName(_("View by name"));
mViewByKey = S.Id(ViewByKeyID).TieRadioButton(_("&Key"), wxT("key"));
mViewByKey->SetName(_("View by key"));
}
S.EndRadioButtonGroup();
}
S.EndHorizontalLay();
S.StartHorizontalLay(wxALIGN_CENTER|wxALIGN_CENTER_VERTICAL, 0);
{
// just a spacer
}
S.EndHorizontalLay();
S.StartHorizontalLay(wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 0);
{
mFilterLabel = S.AddVariableText(_("Searc&h:"));
if (!mFilter) {
mFilter = safenew wxTextCtrl(this,
FilterID,
wxT(""),
wxDefaultPosition,
#if defined(__WXMAC__)
wxSize(300, -1),
#else
wxSize(210, -1),
#endif
wxTE_PROCESS_ENTER);
mFilter->SetName(wxStripMenuCodes(mFilterLabel->GetLabel()));
mFilter->Connect(wxEVT_KEY_DOWN,
wxKeyEventHandler(KeyConfigPrefs::OnFilterKeyDown),
NULL,
this);
mFilter->Connect(wxEVT_CHAR,
wxKeyEventHandler(KeyConfigPrefs::OnFilterChar),
NULL,
this);
}
S.AddWindow(mFilter, wxALIGN_NOT | wxALIGN_LEFT);
}
S.EndHorizontalLay();
}
S.EndThreeColumn();
S.AddSpace(-1, 2);
S.StartHorizontalLay(wxEXPAND, 1);
{
if (!mView) {
mView = safenew KeyView(this, CommandsListID);
mView->SetName(_("Bindings"));
}
S.Prop(true);
S.AddWindow(mView, wxEXPAND);
}
S.EndHorizontalLay();
S.StartThreeColumn();
{
if (!mKey) {
mKey = safenew wxTextCtrl(this,
CurrentComboID,
wxT(""),
wxDefaultPosition,
#if defined(__WXMAC__)
wxSize(300, -1),
#else
wxSize(210, -1),
#endif
wxTE_PROCESS_ENTER);
mKey->SetName(_("Short cut"));
mKey->Connect(wxEVT_KEY_DOWN,
wxKeyEventHandler(KeyConfigPrefs::OnHotkeyKeyDown),
NULL,
this);
mKey->Connect(wxEVT_CHAR,
wxKeyEventHandler(KeyConfigPrefs::OnHotkeyChar),
NULL,
this);
mKey->Connect(wxEVT_KILL_FOCUS,
wxFocusEventHandler(KeyConfigPrefs::OnHotkeyKillFocus),
NULL,
this);
}
S.AddWindow(mKey);
/* i18n-hint: (verb)*/
mSet = S.Id(SetButtonID).AddButton(_("&Set"));
mClear = S.Id(ClearButtonID).AddButton(_("Cl&ear"));
}
S.EndThreeColumn();
#if defined(__WXMAC__)
S.AddFixedText(_("Note: Pressing Cmd+Q will quit. All other keys are valid."));
#endif
S.StartThreeColumn();
{
S.Id(ImportButtonID).AddButton(_("&Import..."));
S.Id(ExportButtonID).AddButton(_("&Export..."));
S.Id(AssignDefaultsButtonID).AddButton(_("&Defaults"));
}
S.EndThreeColumn();
}
S.EndStatic();
// Need to layout so that the KeyView is properly sized before populating.
// Otherwise, the initial selection is not scrolled into view.
Layout();
}
void EffectScienFilter::PopulateOrExchange(ShuttleGui & S)
{
wxWindow *parent = S.GetParent();
S.AddSpace(5);
S.SetSizerProportion(1);
S.StartMultiColumn(3, wxEXPAND);
{
S.SetStretchyCol(1);
S.SetStretchyRow(0);
// -------------------------------------------------------------------
// ROW 1: Freq response panel and sliders for vertical scale
// -------------------------------------------------------------------
S.StartVerticalLay();
{
mdBRuler = new RulerPanel(parent, wxID_ANY);
mdBRuler->ruler.SetBounds(0, 0, 100, 100); // Ruler can't handle small sizes
mdBRuler->ruler.SetOrientation(wxVERTICAL);
mdBRuler->ruler.SetRange(30.0, -120.0);
mdBRuler->ruler.SetFormat(Ruler::LinearDBFormat);
mdBRuler->ruler.SetUnits(_("dB"));
mdBRuler->ruler.SetLabelEdges(true);
int w;
mdBRuler->ruler.GetMaxSize(&w, NULL);
mdBRuler->SetSize(wxSize(w, 150)); // height needed for wxGTK
S.SetBorder(1);
S.AddSpace(1, 1);
S.Prop(1);
S.AddWindow(mdBRuler, wxALIGN_RIGHT | wxTOP);
S.AddSpace(1, 1);
}
S.EndVerticalLay();
mPanel = new EffectScienFilterPanel(this, parent);
mPanel->SetFreqRange(mLoFreq, mNyquist);
S.SetBorder(5);
S.Prop(1);
S.AddWindow(mPanel, wxEXPAND | wxRIGHT);
S.SetSizeHints(-1, -1);
S.StartVerticalLay();
{
S.AddVariableText(_("+ dB"), false, wxCENTER);
S.SetStyle(wxSL_VERTICAL | wxSL_INVERSE);
mdBMaxSlider = S.Id(ID_dBMax).AddSlider(wxT(""), 10, 20, 0);
#if wxUSE_ACCESSIBILITY
mdBMaxSlider->SetName(_("Max dB"));
mdBMaxSlider->SetAccessible(new SliderAx(mdBMaxSlider, wxString(wxT("%d ")) + _("dB")));
#endif
S.SetStyle(wxSL_VERTICAL | wxSL_INVERSE);
mdBMinSlider = S.Id(ID_dBMin).AddSlider(wxT(""), -10, -10, -120);
S.AddVariableText(_("- dB"), false, wxCENTER);
#if wxUSE_ACCESSIBILITY
mdBMinSlider->SetName(_("Min dB"));
mdBMinSlider->SetAccessible(new SliderAx(mdBMinSlider, wxString(wxT("%d ")) + _("dB")));
#endif
}
S.EndVerticalLay();
// -------------------------------------------------------------------
// ROW 2: Frequency ruler
// -------------------------------------------------------------------
S.AddSpace(1, 1);
mfreqRuler = new RulerPanel(parent, wxID_ANY);
mfreqRuler->ruler.SetBounds(0, 0, 100, 100); // Ruler can't handle small sizes
mfreqRuler->ruler.SetOrientation(wxHORIZONTAL);
mfreqRuler->ruler.SetLog(true);
mfreqRuler->ruler.SetRange(mLoFreq, mNyquist);
mfreqRuler->ruler.SetFormat(Ruler::IntFormat);
mfreqRuler->ruler.SetUnits(wxT(""));
mfreqRuler->ruler.SetFlip(true);
mfreqRuler->ruler.SetLabelEdges(true);
int h;
mfreqRuler->ruler.GetMaxSize(NULL, &h);
mfreqRuler->SetMinSize(wxSize(-1, h));
S.Prop(1);
S.AddWindow(mfreqRuler, wxEXPAND | wxALIGN_LEFT | wxRIGHT);
S.AddSpace(1, 1);
// -------------------------------------------------------------------
// ROW 3 and 4: Type, Order, Ripple, Subtype, Cutoff
// -------------------------------------------------------------------
S.AddSpace(1, 1);
S.SetSizerProportion(0);
S.StartMultiColumn(8, wxALIGN_CENTER);
{
wxASSERT(kNumTypes == WXSIZEOF(kTypeStrings));
wxArrayString typeChoices;
for (int i = 0; i < kNumTypes; i++)
{
typeChoices.Add(wxGetTranslation(kTypeStrings[i]));
}
mFilterTypeCtl = S.Id(ID_Type).AddChoice(_("&Filter Type:"), wxT(""), &typeChoices);
mFilterTypeCtl->SetValidator(wxGenericValidator(&mFilterType));
S.SetSizeHints(-1, -1);
wxArrayString orders;
for (int i = 1; i <= 10; i++)
{
orders.Add(wxString::Format(wxT("%d"), i));
}
/*i18n-hint: 'Order' means the complexity of the filter, and is a number between 1 and 10.*/
mFilterOrderCtl = S.Id(ID_Order).AddChoice(_("O&rder:"), wxT(""), &orders);
mFilterOrderCtl->SetValidator(wxGenericValidator(&mOrderIndex));
S.SetSizeHints(-1, -1);
S.AddSpace(1, 1);
FloatingPointValidator<float> vldRipple(1, &mRipple);
vldRipple.SetRange(MIN_Passband, MAX_Passband);
mRippleCtlP = S.AddVariableText(_("&Passband Ripple:"), false, wxALL | wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
mRippleCtl = S.Id(ID_Ripple).AddTextBox(wxT(""), wxT(""), 10);
mRippleCtl->SetName(_("Passband Ripple (dB)"));
mRippleCtl->SetValidator(vldRipple);
mRippleCtlU = S.AddVariableText(_("dB"), false, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
wxASSERT(kNumSubTypes == WXSIZEOF(kSubTypeStrings));
wxArrayString subTypeChoices;
for (int i = 0; i < kNumSubTypes; i++)
{
subTypeChoices.Add(wxGetTranslation(kSubTypeStrings[i]));
}
mFilterSubTypeCtl = S.Id(ID_SubType).AddChoice(_("&Subtype:"), wxT(""), &subTypeChoices);
mFilterSubTypeCtl->SetValidator(wxGenericValidator(&mFilterSubtype));
S.SetSizeHints(-1, -1);
FloatingPointValidator<float> vldCutoff(1, &mCutoff);
vldCutoff.SetRange(MIN_Cutoff, mNyquist - 1);
mCutoffCtl = S.Id(ID_Cutoff).AddTextBox(_("C&utoff:"), wxT(""), 10);
mCutoffCtl->SetName(_("Cutoff (Hz)"));
mCutoffCtl->SetValidator(vldCutoff);
S.AddUnits(_("Hz"));
FloatingPointValidator<float> vldStopbandRipple(1, &mStopbandRipple);
vldStopbandRipple.SetRange(MIN_Stopband, MAX_Stopband);
mStopbandRippleCtlP = S.AddVariableText(_("Minimum S&topband Attenuation:"), false, wxALL | wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
mStopbandRippleCtl = S.Id(ID_StopbandRipple).AddTextBox(wxT(""), wxT(""), 10);
mStopbandRippleCtl->SetName(_("Minimum S&topband Attenuation (dB)"));
mStopbandRippleCtl->SetValidator(vldStopbandRipple);
mStopbandRippleCtlU = S.AddVariableText(_("dB"), false, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
}
S.EndMultiColumn();
S.AddSpace(1, 1);
}
S.EndMultiColumn();
mFilterTypeCtl->SetFocus();
return;
}
