- save

Source/PluginEditor.cpp

@@ -3,6 +3,9 @@
 #include "Veno/Core/Config.h"
 #include "Veno/Utils/Logger.h"
 #include "Veno/Fonts/Fonts.h"
+#include "Veno/Utils.h"
+
+#define SIDEBAR_WIDTH 300
 
 VenoAudioProcessorEditor::VenoAudioProcessorEditor (VenoAudioProcessor& p)
         : AudioProcessorEditor(&p), processor(p)
@@ -10,29 +13,33 @@ VenoAudioProcessorEditor::VenoAudioProcessorEditor (VenoAudioProcessor& p)
     m_id = p.m_id;
     Config::getInstance()->registerEditor(this, m_id);
     LookAndFeel::setDefaultLookAndFeel(m_look);
-    waveform = std::make_unique<SidebarLCD> (m_id);
+    m_sidebar = std::make_unique<Sidebar>(m_id);
-    setSize (600, 400);
+    setSize(1200 * Config::getInstance()->getScale(), 700 * Config::getInstance()->getScale());
-    addAndMakeVisible (*waveform);
+    addAndMakeVisible(*m_sidebar);
 }
 
 VenoAudioProcessorEditor::~VenoAudioProcessorEditor ()
 {
     LookAndFeel::setDefaultLookAndFeel(nullptr);
-    waveform.reset (nullptr);
+    m_sidebar.reset(nullptr);
     delete m_look;
     Config::getInstance()->removeEditor(m_id);
 }
 
 void VenoAudioProcessorEditor::paint (Graphics& g)
 {
+    auto theme = Config::getInstance()->getCurrentTheme();
     g.setFont(*VenoFonts::getNormal());
-    g.fillAll (Colour (0, 0, 0));
+    g.fillAll(theme->getColour(ThemeColour::bg_two));
+    g.setColour(theme->getColour(ThemeColour::bg));
+    g.fillRect(0, 0, VeNo::Utils::getCalculatedWidth(SIDEBAR_WIDTH), getHeight());
+    g.setColour(theme->getColour(ThemeColour::accent));
 }
 
 void VenoAudioProcessorEditor::resized ()
 {
-    if (waveform != nullptr)
+    if (m_sidebar != nullptr)
     {
-        waveform->setBounds (0, 0, getWidth (), getHeight ());
+        m_sidebar->setBounds(0, 0, VeNo::Utils::getCalculatedWidth(SIDEBAR_WIDTH), getHeight());
     }
 }

Source/PluginEditor.h

@@ -3,7 +3,7 @@
 #include <JuceHeader.h>
 #include "PluginProcessor.h"
 #include "Veno/GUI/LookAndFeel/LookHandler.h"
-#include "Veno/GUI/Components/LCD/SidebarLCD.h"
+#include "Veno/GUI/GUIParts/Sidebar/Sidebar.h"
 
 class VenoAudioProcessorEditor : public AudioProcessorEditor
 {
@@ -16,6 +16,6 @@ private:
     VenoAudioProcessor& processor;
     std::string m_id = "";
     LookAndFeel_V4* m_look = new LookHandler();
-    std::unique_ptr<SidebarLCD> waveform;
+    std::unique_ptr<Sidebar> m_sidebar;
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (VenoAudioProcessorEditor)
 };

Source/PluginProcessor.h

@@ -3,57 +3,35 @@
 #include <JuceHeader.h>
 #include "Veno/VenoInstance.h"
 
-class VenoAudioProcessor : public AudioProcessor {
+class VenoAudioProcessor : public AudioProcessor
+{
 public:
     //==============================================================================
     VenoAudioProcessor ();
-
     ~VenoAudioProcessor ();
-
     void prepareToPlay (double sampleRate, int samplesPerBlock) override;
-
     void releaseResources () override;
-
 #ifndef JucePlugin_PreferredChannelConfigurations
-
     bool isBusesLayoutSupported (const BusesLayout& layouts) const override;
-
 #endif
-
     void processBlock (AudioBuffer<float>&, MidiBuffer&) override;
-
     AudioProcessorEditor* createEditor () override;
-
     bool hasEditor () const override;
-
     const String getName () const override;
-
     bool acceptsMidi () const override;
-
     bool producesMidi () const override;
-
     bool isMidiEffect () const override;
-
     double getTailLengthSeconds () const override;
-
     int getNumPrograms () override;
-
     int getCurrentProgram () override;
-
     void setCurrentProgram (int index) override;
-
     const String getProgramName (int index) override;
-
     void changeProgramName (int index, const String& newName) override;
-
     void getStateInformation (MemoryBlock& destData) override;
-
     void setStateInformation (const void* data, int sizeInBytes) override;
-
     // Variable to communicate with the GUI and the Processor
     std::string m_id = Uuid().toString().toStdString();
     std::shared_ptr<VenoInstance> instance;
-
 private:
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (VenoAudioProcessor)
 };

Source/Veno/Core/Config.cpp

@@ -4,6 +4,8 @@
 
 #include "Config.h"
 #include "../Fonts/Fonts.h"
+#include "../GUI/GUIParts/Sidebar/VenoLogo.h"
+#include "../Utils.h"
 
 std::shared_ptr<Config> Config::m_instance = nullptr;
 
@@ -14,6 +16,7 @@ Config::Config ()
     m_theme = std::make_shared<Theme>(m_config);
     m_theme->init();
     m_fps = m_config->getIntValue("waveform_fps", 60);
+    startTimer(5000);
 }
 
 void Config::saveAll ()
@@ -40,6 +43,7 @@ void Config::initConfig ()
     options.folderName = "veno";
     options.filenameSuffix = "xml";
     m_config = std::make_unique<PropertiesFile>(options);
+    m_scale = (float) m_config->getDoubleValue("scale", 1.0);
 }
 
 std::shared_ptr<Theme> Config::getCurrentTheme ()
@@ -47,9 +51,9 @@ std::shared_ptr<Theme> Config::getCurrentTheme ()
     return m_theme;
 }
 
-double Config::getScale ()
+double Config::getScale () const
 {
-    return 1;
+    return m_scale;
 }
 
 void Config::setColourForIndex (Colour* colour, ThemeColour index)
