Update all other plugins to new DPF

4 files changed, 87 insertions, 95 deletions

diff --git a/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.cpp b/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.cpp
index 4504d99..6e46d65 100644
--- a/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.cpp
+++ b/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.cpp
@@ -25,13 +25,13 @@ ZaMultiCompX2Plugin::ZaMultiCompX2Plugin()
     : Plugin(paramCount, 2, 0)
 {
     // set default values
-    d_setProgram(0);
+    loadProgram(0);
 }
 
 // -----------------------------------------------------------------------
 // Init
 
-void ZaMultiCompX2Plugin::d_initParameter(uint32_t index, Parameter& parameter)
+void ZaMultiCompX2Plugin::initParameter(uint32_t index, Parameter& parameter)
 {
     switch (index)
     {
@@ -263,7 +263,7 @@ void ZaMultiCompX2Plugin::d_initParameter(uint32_t index, Parameter& parameter)
     }
 }
 
-void ZaMultiCompX2Plugin::d_initProgramName(uint32_t index, d_string& programName)
+void ZaMultiCompX2Plugin::initProgramName(uint32_t index, String& programName)
 {
 	switch(index) {
 	case 0:
@@ -333,12 +333,19 @@ void ZaMultiCompX2Plugin::loadProgram(uint32_t index)
 		outr = -45.0;
 		break;
 	}
+    /* Default variable values */
+    maxL = 0.f;
+    maxR = 0.f;
+    limit = 0.f;
+
+    /* reset filter values */
+    activate();
 }
 
 // -----------------------------------------------------------------------
 // Internal data
 
-float ZaMultiCompX2Plugin::d_getParameterValue(uint32_t index) const
+float ZaMultiCompX2Plugin::getParameterValue(uint32_t index) const
 {
     switch (index)
     {
@@ -422,7 +429,7 @@ float ZaMultiCompX2Plugin::d_getParameterValue(uint32_t index) const
     }
 }
 
-void ZaMultiCompX2Plugin::d_setParameterValue(uint32_t index, float value)
+void ZaMultiCompX2Plugin::setParameterValue(uint32_t index, float value)
 {
     switch (index)
     {
@@ -516,34 +523,20 @@ void ZaMultiCompX2Plugin::d_setParameterValue(uint32_t index, float value)
     }
 }
 
-void ZaMultiCompX2Plugin::d_setProgram(uint32_t index)
-{
-    /* Default parameter values */
-    loadProgram(index);
-
-    /* Default variable values */
-    maxL = 0.f;
-    maxR = 0.f;
-    limit = 0.f;
-
-    /* reset filter values */
-    d_activate();
-}
-
-void ZaMultiCompX2Plugin::d_setState(const char*, const char*)
+void ZaMultiCompX2Plugin::setState(const char*, const char*)
 {
     resetl = true;
     resetr = true;
 }
 
-void ZaMultiCompX2Plugin::d_initState(unsigned int, d_string&, d_string&)
+void ZaMultiCompX2Plugin::initState(unsigned int, String&, String&)
 {
 }
 
 // -----------------------------------------------------------------------
 // Process
 
