#ifndef __AUDACITY_EFFECTINTERFACE_H__

#define __AUDACITY_EFFECTINTERFACE_H__

#include <functional>

#include "audacity/Types.h"

#include "audacity/ComponentInterface.h"

#include "audacity/ConfigInterface.h"

#include "audacity/EffectAutomationParameters.h" // for command automation

class ShuttleGui;

typedef enum EffectType : int

} EffectType;

class AUDACITY_DLL_API EffectDefinitionInterface /* not final */ : public ComponentInterface

{

virtual ~EffectDefinitionInterface() {};

// Type determines how it behaves.

virtual EffectType GetType() = 0;

// Classification determines which menu it appears in.

virtual EffectType GetClassification() { return GetType();};

virtual EffectFamilySymbol GetFamily() = 0;

// These should move to the "EffectClientInterface" class once all

// effects have been converted.

virtual bool IsInteractive() = 0;

// I don't really like this, but couldn't think of a better way to force the

// effect to appear "above the line" in the menus.

virtual bool IsDefault() = 0;

// This will go away when all Effects have been updated to the new

// interface.

virtual bool IsLegacy() = 0;

// Whether the effect supports realtime previewing (while audio is playing).

virtual bool SupportsRealtime() = 0;

// Can the effect be used without the UI.

virtual bool SupportsAutomation() = 0;

};

class wxDialog;

class wxWindow;

class EffectUIHostInterface;

class EffectUIClientInterface;

class AUDACITY_DLL_API EffectHostInterface /* not final */ : public ConfigClientInterface

{

virtual ~EffectHostInterface() {};

virtual double GetDefaultDuration() = 0;

virtual double GetDuration() = 0;

virtual NumericFormatSymbol GetDurationFormat() = 0;

virtual void SetDuration(double seconds) = 0;

// Preset handling

virtual RegistryPath GetUserPresetsGroup(const RegistryPath & name) = 0;

virtual RegistryPath GetCurrentSettingsGroup() = 0;

virtual RegistryPath GetFactoryDefaultsGroup() = 0;

};

class AUDACITY_DLL_API EffectClientInterface /* not final */ : public EffectDefinitionInterface

{

using EffectDialogFactory = std::function<

wxDialog* ( wxWindow &parent,

EffectHostInterface*, EffectUIClientInterface* )

>;

virtual ~EffectClientInterface() {};

virtual bool SetHost(EffectHostInterface *host) = 0;

virtual unsigned GetAudioInCount() = 0;

virtual unsigned GetAudioOutCount() = 0;

virtual int GetMidiInCount() = 0;

virtual int GetMidiOutCount() = 0;

virtual void SetSampleRate(double rate) = 0;

// Suggest a block size, but the return is the size that was really set:

virtual size_t SetBlockSize(size_t maxBlockSize) = 0;

virtual size_t GetBlockSize() const = 0;

virtual sampleCount GetLatency() = 0;

virtual size_t GetTailSize() = 0;

virtual bool IsReady() = 0;

virtual bool ProcessInitialize(sampleCount totalLen, ChannelNames chanMap = NULL) = 0;

// This may be called during stack unwinding:

virtual bool ProcessFinalize() /* noexcept */ = 0;

virtual size_t ProcessBlock(float **inBlock, float **outBlock, size_t blockLen) = 0;

virtual bool RealtimeInitialize() = 0;

virtual bool RealtimeAddProcessor(unsigned numChannels, float sampleRate) = 0;

virtual bool RealtimeFinalize() = 0;

virtual bool RealtimeSuspend() = 0;

virtual bool RealtimeResume() = 0;

virtual bool RealtimeProcessStart() = 0;

virtual size_t RealtimeProcess(int group, float **inBuf, float **outBuf, size_t numSamples) = 0;

virtual bool RealtimeProcessEnd() = 0;

virtual bool ShowInterface(

wxWindow &parent, const EffectDialogFactory &factory,

bool forceModal = false

) = 0;

// Some effects will use define params to define what parameters they take.

// If they do, they won't need to implement Get or SetAutomation parameters.

// since the Effect class can do it. Or at least that is how things happen

// in AudacityCommand. IF we do the same in class Effect, then Effect maybe

// should derive by some route from AudacityCommand to pick up that

// functionality.

//virtual bool DefineParams( ShuttleParams & S){ return false;};

virtual bool GetAutomationParameters(CommandParameters & parms) = 0;

virtual bool SetAutomationParameters(CommandParameters & parms) = 0;

virtual bool LoadUserPreset(const RegistryPath & name) = 0;

virtual bool SaveUserPreset(const RegistryPath & name) = 0;

virtual RegistryPaths GetFactoryPresets() = 0;

virtual bool LoadFactoryPreset(int id) = 0;

virtual bool LoadFactoryDefaults() = 0;

};

class AUDACITY_DLL_API EffectUIHostInterface

{

virtual ~EffectUIHostInterface() {};

};

class AUDACITY_DLL_API EffectUIClientInterface /* not final */

{

virtual ~EffectUIClientInterface() {};

virtual void SetHostUI(EffectUIHostInterface *host) = 0;

virtual bool IsGraphicalUI() = 0;

virtual bool PopulateUI(ShuttleGui &S) = 0;

virtual bool ValidateUI() = 0;

virtual bool HideUI() = 0;

virtual bool CloseUI() = 0;

virtual bool CanExportPresets() = 0;

virtual void ExportPresets() = 0;

virtual void ImportPresets() = 0;

virtual bool HasOptions() = 0;

virtual void ShowOptions() = 0;

};

class AUDACITY_DLL_API EffectManagerInterface

{

virtual ~EffectManagerInterface() {};

virtual void FindFilesInPathList(const wxString & pattern,

const FilePaths & pathList,

FilePaths & files,

int searchFlags) = 0;

};

#endif // __AUDACITY_EFFECTINTERFACE_H__