@@ -63,8 +67,13 @@ void Config::setColourForIndex (Colour* colour, ThemeColour index)
 Config::~Config ()
 {
     m_config->save();
+    m_config->setNeedsToBeSaved(false);
     m_theme.reset();
     m_config.reset();
+    m_lookHandler.reset();
+    stopTimer();
+    VenoFonts::destroyAll();
+    VenoLogo::deleteInstance();
 }
 
 //LEAK DETECTOR FIX!
@@ -78,7 +87,6 @@ void Config::removeEditor (const std::string& name)
     m_editors.erase(name);
     if (m_editors.empty())
     {
-        VenoFonts::destroyAll ();
         m_instance = nullptr;
     }
 }
@@ -100,3 +108,38 @@ int Config::getFps () const
 {
     return m_fps;
 }
+
+void Config::setScale (float value)
+{
+    value = VeNo::Utils::clamp(value, 0.5f, 2.5f);
+    m_scale = value;
+    m_config->setValue("scale", m_scale);
+    m_config->setNeedsToBeSaved(true);
+    for (auto& editor : m_editors)
+    {
+        editor.second->setSize(1200 * m_scale, 700 * m_scale);
+    }
+}
+
+void Config::timerCallback ()
+{
+    m_config->saveIfNeeded();
+}
+
+void Config::repaintAll ()
+{
+    for (auto& editor : m_editors)
+    {
+        if (editor.second->isShowing())
+        {
+            editor.second->repaint();
+        }
+    }
+}
+
+void Config::setFps (float value)
+{
+    m_fps = VeNo::Utils::clamp(value, 15, 90);
+    m_config->setValue("waveform_fps", m_fps);
+    m_config->setNeedsToBeSaved(true);
+}

Source/Veno/Core/Config.h

@@ -10,7 +10,7 @@
 #include "../GUI/Theme/Theme.h"
 #include <memory>
 
-class Config
+class Config : public Timer
 {
 private:
     std::shared_ptr<PropertiesFile> m_config = nullptr;
@@ -18,14 +18,16 @@ private:
     static std::shared_ptr<Config> m_instance;
     int m_currentLook = 0; //nah move the bitch logic from current to next
     std::unordered_map<std::string, AudioProcessorEditor*> m_editors;
-    int m_fps = 60;
+    std::shared_ptr<LookHandler> m_lookHandler;
 public:
+    int m_fps = 60;
+    float m_scale = 1.0f;
     static std::shared_ptr<Config> getInstance ();
     void saveAll ();
     int getCurrentLook ();
     void setColourForIndex (Colour* colour, ThemeColour index);
     std::shared_ptr<Theme> getCurrentTheme ();
-    double getScale ();
+    double getScale () const;
     // can be public but doesnt need!
     Config ();
     ~Config ();
@@ -33,6 +35,10 @@ public:
     void removeEditor (const std::string& name);
     int getEditorCount ();
     int getFps () const;
+    void setScale(float value);
+    void setFps(float value);
+    void timerCallback () override;
+    void repaintAll();
 protected:
     void initConfig ();
 };

Source/Veno/Core/VeNoState.cpp

@@ -0,0 +1,16 @@
+//
+// Created by versustune on 14.06.20.
+//
+
+#include "VeNoState.h"
+
+VeNoState::VeNoState (std::string pid)
+{
+    m_pid = pid;
+}
+
+VeNoState::~VeNoState ()
+{
+    delete configScreen;
+    configScreen = nullptr;
+}

Source/Veno/Core/VeNoState.h

@@ -0,0 +1,20 @@
+//
+// Created by versustune on 14.06.20.
+//
+
+#ifndef VENO_VENOSTATE_H
+#define VENO_VENOSTATE_H
+
+#include <string>
+#include "../GUI/GUIParts/ConfigScreen/VenoConfigScreen.h"
+
+class VeNoState
+{
+protected:
+    std::string m_pid = "";
+public:
+    VeNoState(std::string pid);
+    ~VeNoState();
+    VenoConfigScreen* configScreen = nullptr;
+};
+#endif //VENO_VENOSTATE_H

Source/Veno/GUI/Components/BaseComponent.cpp

@@ -3,6 +3,7 @@
 //
 
 #include "BaseComponent.h"
+#include "../../Utils.h"
 #include "../../Fonts/Fonts.h"
 #include <utility>
 
@@ -21,6 +22,7 @@ void BaseComponent::addLabel (const std::string& label_text, LabelPosition label
     m_enableLabel = true;
     m_label = std::make_shared<LabelComponent>(this, label_text);
     m_label->setPosition(labelPosition);
+    addAndMakeVisible(*m_label);
 }
 
 void BaseComponent::resized ()
@@ -30,11 +32,12 @@ void BaseComponent::resized ()
         LabelPosition position = m_label->getLabelPosition();
         if (position == LabelPosition::TOP)
         {
-            m_label->setBounds (0, 0, getWidth (), 15);
+            m_label->setBounds(0, 0, getWidth(), VeNo::Utils::getCalculatedHeight(15));
         }
         else if (position == LabelPosition::BOTTOM)
         {
-            m_label->setBounds (0, getHeight () - 20, getWidth (), 15);
+            auto height = VeNo::Utils::getCalculatedHeight(15);
+            m_label->setBounds(0, getHeight() - height, getWidth(), height);
         }
     }
 }

Source/Veno/GUI/Components/BaseComponent.h

@@ -19,7 +19,6 @@ private:
     std::string m_group;
     std::string m_name;
     bool m_enableLabel = false;
-    std::shared_ptr<LabelComponent> m_label;
 public:
     explicit BaseComponent (const std::string& processId);
     ~BaseComponent () override;
@@ -29,5 +28,6 @@ public:
     void paint (Graphics& g) override;
 protected:
     std::string m_processId;
+    std::shared_ptr<LabelComponent> m_label;
 };
 #endif //VENO_BASECOMPONENT_H

Source/Veno/GUI/Components/Config/VeNoColour.cpp

