DynamicRangeProcessorEditor Class Reference

#include <DynamicRangeProcessorEditor.h>

Inheritance diagram for DynamicRangeProcessorEditor:

Collaboration diagram for DynamicRangeProcessorEditor:

Classes
struct	HistoryPanels

Public Member Functions
	DynamicRangeProcessorEditor (wxWindow *parent, CompressorInstance &instance, bool isRealtime, const EffectUIServices &services, EffectSettingsAccess &access)
void	PopulateOrExchange (ShuttleGui &S)
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...

Protected Member Functions
void	Initialize (std::vector< ExtendedCompressorParameter > parameters)
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...

Static Protected Attributes
static constexpr auto	dbStep = 0.1

Private Member Functions
void	AddCompressionCurvePanel (ShuttleGui &S, const CompressorSettings &)
void	AddSliderPanel (ShuttleGui &S)
void	AddCheckboxPanel (ShuttleGui &S, const DynamicRangeProcessorSettings &settings)
void	AddClipIndicator (ShuttleGui &S)
virtual const CompressorSettings *	GetCompressorSettings () const
virtual const LimiterSettings *	GetLimiterSettings () const
CompressorSettings *	GetCompressorSettings ()
LimiterSettings *	GetLimiterSettings ()
void	AddTextboxAndSlider (ShuttleGui &S, ExtendedCompressorParameter &param)
bool	ValidateUI () final override
	Get settings data from the panel; may make error dialogs and return false. More...
bool	UpdateUI () final override
	Update appearance of the panel for changes in settings. More...
void	OnCheckbox (bool newVal, double &setting, void(DynamicRangeProcessorHistoryPanel::*)(bool))

Private Attributes
wxWeakRef< wxWindow >	mUIParent
std::vector< ExtendedCompressorParameter >	mParameters
wxDialog &	mTopLevelParent
CompressorInstance &	mCompressorInstance
const bool	mIsRealtime
int	mFullHeight { 0 }

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 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)
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 Attributes inherited from EffectEditor
const EffectUIServices &	mUIServices
EffectSettingsAccess &	mAccess
bool	mUIClosed { false }

Detailed Description

Definition at line 86 of file DynamicRangeProcessorEditor.h.

Constructor & Destructor Documentation

DynamicRangeProcessorEditor()

DynamicRangeProcessorEditor::DynamicRangeProcessorEditor	(	wxWindow *	parent,
		CompressorInstance &	instance,
		bool	isRealtime,
		const EffectUIServices &	services,
		EffectSettingsAccess &	access
	)

Definition at line 131 of file DynamicRangeProcessorEditor.cpp.

    : EffectEditor { services, access }
    , mUIParent { parent }
    , mTopLevelParent(static_cast<wxDialog&>(*wxGetTopLevelParent(parent)))
    , mCompressorInstance { instance }
    , mIsRealtime { isRealtime }
{
}

Member Function Documentation

AddCheckboxPanel()

void DynamicRangeProcessorEditor::AddCheckboxPanel ( ShuttleGui &  S, const DynamicRangeProcessorSettings &  settings  )

private

Definition at line 265 of file DynamicRangeProcessorEditor.cpp.

