EffectInterface.cpp

Go to the documentation of this file.

/*!********************************************************************
 
  Audacity: A Digital Audio Editor
 
  @file EffectInterface.cpp
 
**********************************************************************/
#include "EffectInterface.h"
#include <wx/tokenzr.h>
#include <wx/window.h>
 
const RegistryPath &EffectSettingsExtra::DurationKey()
{
   static wxString key("LastUsedDuration");
   return key;
}
 
EffectSettingsAccess::~EffectSettingsAccess() = default;
 
SimpleEffectSettingsAccess::~SimpleEffectSettingsAccess() = default;
 
EffectOutputs::~EffectOutputs() = default;
 
EffectSettingsAccess::Message::~Message() = default;
 
const EffectSettings &SimpleEffectSettingsAccess::Get()
{
   return mSettings;
}
 
void SimpleEffectSettingsAccess::Set(EffectSettings &&settings,
   std::unique_ptr<Message>)
{
   mSettings = std::move(settings);
}
 
void SimpleEffectSettingsAccess::Set(std::unique_ptr<Message>)
{
}
 
void SimpleEffectSettingsAccess::Flush()
{
}
 
bool SimpleEffectSettingsAccess::IsSameAs(
   const EffectSettingsAccess &other) const
{
   if (auto pOther =
      dynamic_cast<const SimpleEffectSettingsAccess*>(&other))
      return &this->mSettings == &pOther->mSettings;
   return false;
}
 
Identifier EffectDefinitionInterface::GetSquashedName(const Identifier &ident)
{
   // Get rid of leading and trailing white space
   auto name = ident.GET();
   name.Trim(true).Trim(false);
 
   if (name.empty())
      return {};
 
   wxStringTokenizer st(name, wxT(" "));
   wxString id;
 
   // CamelCase the name
   while (st.HasMoreTokens()) {
      wxString tok = st.GetNextToken();
      id += tok.Left(1).MakeUpper() + tok.Mid(1).MakeLower();
   }
 
   return id;
}
 
EffectDefinitionInterface::~EffectDefinitionInterface() = default;
 
EffectType EffectDefinitionInterface::GetClassification() const
{
   return GetType();
}
 
bool EffectDefinitionInterface::EnablesDebug() const
{
   return false;
}
 
ManualPageID EffectDefinitionInterface::ManualPage() const
{
   return {};
}
 
FilePath EffectDefinitionInterface::HelpPage() const
{
   return {};
}
 
bool EffectDefinitionInterface::IsHiddenFromMenus() const
{
   return false;
}
 
EffectSettingsManager::~EffectSettingsManager() = default;
 
bool EffectSettingsManager::VisitSettings(
   SettingsVisitor &, EffectSettings &)
{
   return false;
}
 
bool EffectSettingsManager::VisitSettings(
   ConstSettingsVisitor &, const EffectSettings &) const
{
   return false;
}
 
auto EffectSettingsManager::MakeSettings() const -> EffectSettings
{
   return {};
}
 
auto EffectSettingsManager::MakeOutputs() const
   -> std::unique_ptr<EffectOutputs>
{
   return nullptr;
}
 
bool EffectSettingsManager::CopySettingsContents(
   const EffectSettings &, EffectSettings &) const
{
   return true;
}
 
EffectInstance::~EffectInstance() = default;
 
bool EffectInstance::Init()
{
   return true;
}
 
bool EffectInstance::RealtimeInitialize(EffectSettings &, double)
{
   return false;
}
 
bool EffectInstance::RealtimeAddProcessor(
   EffectSettings &, EffectOutputs *, unsigned, float)
{
   return true;
}
 
bool EffectInstance::RealtimeSuspend()
{
   return true;
}
 
bool EffectInstance::RealtimeResume()
{
   return true;
}
 
auto EffectInstance::MakeMessage() const -> std::unique_ptr<Message>
{
   return nullptr;
}
 
bool EffectInstance::RealtimeProcessStart(MessagePackage &)
{
   return true;
}
 
size_t EffectInstance::RealtimeProcess(size_t, EffectSettings &,
   const float *const *, float *const *, size_t)
{
   return 0;
}
 
bool EffectInstance::RealtimeProcessEnd(EffectSettings &) noexcept
{
   return true;
}
 
bool EffectInstance::RealtimeFinalize(EffectSettings &) noexcept
{
   return true;
}
 
size_t EffectInstance::GetTailSize() const
{
   return 0;
}
 
auto EffectInstance::GetLatency(const EffectSettings &, double) const
   -> SampleCount
{
   return 0;
}
 
EffectInstanceEx::~EffectInstanceEx() = default;
 
EffectInstanceWithBlockSize::~EffectInstanceWithBlockSize() = default;
 
size_t EffectInstanceWithBlockSize::GetBlockSize() const
{
   return mBlockSize;
}
 
size_t EffectInstanceWithBlockSize::SetBlockSize(size_t maxBlockSize)
{
   return (mBlockSize = maxBlockSize);
}
 
EffectInstanceFactory::~EffectInstanceFactory() = default;
 
EffectUIValidator::EffectUIValidator(
   EffectUIClientInterface &effect, EffectSettingsAccess &access)
   : mEffect{effect}
   , mAccess{access}
{}
 
EffectUIValidator::~EffectUIValidator() = default;
 
bool EffectUIValidator::UpdateUI()
{
   return true;
}
 
bool EffectUIValidator::IsGraphicalUI()
{
   return false;
}
 
void EffectUIValidator::Disconnect()
{
}
 
void EffectUIValidator::OnClose()
{
   if (!mUIClosed)
   {
      mEffect.CloseUI();
      mUIClosed = true;
   }
}
 
EffectUIClientInterface::~EffectUIClientInterface() = default;
 
const RegistryPath &CurrentSettingsGroup()
{
   static RegistryPath id{ "CurrentSettings" };
   return id;
}
 
const RegistryPath &FactoryDefaultsGroup()
{
   static RegistryPath id{ "FactoryDefaults" };
   return id;
}
 
RegistryPath UserPresetsGroup(const RegistryPath & name)
{
   RegistryPath group = wxT("UserPresets");
   if (!name.empty())
      group += wxCONFIG_PATH_SEPARATOR + name;
   return group;
}