Autres/audacity
1
0
Fork 0
mirror of https://github.com/cookiengineer/audacity synced 2025-05-05 14:18:53 +02:00
Code Issues Releases Wiki Activity
audacity/src/Shuttle.cpp

712 lines
20 KiB
C++
Raw Blame History

/**********************************************************************
Shuttle.cpp
James Crook
(C) Audacity Developers, 2007
wxWidgets license. See Licensing.txt
*******************************************************************//**
\file Shuttle.cpp
\brief Implements Shuttle, ShuttleCli and Enums.
*//****************************************************************//**
\class Shuttle
\brief Moves data from one place to another, converting it as required.
Shuttle provides a base class for transfering parameter data into and
out of clasess into some other structure. This is a common
requirement and is needed for:
- Prefs data
- Command line parameter data
- Project data in XML
The 'Master' is the string side of the shuttle transfer, the 'Client'
is the binary data side of the transfer.
\see ShuttleBase
\see ShuttleGui
*//****************************************************************//**
\class ShuttleCli
\brief Derived from Shuttle, this class exchanges string parameters
with a binary representation.
\see ShuttleBase
\see ShuttleGui
*//****************************************************************//**
\class Enums
\brief Enums is a helper class for Shuttle. It defines enumerations
which are used in effects dialogs, in the effects themselves and in
preferences.
(If it grows big, we will move it out of shuttle.h).
*//*******************************************************************/
#include "Audacity.h"
#include <wx/defs.h>
#include <wx/checkbox.h>
#include <wx/choice.h>
#include <wx/intl.h>
#include <wx/sizer.h>
#include <wx/statbox.h>
#include <wx/stattext.h>
#include <wx/textctrl.h>
#include <wx/listctrl.h>
#include <wx/radiobut.h>
#include <wx/button.h>
#include "../include/audacity/EffectAutomationParameters.h" // for command automation
//#include "Project.h"
#include "Shuttle.h"
#include "WrappedType.h"
//#include "commands/CommandManager.h"
//#include "effects/Effect.h"
const int Enums::NumDbChoices = 13;
const wxString Enums::DbChoices[] =
{wxT("-20 dB"), wxT("-25 dB"), wxT("-30 dB"),
wxT("-35 dB"), wxT("-40 dB"), wxT("-45 dB"),
wxT("-50 dB"), wxT("-55 dB"), wxT("-60 dB"),
wxT("-65 dB"), wxT("-70 dB"), wxT("-75 dB"),
wxT("-80 dB")};
const double Enums::Db2Signal[] =
// -20dB -25dB -30dB -35dB -40dB -45dB -50dB -55dB -60dB -65dB -70dB -75dB -80dB Off
{ 0.10000, 0.05620, 0.03160, 0.01780, 0.01000, 0.00562, 0.00316, 0.00178, 0.00100, 0.000562, 0.000316, 0.000178, 0.0001000, 0.0 };
const wxString * Enums::GetDbChoices()
{
return DbChoices;
}
Shuttle::Shuttle()
{
}
bool Shuttle::TransferBool( const wxString & Name, bool & bValue, const bool & bDefault )
{
if( mbStoreInClient )
{
bValue = bDefault;
if( ExchangeWithMaster( Name ))
{
if( !mValueString.IsEmpty() )
bValue = mValueString.GetChar(0) == wxT('y');
}
}
else
{
mValueString = (bValue==0) ? wxT("no"):wxT("yes");
return ExchangeWithMaster( Name );
}
return true;
}
bool Shuttle::TransferFloat( const wxString & Name, float & fValue, const float &fDefault )
{
if( mbStoreInClient )
{
fValue = fDefault;
if( ExchangeWithMaster( Name ))
{
if( !mValueString.IsEmpty() )
fValue = wxAtof( mValueString );
}
}
else
{
mValueString = wxString::Format(wxT("%f"),fValue);
return ExchangeWithMaster( Name );
}
return true;
}
bool Shuttle::TransferDouble( const wxString & Name, double & dValue, const double &dDefault )
{
if( mbStoreInClient )
{
dValue = dDefault;
if( ExchangeWithMaster( Name ))
{
if( !mValueString.IsEmpty() )
dValue = wxAtof( mValueString );
}
}
else
{
//%f is format string for double
mValueString = wxString::Format(wxT("%f"),dValue);
return ExchangeWithMaster( Name );
}
return true;
}
bool Shuttle::TransferInt( const wxString & Name, int & iValue, const int & iDefault )
{
if( mbStoreInClient )
{
iValue = iDefault;
if( ExchangeWithMaster( Name ))
{
iValue = wxAtoi( mValueString );
}
}
else
{
mValueString = wxString::Format(wxT("%i"),iValue);
return ExchangeWithMaster( Name );
}
return true;
}
bool Shuttle::TransferInt( const wxString & Name, wxLongLong_t & iValue, const wxLongLong_t & iDefault )
{
return TransferLongLong(Name, iValue, iDefault);
}
bool Shuttle::TransferLongLong( const wxString & Name, wxLongLong_t & iValue, const wxLongLong_t & iDefault )
{
if( mbStoreInClient )
{
iValue = iDefault;
if( ExchangeWithMaster( Name ))
{
iValue = wxAtoi( mValueString );
}
}
else
{
/// \todo Fix for long long values.
mValueString = wxString::Format(wxT("%lld"), (long long) iValue);
return ExchangeWithMaster( Name );
}
return true;
}
bool Shuttle::TransferEnum( const wxString & Name, int & iValue,
const int nChoices, const wxString * pFirstStr)
{
if( mbStoreInClient )
{
iValue = 0;// default index if none other selected.
if( ExchangeWithMaster( Name ))
{
wxString str = mValueString;
if( str.Left( 1 ) == wxT('"') && str.Right( 1 ) == wxT('"') )
{
str = str.Mid( 2, str.Length() - 2 );
}
for( int i = 0; i < nChoices; i++ )
{
if( str.IsSameAs( pFirstStr[i] ))
{
iValue = i;
break;
}
}
}
}
else
{
//TIDY-ME: Out of range configuration values are silently discarded...
if( iValue > nChoices )
iValue = 0;
if( iValue < 0 )
iValue = 0;
mValueString = pFirstStr[iValue];
if( mValueString.Find( wxT(' ') ) != wxNOT_FOUND )
{
mValueString = wxT('"') + pFirstStr[iValue] + wxT('"'); //strings have quotes around them
}
return ExchangeWithMaster( Name );
}
return true;
}
bool Shuttle::TransferString( const wxString & Name, wxString & strValue, const wxString & WXUNUSED(strDefault) )
{
if( mbStoreInClient )
{
if( ExchangeWithMaster( Name ))
{
strValue = mValueString;
}
else
return false;
}
else
{
mValueString = wxT('"') + strValue + wxT('"'); //strings have quotes around them
return ExchangeWithMaster( Name );
}
return true;
}
bool Shuttle::TransferWrappedType( const wxString & Name, WrappedType & W )
{
if( mbStoreInClient )
{
if( ExchangeWithMaster( Name ))
{
W.WriteToAsString( mValueString );
}
}
else
{
mValueString = W.ReadAsString();
return ExchangeWithMaster( Name );
}
return true;
}
bool Shuttle::ExchangeWithMaster(const wxString & WXUNUSED(Name))
{
// ExchangeWithMaster() will usually be over-ridden
// in derived classes. We could have made it an
// abstract function.
wxASSERT( false );
return true;
}
// This variant uses values of the form
// param1=value1 param2=value2
bool ShuttleCli::ExchangeWithMaster(const wxString & Name)
{
if( !mbStoreInClient )
{
mParams += wxT(" ");
mParams +=Name;
mParams += wxT("=");
mParams +=mValueString;
}
else
{
int i;
mParams = wxT(" ")+mParams;
i=mParams.Find( wxT(" ")+Name+wxT("=") );
if( i>=0 )
{
int j=i+2+Name.Length();
wxString terminator = wxT(' ');
if(mParams.GetChar(j) == wxT('"')) //Strings are surrounded by quotes
{
terminator = wxT('"');
j++;
}
else if(mParams.GetChar(j) == wxT('\'')) // or by single quotes.
{
terminator = wxT('\'');
j++;
}
i=j;
while( j<(int)mParams.Length() && mParams.GetChar(j) != terminator )
j++;
mValueString = mParams.Mid(i,j-i);
return true;
}
return false;
}
return true;
}
bool ShuttleParams::ExchangeWithMaster(const wxString & WXUNUSED(Name))
{
return true;
}
#ifdef _MSC_VER
// If this is compiled with MSVC (Visual Studio)
#pragma warning( push )
#pragma warning( disable: 4100 ) // unused parameters.
#endif //_MSC_VER
// The ShouldSet and CouldGet functions have an important side effect
// on the pOptionalFlag. They 'use it up' and clear it down for the next parameter.
// Tests for parameter being optional.
// Prepares for next parameter by clearing the pointer.
// Reports on whether the parameter should be set, i.e. should set
// if it was chosen to be set, or was not optional.
bool ShuttleParams::ShouldSet(){
if( !pOptionalFlag )
return true;
bool result = *pOptionalFlag;
pOptionalFlag = NULL;
return result;
}
// These are functions to override. They do nothing.
void ShuttleParams::Define( bool & var, const wxChar * key, const bool vdefault, const bool vmin, const bool vmax, const bool vscl){;};
void ShuttleParams::Define( size_t & var, const wxChar * key, const int vdefault, const int vmin, const int vmax, const int vscl ){;};
void ShuttleParams::Define( int & var, const wxChar * key, const int vdefault, const int vmin, const int vmax, const int vscl ){;};
void ShuttleParams::Define( float & 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( wxString &var, const wxChar * key, const wxString vdefault, const wxString vmin, const wxString vmax, const wxString vscl ){;};
void ShuttleParams::DefineEnum( wxString &var, const wxChar * key, const wxString vdefault, wxArrayString strings ){;};
void ShuttleParams::DefineEnum( int &var, const wxChar * key, const int vdefault, wxArrayString strings ){;};
/*
void ShuttleParams::DefineEnum( int &var, const wxChar * key, const int vdefault, wxArrayString strings )
{
}
*/
// ShuttleGetAutomation gets from the shuttle into typically a string.
ShuttleParams & ShuttleGetAutomation::Optional( bool & var ){
pOptionalFlag = &var;
return *this;
};
void ShuttleGetAutomation::Define( bool & var, const wxChar * key, const bool vdefault, const bool vmin, const bool vmax, const bool vscl )
{
if( !ShouldSet() ) return;
mpEap->Write(key, var);
}
void ShuttleGetAutomation::Define( int & var, const wxChar * key, const int vdefault, const int vmin, const int vmax, const int vscl )
{
if( !ShouldSet() ) return;
mpEap->Write(key, var);
}
void ShuttleGetAutomation::Define( size_t & var, const wxChar * key, const int vdefault, const int vmin, const int vmax, const int vscl )
{
if( !ShouldSet() ) return;
mpEap->Write(key, var);
}
void ShuttleGetAutomation::Define( double & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl )
{
if( !ShouldSet() ) return;
mpEap->WriteFloat(key, var);
}
void ShuttleGetAutomation::Define( float & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl )
{
if( !ShouldSet() ) return;
mpEap->WriteFloat(key, var);
}
void ShuttleGetAutomation::Define( double & var, const wxChar * key, const double vdefault, const double vmin, const double vmax, const double vscl )
{
if( !ShouldSet() ) return;
mpEap->Write(key, var);
}
void ShuttleGetAutomation::Define( wxString &var, const wxChar * key, const wxString vdefault, const wxString vmin, const wxString vmax, const wxString vscl )
{
if( !ShouldSet() ) return;
mpEap->Write(key, var);
}
void ShuttleGetAutomation::DefineEnum( wxString &var, const wxChar * key, const wxString vdefault, wxArrayString strings )
{
if( !ShouldSet() ) return;
mpEap->Write(key, var);
}
void ShuttleGetAutomation::DefineEnum( int &var, const wxChar * key, const int vdefault, wxArrayString strings )
{
if( !ShouldSet() ) return;
mpEap->Write(key, strings[var]);
}
ShuttleParams & ShuttleSetAutomation::Optional( bool & var ){
pOptionalFlag = &var;
return *this;
};
// Tests for parameter being optional.
// Prepares for next parameter by clearing the pointer.
// If the parameter is optional, finds out if it was actually provided.
// i.e. could it be got from automation?
// The result goes into the flag variable, so we typically ignore the result.
bool ShuttleSetAutomation::CouldGet( const wxString &key ){
// Not optional? Can get as we will get the default, at worst.
if( !pOptionalFlag )
return true;
bool result = mpEap->HasEntry( key );
*pOptionalFlag = result;
pOptionalFlag = NULL;
return result;
}
void ShuttleSetAutomation::Define( bool & var, const wxChar * key, const bool vdefault, const bool vmin, const bool vmax, const bool vscl )
{
CouldGet( key );
if( !bOK )
return;
// Use of temp in this and related functions is to handle the case of
// only committing values if all values pass verification.
bool temp =var;
bOK = mpEap->ReadAndVerify(key, &temp, vdefault);
if( bWrite && bOK)
var = temp;
}
void ShuttleSetAutomation::Define( int & var, const wxChar * key, const int vdefault, const int vmin, const int vmax, const int vscl )
{
CouldGet( key );
if( !bOK )
return;
int temp =var;
bOK = mpEap->ReadAndVerify(key, &temp, vdefault, vmin, vmax);
if( bWrite && bOK)
var = temp;
}
void ShuttleSetAutomation::Define( size_t & var, const wxChar * key, const int vdefault, const int vmin, const int vmax, const int vscl )
{
CouldGet( key );
if( !bOK )
return;
int temp = var;
bOK = mpEap->ReadAndVerify(key, &temp, vdefault, vmin, vmax);
if( bWrite && bOK )
var = temp;
}
void ShuttleSetAutomation::Define( float & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl )
{
CouldGet( key );
if( !bOK )
return;
float temp = var;
bOK = mpEap->ReadAndVerify(key, &temp, vdefault, vmin, vmax);
if( bWrite && bOK )
var = temp;
}
void ShuttleSetAutomation::Define( double & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl )
{
CouldGet( key );
if( !bOK )
return;
double temp = var;
bOK = mpEap->ReadAndVerify(key, &temp, vdefault, vmin, vmax);
if( bWrite && bOK)
var = temp;
}
void ShuttleSetAutomation::Define( double & var, const wxChar * key, const double vdefault, const double vmin, const double vmax, const double vscl )
{
CouldGet( key );
if( !bOK )
return;
double temp = var;
bOK = mpEap->ReadAndVerify(key, &temp, vdefault, vmin, vmax);
if( bWrite && bOK)
var = temp;
}
void ShuttleSetAutomation::Define( wxString &var, const wxChar * key, const wxString vdefault, const wxString vmin, const wxString vmax, const wxString vscl )
{
CouldGet( key );
if( !bOK )
return;
wxString temp = var;
bOK = mpEap->ReadAndVerify(key, &temp, vdefault);
if( bWrite && bOK )
var = temp;
}
void ShuttleSetAutomation::DefineEnum( wxString &var, const wxChar * key, const wxString vdefault, wxArrayString strings )
{
CouldGet( key );
if( !bOK )
return;
int temp =0;
bOK = mpEap->ReadAndVerify(key, &temp, vdefault, strings);
if( bWrite && bOK)
var = strings[temp];
}
void ShuttleSetAutomation::DefineEnum( int &var, const wxChar * key, const int vdefault, wxArrayString strings )
{
CouldGet( key );
if( !bOK )
return;
int temp = var;
bOK = mpEap->ReadAndVerify(key, &temp, vdefault, strings);
if( bWrite && bOK)
var = temp;
}
bool ShuttleGetDefinition::IsOptional(){
bool result = pOptionalFlag !=NULL;
pOptionalFlag = NULL;
return result;
}
// Definition distinguishes optional from not.
ShuttleParams & ShuttleGetDefinition::Optional( bool & var ){
pOptionalFlag = &var;
return *this;
};
ShuttleGetDefinition::ShuttleGetDefinition( CommandMessageTarget & target ) : CommandMessageTargetDecorator( target )
{
}
// JSON definitions.
void ShuttleGetDefinition::Define( bool & var, const wxChar * key, const bool vdefault, const bool vmin, const bool vmax, const bool vscl )
{
StartStruct();
AddItem( wxString(key), "key" );
AddItem( "bool", "type" );
if( IsOptional() )
AddItem( "unchanged", "default" );
else
AddItem( vdefault ? "True" : "False", "default" );
EndStruct();
}
void ShuttleGetDefinition::Define( int & var, const wxChar * key, const int vdefault, const int vmin, const int vmax, const int vscl )
{
StartStruct();
AddItem( wxString(key), "key" );
AddItem( "int", "type" );
if( IsOptional() )
AddItem( "unchanged", "default" );
else
AddItem( (double)vdefault, "default" );
EndStruct();
}
void ShuttleGetDefinition::Define( size_t & var, const wxChar * key, const int vdefault, const int vmin, const int vmax, const int vscl )
{
StartStruct();
AddItem( wxString(key), "key" );
AddItem( "size_t", "type" );
if( IsOptional() )
AddItem( "unchanged", "default" );
else
AddItem( (double)vdefault, "default" );
EndStruct();
}
void ShuttleGetDefinition::Define( float & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl )
{
StartStruct();
AddItem( wxString(key), "key" );
AddItem( "float", "type" );
if( IsOptional() )
AddItem( "unchanged", "default" );
else
AddItem( (double)vdefault, "default" );
EndStruct();
}
void ShuttleGetDefinition::Define( double & var, const wxChar * key, const float vdefault, const float vmin, const float vmax, const float vscl )
{
StartStruct();
AddItem( wxString(key), "key" );
AddItem( "float", "type" );
if( IsOptional() )
AddItem( "unchanged", "default" );
else
AddItem( (double)vdefault, "default" );
EndStruct();
}
void ShuttleGetDefinition::Define( double & var, const wxChar * key, const double vdefault, const double vmin, const double vmax, const double vscl )
{
StartStruct();
AddItem( wxString(key), "key" );
AddItem( "double", "type" );
if( IsOptional() )
AddItem( "unchanged", "default" );
else
AddItem( (double)vdefault, "default" );
EndStruct();
}
void ShuttleGetDefinition::Define( wxString &var, const wxChar * key, const wxString vdefault, const wxString vmin, const wxString vmax, const wxString vscl )
{
StartStruct();
AddItem( wxString(key), "key" );
AddItem( "string", "type" );
if( IsOptional() )
AddItem( "unchanged", "default" );
else
AddItem( vdefault, "default" );
EndStruct();
}
void ShuttleGetDefinition::DefineEnum( wxString &var, const wxChar * key, const wxString vdefault, wxArrayString strings )
{
StartStruct();
AddItem( wxString(key), "key" );
AddItem( "enum", "type" );
if( IsOptional() )
AddItem( "unchanged", "default" );
else
AddItem( vdefault, "default" );
StartField( "enum" );
StartArray();
for( size_t i=0;i<strings.Count(); i++ )
AddItem( strings[i] );
EndArray();
EndField();
EndStruct();
}
void ShuttleGetDefinition::DefineEnum( int&var, const wxChar * key, const int vdefault, wxArrayString strings )
{
StartStruct();
AddItem( wxString(key), "key" );
AddItem( "enum", "type" );
if( IsOptional() )
AddItem( "unchanged", "default" );
else
AddItem( strings[vdefault], "default" );
StartField( "enum" );
StartArray();
for( size_t i=0;i<strings.Count(); i++ )
AddItem( strings[i] );
EndArray();
EndField();
EndStruct();
}
#ifdef _MSC_VER
// If this is compiled with MSVC (Visual Studio)
#pragma warning( pop )
#endif //_MSC_VER
Reference in New Issue View Git Blame Copy Permalink