@@ -0,0 +1,65 @@
+//
+// Created by versustune on 14.06.20.
+//
+
+#include "VeNoColour.h"
+#include <utility>
+#include "../../../Core/Config.h"
+#include "../../../Utils.h"
+
+using ColourOption = ColourSelector::ColourSelectorOptions;
+VeNoColour::~VeNoColour ()
+{
+    BaseComponent::m_label.reset();
+    m_selector.reset();
+}
+
+VeNoColour::VeNoColour (const std::string& processId, ThemeColour index)
+        : BaseComponent(processId)
+{
+    m_index = index;
+    m_selector = std::make_unique<ColourSelector>(
+            ColourOption::showColourAtTop|ColourOption::editableColour|ColourOption::showColourspace);
+    m_selector->setCurrentColour(Config::getInstance()->getCurrentTheme()->getColour(index),
+                                 NotificationType::dontSendNotification);
+    m_selector->addChangeListener(this);
+    m_selector->setOpaque(false);
+    addAndMakeVisible(*m_selector);
+}
+
+void VeNoColour::setName (std::string name)
+{
+    m_name = std::move(name);
+    if (BaseComponent::m_label == nullptr)
+    {
+        BaseComponent::addLabel(m_name, LabelPosition::TOP);
+    }
+}
+
+void VeNoColour::changeListenerCallback (ChangeBroadcaster* source)
+{
+    auto selector = m_selector->getCurrentColour();
+    auto* colour = new Colour(selector.getRed(), selector.getGreen(), selector.getBlue(),
+                              1.0f);
+    Config::getInstance()->getCurrentTheme()->setColour(m_index, colour);
+    Config::getInstance()->repaintAll();
+}
+
+void VeNoColour::resized ()
+{
+    auto h = VeNo::Utils::getCalculatedHeight(30);
+    if (BaseComponent::m_label != nullptr)
+    {
+        BaseComponent::m_label->setBounds(0, 0, getWidth(), h);
+    }
+    if (m_selector != nullptr)
+    {
+        m_selector->setBounds(0, h, getWidth(), getHeight() - h);
+    }
+}
+
+void VeNoColour::paint (Graphics& g)
+{
+    g.setColour(Colours::white);
+    BaseComponent::paint(g);
+}

Source/Veno/GUI/Components/Config/VeNoColour.h

@@ -0,0 +1,27 @@
+//
+// Created by versustune on 14.06.20.
+//
+
+#ifndef VENO_VENOCOLOUR_H
+#define VENO_VENOCOLOUR_H
+
+#include "JuceHeader.h"
+#include "../BaseComponent.h"
+#include "../../Theme/Theme.h"
+
+class VeNoColour : public BaseComponent, ChangeListener
+{
+private:
+    ThemeColour m_index;
+    std::unique_ptr<ColourSelector> m_selector;
+    std::string m_name;
+public:
+    explicit VeNoColour (const std::string& processId, ThemeColour index);
+    ~VeNoColour () override;
+    void setName(std::string name);
+    void resized () override;
+    void paint (Graphics& g) override;
+private:
+    void changeListenerCallback (ChangeBroadcaster* source) override;
+};
+#endif //VENO_VENOCOLOUR_H

Source/Veno/GUI/Components/Config/VenoConfigButton.cpp

@@ -0,0 +1,34 @@
+//
+// Created by versustune on 14.06.20.
+//
+
+#include "VenoConfigButton.h"
+#include "../../../Core/Config.h"
+#include "../../../Utils.h"
+#include "../../../VenoInstance.h"
+#include "../../../Utils/Logger.h"
+
+VenoConfigButton::VenoConfigButton (const std::string& processId) : BaseComponent(processId)
+{
+    setMouseCursor(MouseCursor::PointingHandCursor);
+}
+
+void VenoConfigButton::paint (Graphics& g)
+{
+    auto theme = Config::getInstance()->getCurrentTheme();
+    VeNo::Utils::setFontSize(16.0f, g);
+    g.setColour(theme->getColour(ThemeColour::accent));
+    g.drawRect(0, 0, getWidth(), getHeight());
+    g.drawFittedText("Config", 0, 0, getWidth(), getHeight(), Justification::centred, 1, 1);
+}
+
+void VenoConfigButton::mouseDown (const MouseEvent& event)
+{
+    // open Window on click :)
+    auto state = VenoInstance::getInstance(m_processId)->state;
+    if (state->configScreen != nullptr)
+    {
+        return;
+    }
+    state->configScreen = new VenoConfigScreen(m_processId);
+}

Source/Veno/GUI/Components/Config/VenoConfigButton.h

@@ -0,0 +1,21 @@
+//
+// Created by versustune on 14.06.20.
+//
+
+#ifndef VENO_VENOCONFIGBUTTON_H
+#define VENO_VENOCONFIGBUTTON_H
+
+#include "JuceHeader.h"
+#include "../BaseComponent.h"
+
+class VenoConfigButton : public BaseComponent
+{
+public:
+    VenoConfigButton (const std::string& processId);
+    ~VenoConfigButton() = default;
+    void paint (Graphics& g) override;
+    void mouseDown (const MouseEvent& event) override;
+private:
+
+};
+#endif //VENO_VENOCONFIGBUTTON_H

Source/Veno/GUI/Components/Config/VenoPreColours.cpp

