RealtimeEffectListWindow Class Reference

Inheritance diagram for RealtimeEffectListWindow:

Collaboration diagram for RealtimeEffectListWindow:

Public Member Functions
	RealtimeEffectListWindow (wxWindow *parent, wxWindowID winid=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxScrolledWindowStyle, const wxString &name=wxPanelNameStr)
void	UpdatePrefs () override
std::optional< wxString >	PickEffect (wxWindow *parent, const wxString &selectedEffectID) override
void	UpdateEffectMenuItems ()
void	OnSizeChanged (wxSizeEvent &event)
void	OnEffectListItemChange (const RealtimeEffectListMessage &msg)
void	ResetTrack ()
void	SetTrack (AudacityProject &project, const std::shared_ptr< SampleTrack > &track)
void	EnableEffects (bool enable)
void	ReloadEffectsList ()
void	OnAddEffectClicked (const wxCommandEvent &event)
void	InsertEffectRow (size_t index, const std::shared_ptr< RealtimeEffectState > &pState)
Public Member Functions inherited from PrefsListener
	PrefsListener ()
virtual	~PrefsListener ()
virtual void	UpdatePrefs ()=0

Private Attributes
wxWeakRef< AudacityProject >	mProject
std::shared_ptr< SampleTrack >	mTrack
AButton *	mAddEffect {nullptr}
wxStaticText *	mAddEffectHint {nullptr}
wxWindow *	mAddEffectTutorialLink {nullptr}
wxWindow *	mEffectListContainer {nullptr}
std::unique_ptr< MenuRegistry::MenuItem >	mEffectMenuRoot
Observer::Subscription	mEffectListItemMovedSubscription
Observer::Subscription	mPluginsChangedSubscription

Additional Inherited Members
Static Public Member Functions inherited from PrefsListener
static void	Broadcast (int id=0)
	Call this static function to notify all PrefsListener objects. More...
Protected Member Functions inherited from PrefsListener
virtual void	UpdateSelectedPrefs (int id)

Detailed Description

Definition at line 561 of file RealtimeEffectPanel.cpp.

Constructor & Destructor Documentation

RealtimeEffectListWindow()

RealtimeEffectListWindow::RealtimeEffectListWindow ( wxWindow *  parent, wxWindowID  winid = wxID_ANY, const wxPoint &  pos = wxDefaultPosition, const wxSize &  size = wxDefaultSize, long  style = wxScrolledWindowStyle, const wxString &  name = wxPanelNameStr  )

inline

i18n-hint: undo history record first parameter - realtime effect name second parameter - track name

i18n-hint: undo history record first parameter - realtime effect name second parameter - track name

