#include <LV2Editor.h>

Inheritance diagram for LV2Editor:

Collaboration diagram for LV2Editor:

Classes
struct	PlainUIControl

struct	Timer
	This must be destroyed before mSuilInstance. More...

struct	UI

Public Member Functions
	LV2Editor (const StatelessEffectUIServices &effect, EffectType type, const LilvPlugin &plug, LV2Instance &instance, EffectSettingsAccess &access, const EffectOutputs pOutputs, double sampleRate, const LV2FeaturesList &features, const LV2Ports &ports, wxWindow parent, bool useGUI)

	~LV2Editor () override

bool	ValidateUI () override
	Get settings data from the panel; may make error dialogs and return false. More...

bool	UpdateUI () override
	Update appearance of the panel for changes in settings. More...

bool	IsGraphicalUI () override

void	Disconnect () override
	On the first call only, may disconnect from further event handling. More...

int	ui_resize (int width, int height) override

void	ui_closed () override

void	SizeRequest (GtkWidget widget, GtkRequisition requisition)

bool	BuildFancy (std::unique_ptr< LV2Wrapper > pWrapper, const EffectSettings &settings)

bool	BuildPlain (EffectSettingsAccess &access)

void	suil_port_write (uint32_t port_index, uint32_t buffer_size, uint32_t protocol, const void *buffer) override

uint32_t	suil_port_index (const char *port_symbol) override

void	UpdateControlPortValue (LV2EffectSettings &settings, size_t controlPortIndex, float value)

void	OnTrigger (wxCommandEvent &evt)

void	OnToggle (wxCommandEvent &evt)

void	OnChoice (wxCommandEvent &evt)

void	OnText (wxCommandEvent &evt)

void	OnSlider (wxCommandEvent &evt)

void	OnIdle (wxIdleEvent &evt)

void	OnSize (wxSizeEvent &evt)

void	SetSlider (const LV2ControlPortState &state, const PlainUIControl &ctrl)

Public Member Functions inherited from EffectEditor
	EffectEditor (const EffectUIServices &services, EffectSettingsAccess &access)

virtual	~EffectEditor ()

virtual bool	ValidateUI ()=0
	Get settings data from the panel; may make error dialogs and return false. More...

virtual bool	UpdateUI ()
	Update appearance of the panel for changes in settings. More...

virtual bool	IsGraphicalUI ()

virtual void	Disconnect ()
	On the first call only, may disconnect from further event handling. More...

virtual void	OnClose ()

Public Member Functions inherited from Observer::Publisher< EffectSettingChanged >
	Publisher (ExceptionPolicy *pPolicy=nullptr, Alloc a={})
	Constructor supporting type-erased custom allocation/deletion. More...

	Publisher (Publisher &&)=default

Publisher &	operator= (Publisher &&)=default

Subscription	Subscribe (Callback callback)
	Connect a callback to the Publisher; later-connected are called earlier. More...

Subscription	Subscribe (Object &obj, Return(Object::*callback)(Args...))
	Overload of Subscribe takes an object and pointer-to-member-function. More...

Static Public Member Functions
static void	size_request (GtkWidget widget, GtkRequisition requisition, LV2Editor *pEditor)

static std::shared_ptr< SuilHost >	GetSuilHost ()

Static Public Member Functions inherited from EffectEditor
static bool	EnableApply (wxWindow *parent, bool enable=true)
	Enable or disable the Apply button of the dialog that contains parent. More...

static bool	EnablePreview (wxWindow *parent, bool enable=true)

Public Attributes
const LilvPlugin &	mPlug

const EffectType	mType

LV2Instance &	mInstance

const EffectOutputs *	mpOutputs {}

const double	mSampleRate

const LV2Ports &	mPorts

std::unique_ptr< LV2Wrapper >	mpWrapper

std::optional< const LV2UIFeaturesList >	mUIFeatures

LV2PortUIStates	mPortUIStates

std::shared_ptr< SuilHost >	mSuilHost

wxWindow *	mParent

bool	mUseGUI {}

std::vector< PlainUIControl >	mPlainUIControls
	Array in correspondence with the control ports. More...

struct LV2Editor::UI	mUI

wxSize	mNativeWinInitialSize { wxDefaultSize }

wxSize	mNativeWinLastSize { wxDefaultSize }

bool	mResizing { false }

bool	mResized { false }

wxWeakRef< wxDialog >	mDialog

bool	mExternalUIClosed { false }

LV2Editor::Timer	mTimer

const LV2UI_Idle_Interface *	mUIIdleInterface {}

const LV2UI_Show_Interface *	mUIShowInterface {}

NumericTextCtrl *	mDuration {}

Additional Inherited Members
Public Types inherited from Observer::Publisher< EffectSettingChanged >
using	message_type = EffectSettingChanged

using	CallbackReturn = std::conditional_t< true, void, bool >

using	Callback = std::function< CallbackReturn(const EffectSettingChanged &) >
	Type of functions that can be connected to the Publisher. More...

Static Public Attributes inherited from EffectEditor
static constexpr int	kPlayID = 20102

Static Public Attributes inherited from Observer::Publisher< EffectSettingChanged >
static constexpr bool	notifies_all

Protected Member Functions inherited from EffectEditor
template<typename EventTag , typename Class , typename Event >
void	BindTo (wxEvtHandler &src, const EventTag &eventType, void(Class::*pmf)(Event &))

Protected Member Functions inherited from Observer::Publisher< EffectSettingChanged >
CallbackReturn	Publish (const EffectSettingChanged &message)
	Send a message to connected callbacks. More...

Protected Attributes inherited from EffectEditor
const EffectUIServices &	mUIServices

EffectSettingsAccess &	mAccess

bool	mUIClosed { false }

Private Member Functions inherited from LV2UIFeaturesList::UIHandler
virtual	~UIHandler ()

virtual int	ui_resize (int width, int height)=0

virtual void	ui_closed ()=0

virtual void	suil_port_write (uint32_t port_index, uint32_t buffer_size, uint32_t protocol, const void *buffer)=0

virtual uint32_t	suil_port_index (const char *port_symbol)=0

Detailed Description

Definition at line 53 of file LV2Editor.h.

Constructor & Destructor Documentation

◆ LV2Editor()

LV2Editor::LV2Editor	(	const StatelessEffectUIServices &	effect,
		EffectType	type,
		const LilvPlugin &	plug,
		LV2Instance &	instance,
		EffectSettingsAccess &	access,
		const EffectOutputs *	pOutputs,
		double	sampleRate,
		const LV2FeaturesList &	features,
		const LV2Ports &	ports,
		wxWindow *	parent,
		bool	useGUI
	)

Definition at line 103 of file LV2Editor.cpp.

   : EffectEditor{ effect, access }
   , mPlug{ plug }
   , mType{ type }
   , mInstance{ instance }
   , mpOutputs{ pOutputs }
   , mSampleRate{ sampleRate }
   , mPorts{ ports }
   , mPortUIStates{ instance.GetPortStates(), ports }
   , mParent{ parent }
   , mUseGUI{ useGUI }
{
   if (mParent)
      mParent->PushEventHandler(this);
}