@@ -0,0 +1,84 @@
+//
+// Created by versustune on 14.06.20.
+//
+
+#include "VenoPreColours.h"
+#include "../../../Core/Config.h"
+
+VenoPreColours::VenoPreColours (const std::string& processId) : BaseComponent(processId)
+{
+    initSliders();
+    initButtons();
+}
+
+VenoPreColours::~VenoPreColours ()
+{
+    m_scaleSlider.reset();
+    m_fpsSlider.reset();
+    for (int i = 0; i < 4; ++i)
+    {
+        m_pre[i].reset();
+    }
+}
+
+void VenoPreColours::initSliders ()
+{
+    m_fpsSlider = std::make_shared<Slider>();
+    m_fpsSlider->setRange(15, 90, 1);
+    m_fpsSlider->setValue(Config::getInstance()->getFps());
+    m_fpsSlider->setSliderStyle(Slider::SliderStyle::LinearHorizontal);
+    m_fpsSlider->setTooltip("FPS");
+    m_scaleSlider = std::make_shared<Slider>();
+    m_scaleSlider->setRange(0.5f, 2.5f, 0.1);
+    m_scaleSlider->setValue(Config::getInstance()->getScale());
+    m_scaleSlider->setSliderStyle(Slider::SliderStyle::LinearHorizontal);
+    m_scaleSlider->setTooltip("Scale");
+    m_scaleSlider->addListener(this);
+    m_fpsSlider->addListener(this);
+    addAndMakeVisible(*m_fpsSlider);
+    addAndMakeVisible(*m_scaleSlider);
+}
+
+void VenoPreColours::sliderValueChanged (Slider* slider)
+{
+    if (slider == m_fpsSlider.get())
+    {
+        Config::getInstance()->setFps(slider->getValue());
+    }
+    if (slider == m_scaleSlider.get())
+    {
+        Config::getInstance()->setScale(slider->getValue());
+    }
+}
+
+void VenoPreColours::initButtons ()
+{
+    //4
+    m_pre.resize(4);
+    for (int i = 0; i < 4; ++i)
+    {
+        m_pre[i] = std::make_unique<TextButton>(m_names[i]);
+        m_pre[i]->addListener(this);
+        addAndMakeVisible(m_pre[i].get());
+    }
+}
+
+void VenoPreColours::buttonClicked (Button* button)
+{
+    auto text = button->getButtonText().toStdString();
+    Config::getInstance()->getCurrentTheme()->setDefault(text);
+}
+
+void VenoPreColours::resized ()
+{
+    auto bounds = Rectangle<int>();
+    bounds.setBounds(0,0,getWidth(), getHeight()-100);
+    auto bWidth = (getWidth()-80) / 4;
+    for (int i = 0; i < 4 ; ++i)
+    {
+        m_pre[i]->setBounds((bWidth * i) + 40, 110, bWidth, 50);
+    }
+    // set slider and button position
+    m_fpsSlider->setBounds(20, 0, getWidth()-40, 50);
+    m_scaleSlider->setBounds(20, 50, getWidth()-40, 50);
+}

Source/Veno/GUI/Components/Config/VenoPreColours.h

@@ -0,0 +1,30 @@
+//
+// Created by versustune on 14.06.20.
+//
+
+#ifndef VENO_VENOPRECOLOURS_H
+#define VENO_VENOPRECOLOURS_H
+
+#include "JuceHeader.h"
+#include "../../Components/BaseComponent.h"
+
+class VenoPreColours : public BaseComponent, public Slider::Listener, Button::Listener
+{
+public:
+    VenoPreColours (const std::string& processId);
+    ~VenoPreColours();
+    void initSliders();
+    void initButtons();
+    void sliderValueChanged (Slider* slider) override;
+    void resized () override;
+private:
+    void buttonClicked (Button* button) override;
+protected:
+    std::shared_ptr<Slider> m_fpsSlider;
+    std::shared_ptr<Slider> m_scaleSlider;
+    std::vector<std::unique_ptr<TextButton>> m_pre;
+    std::string m_names[4]{
+            "LED", "Blood", "Orange Dream", "Ocean"
+    };
+};
+#endif //VENO_VENOPRECOLOURS_H

Source/Veno/GUI/Components/LCD/Waveforms.cpp

@@ -11,19 +11,16 @@
 
 Waveforms::Waveforms (const std::string& processId) : BaseComponent(processId)
 {
+    setMouseCursor(MouseCursor::PointingHandCursor);
     m_context.setOpenGLVersionRequired(OpenGLContext::OpenGLVersion::openGL3_2);
     m_context.setRenderer(this);
     m_context.setContinuousRepainting(false);
     m_context.setComponentPaintingEnabled(true);
     m_context.attachTo(*this);
-    auto fps = Config::getInstance ()->getFps ();
+    setFps();
-    startTimerHz (Config::getInstance ()->getFps ());
     std::srand(unsigned(time(nullptr)));
     pickRandomText = (std::rand() % RANDOM_TEXT_COUNT);
     m_ticks = 0;
-    // is something that
-    m_time_needed = roundToInt (4000 / (1000 / fps));
-    m_time_needed_startup = roundToInt (1000 / (1000 / fps));
 }
 
 Waveforms::~Waveforms ()
@@ -82,11 +79,6 @@ void Waveforms::renderOpenGL ()
     }
 }
 
-void Waveforms::handleAsyncUpdate ()
-{
-
-}
-
 void Waveforms::compileOpenGLShaderProgram ()
 {
     std::unique_ptr<OpenGLShaderProgram> shaderProgramAttempt
@@ -130,6 +122,7 @@ void Waveforms::timerCallback ()
             m_context.triggerRepaint();
         }
     }
+    setFps();
 }
 
 void Waveforms::drawWaveTable ()
@@ -163,8 +156,7 @@ void Waveforms::drawPeakMeter ()
     auto instance = VenoInstance::getInstance(BaseComponent::m_processId);
     instance->audioBuffer->calcPeak();
     // draw peak signal
-    auto leftChannel = jmap (Decibels::gainToDecibels (instance->audioBuffer->leftPeak, -80.0f), -80.0f, 6.0f, -1.0f,
+    auto leftChannel = getdBForChannel(instance->audioBuffer->leftPeak);
-                             1.0f);
     selectColourByPeak(leftChannel);
     glBegin(GL_TRIANGLES);
     glVertex2f(-0.9f, leftChannel);
@@ -174,8 +166,7 @@ void Waveforms::drawPeakMeter ()
     glVertex2f(-0.01f, leftChannel);
     glVertex2f(-0.01f, -1.0f);
     glEnd();
-    auto rightChannel = jmap (Decibels::gainToDecibels (instance->audioBuffer->rightPeak, -80.0f), -80.0f, 6.0f, -1.0f,
+    auto rightChannel = getdBForChannel(instance->audioBuffer->rightPeak);
-                              1.0f);
     selectColourByPeak(rightChannel);
     glBegin(GL_TRIANGLES);
     glVertex2f(0.9f, rightChannel);
@@ -265,14 +256,33 @@ void Waveforms::selectColourByPeak (float value)
         return;
     }
     auto color = theme->getColour(ThemeColour::lcd);
-    if (value > 0.8 && value < 0.9)
-    {
-        color = theme->getColour (ThemeColour::warning);
-    }
     if (value > 0.9)
     {
         color = theme->getColour(ThemeColour::clip);
     }
+    else if (value > 0.8)
+    {
+        color = theme->getColour(ThemeColour::warning);
+    }
     shaderProgram->setUniform("color", color.getFloatRed(), color.getFloatGreen(), color.getFloatBlue(),
                               color.getFloatAlpha());
 }