Definition at line 579 of file RealtimeEffectPanel.cpp.

      : wxScrolledWindow(parent, winid, pos, size, style, name)
   {
      Bind(wxEVT_SIZE, &RealtimeEffectListWindow::OnSizeChanged, this);
#ifdef __WXMSW__
      //Fixes flickering on redraw
      wxScrolledWindow::SetDoubleBuffered(true);
#endif
      auto rootSizer = std::make_unique<wxBoxSizer>(wxVERTICAL);
 
      auto effectListContainer = safenew ThemedWindowWrapper<wxPanel>(this, wxID_ANY);
      effectListContainer->SetBackgroundColorIndex(clrMedium);
      effectListContainer->SetSizer(safenew wxBoxSizer(wxVERTICAL));
      effectListContainer->SetDoubleBuffered(true);
      effectListContainer->Hide();
      mEffectListContainer = effectListContainer;
 
      auto addEffect = safenew ThemedAButtonWrapper<AButton>(this, wxID_ANY);
      addEffect->SetImageIndices(0,
            bmpHButtonNormal,
            bmpHButtonHover,
            bmpHButtonDown,
            bmpHButtonHover,
            bmpHButtonDisabled);
      addEffect->SetTranslatableLabel(XO("Add effect"));
      addEffect->SetButtonType(AButton::TextButton);
      addEffect->SetBackgroundColorIndex(clrMedium);
      addEffect->SetForegroundColorIndex(clrTrackPanelText);
      addEffect->Bind(wxEVT_BUTTON, &RealtimeEffectListWindow::OnAddEffectClicked, this);
      mAddEffect = addEffect;
 
      auto addEffectHint = safenew ThemedWindowWrapper<wxStaticText>(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxST_NO_AUTORESIZE);
      //Workaround: text is set in the OnSizeChange
      addEffectHint->SetForegroundColorIndex(clrTrackPanelText);
      mAddEffectHint = addEffectHint;
 
      auto addEffectTutorialLink = safenew ThemedWindowWrapper<wxHyperlinkCtrl>(
         this, wxID_ANY, _("Watch video"),
         "https://www.audacityteam.org/realtime-video", wxDefaultPosition,
         wxDefaultSize, wxHL_ALIGN_LEFT | wxHL_CONTEXTMENU);
      
      //i18n-hint: Hyperlink to the effects stack panel tutorial video
      addEffectTutorialLink->SetTranslatableLabel(XO("Watch video"));
#if wxUSE_ACCESSIBILITY
      safenew WindowAccessible(addEffectTutorialLink);
#endif
 
      addEffectTutorialLink->Bind(
         wxEVT_HYPERLINK, [](wxHyperlinkEvent& event)
         { BasicUI::OpenInDefaultBrowser(event.GetURL()); });
 
      mAddEffectTutorialLink = addEffectTutorialLink;
 
      //indicates the insertion position of the item
      auto dropHintLine = safenew ThemedWindowWrapper<DropHintLine>(effectListContainer, wxID_ANY);
      dropHintLine->SetBackgroundColorIndex(clrDropHintHighlight);
      dropHintLine->Hide();
 
      rootSizer->Add(mEffectListContainer, 0, wxEXPAND | wxBOTTOM, 10);
      rootSizer->Add(addEffect, 0, wxLEFT | wxRIGHT | wxBOTTOM | wxEXPAND, 20);
      rootSizer->Add(addEffectHint, 0, wxLEFT | wxRIGHT | wxBOTTOM | wxEXPAND, 20);
      rootSizer->Add(addEffectTutorialLink, 0, wxLEFT | wxRIGHT | wxEXPAND, 20);
 
      SetSizer(rootSizer.release());
      SetMinSize({});
 
      Bind(EVT_MOVABLE_CONTROL_DRAG_STARTED, [dropHintLine](const MovableControlEvent& event)
      {
         if(auto window = dynamic_cast<wxWindow*>(event.GetEventObject()))
            window->Raise();
      });
      Bind(EVT_MOVABLE_CONTROL_DRAG_POSITION, [this, dropHintLine](const MovableControlEvent& event)
      {
         constexpr auto DropHintLineHeight { 3 };//px
 
         auto sizer = mEffectListContainer->GetSizer();
         assert(sizer != nullptr);
 
         if(event.GetSourceIndex() == event.GetTargetIndex())
         {
            //do not display hint line if position didn't change
            dropHintLine->Hide();
            return;
         }
 
         if(!dropHintLine->IsShown())
         {
            dropHintLine->Show();
            dropHintLine->Raise();
            if(auto window = dynamic_cast<wxWindow*>(event.GetEventObject()))
               window->Raise();
         }
 
         auto item = sizer->GetItem(event.GetTargetIndex());
         dropHintLine->SetSize(item->GetSize().x, DropHintLineHeight);
 
         if(event.GetTargetIndex() > event.GetSourceIndex())
            dropHintLine->SetPosition(item->GetRect().GetBottomLeft() - wxPoint(0, DropHintLineHeight));
         else
            dropHintLine->SetPosition(item->GetRect().GetTopLeft());
      });
      Bind(EVT_MOVABLE_CONTROL_DRAG_FINISHED, [this, dropHintLine](const MovableControlEvent& event)
      {
         dropHintLine->Hide();
 
         if(mProject == nullptr)
            return;
 
         auto& effectList = RealtimeEffectList::Get(*mTrack);
         const auto from = event.GetSourceIndex();
         const auto to = event.GetTargetIndex();
         if(from != to)
         {
            auto effectName =
               effectList.GetStateAt(from)->GetEffect()->GetName();
            bool up = (to < from);
            effectList.MoveEffect(from, to);
            ProjectHistory::Get(*mProject).PushState(
               (up
                  ? XO("Moved %s up in %s")
                  : XO("Moved %s down in %s"))
                  .Format(effectName, mTrack->GetName()),
               XO("Change effect order"), UndoPush::CONSOLIDATE);
         }
         else
         {
            wxWindowUpdateLocker freeze(this);
            Layout();
         }
      });
      SetScrollRate(0, 20);
      
      mPluginsChangedSubscription = PluginManager::Get().Subscribe(
         [this](PluginsChangedMessage)
         {
            UpdateEffectMenuItems();
         });
      UpdateEffectMenuItems();
   }

