#include <Effect.h>

Inheritance diagram for EffectUIHost:

Public Member Functions
	EffectUIHost (wxWindow parent, Effect effect, EffectUIClientInterface *client)

	EffectUIHost (wxWindow parent, AudacityCommand command, EffectUIClientInterface *client)

virtual	~EffectUIHost ()

bool	TransferDataToWindow () override

bool	TransferDataFromWindow () override

int	ShowModal () override

bool	Initialize ()

Public Member Functions inherited from wxDialogWrapper
	wxDialogWrapper ()

	wxDialogWrapper (wxWindow *parent, wxWindowID id, const wxString &title, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxDEFAULT_DIALOG_STYLE, const wxString &name=_("Dialog"))

bool	Create (wxWindow *parent, wxWindowID id, const wxString &title, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxDEFAULT_DIALOG_STYLE, const wxString &name=_("Dialog"))

Public Member Functions inherited from wxTabTraversalWrapper< wxDialog >
	wxTabTraversalWrapper (Args &&...args)

Public Member Functions inherited from EffectUIHostInterface
virtual	~EffectUIHostInterface ()

Private Member Functions
void	OnInitDialog (wxInitDialogEvent &evt)

void	OnErase (wxEraseEvent &evt)

void	OnPaint (wxPaintEvent &evt)

void	OnClose (wxCloseEvent &evt)

void	OnApply (wxCommandEvent &evt)

void	DoCancel ()

void	OnCancel (wxCommandEvent &evt)

void	OnHelp (wxCommandEvent &evt)

void	OnDebug (wxCommandEvent &evt)

void	OnMenu (wxCommandEvent &evt)

void	OnEnable (wxCommandEvent &evt)

void	OnPlay (wxCommandEvent &evt)

void	OnRewind (wxCommandEvent &evt)

void	OnFFwd (wxCommandEvent &evt)

void	OnPlayback (wxCommandEvent &evt)

void	OnCapture (wxCommandEvent &evt)

void	OnUserPreset (wxCommandEvent &evt)

void	OnFactoryPreset (wxCommandEvent &evt)

void	OnDeletePreset (wxCommandEvent &evt)

void	OnSaveAs (wxCommandEvent &evt)

void	OnImport (wxCommandEvent &evt)

void	OnExport (wxCommandEvent &evt)

void	OnOptions (wxCommandEvent &evt)

void	OnDefaults (wxCommandEvent &evt)

void	UpdateControls ()

wxBitmap	CreateBitmap (const char *const xpm[], bool up, bool pusher)

void	LoadUserPresets ()

void	InitializeRealtime ()

void	CleanupRealtime ()

void	Resume ()

Private Attributes
AudacityProject *	mProject

wxWindow *	mParent

Effect *	mEffect

AudacityCommand *	mCommand

EffectUIClientInterface *	mClient

wxArrayString	mUserPresets

bool	mInitialized

bool	mSupportsRealtime

bool	mIsGUI

bool	mIsBatch

wxButton *	mApplyBtn

wxButton *	mCloseBtn

wxButton *	mMenuBtn

wxButton *	mPlayBtn

wxButton *	mRewindBtn

wxButton *	mFFwdBtn

wxCheckBox *	mEnableCb

wxButton *	mEnableToggleBtn

wxButton *	mPlayToggleBtn

wxBitmap	mPlayBM

wxBitmap	mPlayDisabledBM

wxBitmap	mStopBM

wxBitmap	mStopDisabledBM

bool	mEnabled

bool	mDisableTransport

bool	mPlaying

bool	mCapturing

SelectedRegion	mRegion

double	mPlayPos

bool	mDismissed {}

bool	mNeedsResume {}

Detailed Description

Definition at line 590 of file Effect.h.

Constructor & Destructor Documentation

EffectUIHost::EffectUIHost	(	wxWindow *	parent,
		Effect *	effect,
		EffectUIClientInterface *	client
	)

Definition at line 2830 of file Effect.cpp.

References GetActiveProject(), and Effect::mClient.

 :  wxDialogWrapper(parent, wxID_ANY, effect->GetTranslatedName(),
             wxDefaultPosition, wxDefaultSize,
             wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER | wxMINIMIZE_BOX | wxMAXIMIZE_BOX)
 {
 #if defined(__WXMAC__)
    // Make sure the effect window actually floats above the main window
    [[((NSView *)GetHandle()) window] setLevel:NSFloatingWindowLevel];
 #endif
 
    SetName( effect->GetTranslatedName() );
    SetExtraStyle(GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY);
 
    mParent = parent;
    mEffect = effect;
    mCommand = NULL;
    mClient = client;
 
    mProject = GetActiveProject();
 
    mInitialized = false;
    mSupportsRealtime = false;
 
    mDisableTransport = false;
 
    mEnabled = true;
 
    mPlayPos = 0.0;
    mClient->SetHostUI(this);
 }

EffectUIHost::EffectUIHost	(	wxWindow *	parent,
		AudacityCommand *	command,
		EffectUIClientInterface *	client
	)

Definition at line 2863 of file Effect.cpp.

References GetActiveProject(), mClient, mCommand, mDisableTransport, mEffect, mEnabled, mInitialized, mParent, mPlayPos, mProject, mSupportsRealtime, and EffectUIClientInterface::SetHostUI().

 :  wxDialogWrapper(parent, wxID_ANY, _("Some Command") /*command->GetTranslatedName()*/,
             wxDefaultPosition, wxDefaultSize,
             wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER | wxMINIMIZE_BOX | wxMAXIMIZE_BOX)
 {
 #if defined(__WXMAC__)
    // Make sure the effect window actually floats above the main window
    [[((NSView *)GetHandle()) window] setLevel:NSFloatingWindowLevel];
 #endif
 
    //SetName( command->GetTranslatedName() );
    SetExtraStyle(wxWS_EX_VALIDATE_RECURSIVELY);
 
    mParent = parent;
    mEffect = NULL;
    mCommand = command;
    mClient = client;
 
    mProject = GetActiveProject();
 
    mInitialized = false;
    mSupportsRealtime = false;
 
    mDisableTransport = false;
 
    mEnabled = true;
 
    mPlayPos = 0.0;
    mClient->SetHostUI(this);
 }

