Merge pull request #4 from SmEgDm/ui-interaction

UI interaction

Author: egoracle

public/icons/bell.svg

@@ -2,24 +2,22 @@
 
 PluginEditor::PluginEditor(PluginProcessor &p)
     : juce::AudioProcessorEditor(&p), homePage(p) {
-  setSize(defaultWidth, defaultHeight);
-  setResizable(true, true);
+  juce::LookAndFeel_V4::setDefaultLookAndFeel(&lookAndFeel);
 
   const auto desktopArea =
       juce::Desktop::getInstance().getDisplays().getPrimaryDisplay()->userArea;
-
+  setSize(defaultWidth, defaultHeight);
+  setResizable(true, true);
   setResizeLimits(minWidth, minHeight, desktopArea.getWidth(),
                   desktopArea.getHeight());
 
-  juce::LookAndFeel::setDefaultLookAndFeel(&lookAndFeel);
-
   addAndMakeVisible(homePage);
 
   resized();
 }
 
 PluginEditor::~PluginEditor() {
-  juce::LookAndFeel::setDefaultLookAndFeel(nullptr);
+  juce::LookAndFeel_V4::setDefaultLookAndFeel(nullptr);
 }
 
 void PluginEditor::resized() { homePage.setBounds(getLocalBounds()); }

public/icons/highpass.svg