References _, CONSOLIDATE, PluginManager::Get(), ProjectHistory::Get(), RealtimeEffectList::Get(), mAddEffect, mAddEffectHint, mAddEffectTutorialLink, mEffectListContainer, mPluginsChangedSubscription, mProject, mTrack, OnAddEffectClicked(), OnSizeChanged(), BasicUI::OpenInDefaultBrowser(), ProjectHistory::PushState(), safenew, Observer::Publisher< Message, NotifyAll >::Subscribe(), AButton::TextButton, UpdateEffectMenuItems(), and XO().

Here is the call graph for this function:

Member Function Documentation

EnableEffects()

void RealtimeEffectListWindow::EnableEffects ( bool  enable )

inline

Definition at line 929 of file RealtimeEffectPanel.cpp.

   {
      if (mTrack)
         RealtimeEffectList::Get(*mTrack).SetActive(enable);
   }

References RealtimeEffectList::Get(), mTrack, and RealtimeEffectList::SetActive().

Referenced by RealtimeEffectPanel::RealtimeEffectPanel().

Here is the call graph for this function:

Here is the caller graph for this function:

InsertEffectRow()

void RealtimeEffectListWindow::InsertEffectRow ( size_t  index, const std::shared_ptr< RealtimeEffectState > &  pState  )

inline

Definition at line 1005 of file RealtimeEffectPanel.cpp.

   {
      if(mProject == nullptr)
         return;
 
      // See comment in ReloadEffectsList
      if(!mEffectListContainer->IsShown())
         mEffectListContainer->Show();
 
      auto row = safenew ThemedWindowWrapper<RealtimeEffectControl>(mEffectListContainer, this, wxID_ANY);
      row->SetBackgroundColorIndex(clrEffectListItemBackground);
      row->SetEffect(*mProject, mTrack, pState);
      mEffectListContainer->GetSizer()->Insert(index, row, 0, wxEXPAND);
   }

References mEffectListContainer, mProject, mTrack, and safenew.

Referenced by OnEffectListItemChange(), and ReloadEffectsList().

Here is the caller graph for this function:

OnAddEffectClicked()

void RealtimeEffectListWindow::OnAddEffectClicked ( const wxCommandEvent &  event )

inline

i18n-hint: undo history record first parameter - realtime effect name second parameter - track name

Definition at line 966 of file RealtimeEffectPanel.cpp.

   {
      if(!mTrack || mProject == nullptr)
         return;
 
      const auto effectID = PickEffect(dynamic_cast<wxWindow*>(event.GetEventObject()), {});
      
      if(!effectID || effectID->empty())
         return;
 
      auto plug = PluginManager::Get().GetPlugin(*effectID);
      if(!plug)
         return;
 
      if(!PluginManager::IsPluginAvailable(*plug)) {
         BasicUI::ShowMessageBox(
            XO("This plugin could not be loaded.\nIt may have been deleted."),
            BasicUI::MessageBoxOptions()
               .Caption(XO("Plugin Error")));
 
         return;
      }
 
      if(auto state = AudioIO::Get()->AddState(*mProject, &*mTrack, *effectID))
      {
         auto effect = state->GetEffect();
         assert(effect); // postcondition of AddState
         const auto effectName = effect->GetName();
         ProjectHistory::Get(*mProject).PushState(
            XO("Added %s to %s").Format(effectName, mTrack->GetName()),
            //i18n-hint: undo history record
            XO("Add %s").Format(effectName));
      }
   }

References AudioIO::Get(), PluginManager::Get(), ProjectHistory::Get(), PluginManager::GetPlugin(), PluginManager::IsPluginAvailable(), mProject, mTrack, PickEffect(), ProjectHistory::PushState(), BasicUI::ShowMessageBox(), and XO().

Referenced by RealtimeEffectListWindow().

Here is the call graph for this function:

Here is the caller graph for this function:

OnEffectListItemChange()

void RealtimeEffectListWindow::OnEffectListItemChange ( const RealtimeEffectListMessage &  msg )

inline