EffectUIHost::~EffectUIHost ( )

virtual

Definition at line 2899 of file Effect.cpp.

References CleanupRealtime(), EffectUIClientInterface::CloseUI(), mClient, mNeedsResume, and Resume().

 {
    CleanupRealtime();
 
    if (mClient)
    {
       if (mNeedsResume)
          Resume();
       
       mClient->CloseUI();
       mClient = NULL;
    }
 }

Member Function Documentation

void EffectUIHost::CleanupRealtime ( )

private

Definition at line 3889 of file Effect.cpp.

References EffectManager::Get(), mEffect, mInitialized, mSupportsRealtime, and EffectManager::RealtimeRemoveEffect().

Referenced by OnClose(), and ~EffectUIHost().

 {
    if (mSupportsRealtime && mInitialized)
    {
       EffectManager::Get().RealtimeRemoveEffect(mEffect);
 
       mInitialized = false;
    }
 }

wxBitmap EffectUIHost::CreateBitmap	(	const char *const	xpm[],
		bool	up,
		bool	pusher
	)

private

Definition at line 3745 of file Effect.cpp.

Referenced by Initialize().

 {
    wxMemoryDC dc;
    wxBitmap pic(xpm);
 
    wxBitmap mod(pic.GetWidth() + 6, pic.GetHeight() + 6);
    dc.SelectObject(mod);
 
 #if !defined(__WXMAC__)
 
 #if defined(__WXGTK__)
    wxColour newColour = wxSystemSettings::GetColour(wxSYS_COLOUR_BACKGROUND);
 #elif defined(__WXMSW__)
    wxColour newColour = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
 #endif
 
    dc.SetBackground(wxBrush(newColour));
    dc.Clear();
 #endif
 
    int offset = 3;
    if (pusher)
    {
       if (!up)
       {
          offset += 1;
       }
    }
 
    dc.DrawBitmap(pic, offset, offset, true);
 
    dc.SelectObject(wxNullBitmap);
 
    return mod;
 }

void EffectUIHost::DoCancel ( )

private

Definition at line 3301 of file Effect.cpp.

References mDismissed, mEffect, and Effect::mUIResultID.

Referenced by OnCancel(), and OnClose().

 {
    if (!mDismissed) {
       if( mEffect )
          mEffect->mUIResultID = wxID_CANCEL;
 
       if (IsModal())
          EndModal(false);
       else
          Hide();
 
       mDismissed = true;
    }
 }

bool EffectUIHost::Initialize ( )

Definition at line 2968 of file Effect.cpp.