References mParent.

◆ ~LV2Editor()

LV2Editor::~LV2Editor ( )

override

Definition at line 182 of file LV2Editor.cpp.

{
   Disconnect();
}

References Disconnect().

Here is the call graph for this function:

Member Function Documentation

◆ BuildFancy()

bool LV2Editor::BuildFancy	(	std::unique_ptr< LV2Wrapper >	pWrapper,
		const EffectSettings &	settings
	)

Precondition: pWrapper != nullptr

Definition at line 203 of file LV2Editor.cpp.

{
   assert(pWrapper);
   auto &wrapper = *pWrapper;
   mpWrapper = move(pWrapper);
   using namespace LV2Symbols;
   // Set the native UI type
   const char *nativeType =
#if defined(__WXGTK3__)
      LV2_UI__Gtk3UI;
#elif defined(__WXGTK__)
      LV2_UI__GtkUI;
#elif defined(__WXMSW__)
      LV2_UI__WindowsUI;
#elif defined(__WXMAC__)
      LV2_UI__CocoaUI;
#endif
 
   // Determine if the plugin has a supported UI
   const LilvUI *ui = nullptr;
   const LilvNode *uiType = nullptr;
   using LilvUIsPtr = Lilv_ptr<LilvUIs, lilv_uis_free>;
   LilvUIsPtr uis{ lilv_plugin_get_uis(&mPlug) };
   if (uis) {
      if (LilvNodePtr containerType{ lilv_new_uri(gWorld, nativeType) }) {
         LILV_FOREACH(uis, iter, uis.get()) {
            ui = lilv_uis_get(uis.get(), iter);
            if (lilv_ui_is_supported(ui,
               suil_ui_supported, containerType.get(), &uiType))
               break;
            if (lilv_ui_is_a(ui, node_Gtk) || lilv_ui_is_a(ui, node_Gtk3)) {
               uiType = node_Gtk;
               break;
            }
            ui = nullptr;
         }
      }
   }
 
   // Check for other supported UIs
   if (!ui && uis) {
      LILV_FOREACH(uis, iter, uis.get()) {
         ui = lilv_uis_get(uis.get(), iter);
         if (lilv_ui_is_a(ui, node_ExternalUI) || lilv_ui_is_a(ui, node_ExternalUIOld)) {
            uiType = node_ExternalUI;
            break;
         }
         ui = NULL;
      }
   }
 
   // No usable UI found
   if (ui == NULL)
      return false;
 
   const auto uinode = lilv_ui_get_uri(ui);
   lilv_world_load_resource(gWorld, uinode);
   LV2UIFeaturesList::UIHandler &handler = *this;
   auto &instance = wrapper.GetInstance();
   auto &features = mUIFeatures.emplace(
      wrapper.GetFeatures(), &handler, uinode, &instance,
      (uiType == node_ExternalUI) ? nullptr : mParent);
   if (!features.mOk)
      return false;
 
   const char *containerType;
   if (uiType == node_ExternalUI)
      containerType = LV2_EXTERNAL_UI__Widget;
   else {
      containerType = nativeType;
#if defined(__WXGTK__)
      // Make sure the parent has a window
      if (!gtk_widget_get_window(GTK_WIDGET(mParent->m_wxwindow)))
         gtk_widget_realize(GTK_WIDGET(mParent->m_wxwindow));
#endif
   }
 
   // Set before creating the UI instance so the initial size (if any) can be captured
   mNativeWinInitialSize = wxDefaultSize;
   mNativeWinLastSize = wxDefaultSize;
 
   // Create the suil host
   if (!(mSuilHost = GetSuilHost()))
      return false;
 
#if defined(__WXMSW__)
   // Plugins may have dependencies that need to be loaded from the same path
   // as the main DLL, so add this plugin's path to the DLL search order.
   LilvCharsPtr libPath{
      lilv_file_uri_parse(lilv_node_as_uri(lilv_ui_get_binary_uri(ui)),
      nullptr)
   };
   const auto path = wxPathOnly(libPath.get());
   SetDllDirectory(path.c_str());
   auto cleanup = finally([&]{ SetDllDirectory(nullptr); });
#endif
 
   LilvCharsPtr bundlePath{
      lilv_file_uri_parse(lilv_node_as_uri(lilv_ui_get_bundle_uri(ui)), nullptr)
   };
   LilvCharsPtr binaryPath{
      lilv_file_uri_parse(lilv_node_as_uri(lilv_ui_get_binary_uri(ui)), nullptr)
   };
 
   // The void* that the instance passes back to our write and index
   // callback functions, which were given to suil_host_new:
   UIHandler *pHandler = this;
 
   // Reassign the sample rate, which is pointed to by options, which are
   // pointed to by features, before we tell the library the features
   mUI.mSuilInstance.reset(suil_instance_new(mSuilHost.get(),
      pHandler, containerType,
      lilv_node_as_uri(lilv_plugin_get_uri(&mPlug)),
      lilv_node_as_uri(lilv_ui_get_uri(ui)), lilv_node_as_uri(uiType),
      bundlePath.get(), binaryPath.get(),
      features.GetFeaturePointers().data()));
 
   // Bail if the instance (no compatible UI) couldn't be created
   if (!mUI.mSuilInstance)
      return false;
 
   if (uiType == node_ExternalUI) {
      mParent->SetMinSize(wxDefaultSize);
      mTimer.mExternalWidget = static_cast<LV2_External_UI_Widget *>(
         suil_instance_get_widget(mUI.mSuilInstance.get()));
      mTimer.Start(20);
      LV2_EXTERNAL_UI_SHOW(mTimer.mExternalWidget);
   } else {
      const auto widget = static_cast<WXWidget>(
         suil_instance_get_widget(mUI.mSuilInstance.get()));
 
#if defined(__WXGTK__)
      // Needed by some plugins (e.g., Invada) to ensure the display is fully
      // populated.
      gtk_widget_show_all(widget);
 
      // See note at size_request()
      g_signal_connect(widget, "size-request", G_CALLBACK(LV2Editor::size_request), this);
#endif
 
      wxWindowPtr< NativeWindow > pNativeWin{ safenew NativeWindow() };
      if (!pNativeWin->Create(mParent, widget))
         return false;
      mUI.mNativeWin = pNativeWin;
      pNativeWin->Bind(wxEVT_SIZE, &LV2Editor::OnSize, this);
 
      // The plugin called the LV2UI_Resize::ui_resize function to set the size before
      // the native window was created, so set the size now.
      if (mNativeWinInitialSize != wxDefaultSize)
         pNativeWin->SetMinSize(mNativeWinInitialSize);
 
      wxSizerItem *si = NULL;
      auto vs = std::make_unique<wxBoxSizer>(wxVERTICAL);
      auto hs = std::make_unique<wxBoxSizer>(wxHORIZONTAL);
      if (features.mNoResize) {
         si = hs->Add(pNativeWin.get(), 0, wxCENTER);
         vs->Add(hs.release(), 1, wxCENTER);
      } else {
         si = hs->Add(pNativeWin.get(), 1, wxEXPAND);
         vs->Add(hs.release(), 1, wxEXPAND);
      }
      if (!si)
         return false;
      mParent->SetSizerAndFit(vs.release());
   }
 
   mUIIdleInterface = static_cast<const LV2UI_Idle_Interface *>(
      suil_instance_extension_data(mUI.mSuilInstance.get(), LV2_UI__idleInterface));
 
   mUIShowInterface = static_cast<const LV2UI_Show_Interface *>(
      suil_instance_extension_data(mUI.mSuilInstance.get(), LV2_UI__showInterface));
 
//   if (mUIShowInterface && mUIShowInterface->show) {
//      mUIShowInterface->show(suil_instance_get_handle(mSuilInstance));
//   }
 
#ifdef __WXMAC__
#ifdef __WX_EVTLOOP_BUSY_WAITING__
   wxEventLoop::SetBusyWaiting(true);
#endif
#endif
 
   return true;
}

