cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/faust/gui/JuceGUI.h

@@ -0,0 +1,2061 @@
+/************************** BEGIN JuceGUI.h *****************************
+ FAUST Architecture File
+ Copyright (C) 2003-2022 GRAME, Centre National de Creation Musicale
+ ---------------------------------------------------------------------
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+ 
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+ 
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ 
+ EXCEPTION : As a special exception, you may create a larger work
+ that contains this FAUST architecture section and distribute
+ that work under terms of your choice, so long as this FAUST
+ architecture section is not modified.
+ ************************************************************************/
+
+#ifndef JUCE_GUI_H
+#define JUCE_GUI_H
+
+#ifndef FAUSTFLOAT
+#define FAUSTFLOAT float
+#endif
+
+#include <stack>
+
+#include "../JuceLibraryCode/JuceHeader.h"
+
+#include "faust/gui/GUI.h"
+#include "faust/gui/MetaDataUI.h"
+#include "faust/gui/ValueConverter.h"
+
+// Definition of the standard size of the different elements
+
+#define kKnobWidth 100
+#define kKnobHeight 100
+
+#define kVSliderWidth 80
+#define kVSliderHeight 250
+
+#define kHSliderWidth 350
+#define kHSliderHeight 50
+
+#define kButtonWidth 100
+#define kButtonHeight 50
+
+#define kCheckButtonWidth 60
+#define kCheckButtonHeight 40
+
+#define kMenuWidth 100
+#define kMenuHeight 50
+
+#define kRadioButtonWidth 100
+#define kRadioButtonHeight 55
+
+#define kNumEntryWidth 100
+#define kNumEntryHeight 50
+
+#define kNumDisplayWidth 75
+#define kNumDisplayHeight 50
+
+#define kVBargraphWidth 60
+#define kVBargraphHeight 250
+
+#define kHBargraphWidth 350
+#define kHBargraphHeight 50
+
+#define kLedWidth 25
+#define kLedHeight 25
+
+#define kNameHeight 14
+
+#define kMargin 4
+
+/**
+ * \brief       Custom LookAndFeel class.
+ * \details     Define the appearance of all the JUCE widgets.
+ */
+
+struct CustomLookAndFeel : public juce::LookAndFeel_V3
+{
+    void drawRoundThumb (juce::Graphics& g, const float x, const float y,
+                         const float diameter, const juce::Colour& colour, float outlineThickness)
+    {
+        const juce::Rectangle<float> a (x, y, diameter, diameter);
+        const float halfThickness = outlineThickness * 0.5f;
+
+        juce::Path p;
+        p.addEllipse (x + halfThickness, y + halfThickness, diameter - outlineThickness, diameter - outlineThickness);
+
+        const juce::DropShadow ds (juce::Colours::black, 1, juce::Point<int> (0, 0));
+        ds.drawForPath (g, p);
+
+        g.setColour (colour);
+        g.fillPath (p);
+
+        g.setColour (colour.brighter());
+        g.strokePath (p, juce::PathStrokeType (outlineThickness));
+    }
+
+    void drawButtonBackground (juce::Graphics& g, juce::Button& button, const juce::Colour& backgroundColour,
+                               bool isMouseOverButton, bool isButtonDown) override
+    {
+        juce::Colour baseColour (backgroundColour.withMultipliedSaturation (button.hasKeyboardFocus (true) ? 1.3f : 0.9f)
+                           .withMultipliedAlpha (button.isEnabled() ? 0.9f : 0.5f));
+
+        if (isButtonDown || isMouseOverButton)
+            baseColour = baseColour.contrasting (isButtonDown ? 0.2f : 0.1f);
+
+        const bool flatOnLeft   = button.isConnectedOnLeft();
+        const bool flatOnRight  = button.isConnectedOnRight();
+        const bool flatOnTop    = button.isConnectedOnTop();
+        const bool flatOnBottom = button.isConnectedOnBottom();
+
+        const float width  = button.getWidth() - 1.0f;
+        const float height = button.getHeight() - 1.0f;
+
+        if (width > 0 && height > 0)
+        {
+            const float cornerSize = juce::jmin(15.0f, juce::jmin(width, height) * 0.45f);
+            const float lineThickness = cornerSize * 0.1f;
+            const float halfThickness = lineThickness * 0.5f;
+
+            juce::Path outline;
+            outline.addRoundedRectangle (0.5f + halfThickness, 0.5f + halfThickness, width - lineThickness, height - lineThickness,
+                                         cornerSize, cornerSize,
+                                         ! (flatOnLeft  || flatOnTop),
+                                         ! (flatOnRight || flatOnTop),
+                                         ! (flatOnLeft  || flatOnBottom),
+                                         ! (flatOnRight || flatOnBottom));
+
+            const juce::Colour outlineColour (button.findColour (button.getToggleState() ? juce::TextButton::textColourOnId
+                                        : juce::TextButton::textColourOffId));
+
+            g.setColour (baseColour);
+            g.fillPath (outline);
+
+            if (! button.getToggleState()) {
+                g.setColour (outlineColour);
+                g.strokePath (outline, juce::PathStrokeType (lineThickness));
+            }
+        }
+    }
+
+    void drawTickBox (juce::Graphics& g, juce::Component& component,
+                      float x, float y, float w, float h,
+                      bool ticked,
+                      bool isEnabled,
+                      bool isMouseOverButton,
+                      bool isButtonDown) override
+    {
+        const float boxSize = w * 0.7f;
+
+        bool isDownOrDragging = component.isEnabled() && (component.isMouseOverOrDragging() || component.isMouseButtonDown());
+        const juce::Colour colour (component.findColour (juce::TextButton::buttonColourId).withMultipliedSaturation ((component.hasKeyboardFocus (false) || isDownOrDragging) ? 1.3f : 0.9f)
+                             .withMultipliedAlpha (component.isEnabled() ? 1.0f : 0.7f));
+
+        drawRoundThumb (g, x, y + (h - boxSize) * 0.5f, boxSize, colour,
+                        isEnabled ? ((isButtonDown || isMouseOverButton) ? 1.1f : 0.5f) : 0.3f);
+
+        if (ticked) {
+            const juce::Path tick (juce::LookAndFeel_V2::getTickShape (6.0f));
+            g.setColour (isEnabled ? findColour (juce::TextButton::buttonOnColourId) : juce::Colours::grey);
+
+            const float scale = 9.0f;
+            const juce::AffineTransform trans (juce::AffineTransform::scale (w / scale, h / scale)
+                                         .translated (x - 2.5f, y + 1.0f));
+            g.fillPath (tick, trans);
+        }
+    }
+
+    void drawLinearSliderThumb (juce::Graphics& g, int x, int y, int width, int height,
+                                float sliderPos, float minSliderPos, float maxSliderPos,
+                                const juce::Slider::SliderStyle style, juce::Slider& slider) override
+    {
+        const float sliderRadius = (float)(getSliderThumbRadius (slider) - 2);
+
+        bool isDownOrDragging = slider.isEnabled() && (slider.isMouseOverOrDragging() || slider.isMouseButtonDown());
+        juce::Colour knobColour (slider.findColour (juce::Slider::thumbColourId).withMultipliedSaturation ((slider.hasKeyboardFocus (false) || isDownOrDragging) ? 1.3f : 0.9f)
+                           .withMultipliedAlpha (slider.isEnabled() ? 1.0f : 0.7f));
+
+        if (style == juce::Slider::LinearHorizontal || style == juce::Slider::LinearVertical) {
+            float kx, ky;
+
+            if (style == juce::Slider::LinearVertical) {
+                kx = x + width * 0.5f;
+                ky = sliderPos;
+            } else {
+                kx = sliderPos;
+                ky = y + height * 0.5f;
+            }
+
+            const float outlineThickness = slider.isEnabled() ? 0.8f : 0.3f;
+
+            drawRoundThumb (g,
+                            kx - sliderRadius,
+                            ky - sliderRadius,
+                            sliderRadius * 2.0f,
+                            knobColour, outlineThickness);
+        } else {
+            // Just call the base class for the demo
+            juce::LookAndFeel_V2::drawLinearSliderThumb (g, x, y, width, height, sliderPos, minSliderPos, maxSliderPos, style, slider);
+        }
+    }
+
+    void drawLinearSlider (juce::Graphics& g, int x, int y, int width, int height,
+                           float sliderPos, float minSliderPos, float maxSliderPos,
+                           const juce::Slider::SliderStyle style, juce::Slider& slider) override
+    {
+        g.fillAll (slider.findColour (juce::Slider::backgroundColourId));
+
+        if (style == juce::Slider::LinearBar || style == juce::Slider::LinearBarVertical) {
+            const float fx = (float)x, fy = (float)y, fw = (float)width, fh = (float)height;
+
+            juce::Path p;
+
+            if (style == juce::Slider::LinearBarVertical)
+                p.addRectangle (fx, sliderPos, fw, 1.0f + fh - sliderPos);
+            else
+                p.addRectangle (fx, fy, sliderPos - fx, fh);
+
+            juce::Colour baseColour (slider.findColour (juce::Slider::rotarySliderFillColourId)
+                               .withMultipliedSaturation (slider.isEnabled() ? 1.0f : 0.5f)
+                               .withMultipliedAlpha (0.8f));
+
+            g.setColour (baseColour);
+            g.fillPath (p);
+
+            const float lineThickness = juce::jmin(15.0f, juce::jmin(width, height) * 0.45f) * 0.1f;
+            g.drawRect (slider.getLocalBounds().toFloat(), lineThickness);
+        } else {
+            drawLinearSliderBackground (g, x, y, width, height, sliderPos, minSliderPos, maxSliderPos, style, slider);
+            drawLinearSliderThumb (g, x, y, width, height, sliderPos, minSliderPos, maxSliderPos, style, slider);
+        }
+    }
+
+    void drawLinearSliderBackground (juce::Graphics& g, int x, int y, int width, int height,
+                                     float /*sliderPos*/,
+                                     float /*minSliderPos*/,
+                                     float /*maxSliderPos*/,
+                                     const juce::Slider::SliderStyle /*style*/, juce::Slider& slider) override
+    {
+        const float sliderRadius = getSliderThumbRadius (slider) - 5.0f;
+        juce::Path on, off;
+
+        if (slider.isHorizontal()) {
+            const float iy = y + height * 0.5f - sliderRadius * 0.5f;
+            juce::Rectangle<float> r (x - sliderRadius * 0.5f, iy, width + sliderRadius, sliderRadius);
+            const float onW = r.getWidth() * ((float)slider.valueToProportionOfLength (slider.getValue()));
+
+            on.addRectangle (r.removeFromLeft (onW));
+            off.addRectangle (r);
+        } else {
+            const float ix = x + width * 0.5f - sliderRadius * 0.5f;
+            juce::Rectangle<float> r (ix, y - sliderRadius * 0.5f, sliderRadius, height + sliderRadius);
+            const float onH = r.getHeight() * ((float)slider.valueToProportionOfLength (slider.getValue()));
+
+            on.addRectangle (r.removeFromBottom (onH));
+            off.addRectangle (r);
+        }
+
+        g.setColour (slider.findColour (juce::Slider::rotarySliderFillColourId));
+        g.fillPath (on);
+
+        g.setColour (slider.findColour (juce::Slider::trackColourId));
+        g.fillPath (off);
+    }
+
+    void drawRotarySlider (juce::Graphics& g, int x, int y, int width, int height, float sliderPos,
+                           float rotaryStartAngle, float rotaryEndAngle, juce::Slider& slider) override
+    {
+        const float radius = juce::jmin(width / 2, height / 2) - 4.0f;
+        const float centreX = x + width * 0.5f;
+        const float centreY = y + height * 0.5f;
+        const float rx = centreX - radius;
+        const float ry = centreY - radius;
+        const float rw = radius * 2.0f;
+        const float angle = rotaryStartAngle + sliderPos * (rotaryEndAngle - rotaryStartAngle);
+        const bool isMouseOver = slider.isMouseOverOrDragging() && slider.isEnabled();
+
+        //Background
+        {
+            g.setColour(juce::Colours::lightgrey.withAlpha (isMouseOver ? 1.0f : 0.7f));
+            juce::Path intFilledArc;
+            intFilledArc.addPieSegment(rx, ry, rw, rw, rotaryStartAngle, rotaryEndAngle, 0.8);
+            g.fillPath(intFilledArc);
+        }
+
+        if (slider.isEnabled()) {
+            g.setColour(slider.findColour (juce::Slider::rotarySliderFillColourId).withAlpha (isMouseOver ? 1.0f : 0.7f));
+        } else {
+            g.setColour(juce::Colour (0x80808080));
+        }
+
+        //Render knob value
+        {
+            juce::Path pathArc;
+            pathArc.addPieSegment(rx, ry, rw, rw, rotaryStartAngle, angle, 0.8);
+            g.fillPath(pathArc);
+
+            juce::Path cursor, cursorShadow;
+            float rectWidth = radius*0.4;
+            float rectHeight = rectWidth/2;
+            float rectX = centreX + radius*0.9 - rectHeight/2;
+            float rectY = centreY - rectWidth/2;
+
+            cursor.addRectangle(rectX, rectY, rectWidth, rectHeight);
+            cursorShadow.addRectangle(rectX-1, rectY-1, rectWidth+2, rectHeight+2);
+
+            juce::AffineTransform t = juce::AffineTransform::translation(-rectWidth + 2, rectHeight/2);
+            t = t.rotated((angle - juce::MathConstants<float>::pi/2), centreX, centreY);
+
+            cursor.applyTransform(t);
+            cursorShadow.applyTransform(t);
+
+            g.setColour(juce::Colours::black);
+            g.fillPath(cursor);
+
+            g.setColour(juce::Colours::black .withAlpha(0.15f));
+            g.fillPath(cursorShadow);
+        }
+    }
+};
+
+/**
+ * \brief   Different kind of slider available
+ * \see     uiSlider
+ */
+enum SliderType {
+    HSlider,    /*!< Horizontal Slider      */
+    VSlider,    /*!< Vertical Slider        */
+    NumEntry,   /*!< Numerical Entry Box    */
+    Knob        /*!< Circular Slider        */
+};
+
+/**
+ * \brief   Different kind of VU-meter available.
+ */
+enum VUMeterType {
+    HVUMeter,   /*!< Horizontal VU-meter    */
+    VVUMeter,   /*!< Vertical VU-meter      */
+    Led,        /*!< LED VU-meter           */
+    NumDisplay  /*!< TextBox VU-meter       */
+};
+
+/**
+ * \brief   Intern class for all FAUST widgets.
+ * \details Every active, passive or box widgets derive from this class.
+ */
+class uiBase
+{
+    
+    protected:
+        
+        int fTotalWidth, fTotalHeight;              // Size with margins included (for a uiBox)
+        int fDisplayRectWidth, fDisplayRectHeight;  // Size without margin, just the child dimensions, sum on one dimension, max on the other
+        float fHRatio, fVRatio;
+        
+    public:
+        
+        /**
+         * \brief   Constructor.
+         * \details Initialize a uiBase with all its sizes.
+         *
+         * \param   totWidth    Minimal total width.
+         * \param   totHeight   Minimal total Height.
+         */
+        uiBase(int totWidth = 0, int totHeight = 0):
+            fTotalWidth(totWidth), fTotalHeight(totHeight),
+            fDisplayRectWidth(0), fDisplayRectHeight(0),
+            fHRatio(1), fVRatio(1)
+        {}
+        
+        virtual ~uiBase()
+        {}
+        
+        /** Return the size. */
+        juce::Rectangle<int> getSize()
+        {
+            return juce::Rectangle<int>(0, 0, fTotalWidth, fTotalHeight);
+        }
+        
+        /** Return the total height in pixels. */
+        int getTotalHeight()
+        {
+            return fTotalHeight;
+        }
+        
+        /** Return the total width in pixels. */
+        int getTotalWidth()
+        {
+            return fTotalWidth;
+        }
+        
+        /** Return the horizontal ratio, between 0 and 1. */
+        float getHRatio()
+        {
+            return fHRatio;
+        }
+        
+        /** Return the vertical ratio, between 0 and 1. */
+        float getVRatio()
+        {
+            return fVRatio;
+        }
+        
+        /**
+         * \brief   Set the uiBase bounds.
+         * \details Convert absolute bounds to relative bounds,
+         *          used in JUCE Component mechanics.
+         *
+         * \param r The absolute bounds.
+         *
+         */
+        void setRelativeSize(juce::Component* comp, const juce::Rectangle<int>& r)
+        {
+            comp->setBounds(r.getX() - comp->getParentComponent()->getX(),
+                            r.getY() - comp->getParentComponent()->getY(),
+                            r.getWidth(),
+                            r.getHeight());
+        }
+    
+        virtual void init(juce::Component* comp = nullptr)
+        {
+            /** Initialize both vertical and horizontal ratios. */
+            assert(comp);
+            uiBase* parentBox = comp->findParentComponentOfClass<uiBase>();
+            if (parentBox != nullptr) {
+                fHRatio = (float)fTotalWidth / (float)parentBox->fDisplayRectWidth;
+                fVRatio = (float)fTotalHeight / (float)parentBox->fDisplayRectHeight;
+            }
+        }
+    
+        virtual void setRecommendedSize()
+        {}
+        
+        virtual void add(juce::Component* comp)
+        {}
+    
+};
+
+/**
+ * \brief   Intern class for all FAUST active or passive widgets.
+ * \details Every activ or passive widgets derive from this class.
+ */
+class uiComponent : public uiBase, public juce::Component, public uiItem
+{
+
+    public:
+        /**
+         * \brief   Constructor.
+         * \details Initialize all uiItem, uiBase and the tooltip variables.
+         *
+         * \param   gui     Current FAUST GUI.
+         * \param   zone    Zone of the widget.
+         * \param   w       Width of the widget.
+         * \param   h       Height of the widget.
+         * \param   name    Name of the widget.
+         */
+        uiComponent(GUI* gui, FAUSTFLOAT* zone, int w, int h, juce::String name):uiBase(w, h), Component(name), uiItem(gui, zone)
+        {}
+
+};
+
+/** 
+ * \brief   Intern class for all kind of sliders.
+ * \see     SliderType
+ */
+class uiSlider : public uiComponent, public uiConverter, private juce::Slider::Listener
+{
+    
+    private:
+        
+        juce::Slider::SliderStyle fStyle;
+        juce::Label fLabel;
+        SliderType fType;
+        juce::Slider fSlider;
+
+    public:
+        /**
+         * \brief   Constructor.
+         * \details Initialize all uiComponent variables, and Slider specific ones.
+         *          Initialize juce::Slider parameters.
+         *
+         * \param   gui, zone, w, h, tooltip, name  uiComponent variables.
+         * \param   min                             Minimum value of the slider.
+         * \param   max                             Maximum value of the slider.
+         * \param   cur                             Initial value of the slider.
+         * \param   step                            Step of the slider.
+         * \param   unit                            Unit of the slider value.
+         * \param   scale                           Scale of the slider, exponential, logarithmic, or linear.
+         * \param   type                            Type of slider (see SliderType).
+         */
+        uiSlider(GUI* gui, FAUSTFLOAT* zone, FAUSTFLOAT w, FAUSTFLOAT h, FAUSTFLOAT cur, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step, juce::String name, juce::String unit, juce::String tooltip, MetaDataUI::Scale scale, SliderType type)
+            : uiComponent(gui, zone, w, h, name), uiConverter(scale, min, max, min, max), fType(type)
+        {
+            // Set the JUCE widget initalization variables.
+            switch(fType) {
+                case HSlider:
+                    fStyle = juce::Slider::SliderStyle::LinearHorizontal;
+                    break;
+                case VSlider:
+                    fStyle = juce::Slider::SliderStyle::LinearVertical;
+                    fSlider.setTextBoxStyle(juce::Slider::TextBoxBelow, false, 60, 20);
+                    break;
+                case NumEntry:
+                    fSlider.setIncDecButtonsMode(juce::Slider::incDecButtonsDraggable_AutoDirection);
+                    fStyle = juce::Slider::SliderStyle::IncDecButtons;
+                    break;
+                case Knob:
+                    fStyle = juce::Slider::SliderStyle::Rotary;
+                    fSlider.setTextBoxStyle(juce::Slider::TextBoxBelow, false, 60, 20);
+                    break;
+                default:
+                    break;
+            }
+            addAndMakeVisible(fSlider);
+
+            // Slider settings
+            fSlider.setRange(min, max, step);
+            fSlider.setValue(fConverter->faust2ui(cur));
+            fSlider.addListener(this);
+            fSlider.setSliderStyle(fStyle);
+            fSlider.setTextValueSuffix(" " + unit);
+            fSlider.setTooltip(tooltip);
+            switch (scale) {
+                case MetaDataUI::kLog:
+                    fSlider.setSkewFactor(0.25);
+                    break;
+                case MetaDataUI::kExp:
+                    fSlider.setSkewFactor(0.75);
+                    break;
+                default:
+                    break;
+            }
+      
+            // Label settings, only happens for a horizontal of numerical entry slider
+            // because the method attachToComponent only give the choice to place the
+            // slider name on centered top, which is what we want. It's done manually
+            // in the paint method.
+            if (fType == HSlider || fType == NumEntry) {
+                fLabel.setText(getName(), juce::dontSendNotification);
+                fLabel.attachToComponent(&fSlider, true);
+                fLabel.setTooltip(tooltip);
+                addAndMakeVisible(fLabel);
+            }
+        }
+
+        /** Draw the name of a vertical or circular slider. */
+        virtual void paint(juce::Graphics& g) override
+        {
+            if (fType == VSlider || fType == Knob) {
+                g.setColour(juce::Colours::black);
+                g.drawText(getName(), getLocalBounds(), juce::Justification::centredTop);
+            }
+        }
+
+        /** Allow to control the slider when its value is changed, but not by the user. */
+        void reflectZone() override
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+            fSlider.setValue(fConverter->faust2ui(v));
+        }
+
+        /** JUCE callback for a slider value change, give the value to the FAUST module. */
+        void sliderValueChanged(juce::Slider* slider) override
+        {
+            float v = slider->getValue();
+            modifyZone(FAUSTFLOAT(fConverter->ui2faust(v)));
+        }
+
+        /** 
+         * Set the good coordinates and size for the juce::Slider object depending 
+         * on its SliderType, whenever the layout size changes.
+         */
+        void resized() override
+        {
+            int x, y, width, height;
+            
+            switch (fType) {
+                    
+                case HSlider: {
+                    int nameWidth = juce::Font().getStringWidth(getName()) + kMargin * 2;
+                    x = nameWidth;
+                    y = 0;
+                    width = getWidth() - nameWidth;
+                    height = getHeight();
+                    break;
+                }
+                    
+                case VSlider:
+                    x = 0;
+                    y = kNameHeight; // kNameHeight pixels for the name
+                    height = getHeight() - kNameHeight;
+                    width = getWidth();
+                    break;
+
+                case NumEntry:
+                    width = kNumEntryWidth;
+                    height = kNumEntryHeight;
+                    // x position is the top left corner horizontal position of the box
+                    // and not the top left of the NumEntry label, so we have to do that
+                    x = (getWidth() - width)/2 + (juce::Font().getStringWidth(getName()) + kMargin)/2;
+                    y = (getHeight() - height)/2;
+                    break;
+                    
+                case Knob:
+                    // The knob name needs to be displayed, kNameHeight pixels
+                    height = width = juce::jmin(getHeight() - kNameHeight, kKnobHeight);
+                    x = (getWidth() - width)/2;
+                    // kNameHeight pixels for the knob name still
+                    y = juce::jmax((getHeight() - height)/2, kNameHeight);
+                    break;
+                    
+                default:
+                    assert(false);
+                    break;
+            }
+            
+            fSlider.setBounds(x, y, width, height);
+        }
+    
+};
+
+/** Intern class for button */
+class uiButton : public uiComponent, private juce::Button::Listener
+{
+    
+    private:
+        
+        juce::TextButton fButton;
+
+    public:
+        /**
+         * \brief   Constructor.
+         * \details Initialize all uiComponent variables and juce::TextButton parameters.
+         *
+         * \param   gui, zone, w, h, tooltip, label uiComponent variable.
+         */
+        uiButton(GUI* gui, FAUSTFLOAT* zone, FAUSTFLOAT w, FAUSTFLOAT h, juce::String label, juce::String tooltip) :  uiComponent(gui, zone, w, h, label)
+        {
+            int x = 0;
+            int y = (getHeight() - kButtonHeight)/2;
+
+            fButton.setButtonText(label);
+            fButton.setBounds(x, y, kButtonWidth, kButtonHeight);
+            fButton.addListener(this);
+            fButton.setTooltip(tooltip);
+            addAndMakeVisible(fButton);
+        }
+
+        /** 
+         * Has to be defined because its a pure virtual function of juce::Button::Listener, 
+         * which uiButton derives from. Control of user actions is done in buttonStateChanged.
+         * \see buttonStateChanged
+         */
+        void buttonClicked (juce::Button* button) override
+        {}
+
+        /** Indicate to the FAUST module when the button is pressed and released. */
+        void buttonStateChanged (juce::Button* button) override
+        {
+            if (button->isDown()) {
+                modifyZone(FAUSTFLOAT(1));
+            } else {
+                modifyZone(FAUSTFLOAT(0));
+            }
+        }
+        
+        void reflectZone() override
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+            if (v == FAUSTFLOAT(1)) {
+                fButton.triggerClick();
+            }
+        }
+
+        /** Set the good coordinates and size to the juce::TextButton widget whenever the layout size changes. */
+        virtual void resized() override
+        {
+            int x = kMargin;
+            int width = getWidth() - 2 * kMargin;
+            int height = juce::jmin(getHeight(), kButtonHeight);
+            int y = (getHeight()-height)/2;
+            fButton.setBounds(x, y, width, height);
+        }
+    
+};
+
+/** Intern class for checkButton */
+class uiCheckButton : public uiComponent, private juce::Button::Listener
+{
+    
+    private:
+        
+        juce::ToggleButton fCheckButton;
+
+    public:
+        /**
+         * \brief   Constructor.
+         * \details Initialize all uiComponent variables and juce::ToggleButton parameters.
+         *
+         * \param   gui, zone, w, h, label, tooltip  uiComponent variables.
+         */
+        uiCheckButton(GUI* gui, FAUSTFLOAT* zone, FAUSTFLOAT w, FAUSTFLOAT h, juce::String label, juce::String tooltip) : uiComponent(gui, zone, w, h, label)
+        {
+            int x = 0;
+            int y = (getHeight()-h)/2;
+            
+            fCheckButton.setButtonText(label);
+            fCheckButton.setBounds(x, y, w, h);
+            fCheckButton.addListener(this);
+            fCheckButton.setTooltip(tooltip);
+            addAndMakeVisible(fCheckButton);
+        }
+
+        /** Indicate to the FAUST module when the button is toggled or not. */
+        void buttonClicked(juce::Button* button) override
+        {
+            //std::cout << getName() << " : " << button->getToggleState() << std::endl;
+            modifyZone(button->getToggleState());
+        }
+
+        void reflectZone() override
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+            fCheckButton.triggerClick();
+        }
+
+        /** Set the good coordinates and size to the juce::ToggleButton widget, whenever the layout size changes. */
+        virtual void resized() override
+        {
+            fCheckButton.setBounds(getLocalBounds());
+        }
+    
+};
+
+/** Intern class for Menu */
+class uiMenu : public uiComponent, private juce::ComboBox::Listener
+{
+    
+    private:
+        
+        juce::ComboBox fComboBox;
+        std::vector<double> fValues;
+
+    public:
+        /**
+         * \brief   Constructor.
+         * \details Initialize the uiComponent and Menu specific variables, and the juce::ComboBox parameters.
+         *          Menu is considered as a slider in the FAUST logic, with a step of one. The first item
+         *          would be 0 on a slider, the second 1, etc. Each "slider value" is associated with a 
+         *          string.
+         *
+         * \param   gui, zone, w, h, tooltip, label     uiComponent variables.
+         * \param   cur                                 Current "slider value" associated with the current item selected.
+         * \param   low                                 Lowest value possible.
+         * \param   hi                                  Highest value possible.
+         * \param   mdescr                              Menu description. Contains the names of the items associated with their "value".
+         */
+        uiMenu(GUI* gui, FAUSTFLOAT* zone, juce::String label, FAUSTFLOAT w, FAUSTFLOAT h, FAUSTFLOAT cur, FAUSTFLOAT lo, FAUSTFLOAT hi, juce::String tooltip, const char* mdescr) : uiComponent(gui, zone, w, h, label)
+        {
+            //Init ComboBox parameters
+            fComboBox.setEditableText(false);
+            fComboBox.setJustificationType(juce::Justification::centred);
+            fComboBox.addListener(this);
+            addAndMakeVisible(fComboBox);
+
+            std::vector<std::string> names;
+            std::vector<double> values;
+
+            if (parseMenuList(mdescr, names, values)) {
+
+                int defaultitem = -1;
+                double mindelta = FLT_MAX;
+                int item = 1;
+
+                // Go through all the Menu's items.
+                for (int i = 0; i < names.size(); i++) {
+                    double v = values[i];
+                    if ((v >= lo) && (v <= hi)) {
+                        // It is a valid value : add corresponding menu item
+                        // item astrating at 1 because index 0 is reserved for a non-defined item.
+                        fComboBox.addItem(juce::String(names[i].c_str()), item++);
+                        fValues.push_back(v);
+
+                        // Check if this item is a good candidate to represent the current value
+                        double delta = fabs(cur-v);
+                        if (delta < mindelta) {
+                            mindelta = delta;
+                            defaultitem = fComboBox.getNumItems();
+                        }
+                    }
+                }
+                // check the best candidate to represent the current value
+                if (defaultitem > -1) {
+                    fComboBox.setSelectedItemIndex(defaultitem);
+                }
+            }
+
+            *fZone = cur;
+        }
+
+        /** Indicate to the FAUST module when the selected items is changed. */
+        void comboBoxChanged (juce::ComboBox* cb) override
+        {
+            //std::cout << getName( )<< " : " << cb->getSelectedId() - 1 << std::endl;
+            // -1 because of the starting item  at 1 at the initialization
+            modifyZone(fValues[cb->getSelectedId() - 1]);
+        }
+
+        virtual void reflectZone() override
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+
+            // search closest value
+            int defaultitem = -1;
+            double mindelta = FLT_MAX;
+
+            for (unsigned int i = 0; i < fValues.size(); i++) {
+                double delta = fabs(fValues[i]-v);
+                if (delta < mindelta) {
+                    mindelta = delta;
+                    defaultitem = i;
+                }
+            }
+            if (defaultitem > -1) {
+                fComboBox.setSelectedItemIndex(defaultitem);
+            }
+        }
+
+        /** Set the good coordinates and size to the juce::ComboBox widget whenever the layout get reiszed */
+        virtual void resized() override
+        {
+            fComboBox.setBounds(0, 0 + kMenuHeight/2, getWidth(), kMenuHeight/2);
+        }
+
+        /** Display the name of the Menu */
+        virtual void paint(juce::Graphics& g) override
+        {
+            g.setColour(juce::Colours::black);
+            g.drawText(getName(), getLocalBounds().withHeight(getHeight()/2), juce::Justification::centredTop);
+        }
+    
+};
+
+/** Intern class for RadioButton */
+class uiRadioButton : public uiComponent, private juce::Button::Listener
+{
+    
+    private:
+        
+        bool fIsVertical;
+        juce::OwnedArray<juce::ToggleButton> fButtons;
+        std::vector<double> fValues;
+
+    public:
+        /**
+         * \brief   Constructor.
+         * \details Initialize the uiComponent variables, and the RadioButton specific variables
+         *          and parameters. Works in a similar way to the Menu, because it is a special
+         *          kind of sliders in the faust logic. 
+         * \see     uiMenu
+         * 
+         * \param   gui, zone, tooltip, label   uiComponent variables.
+         * \param   w                           uiComponent variable and width of the RadioButton widget.
+         * \param   h                           uiComponent variable and height of the RadioButton widget.
+         * \param   cur                         Current "value" associated with the item selected.
+         * \param   low                         Lowest "value" possible.
+         * \param   hi                          Highest "value" possible.
+         * \param   vert                        True if vertical, false if horizontal.
+         * \param   names                       Contain the names of the different items.
+         * \param   values                      Contain the "values" of the different items.
+         * \param   fRadioGroupID               RadioButton being multiple CheckButton in JUCE,
+         *                                      we need an ID to know which are linked together.
+         */
+        uiRadioButton(GUI* gui, FAUSTFLOAT* zone, juce::String label, FAUSTFLOAT w, FAUSTFLOAT h, FAUSTFLOAT cur, FAUSTFLOAT lo, FAUSTFLOAT hi, bool vert, std::vector<std::string>& names, std::vector<double>& values, juce::String tooltip, int radioGroupID) : uiComponent(gui, zone, w, h, label), fIsVertical(vert)
+        {
+            juce::ToggleButton* defaultbutton = 0;
+            double mindelta = FLT_MAX;
+
+            for (int i = 0; i < names.size(); i++) {
+                double v = values[i];
+                if ((v >= lo) && (v <= hi)) {
+
+                    // It is a valid value included in slider's range
+                    juce::ToggleButton* tb = new juce::ToggleButton(names[i]);
+                    addAndMakeVisible(tb);
+                    tb->setRadioGroupId (radioGroupID);
+                    tb->addListener(this);
+                    tb->setTooltip(tooltip);
+                    fValues.push_back(v);
+                    fButtons.add(tb);
+      
+                    // Check if this item is a good candidate to represent the current value
+                    double delta = fabs(cur-v);
+                    if (delta < mindelta) {
+                        mindelta = delta;
+                        defaultbutton = tb;
+                    }
+                }
+            }
+            // check the best candidate to represent the current value
+            if (defaultbutton) {
+                defaultbutton->setToggleState (true, juce::dontSendNotification);
+            }
+        }
+     
+        virtual void reflectZone() override
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+
+            // select closest value
+            int defaultitem = -1;
+            double mindelta = FLT_MAX;
+
+            for (unsigned int i = 0; i < fValues.size(); i++) {
+                double delta = fabs(fValues[i]-v);
+                if (delta < mindelta) {
+                    mindelta = delta;
+                    defaultitem = i;
+                }
+            }
+            if (defaultitem > -1) {
+                fButtons.operator[](defaultitem)->setToggleState (true, juce::dontSendNotification);
+            }
+        }
+
+        /** Handle the placement of each juce::ToggleButton everytime the layout size is changed. */
+        virtual void resized() override
+        {
+            int width, height;
+            fIsVertical ? (height = (getHeight() - kNameHeight) / fButtons.size()) : (width = getWidth() / fButtons.size());
+
+            for (int i = 0; i < fButtons.size(); i++) {
+                if (fIsVertical) {
+                    fButtons.operator[](i)->setBounds(0, i * height + kNameHeight, getWidth(), height);
+                } else {
+                    // kNameHeight pixels offset for the title
+                    fButtons.operator[](i)->setBounds(i * width, kNameHeight, width, getHeight() - kNameHeight);
+                }
+            }
+        }
+        
+        /** Display the RadioButton name */
+        virtual void paint(juce::Graphics& g) override
+        {
+            g.setColour(juce::Colours::black);
+            g.drawText(getName(), getLocalBounds().withHeight(kNameHeight), juce::Justification::centredTop);
+        }
+
+        /** Check which button is checked, and give its "value" to the FAUST module */
+    void buttonClicked(juce::Button* button) override
+        {
+            juce::ToggleButton* checkButton = dynamic_cast<juce::ToggleButton*>(button);
+            //std::cout << getName() << " : " << fButtons.indexOf(checkButton) << std::endl;
+            modifyZone(fButtons.indexOf(checkButton));
+        }
+    
+};
+
+/**
+ * \brief   Intern class for VU-meter
+ * \details There is no JUCE widgets for VU-meter, so its fully designed in this class.
+ */
+class uiVUMeter : public uiComponent, public juce::SettableTooltipClient, public juce::Timer
+{
+    
+    private:
+    
+        FAUSTFLOAT fLevel;               // Current level of the VU-meter.
+        FAUSTFLOAT fMin, fMax;           // Linear range of the VU-meter.
+        FAUSTFLOAT fScaleMin, fScaleMax; // Range in dB if needed.
+        bool fDB;                        // True if it's a dB VU-meter, false otherwise.
+        VUMeterType fStyle;
+        juce::String fUnit;
+        juce::Label fLabel;               // Name of the VU-meter.
+    
+        bool isNameDisplayed()
+        {
+            return (!(getName().startsWith("0x")) && getName().isNotEmpty());
+        }
+        
+        /** Give the right coordinates and size to the text of Label depending on the VU-meter style */
+        void setLabelPos()
+        {
+            if (fStyle == VVUMeter) {
+                // -22 on the height because of the text box.
+                fLabel.setBounds((getWidth()-50)/2, getHeight()-22, 50, 20);
+            } else if (fStyle == HVUMeter) {
+                isNameDisplayed() ? fLabel.setBounds(63, (getHeight()-20)/2, 50, 20)
+                : fLabel.setBounds(3, (getHeight()-20)/2, 50, 20);
+            } else if (fStyle == NumDisplay) {
+                fLabel.setBounds((getWidth()-kNumDisplayWidth)/2,
+                                 (getHeight()-kNumDisplayHeight/2)/2,
+                                 kNumDisplayWidth,
+                                 kNumDisplayHeight/2);
+            }
+        }
+        
+        /** Contain all the initialization need for our Label */
+        void setupLabel(juce::String tooltip)
+        {
+            setLabelPos();
+            fLabel.setEditable(false, false, false);
+            fLabel.setJustificationType(juce::Justification::centred);
+            fLabel.setText(juce::String(*fZone) + " " + fUnit, juce::dontSendNotification);
+            fLabel.setTooltip(tooltip);
+            addAndMakeVisible(fLabel);
+        }
+        
+        /**
+         * \brief   Generic method to draw an horizontal VU-meter.
+         * \details Draw the background of the bargraph, and the TextBox box, without taking
+         *          care of the actual level of the VU-meter
+         * \see     drawHBargraphDB
+         * \see     drawHBargraphLin
+         *
+         * \param   g       JUCE graphics context, used to draw components or images.
+         * \param   width   Width of the VU-meter widget.
+         * \param   height  Height of the VU-meter widget.
+         * \param   level   Current level that needs to be displayed.
+         * \param   dB      True if it's a db level, false otherwise.
+         */
+        void drawHBargraph(juce::Graphics& g, int width, int height)
+        {
+            float x;
+            float y = (float)(getHeight()-height)/2;
+            if (isNameDisplayed()) {
+                x = 120;
+                width -= x;
+                // VUMeter Name
+                g.setColour(juce::Colours::black);
+                g.drawText(getName(), 0, y, 60, height, juce::Justification::centredRight);
+            } else {
+                x = 60;
+                width -= x;
+            }
+            
+            // VUMeter Background
+            g.setColour(juce::Colours::lightgrey);
+            g.fillRect(x, y, (float)width, (float)height);
+            g.setColour(juce::Colours::black);
+            g.fillRect(x+1.0f, y+1.0f, (float)width-2, (float)height-2);
+            
+            // Label Window
+            g.setColour(juce::Colours::darkgrey);
+            g.fillRect((int)x-58, (getHeight()-22)/2, 52, 22);
+            g.setColour(juce::Colours::white.withAlpha(0.8f));
+            g.fillRect((int)x-57, (getHeight()-20)/2, 50, 20);
+            
+            // Call the appropriate drawing method for the level.
+            fDB ? drawHBargraphDB (g, y, height) : drawHBargraphLin(g, x, y, width, height);
+        }
+        
+        /**
+         * Method in charge of drawing the level of a horizontal dB VU-meter.
+         *
+         * \param   g       JUCE graphics context, used to draw components or images.
+         * \param   y       y coordinate of the VU-meter.
+         * \param   height  Height of the VU-meter.
+         * \param   level   Current level of the VU-meter, in dB.
+         */
+        void drawHBargraphDB(juce::Graphics& g, int y, int height)
+        {
+            // Drawing Scale
+            g.setFont(9.0f);
+            g.setColour(juce::Colours::white);
+            for (int i = -10; i > fMin; i -= 10) {
+                paintScale(g, i);
+            }
+            for (int i = -6; i < fMax; i += 3)  {
+                paintScale(g, i);
+            }
+            
+            int alpha = 200;
+            FAUSTFLOAT dblevel = dB2Scale(fLevel);
+            
+            // We need to test here every color changing levels, to avoid to mix colors because of the alpha,
+            // and so to start the new color rectangle at the end of the previous one.
+            
+            // Drawing from the minimal range to the current level, or -10dB.
+            g.setColour(juce::Colour((juce::uint8)40, (juce::uint8)160, (juce::uint8)40, (juce::uint8)alpha));
+            g.fillRect(dB2x(fMin), y+1.0f, juce::jmin(dB2x(fLevel)-dB2x(fMin), dB2x(-10)-dB2x(fMin)), (float)height-2);
+            
+            // Drawing from -10dB to the current level, or -6dB.
+            if (dblevel > dB2Scale(-10)) {
+                g.setColour(juce::Colour((juce::uint8)160, (juce::uint8)220, (juce::uint8)20, (juce::uint8)alpha));
+                g.fillRect(dB2x(-10), y+1.0f, juce::jmin(dB2x(fLevel)-dB2x(-10), dB2x(-6)-dB2x(-10)), (float)height-2);
+            }
+            // Drawing from -6dB to the current level, or -3dB.
+            if (dblevel > dB2Scale(-6)) {
+                g.setColour(juce::Colour((juce::uint8)220, (juce::uint8)220, (juce::uint8)20, (juce::uint8)alpha));
+                g.fillRect(dB2x(-6), y+1.0f, juce::jmin(dB2x(fLevel)-dB2x(-6), dB2x(-3)-dB2x(-6)), (float)height-2);
+            }
+            // Drawing from -3dB to the current level, or 0dB.
+            if (dblevel > dB2Scale(-3)) {
+                g.setColour(juce::Colour((juce::uint8)240, (juce::uint8)160, (juce::uint8)20, (juce::uint8)alpha));
+                g.fillRect(dB2x(-3), y+1.0f, juce::jmin(dB2x(fLevel)-dB2x(-3), dB2x(0)-dB2x(-3)), (float)height-2);
+            }
+            // Drawing from 0dB to the current level, or the max range.
+            if (dblevel > dB2Scale(0)) {
+                g.setColour(juce::Colour((juce::uint8)240, (juce::uint8)0, (juce::uint8)20, (juce::uint8)alpha));
+                g.fillRect(dB2x(0), y+1.0f, juce::jmin(dB2x(fLevel)-dB2x(0), dB2x(fMax)-dB2x(0)), (float)height-2);
+            }
+        }
+        
+        /**
+         * Method in charge of drawing the level of a horizontal linear VU-meter.
+         *
+         * \param   g       JUCE graphics context, used to draw components or images.
+         * \param   x       x coordinate of the VU-meter.
+         * \param   y       y coordinate of the VU-meter.
+         * \param   height  Height of the VU-meter.
+         * \param   width   Width of the VU-meter.
+         * \param   level   Current level of the VU-meter, in linear logic.
+         */
+        void drawHBargraphLin(juce::Graphics& g, int x, int y, int width, int height)
+        {
+            int alpha = 200;
+            juce::Colour c = juce::Colour((juce::uint8)255, (juce::uint8)165, (juce::uint8)0, (juce::uint8)alpha);
+            
+            // Drawing from the minimal range to the current level, or 20% of the VU-meter
+            g.setColour(c.brighter());
+            g.fillRect(x+1.0f, y+1.0f, juce::jmin<float>(fLevel*(width-2), 0.2f*(width-2)), (float)height-2);
+            // Drawing from 20% of the VU-meter to the current level, or 90% of the VU-meter
+            if (fLevel > 0.2f) {
+                g.setColour(c);
+                g.fillRect(x+1.0f + 0.2f*(width-2), y+1.0f, juce::jmin<float>((fLevel-0.2f) * (width-2), (0.9f-0.2f) * (width-2)), (float)height-2);
+            }
+            // Drawing from 90% of the VU-meter to the current level, or the maximal range of the VU-meter
+            if (fLevel > 0.9f) {
+                g.setColour(c.darker());
+                g.fillRect(x+1.0f + 0.9f*(width-2), y+1.0f, juce::jmin<float>((fLevel-0.9f) * (width-2), (1.0f-0.9f) * (width-2)), (float)height-2);
+            }
+        }
+        /**
+         * \brief   Generic method to draw a vertical VU-meter.
+         * \details Draw the background of the bargraph, and the TextBox box, without taking
+         *          care of the actual level of the VU-meter
+         * \see     drawHBargraphDB
+         * \see     drawHBargraphLin
+         *
+         * \param   g       JUCE graphics context, used to draw components or images.
+         * \param   width   Width of the VU-meter widget.
+         * \param   height  Height of the VU-meter widget.
+         * \param   level   Current level that needs to be displayed.
+         * \param   dB      True if it's a db level, false otherwise.
+         */
+        void drawVBargraph(juce::Graphics& g, int width, int height)
+        {
+            float x = (float)(getWidth()-width)/2;
+            float y;
+            if (isNameDisplayed()) {
+                y = (float)getHeight()-height+15;
+                height -= 40;
+                // VUMeter Name
+                g.setColour(juce::Colours::black);
+                g.drawText(getName(), getLocalBounds(), juce::Justification::centredTop);
+            } else {
+                y = (float)getHeight()-height;
+                height -= 25;
+            }
+            
+            // VUMeter Background
+            g.setColour(juce::Colours::lightgrey);
+            g.fillRect(x, y, (float)width, (float)height);
+            g.setColour(juce::Colours::black);
+            g.fillRect(x+1.0f, y+1.0f, (float)width-2, (float)height-2);
+            
+            // Label window
+            g.setColour(juce::Colours::darkgrey);
+            g.fillRect(juce::jmax((getWidth()-50)/2, 0), getHeight()-23, juce::jmin(getWidth(), 50), 22);
+            g.setColour(juce::Colours::white.withAlpha(0.8f));
+            g.fillRect(juce::jmax((getWidth()-48)/2, 1), getHeight()-22, juce::jmin(getWidth()-2, 48), 20);
+            
+            fDB ? drawVBargraphDB (g, x, width) : drawVBargraphLin(g, x, width);
+        }
+        
+        /**
+         * Method in charge of drawing the level of a vertical dB VU-meter.
+         *
+         * \param   g       JUCE graphics context, used to draw components or images.
+         * \param   x       x coordinate of the VU-meter.
+         * \param   width   Width of the VU-meter.
+         * \param   level   Current level of the VU-meter, in dB.
+         */
+        void drawVBargraphDB(juce::Graphics& g, int x, int width)
+        {
+            // Drawing Scale
+            g.setFont(9.0f);
+            g.setColour(juce::Colours::white);
+            for (int i = -10; i > fMin; i -= 10) {
+                paintScale(g, i);
+            }
+            for (int i = -6; i < fMax; i += 3)  {
+                paintScale(g, i);
+            }
+            
+            int alpha = 200;
+            FAUSTFLOAT dblevel = dB2Scale(fLevel);
+            
+            // We need to test here every color changing levels, to avoid to mix colors because of the alpha,
+            // and so to start the new color rectangle at the end of the previous one.
+            
+            // Drawing from the minimal range to the current level, or -10dB.
+            g.setColour(juce::Colour((juce::uint8)40, (juce::uint8)160, (juce::uint8)40, (juce::uint8)alpha));
+            g.fillRect(x+1.0f, juce::jmax(dB2y(fLevel), dB2y(-10)), (float)width-2, dB2y(fMin)-juce::jmax(dB2y(fLevel), dB2y(-10)));
+            
+            // Drawing from -10dB to the current level, or -6dB.
+            if (dblevel > dB2Scale(-10)) {
+                g.setColour(juce::Colour((juce::uint8)160, (juce::uint8)220, (juce::uint8)20, (juce::uint8)alpha));
+                g.fillRect(x+1.0f, juce::jmax(dB2y(fLevel), dB2y(-6)), (float)width-2, dB2y(-10)-juce::jmax(dB2y(fLevel), dB2y(-6)));
+            }
+            // Drawing from -6dB to the current level, or -3dB.
+            if (dblevel > dB2Scale(-6)) {
+                g.setColour(juce::Colour((juce::uint8)220, (juce::uint8)220, (juce::uint8)20, (juce::uint8)alpha));
+                g.fillRect(x+1.0f, juce::jmax(dB2y(fLevel), dB2y(-3)), (float)width-2, dB2y(-6)-juce::jmax(dB2y(fLevel), dB2y(-3)));
+            }
+            // Drawing from -3dB to the current level, or 0dB.
+            if (dblevel > dB2Scale(-3)) {
+                g.setColour(juce::Colour((juce::uint8)240, (juce::uint8)160, (juce::uint8)20, (juce::uint8)alpha));
+                g.fillRect(x+1.0f, juce::jmax(dB2y(fLevel), dB2y(0)), (float)width-2, dB2y(-3)-juce::jmax(dB2y(fLevel), dB2y(0)));
+            }
+            // Drawing from 0dB to the current level, or the maximum range.
+            if (dblevel > dB2Scale(0)) {
+                g.setColour(juce::Colour((juce::uint8)240, (juce::uint8)0, (juce::uint8)20, (juce::uint8)alpha));
+                g.fillRect(x+1.0f, juce::jmax(dB2y(fLevel), dB2y(fMax)), (float)width-2, dB2y(0)-juce::jmax(dB2y(fLevel), dB2y(fMax)));
+            }
+        }
+        
+        /**
+         * Method in charge of drawing the level of a vertical linear VU-meter.
+         *
+         * \param   g       JUCE graphics context, used to draw components or images.
+         * \param   x       x coordinate of the VU-meter.
+         * \param   width   Width of the VU-meter.
+         * \param   level   Current level of the VU-meter, in linear logic.
+         */
+        void drawVBargraphLin(juce::Graphics& g, int x, int width)
+        {
+            int alpha = 200;
+            juce::Colour c = juce::Colour((juce::uint8)255, (juce::uint8)165, (juce::uint8)0, (juce::uint8)alpha);
+            
+            // Drawing from the minimal range to the current level, or 20% of the VU-meter.
+            g.setColour(c.brighter());
+            g.fillRect(x+1.0f, juce::jmax(lin2y(fLevel), lin2y(0.2)), (float)width-2, lin2y(fMin)-juce::jmax(lin2y(fLevel), lin2y(0.2)));
+            
+            // Drawing from 20% of the VU-meter to the current level, or 90% of the VU-meter.
+            if (fLevel > 0.2f) {
+                g.setColour(c);
+                g.fillRect(x+1.0f, juce::jmax(lin2y(fLevel), lin2y(0.9)), (float)width-2, lin2y(0.2)-juce::jmax(lin2y(fLevel), lin2y(0.9)));
+            }
+            
+            // Drawing from 90% of the VU-meter to the current level, or the maximum range.
+            if (fLevel > 0.9f) {
+                g.setColour(c.darker());
+                g.fillRect(x+1.0f, juce::jmax(lin2y(fLevel), lin2y(fMax)), (float)width-2, lin2y(0.9)-juce::jmax(lin2y(fLevel), lin2y(fMax)));
+            }
+        }
+        
+        /**
+         * Method in charge of drawing the LED VU-meter, dB or not.
+         *
+         * \param   g       JUCE graphics context, used to draw components or images.
+         * \param   width   Width of the LED.
+         * \param   height  Height of the LED.
+         * \param   level   Current level of the VU-meter, dB or not.
+         */
+        void drawLed(juce::Graphics& g, int width, int height)
+        {
+            float x = (float)(getWidth() - width)/2;
+            float y = (float)(getHeight() - height)/2;
+            g.setColour(juce::Colours::black);
+            g.fillEllipse(x, y, width, height);
+            
+            if (fDB) {
+                int alpha = 200;
+                FAUSTFLOAT dblevel = dB2Scale(fLevel);
+                
+                // Adjust the color depending on the current level
+                g.setColour(juce::Colour((juce::uint8)40, (juce::uint8)160, (juce::uint8)40, (juce::uint8)alpha));
+                if (dblevel > dB2Scale(-10)) {
+                    g.setColour(juce::Colour((juce::uint8)160, (juce::uint8)220, (juce::uint8)20, (juce::uint8)alpha));
+                }
+                if (dblevel > dB2Scale(-6)) {
+                    g.setColour(juce::Colour((juce::uint8)220, (juce::uint8)220, (juce::uint8)20, (juce::uint8)alpha));
+                }
+                if (dblevel > dB2Scale(-3)) {
+                    g.setColour(juce::Colour((juce::uint8)240, (juce::uint8)160, (juce::uint8)20, (juce::uint8)alpha));
+                }
+                if (dblevel > dB2Scale(0))  {
+                    g.setColour(juce::Colour((juce::uint8)240, (juce::uint8)0, (juce::uint8)20, (juce::uint8)alpha));
+                }
+                
+                g.fillEllipse(x+1, y+1, width-2, height-2);
+            } else {
+                // The alpha depend on the level, from 0 to 1
+                g.setColour(juce::Colours::red.withAlpha((float)fLevel));
+                g.fillEllipse(x+1, y+1, width-2, height-2);
+            }
+        }
+        
+        /**
+         * Method in charge of drawing the Numerical Display VU-meter, dB or not.
+         *
+         * \param   g       JUCE graphics context, used to draw components or images.
+         * \param   width   Width of the Numerical Display.
+         * \param   height  Height of the Numerical Display.
+         * \param   level   Current level of the VU-meter.
+         */
+        void drawNumDisplay(juce::Graphics& g, int width, int height)
+        {
+            // Centering it
+            int x = (getWidth()-width) / 2;
+            int y = (getHeight()-height) / 2;
+            
+            // Draw box.
+            g.setColour(juce::Colours::darkgrey);
+            g.fillRect(x, y, width, height);
+            g.setColour(juce::Colours::white.withAlpha(0.8f));
+            g.fillRect(x+1, y+1, width-2, height-2);
+            
+            // Text is handled by the setLabelPos() function
+        }
+        
+        /** Convert a dB level to a y coordinate, for easier draw methods. */
+        FAUSTFLOAT dB2y(FAUSTFLOAT dB)
+        {
+            FAUSTFLOAT s0 = fScaleMin;      // Minimal range.
+            FAUSTFLOAT s1 = fScaleMax;      // Maximum range.
+            FAUSTFLOAT sx = dB2Scale(dB);   // Current level.
+            
+            int h;
+            int treshold;   // Value depend if the name is displayed
+            
+            if (isNameDisplayed()) {
+                h = getHeight()-42; // 15 pixels for the VU-Meter name,
+                // 25 for the textBox, 2 pixels margin.
+                treshold = 16;      // 15 pixels for the VU-Meter name.
+            } else {
+                h = getHeight()-27; // 25 for the textBox, 2 pixels margin.
+                treshold = 1;       // 1 pixel margin.
+            }
+            
+            return (h - h*(s0-sx)/(s0-s1)) + treshold;
+        }
+        
+        /** Convert a linear level to a y coordinate, for easier draw methods. */
+        FAUSTFLOAT lin2y(FAUSTFLOAT level)
+        {
+            int h;
+            int treshold;
+            
+            if (isNameDisplayed()) {
+                h = getHeight()-42; // 15 pixels for the VU-Meter name,
+                // 25 for the textBox, 2 pixels margin.
+                treshold = 16;      // 15 pixels for the VU-Meter name.
+            } else {
+                h = getHeight()-27; // 25 for the textBox, 2 pixels margin.
+                treshold = 1;       // 1 pixel margin.
+            }
+            
+            return h * (1 - level) + treshold;
+        }
+        
+        /** Convert a dB level to a x coordinate, for easier draw methods. */
+        FAUSTFLOAT dB2x(FAUSTFLOAT dB)
+        {
+            FAUSTFLOAT s0 = fScaleMin;      // Minimal range.
+            FAUSTFLOAT s1 = fScaleMax;      // Maximal range.
+            FAUSTFLOAT sx = dB2Scale(dB);   // Current level.
+            
+            int w;
+            int treshold;
+            
+            if (isNameDisplayed()) {
+                w = getWidth()-122; // 60 pixels for the VU-Meter name,
+                // 60 for the TextBox, 2 pixels margin.
+                treshold = 121;     // 60 pixels for the VU-Meter name,
+                // 60 for the TextBox, and 1 pixel margin.
+            } else {
+                w = getWidth()-62;  // 60 pixels for the TextBox, 2 pixels margin.
+                treshold = 61;      // 60 pixels for the TextBox, 1 pixel margin.
+            }
+            
+            return treshold + w - w*(s1-sx)/(s1-s0);
+        }
+        
+        /** Write the different level included in the VU-Meter range. */
+        void paintScale(juce::Graphics& g, float num)
+        {
+            juce::Rectangle<int> r;
+            
+            if (fStyle == VVUMeter) {
+                r = juce::Rectangle<int>((getWidth()-(kVBargraphWidth/2))/2 + 1,  // Left side of the VU-Meter.
+                                         dB2y(num),                               // Vertically centred with 20 height.
+                                         (kVBargraphWidth/2)-2,                   // VU-Meter width with margin.
+                                         20);                                     // 20 height.
+                g.drawText(juce::String(num), r, juce::Justification::centredRight, false);
+            } else {
+                r = juce::Rectangle<int>(dB2x(num)-10,                            // Horizontally centred with 20 width.
+                                        (getHeight()-kHBargraphHeight/2)/2 + 1,  // Top side of the VU-Meter.
+                                        20,                                      // 20 width.
+                                        (kHBargraphHeight/2)-2);                 // VU-Meter height with margin
+                g.drawText(juce::String(num), r, juce::Justification::centredTop, false);
+            }
+        }
+        
+        /** Set the level, keep it in the range of the VU-Meter, and set the TextBox text. */
+        void setLevel()
+        {
+            FAUSTFLOAT rawLevel = *fZone;
+        #if JUCE_DEBUG
+            if (std::isnan(rawLevel)) {
+                std::cerr << "uiVUMeter: NAN\n";
+            }
+        #endif
+            if (fDB) {
+                fLevel = range(rawLevel);
+            } else {
+                fLevel = range((rawLevel-fMin)/(fMax-fMin));
+            }
+            fLabel.setText(juce::String(rawLevel) + " " + fUnit, juce::dontSendNotification);
+        }
+        
+        FAUSTFLOAT range(FAUSTFLOAT level) { return (level > fMax) ? fMax : ((level < fMin) ? fMin : level); }
+    
+    public:
+    
+        /**
+         * \brief   Constructor.
+         * \details Initialize the uiComponent variables and the VU-meter specific ones.
+         *
+         * \param   gui, zone, w, h, tooltip, label     uiComponent variables.
+         * \param   mini                                Minimal value of the VU-meter range.
+         * \param   maxi                                Maximal value of the VU-meter range.
+         * \param   unit                                Unit of the VU-meter (dB or not).
+         * \param   style                               Type of the VU-meter (see VUMeterType).
+         * \param   vert                                True if vertical, false if horizontal.
+         */
+        uiVUMeter (GUI* gui, FAUSTFLOAT* zone, FAUSTFLOAT w, FAUSTFLOAT h, juce::String label, FAUSTFLOAT mini, FAUSTFLOAT maxi, juce::String unit, juce::String tooltip, VUMeterType style, bool vert)
+            : uiComponent(gui, zone, w, h, label), fMin(mini), fMax(maxi), fStyle(style)
+        {
+            fLevel = 0;         // Initialization of the level
+            startTimer(50);     // Launch a timer that trigger a callback every 50ms
+            this->fUnit = unit;
+            fDB = (unit == "dB");
+            
+            if (fDB) {
+                // Conversion in dB of the range
+                fScaleMin = dB2Scale(fMin);
+                fScaleMax = dB2Scale(fMax);
+            }
+            setTooltip(tooltip);
+            
+            // No text editor for LEDs
+            if (fStyle != Led) {
+                setupLabel(tooltip);
+            }
+        }
+        
+        /** Method called by the timer every 50ms, to refresh the VU-meter if it needs to */
+        void timerCallback() override
+        {
+            if (isShowing()) {
+                //Force painting at the initialisation
+                bool forceRepaint = (fLevel == 0);
+                FAUSTFLOAT lastLevel = fLevel;   //t-1
+                setLevel(); //t
+                
+                // Following condition means that we're repainting our VUMeter only if
+                // there's one or more changing pixels between last state and this one,
+                // and if the curent level is included in the VUMeter range. It improves
+                // performances a lot in IDLE. It's the same for the other style of VUMeter
+                
+                if (fDB) {
+                    switch (fStyle) {
+                        case VVUMeter:
+                            if (((int)dB2y(lastLevel) != (int)dB2y(fLevel) && fLevel >= fMin && fLevel <= fMax) || forceRepaint) {
+                                repaint();
+                            }
+                            break;
+                        case HVUMeter:
+                            if (((int)dB2x(lastLevel) != (int)dB2x(fLevel) && fLevel >= fMin && fLevel <= fMax) || forceRepaint) {
+                                repaint();
+                            }
+                            break;
+                        case NumDisplay:
+                            if (((int)lastLevel != (int)fLevel && fLevel >= fMin && fLevel <= fMax) || forceRepaint) {
+                                repaint();
+                            }
+                            break;
+                        case Led:
+                            if ((dB2Scale(lastLevel) != dB2Scale(fLevel) && fLevel >= fMin && fLevel <= fMax) || forceRepaint) {
+                                repaint();
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                } else {
+                    switch (fStyle) {
+                        case VVUMeter:
+                            if (((int)lin2y(lastLevel) != (int)lin2y(fLevel) && fLevel >= fMin && fLevel <= fMax) || forceRepaint) {
+                                repaint();
+                            }
+                            break;
+                        case HVUMeter:
+                            if ((std::abs(lastLevel-fLevel) > 0.01 && fLevel >= fMin && fLevel <= fMax) || forceRepaint) {
+                                repaint();
+                            }
+                            break;
+                        case NumDisplay:
+                            if ((std::abs(lastLevel-fLevel) > 0.01 && fLevel >= fMin && fLevel <= fMax) || forceRepaint) {
+                                repaint();
+                            }
+                            break;
+                        case Led:
+                            if (((int)lastLevel != (int)fLevel && fLevel >= fMin && fLevel <= fMax) || forceRepaint) {
+                                repaint();
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            } else {
+                fLevel = 0;
+            }
+        }
+        
+        /**
+         * Call the appropriate drawing method according to the VU-meter style
+         * \see drawLed
+         * \see drawNumDisplay
+         * \see drawVBargraph
+         * \see drawHBargraph
+         */
+        void paint(juce::Graphics& g) override
+        {
+            switch (fStyle) {
+                case Led:
+                    drawLed(g, kLedWidth, kLedHeight);
+                    break;
+                case NumDisplay:
+                    drawNumDisplay(g, kNumDisplayWidth, kNumDisplayHeight/2);
+                    break;
+                case VVUMeter:
+                    drawVBargraph(g, kVBargraphWidth/2, getHeight());
+                    break;
+                case HVUMeter:
+                    drawHBargraph(g, getWidth(), kHBargraphHeight/2);
+                    break;
+                default:
+                    break;
+            }
+        }
+        
+        /** Set the Label position whenever the layout size changes. */
+        void resized() override
+        {
+            setLabelPos();
+        }
+        
+        void reflectZone() override
+        {
+            FAUSTFLOAT v = *fZone;
+            fCache = v;
+        }
+    
+};
+
+/** Intern class for tab widget */
+class uiTabBox : public uiBase, public juce::TabbedComponent
+{
+    
+public:
+    /**
+     * \brief   Constructor.
+     * \details Initalize the juce::TabbedComponent tabs to be at top, and the uiTabBox size at 0
+     */
+    uiTabBox(juce::String label):uiBase(),juce::TabbedComponent(juce::TabbedButtonBar::TabsAtTop)
+    {
+        setName(label);
+    }
+    
+    /**
+     * Initialize all his child ratios (1 uiBox per tabs), the LookAndFeel
+     * and the uiTabBox size to fit the biggest of its child.
+     */
+    void init(juce::Component* comp = nullptr) override
+    {
+        for (int i = 0; i < getNumTabs(); i++) {
+            Component* comp = getTabContentComponent(i);
+            uiBase* base_comp = dynamic_cast<uiBase*>(comp);
+            base_comp->init(comp);
+            
+            // The TabbedComponent size should be as big as its bigger child's dimension, done here
+            fTotalWidth = juce::jmax(fTotalWidth, base_comp->getTotalWidth());
+            fTotalHeight = juce::jmax(fTotalHeight, base_comp->getTotalHeight());
+        }
+        
+        fTotalHeight += 30;  // 30 height for the TabBar.
+    }
+    
+    void setRecommendedSize() override
+    {
+        for (int i = 0; i < getNumTabs(); i++) {
+            uiBase* comp = dynamic_cast<uiBase*>(getTabContentComponent(i));
+            comp->setRecommendedSize();
+            
+            // The TabbedComponent size should be as big as its bigger child's dimension, done here
+            fTotalWidth = juce::jmax(fTotalWidth, comp->getTotalWidth());
+            fTotalHeight = juce::jmax(fTotalHeight, comp->getTotalHeight());
+        }
+        
+        fTotalHeight += 30;  // 30 height for the TabBar
+    }
+    
+    void add(Component* comp) override
+    {
+        // Name of the component is moved in Tab (so removed from component)
+        juce::TabbedComponent::addTab(comp->getName(), juce::Colours::white, comp, true);
+        comp->setName("");
+    }
+    
+};
+
+/**
+ * \brief   Intern class for box widgets
+ * \details That's the class where the whole layout is calculated.
+ */
+class uiBox : public uiBase, public juce::Component
+{
+  
+    private:
+    
+        bool fIsVertical;
+    
+        bool isNameDisplayed()
+        {
+            return (!(getName().startsWith("0x")) && getName().isNotEmpty());
+        }
+    
+        /**
+         * \brief   Return the vertical dimension size for a child to be displayed in.
+         *
+         */
+        int getVSpaceToRemove()
+        {
+            // Checking if the name is displayed, to give to good amount space for child components
+            // kNameHeight pixels is the bix name, kMargin pixel per child components for the margins
+            if (isNameDisplayed()) {
+                return (getHeight() - kNameHeight - kMargin * getNumChildComponents());
+            } else {
+                return (getHeight() - kMargin * getNumChildComponents());
+            }
+        }
+    
+        /**
+         * \brief   Return the vertical dimension size for a child to be displayed in.
+         *
+         */
+        int getHSpaceToRemove()
+        {
+            // Don't need to check for an horizontal box, as it height doesn't matter
+            return (getWidth() - kMargin * getNumChildComponents());
+        }
+    
+    public:
+        /**
+         * \brief   Constructor.
+         * \details Initialize uiBase variables and uiBox specific ones.
+         *
+         * \param   vert        True if it's a vertical box, false otherwise.
+         * \param   boxName     Name of the uiBox.
+         */
+        uiBox(bool vert, juce::String boxName): uiBase(0,0), juce::Component(boxName), fIsVertical(vert)
+        {}
+    
+        /**
+         * \brief   Destructor.
+         * \details Delete all uiBox recusively, but not the uiComponent,
+         *          because it's handled by the uiItem FAUST objects.
+         */
+        virtual ~uiBox()
+        {
+            /*
+             Deleting boxes, from leaves to root:
+             - leaves (uiComponent) are deleted by the uiItem mechanism
+             - containers (uiBox and uiTabBox) have to be explicitly deleted
+             */
+            for (int i = getNumChildComponents()-1; i >= 0; i--) {
+                delete dynamic_cast<uiBox*>(getChildComponent(i));
+                delete dynamic_cast<uiTabBox*>(getChildComponent(i));
+            }
+        }
+
+        /**
+         * \brief   Initialization of the DisplayRect and Total size.
+         * \details Calculate the correct size for each box, depending on its child sizes.
+         */
+        void setRecommendedSize() override
+        {
+            // Initialized each time
+            fDisplayRectWidth = fDisplayRectHeight = 0;
+            
+            // Display rectangle size is the sum of a dimension on a side, and the max of the other one
+            // on the other side, depending on its orientation (horizontal/vertical).
+            // Using child's totalSize, because the display rectangle size need to be as big as
+            // all of its child components with their margins included.
+            for (int j = 0; j < getNumChildComponents(); j++) {
+                uiBase* base_comp = dynamic_cast<uiBase*>(getChildComponent(j));
+                if (fIsVertical) {
+                    fDisplayRectWidth = juce::jmax(fDisplayRectWidth, base_comp->getTotalWidth());
+                    fDisplayRectHeight += base_comp->getTotalHeight();
+                } else {
+                    fDisplayRectWidth += base_comp->getTotalWidth();
+                    fDisplayRectHeight = juce::jmax(fDisplayRectHeight, base_comp->getTotalHeight());
+                }
+            }
+            
+            fTotalHeight = fDisplayRectHeight;
+            fTotalWidth = fDisplayRectWidth;
+            
+            // Adding kMargin pixels of margins per child component on a dimension, and just kMargin on
+            // the other one, depending on its orientation
+            
+            if (fIsVertical) {
+                fTotalHeight += kMargin * getNumChildComponents();
+                fTotalWidth += kMargin;
+            } else {
+                fTotalWidth += kMargin * getNumChildComponents();
+                fTotalHeight += kMargin;
+            }
+         
+            // Adding kNameHeight pixels on its height to allow the name to be displayed
+            if (isNameDisplayed()) {
+                fTotalHeight += kNameHeight;
+            }
+        }
+
+        /** Initiate the current box ratio, and its child's ones recursively. */
+        void init(juce::Component* comp = nullptr) override
+        {
+            uiBase::init(this);
+            
+            // Going through the Component tree recursively
+            for (int i = 0; i < getNumChildComponents(); i++) {
+                Component* comp = getChildComponent(i);
+                uiBase* base_comp = dynamic_cast<uiBase*>(comp);
+                base_comp->init(comp);
+            }
+        }
+
+        /**
+         * \brief   Main layout function.
+         * \details Allow to place all uiBase child correctly according to their ratios
+         *          and the current box size.
+         *
+         * \param   displayRect    Absolute raw bounds of the current box (with margins
+         *                          and space for the title).
+         */
+        void resized() override
+        {
+            juce::Rectangle<int> displayRect = getBounds();
+            
+            // Deleting space for the box name if it needs to be shown
+            if (isNameDisplayed()) {
+                displayRect.removeFromTop(kNameHeight);
+            }
+            
+            // Putting the margins
+            displayRect.reduce(kMargin/2, kMargin/2);
+            
+            // Give child components an adapt size depending on its ratio and the current box size
+            for (int i = 0; i < getNumChildComponents(); i++) {
+                juce::Component* comp = getChildComponent(i);
+                uiBase* base_comp = dynamic_cast<uiBase*>(comp);
+                
+                if (fIsVertical) {
+                    int heightToRemove = getVSpaceToRemove() * base_comp->getVRatio();
+                    // Remove the space needed from the displayRect, and translate it to show the margins
+                    base_comp->setRelativeSize(comp, displayRect.removeFromTop(heightToRemove).translated(0, kMargin * i));
+                } else {
+                    int widthToRemove = getHSpaceToRemove() * base_comp->getHRatio();
+                    // Remove the space needed from the displayRect, and translate it to show the margins
+                    base_comp->setRelativeSize(comp, displayRect.removeFromLeft(widthToRemove).translated(kMargin * i, 0));
+                }
+            }
+        }
+
+        /** 
+         * Fill the uiBox bounds with a grey color, different shades depending on its order.
+         * Write the uiBox name if it needs to.
+         */
+        void paint(juce::Graphics& g) override
+        {
+            // Fill the box background in gray shades
+            g.setColour(juce::Colours::black.withAlpha(0.5f)); // 0.05, used until 2023-08-5, is not readable on the Mac
+            g.fillRect(getLocalBounds());
+
+            // Display the name if it's needed
+            if (isNameDisplayed()) {
+                g.setColour(juce::Colours::black);
+                g.drawText(getName(), getLocalBounds().withHeight(kNameHeight), juce::Justification::centred);
+            }
+        }
+        
+        void add(juce::Component* comp) override
+        {
+            addAndMakeVisible(comp);
+        }
+    
+};
+
+/** Class in charge of doing the glue between FAUST and JUCE */
+class JuceGUI : public GUI, public MetaDataUI, public juce::Component
+{
+    
+    private:
+    
+        std::stack<uiBase*> fBoxStack;
+        uiBase* fCurrentBox = nullptr;   // Current box used in buildUserInterface logic.
+        
+        int fRadioGroupID;               // In case of radio buttons.
+        std::unique_ptr<juce::LookAndFeel> fLaf = std::make_unique<juce::LookAndFeel_V4>();
+    
+        /** Add generic box to the user interface. */
+        void openBox(uiBase* box)
+        {
+            if (fCurrentBox) {
+                fCurrentBox->add(dynamic_cast<juce::Component*>(box));
+                fBoxStack.push(fCurrentBox);
+            }
+            fCurrentBox = box;
+        }
+     
+        /** Add a slider to the user interface. */
+        void addSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step, int kWidth, int kHeight, SliderType type)
+        {
+            if (isKnob(zone)) {
+                addKnob(label, zone, *zone, min, max, step);
+            } else if (isRadio(zone)) {
+                addRadioButtons(label, zone, *zone, min, max, step, fRadioDescription[zone].c_str(), false);
+            } else if (isMenu(zone)) {
+                addMenu(label, zone, *zone, min, max, step, fMenuDescription[zone].c_str());
+            } else {
+                fCurrentBox->add(new uiSlider(this, zone, kWidth, kHeight, *zone, min, max, step, juce::String(label), juce::String(fUnit[zone]), juce::String(fTooltip[zone]), getScale(zone), type));
+            }
+        }
+        
+        /** Add a radio buttons to the user interface. */
+        void addRadioButtons(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step, const char* mdescr, bool vert)
+        {
+            std::vector<std::string> names;
+            std::vector<double> values;
+            parseMenuList(mdescr, names, values); // Set names and values vectors
+            
+            // and not just n checkButtons :
+            // TODO : check currently unused checkButtonWidth...
+            int checkButtonWidth = 0;
+            for (int i = 0; i < names.size(); i++) {
+                // Checking the maximum of horizontal space needed to display the radio buttons
+                checkButtonWidth = juce::jmax(juce::Font().getStringWidth(juce::String(names[i])) + 15, checkButtonWidth);
+            }
+            
+            if (vert) {
+                fCurrentBox->add(new uiRadioButton(this, zone, juce::String(label), kCheckButtonWidth, names.size() * (kRadioButtonHeight - 25) + 25, *zone, min, max, true, names, values, juce::String(fTooltip[zone]), fRadioGroupID++));
+            } else {
+                fCurrentBox->add(new uiRadioButton(this, zone, juce::String(label), kCheckButtonWidth, kRadioButtonHeight, *zone, min, max, false, names, values, juce::String(fTooltip[zone]), fRadioGroupID++));
+            }
+        }
+        
+        /** Add a menu to the user interface. */
+        void addMenu(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step, const char* mdescr)
+        {
+            fCurrentBox->add(new uiMenu(this, zone, juce::String(label), kMenuWidth, kMenuHeight, *zone, min, max, juce::String(fTooltip[zone]), mdescr));
+        }
+        
+        /** Add a ciruclar slider to the user interface. */
+        void addKnob(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) {
+            fCurrentBox->add(new uiSlider(this, zone, kKnobWidth, kKnobHeight, *zone, min, max, step, juce::String(label), juce::String(fUnit[zone]), juce::String(fTooltip[zone]), getScale(zone), Knob));
+        }
+        
+        /** Add a bargraph to the user interface. */
+        void addBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max, int kWidth, int kHeight, VUMeterType type)
+        {
+            if (isLed(zone)) {
+                addLed(juce::String(label), zone, min, max);
+            } else if (isNumerical(zone)) {
+                addNumericalDisplay(juce::String(label), zone, min, max);
+            } else {
+                fCurrentBox->add(new uiVUMeter (this, zone, kWidth, kHeight, juce::String(label), min, max, juce::String(fUnit[zone]), juce::String(fTooltip[zone]), type, false));
+            }
+        }
+        
+    public:
+        /**
+         * \brief   Constructor, displaying the *current state* of all controller zones.
+         * \details Initialize the JuceGUI specific variables. 
+         */
+        JuceGUI():fRadioGroupID(1) // fRadioGroupID must start at 1
+        {
+            setLookAndFeel(fLaf.get());
+        }
+        
+        /**
+         * \brief   Destructor.
+         * \details Delete root box used in buildUserInterface logic.
+         */
+        virtual ~JuceGUI()
+        {
+            setLookAndFeel(nullptr);
+            delete fCurrentBox;
+        }
+
+        /** Return the size of the FAUST program */
+        juce::Rectangle<int> getSize()
+        {
+            // Mininum size in case of empty GUI
+            if (fCurrentBox) {
+                juce::Rectangle<int> res = fCurrentBox->getSize();
+                res.setSize(std::max<int>(1, res.getWidth()), std::max<int>(1, res.getHeight()));
+                return res;
+            } else {
+                return juce::Rectangle<int>(0, 0, 1, 1);
+            }
+        }
+
+        /** Initialize the uiTabBox component to be visible. */
+        virtual void openTabBox(const char* label) override
+        {
+            openBox(new uiTabBox(juce::String(label)));
+        }
+        
+        /** Add a new vertical box to the user interface. */
+        virtual void openVerticalBox(const char* label) override
+        {
+            openBox(new uiBox(true, juce::String(label)));
+        }
+
+        /** Add a new horizontal box to the user interface. */
+        virtual void openHorizontalBox(const char* label) override
+        {
+            openBox(new uiBox(false, juce::String(label)));
+        }
+
+        /** Close the current box. */
+        virtual void closeBox() override
+        {
+            fCurrentBox->setRecommendedSize();
+            
+            if (fBoxStack.empty()) {
+                // Add root box in JuceGUI component
+                addAndMakeVisible(dynamic_cast<juce::Component*>(fCurrentBox));
+                fCurrentBox->init();
+                // Force correct draw
+                resized();
+            } else {
+                fCurrentBox = fBoxStack.top();
+                fBoxStack.pop();
+            }
+        }
+     
+        /** Add an horizontal slider to the user interface. */
+        virtual void addHorizontalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) override
+        {
+            if (isHidden(zone)) return;
+            addSlider(label, zone, init, min, max, step, kHSliderWidth, kHSliderHeight, HSlider);
+        }
+        
+        /** Add a vertical slider to the user interface. */
+        virtual void addVerticalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) override
+        {
+            if (isHidden(zone)) return;
+            int newWidth = juce::jmax(juce::Font().getStringWidth(juce::String(label)), kVSliderWidth) + kMargin;
+            addSlider(label, zone, init, min, max, step, newWidth, kVSliderHeight, VSlider);
+        }
+        
+        /** Add a button to the user interface. */
+        virtual void addButton(const char* label, FAUSTFLOAT* zone) override
+        {
+            if (isHidden(zone)) return;
+            fCurrentBox->add(new uiButton(this, zone, kButtonWidth, kButtonHeight, juce::String(label), juce::String(fTooltip[zone])));
+        }
+        
+        /** Add a check button to the user interface. */
+        virtual void addCheckButton(const char* label, FAUSTFLOAT* zone) override
+        {
+            if (isHidden(zone)) return;
+            // newWidth is his text size, plus the check box size
+            int newWidth = juce::Font().getStringWidth(juce::String(label)) + kCheckButtonWidth;
+            fCurrentBox->add(new uiCheckButton(this, zone, newWidth, kCheckButtonHeight, juce::String(label), juce::String(fTooltip[zone])));
+        }
+        
+        /** Add a numerical entry to the user interface. */
+        virtual void addNumEntry(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) override
+        {
+            if (isHidden(zone)) return;
+            // kMargin pixels between the slider and his name
+            int newWidth = juce::Font().getStringWidth(juce::String(label)) + kNumEntryWidth + kMargin;
+            fCurrentBox->add(new uiSlider(this, zone, newWidth, kNumEntryHeight, *zone, min, max, step, juce::String(label), juce::String(fUnit[zone]), juce::String(fTooltip[zone]), getScale(zone), NumEntry));
+        }
+        
+        /** Add a vertical bargraph to the user interface. */
+        virtual void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) override
+        {
+            if (isHidden(zone)) return;
+            addBargraph(label, zone, min, max, kVBargraphWidth, kVBargraphHeight, VVUMeter);
+        }
+        
+        /** Add a vertical bargraph to the user interface. */
+        virtual void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) override
+        {
+            if (isHidden(zone)) return;
+            addBargraph(label, zone, min, max, kHBargraphWidth, kHBargraphHeight, HVUMeter);
+        }
+      
+        /** Add a LED to the user interface. */
+        void addLed(juce::String label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max)
+        {
+            fCurrentBox->add(new uiVUMeter(this, zone, kLedWidth, kLedHeight, label, min, max, juce::String(fUnit[zone]), juce::String(fTooltip[zone]), Led, false));
+        }
+        
+        /** Add a numerical display to the user interface. */
+        void addNumericalDisplay(juce::String label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) {
+            fCurrentBox->add(new uiVUMeter(this, zone, kNumDisplayWidth, kNumDisplayHeight, label, min, max, juce::String(fUnit[zone]), juce::String(fTooltip[zone]), NumDisplay, false));
+        }
+        
+        /** Declare a metadata. */
+        virtual void declare(FAUSTFLOAT* zone, const char* key, const char* value) override
+        {
+            MetaDataUI::declare(zone, key, value);
+        }
+
+        /** Resize its child to match the new bounds */
+        void resized() override
+        {
+            if (fCurrentBox) {
+                dynamic_cast<Component*>(fCurrentBox)->setBounds(getLocalBounds());
+            }
+        }
+    
+};
+
+#endif
+/**************************  END  JuceGUI.h **************************/