References _(), CreateBitmap(), CreateStdButtonSizer(), eApplyButton, eCloseButton, eDebugButton, EffectTypeAnalyze, EffectTypeTool, eHelpButton, gAudioIO, AudioIO::GetNumCaptureChannels(), Effect::GetType(), Effect::HelpPage(), InitializeRealtime(), AudioIO::IsAvailable(), AudacityCommand::IsBatchProcessing(), Effect::IsBatchProcessing(), EffectUIClientInterface::IsGraphicalUI(), AudioIO::IsStreamActive(), kEnableID, kFFwdID, kMenuID, kPlayID, kRewindID, LoadUserPresets(), Effect::ManualPage(), mApplyBtn, mCapturing, mClient, mCloseBtn, mCommand, mDisableTransport, mEffect, mEnableCb, mEnabled, mFFwdBtn, mIsBatch, mIsGUI, mMenuBtn, mParent, mPlayBM, mPlayBtn, mPlayDisabledBM, mPlaying, mPlayToggleBtn, mProject, mRewindBtn, mStopBM, mStopDisabledBM, mSupportsRealtime, Effect::mUIDebug, EffectUIClientInterface::PopulateUI(), safenew, EffectPanel::SetAccept(), Effect::SupportsRealtime(), and UpdateControls().

 {
    EffectPanel *w = safenew EffectPanel(this);
    {
       auto vs = std::make_unique<wxBoxSizer>(wxVERTICAL);
       {
          auto hs = std::make_unique<wxBoxSizer>(wxHORIZONTAL);
 
          // Try to give the window a sensible default/minimum size
          w->SetMinSize(wxSize(wxMax(600, mParent->GetSize().GetWidth() * 2 / 3),
             mParent->GetSize().GetHeight() / 2));
 
          mDisableTransport = !gAudioIO->IsAvailable(mProject);
          mPlaying = gAudioIO->IsStreamActive(); // not exactly right, but will suffice
          mCapturing = gAudioIO->IsStreamActive() && gAudioIO->GetNumCaptureChannels() > 0;
 
          if (!mClient->PopulateUI(w))
          {
             return false;
          }
 
          hs->Add(w, 1, wxEXPAND);
          vs->Add(hs.release(), 1, wxEXPAND);
       }
 
       wxPanel *buttonPanel = safenew wxPanelWrapper(this, wxID_ANY);
       wxPanel *const bar = safenew wxPanelWrapper(buttonPanel, wxID_ANY);
 
       // This fools NVDA into not saying "Panel" when the dialog gets focus
       bar->SetName(wxT("\a"));
       bar->SetLabel(wxT("\a"));
 
       {
          auto bs = std::make_unique<wxBoxSizer>(wxHORIZONTAL);
 
          mSupportsRealtime = mEffect && mEffect->SupportsRealtime();
          mIsGUI = mClient->IsGraphicalUI();
          mIsBatch = (mEffect && mEffect->IsBatchProcessing()) ||
             (mCommand && mCommand->IsBatchProcessing());
 
          wxBitmapButton *bb;
 
          int margin = 0;
 
 #if defined(__WXMAC__)
          margin = 3; // I'm sure it's needed because of the order things are created...
 #endif   
 
          if (!mIsGUI)
          {
             wxASSERT(bar); // To justify safenew
             mMenuBtn = safenew wxButton(bar, kMenuID, _("&Manage"));
             bs->Add(mMenuBtn, 0, wxALIGN_CENTER | wxTOP | wxBOTTOM, margin);
          }
          else
          {
             wxASSERT(bar); // To justify safenew
             mMenuBtn = safenew wxBitmapButton(bar, kMenuID, CreateBitmap(effect_menu_xpm, true, false));
 #if defined(__WXMAC__)
             mMenuBtn->SetName(_("&Manage"));
 #else
             mMenuBtn->SetLabel(_("&Manage"));
 #endif
             bs->Add(mMenuBtn);
          }
          mMenuBtn->SetToolTip(_("Manage presets and options"));
 
          bs->Add(5, 5);
 
          if (!mIsBatch)
          {
             if (!mIsGUI)
             {
                if (mSupportsRealtime)
                {
                   wxASSERT(bar); // To justify safenew
                   mPlayToggleBtn = safenew wxButton(bar, kPlayID, _("Start &Playback"));
                   mPlayToggleBtn->SetToolTip(_("Start and stop playback"));
                   bs->Add(mPlayToggleBtn, 0, wxALIGN_CENTER | wxTOP | wxBOTTOM, margin);
                }
                else if (mEffect && 
                   (mEffect->GetType() != EffectTypeAnalyze) && 
                   (mEffect->GetType() != EffectTypeTool)
                   ) 
                {
                   wxASSERT(bar); // To justify safenew
                   mPlayToggleBtn = safenew wxButton(bar, kPlayID, _("&Preview"));
                   mPlayToggleBtn->SetToolTip(_("Preview effect"));
                   bs->Add(mPlayToggleBtn, 0, wxALIGN_CENTER | wxTOP | wxBOTTOM, margin);
                }
             }
             else
             {
                mPlayBM = CreateBitmap(effect_play_xpm, true, false);
                mPlayDisabledBM = CreateBitmap(effect_play_disabled_xpm, true, false);
                mStopBM = CreateBitmap(effect_stop_xpm, true, false);
                mStopDisabledBM = CreateBitmap(effect_stop_disabled_xpm, true, false);
                wxASSERT(bar); // To justify safenew
                bb = safenew wxBitmapButton(bar, kPlayID, mPlayBM);
                bb->SetBitmapDisabled(mPlayDisabledBM);
                mPlayBtn = bb;
                bs->Add(mPlayBtn);
                if (!mSupportsRealtime)
                {
                   mPlayBtn->SetToolTip(_("Preview effect"));
 #if defined(__WXMAC__)
                   mPlayBtn->SetName(_("Preview effect"));
 #else
                   mPlayBtn->SetLabel(_("&Preview effect"));
 #endif
                }
             }
 
             if (mSupportsRealtime)
             {
                if (!mIsGUI)
                {
                   wxASSERT(bar); // To justify safenew
                   mRewindBtn = safenew wxButton(bar, kRewindID, _("Skip &Backward"));
                   bs->Add(mRewindBtn, 0, wxALIGN_CENTER | wxTOP | wxBOTTOM, margin);
                }
                else
                {
                   wxASSERT(bar); // To justify safenew
                   bb = safenew wxBitmapButton(bar, kRewindID, CreateBitmap(effect_rewind_xpm, true, true));
                   bb->SetBitmapDisabled(CreateBitmap(effect_rewind_disabled_xpm, true, true));
                   mRewindBtn = bb;
 #if defined(__WXMAC__)
                   mRewindBtn->SetName(_("Skip &Backward"));
 #else
                   mRewindBtn->SetLabel(_("Skip &Backward"));
 #endif
                   bs->Add(mRewindBtn);
                }
                mRewindBtn->SetToolTip(_("Skip backward"));
 
                if (!mIsGUI)
                {
                   wxASSERT(bar); // To justify safenew
                   mFFwdBtn = safenew wxButton(bar, kFFwdID, _("Skip &Forward"));
                   bs->Add(mFFwdBtn, 0, wxALIGN_CENTER | wxTOP | wxBOTTOM, margin);
                }
                else
                {
                   wxASSERT(bar); // To justify safenew
                   bb = safenew wxBitmapButton(bar, kFFwdID, CreateBitmap(effect_ffwd_xpm, true, true));
                   bb->SetBitmapDisabled(CreateBitmap(effect_ffwd_disabled_xpm, true, true));
                   mFFwdBtn = bb;
 #if defined(__WXMAC__)
                   mFFwdBtn->SetName(_("Skip &Forward"));
 #else
                   mFFwdBtn->SetLabel(_("Skip &Forward"));
 #endif
                   bs->Add(mFFwdBtn);
                }
                mFFwdBtn->SetToolTip(_("Skip forward"));
 
                bs->Add(5, 5);
 
                mEnableCb = safenew wxCheckBox(bar, kEnableID, _("&Enable"));
                mEnableCb->SetValue(mEnabled);
                mEnableCb->SetName(_("Enable"));
                bs->Add(mEnableCb, 0, wxALIGN_CENTER | wxTOP | wxBOTTOM, margin);
             }
          }
 
          bar->SetSizerAndFit(bs.release());
       }
 
       long buttons;
       if ( mEffect && mEffect->ManualPage().IsEmpty() && mEffect->HelpPage().IsEmpty()) {
          buttons = eApplyButton + eCloseButton;
          this->SetAcceleratorTable(wxNullAcceleratorTable);
       }
       else {
          buttons = eApplyButton + eCloseButton + eHelpButton;
          wxAcceleratorEntry entries[1];
 #if defined(__WXMAC__)
          // Is there a standard shortcut on Mac?
 #else
          entries[0].Set(wxACCEL_NORMAL, (int) WXK_F1, wxID_HELP);
 #endif
          wxAcceleratorTable accel(1, entries);
          this->SetAcceleratorTable(accel);
       }
 
       if (mEffect && mEffect->mUIDebug) {
          buttons += eDebugButton;
       }
 
       buttonPanel->SetSizer(CreateStdButtonSizer(buttonPanel, buttons, bar).release());
       vs->Add(buttonPanel, 0, wxEXPAND);
 
       SetSizer(vs.release());
    }
 
    Layout();
    Fit();
    Center();
 
    mApplyBtn = (wxButton *) FindWindow(wxID_APPLY);
    mCloseBtn = (wxButton *) FindWindow(wxID_CANCEL);
 
    UpdateControls();
 
    w->SetAccept(!mIsGUI);
    (!mIsGUI ? w : FindWindow(wxID_APPLY))->SetFocus();
  
    LoadUserPresets();
 
    InitializeRealtime();
 
    SetMinSize(GetSize());
    return true;
 }

