audacia
/
audacia
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Pass array and count separately to read/write/define enum

This commit is contained in:
Paul Licameli 2018-03-26 21:06:35 -04:00
parent 180cf92790
commit 81dd580c57
19 changed files with 91 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
include/audacity/EffectAutomationParameters.h
View File

@ -161,7 +161,8 @@ public:
// list of non-obsolete names. // list of non-obsolete names.
using ObsoleteMap = std::pair< wxString, size_t >; using ObsoleteMap = std::pair< wxString, size_t >;
bool ReadEnum(const wxString & key, int *pi, const wxArrayString & choices, bool ReadEnum(const wxString & key, int *pi,
const wxString choices[], size_t nChoices,
const ObsoleteMap obsoletes[] = nullptr, const ObsoleteMap obsoletes[] = nullptr,
size_t nObsoletes = 0) const size_t nObsoletes = 0) const
{ {
@ -170,7 +171,10 @@ public:
{ {
return false; return false;
} }
*pi = choices.Index(s); *pi = std::find( choices, choices + nChoices,
s ) - choices;
if (*pi == nChoices)
*pi = -1;
if (*pi < 0 && obsoletes) { if (*pi < 0 && obsoletes) {
auto index = std::find_if(obsoletes, obsoletes + nObsoletes, auto index = std::find_if(obsoletes, obsoletes + nObsoletes,
[&](const ObsoleteMap &entry){ [&](const ObsoleteMap &entry){
@ -183,20 +187,21 @@ public:
} }
bool ReadEnum(const wxString & key, int *pi, int defVal, bool ReadEnum(const wxString & key, int *pi, int defVal,
const wxArrayString & choices, const wxString choices[], size_t nChoices,
const ObsoleteMap obsoletes[] = nullptr, const ObsoleteMap obsoletes[] = nullptr,
size_t nObsoletes = 0) const size_t nObsoletes = 0) const
{ {
if (!ReadEnum(key, pi, choices, obsoletes, nObsoletes)) if (!ReadEnum(key, pi, choices, nChoices, obsoletes, nObsoletes))
{ {
*pi = defVal; *pi = defVal;
} }
return true; return true;
} }
bool WriteEnum(const wxString & key, int value, const wxArrayString & choices) bool WriteEnum(const wxString & key, int value,
const wxString choices[], size_t nChoices)
{ {
if (value < 0 || value >= (int) choices.GetCount()) if (value < 0 || value >= nChoices)
{ {
return false; return false;
} }
@ -241,11 +246,11 @@ public:
} }
bool ReadAndVerify(const wxString & key, int *val, int defVal, bool ReadAndVerify(const wxString & key, int *val, int defVal,
const wxArrayString & choices, const wxString choices[], size_t nChoices,
const ObsoleteMap obsoletes[] = nullptr, const ObsoleteMap obsoletes[] = nullptr,
size_t nObsoletes = 0) const size_t nObsoletes = 0) const
{ {
ReadEnum(key, val, defVal, choices, obsoletes, nObsoletes); ReadEnum(key, val, defVal, choices, nChoices, obsoletes, nObsoletes);
return (*val != wxNOT_FOUND); return (*val != wxNOT_FOUND);
} }

17
src/Shuttle.cpp
View File

@ -343,12 +343,12 @@ void ShuttleParams::Define( float & var, const wxChar * key, const float vdef
void ShuttleParams::Define( double & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl ){;}; void ShuttleParams::Define( double & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl ){;};
void ShuttleParams::Define( double & var, const wxChar * key, const double vdefault, const double vmin, const double vmax, const double vscl ){;}; void ShuttleParams::Define( double & var, const wxChar * key, const double vdefault, const double vmin, const double vmax, const double vscl ){;};
void ShuttleParams::Define( wxString &var, const wxChar * key, const wxString vdefault, const wxString vmin, const wxString vmax, const wxString vscl ){;}; void ShuttleParams::Define( wxString &var, const wxChar * key, const wxString vdefault, const wxString vmin, const wxString vmax, const wxString vscl ){;};
void ShuttleParams::DefineEnum( int &var, const wxChar * key, const int vdefault, wxArrayString strings ){;}; void ShuttleParams::DefineEnum( int &var, const wxChar * key, const int vdefault, const wxString strings[], size_t nStrings ){;};
/* /*
void ShuttleParams::DefineEnum( int &var, const wxChar * key, const int vdefault, wxArrayString strings ) void ShuttleParams::DefineEnum( int &var, const wxChar * key, const int vdefault, const IdentInterfaceSymbol strings[], size_t nStrings )
{ {
} }
*/ */
@ -402,7 +402,8 @@ void ShuttleGetAutomation::Define( wxString &var, const wxChar * key, const wxSt
mpEap->Write(key, var); mpEap->Write(key, var);
} }
void ShuttleGetAutomation::DefineEnum( int &var, const wxChar * key, const int vdefault, wxArrayString strings )
void ShuttleGetAutomation::DefineEnum( int &var, const wxChar * key, const int vdefault, const wxString strings[], size_t nStrings )
{ {
if( !ShouldSet() ) return; if( !ShouldSet() ) return;
mpEap->Write(key, strings[var]); mpEap->Write(key, strings[var]);
@ -512,13 +513,13 @@ void ShuttleSetAutomation::Define( wxString &var, const wxChar * key, const wxSt
} }
void ShuttleSetAutomation::DefineEnum( int &var, const wxChar * key, const int vdefault, wxArrayString strings ) void ShuttleSetAutomation::DefineEnum( int &var, const wxChar * key, const int vdefault, const wxString strings[], size_t nStrings )
{ {
CouldGet( key ); CouldGet( key );
if( !bOK ) if( !bOK )
return; return;
int temp = var; int temp = var;
bOK = mpEap->ReadAndVerify(key, &temp, vdefault, strings); bOK = mpEap->ReadAndVerify(key, &temp, vdefault, strings, nStrings);
if( bWrite && bOK) if( bWrite && bOK)
var = temp; var = temp;
} }
@ -627,7 +628,9 @@ void ShuttleGetDefinition::Define( wxString &var, const wxChar * key, const wxSt
} }
void ShuttleGetDefinition::DefineEnum( int&var, const wxChar * key, const int vdefault, wxArrayString strings ) void ShuttleGetDefinition::DefineEnum( int &var,
const wxChar * key, const int vdefault,
const wxString strings[], size_t nStrings )
{ {
StartStruct(); StartStruct();
AddItem( wxString(key), "key" ); AddItem( wxString(key), "key" );
@ -638,7 +641,7 @@ void ShuttleGetDefinition::DefineEnum( int&var, const wxChar * key, const int vd
AddItem( strings[vdefault], "default" ); AddItem( strings[vdefault], "default" );
StartField( "enum" ); StartField( "enum" );
StartArray(); StartArray();
for( size_t i=0;i<strings.Count(); i++ ) for( size_t i = 0; i < nStrings; i++ )
AddItem( strings[i] ); AddItem( strings[i] );
EndArray(); EndArray();
EndField(); EndField();

20
src/Shuttle.h
View File

@ -75,7 +75,8 @@ public:
virtual void Define( double & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl=1.0f ); virtual void Define( double & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl=1.0f );
virtual void Define( double & var, const wxChar * key, const double vdefault, const double vmin, const double vmax, const double vscl=1.0f ); virtual void Define( double & var, const wxChar * key, const double vdefault, const double vmin, const double vmax, const double vscl=1.0f );
virtual void Define( wxString &var, const wxChar * key, const wxString vdefault, const wxString vmin="", const wxString vmax="", const wxString vscl="" ); virtual void Define( wxString &var, const wxChar * key, const wxString vdefault, const wxString vmin="", const wxString vmax="", const wxString vscl="" );
virtual void DefineEnum( int &var, const wxChar * key, const int vdefault, wxArrayString strings ); virtual void DefineEnum( int &var, const wxChar * key, const int vdefault,
const wxString strings[], size_t nStrings );
}; };
/**************************************************************************//** /**************************************************************************//**
@ -92,7 +93,8 @@ public:
void Define( double & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl ) override; void Define( double & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl ) override;
void Define( double & var, const wxChar * key, const double vdefault, const double vmin, const double vmax, const double vscl ) override; void Define( double & var, const wxChar * key, const double vdefault, const double vmin, const double vmax, const double vscl ) override;
void Define( wxString &var, const wxChar * key, const wxString vdefault, const wxString vmin, const wxString vmax, const wxString vscl ) override; void Define( wxString &var, const wxChar * key, const wxString vdefault, const wxString vmin, const wxString vmax, const wxString vscl ) override;
void DefineEnum( int &var, const wxChar * key, const int vdefault, wxArrayString strings )override; void DefineEnum( int &var, const wxChar * key, const int vdefault,
const wxString strings[], size_t nStrings ) override;
}; };
/**************************************************************************//** /**************************************************************************//**
@ -115,7 +117,8 @@ public:
void Define( double & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl ) override; void Define( double & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl ) override;
void Define( double & var, const wxChar * key, const double vdefault, const double vmin, const double vmax, const double vscl ) override; void Define( double & var, const wxChar * key, const double vdefault, const double vmin, const double vmax, const double vscl ) override;
void Define( wxString &var, const wxChar * key, const wxString vdefault, const wxString vmin, const wxString vmax, const wxString vscl ) override; void Define( wxString &var, const wxChar * key, const wxString vdefault, const wxString vmin, const wxString vmax, const wxString vscl ) override;
void DefineEnum( int &var, const wxChar * key, const int vdefault, wxArrayString strings )override; void DefineEnum( int &var, const wxChar * key, const int vdefault,
const wxString strings[], size_t nStrings ) override;
}; };
/**************************************************************************//** /**************************************************************************//**
@ -135,7 +138,8 @@ public:
void Define( double & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl ) override; void Define( double & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl ) override;
void Define( double & var, const wxChar * key, const double vdefault, const double vmin, const double vmax, const double vscl ) override; void Define( double & var, const wxChar * key, const double vdefault, const double vmin, const double vmax, const double vscl ) override;
void Define( wxString &var, const wxChar * key, const wxString vdefault, const wxString vmin, const wxString vmax, const wxString vscl ) override; void Define( wxString &var, const wxChar * key, const wxString vdefault, const wxString vmin, const wxString vmax, const wxString vscl ) override;
void DefineEnum( int &var, const wxChar * key, const int vdefault, wxArrayString strings )override; void DefineEnum( int &var, const wxChar * key, const int vdefault,
const wxString strings[], size_t nStrings ) override;
}; };
@ -171,8 +175,8 @@ public:
void Define( wxString &var, const wxChar * WXUNUSED(key), const wxString vdefault, void Define( wxString &var, const wxChar * WXUNUSED(key), const wxString vdefault,
const wxString WXUNUSED(vmin), const wxString WXUNUSED(vmax), const wxString WXUNUSED(vscl) ) const wxString WXUNUSED(vmin), const wxString WXUNUSED(vmax), const wxString WXUNUSED(vscl) )
override { var = vdefault;}; override { var = vdefault;};
void DefineEnum( int &var, const wxChar * WXUNUSED(key), const int vdefault, void DefineEnum( int &var, const wxChar * WXUNUSED(key), const int vdefault,
wxArrayString WXUNUSED(strings) ) const wxString WXUNUSED(strings) [], size_t WXUNUSED( nStrings ) )
override { var = vdefault;}; override { var = vdefault;};
}; };
@ -184,7 +188,7 @@ public:
#define SHUTTLE_PARAM( var, name ) \ #define SHUTTLE_PARAM( var, name ) \
Define( var, KEY_ ## name, DEF_ ## name, MIN_ ## name, MAX_ ## name, SCL_ ## name ) Define( var, KEY_ ## name, DEF_ ## name, MIN_ ## name, MAX_ ## name, SCL_ ## name )
#define SHUTTLE_ENUM_PARAM( var, name, strings ) \ #define SHUTTLE_ENUM_PARAM( var, name, strings, nStrings ) \
DefineEnum( var, KEY_ ## name, DEF_ ## name, strings ) DefineEnum( var, KEY_ ## name, DEF_ ## name, strings, nStrings )
#endif #endif

3
src/commands/DragCommand.cpp
View File

@ -48,14 +48,13 @@ static const wxString kCoordTypeStrings[nCoordTypes] =
bool DragCommand::DefineParams( ShuttleParams & S ){ bool DragCommand::DefineParams( ShuttleParams & S ){
wxArrayString coords( nCoordTypes, kCoordTypeStrings );
S.OptionalN( bHasId ).Define( mId, wxT("Id"), 11000.0, -100000.0, 1000000.0); S.OptionalN( bHasId ).Define( mId, wxT("Id"), 11000.0, -100000.0, 1000000.0);
S.OptionalY( bHasWinName ).Define( mWinName, wxT("Window"), "Timeline"); S.OptionalY( bHasWinName ).Define( mWinName, wxT("Window"), "Timeline");
S.OptionalY( bHasFromX ).Define( mFromX, wxT("FromX"), 200.0, 0.0, 1000000.0); S.OptionalY( bHasFromX ).Define( mFromX, wxT("FromX"), 200.0, 0.0, 1000000.0);
S.OptionalY( bHasFromY ).Define( mFromY, wxT("FromY"), 10.0, 0.0, 1000000.0); S.OptionalY( bHasFromY ).Define( mFromY, wxT("FromY"), 10.0, 0.0, 1000000.0);
S.OptionalN( bHasToX ).Define( mToX, wxT("ToX"), 400.0, 0.0, 1000000.0); S.OptionalN( bHasToX ).Define( mToX, wxT("ToX"), 400.0, 0.0, 1000000.0);
S.OptionalN( bHasToY ).Define( mToY, wxT("ToY"), 10.0, 0.0, 1000000.0); S.OptionalN( bHasToY ).Define( mToY, wxT("ToY"), 10.0, 0.0, 1000000.0);
S.OptionalN( bHasRelativeTo ).DefineEnum( mRelativeTo, wxT("RelativeTo"), kPanel, coords ); S.OptionalN( bHasRelativeTo ).DefineEnum( mRelativeTo, wxT("RelativeTo"), kPanel, kCoordTypeStrings, nCoordTypes );
return true; return true;
}; };

6
src/commands/GetInfoCommand.cpp
View File

@ -85,10 +85,8 @@ static const wxString kFormats[nFormats] =
bool GetInfoCommand::DefineParams( ShuttleParams & S ){ bool GetInfoCommand::DefineParams( ShuttleParams & S ){
wxArrayString types( nTypes, kTypes ); S.DefineEnum( mInfoType, wxT("Type"), 0, kTypes, nTypes );
wxArrayString formats( nFormats, kFormats ); S.DefineEnum( mFormat, wxT("Format"), 0, kFormats, nFormats );
S.DefineEnum( mInfoType, wxT("Type"), 0, types );
S.DefineEnum( mFormat, wxT("Format"), 0, formats );
return true; return true;
} }

3
src/commands/GetTrackInfoCommand.cpp
View File

@ -40,8 +40,7 @@ GetTrackInfoCommand::GetTrackInfoCommand()
} }
bool GetTrackInfoCommand::DefineParams( ShuttleParams & S ){ bool GetTrackInfoCommand::DefineParams( ShuttleParams & S ){
wxArrayString types( nTypes, kTypes ); S.DefineEnum( mInfoType, wxT("Type"), 0, kTypes, nTypes );
S.DefineEnum( mInfoType, wxT("Type"), 0, types );
return true; return true;
} }

6
src/commands/ScreenshotCommand.cpp
View File

@ -92,11 +92,9 @@ static const wxString kBackgroundStrings[ ScreenshotCommand::nBackgrounds ] =
bool ScreenshotCommand::DefineParams( ShuttleParams & S ){ bool ScreenshotCommand::DefineParams( ShuttleParams & S ){
wxArrayString whats(nCaptureWhats, kCaptureWhatStrings);
wxArrayString backs(nBackgrounds, kBackgroundStrings);
S.Define( mPath, wxT("Path"), wxT("")); S.Define( mPath, wxT("Path"), wxT(""));
S.DefineEnum( mWhat, wxT("CaptureWhat"), kwindow, whats ); S.DefineEnum( mWhat, wxT("CaptureWhat"), kwindow,kCaptureWhatStrings, nCaptureWhats );
S.OptionalN(bHasBackground).DefineEnum( mBack, wxT("Background"), kNone, backs ); S.OptionalN(bHasBackground).DefineEnum( mBack, wxT("Background"), kNone, kBackgroundStrings, nBackgrounds );
S.OptionalN(bHasBringToTop).Define( mbBringToTop, wxT("ToTop"), true ); S.OptionalN(bHasBringToTop).Define( mbBringToTop, wxT("ToTop"), true );
return true; return true;
}; };

6
src/commands/SelectCommand.cpp
View File

@ -55,12 +55,11 @@ static const wxString kRelativeTo[nRelativeTos] =
}; };
bool SelectTimeCommand::DefineParams( ShuttleParams & S ){ bool SelectTimeCommand::DefineParams( ShuttleParams & S ){
wxArrayString relativeSpec( nRelativeTos, kRelativeTo );
// Allow selection down to -ve 100seconds. // Allow selection down to -ve 100seconds.
// Typically used to expand/contract selections by a small amount. // Typically used to expand/contract selections by a small amount.
S.OptionalY( bHasT0 ).Define( mT0, wxT("Start"), 0.0, -100.0, (double)FLT_MAX); S.OptionalY( bHasT0 ).Define( mT0, wxT("Start"), 0.0, -100.0, (double)FLT_MAX);
S.OptionalY( bHasT1 ).Define( mT1, wxT("End"), 0.0, -100.0, (double)FLT_MAX); S.OptionalY( bHasT1 ).Define( mT1, wxT("End"), 0.0, -100.0, (double)FLT_MAX);
S.OptionalN( bHasRelativeSpec ).DefineEnum( mRelativeTo, wxT("RelativeTo"), 0, relativeSpec ); S.OptionalN( bHasRelativeSpec ).DefineEnum( mRelativeTo, wxT("RelativeTo"), 0, kRelativeTo, nRelativeTos );
return true; return true;
} }
@ -177,10 +176,9 @@ static const wxString kModes[nModes] =
}; };
bool SelectTracksCommand::DefineParams( ShuttleParams & S ){ bool SelectTracksCommand::DefineParams( ShuttleParams & S ){
wxArrayString modes( nModes, kModes );
S.OptionalN( bHasFirstTrack).Define( mFirstTrack, wxT("Track"), 0.0, 0.0, 100.0); S.OptionalN( bHasFirstTrack).Define( mFirstTrack, wxT("Track"), 0.0, 0.0, 100.0);
S.OptionalN( bHasNumTracks ).Define( mNumTracks, wxT("TrackCount"), 1.0, 0.0, 100.0); S.OptionalN( bHasNumTracks ).Define( mNumTracks, wxT("TrackCount"), 1.0, 0.0, 100.0);
S.OptionalY( bHasMode ).DefineEnum( mMode, wxT("Mode"), 0, modes ); S.OptionalY( bHasMode ).DefineEnum( mMode, wxT("Mode"), 0, kModes, nModes );
return true; return true;
} }

3
src/commands/SetClipCommand.cpp
View File

@ -48,9 +48,8 @@ static const wxString kColourStrings[nColours] =
bool SetClipCommand::DefineParams( ShuttleParams & S ){ bool SetClipCommand::DefineParams( ShuttleParams & S ){
wxArrayString colours( nColours, kColourStrings );
S.OptionalY( bHasContainsTime ).Define( mContainsTime, wxT("At"), 0.0, 0.0, 100000.0 ); S.OptionalY( bHasContainsTime ).Define( mContainsTime, wxT("At"), 0.0, 0.0, 100000.0 );
S.OptionalN( bHasColour ).DefineEnum( mColour, wxT("Color"), kColour0, colours ); S.OptionalN( bHasColour ).DefineEnum( mColour, wxT("Color"), kColour0, kColourStrings, nColours );
// Allowing a negative start time is not a mistake. // Allowing a negative start time is not a mistake.
// It will be used in demonstrating time before zero. // It will be used in demonstrating time before zero.
S.OptionalN( bHasT0 ).Define( mT0, wxT("Start"), 0.0, -5.0, 1000000.0); S.OptionalN( bHasT0 ).Define( mT0, wxT("Start"), 0.0, -5.0, 1000000.0);

13
src/commands/SetTrackInfoCommand.cpp
View File

@ -287,17 +287,12 @@ static const wxString kZoomTypeStrings[nZoomTypes] =
}; };
bool SetTrackVisualsCommand::DefineParams( ShuttleParams & S ){ bool SetTrackVisualsCommand::DefineParams( ShuttleParams & S ){
wxArrayString colours( nColours, kColourStrings );
wxArrayString displays( nDisplayTypes, kDisplayTypeStrings );
wxArrayString scales( nScaleTypes, kScaleTypeStrings );
wxArrayString vzooms( nZoomTypes, kZoomTypeStrings );
SetTrackBase::DefineParams( S ); SetTrackBase::DefineParams( S );
S.OptionalN( bHasHeight ).Define( mHeight, wxT("Height"), 120, 44, 700 ); S.OptionalN( bHasHeight ).Define( mHeight, wxT("Height"), 120, 44, 700 );
S.OptionalN( bHasDisplayType ).DefineEnum( mDisplayType, wxT("Display"), kWaveform, displays ); S.OptionalN( bHasDisplayType ).DefineEnum( mDisplayType, wxT("Display"), kWaveform, kDisplayTypeStrings, nDisplayTypes );
S.OptionalN( bHasScaleType ).DefineEnum( mScaleType, wxT("Scale"), kLinear, scales ); S.OptionalN( bHasScaleType ).DefineEnum( mScaleType, wxT("Scale"), kLinear, kScaleTypeStrings, nScaleTypes );
S.OptionalN( bHasColour ).DefineEnum( mColour, wxT("Color"), kColour0, colours ); S.OptionalN( bHasColour ).DefineEnum( mColour, wxT("Color"), kColour0, kColourStrings, nColours );
S.OptionalN( bHasVZoom ).DefineEnum( mVZoom, wxT("VZoom"), kReset, vzooms ); S.OptionalN( bHasVZoom ).DefineEnum( mVZoom, wxT("VZoom"), kReset, kZoomTypeStrings, nZoomTypes );
S.OptionalN( bHasUseSpecPrefs ).Define( bUseSpecPrefs, wxT("SpecPrefs"), false ); S.OptionalN( bHasUseSpecPrefs ).Define( bUseSpecPrefs, wxT("SpecPrefs"), false );
S.OptionalN( bHasSpectralSelect ).Define( bSpectralSelect, wxT("SpectralSel"),true ); S.OptionalN( bHasSpectralSelect ).Define( bSpectralSelect, wxT("SpectralSel"),true );

6
src/effects/Distortion.cpp
View File

@ -280,8 +280,8 @@ size_t EffectDistortion::RealtimeProcess(int group,
return InstanceProcess(mSlaves[group], inbuf, outbuf, numSamples); return InstanceProcess(mSlaves[group], inbuf, outbuf, numSamples);
} }
bool EffectDistortion::DefineParams( ShuttleParams & S ){ bool EffectDistortion::DefineParams( ShuttleParams & S ){
wxArrayString tables( nTableTypes, kTableTypeStrings ); S.SHUTTLE_ENUM_PARAM( mParams.mTableChoiceIndx, TableTypeIndx,
S.SHUTTLE_ENUM_PARAM( mParams.mTableChoiceIndx, TableTypeIndx, tables ); kTableTypeStrings, nTableTypes );
S.SHUTTLE_PARAM( mParams.mDCBlock, DCBlock ); S.SHUTTLE_PARAM( mParams.mDCBlock, DCBlock );
S.SHUTTLE_PARAM( mParams.mThreshold_dB, Threshold_dB ); S.SHUTTLE_PARAM( mParams.mThreshold_dB, Threshold_dB );
S.SHUTTLE_PARAM( mParams.mNoiseFloor, NoiseFloor ); S.SHUTTLE_PARAM( mParams.mNoiseFloor, NoiseFloor );
@ -306,7 +306,7 @@ bool EffectDistortion::GetAutomationParameters(CommandParameters & parms)
bool EffectDistortion::SetAutomationParameters(CommandParameters & parms) bool EffectDistortion::SetAutomationParameters(CommandParameters & parms)
{ {
ReadAndVerifyEnum(TableTypeIndx, wxArrayString(nTableTypes, kTableTypeStrings)); ReadAndVerifyEnum(TableTypeIndx, kTableTypeStrings, nTableTypes);
ReadAndVerifyBool(DCBlock); ReadAndVerifyBool(DCBlock);
ReadAndVerifyDouble(Threshold_dB); ReadAndVerifyDouble(Threshold_dB);
ReadAndVerifyDouble(NoiseFloor); ReadAndVerifyDouble(NoiseFloor);

8
src/effects/Effect.h
View File

@ -787,15 +787,15 @@ inline long TrapLong(long x, long min, long max)
if (!parms.ReadAndVerify(KEY_ ## name, &name, DEF_ ## name)) \ if (!parms.ReadAndVerify(KEY_ ## name, &name, DEF_ ## name)) \
return false; return false;
#define ReadAndVerifyEnum(name, list) \ #define ReadAndVerifyEnum(name, list, listSize) \
int name; \ int name; \
if (!parms.ReadAndVerify(KEY_ ## name, &name, DEF_ ## name, list)) \ if (!parms.ReadAndVerify(KEY_ ## name, &name, DEF_ ## name, list, listSize)) \
return false; return false;
#define ReadAndVerifyEnumWithObsoletes(name, list, obsoleteList, nObsolete) \ #define ReadAndVerifyEnumWithObsoletes(name, list, listSize, obsoleteList, nObsolete) \
int name; \ int name; \
if (!parms.ReadAndVerify(KEY_ ## name, &name, DEF_ ## name, \ if (!parms.ReadAndVerify(KEY_ ## name, &name, DEF_ ## name, \
list, obsoleteList, nObsolete)) \ list, listSize, obsoleteList, nObsolete)) \
return false; return false;
#define ReadAndVerifyInt(name) ReadParam(int, name) #define ReadAndVerifyInt(name) ReadParam(int, name)

7
src/effects/Equalization.cpp
View File

@ -309,11 +309,10 @@ EffectType EffectEqualization::GetType()
// EffectClientInterface implementation // EffectClientInterface implementation
bool EffectEqualization::DefineParams( ShuttleParams & S ){ bool EffectEqualization::DefineParams( ShuttleParams & S ){
wxArrayString interp(nInterpolations, kInterpStrings);
S.SHUTTLE_PARAM( mM, FilterLength ); S.SHUTTLE_PARAM( mM, FilterLength );
S.SHUTTLE_PARAM( mCurveName, CurveName); S.SHUTTLE_PARAM( mCurveName, CurveName);
S.SHUTTLE_PARAM( mLin, InterpLin); S.SHUTTLE_PARAM( mLin, InterpLin);
S.SHUTTLE_ENUM_PARAM( mInterp, InterpMeth, interp ); S.SHUTTLE_ENUM_PARAM( mInterp, InterpMeth, kInterpStrings, nInterpolations );
return true; return true;
} }
@ -323,7 +322,7 @@ bool EffectEqualization::GetAutomationParameters(CommandParameters & parms)
parms.Write(KEY_FilterLength, (unsigned long)mM); parms.Write(KEY_FilterLength, (unsigned long)mM);
parms.Write(KEY_CurveName, mCurveName); parms.Write(KEY_CurveName, mCurveName);
parms.Write(KEY_InterpLin, mLin); parms.Write(KEY_InterpLin, mLin);
parms.WriteEnum(KEY_InterpMeth, mInterp, wxArrayString(nInterpolations, kInterpStrings)); parms.WriteEnum(KEY_InterpMeth, mInterp, kInterpStrings, nInterpolations);
return true; return true;
} }
@ -341,7 +340,7 @@ bool EffectEqualization::SetAutomationParameters(CommandParameters & parms)
ReadAndVerifyInt(FilterLength); ReadAndVerifyInt(FilterLength);
ReadAndVerifyString(CurveName); ReadAndVerifyString(CurveName);
ReadAndVerifyBool(InterpLin); ReadAndVerifyBool(InterpLin);
ReadAndVerifyEnum(InterpMeth, interpolations); ReadAndVerifyEnum(InterpMeth, kInterpStrings, nInterpolations);
mM = FilterLength; mM = FilterLength;
mCurveName = CurveName; mCurveName = CurveName;

7
src/effects/Noise.cpp
View File

@ -35,7 +35,7 @@ enum kTypes
nTypes nTypes
}; };
static const wxChar *kTypeStrings[nTypes] = static const wxString kTypeStrings[nTypes] =
{ {
XO("White"), XO("White"),
XO("Pink"), XO("Pink"),
@ -162,8 +162,7 @@ size_t EffectNoise::ProcessBlock(float **WXUNUSED(inbuf), float **outbuf, size_t
return size; return size;
} }
bool EffectNoise::DefineParams( ShuttleParams & S ){ bool EffectNoise::DefineParams( ShuttleParams & S ){
wxArrayString types( nTypes, kTypeStrings ); S.SHUTTLE_ENUM_PARAM( mType, Type, kTypeStrings, nTypes );
S.SHUTTLE_ENUM_PARAM( mType, Type, types );
S.SHUTTLE_PARAM( mAmp, Amp ); S.SHUTTLE_PARAM( mAmp, Amp );
return true; return true;
} }
@ -178,7 +177,7 @@ bool EffectNoise::GetAutomationParameters(CommandParameters & parms)
bool EffectNoise::SetAutomationParameters(CommandParameters & parms) bool EffectNoise::SetAutomationParameters(CommandParameters & parms)
{ {
ReadAndVerifyEnum(Type, wxArrayString(nTypes, kTypeStrings)); ReadAndVerifyEnum(Type, kTypeStrings, nTypes);
ReadAndVerifyDouble(Amp); ReadAndVerifyDouble(Amp);
mType = Type; mType = Type;

14
src/effects/ScienFilter.cpp
View File

@ -86,7 +86,7 @@ enum kTypes
nTypes nTypes
}; };
static const wxChar *kTypeStrings[nTypes] = static const wxString kTypeStrings[nTypes] =
{ {
/*i18n-hint: Butterworth is the name of the person after whom the filter type is named.*/ /*i18n-hint: Butterworth is the name of the person after whom the filter type is named.*/
XO("Butterworth"), XO("Butterworth"),
@ -103,7 +103,7 @@ enum kSubTypes
nSubTypes nSubTypes
}; };
static const wxChar *kSubTypeStrings[nSubTypes] = static const wxString kSubTypeStrings[nSubTypes] =
{ {
XO("Lowpass"), XO("Lowpass"),
XO("Highpass") XO("Highpass")
@ -241,10 +241,8 @@ size_t EffectScienFilter::ProcessBlock(float **inBlock, float **outBlock, size_t
return blockLen; return blockLen;
} }
bool EffectScienFilter::DefineParams( ShuttleParams & S ){ bool EffectScienFilter::DefineParams( ShuttleParams & S ){
wxArrayString filters( nTypes, kTypeStrings ); S.SHUTTLE_ENUM_PARAM( mFilterType, Type, kTypeStrings, nTypes );
wxArrayString subtypes( nSubTypes, kSubTypeStrings ); S.SHUTTLE_ENUM_PARAM( mFilterSubtype, Subtype, kSubTypeStrings, nSubTypes );
S.SHUTTLE_ENUM_PARAM( mFilterType, Type, filters );
S.SHUTTLE_ENUM_PARAM( mFilterSubtype, Subtype, subtypes );
S.SHUTTLE_PARAM( mOrder, Order ); S.SHUTTLE_PARAM( mOrder, Order );
S.SHUTTLE_PARAM( mCutoff, Cutoff ); S.SHUTTLE_PARAM( mCutoff, Cutoff );
S.SHUTTLE_PARAM( mRipple, Passband ); S.SHUTTLE_PARAM( mRipple, Passband );
@ -266,8 +264,8 @@ bool EffectScienFilter::GetAutomationParameters(CommandParameters & parms)
bool EffectScienFilter::SetAutomationParameters(CommandParameters & parms) bool EffectScienFilter::SetAutomationParameters(CommandParameters & parms)
{ {
ReadAndVerifyEnum(Type, wxArrayString(nTypes, kTypeStrings)); ReadAndVerifyEnum(Type, kTypeStrings, nTypes);
ReadAndVerifyEnum(Subtype, wxArrayString(nSubTypes, kSubTypeStrings)); ReadAndVerifyEnum(Subtype, kSubTypeStrings, nSubTypes);
ReadAndVerifyInt(Order); ReadAndVerifyInt(Order);
ReadAndVerifyFloat(Cutoff); ReadAndVerifyFloat(Cutoff);
ReadAndVerifyFloat(Passband); ReadAndVerifyFloat(Passband);

10
src/effects/ToneGen.cpp
View File

@ -267,10 +267,8 @@ bool EffectToneGen::DefineParams( ShuttleParams & S ){
mFrequency[1] = mFrequency[0]; mFrequency[1] = mFrequency[0];
mAmplitude[1] = mAmplitude[0]; mAmplitude[1] = mAmplitude[0];
} }
wxArrayString waves( nWaveforms, kWaveStrings ); S.SHUTTLE_ENUM_PARAM( mWaveform, Waveform, kWaveStrings, nWaveforms );
wxArrayString interps( nInterpolations ,kInterStrings ); S.SHUTTLE_ENUM_PARAM( mInterpolation, Interp, kInterStrings, nInterpolations );
S.SHUTTLE_ENUM_PARAM( mWaveform, Waveform, waves );
S.SHUTTLE_ENUM_PARAM( mInterpolation, Interp, interps );
// double freqMax = (GetActiveProject() ? GetActiveProject()->GetRate() : 44100.0) / 2.0; // double freqMax = (GetActiveProject() ? GetActiveProject()->GetRate() : 44100.0) / 2.0;
@ -303,8 +301,8 @@ bool EffectToneGen::GetAutomationParameters(CommandParameters & parms)
bool EffectToneGen::SetAutomationParameters(CommandParameters & parms) bool EffectToneGen::SetAutomationParameters(CommandParameters & parms)
{ {
ReadAndVerifyEnum(Waveform, wxArrayString(nWaveforms, kWaveStrings)); ReadAndVerifyEnum(Waveform, kWaveStrings, nWaveforms);
ReadAndVerifyEnum(Interp, wxArrayString(nInterpolations, kInterStrings)); ReadAndVerifyEnum(Interp, kInterStrings, nInterpolations);
if (mChirp) if (mChirp)
{ {
ReadAndVerifyDouble(StartFreq); ReadAndVerifyDouble(StartFreq);

15
src/effects/TruncSilence.cpp
View File

@ -77,7 +77,7 @@ enum kActions
nActions nActions
}; };
static const wxChar *kActionStrings[nActions] = static const wxString kActionStrings[nActions] =
{ {
XO("Truncate Detected Silence"), XO("Truncate Detected Silence"),
XO("Compress Excess Silence") XO("Compress Excess Silence")
@ -176,10 +176,9 @@ EffectType EffectTruncSilence::GetType()
// EffectClientInterface implementation // EffectClientInterface implementation
bool EffectTruncSilence::DefineParams( ShuttleParams & S ){ bool EffectTruncSilence::DefineParams( ShuttleParams & S ){
wxArrayString actions(nActions, kActionStrings); S.SHUTTLE_ENUM_PARAM( mTruncDbChoiceIndex, DbIndex,
Enums::DbChoices, Enums::NumDbChoices );
S.SHUTTLE_ENUM_PARAM( mTruncDbChoiceIndex, DbIndex, mDbChoices ); S.SHUTTLE_ENUM_PARAM( mActionIndex, ActIndex, kActionStrings, nActions );
S.SHUTTLE_ENUM_PARAM( mActionIndex, ActIndex, actions );
S.SHUTTLE_PARAM( mInitialAllowedSilence, Minimum ); S.SHUTTLE_PARAM( mInitialAllowedSilence, Minimum );
S.SHUTTLE_PARAM( mTruncLongestAllowedSilence, Truncate ); S.SHUTTLE_PARAM( mTruncLongestAllowedSilence, Truncate );
S.SHUTTLE_PARAM( mSilenceCompressPercent, Compress ); S.SHUTTLE_PARAM( mSilenceCompressPercent, Compress );
@ -201,13 +200,11 @@ bool EffectTruncSilence::GetAutomationParameters(CommandParameters & parms)
bool EffectTruncSilence::SetAutomationParameters(CommandParameters & parms) bool EffectTruncSilence::SetAutomationParameters(CommandParameters & parms)
{ {
wxArrayString actions(nActions, kActionStrings);
ReadAndVerifyDouble(Minimum); ReadAndVerifyDouble(Minimum);
ReadAndVerifyDouble(Truncate); ReadAndVerifyDouble(Truncate);
ReadAndVerifyDouble(Compress); ReadAndVerifyDouble(Compress);
ReadAndVerifyEnum(DbIndex, mDbChoices); ReadAndVerifyEnum(DbIndex, Enums::DbChoices, Enums::NumDbChoices);
ReadAndVerifyEnumWithObsoletes(ActIndex, actions, ReadAndVerifyEnumWithObsoletes(ActIndex, kActionStrings, nActions,
kObsoleteActions, nObsoleteActions); kObsoleteActions, nObsoleteActions);
ReadAndVerifyBool(Independent); ReadAndVerifyBool(Independent);

16
src/effects/nyquist/Nyquist.cpp
View File

@ -338,10 +338,10 @@ bool NyquistEffect::DefineParams( ShuttleParams & S )
else if (ctrl.type == NYQ_CTRL_CHOICE) else if (ctrl.type == NYQ_CTRL_CHOICE)
{ {
// untranslated // untranslated
const wxArrayString &choices = ctrl.choices;
int x=d; int x=d;
//parms.WriteEnum(ctrl.var, (int) d, choices); //parms.WriteEnum(ctrl.var, (int) d, choices);
S.DefineEnum( x, static_cast<const wxChar*>( ctrl.var.c_str() ), 0, choices ); S.DefineEnum( x, static_cast<const wxChar*>( ctrl.var.c_str() ), 0,
&ctrl.choices[0], ctrl.choices.size() );
} }
else if (ctrl.type == NYQ_CTRL_STRING) else if (ctrl.type == NYQ_CTRL_STRING)
{ {
@ -388,8 +388,8 @@ bool NyquistEffect::GetAutomationParameters(CommandParameters & parms)
else if (ctrl.type == NYQ_CTRL_CHOICE) else if (ctrl.type == NYQ_CTRL_CHOICE)
{ {
// untranslated // untranslated
const wxArrayString &choices = ctrl.choices; parms.WriteEnum(ctrl.var, (int) d,
parms.WriteEnum(ctrl.var, (int) d, choices); &ctrl.choices[0], ctrl.choices.size());
} }
else if (ctrl.type == NYQ_CTRL_STRING) else if (ctrl.type == NYQ_CTRL_STRING)
{ {
@ -439,8 +439,8 @@ bool NyquistEffect::SetAutomationParameters(CommandParameters & parms)
{ {
int val; int val;
// untranslated // untranslated
const wxArrayString &choices = ctrl.choices; good = parms.ReadEnum(ctrl.var, &val,
good = parms.ReadEnum(ctrl.var, &val, choices) && &ctrl.choices[0], ctrl.choices.size()) &&
val != wxNOT_FOUND; val != wxNOT_FOUND;
} }
else if (ctrl.type == NYQ_CTRL_STRING) else if (ctrl.type == NYQ_CTRL_STRING)
@ -480,8 +480,8 @@ bool NyquistEffect::SetAutomationParameters(CommandParameters & parms)
{ {
int val {0}; int val {0};
// untranslated // untranslated
const wxArrayString &choices = ctrl.choices; parms.ReadEnum(ctrl.var, &val,
parms.ReadEnum(ctrl.var, &val, choices); &ctrl.choices[0], ctrl.choices.size());
ctrl.val = (double) val; ctrl.val = (double) val;
} }
else if (ctrl.type == NYQ_CTRL_STRING) else if (ctrl.type == NYQ_CTRL_STRING)

12
src/effects/vamp/VampEffect.cpp
View File

@ -190,10 +190,10 @@ bool VampEffect::GetAutomationParameters(CommandParameters & parms)
{ {
val = i; val = i;
} }
choices.Add(choice); choices.push_back(choice);
} }
parms.WriteEnum(key, val, choices); parms.WriteEnum(key, val, &choices[0], choices.size());
} }
else else
{ {
@ -233,10 +233,10 @@ bool VampEffect::SetAutomationParameters(CommandParameters & parms)
for (size_t i = 0, cnt = mParameters[p].valueNames.size(); i < cnt; i++) for (size_t i = 0, cnt = mParameters[p].valueNames.size(); i < cnt; i++)
{ {
wxString choice = wxString::FromUTF8(mParameters[p].valueNames[i].c_str()); wxString choice = wxString::FromUTF8(mParameters[p].valueNames[i].c_str());
choices.Add(choice); choices.push_back(choice);
} }
good = parms.ReadEnum(key, &val, choices) && val != wxNOT_FOUND; good = parms.ReadEnum(key, &val, &choices[0], choices.size()) && val != wxNOT_FOUND;
} }
else else
{ {
@ -279,10 +279,10 @@ bool VampEffect::SetAutomationParameters(CommandParameters & parms)
for (size_t i = 0, cnt = mParameters[p].valueNames.size(); i < cnt; i++) for (size_t i = 0, cnt = mParameters[p].valueNames.size(); i < cnt; i++)
{ {
wxString choice = wxString::FromUTF8(mParameters[p].valueNames[i].c_str()); wxString choice = wxString::FromUTF8(mParameters[p].valueNames[i].c_str());
choices.Add(choice); choices.push_back(choice);
} }
parms.ReadEnum(key, &val, choices); parms.ReadEnum(key, &val, &choices[0], choices.size());
mPlugin->setParameter(mParameters[p].identifier, (float) val); mPlugin->setParameter(mParameters[p].identifier, (float) val);
} }