{
#define GET_REF(settingName)                                        \
   GetCompressorSettings() ? GetCompressorSettings()->settingName : \
                             GetLimiterSettings()->settingName
 
   S.StartVerticalLay(wxALIGN_BOTTOM, 0);
   {
      S.StartHorizontalLay(wxALIGN_LEFT, 0);
      {
         S.AddSpace(borderSize, 0);
         const auto input = S.AddCheckBox(XO("I&nput"), settings.showInput);
         input->Bind(wxEVT_CHECKBOX, [this](wxCommandEvent& evt) {
            OnCheckbox(
               evt.IsChecked(), GET_REF(showInput), &HistPanel::ShowInput);
         });
         /* i18n-hint: show input on a graph */
         input->SetName(_("Show input"));
 
         const auto output = S.AddCheckBox(XO("O&utput"), settings.showOutput);
         output->Bind(wxEVT_CHECKBOX, [&](wxCommandEvent& evt) {
            OnCheckbox(
               evt.IsChecked(), GET_REF(showOutput), &HistPanel::ShowOutput);
         });
         /* i18n-hint: show output on a graph */
         output->SetName(_("Show output"));
 
         /* i18n-hint: The effective compression, including smoothing. */
         const auto actual =
            S.AddCheckBox(XO("A&ctual compression"), settings.showActual);
         actual->Bind(wxEVT_CHECKBOX, [&](wxCommandEvent& evt) {
            OnCheckbox(
               evt.IsChecked(), GET_REF(showActual), &HistPanel::ShowActual);
         });
         /* i18n-hint: show actual compression on a graph */
         actual->SetName(_("Show actual compression"));
 
         /* i18n-hint: The target compression, before smoothing. */
         const auto target =
            S.AddCheckBox(XO("Tar&get compression"), settings.showTarget);
         target->Bind(wxEVT_CHECKBOX, [&](wxCommandEvent& evt) {
            OnCheckbox(
               evt.IsChecked(), GET_REF(showTarget), &HistPanel::ShowTarget);
         });
         /* i18n-hint: show target compression on a graph */
         target->SetName(_("Show target compression"));
 
#if wxUSE_ACCESSIBILITY
         // so that name can be set on a standard control
         safenew WindowAccessible(input);
         safenew WindowAccessible(output);
         safenew WindowAccessible(actual);
         safenew WindowAccessible(target);
#endif
      }
      S.EndHorizontalLay();
      S.AddSpace(0, borderSize);
   }
   S.EndVerticalLay();
}

References _, anonymous_namespace{DynamicRangeProcessorEditor.cpp}::borderSize, GET_REF, OnCheckbox(), S, safenew, settings(), and XO().

Referenced by PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

AddClipIndicator()

void DynamicRangeProcessorEditor::AddClipIndicator ( ShuttleGui &  S )

private

Definition at line 327 of file DynamicRangeProcessorEditor.cpp.

{
   constexpr auto width = compressionMeterPanelWidth / 2 - 2;
   constexpr auto height = compressionMeterPanelWidth / 4;
   S.MinSize({ width, height })
      .AddWindow(
         safenew ClipIndicatorPanel(mUIParent, clipIndicatorId),
         wxALIGN_RIGHT | wxALIGN_BOTTOM)
      ->Bind(wxEVT_LEFT_UP, [this](wxMouseEvent& evt) {
         if (
            const auto panel = dynamic_cast<CompressionMeterPanel*>(
               wxWindow::FindWindowById(compressionMeterPanelId, mUIParent)))
            panel->ResetClipped();
         if (
            const auto indicator =
               dynamic_cast<ClipIndicatorPanel*>(evt.GetEventObject()))
            indicator->Reset();
      });
}

References anonymous_namespace{DynamicRangeProcessorEditor.cpp}::clipIndicatorId, anonymous_namespace{DynamicRangeProcessorEditor.cpp}::compressionMeterPanelId, anonymous_namespace{DynamicRangeProcessorEditor.cpp}::compressionMeterPanelWidth, mUIParent, S, and safenew.

Referenced by PopulateOrExchange().

Here is the caller graph for this function:

AddCompressionCurvePanel()

void DynamicRangeProcessorEditor::AddCompressionCurvePanel ( ShuttleGui &  S, const CompressorSettings &  compressorSettings  )

private

Definition at line 347 of file DynamicRangeProcessorEditor.cpp.

{
   S.StartMultiColumn(3);
   {
      S.SetStretchyRow(1);
 
      constexpr auto tfWidth = 200;
 
      // Horizontal ruler row
      S.AddSpace(borderSize, 0);
      S.Prop(1)
         .Position(wxALIGN_BOTTOM)
         .MinSize({ tfWidth, rulerWidth })
         .AddWindow(MakeRulerPanel(mUIParent, wxHORIZONTAL, TFPanel::rangeDb));
      S.AddSpace(rulerWidth, 0);
 
      // Transfer function row
      S.AddSpace(borderSize, 0);
      S.Prop(1).Position(wxEXPAND).AddWindow(safenew TFPanel(
         mUIParent, transferFunctionPanelId, compressorSettings));
      S.Prop(1).Position(wxEXPAND).AddWindow(
         MakeRulerPanel(mUIParent, wxVERTICAL, TFPanel::rangeDb));
   }
   S.EndMultiColumn();
}

References anonymous_namespace{DynamicRangeProcessorEditor.cpp}::borderSize, anonymous_namespace{DynamicRangeProcessorEditor.cpp}::MakeRulerPanel(), mUIParent, anonymous_namespace{DynamicRangeProcessorEditor.cpp}::rulerWidth, S, safenew, and anonymous_namespace{DynamicRangeProcessorEditor.cpp}::transferFunctionPanelId.