void EffectUIHost::InitializeRealtime ( )

private

Definition at line 3871 of file Effect.cpp.

References EffectManager::Get(), mEffect, mInitialized, mSupportsRealtime, OnCapture(), OnPlayback(), and EffectManager::RealtimeAddEffect().

Referenced by Initialize().

 {
    if (mSupportsRealtime && !mInitialized)
    {
       EffectManager::Get().RealtimeAddEffect(mEffect);
 
       wxTheApp->Bind(EVT_AUDIOIO_PLAYBACK,
                         &EffectUIHost::OnPlayback,
                         this);
 
       wxTheApp->Bind(EVT_AUDIOIO_CAPTURE,
                         &EffectUIHost::OnCapture,
                         this);
 
       mInitialized = true;
    }
 }

void EffectUIHost::LoadUserPresets ( )

private

Definition at line 3859 of file Effect.cpp.

References Effect::GetPrivateConfigSubgroups(), Effect::GetUserPresetsGroup(), mEffect, and mUserPresets.

Referenced by Initialize(), OnDeletePreset(), OnImport(), OnMenu(), and OnSaveAs().

 {
    mUserPresets.Clear();
 
    if( mEffect )
       mEffect->GetPrivateConfigSubgroups(mEffect->GetUserPresetsGroup(wxEmptyString), mUserPresets);
 
    mUserPresets.Sort();
 
    return;
 }

void EffectUIHost::OnApply ( wxCommandEvent & evt )

private

Definition at line 3235 of file Effect.cpp.

References AlwaysEnabledFlag, AudacityCommand::Apply(), Effect::Apply(), EffectTypeGenerate, AudacityCommand::GetAutomationParameters(), Effect::GetCurrentSettingsGroup(), IdentInterface::GetTranslatedName(), Effect::GetType(), SelectedRegion::isPoint(), mApplyBtn, mClient, mCommand, mDismissed, mEffect, mIsBatch, mProject, Effect::mUIResultID, AudacityProject::mViewInfo, params, AudacityProject::ReportIfActionNotAllowed(), Effect::SaveUserPreset(), ViewInfo::selectedRegion, TimeSelectedFlag, EffectUIClientInterface::ValidateUI(), and WaveTracksSelectedFlag.

Referenced by OnDebug().

 {
    // On wxGTK (wx2.8.12), the default action is still executed even if
    // the button is disabled.  This appears to affect all wxDialogs, not
    // just our Effects dialogs.  So, this is a only temporary workaround
    // for legacy effects that disable the OK button.  Hopefully this has
    // been corrected in wx3.
    if (!FindWindow(wxID_APPLY)->IsEnabled())
    {
       return;
    }
 
    // Honor the "select all if none" preference...a little hackish, but whatcha gonna do...
    if (!mIsBatch && mEffect && mEffect->GetType() != EffectTypeGenerate && mProject->mViewInfo.selectedRegion.isPoint())
    {
       auto flags = AlwaysEnabledFlag;
       bool allowed = mProject->ReportIfActionNotAllowed(
          mEffect->GetTranslatedName(),
          flags,
          WaveTracksSelectedFlag | TimeSelectedFlag,
          WaveTracksSelectedFlag | TimeSelectedFlag);
       if (!allowed)
          return;
    }
 
    if (!mClient->ValidateUI())
    {
       return;
    }
 
    // This will take care of calling TransferDataFromWindow() for an effect.
    if (mEffect &&  !mEffect->SaveUserPreset(mEffect->GetCurrentSettingsGroup()))
    {
       return;
    }
    // This will take care of calling TransferDataFromWindow() for a command.
    if (mCommand ){
       wxString params;
       mCommand->GetAutomationParameters( params );
    }
 
    if( mEffect )
       mEffect->mUIResultID = evt.GetId();
 
    if (IsModal())
    {
       mDismissed = true;
 
       EndModal(true);
 
       Close();
 
       return;
    }
 
    // Progress dialog no longer yields, so this "shouldn't" be necessary (yet to be proven
    // for sure), but it is a nice visual cue that something is going on.
    mApplyBtn->Disable();
    auto cleanup = finally( [&] { mApplyBtn->Enable(); } );
 
    if( mEffect )
       mEffect->Apply();
    if( mCommand )
       mCommand->Apply();
 }

void EffectUIHost::OnCancel ( wxCommandEvent & evt )

private

Definition at line 3316 of file Effect.cpp.

References DoCancel().

 {
    DoCancel();
    Close();
 }

void EffectUIHost::OnCapture ( wxCommandEvent & evt )

private

Definition at line 3581 of file Effect.cpp.

References mCapturing, mDisableTransport, mProject, and UpdateControls().