+
+float Waveforms::getdBForChannel (float value)
+{
+    float v = VeNo::Utils::clamp(Decibels::gainToDecibels(value, -60.0f), -60.0f, 6.0f);
+    return jmap(v, -60.0f, 6.0f, -1.0f,
+                1.0f);
+}
+
+void Waveforms::setFps ()
+{
+    if(m_currentFps != Config::getInstance()->getFps()) {
+        m_currentFps = Config::getInstance()->getFps();
+        // is something that
+        m_time_needed = roundToInt(4000 / (1000 / m_currentFps));
+        m_time_needed_startup = roundToInt(1000 / (1000 / m_currentFps));
+        stopTimer();
+        startTimer(m_currentFps);
+    }
+}

Source/Veno/GUI/Components/LCD/Waveforms.h

@@ -12,7 +12,6 @@
 // opengl context :D
 class Waveforms : public BaseComponent,
                   private OpenGLRenderer,
-                  private AsyncUpdater,
                   private Timer
 {
 protected:
@@ -34,7 +33,6 @@ public:
     void newOpenGLContextCreated () override;
     void openGLContextClosing () override;
     void renderOpenGL () override;
-    void handleAsyncUpdate () override;
     void mouseDown (const MouseEvent& e) override;
     void mouseDrag (const MouseEvent& e) override;
     void paint (Graphics& g) override;
@@ -51,7 +49,10 @@ private:
     void drawWelcome (Graphics& g, int w, int h, int x, int y);
     void compileOpenGLShaderProgram ();
     void selectColourByPeak (float value);
+    float getdBForChannel (float value);
+    void setFps();
     OpenGLContext m_context;
     std::unique_ptr<OpenGLShaderProgram> shaderProgram;
+    int m_currentFps = 0;
 };
 #endif //VENO_WAVEFORMS_H

Source/Veno/GUI/Components/LabelComponent.cpp

@@ -9,6 +9,7 @@ LabelComponent::LabelComponent (Component* parent, std::string name)
     m_text = name;
     m_parent = parent;
     m_label = std::make_shared<Label>(m_parent->getName(), name);
+    addAndMakeVisible(*m_label);
 }
 
 LabelComponent::~LabelComponent ()

Source/Veno/GUI/GUIParts/ConfigScreen/ConfigComponent.cpp

@@ -0,0 +1,77 @@
+//
+// Created by versustune on 14.06.20.
+//
+
+#include "ConfigComponent.h"
+#include <utility>
+
+ConfigComponent::ConfigComponent (std::string pid)
+{
+    m_pid = std::move(pid);
+    m_colors.resize(8);
+    auto theme = Config::getInstance()->getCurrentTheme();
+    for (int i = 0; i < 8; i++)
+    {
+        m_colors[i] = std::make_unique<VeNoColour>(pid, getColorForId(i));
+        m_colors[i]->setName(m_names[i]);
+        addAndMakeVisible(m_colors[i].get());
+    }
+    m_preColours = std::make_unique<VenoPreColours>(pid);
+    addAndMakeVisible(*m_preColours);
+    flexBox.flexDirection = FlexBox::Direction::row;
+    flexBox.justifyContent = FlexBox::JustifyContent::flexStart;
+    flexBox.flexWrap = FlexBox::Wrap::wrap;
+    auto w = 200;
+    auto h = 100;
+    for (auto& color : m_colors)
+    {
+        auto item = FlexItem(w, h, *color);
+        item.margin = FlexItem::Margin(5, 5, 5, 5);
+        flexBox.items.add(item);
+    }
+}
+
+ConfigComponent::~ConfigComponent ()
+{
+    for (auto& color : m_colors)
+    {
+        color.reset();
+    }
+    m_colors.clear();
+}
+
+ThemeColour ConfigComponent::getColorForId (int id)
+{
+    switch (id)
+    {
+        default:
+            return ThemeColour::bg;
+        case 1:
+            return ThemeColour::bg_two;
+        case 2:
+            return ThemeColour::accent;
+        case 3:
+            return ThemeColour::accent_two;
+        case 4:
+            return ThemeColour::warning;
+        case 5:
+            return ThemeColour::clip;
+        case 6:
+            return ThemeColour::lcd_bg;
+        case 7:
+            return ThemeColour::lcd;
+    }
+}
+
+void ConfigComponent::paint (Graphics& g)
+{
+    g.fillAll(Colours::black);
+}
+
+void ConfigComponent::resized ()
+{
+    auto bounds = Rectangle<int>();
+    bounds.setBounds(0,0,getWidth(), getHeight()-200);
+    flexBox.performLayout(bounds);
+    m_preColours->setBounds(0, getHeight() - 200, getWidth(), 200);
+}

Source/Veno/GUI/GUIParts/ConfigScreen/ConfigComponent.h

@@ -0,0 +1,30 @@
+//
+// Created by versustune on 14.06.20.
+//
+
+#ifndef VENO_CONFIGCOMPONENT_H
+#define VENO_CONFIGCOMPONENT_H
+
+#include "JuceHeader.h"
+#include "../../../Core/Config.h"
+#include "../../Components/Config/VeNoColour.h"
+#include "../../Components/Config/VenoPreColours.h"
+
+class ConfigComponent : public Component
+{
+public:
+    explicit ConfigComponent(std::string pid);
+    ~ConfigComponent() override;
+    void paint (Graphics& g) override;
+    void resized () override;
+protected:
+    static ThemeColour getColorForId(int id);
+    std::string m_pid;
+    std::string m_names[8]{
+            "Background", "BackgroundTwo", "Accent", "Accent Two", "Warning", "Clip", "LCD Background", "LCD"
+    };
+    std::vector<std::unique_ptr<VeNoColour>> m_colors;
+    std::unique_ptr<VenoPreColours> m_preColours;
+    FlexBox flexBox;
+};
+#endif //VENO_CONFIGCOMPONENT_H

Source/Veno/GUI/GUIParts/ConfigScreen/VenoConfigScreen.cpp