Referenced by PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

AddSliderPanel()

void DynamicRangeProcessorEditor::AddSliderPanel ( ShuttleGui &  S )

private

Definition at line 374 of file DynamicRangeProcessorEditor.cpp.

{
   using It = std::vector<ExtendedCompressorParameter>::iterator;
   const auto addTextboxAndSliders = [&](
                                        const TranslatableString& prompt,
                                        const It& begin, const It& end) {
      S.StartStatic(prompt);
      S.StartMultiColumn(3, wxEXPAND);
      {
         S.SetStretchyCol(2);
         std::for_each(begin, end, [&](ExtendedCompressorParameter& parameter) {
            AddTextboxAndSlider(S, parameter);
         });
      }
      S.EndMultiColumn();
      S.EndStatic();
   };
 
   const auto firstSmoothingParameterIt =
      std::find_if(mParameters.begin(), mParameters.end(), [](const auto& p) {
         return p.category == ControllerCategory::TimeSmoothing;
      });
 
   S.StartPanel();
   {
      addTextboxAndSliders(
         XO("Compression curve"), mParameters.begin(),
         firstSmoothingParameterIt);
      addTextboxAndSliders(
         XO("Smoothing"), firstSmoothingParameterIt, mParameters.end());
   }
   S.EndPanel();
}

References AddTextboxAndSlider(), details::begin(), details::end(), mParameters, S, and XO().

Referenced by PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

AddTextboxAndSlider()

void DynamicRangeProcessorEditor::AddTextboxAndSlider ( ShuttleGui &  S, ExtendedCompressorParameter &  param  )

private

Definition at line 408 of file DynamicRangeProcessorEditor.cpp.

{
   setting.text = S.Validator<FloatingPointValidator<double>>(
                      1, &setting.value, NumValidatorStyle::ONE_TRAILING_ZERO,
                      setting.param->Min(), setting.param->Max())
                     .AddTextBox(setting.attributes.caption, L"", 12);
 
   setting.text->Bind(wxEVT_TEXT, [&](wxCommandEvent& evt) {
      if (!EnableApply(mUIParent, mUIParent->TransferDataFromWindow()))
         return;
      setting.slider->SetValue(TextToSliderValue(setting));
      ValidateUI();
      UpdateUI();
      Publish(EffectSettingChanged {});
   });
 
   setting.slider =
      S.Name(setting.attributes.caption)
         .Style(wxSL_HORIZONTAL)
         .MinSize({ 100, -1 })
         .AddSlider(
            {}, TextToSliderValue(setting), setting.param->SliderMax(),
            setting.param->SliderMin());
 
   setting.slider->Bind(wxEVT_SLIDER, [&](wxCommandEvent& evt) {
      setting.value = SliderToTextValue(setting.slider->GetValue(), setting);
      setting.text->GetValidator()->TransferToWindow();
      EnableApply(mUIParent, mUIParent->Validate());
      ValidateUI();
      UpdateUI();
      Publish(EffectSettingChanged {});
   });
 
   // For exponential slider, for right/down arrow keys, because
   // the setting value has precision of 1, ensure that
   // the change in slider position results a change in value of
   // at least 0.1, otherwise the slider position and setting value
   // may not change.
   setting.slider->Bind(wxEVT_SCROLL_LINEDOWN, [&](wxScrollEvent& evt) {
      if (setting.attributes.exponentialSlider
         && setting.value == SliderToTextValue(evt.GetInt(), setting)) {
         setting.value += 0.1;
         setting.slider->SetValue(std::round(TextToSliderValue(setting)));
      }
   });
 
   // And similarly for left/up arrow keys.
   setting.slider->Bind(wxEVT_SCROLL_LINEUP, [&](wxScrollEvent& evt) {
      if (setting.attributes.exponentialSlider
         && setting.value == SliderToTextValue(evt.GetInt(), setting)) {
         setting.value -= 0.1;
         setting.slider->SetValue(std::round(TextToSliderValue(setting)));
      }
   });
}