Referenced by InitializeRealtime().

 {
    evt.Skip();
 
    if (evt.GetInt() != 0)
    {
       if (evt.GetEventObject() != mProject)
       {
          mDisableTransport = true;
       }
       else
       {
          mCapturing = true;
       }
    }
    else
    {
       mDisableTransport = false;
       mCapturing = false;
    }
 
    UpdateControls();
 }

void EffectUIHost::OnClose ( wxCloseEvent & evt )

private

Definition at line 3219 of file Effect.cpp.

References CleanupRealtime(), EffectUIClientInterface::CloseUI(), DoCancel(), mClient, mNeedsResume, and Resume().

 {
    DoCancel();
 
    CleanupRealtime();
 
    Hide();
 
    if (mNeedsResume)
       Resume();
    mClient->CloseUI();
    mClient = NULL;
 
    Destroy();
 }

void EffectUIHost::OnDebug ( wxCommandEvent & evt )

private

Definition at line 3336 of file Effect.cpp.

References mEffect, Effect::mUIResultID, and OnApply().

 {
    OnApply(evt);
    if( mEffect )
       mEffect->mUIResultID = evt.GetId();
 }

void EffectUIHost::OnDefaults ( wxCommandEvent & evt )

private

Definition at line 3738 of file Effect.cpp.

References Effect::LoadFactoryDefaults(), and mEffect.

 {
    mEffect->LoadFactoryDefaults();
 
    return;
 }

void EffectUIHost::OnDeletePreset ( wxCommandEvent & evt )

private

Definition at line 3621 of file Effect.cpp.

References _(), AudacityMessageBox(), Effect::GetUserPresetsGroup(), kDeletePresetID, LoadUserPresets(), mEffect, mUserPresets, and Effect::RemovePrivateConfigSubgroup().

 {
    wxString preset = mUserPresets[evt.GetId() - kDeletePresetID];
 
    int res = AudacityMessageBox(wxString::Format(_("Are you sure you want to delete \"%s\"?"), preset),
                           _("Delete Preset"),
                           wxICON_QUESTION | wxYES_NO);
    if (res == wxYES)
    {
       mEffect->RemovePrivateConfigSubgroup(mEffect->GetUserPresetsGroup(preset));
    }
 
    LoadUserPresets();
 
    return;
 }

void EffectUIHost::OnEnable ( wxCommandEvent & evt )

private

Definition at line 3445 of file Effect.cpp.

References mEffect, mEnableCb, mEnabled, mNeedsResume, Effect::RealtimeSuspend(), Resume(), and UpdateControls().

 {
    mEnabled = mEnableCb->GetValue();
 
    if (mEnabled) {
       Resume();
       mNeedsResume = false;
    }
    else
    {
       mEffect->RealtimeSuspend();
       mNeedsResume = true;
    }
 
    UpdateControls();
 }

void EffectUIHost::OnErase ( wxEraseEvent & evt )

private

Definition at line 3207 of file Effect.cpp.

 {
    // Ignore it
 }

void EffectUIHost::OnExport ( wxCommandEvent & evt )

private

Definition at line 3722 of file Effect.cpp.

References EffectUIClientInterface::ExportPresets(), and mClient.

 {
    // may throw
    // exceptions are handled in AudacityApp::OnExceptionInMainLoop
    mClient->ExportPresets();
 
    return;
 }

void EffectUIHost::OnFactoryPreset ( wxCommandEvent & evt )

private

Definition at line 3614 of file Effect.cpp.

References kFactoryPresetsID, Effect::LoadFactoryPreset(), and mEffect.

 {
    mEffect->LoadFactoryPreset(evt.GetId() - kFactoryPresetsID);
 
    return;
 }

void EffectUIHost::OnFFwd ( wxCommandEvent & evt )

private

Definition at line 3529 of file Effect.cpp.

References gAudioIO, AudioIO::GetStreamTime(), gPrefs, mPlaying, mPlayPos, mRegion, AudioIO::SeekStream(), SelectedRegion::t0(), and SelectedRegion::t1().

 {
    if (mPlaying)
    {
       double seek;
       gPrefs->Read(wxT("/AudioIO/SeekShortPeriod"), &seek, 1.0);
 
       double pos = gAudioIO->GetStreamTime();
       if (mRegion.t0() < mRegion.t1() && pos + seek > mRegion.t1())
       {
          seek = mRegion.t1() - pos;
       }
 
       gAudioIO->SeekStream(seek);
    }
    else
    {
       // It allows to play past end of selection...probably useless
       mPlayPos = mRegion.t1();
    }
 }

void EffectUIHost::OnHelp ( wxCommandEvent & evt )

private

Definition at line 3322 of file Effect.cpp.

References Effect::GetFamilyId(), Effect::HelpPage(), Effect::ManualPage(), mEffect, NYQUISTEFFECTS_FAMILY, and HelpSystem::ShowHelp().

 {
    if (mEffect && mEffect->GetFamilyId() == NYQUISTEFFECTS_FAMILY && (mEffect->ManualPage().IsEmpty())) {
       // Old ShowHelp required when there is no on-line manual.
       // Always use default web browser to allow full-featured HTML pages.
       HelpSystem::ShowHelp(FindWindow(wxID_HELP), mEffect->HelpPage(), wxEmptyString, true, true);
    }
    else if( mEffect )
    {
       // otherwise use the NEW ShowHelp
       HelpSystem::ShowHelp(FindWindow(wxID_HELP), mEffect->ManualPage(), true);
    }
 }

void EffectUIHost::OnImport ( wxCommandEvent & evt )

private

Definition at line 3713 of file Effect.cpp.

References EffectUIClientInterface::ImportPresets(), LoadUserPresets(), and mClient.

 {
    mClient->ImportPresets();
 
    LoadUserPresets();
 
    return;
 }

void EffectUIHost::OnInitDialog ( wxInitDialogEvent & evt )

private