@@ -0,0 +1,49 @@
+//
+// Created by versustune on 14.06.20.
+//
+
+#include "VenoConfigScreen.h"
+#include "../../../VenoInstance.h"
+
+VenoConfigScreen::VenoConfigScreen (const std::string& pid) : DocumentWindow("VeNo Config", Colours::black,
+                                                                             DocumentWindow::closeButton, true)
+{
+    m_pid = pid;
+    auto w = 840;
+    auto h = 800;
+    component = std::make_shared<ConfigComponent>(pid);
+    component->setSize(w, h);
+    m_lookHandler = std::make_unique<LookHandler>();
+    component->setLookAndFeel(m_lookHandler->getLook());
+    centreWithSize(w, h);
+    setAlwaysOnTop(true);
+    setContentOwned(component.get(), false);
+    setResizable(false, false);
+    setUsingNativeTitleBar(true);
+    setVisible(true);
+}
+
+VenoConfigScreen::~VenoConfigScreen ()
+{
+    component->setLookAndFeel(nullptr);
+    m_lookHandler.reset();
+    component.reset();
+}
+
+void VenoConfigScreen::closeButtonPressed ()
+{
+    auto state = VenoInstance::getInstance(m_pid)->state;
+    if (state != nullptr && state->configScreen != nullptr)
+    {
+        delete state->configScreen;
+        state->configScreen = nullptr;
+    }
+}
+
+void VenoConfigScreen::paint (Graphics& graphics)
+{
+}
+
+void VenoConfigScreen::resized ()
+{
+}

Source/Veno/GUI/GUIParts/ConfigScreen/VenoConfigScreen.h

@@ -0,0 +1,28 @@
+//
+// Created by versustune on 14.06.20.
+//
+
+#ifndef VENO_VENOCONFIGSCREEN_H
+#define VENO_VENOCONFIGSCREEN_H
+
+#include "JuceHeader.h"
+#include "../../../Core/Config.h"
+#include "../../Components/Config/VeNoColour.h"
+#include "ConfigComponent.h"
+
+class VenoConfigScreen : public DocumentWindow
+{
+public:
+    explicit VenoConfigScreen (const std::string& pid);
+    ~VenoConfigScreen () override;
+    void closeButtonPressed () override;
+    void paint (Graphics& graphics) override;
+    void resized () override;
+private:
+    std::string m_pid;
+    std::shared_ptr<ConfigComponent> component;
+    std::unique_ptr<LookHandler> m_lookHandler;
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (VenoConfigScreen)
+
+};
+#endif //VENO_VENOCONFIGSCREEN_H

Source/Veno/GUI/GUIParts/Sidebar/Sidebar.cpp

@@ -3,3 +3,48 @@
 //
 
 #include "Sidebar.h"
+#include "VenoLogo.h"
+#include "../../../Utils.h"
+
+Sidebar::Sidebar (const std::string& processId) : BaseComponent(processId)
+{
+    m_lcd = std::make_unique<SidebarLCD>(processId);
+    m_configButton = std::make_unique<VenoConfigButton>(processId);
+    addAndMakeVisible(*m_lcd);
+    addAndMakeVisible(*m_configButton);
+}
+
+Sidebar::~Sidebar ()
+{
+    m_lcd.reset(nullptr);
+    m_configButton.reset(nullptr);
+}
+
+void Sidebar::resized ()
+{
+    if (m_lcd != nullptr)
+    {
+        m_lcd->setBounds(0, (getWidth() / 5) + 30, getWidth(), VeNo::Utils::getCalculatedHeight(175));
+    }
+    if (m_configButton != nullptr)
+    {
+        auto height = VeNo::Utils::getCalculatedHeight(30);
+        auto margin = VeNo::Utils::getCalculatedWidth(10);
+        m_configButton->setBounds(margin, getHeight()-height-margin, (getWidth()/2)-(margin*2), height);
+    }
+}
+
+void Sidebar::paint (Graphics& g)
+{
+    auto logo = VenoLogo::getInstance()->getLogo();
+    if (logo.isValid())
+    {
+        float height = getWidth() / 5;
+        g.drawImage(logo, 0, 15, getWidth(), height, 0, 0, 500, 100);
+    }
+    else
+    {
+        g.setFont(getWidth() / 4);
+        g.drawSingleLineText("VeNo", 0, 25);
+    }
+}

Source/Veno/GUI/GUIParts/Sidebar/Sidebar.h

@@ -7,13 +7,21 @@
 
 #include "JuceHeader.h"
 #include "../../Components/BaseComponent.h"
+#include "../../Components/LCD/SidebarLCD.h"
+#include "SidebarMixer.h"
+#include "../../Components/Config/VenoConfigButton.h"
 
 class Sidebar : public BaseComponent
 {
 private:
 public:
-    Sidebar ();
+    Sidebar (const std::string& processId);
-    ~Sidebar ();
+    ~Sidebar () override;
+    void resized () override;
+    void paint (Graphics& g) override;
 protected:
+    std::unique_ptr<SidebarLCD> m_lcd;
+    std::unique_ptr<SidebarMixer> m_mixer;
+    std::unique_ptr<VenoConfigButton> m_configButton;
 };
 #endif //VENO_SIDEBAR_H

Source/Veno/GUI/GUIParts/Sidebar/VenoLogo.cpp

@@ -0,0 +1,36 @@
+//
+// Created by versustune on 14.06.20.
+//
+
+#include "VenoLogo.h"
+
+VenoLogo* VenoLogo::instance = nullptr;
+
+VenoLogo* VenoLogo::getInstance ()
+{
+    if (instance == nullptr)
+    {
+        instance = new VenoLogo();
+    }
+    return instance;
+}
+
+VenoLogo::VenoLogo ()
+{
+    MemoryOutputStream mo;
+    auto result = Base64::convertFromBase64(mo, base64logo);
+    if (result)
+    {
+        realLogo = juce::PNGImageFormat::loadFrom(mo.getData(), mo.getDataSize());
+    }
+}
+
+Image VenoLogo::getLogo ()
+{
+    return getInstance()->realLogo;
+}
+
+void VenoLogo::deleteInstance ()
+{
+    delete instance;
+}

Source/Veno/GUI/LookAndFeel/FlatLook.cpp

@@ -3,3 +3,20 @@
 //
 
 #include "FlatLook.h"