References GetSuilHost(), LV2Symbols::gWorld, audacity::cloud::audiocom::anonymous_namespace{AuthorizationHandler.cpp}::handler, LV2_EXTERNAL_UI__Widget, LV2_EXTERNAL_UI_SHOW, LV2Editor::Timer::mExternalWidget, LV2Editor::UI::mNativeWin, mNativeWinInitialSize, mNativeWinLastSize, mParent, mPlug, mpWrapper, mSuilHost, LV2Editor::UI::mSuilInstance, mTimer, mUI, mUIFeatures, mUIIdleInterface, mUIShowInterface, OnSize(), safenew, and size_request().

Here is the call graph for this function:

◆ BuildPlain()

bool LV2Editor::BuildPlain ( EffectSettingsAccess & access )

Captures a const reference to value!

Function to revisit the controls just added above

Definition at line 389 of file LV2Editor.cpp.

{
   auto &portUIStates = mPortUIStates;
   auto &settings = access.Get();
   auto &values = GetSettings(settings).values;
   mPlainUIControls.resize(mPorts.mControlPorts.size());
 
   int numCols = 5;
   wxSizer *innerSizer;
 
   assert(mParent); // To justify safenew
   const auto w = safenew wxScrolledWindow(mParent,
      wxID_ANY, wxDefaultPosition, wxDefaultSize, wxVSCROLL | wxTAB_TRAVERSAL);
 
   {
      auto outerSizer = std::make_unique<wxBoxSizer>(wxVERTICAL);
      w->SetScrollRate(0, 20);
      // This fools NVDA into not saying "Panel" when the dialog gets focus
      w->SetName(wxT("\a"));
      w->SetLabel(wxT("\a"));
      outerSizer->Add(w, 1, wxEXPAND);
 
      auto uInnerSizer = std::make_unique<wxBoxSizer>(wxVERTICAL);
      innerSizer = uInnerSizer.get();
 
      // Add the duration control, if a generator
      if (mType == EffectTypeGenerate) {
         auto sizer = std::make_unique<wxBoxSizer>(wxHORIZONTAL);
         auto item = safenew wxStaticText(w, 0, _("&Duration:"));
         sizer->Add(item, 0, wxALIGN_CENTER | wxALL, 5);
         auto &extra = settings.extra;
         mDuration = safenew NumericTextCtrl(
            FormatterContext::SampleRateContext(mSampleRate), w, ID_Duration,
            NumericConverterType_TIME(), extra.GetDurationFormat(),
            extra.GetDuration(),
            NumericTextCtrl::Options{}.AutoPos(true));
         mDuration->SetName( XO("Duration") );
         sizer->Add(mDuration, 0, wxALIGN_CENTER | wxALL, 5);
         auto groupSizer =
            std::make_unique<wxStaticBoxSizer>(wxVERTICAL, w, _("Generator"));
         groupSizer->Add(sizer.release(), 0, wxALIGN_CENTER | wxALL, 5);
         innerSizer->Add(groupSizer.release(), 0, wxEXPAND | wxALL, 5);
      }
 
      // Make other controls, grouped into static boxes that are named
      // according to certain control port metadata
      auto groups = mPorts.mGroups; // mutable copy
      std::sort(groups.begin(), groups.end(), TranslationLess);
      for (auto &label: groups) {
         auto gridSizer = std::make_unique<wxFlexGridSizer>(numCols, 5, 5);
         gridSizer->AddGrowableCol(3);
         for (auto & p : mPorts.mGroupMap.at(label)) /* won't throw */ {
            auto &state = portUIStates.mControlPortStates[p];
            auto &port = state.mpPort;
            auto &ctrl = mPlainUIControls[p];
            const auto &value = values[p];
            auto labelText = port->mName;
            if (!port->mUnits.empty())
               labelText += XO("(%s)").Format(port->mUnits).Translation();
 
            // A "trigger" port gets a row with just a pushbutton
            if (port->mTrigger) {
               gridSizer->Add(1, 1, 0);
 
               assert(w); // To justify safenew
               auto b = safenew wxButton(w, ID_Triggers + p, labelText);
               gridSizer->Add(b, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
               ctrl.button = b;
 
               gridSizer->Add(1, 1, 0);
               gridSizer->Add(1, 1, 0);
               gridSizer->Add(1, 1, 0);
               continue;
            }
 
            // Any other kind of port gets a name text...
            auto item = safenew wxStaticText(w, wxID_ANY, labelText + wxT(":"),
               wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT);
            gridSizer->Add(item, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT);
 
            // ... then appropriate controls and static texts in other columns
            if (port->mToggle) {
               // Toggle port gets a checkbox
               auto c = safenew wxCheckBox(w, ID_Toggles + p, wxT(""));
               c->SetName(labelText);
               c->SetValue(value > 0);
               gridSizer->Add(c, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
               ctrl.checkbox = c;
 
               gridSizer->Add(1, 1, 0);
               gridSizer->Add(1, 1, 0);
               gridSizer->Add(1, 1, 0);
            }
            else if (port->mEnumeration) {
               // Enumeration port gets a choice control
               // Discretize the value (all ports hold a float value) to
               // determine the intial selection
               auto s = port->Discretize(value);
               auto c = safenew wxChoice(w, ID_Choices + p);
               c->SetName(labelText);
               c->Append(port->mScaleLabels);
               c->SetSelection(s);
               gridSizer->Add(c, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
               ctrl.choice = c;
 
               gridSizer->Add(1, 1, 0);
               gridSizer->Add(1, 1, 0);
               gridSizer->Add(1, 1, 0);
            }
            else if (!port->mIsInput) {
               // Real-valued output gets a meter control
               gridSizer->Add(1, 1, 0);
               gridSizer->Add(1, 1, 0);
 
               static float sink;
               const auto pOutputValues =
                  static_cast<const LV2EffectOutputs*>(mpOutputs);
               const auto pValue =
                  pOutputValues ? &pOutputValues->values[p] : &sink;
               auto m = safenew LV2EffectMeter(w, port, *pValue);
               gridSizer->Add(m, 0, wxALIGN_CENTER_VERTICAL | wxEXPAND);
               ctrl.meter = m;
 
               gridSizer->Add(1, 1, 0);
            }
            else {
               // Numerical input gets a text input, with a validator...
               auto t = safenew wxTextCtrl(w, ID_Texts + p, wxT(""));
               t->SetName(labelText);
               gridSizer->Add(t, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
               ctrl.mText = t;
               auto rate = port->mSampleRate ? mSampleRate : 1.0f;
               state.mLo = port->mMin * rate;
               state.mHi = port->mMax * rate;
               state.mTmp = value * rate;
               if (port->mInteger) {
                  IntegerValidator<float> vld(&state.mTmp);
                  vld.SetRange(state.mLo, state.mHi);
                  t->SetValidator(vld);
               }
               else {
                  FloatingPointValidator<float> vld(6, &state.mTmp);
                  vld.SetRange(state.mLo, state.mHi);
 
                  // Set number of decimal places
                  float range = state.mHi - state.mLo;
                  auto style = range < 10
                     ? NumValidatorStyle::THREE_TRAILING_ZEROES
                     : range < 100
                        ? NumValidatorStyle::TWO_TRAILING_ZEROES
                        : NumValidatorStyle::ONE_TRAILING_ZERO;
                  vld.SetStyle(style);
                  t->SetValidator(vld);
               }
 
               // ... optional lower-bound static text ...
               if (port->mHasLo) {
                  wxString str;
                  if (port->mInteger || port->mSampleRate)
                     str.Printf(wxT("%d"), (int) lrintf(state.mLo));
                  else
                     str = Internat::ToDisplayString(state.mLo);
                  item = safenew wxStaticText(w, wxID_ANY, str);
                  gridSizer->Add(item, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT);
               }
               else
                  gridSizer->Add(1, 1, 0);
 
               // ... a slider ...
               auto s = safenew wxSliderWrapper(w, ID_Sliders + p,
                  0, 0, 1000, wxDefaultPosition, { 150, -1 });
               s->SetName(labelText);
               gridSizer->Add(s, 0, wxALIGN_CENTER_VERTICAL | wxEXPAND);
               ctrl.slider = s;
 
               // ... and optional upper-bound static text
               if (port->mHasHi) {
                  wxString str;
                  if (port->mInteger || port->mSampleRate)
                     str.Printf(wxT("%d"), (int) lrintf(state.mHi));
                  else
                     str = Internat::ToDisplayString(state.mHi);
                  item = safenew wxStaticText(w, wxID_ANY, str);
                  gridSizer->Add(item, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
               }
               else
                  gridSizer->Add(1, 1, 0);
            }
         }
 
         auto groupSizer = std::make_unique<wxStaticBoxSizer>(
            wxVERTICAL, w, label.Translation());
         groupSizer->Add(gridSizer.release(), 1, wxEXPAND | wxALL, 5);
         innerSizer->Add(groupSizer.release(), 0, wxEXPAND | wxALL, 5);
      }
 
      innerSizer->Layout();
 
      auto VisitCells = [&, cnt = innerSizer->GetChildren().GetCount()](auto f){
         for (size_t i = (mType == EffectTypeGenerate); i < cnt; ++i) {
            // For each group (skipping duration) visit the grid sizer
            auto groupSizer = innerSizer->GetItem(i)->GetSizer();
            auto gridSizer = static_cast<wxFlexGridSizer *>(
               groupSizer->GetItem(size_t{0})->GetSizer());
            auto items = gridSizer->GetChildren().GetCount();
            size_t cols = gridSizer->GetCols();
            for (size_t j = 0; j < items; ++j) {
               // For each grid item
               auto item = gridSizer->GetItem(j);
               f(item, j, cols);
            }
         }
      };
 
      // Calculate the maximum width of all columns (bypass Generator sizer)
      std::vector<int> widths(numCols);
      VisitCells([&](wxSizerItem *item, size_t j, size_t cols){
         auto &width = widths[j % cols];
         width = std::max(width, item->GetSize().GetWidth());
      });
 
      // Set each column in all of the groups to the same width.
      VisitCells([&](wxSizerItem *item, size_t j, size_t cols){
         int flags = item->GetFlag();
         if (flags & wxEXPAND)
            return;
         if (flags & wxALIGN_RIGHT)
            flags = (flags & ~wxALL) | wxLEFT;
         else
            flags = (flags & ~wxALL) | wxRIGHT;
         item->SetFlag(flags);
         item->SetBorder(widths[j % cols] - item->GetMinSize().GetWidth());
      });
 
      w->SetSizer(uInnerSizer.release());
 
      mParent->SetSizer(outerSizer.release());
   } // scope of unique_ptrs of sizers
 
   // Try to give the window a sensible default/minimum size
   wxSize sz1 = innerSizer->GetMinSize();
   wxSize sz2 = mParent->GetMinSize();
   w->SetMinSize( { -1, std::min(sz1.y, sz2.y) } );
 
   // And let the parent reduce to the NEW minimum if possible
   mParent->SetMinSize(w->GetMinSize());
 
   return true;
}

References _, NumericTextCtrl::Options::AutoPos(), EffectTypeGenerate, EffectSettingsAccess::Get(), anonymous_namespace{DynamicRangeProcessorEditor.cpp}::GetSettings(), ID_Choices, ID_Duration, ID_Sliders, ID_Texts, ID_Toggles, ID_Triggers, label, lrintf, LV2Ports::mControlPorts, mDuration, LV2Ports::mGroupMap, LV2Ports::mGroups, min(), mParent, mPlainUIControls, mPorts, mPortUIStates, mpOutputs, mSampleRate, mType, NumericConverterType_TIME(), safenew, FormatterContext::SampleRateContext(), NumericTextCtrl::SetName(), settings(), str, anonymous_namespace{AudacityDontAskAgainMessageDialog.cpp}::style, Internat::ToDisplayString(), TranslatableString::Translation(), TranslationLess(), values, LV2EffectOutputs::values, wxT(), and XO().

Here is the call graph for this function:

◆ Disconnect()

void LV2Editor::Disconnect ( )

overridevirtual

On the first call only, may disconnect from further event handling.

Default implemantation does nothing

Reimplemented from EffectEditor.

Definition at line 159 of file LV2Editor.cpp.

{
   // Disconnect the plain UI output meters
   if (!mPlainUIControls.empty()) {
      size_t p = 0;
      for (auto &port : mPorts.mControlPorts) {
         if (!port->mIsInput)
            if (auto &pMeter = mPlainUIControls[p].meter) {
               pMeter->Disconnect();
               pMeter = nullptr;
            }
         ++p;
      }
   }
   // The idle event handler for the fancy UI output must disconnect too
   mpOutputs = nullptr;
   if (mParent) {
      mParent->PopEventHandler();
      mParent = nullptr;
   }
   mUI.Destroy();
}

References LV2Editor::UI::Destroy(), LV2Ports::mControlPorts, mParent, mPlainUIControls, mPorts, mpOutputs, and mUI.

Referenced by ~LV2Editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSuilHost()

std::shared_ptr< SuilHost > LV2Editor::GetSuilHost ( )

static

Definition at line 187 of file LV2Editor.cpp.

{
   // This is a unique_ptr specialization
   using SuilHostPtr = Lilv_ptr<SuilHost, suil_host_free>;
   // The host has no dependency on the plug-in and can be shared among
   // validators
   static std::weak_ptr<SuilHost> sSuilHost;
   std::shared_ptr<SuilHost> result = sSuilHost.lock();
   if (!result)
      // shared_ptr erases type of custom deleter of SuilHostPtr
      sSuilHost = result = SuilHostPtr{ suil_host_new(
         LV2UIFeaturesList::suil_port_write,
         LV2UIFeaturesList::suil_port_index, nullptr, nullptr) };
   return result;
}

References LV2UIFeaturesList::suil_port_index(), and LV2UIFeaturesList::suil_port_write().

Referenced by BuildFancy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsGraphicalUI()

bool LV2Editor::IsGraphicalUI ( )

overridevirtual

Default implementation returns false

Returns: true if using a native plug-in UI, not widgets

Reimplemented from EffectEditor.

Definition at line 144 of file LV2Editor.cpp.

{
   return mUseGUI;
}

◆ OnChoice()

void LV2Editor::OnChoice ( wxCommandEvent & evt )

Definition at line 762 of file LV2Editor.cpp.

{
   size_t idx = evt.GetId() - ID_Choices;
   auto & port = mPorts.mControlPorts[idx];
   mAccess.ModifySettings([&](EffectSettings &settings) {
      UpdateControlPortValue(
         GetSettings(settings), idx, port->mScaleValues[evt.GetInt()]);
      return nullptr;
   });
}

References anonymous_namespace{DynamicRangeProcessorEditor.cpp}::GetSettings(), ID_Choices, EffectEditor::mAccess, LV2Ports::mControlPorts, EffectSettingsAccess::ModifySettings(), mPorts, settings(), and UpdateControlPortValue().

Here is the call graph for this function:

◆ OnIdle()

void LV2Editor::OnIdle ( wxIdleEvent & evt )

Definition at line 819 of file LV2Editor.cpp.

{
   evt.Skip();
   if (!mUI.mSuilInstance)
      return;
 
   if (mExternalUIClosed) {
      mExternalUIClosed = false;
      if (mDialog)
         mDialog->Close();
      return;
   }
 
   if (mUIIdleInterface) {
      const auto handle = suil_instance_get_handle(mUI.mSuilInstance.get());
      if (mUIIdleInterface->idle && mUIIdleInterface->idle(handle)) {
         if (mUIShowInterface && mUIShowInterface->hide)
            mUIShowInterface->hide(handle);
         if (mDialog)
            mDialog->Close();
         return;
      }
   }
 
   auto &portUIStates = mPortUIStates;
 
   if (auto &atomState = portUIStates.mControlOut) {
      atomState->SendToDialog([&](const LV2_Atom *atom, uint32_t size){
         suil_instance_port_event(mUI.mSuilInstance.get(),
            atomState->mpPort->mIndex, size,
            // Means this event sends some structured data:
            LV2Symbols::urid_EventTransfer, atom);
      });
   }
 
   // Is this idle time polling for changes of input redundant with
   // TransferDataToWindow or is it really needed?  Probably harmless.
   // In case of output control port values though, it is needed for metering.
   mAccess.Flush();
   auto& values = GetSettings(mAccess.Get()).values;
   auto pOutputValues = static_cast<const LV2EffectOutputs *>(mpOutputs);
 
   size_t index = 0; for (auto &state : portUIStates.mControlPortStates) {
      auto &port = state.mpPort;
 
      const auto pValue = port->mIsInput
         ? &values[index]
         : pOutputValues ? &pOutputValues->values[index]
         : nullptr;
      if (pValue) {
         auto &value = *pValue;
         // Let UI know that a port's value has changed
         if (value != state.mLst) {
            suil_instance_port_event(mUI.mSuilInstance.get(),
               port->mIndex, sizeof(value),
               /* Means this event sends a float: */ 0,
/*
   Quoting what suil.h says about the next argument (which is good):
 
   The `buffer` must be valid only for the duration of this call, the UI must
   not keep a reference to it.
 */
               &value);
            state.mLst = value;
        }
      }
      ++index;
   }
}

References EffectSettingsAccess::Flush(), EffectSettingsAccess::Get(), anonymous_namespace{DynamicRangeProcessorEditor.cpp}::GetSettings(), EffectEditor::mAccess, mDialog, mExternalUIClosed, mPortUIStates, mpOutputs, LV2Editor::UI::mSuilInstance, mUI, mUIIdleInterface, mUIShowInterface, size, and values.

Here is the call graph for this function:

◆ OnSize()

void LV2Editor::OnSize ( wxSizeEvent & evt )

Definition at line 889 of file LV2Editor.cpp.

{
   evt.Skip();
 
   // Don't do anything here if we're recursing
   if (mResizing)
      return;
 
   // Indicate resizing is occurring
   mResizing = true;
 
   // Can only resize AFTER the dialog has been completely created and
   // there's no need to resize if we're already at the desired size.
   if (mDialog && evt.GetSize() != mNativeWinLastSize) {
      // Save the desired size and set the native window to match
      mNativeWinLastSize = evt.GetSize();
      mUI.mNativeWin->SetMinSize(mNativeWinLastSize);
 
      // Clear the minimum size of the parent window to allow the following
      // Fit() to make proper adjustments
      mParent->SetMinSize(wxDefaultSize);
 
#if defined(__WXGTK__)
      // If the user resized the native window, then we need to also
      // clear the dialogs minimum size.  If this isn't done, the dialog
      // will not resize properly when going from a larger size to a smaller
      // size (due to the minimum size constraint).
      //
      // In this case, mResized has been set by the "size_request()" function
      // to indicate that this is a plugin generated resize request.
      if (mResized)
         mDialog->SetMinSize(wxDefaultSize);
 
      // Resize dialog
      mDialog->Fit();
 
      // Reestablish the minimum (and maximum) now that the dialog
      // has is desired size.
      if (mResized) {
         mDialog->SetMinSize(mDialog->GetSize());
         if (mUIFeatures && mUIFeatures->mNoResize)
            mDialog->SetMaxSize(mDialog->GetSize());
      }
 
      // Tell size_request() that the native window was just resized.
      mResized = true;
#else
      // Resize the dialog to fit its content.
      mDialog->Fit();
#endif
   }
 
   // No longer resizing
   mResizing = false;
}

References mDialog, LV2Editor::UI::mNativeWin, mNativeWinLastSize, mParent, mResized, mResizing, mUI, and mUIFeatures.

Referenced by BuildFancy().

Here is the caller graph for this function:

◆ OnSlider()

void LV2Editor::OnSlider ( wxCommandEvent & evt )

Definition at line 790 of file LV2Editor.cpp.

{
   size_t idx = evt.GetId() - ID_Sliders;
   auto &state = mPortUIStates.mControlPortStates[idx];
   auto &port = state.mpPort;
   float lo = state.mLo;
   float hi = state.mHi;
   if (port->mLogarithmic) {
      lo = logf(lo);
      hi = logf(hi);
   }
   state.mTmp = (((float) evt.GetInt()) / 1000.0) * (hi - lo) + lo;
   state.mTmp = std::clamp(state.mTmp, lo, hi);
   state.mTmp = port->mLogarithmic ? expf(state.mTmp) : state.mTmp;
   mAccess.ModifySettings([&](EffectSettings &settings) {
      UpdateControlPortValue(
         GetSettings(settings), idx,
            port->mSampleRate ? state.mTmp / mSampleRate : state.mTmp);
      return nullptr;
   });
   mPlainUIControls[idx].mText->GetValidator()->TransferToWindow();
}

References anonymous_namespace{DynamicRangeProcessorEditor.cpp}::GetSettings(), ID_Sliders, EffectEditor::mAccess, LV2PortUIStates::mControlPortStates, EffectSettingsAccess::ModifySettings(), mPlainUIControls, mPortUIStates, mSampleRate, settings(), and UpdateControlPortValue().

Here is the call graph for this function:

◆ OnText()

void LV2Editor::OnText ( wxCommandEvent & evt )

Definition at line 773 of file LV2Editor.cpp.

{
   size_t idx = evt.GetId() - ID_Texts;
   auto &state = mPortUIStates.mControlPortStates[idx];
   auto &port = state.mpPort;
   auto &ctrl = mPlainUIControls[idx];
   if (ctrl.mText->GetValidator()->TransferFromWindow()) {
      mAccess.ModifySettings([&](EffectSettings &settings) {
         UpdateControlPortValue(
            GetSettings(settings), idx,
               port->mSampleRate ? state.mTmp / mSampleRate : state.mTmp);
         return nullptr;
      });
      SetSlider(state, ctrl);
   }
}

References anonymous_namespace{DynamicRangeProcessorEditor.cpp}::GetSettings(), ID_Texts, EffectEditor::mAccess, LV2PortUIStates::mControlPortStates, EffectSettingsAccess::ModifySettings(), mPlainUIControls, mPortUIStates, mSampleRate, SetSlider(), settings(), and UpdateControlPortValue().

Here is the call graph for this function:

◆ OnToggle()

void LV2Editor::OnToggle ( wxCommandEvent & evt )

Definition at line 752 of file LV2Editor.cpp.

{
   size_t idx = evt.GetId() - ID_Toggles;
   mAccess.ModifySettings([&](EffectSettings &settings) {
      UpdateControlPortValue(
         GetSettings(settings), idx, evt.GetInt() ? 1.0 : 0.0);
      return nullptr;
   });
}

References anonymous_namespace{DynamicRangeProcessorEditor.cpp}::GetSettings(), ID_Toggles, EffectEditor::mAccess, EffectSettingsAccess::ModifySettings(), settings(), and UpdateControlPortValue().

Here is the call graph for this function:

◆ OnTrigger()

void LV2Editor::OnTrigger ( wxCommandEvent & evt )

Definition at line 742 of file LV2Editor.cpp.

{
   size_t idx = evt.GetId() - ID_Triggers;
   auto & port = mPorts.mControlPorts[idx];
   mAccess.ModifySettings([&](EffectSettings &settings) {
      UpdateControlPortValue(GetSettings(settings), idx, port->mDef);
      return nullptr;
   });
}

References anonymous_namespace{DynamicRangeProcessorEditor.cpp}::GetSettings(), ID_Triggers, EffectEditor::mAccess, LV2Ports::mControlPorts, EffectSettingsAccess::ModifySettings(), mPorts, settings(), and UpdateControlPortValue().

Here is the call graph for this function:

◆ SetSlider()

void LV2Editor::SetSlider	(	const LV2ControlPortState &	state,
		const PlainUIControl &	ctrl
	)

Definition at line 708 of file LV2Editor.cpp.

{
   float lo = state.mLo;
   float hi = state.mHi;
   float val = state.mTmp;
   if (state.mpPort->mLogarithmic) {
      lo = logf(lo);
      hi = logf(hi);
      val = logf(val);
   }
   ctrl.slider->SetValue(lrintf((val - lo) / (hi - lo) * 1000.0));
}

References lrintf, LV2ControlPortState::mHi, LV2ControlPortState::mLo, LV2ControlPortState::mpPort, LV2ControlPortState::mTmp, and LV2Editor::PlainUIControl::slider.

Referenced by OnText(), and UpdateUI().

Here is the caller graph for this function:

◆ size_request()

void LV2Editor::size_request	(	GtkWidget *	widget,
		GtkRequisition *	requisition,
		LV2Editor *	pEditor
	)

static

Definition at line 1015 of file LV2Editor.cpp.

{
   pEditor->SizeRequest(widget, requisition);
}

References SizeRequest().

Referenced by BuildFancy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SizeRequest()

void LV2Editor::SizeRequest	(	GtkWidget *	widget,
		GtkRequisition *	requisition
	)

Definition at line 1021 of file LV2Editor.cpp.

{
   // Don't do anything if the OnSize() method is active
   if (!mResizing) {
      // If the OnSize() routine has processed an event, mResized will be true,
      // so just set the widgets size.
      if (mResized) {
         gtk_widget_set_size_request(widget,
            mNativeWinLastSize.x, mNativeWinLastSize.y);
         mResized = false;
      }
      // Otherwise, the plugin has resized the widget and we need to let WX know
      // about it.
      else if (mUI.mNativeWin) {
         mResized = true;
         wxSizeEvent se(wxSize(requisition->width, requisition->height));
         se.SetEventObject(mUI.mNativeWin.get());
         mUI.mNativeWin->GetEventHandler()->AddPendingEvent(se);
      }
   }
}

References LV2Editor::UI::mNativeWin, mNativeWinLastSize, mResized, mResizing, and mUI.

Referenced by size_request().

Here is the caller graph for this function:

◆ suil_port_index()

uint32_t LV2Editor::suil_port_index ( const char * port_symbol )

overridevirtual

Implements LV2UIFeaturesList::UIHandler.

Definition at line 998 of file LV2Editor.cpp.

{
   for (size_t i = 0, cnt = lilv_plugin_get_num_ports(&mPlug); i < cnt; ++i) {
      const auto port = lilv_plugin_get_port_by_index(&mPlug, i);
      if (strcmp(port_symbol,
            lilv_node_as_string(lilv_port_get_symbol(&mPlug, port))) == 0)
         return lilv_port_get_index(&mPlug, port);
   }
   return LV2UI_INVALID_PORT_INDEX;
}

References mPlug.

◆ suil_port_write()

void LV2Editor::suil_port_write	(	uint32_t	port_index,
		uint32_t	buffer_size,
		uint32_t	protocol,
		const void *	buffer
	)

overridevirtual

Implements LV2UIFeaturesList::UIHandler.

Definition at line 969 of file LV2Editor.cpp.

{
   // Handle implicit floats
   if (protocol == 0 && buffer_size == sizeof(float)) {
      if (auto it = mPorts.mControlPortMap.find(port_index);
          it != mPorts.mControlPortMap.end())
      {
         const auto value = *static_cast<const float*>(buffer);
         mAccess.ModifySettings(
            [&](EffectSettings& settings)
            {
               GetSettings(settings).values[it->second] = value;
               return nullptr;
            });
 
 
         Publish({ size_t(port_index), value });
      }
   }
   // Handle event transfers
   else if (protocol == LV2Symbols::urid_EventTransfer) {
      auto &portUIStates = mPortUIStates;
      auto &atomPortState = portUIStates.mControlIn;
      if (atomPortState && port_index == atomPortState->mpPort->mIndex)
         atomPortState->ReceiveFromDialog(buffer, buffer_size);
   }
}

References anonymous_namespace{DynamicRangeProcessorEditor.cpp}::GetSettings(), EffectEditor::mAccess, LV2PortUIStates::mControlIn, LV2Ports::mControlPortMap, EffectSettingsAccess::ModifySettings(), mPorts, mPortUIStates, Observer::Publisher< EffectSettingChanged >::Publish(), and settings().

Here is the call graph for this function:

◆ ui_closed()

void LV2Editor::ui_closed ( )

overridevirtual

Implements LV2UIFeaturesList::UIHandler.

Definition at line 963 of file LV2Editor.cpp.

{
   mExternalUIClosed = true;
}

References mExternalUIClosed.

◆ ui_resize()

int LV2Editor::ui_resize	(	int	width,
		int	height
	)

overridevirtual

Implements LV2UIFeaturesList::UIHandler.

Definition at line 949 of file LV2Editor.cpp.

{
   // Queue a wxSizeEvent to resize the plugins UI
   if (mUI.mNativeWin) {
      wxSizeEvent sw{ wxSize{ width, height } };
      sw.SetEventObject(mUI.mNativeWin.get());
      mUI.mNativeWin->GetEventHandler()->AddPendingEvent(sw);
   }
   else
      // The window hasn't been created yet, so record the desired size
      mNativeWinInitialSize = { width, height };
   return 0;
}

References LV2Editor::UI::mNativeWin, mNativeWinInitialSize, and mUI.

◆ UpdateControlPortValue()

void LV2Editor::UpdateControlPortValue	(	LV2EffectSettings &	settings,
		size_t	controlPortIndex,
		float	value
	)

Definition at line 722 of file LV2Editor.cpp.

{
   const auto currentValue = settings.values[controlPortIndex];
 
   // LV2 implementation allows to edit the values
   // using text boxes too. Provide sufficiently small epsilon
   // to distinguish between the values.
   // (for example, conversion from the text representation
   // is always lossy, so direct comparison of the values
   // is not possible, nor should it be used for float values)
   const auto epsilon = 1e-5f;
 
   if (std::abs(currentValue - value) < epsilon)
      return;
 
   settings.values[controlPortIndex] = value;
   Publish({ mPorts.mControlPorts[controlPortIndex]->mIndex, value });
}

References LV2Ports::mControlPorts, mPorts, Observer::Publisher< EffectSettingChanged >::Publish(), and settings().

Referenced by OnChoice(), OnSlider(), OnText(), OnToggle(), and OnTrigger().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateUI()

bool LV2Editor::UpdateUI ( )

overridevirtual

Update appearance of the panel for changes in settings.

Default implementation does nothing, returns true

Returns: true if successful

Reimplemented from EffectEditor.

Definition at line 641 of file LV2Editor.cpp.

{
   const auto &mySettings = GetSettings(mAccess.Get());
   auto pMaster = mInstance.GetMaster();
 
   if (pMaster && mySettings.mpState) {
      // Maybe there are other important side effects on the instance besides
      // changes of port values
      lilv_state_restore(mySettings.mpState.get(), &pMaster->GetInstance(),
         nullptr, nullptr, 0, nullptr);
      // Destroy the short lived carrier of preset state
      mySettings.mpState.reset();
   }
 
   auto &values = mySettings.values;
   {
      size_t index = 0; for (auto & state : mPortUIStates.mControlPortStates) {
         auto &port = state.mpPort;
         if (port->mIsInput)
            state.mTmp =
               values[index] * (port->mSampleRate ? mSampleRate : 1.0);
         ++index;
      }
   }
 
   if (mUseGUI) {
      // fancy UI
      if (mUI.mSuilInstance) {
         size_t index = 0;
         for (auto & port : mPorts.mControlPorts) {
            if (port->mIsInput)
               suil_instance_port_event(mUI.mSuilInstance.get(),
                  port->mIndex, sizeof(float),
                  /* Means this event sends a float: */ 0,
                  &values[index]);
            ++index;
         }
      }
      return true;
   }
 
   // else plain UI
   // Visiting controls by groups
   for (auto & group : mPorts.mGroups) {
      const auto & params = mPorts.mGroupMap.at(group); /* won't throw */
      for (auto & param : params) {
         auto &state = mPortUIStates.mControlPortStates[param];
         auto &port = state.mpPort;
         auto &ctrl = mPlainUIControls[param];
         auto &value = values[param];
         if (port->mTrigger)
            continue;
         else if (port->mToggle)
            ctrl.checkbox->SetValue(value > 0);
         else if (port->mEnumeration)      // Check before integer
            ctrl.choice->SetSelection(port->Discretize(value));
         else if (port->mIsInput) {
            state.mTmp = value * (port->mSampleRate ? mSampleRate : 1.0f);
            SetSlider(state, ctrl);
         }
      }
   }
   if (mParent && !mParent->TransferDataToWindow())
      return false;
   return true;
}

References EffectSettingsAccess::Get(), LV2Instance::GetMaster(), anonymous_namespace{DynamicRangeProcessorEditor.cpp}::GetSettings(), EffectEditor::mAccess, LV2Ports::mControlPorts, LV2PortUIStates::mControlPortStates, LV2Ports::mGroupMap, LV2Ports::mGroups, mInstance, mParent, mPlainUIControls, mPorts, mPortUIStates, mSampleRate, LV2Editor::UI::mSuilInstance, mUI, mUseGUI, params, SetSlider(), and values.

Here is the call graph for this function:

◆ ValidateUI()

bool LV2Editor::ValidateUI ( )

overridevirtual

Get settings data from the panel; may make error dialogs and return false.

Returns: true only if panel settings are acceptable

Implements EffectEditor.

Definition at line 149 of file LV2Editor.cpp.

{
   mAccess.ModifySettings([&](EffectSettings &settings){
      if (mType == EffectTypeGenerate)
         settings.extra.SetDuration(mDuration->GetValue());
      return nullptr;
   });
   return true;
}

References EffectTypeGenerate, NumericConverter::GetValue(), EffectEditor::mAccess, mDuration, EffectSettingsAccess::ModifySettings(), mType, and settings().

Here is the call graph for this function:

Member Data Documentation

◆ mDialog

wxWeakRef<wxDialog> LV2Editor::mDialog

Definition at line 152 of file LV2Editor.h.

Referenced by OnIdle(), and OnSize().

◆ mDuration

NumericTextCtrl* LV2Editor::mDuration {}

Definition at line 163 of file LV2Editor.h.

Referenced by BuildPlain(), and ValidateUI().

◆ mExternalUIClosed

bool LV2Editor::mExternalUIClosed { false }

Definition at line 153 of file LV2Editor.h.

Referenced by OnIdle(), and ui_closed().

◆ mInstance

LV2Instance& LV2Editor::mInstance

Definition at line 106 of file LV2Editor.h.

Referenced by UpdateUI().

◆ mNativeWinInitialSize

wxSize LV2Editor::mNativeWinInitialSize { wxDefaultSize }

Definition at line 145 of file LV2Editor.h.

Referenced by BuildFancy(), and ui_resize().

◆ mNativeWinLastSize

wxSize LV2Editor::mNativeWinLastSize { wxDefaultSize }

Definition at line 146 of file LV2Editor.h.

Referenced by BuildFancy(), OnSize(), and SizeRequest().

◆ mParent

wxWindow* LV2Editor::mParent

Definition at line 115 of file LV2Editor.h.

Referenced by BuildFancy(), BuildPlain(), Disconnect(), LV2Editor(), OnSize(), and UpdateUI().

◆ mPlainUIControls

std::vector<PlainUIControl> LV2Editor::mPlainUIControls

Array in correspondence with the control ports.

Definition at line 131 of file LV2Editor.h.

Referenced by BuildPlain(), Disconnect(), OnSlider(), OnText(), and UpdateUI().

◆ mPlug

const LilvPlugin& LV2Editor::mPlug

Definition at line 104 of file LV2Editor.h.

Referenced by BuildFancy(), and suil_port_index().

◆ mPorts

const LV2Ports& LV2Editor::mPorts

Definition at line 109 of file LV2Editor.h.

Referenced by BuildPlain(), Disconnect(), OnChoice(), OnTrigger(), suil_port_write(), UpdateControlPortValue(), and UpdateUI().

◆ mPortUIStates

LV2PortUIStates LV2Editor::mPortUIStates

Definition at line 112 of file LV2Editor.h.

Referenced by BuildPlain(), OnIdle(), OnSlider(), OnText(), suil_port_write(), and UpdateUI().

◆ mpOutputs

const EffectOutputs* LV2Editor::mpOutputs {}

Definition at line 107 of file LV2Editor.h.

Referenced by BuildPlain(), Disconnect(), and OnIdle().

◆ mpWrapper

std::unique_ptr<LV2Wrapper> LV2Editor::mpWrapper

Definition at line 110 of file LV2Editor.h.

Referenced by BuildFancy().

◆ mResized

bool LV2Editor::mResized { false }

Definition at line 149 of file LV2Editor.h.

Referenced by OnSize(), and SizeRequest().

◆ mResizing

bool LV2Editor::mResizing { false }

Definition at line 147 of file LV2Editor.h.

Referenced by OnSize(), and SizeRequest().

◆ mSampleRate

const double LV2Editor::mSampleRate

Definition at line 108 of file LV2Editor.h.

Referenced by BuildPlain(), OnSlider(), OnText(), and UpdateUI().

◆ mSuilHost

std::shared_ptr<SuilHost> LV2Editor::mSuilHost

Definition at line 114 of file LV2Editor.h.

Referenced by BuildFancy().

◆ mTimer

LV2Editor::Timer LV2Editor::mTimer

Referenced by BuildFancy().

◆ mType

const EffectType LV2Editor::mType

Definition at line 105 of file LV2Editor.h.

Referenced by BuildPlain(), and ValidateUI().

◆ mUI

struct LV2Editor::UI LV2Editor::mUI

Referenced by BuildFancy(), Disconnect(), OnIdle(), OnSize(), SizeRequest(), ui_resize(), and UpdateUI().

◆ mUIFeatures

std::optional<const LV2UIFeaturesList> LV2Editor::mUIFeatures

Definition at line 111 of file LV2Editor.h.

Referenced by BuildFancy(), and OnSize().

◆ mUIIdleInterface

const LV2UI_Idle_Interface* LV2Editor::mUIIdleInterface {}

Definition at line 161 of file LV2Editor.h.

Referenced by BuildFancy(), and OnIdle().

◆ mUIShowInterface

const LV2UI_Show_Interface* LV2Editor::mUIShowInterface {}

Definition at line 162 of file LV2Editor.h.

Referenced by BuildFancy(), and OnIdle().

◆ mUseGUI

bool LV2Editor::mUseGUI {}

Definition at line 116 of file LV2Editor.h.

Referenced by UpdateUI().

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

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ LV2Editor()

◆ ~LV2Editor()

Member Function Documentation

◆ BuildFancy()

◆ BuildPlain()

◆ Disconnect()

◆ GetSuilHost()

◆ IsGraphicalUI()

◆ OnChoice()

◆ OnIdle()

◆ OnSize()

◆ OnSlider()

◆ OnText()

◆ OnToggle()

◆ OnTrigger()

◆ SetSlider()

◆ size_request()

◆ SizeRequest()

◆ suil_port_index()

◆ suil_port_write()

◆ ui_closed()

◆ ui_resize()

◆ UpdateControlPortValue()

◆ UpdateUI()

◆ ValidateUI()

Member Data Documentation

◆ mDialog

◆ mDuration

◆ mExternalUIClosed

◆ mInstance

◆ mNativeWinInitialSize

◆ mNativeWinLastSize

◆ mParent

◆ mPlainUIControls

◆ mPlug

◆ mPorts

◆ mPortUIStates

◆ mpOutputs

◆ mpWrapper

◆ mResized

◆ mResizing

◆ mSampleRate

◆ mSuilHost

◆ mTimer

◆ mType

◆ mUI

◆ mUIFeatures

◆ mUIIdleInterface

◆ mUIShowInterface

◆ mUseGUI