Definition at line 3184 of file Effect.cpp.

 {
    // Do default handling
    wxDialogWrapper::OnInitDialog(evt);
 
 #if wxCHECK_VERSION(3, 0, 0)
 //#warning "check to see if this still needed in wx3"
 #endif
 
    // Pure hackage coming down the pike...
    //
    // I have no idea why, but if a wxTextCtrl is the first control in the
    // panel, then its contents will not be automatically selected when the
    // dialog is displayed.
    //
    // So, we do the selection manually.
    wxTextCtrl *focused = wxDynamicCast(FindFocus(), wxTextCtrl);
    if (focused)
    {
       focused->SelectAll();
    }
 }

void EffectUIHost::OnMenu ( wxCommandEvent & evt )

private

Definition at line 3343 of file Effect.cpp.

References _(), EffectUIClientInterface::CanExportPresets(), Effect::GetDescription(), Effect::GetFactoryPresets(), Effect::GetFamilyId(), IdentInterface::GetTranslatedName(), Effect::GetVendor(), Effect::GetVersion(), EffectUIClientInterface::HasOptions(), kDefaultsID, kDeletePresetDummyID, kDeletePresetID, kDummyID, kExportID, kFactoryPresetsID, kImportID, kMenuID, kOptionsID, kSaveAsID, kUserPresetsDummyID, kUserPresetsID, label, LoadUserPresets(), mClient, mEffect, mUserPresets, and IdentInterfaceSymbol::Translation().

 {
    wxMenu menu;
    if( !mEffect )
       return;
 
    LoadUserPresets();
 
    if (mUserPresets.GetCount() == 0)
    {
       menu.Append(kUserPresetsDummyID, _("User Presets"))->Enable(false);
    }
    else
    {
       auto sub = std::make_unique<wxMenu>();
       for (size_t i = 0, cnt = mUserPresets.GetCount(); i < cnt; i++)
       {
          sub->Append(kUserPresetsID + i, mUserPresets[i]);
       }
       menu.Append(0, _("User Presets"), sub.release());
    }
 
    menu.Append(kSaveAsID, _("Save Preset..."));
 
    if (mUserPresets.GetCount() == 0)
    {
       menu.Append(kDeletePresetDummyID, _("Delete Preset"))->Enable(false);
    }
    else
    {
       auto sub = std::make_unique<wxMenu>();
       for (size_t i = 0, cnt = mUserPresets.GetCount(); i < cnt; i++)
       {
          sub->Append(kDeletePresetID + i, mUserPresets[i]);
       }
       menu.Append(0, _("Delete Preset"), sub.release());
    }
 
    menu.AppendSeparator();
 
    wxArrayString factory = mEffect->GetFactoryPresets();
 
    {
       auto sub = std::make_unique<wxMenu>();
       sub->Append(kDefaultsID, _("Defaults"));
       if (factory.GetCount() > 0)
       {
          sub->AppendSeparator();
          for (size_t i = 0, cnt = factory.GetCount(); i < cnt; i++)
          {
             wxString label = factory[i];
             if (label.IsEmpty())
             {
                label = _("None");
             }
 
             sub->Append(kFactoryPresetsID + i, label);
          }
       }
       menu.Append(0, _("Factory Presets"), sub.release());
    }
 
    menu.AppendSeparator();
    menu.Append(kImportID, _("Import..."))->Enable(mClient->CanExportPresets());
    menu.Append(kExportID, _("Export..."))->Enable(mClient->CanExportPresets());
    menu.AppendSeparator();
    menu.Append(kOptionsID, _("Options..."))->Enable(mClient->HasOptions());
    menu.AppendSeparator();
 
    {
       auto sub = std::make_unique<wxMenu>();
 
       sub->Append(kDummyID, wxString::Format(_("Type: %s"),
                   ::wxGetTranslation( mEffect->GetFamilyId().Translation() )));
       sub->Append(kDummyID, wxString::Format(_("Name: %s"), mEffect->GetTranslatedName()));
       sub->Append(kDummyID, wxString::Format(_("Version: %s"), mEffect->GetVersion()));
       sub->Append(kDummyID, wxString::Format(_("Vendor: %s"), mEffect->GetVendor().Translation()));
       sub->Append(kDummyID, wxString::Format(_("Description: %s"), mEffect->GetDescription()));
 
       menu.Append(0, _("About"), sub.release());
    }
 
    wxWindow *btn = FindWindow(kMenuID);
    wxRect r = btn->GetRect();
    btn->PopupMenu(&menu, r.GetLeft(), r.GetBottom());
 }

void EffectUIHost::OnOptions ( wxCommandEvent & evt )

private

Definition at line 3731 of file Effect.cpp.

References mClient, and EffectUIClientInterface::ShowOptions().

 {
    mClient->ShowOptions();
 
    return;
 }

void EffectUIHost::OnPaint ( wxPaintEvent & evt )

private

Definition at line 3212 of file Effect.cpp.

 {
    wxPaintDC dc(this);
 
    dc.Clear();
 }

void EffectUIHost::OnPlay ( wxCommandEvent & evt )

private

Definition at line 3462 of file Effect.cpp.