+#include "../../Core/Config.h"
+
+void FlatLook::drawButtonBackground (Graphics& graphics, Button& button, const Colour& backgroundColour,
+                                     bool shouldDrawButtonAsHighlighted, bool shouldDrawButtonAsDown)
+{
+    auto theme = Config::getInstance()->getCurrentTheme();
+    auto buttonArea = button.getLocalBounds();
+    if (shouldDrawButtonAsHighlighted)
+    {
+        graphics.setColour(theme->getColour(ThemeColour::accent));
+    }
+    else
+    {
+        graphics.setColour(theme->getColour(ThemeColour::accent_two));
+    }
+    graphics.drawRect(buttonArea);
+}

Source/Veno/GUI/LookAndFeel/FlatLook.h

@@ -11,6 +11,8 @@ class FlatLook : public LookAndFeel_V4
 {
 private:
 public:
+    void drawButtonBackground (Graphics& graphics, Button& button, const Colour& backgroundColour,
+                               bool shouldDrawButtonAsHighlighted, bool shouldDrawButtonAsDown) override;
 protected:
 };
 #endif //VENO_FLATLOOK_H

Source/Veno/GUI/Theme/Theme.cpp

@@ -4,6 +4,7 @@
 
 #include "Theme.h"
 #include "ThemePresets.cpp"
+#include "../../Core/Config.h"
 
 Theme::Theme (std::shared_ptr<PropertiesFile> file)
 {
@@ -29,7 +30,7 @@ void Theme::setColour (ThemeColour index, Colour* colour)
         m_colours[index] = colour;
     }
     m_configFile->setValue(ThemeColourToString(index), colour->toString());
-    m_configFile->save ();
+    m_configFile->setNeedsToBeSaved(true);
 
 }
 
@@ -90,3 +91,24 @@ void Theme::setColourThemeById (int id)
             break;
     }
 }
+
+void Theme::setDefault (const std::string& value)
+{
+    if (value == "LED")
+    {
+        setLEDTheme(this);
+    }
+    if (value == "Blood")
+    {
+        setBloodTheme(this);
+    }
+    if (value == "Orange Dream")
+    {
+        setOrangeDreamTheme(this);
+    }
+    if (value == "Ocean")
+    {
+        setOceanTheme(this);
+    }
+    Config::getInstance()->repaintAll();
+}

Source/Veno/GUI/Theme/Theme.h

@@ -21,6 +21,7 @@ public:
     void setColour (ThemeColour index, Colour* colour);
     void setColourThemeById (int id);
     void init ();
+    void setDefault(const std::string& value);
     void getColourFromConfig (ThemeColour index);
     Colour getColour (ThemeColour index);
 protected:

Source/Veno/GUI/Theme/ThemePresets.cpp

@@ -1,5 +1,7 @@
 #include "Theme.h"
 