References ExtendedCompressorParameter::attributes, DynamicRangeProcessorParameterAttributes::caption, EffectEditor::EnableApply(), DynamicRangeProcessorParameterAttributes::exponentialSlider, mUIParent, ExtendedCompressorParameter::param, Observer::Publisher< EffectSettingChanged >::Publish(), fast_float::round(), S, ExtendedCompressorParameter::slider, anonymous_namespace{DynamicRangeProcessorEditor.cpp}::SliderToTextValue(), ExtendedCompressorParameter::text, anonymous_namespace{DynamicRangeProcessorEditor.cpp}::TextToSliderValue(), UpdateUI(), ValidateUI(), and ExtendedCompressorParameter::value.

Referenced by AddSliderPanel().

Here is the call graph for this function:

Here is the caller graph for this function:

GetCompressorSettings() [1/2]

CompressorSettings * DynamicRangeProcessorEditor::GetCompressorSettings ( )

inlineprivate

Definition at line 121 of file DynamicRangeProcessorEditor.h.

   {
      return const_cast<CompressorSettings*>(
         const_cast<const DynamicRangeProcessorEditor&>(*this)
            .GetCompressorSettings());
   }

References GetCompressorSettings().

Here is the call graph for this function:

GetCompressorSettings() [2/2]

virtual const CompressorSettings * DynamicRangeProcessorEditor::GetCompressorSettings ( ) const

inlineprivatevirtual

Reimplemented in CompressorEditor.

Definition at line 111 of file DynamicRangeProcessorEditor.h.

   {
      return nullptr;
   }

Referenced by GetCompressorSettings(), PopulateOrExchange(), UpdateUI(), and ValidateUI().

Here is the caller graph for this function:

GetLimiterSettings() [1/2]

LimiterSettings * DynamicRangeProcessorEditor::GetLimiterSettings ( )

inlineprivate

Definition at line 128 of file DynamicRangeProcessorEditor.h.

   {
      return const_cast<LimiterSettings*>(
         const_cast<const DynamicRangeProcessorEditor&>(*this)
            .GetLimiterSettings());
   }

References GetLimiterSettings().

Here is the call graph for this function:

GetLimiterSettings() [2/2]

virtual const LimiterSettings * DynamicRangeProcessorEditor::GetLimiterSettings ( ) const

inlineprivatevirtual

Reimplemented in LimiterEditor.

Definition at line 116 of file DynamicRangeProcessorEditor.h.

   {
      return nullptr;
   }

Referenced by GetLimiterSettings(), UpdateUI(), and ValidateUI().

Here is the caller graph for this function:

Initialize()

void DynamicRangeProcessorEditor::Initialize ( std::vector< ExtendedCompressorParameter >  parameters )

protected

Definition at line 142 of file DynamicRangeProcessorEditor.cpp.

{
   assert(std::is_sorted(
      parameters.begin(), parameters.end(),
      [](const auto& a, const auto& b) { return a.category < b.category; }));
   mParameters = std::move(parameters);
}

References mParameters.

Referenced by CompressorEditor::CompressorEditor(), and LimiterEditor::LimiterEditor().

Here is the caller graph for this function:

OnCheckbox()

void DynamicRangeProcessorEditor::OnCheckbox ( bool  newVal, double &  setting, void(DynamicRangeProcessorHistoryPanel::*)(bool)  setter  )

private

Definition at line 496 of file DynamicRangeProcessorEditor.cpp.

{
   setting = newVal;
   if (
      const auto panel = dynamic_cast<HistPanel*>(
         wxWindow::FindWindowById(historyPanelId, mUIParent)))
      (panel->*setter)(newVal);
   ValidateUI();
   Publish(EffectSettingChanged {});
}

References anonymous_namespace{DynamicRangeProcessorEditor.cpp}::historyPanelId, mUIParent, Observer::Publisher< EffectSettingChanged >::Publish(), and ValidateUI().

Referenced by AddCheckboxPanel().

Here is the call graph for this function:

Here is the caller graph for this function:

PopulateOrExchange()

void DynamicRangeProcessorEditor::PopulateOrExchange

(

ShuttleGui &

S

)

Definition at line 151 of file DynamicRangeProcessorEditor.cpp.