References gAudioIO, AudacityProject::GetControlToolBar(), AudacityProject::GetDefaultPlayOptions(), AudacityProject::GetPlayRegion(), AudioIO::GetStreamTime(), AudacityProject::IsPlayRegionLocked(), mClient, mEffect, mPlaying, mPlayPos, mProject, mRegion, mSupportsRealtime, AudacityProject::mViewInfo, normalPlay, ControlToolBar::PlayPlayRegion(), Effect::Preview(), ViewInfo::selectedRegion, SelectedRegion::setTimes(), ControlToolBar::StopPlaying(), SelectedRegion::t0(), SelectedRegion::t1(), Effect::TransferDataFromWindow(), and EffectUIClientInterface::ValidateUI().

 {
    if (!mSupportsRealtime)
    {
       if (!mClient->ValidateUI() || !mEffect->TransferDataFromWindow())
       {
          return;
       }
 
       mEffect->Preview(false);
 
       return;
    }
 
    if (mPlaying)
    {
       mPlayPos = gAudioIO->GetStreamTime();
       mProject->GetControlToolBar()->StopPlaying();
    }
    else
    {
       if (mProject->IsPlayRegionLocked())
       {
          double t0, t1;
          mProject->GetPlayRegion(&t0, &t1);
          mRegion.setTimes(t0, t1);
          mPlayPos = mRegion.t0();
       }
       else if (mProject->mViewInfo.selectedRegion.t0() != mRegion.t0() ||
                mProject->mViewInfo.selectedRegion.t1() != mRegion.t1())
       {
          mRegion = mProject->mViewInfo.selectedRegion;
          mPlayPos = mRegion.t0();
       }
 
       if (mPlayPos > mRegion.t1())
       {
          mPlayPos = mRegion.t1();
       }
 
       mProject->GetControlToolBar()->PlayPlayRegion
          (SelectedRegion(mPlayPos, mRegion.t1()),
           mProject->GetDefaultPlayOptions(), PlayMode::normalPlay);
    }
 }

void EffectUIHost::OnPlayback ( wxCommandEvent & evt )

private

Definition at line 3551 of file Effect.cpp.

References mDisableTransport, mPlaying, mPlayPos, mProject, mRegion, AudacityProject::mViewInfo, ViewInfo::selectedRegion, SelectedRegion::t0(), and UpdateControls().

Referenced by InitializeRealtime().

 {
    evt.Skip();
 
    if (evt.GetInt() != 0)
    {
       if (evt.GetEventObject() != mProject)
       {
          mDisableTransport = true;
       }
       else
       {
          mPlaying = true;
       }
    }
    else
    {
       mDisableTransport = false;
       mPlaying = false;
    }
 
    if (mPlaying)
    {
       mRegion = mProject->mViewInfo.selectedRegion;
       mPlayPos = mRegion.t0();
    }
 
    UpdateControls();
 }

void EffectUIHost::OnRewind ( wxCommandEvent & evt )

private

Definition at line 3508 of file Effect.cpp.

References gAudioIO, AudioIO::GetStreamTime(), gPrefs, mPlaying, mPlayPos, mRegion, AudioIO::SeekStream(), and SelectedRegion::t0().

 {
    if (mPlaying)
    {
       double seek;
       gPrefs->Read(wxT("/AudioIO/SeekShortPeriod"), &seek, 1.0);
 
       double pos = gAudioIO->GetStreamTime();
       if (pos - seek < mRegion.t0())
       {
          seek = pos - mRegion.t0();
       }
 
       gAudioIO->SeekStream(-seek);
    }
    else
    {
       mPlayPos = mRegion.t0();
    }
 }

void EffectUIHost::OnSaveAs ( wxCommandEvent & evt )

private

Definition at line 3638 of file Effect.cpp.

References _(), ShuttleGui::AddStandardButtons(), ShuttleGuiBase::AddTextBox(), eIsCreating, ShuttleGuiBase::EndHorizontalLay(), ShuttleGuiBase::EndPanel(), ShuttleGuiBase::EndVerticalLay(), Effect::GetUserPresetsGroup(), LoadUserPresets(), mEffect, mUserPresets, name, Effect::SaveUserPreset(), ShuttleGuiBase::SetBorder(), ShuttleGuiBase::StartHorizontalLay(), ShuttleGuiBase::StartPanel(), and ShuttleGuiBase::StartVerticalLay().

 {
    wxTextCtrl *text;
    wxString name;
    wxDialogWrapper dlg(this, wxID_ANY, wxString(_("Save Preset")));
 
    ShuttleGui S(&dlg, eIsCreating);
 
    S.StartPanel();
    {
       S.StartVerticalLay(1);
       {
          S.StartHorizontalLay(wxALIGN_LEFT, 0);
          {
             text = S.AddTextBox(_("Preset name:"), name, 30);
          }
          S.EndHorizontalLay();
          S.SetBorder(10);
          S.AddStandardButtons();
       }
       S.EndVerticalLay();
    }
    S.EndPanel();
 
    dlg.SetSize(dlg.GetSizer()->GetMinSize());
    dlg.Center();
 
    while (true)
    {
       int rc = dlg.ShowModal();
 
       if (rc != wxID_OK)
       {
          break;
       }
 
       name = text->GetValue();
       if (name.IsEmpty())
       {
          AudacityMessageDialog md(this,
                             _("You must specify a name"),
                             _("Save Preset"));
          md.Center();
          md.ShowModal();
          continue;
       }
 
       if (mUserPresets.Index(name) != wxNOT_FOUND)
       {
          AudacityMessageDialog md(this,
                             _("Preset already exists.\n\nReplace?"),
                             _("Save Preset"),
                             wxYES_NO | wxCANCEL | wxICON_EXCLAMATION);
          md.Center();
          int choice = md.ShowModal();
          if (choice == wxID_CANCEL)
          {
             break;
          }
 
          if (choice == wxID_NO)
          {
             continue;
          }
       }
 
       mEffect->SaveUserPreset(mEffect->GetUserPresetsGroup(name));
       LoadUserPresets();
 
       break;
    }
 
    return;
 }

void EffectUIHost::OnUserPreset ( wxCommandEvent & evt )

private

Definition at line 3605 of file Effect.cpp.

References Effect::GetUserPresetsGroup(), kUserPresetsID, Effect::LoadUserPreset(), mEffect, and mUserPresets.

 {
    int preset = evt.GetId() - kUserPresetsID;
 
    mEffect->LoadUserPreset(mEffect->GetUserPresetsGroup(mUserPresets[preset]));
 
    return;
 }