+#ifndef VENO_THEME_PRESETS
+#define VENO_THEME_PRESETS
 /*
  * this file holds function that read some presets
  * in the current Theme class
@@ -81,3 +83,5 @@ std::string ThemeColourToString (ThemeColour index)
             return "";
     }
 }
+
+#endif

Source/Veno/Utils.cpp

@@ -25,3 +25,53 @@ float VeNo::Utils::setFontSize (float size, Graphics& g)
     g.setFont(s);
     return s;
 }
+
+float VeNo::Utils::clamp (float value, float min, float max)
+{
+    return value > max ? max : value < min ? min : value;
+}
+
+void
+VeNo::Utils::setPosition (int width, int height, int x, int y, std::shared_ptr<Component> component, bool useMarginY)
+{
+    double scale = Config::getInstance()->getScale();
+    double w = width * scale;
+    double h = height * scale;
+    if (useMarginY)
+    {
+        y += 10;
+    }
+    component->setBounds(x + 10, y, w, h);
+}
+
+void VeNo::Utils::setPositionSameRow (int width, int height, std::shared_ptr<Component> component,
+                                      std::shared_ptr<Component> previous)
+{
+    setPosition(width, height, previous->getX() + previous->getWidth(), previous->getY(), component, false);
+}
+
+void VeNo::Utils::setPositionByPreviousRow (int width, int height, int x, std::shared_ptr<Component> component,
+                                            std::shared_ptr<Component> previous)
+{
+    setPosition(width, height, x, previous->getY() + previous->getHeight(), component, true);
+}
+
+std::vector<int> VeNo::Utils::calcPosition (int width, int height, int prevWidth, int prevHeight)
+{
+    double scale = Config::getInstance()->getScale();
+    int w = (width * scale);
+    int h = (height * scale);
+    int x = prevWidth + 10;
+    int y = prevHeight + 10;
+    return {x, y, w, h};
+}
+
+int VeNo::Utils::getCalculatedWidth (int width)
+{
+    return width * Config::getInstance()->getScale();
+}
+
+int VeNo::Utils::getCalculatedHeight (int height)
+{
+    return height * Config::getInstance()->getScale();
+}

Source/Veno/Utils.h

@@ -15,7 +15,17 @@ namespace VeNo
         Utils () = default;
         ~Utils () = default;
         static int nextPowerOfTwo (float value);
+        static float clamp (float value, float min, float max);
         static float setFontSize (float size, Graphics& g);
+        static void
+        setPosition (int width, int height, int x, int y, std::shared_ptr<Component> component, bool useMarginY);
+        static void setPositionSameRow (int width, int height, std::shared_ptr<Component> component,
+                                        std::shared_ptr<Component> previous);
+        static void
+        setPositionByPreviousRow(int width, int height, int x, std::shared_ptr<Component> component, std::shared_ptr<Component> previous);
+        static std::vector<int> calcPosition(int width, int height, int prevWidth, int prevHeight);
+        static int getCalculatedWidth(int width);
+        static int getCalculatedHeight(int height);
     };
 }
 #endif //VENO_UTILS_H

Source/Veno/VenoInstance.cpp

@@ -13,12 +13,14 @@ VenoInstance::VenoInstance (std::string id)
     m_id = std::move(id);
     m_synthInstance = std::make_shared<SynthInstance>(id);
     audioBuffer = std::make_shared<VenoBuffer>();
+    state = new VeNoState(id);
 }
 
 VenoInstance::~VenoInstance ()
 {
     m_synthInstance.reset();
     audioBuffer.reset();
+    delete state;
 }
 
 std::shared_ptr<VenoInstance> VenoInstance::createInstance (const std::string& id)
@@ -53,3 +55,8 @@ void VenoInstance::deleteInstance (const std::string& processId)
         VeNo::Logger::debugMessage("Removed VenoInstance with id: " + processId);
     }
 }
+
+std::unordered_map<std::string, std::shared_ptr<VenoInstance>> VenoInstance::getAll ()
+{
+    return instances;
+}

Source/Veno/VenoInstance.h

@@ -10,6 +10,7 @@
 #include "Utils/FFT.h"
 #include "Audio/VenoBuffer.h"
 #include "Audio/Engine/VenoMatrix.h"
+#include "Core/VeNoState.h"
 #include <unordered_map>
 
 class VenoInstance
@@ -28,5 +29,7 @@ public:
     FFT fft;
     std::shared_ptr<VenoBuffer> audioBuffer;
     VenoMatrix matrix{m_id}; //matrix need a own xml profile to save and restore!
+    VeNoState* state;
+    static std::unordered_map<std::string, std::shared_ptr<VenoInstance>> getAll ();
 };
 #endif //VENO_VENOINSTANCE_H

Veno.jucer

@@ -75,15 +75,39 @@
         </GROUP>
         <GROUP id="{EFD25B6B-987D-435F-F8DE-BD6C2B831E62}" name="GUI">
           <GROUP id="{9C28E1EA-57BD-A04E-6ED6-3C46B5BC7FC7}" name="GUIParts">
+            <GROUP id="{D7ABC90B-205D-31C2-67AD-7A31B96627FF}" name="ConfigScreen">
+              <FILE id="klHmJa" name="ConfigComponent.cpp" compile="1" resource="0"
+                    file="Source/Veno/GUI/GUIParts/ConfigScreen/ConfigComponent.cpp"/>
+              <FILE id="pYQYBm" name="ConfigComponent.h" compile="0" resource="0"
+                    file="Source/Veno/GUI/GUIParts/ConfigScreen/ConfigComponent.h"/>
+              <FILE id="aeg3dC" name="VenoConfigScreen.cpp" compile="1" resource="0"
+                    file="Source/Veno/GUI/GUIParts/ConfigScreen/VenoConfigScreen.cpp"/>
+              <FILE id="CvExms" name="VenoConfigScreen.h" compile="0" resource="0"
+                    file="Source/Veno/GUI/GUIParts/ConfigScreen/VenoConfigScreen.h"/>
+            </GROUP>
             <GROUP id="{B7626B9F-22D9-713A-B543-1D7B34AF77B7}" name="Sidebar">
               <FILE id="aGx0eJ" name="Sidebar.cpp" compile="1" resource="0" file="Source/Veno/GUI/GUIParts/Sidebar/Sidebar.cpp"/>
               <FILE id="uL7MJ3" name="Sidebar.h" compile="0" resource="0" file="Source/Veno/GUI/GUIParts/Sidebar/Sidebar.h"/>
               <FILE id="lNXOQs" name="SidebarMixer.cpp" compile="1" resource="0"
                     file="Source/Veno/GUI/GUIParts/Sidebar/SidebarMixer.cpp"/>
               <FILE id="onzdTZ" name="SidebarMixer.h" compile="0" resource="0" file="Source/Veno/GUI/GUIParts/Sidebar/SidebarMixer.h"/>
+              <FILE id="w3JFHK" name="VenoLogo.h" compile="0" resource="0" file="Source/Veno/GUI/GUIParts/Sidebar/VenoLogo.h"/>
+              <FILE id="AE7YqM" name="VenoLogo.cpp" compile="1" resource="0" file="Source/Veno/GUI/GUIParts/Sidebar/VenoLogo.cpp"/>
             </GROUP>
           </GROUP>
           <GROUP id="{53C33AC6-67D7-762E-FFD5-C82B7F51DA5F}" name="Components">
+            <GROUP id="{90BA3743-01F8-1537-6D24-1C38F4063F10}" name="Config">
+              <FILE id="SRKqRQ" name="VeNoColour.cpp" compile="1" resource="0" file="Source/Veno/GUI/Components/Config/VeNoColour.cpp"/>
+              <FILE id="Da4NUN" name="VeNoColour.h" compile="0" resource="0" file="Source/Veno/GUI/Components/Config/VeNoColour.h"/>
+              <FILE id="zC4cQd" name="VenoConfigButton.cpp" compile="1" resource="0"
+                    file="Source/Veno/GUI/Components/Config/VenoConfigButton.cpp"/>
+              <FILE id="kCWitN" name="VenoConfigButton.h" compile="0" resource="0"
+                    file="Source/Veno/GUI/Components/Config/VenoConfigButton.h"/>
+              <FILE id="Yxj8Nf" name="VenoPreColours.cpp" compile="1" resource="0"
+                    file="Source/Veno/GUI/Components/Config/VenoPreColours.cpp"/>
+              <FILE id="DbGZt9" name="VenoPreColours.h" compile="0" resource="0"
+                    file="Source/Veno/GUI/Components/Config/VenoPreColours.h"/>
+            </GROUP>
             <GROUP id="{7C37E6D2-F2F7-6BF7-5D9B-2DDABFFE993F}" name="LCD">
               <FILE id="LpeTfD" name="SidebarLCD.cpp" compile="1" resource="0" file="Source/Veno/GUI/Components/LCD/SidebarLCD.cpp"/>
               <FILE id="Y5kUlM" name="SidebarLCD.h" compile="0" resource="0" file="Source/Veno/GUI/Components/LCD/SidebarLCD.h"/>
@@ -121,6 +145,8 @@
           <FILE id="i3vbdH" name="PresetManager.cpp" compile="1" resource="0"
                 file="Source/Veno/Core/PresetManager.cpp"/>
           <FILE id="WV2uuz" name="PresetManager.h" compile="0" resource="0" file="Source/Veno/Core/PresetManager.h"/>
+          <FILE id="Wvf9em" name="VeNoState.cpp" compile="1" resource="0" file="Source/Veno/Core/VeNoState.cpp"/>
+          <FILE id="skv4zn" name="VeNoState.h" compile="0" resource="0" file="Source/Veno/Core/VeNoState.h"/>
         </GROUP>
       </GROUP>
       <FILE id="zASeb7" name="PluginProcessor.cpp" compile="1" resource="0"