{
   S.SetBorder(borderSize);
   S.AddSpace(0, borderSize);
 
   const auto compressorSettings = GetCompressorSettings();
   if (compressorSettings)
   {
      S.StartMultiColumn(2, wxEXPAND);
      {
         S.SetStretchyCol(0);
         AddSliderPanel(S);
         AddCompressionCurvePanel(S, *compressorSettings);
      }
      S.EndMultiColumn();
   }
   else
      AddSliderPanel(S);
 
   if (!mIsRealtime)
      // Not a real-time effect editor, no need for a graph
      return;
 
   const auto settings = GetSettings(mAccess);
 
   const auto rulerPanel = MakeRulerPanel(
      mUIParent, wxVERTICAL,
      GetDbRange(CompressorProcessor::GetMaxCompressionDb(settings)),
      historyRulerPanelId);
 
   const auto onDbRangeChanged = [this](float newDbRange) {
      for (const auto id :
           { historyRulerPanelId, compressionMeterRulerPanelId })
         if (
            const auto panel = dynamic_cast<RulerPanel*>(
               wxWindow::FindWindowById(id, mUIParent)))
         {
            panel->ruler.SetRange(0., -newDbRange);
            panel->Refresh();
         }
      if (
         const auto compressionMeterPanel =
            dynamic_cast<CompressionMeterPanel*>(
               wxWindow::FindWindowById(compressionMeterPanelId, mUIParent)))
         compressionMeterPanel->SetDbRange(newDbRange);
   };
 
   const auto histPanel = safenew HistPanel(
      mUIParent, historyPanelId, mCompressorInstance, onDbRangeChanged);
   histPanel->ShowInput(settings.showInput);
   histPanel->ShowOutput(settings.showOutput);
   histPanel->ShowActual(settings.showActual);
   histPanel->ShowTarget(settings.showTarget);
 
   S.StartMultiColumn(compressorSettings ? 3 : 1, wxEXPAND);
   {
      S.SetStretchyCol(0);
      AddCheckboxPanel(S, settings);
      if (compressorSettings)
      {
         AddClipIndicator(S);
         S.AddSpace(rulerWidth, 0);
      }
   }
   S.EndMultiColumn();
 
   S.SetSizerProportion(1);
   S.StartMultiColumn(5, wxEXPAND);
   {
      using namespace DynamicRangeProcessorPanel;
 
      S.SetStretchyCol(1);
      S.SetStretchyRow(0);
      S.AddSpace(borderSize, 0);
      S.Prop(1)
         .Position(wxALIGN_LEFT | wxALIGN_TOP | wxEXPAND)
         .MinSize({ HistPanel::minWidth, graphMinHeight })
         .AddWindow(histPanel);
 
      S.AddSpace(borderSize, 0);
 
      const auto onClipped = [this] {
         if (
            const auto panel = dynamic_cast<ClipIndicatorPanel*>(
               wxWindow::FindWindowById(clipIndicatorId, mUIParent)))
            panel->SetClipped();
      };
      S.Prop(1)
         .Position(wxALIGN_LEFT | wxALIGN_TOP | wxEXPAND)
         .MinSize({ compressionMeterPanelWidth, graphMinHeight })
         .AddWindow(safenew CompressionMeterPanel(
            mUIParent, compressionMeterPanelId, mCompressorInstance,
            graphMinRangeDb, onClipped))
         ->Bind(wxEVT_LEFT_UP, [this](wxMouseEvent& evt) {
            if (
               const auto panel =
                  dynamic_cast<CompressionMeterPanel*>(evt.GetEventObject()))
               panel->Reset();
            if (
               const auto indicator = dynamic_cast<ClipIndicatorPanel*>(
                  wxWindow::FindWindowById(clipIndicatorId, mUIParent)))
               indicator->Reset();
         });
 
      S.Prop(1)
         .Position(wxEXPAND | wxALIGN_TOP)
         .MinSize({ rulerWidth, graphMinHeight })
         .AddWindow(rulerPanel);
   }
   S.EndMultiColumn();
 
   S.AddSpace(0, borderSize);
}

References AddCheckboxPanel(), AddClipIndicator(), AddCompressionCurvePanel(), AddSliderPanel(), anonymous_namespace{DynamicRangeProcessorEditor.cpp}::borderSize, anonymous_namespace{DynamicRangeProcessorEditor.cpp}::clipIndicatorId, anonymous_namespace{DynamicRangeProcessorEditor.cpp}::compressionMeterPanelId, anonymous_namespace{DynamicRangeProcessorEditor.cpp}::compressionMeterPanelWidth, anonymous_namespace{DynamicRangeProcessorEditor.cpp}::compressionMeterRulerPanelId, GetCompressorSettings(), anonymous_namespace{DynamicRangeProcessorEditor.cpp}::GetDbRange(), CompressorProcessor::GetMaxCompressionDb(), anonymous_namespace{DynamicRangeProcessorEditor.cpp}::GetSettings(), DynamicRangeProcessorPanel::graphMinHeight, DynamicRangeProcessorPanel::graphMinRangeDb, anonymous_namespace{DynamicRangeProcessorEditor.cpp}::historyPanelId, anonymous_namespace{DynamicRangeProcessorEditor.cpp}::historyRulerPanelId, EffectEditor::mAccess, anonymous_namespace{DynamicRangeProcessorEditor.cpp}::MakeRulerPanel(), mCompressorInstance, mIsRealtime, mUIParent, anonymous_namespace{DynamicRangeProcessorEditor.cpp}::rulerWidth, S, safenew, and settings().