-void ZaMultiCompX2Plugin::d_activate()
+void ZaMultiCompX2Plugin::activate()
 {
         int i,j;
         for (i = 0; i < MAX_COMP; i++)
@@ -613,7 +606,7 @@ void ZaMultiCompX2Plugin::set_hp_coeffs(float fc, float q, float sr, int i, int
 
 void ZaMultiCompX2Plugin::run_limit(float inL, float inR, float *outL, float *outR)
 {
-	float srate = d_getSampleRate();
+	float srate = getSampleRate();
         float width=0.01;
 	float threshdb = -0.5;
         float attack_coeff = exp(-1000.f/(0.001 * srate));
@@ -692,7 +685,7 @@ void ZaMultiCompX2Plugin::run_limit(float inL, float inR, float *outL, float *ou
 
 void ZaMultiCompX2Plugin::run_comp(int k, float inL, float inR, float *outL, float *outR)
 {
-	float srate = d_getSampleRate();
+	float srate = getSampleRate();
         float width=(knee-0.99f)*6.f;
         float attack_coeff = exp(-1000.f/(attack * srate));
         float release_coeff = exp(-1000.f/(release * srate));
@@ -792,9 +785,9 @@ void ZaMultiCompX2Plugin::run_comp(int k, float inL, float inR, float *outL, flo
         old_yg[1][k] = Ryg;
 }
 
-void ZaMultiCompX2Plugin::d_run(const float** inputs, float** outputs, uint32_t frames)
+void ZaMultiCompX2Plugin::run(const float** inputs, float** outputs, uint32_t frames)
 {
-	float srate = d_getSampleRate();
+	float srate = getSampleRate();
 	float maxxL = maxL;
 	float maxxR = maxR;
 
diff --git a/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.hpp b/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.hpp
index a7ee283..bfa525b 100644
--- a/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.hpp
+++ b/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.hpp
@@ -83,27 +83,27 @@ protected:
     // -------------------------------------------------------------------
     // Information
 
-    const char* d_getLabel() const noexcept override
+    const char* getLabel() const noexcept override
     {
         return "ZaMultiCompX2";
     }
 
-    const char* d_getMaker() const noexcept override
+    const char* getMaker() const noexcept override
     {
         return "Damien Zammit";
     }
 
-    const char* d_getLicense() const noexcept override
+    const char* getLicense() const noexcept override
     {
         return "GPL v2+";
     }
 
-    uint32_t d_getVersion() const noexcept override
+    uint32_t getVersion() const noexcept override
     {
         return 0x1000;
     }
 
-    int64_t d_getUniqueId() const noexcept override
+    int64_t getUniqueId() const noexcept override
     {
         return d_cconst('Z', 'M', 'M', '2');
     }
@@ -111,19 +111,18 @@ protected:
     // -------------------------------------------------------------------
     // Init
 
-    void d_initParameter(uint32_t index, Parameter& parameter) ;
-    void d_initProgramName(uint32_t index, d_string& programName) ;
-    void d_initState(uint32_t, d_string&, d_string&) override;
+    void initParameter(uint32_t index, Parameter& parameter) ;
+    void initProgramName(uint32_t index, String& programName) ;
+    void initState(uint32_t, String&, String&) override;
 
     // -------------------------------------------------------------------
     // Internal data
 
-    float d_getParameterValue(uint32_t index) const override;
-    void  d_setParameterValue(uint32_t index, float value) override;
-    void  d_setProgram(uint32_t index) override;
-    void  d_setState(const char* key, const char* value) override;
+    float getParameterValue(uint32_t index) const override;
+    void  setParameterValue(uint32_t index, float value) override;
+    void  loadProgram(uint32_t index) override;
+    void  setState(const char* key, const char* value) override;
 
-    void  loadProgram(uint32_t index);
     // -------------------------------------------------------------------
     // Process
 
@@ -150,8 +149,8 @@ protected:
     void set_lp_coeffs(float fc, float q, float sr, int i, int ch, float gain);
     void set_hp_coeffs(float fc, float q, float sr, int i, int ch, float gain);
 
-    void d_activate() override;
-    void d_run(const float** inputs, float** outputs, uint32_t frames) override;
+    void activate() override;
+    void run(const float** inputs, float** outputs, uint32_t frames) override;
 
     // -------------------------------------------------------------------
 
diff --git a/plugins/ZaMultiCompX2/ZaMultiCompX2UI.cpp b/plugins/ZaMultiCompX2/ZaMultiCompX2UI.cpp
index 5bd92d3..9f82730 100644
--- a/plugins/ZaMultiCompX2/ZaMultiCompX2UI.cpp
+++ b/plugins/ZaMultiCompX2/ZaMultiCompX2UI.cpp
@@ -218,7 +218,7 @@ ZaMultiCompX2UI::ZaMultiCompX2UI()
     }
 
     // set default values
-    d_programChanged(0);
+    programLoaded(0);
 }
 
 void ZaMultiCompX2UI::compcurve(float in, int k, float *outx, float* outy) {
@@ -274,7 +274,7 @@ void ZaMultiCompX2UI::calc_compcurves() {
 // -----------------------------------------------------------------------
 // DSP Callbacks
 
-void ZaMultiCompX2UI::d_parameterChanged(uint32_t index, float value)
+void ZaMultiCompX2UI::parameterChanged(uint32_t index, float value)
 {
     switch (index)
     {
@@ -409,7 +409,7 @@ void ZaMultiCompX2UI::d_parameterChanged(uint32_t index, float value)
     }
 }
 
-void ZaMultiCompX2UI::d_programChanged(uint32_t index)
+void ZaMultiCompX2UI::programLoaded(uint32_t index)
 {
     if (index != 0)
         return;
@@ -436,7 +436,7 @@ void ZaMultiCompX2UI::d_programChanged(uint32_t index)
     fToggleStereo->setValue(0.0f);
 }
 
-void ZaMultiCompX2UI::d_stateChanged(const char*, const char*)
+void ZaMultiCompX2UI::stateChanged(const char*, const char*)
 {
 }
 
@@ -446,141 +446,141 @@ void ZaMultiCompX2UI::d_stateChanged(const char*, const char*)
 void ZaMultiCompX2UI::imageKnobDragStarted(ImageKnob* knob)
 {
     if (knob == fKnobAttack)
-        d_editParameter(ZaMultiCompX2Plugin::paramAttack, true);
+        editParameter(ZaMultiCompX2Plugin::paramAttack, true);
     else if (knob == fKnobRelease)
-        d_editParameter(ZaMultiCompX2Plugin::paramRelease, true);
+        editParameter(ZaMultiCompX2Plugin::paramRelease, true);
     else if (knob == fKnobThresh1)
-        d_editParameter(ZaMultiCompX2Plugin::paramThresh1, true);
+        editParameter(ZaMultiCompX2Plugin::paramThresh1, true);
     else if (knob == fKnobThresh2)
-        d_editParameter(ZaMultiCompX2Plugin::paramThresh2, true);
+        editParameter(ZaMultiCompX2Plugin::paramThresh2, true);
     else if (knob == fKnobThresh3)
-        d_editParameter(ZaMultiCompX2Plugin::paramThresh3, true);
+        editParameter(ZaMultiCompX2Plugin::paramThresh3, true);
     else if (knob == fKnobRatio)
-        d_editParameter(ZaMultiCompX2Plugin::paramRatio, true);
+        editParameter(ZaMultiCompX2Plugin::paramRatio, true);
     else if (knob == fKnobKnee)
-        d_editParameter(ZaMultiCompX2Plugin::paramKnee, true);
+        editParameter(ZaMultiCompX2Plugin::paramKnee, true);
     else if (knob == fKnobGlobalGain)
-        d_editParameter(ZaMultiCompX2Plugin::paramGlobalGain, true);
+        editParameter(ZaMultiCompX2Plugin::paramGlobalGain, true);
     else if (knob == fKnobMakeup1)
-        d_editParameter(ZaMultiCompX2Plugin::paramMakeup1, true);
+        editParameter(ZaMultiCompX2Plugin::paramMakeup1, true);
     else if (knob == fKnobMakeup2)
-        d_editParameter(ZaMultiCompX2Plugin::paramMakeup2, true);
+        editParameter(ZaMultiCompX2Plugin::paramMakeup2, true);
     else if (knob == fKnobMakeup3)
-        d_editParameter(ZaMultiCompX2Plugin::paramMakeup3, true);
+        editParameter(ZaMultiCompX2Plugin::paramMakeup3, true);
     else if (knob == fKnobXover1)
-        d_editParameter(ZaMultiCompX2Plugin::paramXover1, true);
+        editParameter(ZaMultiCompX2Plugin::paramXover1, true);
     else if (knob == fKnobXover2)
-        d_editParameter(ZaMultiCompX2Plugin::paramXover2, true);
+        editParameter(ZaMultiCompX2Plugin::paramXover2, true);
 }
 
 void ZaMultiCompX2UI::imageKnobDragFinished(ImageKnob* knob)
 {
     if (knob == fKnobAttack)
-        d_editParameter(ZaMultiCompX2Plugin::paramAttack, false);
+        editParameter(ZaMultiCompX2Plugin::paramAttack, false);
     else if (knob == fKnobRelease)
-        d_editParameter(ZaMultiCompX2Plugin::paramRelease, false);
+        editParameter(ZaMultiCompX2Plugin::paramRelease, false);
     else if (knob == fKnobThresh1)
-        d_editParameter(ZaMultiCompX2Plugin::paramThresh1, false);
+        editParameter(ZaMultiCompX2Plugin::paramThresh1, false);
     else if (knob == fKnobThresh2)
-        d_editParameter(ZaMultiCompX2Plugin::paramThresh2, false);
+        editParameter(ZaMultiCompX2Plugin::paramThresh2, false);
     else if (knob == fKnobThresh3)
-        d_editParameter(ZaMultiCompX2Plugin::paramThresh3, false);
+        editParameter(ZaMultiCompX2Plugin::paramThresh3, false);
     else if (knob == fKnobRatio)
-        d_editParameter(ZaMultiCompX2Plugin::paramRatio, false);
+        editParameter(ZaMultiCompX2Plugin::paramRatio, false);
     else if (knob == fKnobKnee)
-        d_editParameter(ZaMultiCompX2Plugin::paramKnee, false);
+        editParameter(ZaMultiCompX2Plugin::paramKnee, false);
     else if (knob == fKnobGlobalGain)
-        d_editParameter(ZaMultiCompX2Plugin::paramGlobalGain, false);
+        editParameter(ZaMultiCompX2Plugin::paramGlobalGain, false);
     else if (knob == fKnobMakeup1)
-        d_editParameter(ZaMultiCompX2Plugin::paramMakeup1, false);
+        editParameter(ZaMultiCompX2Plugin::paramMakeup1, false);
     else if (knob == fKnobMakeup2)
-        d_editParameter(ZaMultiCompX2Plugin::paramMakeup2, false);
+        editParameter(ZaMultiCompX2Plugin::paramMakeup2, false);
     else if (knob == fKnobMakeup3)
-        d_editParameter(ZaMultiCompX2Plugin::paramMakeup3, false);
+        editParameter(ZaMultiCompX2Plugin::paramMakeup3, false);
     else if (knob == fKnobXover1)
-        d_editParameter(ZaMultiCompX2Plugin::paramXover1, false);
+        editParameter(ZaMultiCompX2Plugin::paramXover1, false);
     else if (knob == fKnobXover2)
-        d_editParameter(ZaMultiCompX2Plugin::paramXover2, false);
+        editParameter(ZaMultiCompX2Plugin::paramXover2, false);
 }
 
 void ZaMultiCompX2UI::imageKnobValueChanged(ImageKnob* knob, float value)
 {
     if (knob == fKnobAttack)
-        d_setParameterValue(ZaMultiCompX2Plugin::paramAttack, value);
+        setParameterValue(ZaMultiCompX2Plugin::paramAttack, value);
     else if (knob == fKnobRelease)
-        d_setParameterValue(ZaMultiCompX2Plugin::paramRelease, value);
+        setParameterValue(ZaMultiCompX2Plugin::paramRelease, value);
     else if (knob == fKnobThresh1) {
-        d_setParameterValue(ZaMultiCompX2Plugin::paramThresh1, value);
+        setParameterValue(ZaMultiCompX2Plugin::paramThresh1, value);
 	fThresh[0] = value;
     }
     else if (knob == fKnobThresh2) {
-        d_setParameterValue(ZaMultiCompX2Plugin::paramThresh2, value);
+        setParameterValue(ZaMultiCompX2Plugin::paramThresh2, value);
 	fThresh[1] = value;
     }
     else if (knob == fKnobThresh3) {
-        d_setParameterValue(ZaMultiCompX2Plugin::paramThresh3, value);
+        setParameterValue(ZaMultiCompX2Plugin::paramThresh3, value);
 	fThresh[2] = value;
     }
     else if (knob == fKnobRatio) {
-        d_setParameterValue(ZaMultiCompX2Plugin::paramRatio, value);
+        setParameterValue(ZaMultiCompX2Plugin::paramRatio, value);
         fRatio = value;
     }
     else if (knob == fKnobKnee) {
-        d_setParameterValue(ZaMultiCompX2Plugin::paramKnee, value);
+        setParameterValue(ZaMultiCompX2Plugin::paramKnee, value);
 	fKnee = value;
     }
     else if (knob == fKnobGlobalGain) {
-        d_setParameterValue(ZaMultiCompX2Plugin::paramGlobalGain, value);
+        setParameterValue(ZaMultiCompX2Plugin::paramGlobalGain, value);
         fMaster = value;
     }
     else if (knob == fKnobMakeup1) {
-        d_setParameterValue(ZaMultiCompX2Plugin::paramMakeup1, value);
+        setParameterValue(ZaMultiCompX2Plugin::paramMakeup1, value);
         fMakeup[0] = value;
     }
     else if (knob == fKnobMakeup2) {
-        d_setParameterValue(ZaMultiCompX2Plugin::paramMakeup2, value);
+        setParameterValue(ZaMultiCompX2Plugin::paramMakeup2, value);
         fMakeup[1] = value;
     }
     else if (knob == fKnobMakeup3) {
-        d_setParameterValue(ZaMultiCompX2Plugin::paramMakeup3, value);
+        setParameterValue(ZaMultiCompX2Plugin::paramMakeup3, value);
         fMakeup[2] = value;
     }
     else if (knob == fKnobXover1)
-        d_setParameterValue(ZaMultiCompX2Plugin::paramXover1, value);
+        setParameterValue(ZaMultiCompX2Plugin::paramXover1, value);
     else if (knob == fKnobXover2)
-        d_setParameterValue(ZaMultiCompX2Plugin::paramXover2, value);
+        setParameterValue(ZaMultiCompX2Plugin::paramXover2, value);
 }
 
 void ZaMultiCompX2UI::imageToggleClicked(ImageToggle* toggle, int)
 {
     float v = toggle->getValue();
     if (toggle == fToggleBypass1) {
-        d_setParameterValue(ZaMultiCompX2Plugin::paramToggle1, v);
+        setParameterValue(ZaMultiCompX2Plugin::paramToggle1, v);
         fBypass[0] = v;
     }
     else if (toggle == fToggleBypass2) {
-        d_setParameterValue(ZaMultiCompX2Plugin::paramToggle2, v);
+        setParameterValue(ZaMultiCompX2Plugin::paramToggle2, v);
         fBypass[1] = v;
     }
     else if (toggle == fToggleBypass3) {
-        d_setParameterValue(ZaMultiCompX2Plugin::paramToggle3, v);
+        setParameterValue(ZaMultiCompX2Plugin::paramToggle3, v);
         fBypass[2] = v;
     }
     else if (toggle == fToggleListen1)
-        d_setParameterValue(ZaMultiCompX2Plugin::paramListen1, v);
+        setParameterValue(ZaMultiCompX2Plugin::paramListen1, v);
     else if (toggle == fToggleListen2)
-        d_setParameterValue(ZaMultiCompX2Plugin::paramListen2, v);
+        setParameterValue(ZaMultiCompX2Plugin::paramListen2, v);
     else if (toggle == fToggleListen3)
-        d_setParameterValue(ZaMultiCompX2Plugin::paramListen3, v);
+        setParameterValue(ZaMultiCompX2Plugin::paramListen3, v);
     else if (toggle == fToggleStereo)
-        d_setParameterValue(ZaMultiCompX2Plugin::paramStereoDet, v);
+        setParameterValue(ZaMultiCompX2Plugin::paramStereoDet, v);
 }
 
 void ZaMultiCompX2UI::onDisplay()
 {
     fImgBackground.draw();
 
-    d_setState("stateMeterReset", "");
+    setState("stateMeterReset", "");
 
     // draw leds
     static const float sLedSpacing  = 15.5f;
diff --git a/plugins/ZaMultiCompX2/ZaMultiCompX2UI.hpp b/plugins/ZaMultiCompX2/ZaMultiCompX2UI.hpp
index d9023f4..9afa5b5 100644
--- a/plugins/ZaMultiCompX2/ZaMultiCompX2UI.hpp
+++ b/plugins/ZaMultiCompX2/ZaMultiCompX2UI.hpp
@@ -52,9 +52,9 @@ protected:
     // -------------------------------------------------------------------
     // DSP Callbacks
 
-    void d_parameterChanged(uint32_t index, float value) override;
-    void d_programChanged(uint32_t index) override;
-    void d_stateChanged(const char*, const char*) override;
+    void parameterChanged(uint32_t index, float value) override;
+    void programLoaded(uint32_t index) override;
+    void stateChanged(const char*, const char*) override;
 
     // -------------------------------------------------------------------
     // Widget Callbacks