Definition at line 827 of file RealtimeEffectPanel.cpp.

   {
      auto sizer = mEffectListContainer->GetSizer();
      const auto insertItem = [this, &msg](){
         auto& effects = RealtimeEffectList::Get(*mTrack);
         InsertEffectRow(msg.srcIndex, effects.GetStateAt(msg.srcIndex));
         mAddEffectHint->Hide();
         mAddEffectTutorialLink->Hide();
      };
      const auto removeItem = [&](){
         auto& ui = RealtimeEffectStateUI::Get(*msg.affectedState);
         // Don't need to auto-save changed settings of effect that is deleted
         // Undo history push will do it anyway
         ui.Hide();
         
         auto window = sizer->GetItem(msg.srcIndex)->GetWindow();
         sizer->Remove(msg.srcIndex);
         wxTheApp->CallAfter([ref = wxWeakRef { window }] {
            if(ref) ref->Destroy();
         });
         
         if(sizer->IsEmpty())
         {
            if(mEffectListContainer->IsDescendant(FindFocus()))
               mAddEffect->SetFocus();
            
            mEffectListContainer->Hide();
            mAddEffectHint->Show();
            mAddEffectTutorialLink->Show();
         }
      };
 
      wxWindowUpdateLocker freeze(this);
      if(msg.type == RealtimeEffectListMessage::Type::Move)
      {
         const auto sizer = mEffectListContainer->GetSizer();
 
         const auto movedItem = sizer->GetItem(msg.srcIndex);
 
         const auto proportion = movedItem->GetProportion();
         const auto flag = movedItem->GetFlag();
         const auto border = movedItem->GetBorder();
         const auto window = movedItem->GetWindow();
 
         if(msg.srcIndex < msg.dstIndex)
            window->MoveAfterInTabOrder(sizer->GetItem(msg.dstIndex)->GetWindow());
         else
            window->MoveBeforeInTabOrder(sizer->GetItem(msg.dstIndex)->GetWindow());
         
         sizer->Remove(msg.srcIndex);
         sizer->Insert(msg.dstIndex, window, proportion, flag, border);
      }
      else if(msg.type == RealtimeEffectListMessage::Type::Insert)
      {
         insertItem();
      }
      else if(msg.type == RealtimeEffectListMessage::Type::WillReplace)
      {
         removeItem();
      }
      else if(msg.type == RealtimeEffectListMessage::Type::DidReplace)
      {
         insertItem();
      }
      else if(msg.type == RealtimeEffectListMessage::Type::Remove)
      {
         removeItem();
      }
      SendSizeEventToParent();
   }

References RealtimeEffectListMessage::affectedState, RealtimeEffectListMessage::DidReplace, RealtimeEffectListMessage::dstIndex, BasicUI::FindFocus(), flag, RealtimeEffectList::Get(), RealtimeEffectStateUI::Get(), RealtimeEffectListMessage::Insert, InsertEffectRow(), mAddEffect, mAddEffectHint, mAddEffectTutorialLink, mEffectListContainer, RealtimeEffectListMessage::Move, mTrack, RealtimeEffectListMessage::Remove, RealtimeEffectListMessage::srcIndex, RealtimeEffectListMessage::type, and RealtimeEffectListMessage::WillReplace.

Referenced by SetTrack().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSizeChanged()

void RealtimeEffectListWindow::OnSizeChanged ( wxSizeEvent &  event )

inline

Definition at line 811 of file RealtimeEffectPanel.cpp.

   {
      if(auto sizerItem = GetSizer()->GetItem(mAddEffectHint))
      {
         //We need to wrap the text whenever panel width changes and adjust widget height
         //so that text is fully visible, but there is no height-for-width layout algorithm
         //in wxWidgets yet, so for now we just do it manually
 
         //Restore original text, because 'Wrap' will replace it with wrapped one
         mAddEffectHint->SetLabel(_("Realtime effects are non-destructive and can be changed at any time."));
         mAddEffectHint->Wrap(GetClientSize().x - sizerItem->GetBorder() * 2);
         mAddEffectHint->InvalidateBestSize();
      }
      event.Skip();
   }

References _, and mAddEffectHint.

Referenced by RealtimeEffectListWindow().

Here is the caller graph for this function:

PickEffect()

std::optional< wxString > RealtimeEffectListWindow::PickEffect ( wxWindow *  parent, const wxString &  selectedEffectID  )

inlineoverride