@@ -19,7 +19,7 @@ class PluginEditor : public juce::AudioProcessorEditor {
   void resized() override;
 
 private:
-  SairaFontLookAndFeel lookAndFeel;
+  PluginLookAndFeel lookAndFeel;
 
   HomePage homePage;
 

public/icons/lowpass.svg

@@ -1,11 +1,35 @@
 #include "equalizer.hpp"
 
-Equalizer::Equalizer(PluginProcessor &pluginProcessor)
-    : analyzer(pluginProcessor), freqResponse(pluginProcessor) {
+#include <algorithm>
+
+Equalizer::Equalizer(PluginProcessor &p)
+    : pluginProcessor(p), uiState(p.getUiState()), analyzer(p), freqResponse(p),
+      filterPanel(p, [&]() { update(); }) {
+  addMouseListener(this, true);
+
   addAndMakeVisible(grid);
   addAndMakeVisible(analyzer);
+
+  for (int id = constants::FILTER_MIN_ID; id <= constants::FILTER_MAX_ID;
+       ++id) {
+    filterFreqResponses.push_back(
+        std::make_unique<FilterFrequencyResponse>(pluginProcessor, id));
+    addChildComponent(filterFreqResponses.back().get());
+  }
+
   addAndMakeVisible(freqResponse);
 
+  for (int id = constants::FILTER_MIN_ID; id <= constants::FILTER_MAX_ID;
+       ++id) {
+    filterButtons.push_back(std::make_unique<FilterButton>(
+        id, pluginProcessor, [&]() { update(); }));
+    addChildComponent(filterButtons.back().get());
+  }
+
+  addChildComponent(filterPanel);
+
+  update();
+
   resized();
 }
 
@@ -16,6 +40,77 @@ void Equalizer::resized() {
 
   LayoutComponent::resized();
 
-  analyzer.setBounds(getLocalBounds());
-  freqResponse.setBounds(getLocalBounds());
+  const auto bounds = getLocalBounds();
+
+  analyzer.setBounds(bounds);
+  for (auto &filterFreqResponse : filterFreqResponses) {
+    filterFreqResponse->setBounds(bounds);
+  }
+  freqResponse.setBounds(bounds);
+  filterPanel.setBounds(bounds.withSizeKeepingCentre(300, 170).translated(
+      0.0f, static_cast<float>(getHeight()) * 0.5f - 85.0f - 30.0f));
+  for (auto &filterButton : filterButtons) {
+    filterButton->timerCallback();
+  }
+}
+
+void Equalizer::mouseDown(const juce::MouseEvent &event) {
+  LayoutComponent::mouseDown(event);
+
+  if (event.eventComponent == &freqResponse) {
+    uiState.selectedFilterID = -1;
+    update();
+  }
+}
+
+void Equalizer::mouseDoubleClick(const juce::MouseEvent &event) {
+  LayoutComponent::mouseDoubleClick(event);
+
+  if (event.eventComponent != &freqResponse || !uiState.addFilter()) {
+    return;
+  }
+
+  const float xMin = 0.0f;
+  const float xMax = static_cast<float>(event.eventComponent->getWidth());
+  const float yMax = static_cast<float>(event.eventComponent->getHeight());
+
+  const auto xToFreq = math::invLogMapping(xMin, xMax, constants::GRID_MIN_FREQ,
+                                           constants::GRID_MAX_FREQ);
+  const auto yToDb = math::segmentMapping(yMax, 0.0f, constants::GRID_MIN_DB,
+                                          constants::GRID_MAX_DB);
+  const auto dBToNorm = math::segmentMapping(-12, 12, 0, 1);
+
+  const float x = static_cast<float>(event.getMouseDownX());
+  const float y = static_cast<float>(event.getMouseDownY());
+
+  FilterParameters filterParameters(uiState.selectedFilterID,
+                                    pluginProcessor.getAPVTS());
+  const auto freqToNorm = filterParameters.frequency->getNormalisableRange();
+
+  filterParameters.isActive->beginChangeGesture();
+  filterParameters.isActive->setValueNotifyingHost(1.0f);
+  filterParameters.isActive->endChangeGesture();
+
+  filterParameters.frequency->beginChangeGesture();
+  filterParameters.frequency->setValueNotifyingHost(
+      freqToNorm.convertTo0to1(xToFreq(x)));
+  filterParameters.frequency->endChangeGesture();
+
+  filterParameters.gain->beginChangeGesture();
+  filterParameters.gain->setValueNotifyingHost(dBToNorm(yToDb(y)));
+  filterParameters.gain->endChangeGesture();
+
+  filterButtons[uiState.selectedFilterID - 1]->setCentrePosition(
+      event.getMouseDownPosition());
+  filterButtons[uiState.selectedFilterID - 1]->setVisible(true);
+
+  update();
+}
+
+void Equalizer::update() {
+  filterPanel.update();
+  for (const auto &[filterID, isUsed] : uiState.usedFilterIDs) {
+    filterFreqResponses[filterID - 1]->setVisible(isUsed);
+    filterButtons[filterID - 1]->setVisible(isUsed);
+  }
 }

public/icons/powerswitch.svg

@@ -1,17 +1,30 @@
 #pragma once
 
 #include "shared.hpp"
-
 #include "ui/ui.hpp"
 
+#include <memory>
+#include <vector>
+
 class Equalizer : public LayoutComponent {
 public:
   Equalizer(PluginProcessor &);
 
   void resized() override;
 
+  void mouseDown(const juce::MouseEvent &event) override;
+  void mouseDoubleClick(const juce::MouseEvent &event) override;
+
+  void update();
+
 private:
+  PluginProcessor &pluginProcessor;
+  PluginProcessor::UiState &uiState;
+
   GridComponent grid;
   AnalyzerComponent analyzer;
-  FrequencyResponseComponent freqResponse;
+  std::vector<std::unique_ptr<FilterFrequencyResponse>> filterFreqResponses;
+  EqualizerFrequencyResponse freqResponse;
+  FilterPanel filterPanel;
+  std::vector<std::unique_ptr<FilterButton>> filterButtons;
 };

src/app/editor.cpp

@@ -7,7 +7,7 @@
 #include <vector>
 
 AnalyzerComponent::AnalyzerComponent(PluginProcessor &p) : pluginProcessor(p) {
-  startTimerHz(30);
+  startTimerHz(24);
 }
 
 void AnalyzerComponent::paint(juce::Graphics &g) {

src/app/editor.hpp

@@ -1,13 +1,13 @@
-#include "frequency_response.hpp"
+#include "equalizer_response.hpp"
 
 #include "constants.hpp"
 
-FrequencyResponseComponent::FrequencyResponseComponent(PluginProcessor &p)
+EqualizerFrequencyResponse::EqualizerFrequencyResponse(PluginProcessor &p)
     : pluginProcessor(p), frequencyResponse([](float) { return 0.0f; }) {
-  startTimerHz(30);
+  startTimerHz(24);
 }
 
-void FrequencyResponseComponent::paint(juce::Graphics &g) {
+void EqualizerFrequencyResponse::paint(juce::Graphics &g) {
   const auto equalizerProcessor = pluginProcessor.getEqualizerProcessor();
 
   if (!equalizerProcessor) {
@@ -44,7 +44,7 @@ void FrequencyResponseComponent::paint(juce::Graphics &g) {
                                  juce::PathStrokeType::EndCapStyle::rounded));
 }
 
-void FrequencyResponseComponent::timerCallback() {
+void EqualizerFrequencyResponse::timerCallback() {
   const auto equalizerProcessor = pluginProcessor.getEqualizerProcessor();
 
   if (equalizerProcessor) {