Here is the call graph for this function:

UpdateUI()

bool DynamicRangeProcessorEditor::UpdateUI ( )

finaloverrideprivatevirtual

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 478 of file DynamicRangeProcessorEditor.cpp.

{
   if (CompressorSettings* compressorSettings = GetCompressorSettings())
      *compressorSettings = *mAccess.Get().cast<CompressorSettings>();
   else
      *GetLimiterSettings() = *mAccess.Get().cast<LimiterSettings>();
 
   for (auto& setting : mParameters)
      setting.slider->SetValue(std::round(TextToSliderValue(setting)));
 
   if (
      auto tfPanel =
         wxWindow::FindWindowById(transferFunctionPanelId, mUIParent))
      tfPanel->Refresh();
 
   return true;
}

References audacity::TypedAny< Tag >::cast(), EffectSettingsAccess::Get(), GetCompressorSettings(), GetLimiterSettings(), EffectEditor::mAccess, mParameters, mUIParent, fast_float::round(), anonymous_namespace{DynamicRangeProcessorEditor.cpp}::TextToSliderValue(), and anonymous_namespace{DynamicRangeProcessorEditor.cpp}::transferFunctionPanelId.

Referenced by AddTextboxAndSlider().

Here is the call graph for this function:

Here is the caller graph for this function:

ValidateUI()

bool DynamicRangeProcessorEditor::ValidateUI ( )

finaloverrideprivatevirtual

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 465 of file DynamicRangeProcessorEditor.cpp.

{
   mAccess.ModifySettings([this](EffectSettings& settings) {
      // pass back the modified settings to the MessageBuffer
      if (auto compressorSettings = settings.cast<CompressorSettings>())
         *compressorSettings = *GetCompressorSettings();
      else
         *settings.cast<LimiterSettings>() = *GetLimiterSettings();
      return nullptr;
   });
   return true;
}

References GetCompressorSettings(), GetLimiterSettings(), EffectEditor::mAccess, EffectSettingsAccess::ModifySettings(), and settings().

Referenced by AddTextboxAndSlider(), and OnCheckbox().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

dbStep

constexpr auto DynamicRangeProcessorEditor::dbStep = 0.1

staticconstexprprotected

Definition at line 99 of file DynamicRangeProcessorEditor.h.

mCompressorInstance

CompressorInstance& DynamicRangeProcessorEditor::mCompressorInstance

private

Definition at line 152 of file DynamicRangeProcessorEditor.h.

Referenced by PopulateOrExchange().

mFullHeight

int DynamicRangeProcessorEditor::mFullHeight { 0 }

private

Definition at line 154 of file DynamicRangeProcessorEditor.h.

mIsRealtime

const bool DynamicRangeProcessorEditor::mIsRealtime

private

Definition at line 153 of file DynamicRangeProcessorEditor.h.

Referenced by PopulateOrExchange().

mParameters

std::vector<ExtendedCompressorParameter> DynamicRangeProcessorEditor::mParameters

private

Definition at line 150 of file DynamicRangeProcessorEditor.h.

Referenced by AddSliderPanel(), Initialize(), and UpdateUI().

mTopLevelParent

wxDialog& DynamicRangeProcessorEditor::mTopLevelParent

private

Definition at line 151 of file DynamicRangeProcessorEditor.h.

mUIParent

wxWeakRef<wxWindow> DynamicRangeProcessorEditor::mUIParent

private

Definition at line 149 of file DynamicRangeProcessorEditor.h.

Referenced by AddClipIndicator(), AddCompressionCurvePanel(), AddTextboxAndSlider(), OnCheckbox(), PopulateOrExchange(), and UpdateUI().

---

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

• DynamicRangeProcessorEditor.h
• DynamicRangeProcessorEditor.cpp