Definition at line 737 of file RealtimeEffectPanel.cpp.

   {
      if (mProject == nullptr)
         return {};
   
      wxMenu menu;
      if(!selectedEffectID.empty())
      {
         //no need to handle language change since menu creates its own event loop
         menu.Append(wxID_REMOVE, _("No Effect"));
         menu.AppendSeparator();
      }
      
      RealtimeEffectsMenuVisitor visitor { menu };
      
      Registry::VisitWithFunctions(visitor, mEffectMenuRoot.get(), {}, *mProject);
      
      int commandId = wxID_NONE;
      
      menu.AppendSeparator();
      menu.Append(wxID_MORE, _("Get more effects..."));
      
      menu.Bind(wxEVT_MENU, [&](wxCommandEvent evt) { commandId = evt.GetId(); });
      
      if(parent->PopupMenu(&menu, parent->GetClientRect().GetLeftBottom()) && commandId != wxID_NONE)
      {
         if(commandId == wxID_REMOVE)
            return wxString {};
         else if(commandId == wxID_MORE)
            OpenInDefaultBrowser("https://plugins.audacityteam.org/");
         else
            return visitor.GetPluginID(commandId).GET();
      }
      
      return {};
   }

References _, mEffectMenuRoot, mProject, BasicUI::OpenInDefaultBrowser(), and Registry::VisitWithFunctions().

Referenced by OnAddEffectClicked().

Here is the call graph for this function:

Here is the caller graph for this function:

ReloadEffectsList()

void RealtimeEffectListWindow::ReloadEffectsList ( )

inline

Definition at line 935 of file RealtimeEffectPanel.cpp.

   {
      wxWindowUpdateLocker freeze(this);
      
      const auto hadFocus = mEffectListContainer->IsDescendant(FindFocus());
      //delete items that were added to the sizer
      mEffectListContainer->Hide();
      mEffectListContainer->GetSizer()->Clear(true);
 
      
      if(!mTrack || RealtimeEffectList::Get(*mTrack).GetStatesCount() == 0)
         mEffectListContainer->Hide();
      
      auto isEmpty{true};
      if(mTrack)
      {
         auto& effects = RealtimeEffectList::Get(*mTrack);
         isEmpty = effects.GetStatesCount() == 0;
         for(size_t i = 0, count = effects.GetStatesCount(); i < count; ++i)
            InsertEffectRow(i, effects.GetStateAt(i));
      }
      mAddEffect->SetEnabled(!!mTrack);
      //Workaround for GTK: Underlying GTK widget does not update
      //its size when wxWindow size is set to zero
      mEffectListContainer->Show(!isEmpty);
      mAddEffectHint->Show(isEmpty);
      mAddEffectTutorialLink->Show(isEmpty);
      
      SendSizeEventToParent();
   }

References BasicUI::FindFocus(), RealtimeEffectList::Get(), RealtimeEffectList::GetStatesCount(), InsertEffectRow(), mAddEffect, mAddEffectHint, mAddEffectTutorialLink, mEffectListContainer, mTrack, and AButton::SetEnabled().

Referenced by ResetTrack(), and SetTrack().

Here is the call graph for this function:

Here is the caller graph for this function:

ResetTrack()

void RealtimeEffectListWindow::ResetTrack ( )

inline

Definition at line 898 of file RealtimeEffectPanel.cpp.

   {
      mEffectListItemMovedSubscription.Reset();
 
      mTrack.reset();
      mProject = nullptr;
      ReloadEffectsList();
   }

References mEffectListItemMovedSubscription, mProject, mTrack, ReloadEffectsList(), and Observer::Subscription::Reset().

Referenced by RealtimeEffectPanel::ResetTrack().

Here is the call graph for this function:

Here is the caller graph for this function:

SetTrack()

void RealtimeEffectListWindow::SetTrack ( AudacityProject &  project, const std::shared_ptr< SampleTrack > &  track  )

inline

Definition at line 907 of file RealtimeEffectPanel.cpp.

   {
      if (mTrack == track)
         return;
 
      mEffectListItemMovedSubscription.Reset();
 
      mTrack = track;
      mProject = &project;
      ReloadEffectsList();
 
      if (track)
      {
         auto& effects = RealtimeEffectList::Get(*mTrack);
         mEffectListItemMovedSubscription = effects.Subscribe(
            *this, &RealtimeEffectListWindow::OnEffectListItemChange);
 
         UpdateRealtimeEffectUIData(*track);
      }
   }

References RealtimeEffectList::Get(), mEffectListItemMovedSubscription, mProject, mTrack, OnEffectListItemChange(), project, ReloadEffectsList(), Observer::Subscription::Reset(), and anonymous_namespace{RealtimeEffectPanel.cpp}::UpdateRealtimeEffectUIData().

Referenced by RealtimeEffectPanel::SetTrack().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateEffectMenuItems()

void RealtimeEffectListWindow::UpdateEffectMenuItems ( )

inline