void EffectUIHost::Resume ( )

private

Definition at line 3430 of file Effect.cpp.

References mClient, mEffect, mEnableCb, mEnabled, Effect::RealtimeResume(), and EffectUIClientInterface::ValidateUI().

Referenced by OnClose(), OnEnable(), and ~EffectUIHost().

 {
    if (!mClient->ValidateUI()) {
       // If we're previewing we should still be able to stop playback
       // so don't disable transport buttons.
       //   mEffect->EnableApply(false);   // currently this would also disable transport buttons.
       // The preferred behaviour is currently undecided, so for now
       // just disallow enabling until settings are valid.
       mEnabled = false;
       mEnableCb->SetValue(mEnabled);
       return;
    }
    mEffect->RealtimeResume();
 }

int EffectUIHost::ShowModal ( )

override

Definition at line 2939 of file Effect.cpp.

References mApplyBtn, mCloseBtn, and safenew.

 {
 #if defined(__WXMSW__)
    // Swap the Close and Apply buttons
    wxSizer *sz = mApplyBtn->GetContainingSizer();
    wxASSERT(mApplyBtn->GetParent()); // To justify safenew
    wxButton *apply = safenew wxButton(mApplyBtn->GetParent(), wxID_APPLY);
    sz->Replace(mCloseBtn, apply);
    sz->Replace(mApplyBtn, mCloseBtn);
    sz->Layout();
    mApplyBtn->Destroy();
    mApplyBtn = apply;
    mApplyBtn->SetDefault();
    mApplyBtn->SetLabel(wxGetStockLabel(wxID_OK, 0));
    mCloseBtn->SetLabel(wxGetStockLabel(wxID_CANCEL, 0));
 #else
    mApplyBtn->SetLabel(wxGetStockLabel(wxID_OK));
    mCloseBtn->SetLabel(wxGetStockLabel(wxID_CANCEL));
 #endif
 
    Layout();
 
    return wxDialogWrapper::ShowModal();
 }

bool EffectUIHost::TransferDataFromWindow ( )

override

Definition at line 2926 of file Effect.cpp.

References mCommand, mEffect, AudacityCommand::TransferDataFromWindow(), and Effect::TransferDataFromWindow().

 {
    if( mEffect) 
       return mEffect->TransferDataFromWindow();
    if( mCommand) 
       return mCommand->TransferDataFromWindow();
    return false;
 }

bool EffectUIHost::TransferDataToWindow ( )

override

Definition at line 2917 of file Effect.cpp.

References mCommand, mEffect, AudacityCommand::TransferDataToWindow(), and Effect::TransferDataToWindow().

 {
    if( mEffect )
       return mEffect->TransferDataToWindow();
    if( mCommand )
       return mCommand->TransferDataToWindow();
    return false;
 }

void EffectUIHost::UpdateControls ( )

private

Definition at line 3781 of file Effect.cpp.

References _(), EffectTypeAnalyze, EffectTypeTool, Effect::GetType(), mApplyBtn, mCapturing, mCloseBtn, mDisableTransport, mEffect, mEnableCb, mFFwdBtn, mIsBatch, mIsGUI, mPlayBM, mPlayBtn, mPlayDisabledBM, mPlaying, mPlayToggleBtn, mRewindBtn, mStopBM, mStopDisabledBM, and mSupportsRealtime.

Referenced by Initialize(), OnCapture(), OnEnable(), and OnPlayback().

 {
    if (mIsBatch)
    {
       return;
    }
 
    if (mCapturing || mDisableTransport)
    {
       // Don't allow focus to get trapped
       wxWindow *focus = FindFocus();
       if (focus == mRewindBtn || focus == mFFwdBtn || focus == mPlayBtn || focus == mEnableCb)
       {
          mCloseBtn->SetFocus();
       }
    }
 
    mApplyBtn->Enable(!mCapturing);
    if (mEffect && (mEffect->GetType() != EffectTypeAnalyze) && (mEffect->GetType() != EffectTypeTool) )
    {
       (!mIsGUI ? mPlayToggleBtn : mPlayBtn)->Enable(!(mCapturing || mDisableTransport));
    }
 
    if (mSupportsRealtime)
    {
       mRewindBtn->Enable(!(mCapturing || mDisableTransport));
       mFFwdBtn->Enable(!(mCapturing || mDisableTransport));
       mEnableCb->Enable(!(mCapturing || mDisableTransport));
 
       wxBitmapButton *bb;
 
       if (mPlaying)
       {
          if (!mIsGUI)
          {
             /* i18n-hint: The access key "&P" should be the same in
                "Stop &Playback" and "Start &Playback" */
             mPlayToggleBtn->SetLabel(_("Stop &Playback"));
             mPlayToggleBtn->Refresh();
          }
          else
          {
             bb = (wxBitmapButton *) mPlayBtn;
             bb->SetBitmapLabel(mStopBM);
             bb->SetBitmapDisabled(mStopDisabledBM);
             bb->SetToolTip(_("Stop"));
 #if defined(__WXMAC__)
             bb->SetName(_("Stop &Playback"));
 #else
             bb->SetLabel(_("Stop &Playback"));
 #endif
          }
       }
       else
       {
          if (!mIsGUI)
          {
             /* i18n-hint: The access key "&P" should be the same in
                "Stop &Playback" and "Start &Playback" */
             mPlayToggleBtn->SetLabel(_("Start &Playback"));
             mPlayToggleBtn->Refresh();
          }
          else
          {
             bb = (wxBitmapButton *) mPlayBtn;
             bb->SetBitmapLabel(mPlayBM);
             bb->SetBitmapDisabled(mPlayDisabledBM);
             bb->SetToolTip(_("Play"));
 #if defined(__WXMAC__)
             bb->SetName(_("Start &Playback"));
 #else
             bb->SetLabel(_("Start &Playback"));
 #endif
          }
       }
    }
 }