Definition at line 774 of file RealtimeEffectPanel.cpp.

   {
      using namespace MenuRegistry;
      auto root = Menu("", TranslatableString{});
 
      static auto realtimeEffectPredicate = [](const PluginDescriptor& desc)
      {
         return desc.IsEffectRealtime();
      };
 
      const auto groupby = RealtimeEffectsGroupBy.Read();
 
      auto analyzeSection = Section("", Menu("", XO("Analyze")));
      auto submenu =
         static_cast<MenuItem*>(analyzeSection->begin()->get());
      MenuHelper::PopulateEffectsMenu(
         *submenu,
         EffectTypeAnalyze,
         {}, groupby, nullptr,
         realtimeEffectPredicate
      );
      
      if(!submenu->empty())
      {
         root->push_back(move(analyzeSection));
      }
   
      MenuHelper::PopulateEffectsMenu(
         *root,
         EffectTypeProcess,
         {}, groupby, nullptr,
         realtimeEffectPredicate
      );
      
      mEffectMenuRoot.swap(root);
   }

References anonymous_namespace{ExportPCM.cpp}::desc, EffectTypeAnalyze, EffectTypeProcess, mEffectMenuRoot, MenuRegistry::Menu, MenuHelper::PopulateEffectsMenu(), ChoiceSetting::Read(), RealtimeEffectsGroupBy, MenuRegistry::Section, and XO().

Referenced by RealtimeEffectListWindow(), and UpdatePrefs().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdatePrefs()

void RealtimeEffectListWindow::UpdatePrefs ( )

inlineoverridevirtual

Implements PrefsListener.

Definition at line 732 of file RealtimeEffectPanel.cpp.

   {
      UpdateEffectMenuItems();
   }

References UpdateEffectMenuItems().

Here is the call graph for this function:

Member Data Documentation

mAddEffect

AButton* RealtimeEffectListWindow::mAddEffect {nullptr}

private

Definition at line 568 of file RealtimeEffectPanel.cpp.

Referenced by OnEffectListItemChange(), RealtimeEffectListWindow(), and ReloadEffectsList().

mAddEffectHint

wxStaticText* RealtimeEffectListWindow::mAddEffectHint {nullptr}

private

Definition at line 569 of file RealtimeEffectPanel.cpp.

Referenced by OnEffectListItemChange(), OnSizeChanged(), RealtimeEffectListWindow(), and ReloadEffectsList().

mAddEffectTutorialLink

wxWindow* RealtimeEffectListWindow::mAddEffectTutorialLink {nullptr}

private

Definition at line 570 of file RealtimeEffectPanel.cpp.

Referenced by OnEffectListItemChange(), RealtimeEffectListWindow(), and ReloadEffectsList().

mEffectListContainer

wxWindow* RealtimeEffectListWindow::mEffectListContainer {nullptr}

private

Definition at line 571 of file RealtimeEffectPanel.cpp.

Referenced by InsertEffectRow(), OnEffectListItemChange(), RealtimeEffectListWindow(), and ReloadEffectsList().

mEffectListItemMovedSubscription

Observer::Subscription RealtimeEffectListWindow::mEffectListItemMovedSubscription

private

Definition at line 575 of file RealtimeEffectPanel.cpp.

Referenced by ResetTrack(), and SetTrack().

mEffectMenuRoot

std::unique_ptr<MenuRegistry::MenuItem> RealtimeEffectListWindow::mEffectMenuRoot

private

Definition at line 573 of file RealtimeEffectPanel.cpp.

Referenced by PickEffect(), and UpdateEffectMenuItems().

mPluginsChangedSubscription

Observer::Subscription RealtimeEffectListWindow::mPluginsChangedSubscription

private

Definition at line 576 of file RealtimeEffectPanel.cpp.

Referenced by RealtimeEffectListWindow().

mProject

wxWeakRef<AudacityProject> RealtimeEffectListWindow::mProject

private

Definition at line 566 of file RealtimeEffectPanel.cpp.

Referenced by InsertEffectRow(), OnAddEffectClicked(), PickEffect(), RealtimeEffectListWindow(), ResetTrack(), and SetTrack().

mTrack

std::shared_ptr<SampleTrack> RealtimeEffectListWindow::mTrack

private

Definition at line 567 of file RealtimeEffectPanel.cpp.

Referenced by EnableEffects(), InsertEffectRow(), OnAddEffectClicked(), OnEffectListItemChange(), RealtimeEffectListWindow(), ReloadEffectsList(), ResetTrack(), and SetTrack().

---

The documentation for this class was generated from the following file:

• RealtimeEffectPanel.cpp