Add and apply .clang-format

10 files changed, 216 insertions, 183 deletions

diff --git a/src/DSP/AllPassFilter.cpp b/src/DSP/AllPassFilter.cpp
index 78af7c9..a051fd4 100644
--- a/src/DSP/AllPassFilter.cpp
+++ b/src/DSP/AllPassFilter.cpp
@@ -1,30 +1,32 @@
 #include "AllPassFilter.h"
 
-void AllPassFilter::prepare(double sampleRate, int samplesPerBlock, int delayInSamples, float gain) {
-  int maxDelayTimeMs = 100;
-  int maxDelaySamples = static_cast<int>(sampleRate * maxDelayTimeMs / 1000.0);
+void
+AllPassFilter::prepare(double sampleRate, int samplesPerBlock, int delayInSamples, float gain)
+{
+    int maxDelayTimeMs = 100;
+    int maxDelaySamples = static_cast<int>(sampleRate * maxDelayTimeMs / 1000.0);
 
-  delayBuffer.resize(maxDelaySamples, 0.0f);
-  std::fill(delayBuffer.begin(), delayBuffer.end(), 0.0f);  
-  delayBufferWritePos = 0;
-  this->delayInSamples_ = delayInSamples;
-  this->gain = gain;
+    delayBuffer.resize(maxDelaySamples, 0.0f);
+    std::fill(delayBuffer.begin(), delayBuffer.end(), 0.0f);
+    delayBufferWritePos = 0;
+    this->delayInSamples_ = delayInSamples;
+    this->gain = gain;
 }
 
-void AllPassFilter::process(float* sample) {
-  int delayBufferLength = (int)delayBuffer.size();
-  int delayReadPos =
-      (delayBufferWritePos - delayInSamples_ + delayBufferLength) %
-      delayBufferLength;
+void
+AllPassFilter::process(float* sample)
+{
+    int delayBufferLength = (int)delayBuffer.size();
+    int delayReadPos
+        = (delayBufferWritePos - delayInSamples_ + delayBufferLength) % delayBufferLength;
 
+    float delayedSample = delayBuffer[delayReadPos];
+    float xn = *sample;
 
-  float delayedSample = delayBuffer[delayReadPos];
-  float xn = *sample;
+    float bufferInput = xn + gain * delayedSample;
+    float yn = -gain * xn + delayedSample;
 
-  float bufferInput = xn + gain * delayedSample;
-  float yn = -gain * xn + delayedSample;  
-
-  delayBuffer[delayBufferWritePos] = bufferInput;
-  *sample = yn;
-  delayBufferWritePos = (delayBufferWritePos + 1) % delayBufferLength;
+    delayBuffer[delayBufferWritePos] = bufferInput;
+    *sample = yn;
+    delayBufferWritePos = (delayBufferWritePos + 1) % delayBufferLength;
 }
diff --git a/src/DSP/AllPassFilter.h b/src/DSP/AllPassFilter.h
index 0d9a91e..b989122 100644
--- a/src/DSP/AllPassFilter.h
+++ b/src/DSP/AllPassFilter.h
@@ -2,15 +2,16 @@
 
 #include <juce_audio_processors/juce_audio_processors.h>
 
-class AllPassFilter {
-public:
-  void prepare(double sampleRate, int samplesPerBlock, int delayInSamples, float gain);
-  void reset();
-  void process(float *sample);
+class AllPassFilter
+{
+  public:
+    void prepare(double sampleRate, int samplesPerBlock, int delayInSamples, float gain);
+    void reset();
+    void process(float* sample);
 
-private:
-  std::vector<float> delayBuffer;
-  int delayBufferWritePos = 0;
-  int delayInSamples_ = 0;
-  float gain = 0.7f;
+  private:
+    std::vector<float> delayBuffer;
+    int delayBufferWritePos = 0;
+    int delayInSamples_ = 0;
+    float gain = 0.7f;
 };
diff --git a/src/DSP/CombFilter.cpp b/src/DSP/CombFilter.cpp
index 3d11f2f..dc4de96 100644
--- a/src/DSP/CombFilter.cpp
+++ b/src/DSP/CombFilter.cpp
@@ -1,22 +1,27 @@
 #include "CombFilter.h"
 
-void CombFilter::prepare(double sampleRate, int samplesPerBlock, int delayInSamples, float gain) {
-  int maxDelayTimeMs = 500;
-  int maxDelaySamples = static_cast<int>(sampleRate * maxDelayTimeMs / 1000.0);
+void
+CombFilter::prepare(double sampleRate, int samplesPerBlock, int delayInSamples, float gain)
+{
+    int maxDelayTimeMs = 500;
+    int maxDelaySamples = static_cast<int>(sampleRate * maxDelayTimeMs / 1000.0);
 
-  delayBuffer.resize(maxDelaySamples, 0.0f);
-  std::fill(delayBuffer.begin(), delayBuffer.end(), 0.0f);
-  delayBufferWritePos = 0;
-  this->delayInSamples_ = delayInSamples;
-  this->gain = gain;
+    delayBuffer.resize(maxDelaySamples, 0.0f);
+    std::fill(delayBuffer.begin(), delayBuffer.end(), 0.0f);
+    delayBufferWritePos = 0;
+    this->delayInSamples_ = delayInSamples;
+    this->gain = gain;
 }
 
-void CombFilter::process(float* sample) {
-  int delayBufferLength = (int)delayBuffer.size();
-  int delayReadPos = (delayBufferWritePos - delayInSamples_ + delayBufferLength) % delayBufferLength;
-  float delayedSample = delayBuffer[delayReadPos];
-  float yn = *sample + gain * delayedSample;
-  delayBuffer[delayBufferWritePos] = yn;
-  delayBufferWritePos = (delayBufferWritePos + 1) % delayBufferLength;
-  *sample = delayedSample;  
+void
+CombFilter::process(float* sample)
+{
+    int delayBufferLength = (int)delayBuffer.size();
+    int delayReadPos
+        = (delayBufferWritePos - delayInSamples_ + delayBufferLength) % delayBufferLength;
+    float delayedSample = delayBuffer[delayReadPos];
+    float yn = *sample + gain * delayedSample;
+    delayBuffer[delayBufferWritePos] = yn;
+    delayBufferWritePos = (delayBufferWritePos + 1) % delayBufferLength;
+    *sample = delayedSample;
 }
diff --git a/src/DSP/CombFilter.h b/src/DSP/CombFilter.h
index 5568fec..4e435cd 100644
--- a/src/DSP/CombFilter.h
+++ b/src/DSP/CombFilter.h
@@ -2,15 +2,16 @@
 
 #include <juce_audio_processors/juce_audio_processors.h>
 
-class CombFilter {
-public:
-  void prepare(double sampleRate, int samplesPerBlock, int delayInSamples, float gain);
-  void reset();
-  void process(float* sample);
+class CombFilter
+{
+  public:
+    void prepare(double sampleRate, int samplesPerBlock, int delayInSamples, float gain);
+    void reset();
+    void process(float* sample);
 
-private:
-  std::vector<float> delayBuffer;
-  int delayBufferWritePos = 0;
-  int delayInSamples_ = 0;
-  float gain = 0.7f;
+  private:
+    std::vector<float> delayBuffer;
+    int delayBufferWritePos = 0;
+    int delayInSamples_ = 0;
+    float gain = 0.7f;
 };
diff --git a/src/DSP/SchroederReverb.cpp b/src/DSP/SchroederReverb.cpp
index 785e84c..202c24d 100644
--- a/src/DSP/SchroederReverb.cpp
+++ b/src/DSP/SchroederReverb.cpp
@@ -1,30 +1,34 @@
 #include "SchroederReverb.h"
 
-void SchroederReverb::prepare(double sampleRate, int samplesPerBlock) {
-  combFilter0.prepare(sampleRate, samplesPerBlock, 4799, 0.742f);
-  combFilter1.prepare(sampleRate, samplesPerBlock, 4999, 0.733f);
-  combFilter2.prepare(sampleRate, samplesPerBlock, 5399, 0.715f);
-  combFilter3.prepare(sampleRate, samplesPerBlock, 5801, 0.697f);
-  allPassFilter0.prepare(sampleRate, samplesPerBlock, 1051, 0.7f);
-  allPassFilter1.prepare(sampleRate, samplesPerBlock, 337, 0.7f);    
+void
+SchroederReverb::prepare(double sampleRate, int samplesPerBlock)
+{
+    combFilter0.prepare(sampleRate, samplesPerBlock, 4799, 0.742f);
+    combFilter1.prepare(sampleRate, samplesPerBlock, 4999, 0.733f);
+    combFilter2.prepare(sampleRate, samplesPerBlock, 5399, 0.715f);
+    combFilter3.prepare(sampleRate, samplesPerBlock, 5801, 0.697f);
+    allPassFilter0.prepare(sampleRate, samplesPerBlock, 1051, 0.7f);
+    allPassFilter1.prepare(sampleRate, samplesPerBlock, 337, 0.7f);
 }
 
-void SchroederReverb::process(float *sample) {
-  juce::ScopedNoDenormals noDenormals;
-  
-  float in0 = *sample;
-  float in1 = *sample;
-  float in2 = *sample;
-  float in3 = *sample;
+void
+SchroederReverb::process(float* sample)
+{
+    juce::ScopedNoDenormals noDenormals;
 
-  combFilter0.process(&in0);
-  combFilter1.process(&in1);
-  combFilter2.process(&in2);
-  combFilter3.process(&in3);
+    float in0 = *sample;
+    float in1 = *sample;
+    float in2 = *sample;
+    float in3 = *sample;
 
-  float allPassIn = 0.25f * (in0 + in1 + in2 + in3);
-  allPassFilter0.process(&allPassIn);
-  allPassFilter1.process(&allPassIn);
+    combFilter0.process(&in0);
+    combFilter1.process(&in1);
+    combFilter2.process(&in2);
+    combFilter3.process(&in3);
 
-  *sample = allPassIn;
+    float allPassIn = 0.25f * (in0 + in1 + in2 + in3);
+    allPassFilter0.process(&allPassIn);
+    allPassFilter1.process(&allPassIn);
+
+    *sample = allPassIn;
 }
diff --git a/src/DSP/SchroederReverb.h b/src/DSP/SchroederReverb.h
index 8c4567a..a5b3038 100644
--- a/src/DSP/SchroederReverb.h
+++ b/src/DSP/SchroederReverb.h
@@ -1,16 +1,17 @@
 #pragma once
 
-#include <juce_audio_processors/juce_audio_processors.h>
-#include "CombFilter.h"
 #include "AllPassFilter.h"
+#include "CombFilter.h"
+#include <juce_audio_processors/juce_audio_processors.h>
 
-class SchroederReverb {
-public:
-  void prepare(double sampleRate, int samplesPerBlock);
-  void reset();
-  void process(float* sample);
+class SchroederReverb
+{
+  public:
+    void prepare(double sampleRate, int samplesPerBlock);
+    void reset();
+    void process(float* sample);
 
-private:
-  CombFilter combFilter0, combFilter1, combFilter2, combFilter3;
-  AllPassFilter allPassFilter0, allPassFilter1;
+  private:
+    CombFilter combFilter0, combFilter1, combFilter2, combFilter3;
+    AllPassFilter allPassFilter0, allPassFilter1;
 };
diff --git a/src/PluginProcessor.cpp b/src/PluginProcessor.cpp
index c1f4373..ec16ea9 100644
--- a/src/PluginProcessor.cpp
+++ b/src/PluginProcessor.cpp
@@ -3,131 +3,143 @@
 
 //==============================================================================
 SchroederReverbAudioProcessor::SchroederReverbAudioProcessor()
-     : AudioProcessor (BusesProperties()
-                     #if ! JucePlugin_IsMidiEffect
-                      #if ! JucePlugin_IsSynth
-                       .withInput  ("Input",  juce::AudioChannelSet::stereo(), true)
-                      #endif
-                       .withOutput ("Output", juce::AudioChannelSet::stereo(), true)
-                     #endif
-                       )
+    : AudioProcessor(BusesProperties()
+#if !JucePlugin_IsMidiEffect
+#if !JucePlugin_IsSynth
+                         .withInput("Input", juce::AudioChannelSet::stereo(), true)
+#endif
+                         .withOutput("Output", juce::AudioChannelSet::stereo(), true)
+#endif
+      )
 {
 }
 
-SchroederReverbAudioProcessor::~SchroederReverbAudioProcessor()
-{
-}
+SchroederReverbAudioProcessor::~SchroederReverbAudioProcessor() {}
 
 //==============================================================================
-const juce::String SchroederReverbAudioProcessor::getName() const
+const juce::String
+SchroederReverbAudioProcessor::getName() const
 {
     return JucePlugin_Name;
 }
 
-bool SchroederReverbAudioProcessor::acceptsMidi() const
+bool
+SchroederReverbAudioProcessor::acceptsMidi() const
 {
-   #if JucePlugin_WantsMidiInput
+#if JucePlugin_WantsMidiInput
     return true;
-   #else
+#else
     return false;
-   #endif
+#endif
 }
 
-bool SchroederReverbAudioProcessor::producesMidi() const
+bool
+SchroederReverbAudioProcessor::producesMidi() const
 {
-   #if JucePlugin_ProducesMidiOutput
+#if JucePlugin_ProducesMidiOutput
     return true;
-   #else
+#else
     return false;
-   #endif
+#endif
 }
 
-bool SchroederReverbAudioProcessor::isMidiEffect() const
+bool
+SchroederReverbAudioProcessor::isMidiEffect() const
 {
-   #if JucePlugin_IsMidiEffect
+#if JucePlugin_IsMidiEffect
     return true;
-   #else
+#else
     return false;
-   #endif
+#endif
 }
 
-double SchroederReverbAudioProcessor::getTailLengthSeconds() const
+double
+SchroederReverbAudioProcessor::getTailLengthSeconds() const
 {
     return 0.0;
 }
 
-int SchroederReverbAudioProcessor::getNumPrograms()
+int
+SchroederReverbAudioProcessor::getNumPrograms()
 {
-    return 1;   // NB: some hosts don't cope very well if you tell them there are 0 programs,
-                // so this should be at least 1, even if you're not really implementing programs.
+    return 1; // NB: some hosts don't cope very well if you tell them there are 0 programs,
+              // so this should be at least 1, even if you're not really implementing programs.
 }
 
-int SchroederReverbAudioProcessor::getCurrentProgram()
+int
+SchroederReverbAudioProcessor::getCurrentProgram()
 {
     return 0;
 }
 
-void SchroederReverbAudioProcessor::setCurrentProgram (int index)
+void
+SchroederReverbAudioProcessor::setCurrentProgram(int index)
 {
-    juce::ignoreUnused (index);
+    juce::ignoreUnused(index);
 }
 
-const juce::String SchroederReverbAudioProcessor::getProgramName (int index)
+const juce::String
+SchroederReverbAudioProcessor::getProgramName(int index)
 {
-    juce::ignoreUnused (index);
+    juce::ignoreUnused(index);
     return {};
 }
 
-void SchroederReverbAudioProcessor::changeProgramName (int index, const juce::String& newName)
+void
+SchroederReverbAudioProcessor::changeProgramName(int index, const juce::String& newName)
 {
-    juce::ignoreUnused (index, newName);
+    juce::ignoreUnused(index, newName);
 }
 
 //==============================================================================
-void SchroederReverbAudioProcessor::prepareToPlay (double sampleRate, int samplesPerBlock)
+void
+SchroederReverbAudioProcessor::prepareToPlay(double sampleRate, int samplesPerBlock)
 {
     // Use this method as the place to do any pre-playback
     // initialisation that you need..
     schroederReverb.prepare(sampleRate, samplesPerBlock);
 }
 
-void SchroederReverbAudioProcessor::releaseResources()
+void
+SchroederReverbAudioProcessor::releaseResources()
 {
     // When playback stops, you can use this as an opportunity to free up any
     // spare memory, etc.
 }
 
-bool SchroederReverbAudioProcessor::isBusesLayoutSupported (const BusesLayout& layouts) const
+bool
+SchroederReverbAudioProcessor::isBusesLayoutSupported(const BusesLayout& layouts) const
 {
-  #if JucePlugin_IsMidiEffect
-    juce::ignoreUnused (layouts);
+#if JucePlugin_IsMidiEffect
+    juce::ignoreUnused(layouts);
     return true;
-  #else
+#else
     // This is the place where you check if the layout is supported.
     // In this template code we only support mono or stereo.
     // Some plugin hosts, such as certain GarageBand versions, will only
     // load plugins that support stereo bus layouts.
     if (layouts.getMainOutputChannelSet() != juce::AudioChannelSet::mono()
-     && layouts.getMainOutputChannelSet() != juce::AudioChannelSet::stereo())
+        && layouts.getMainOutputChannelSet() != juce::AudioChannelSet::stereo())
         return false;
 
     // This checks if the input layout matches the output layout
-   #if ! JucePlugin_IsSynth
+#if !JucePlugin_IsSynth
     if (layouts.getMainOutputChannelSet() != layouts.getMainInputChannelSet())
         return false;
-   #endif
+#endif
 
     return true;
-  #endif
+#endif
 }
 
-void SchroederReverbAudioProcessor::processBlock (juce::AudioBuffer<float>& buffer,
-                                              juce::MidiBuffer& midiMessages)
+void
+SchroederReverbAudioProcessor::processBlock(juce::AudioBuffer<float>& buffer,
+                                            juce::MidiBuffer& midiMessages)
 {
-    juce::ignoreUnused (midiMessages);
+    juce::ignoreUnused(midiMessages);
 
     juce::ScopedNoDenormals noDenormals;
-    auto totalNumInputChannels  = getTotalNumInputChannels();
+    auto totalNumInputChannels = getTotalNumInputChannels();
     auto totalNumOutputChannels = getTotalNumOutputChannels();
 
     // In case we have more outputs than inputs, this code clears any output
@@ -137,7 +149,7 @@ void SchroederReverbAudioProcessor::processBlock (juce::AudioBuffer<float>& buff
     // when they first compile a plugin, but obviously you don't need to keep
     // this code if your algorithm always overwrites all the output channels.
     for (auto i = totalNumInputChannels; i < totalNumOutputChannels; ++i)
-        buffer.clear (i, 0, buffer.getNumSamples());
+        buffer.clear(i, 0, buffer.getNumSamples());
 
     // This is the place where you'd normally do the guts of your plugin's
     // audio processing...
@@ -147,44 +159,50 @@ void SchroederReverbAudioProcessor::processBlock (juce::AudioBuffer<float>& buff
     // interleaved by keeping the same state.
     for (int channel = 0; channel < totalNumInputChannels; ++channel)
     {
-      auto *channelData = buffer.getWritePointer(channel);
-      for (int i = 0; i < buffer.getNumSamples(); ++i) {
-	        schroederReverb.process(&channelData[i]);
+        auto* channelData = buffer.getWritePointer(channel);
+        for (int i = 0; i < buffer.getNumSamples(); ++i)
+        {
+            schroederReverb.process(&channelData[i]);
         }
         // ..do something to the data...
     }
 }
 
 //==============================================================================
-bool SchroederReverbAudioProcessor::hasEditor() const
+bool
+SchroederReverbAudioProcessor::hasEditor() const
 {
     return true; // (change this to false if you choose to not supply an editor)
 }
 
-juce::AudioProcessorEditor* SchroederReverbAudioProcessor::createEditor()
+juce::AudioProcessorEditor*
+SchroederReverbAudioProcessor::createEditor()
 {
-    return new SchroederReverbAudioProcessorEditor (*this);
+    return new SchroederReverbAudioProcessorEditor(*this);
 }
 
 //==============================================================================
-void SchroederReverbAudioProcessor::getStateInformation (juce::MemoryBlock& destData)
+void
+SchroederReverbAudioProcessor::getStateInformation(juce::MemoryBlock& destData)
 {
     // You should use this method to store your parameters in the memory block.
     // You could do that either as raw data, or use the XML or ValueTree classes
     // as intermediaries to make it easy to save and load complex data.
-    juce::ignoreUnused (destData);
+    juce::ignoreUnused(destData);
 }
 
-void SchroederReverbAudioProcessor::setStateInformation (const void* data, int sizeInBytes)
+void
+SchroederReverbAudioProcessor::setStateInformation(const void* data, int sizeInBytes)
 {
     // You should use this method to restore your parameters from this memory block,
     // whose contents will have been created by the getStateInformation() call.
-    juce::ignoreUnused (data, sizeInBytes);
+    juce::ignoreUnused(data, sizeInBytes);
 }
 
 //==============================================================================
 // This creates new instances of the plugin..
-juce::AudioProcessor* JUCE_CALLTYPE createPluginFilter()
+juce::AudioProcessor* JUCE_CALLTYPE
+createPluginFilter()
 {
     return new SchroederReverbAudioProcessor();
 }
diff --git a/src/PluginProcessor.h b/src/PluginProcessor.h
index 1d31a49..ed9ae5f 100644
--- a/src/PluginProcessor.h
+++ b/src/PluginProcessor.h
@@ -1,23 +1,23 @@
 #pragma once
 
-#include <juce_audio_processors/juce_audio_processors.h>
 #include "DSP/SchroederReverb.h"
+#include <juce_audio_processors/juce_audio_processors.h>
 
 //==============================================================================
 class SchroederReverbAudioProcessor final : public juce::AudioProcessor
 {
-public:
+  public:
     //==============================================================================
     SchroederReverbAudioProcessor();
     ~SchroederReverbAudioProcessor() override;
 
     //==============================================================================
-    void prepareToPlay (double sampleRate, int samplesPerBlock) override;
+    void prepareToPlay(double sampleRate, int samplesPerBlock) override;
     void releaseResources() override;
 
-    bool isBusesLayoutSupported (const BusesLayout& layouts) const override;
+    bool isBusesLayoutSupported(const BusesLayout& layouts) const override;
 
-    void processBlock (juce::AudioBuffer<float>&, juce::MidiBuffer&) override;
+    void processBlock(juce::AudioBuffer<float>&, juce::MidiBuffer&) override;
     using AudioProcessor::processBlock;
 
     //==============================================================================
@@ -35,16 +35,16 @@ public:
     //==============================================================================
     int getNumPrograms() override;
     int getCurrentProgram() override;
-    void setCurrentProgram (int index) override;
-    const juce::String getProgramName (int index) override;
-    void changeProgramName (int index, const juce::String& newName) override;
+    void setCurrentProgram(int index) override;
+    const juce::String getProgramName(int index) override;
+    void changeProgramName(int index, const juce::String& newName) override;
 
     //==============================================================================
-    void getStateInformation (juce::MemoryBlock& destData) override;
-    void setStateInformation (const void* data, int sizeInBytes) override;
+    void getStateInformation(juce::MemoryBlock& destData) override;
+    void setStateInformation(const void* data, int sizeInBytes) override;
 
-private:
-  //==============================================================================
-  SchroederReverb schroederReverb;
-    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SchroederReverbAudioProcessor)
+  private:
+    //==============================================================================
+    SchroederReverb schroederReverb;
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(SchroederReverbAudioProcessor)
 };
diff --git a/src/UI/PluginEditor.cpp b/src/UI/PluginEditor.cpp
index 1ba07af..b3b8256 100644
--- a/src/UI/PluginEditor.cpp
+++ b/src/UI/PluginEditor.cpp
@@ -1,32 +1,33 @@
-#include "../PluginProcessor.h"
 #include "PluginEditor.h"
+#include "../PluginProcessor.h"
 
 //==============================================================================
-SchroederReverbAudioProcessorEditor::SchroederReverbAudioProcessorEditor (SchroederReverbAudioProcessor& p)
-    : AudioProcessorEditor (&p), processorRef (p)
+SchroederReverbAudioProcessorEditor::SchroederReverbAudioProcessorEditor(
+    SchroederReverbAudioProcessor& p)
+    : AudioProcessorEditor(&p), processorRef(p)
 {
-    juce::ignoreUnused (processorRef);
+    juce::ignoreUnused(processorRef);
     // Make sure that before the constructor has finished, you've set the
     // editor's size to whatever you need it to be.
-    setSize (400, 300);
+    setSize(400, 300);
 }
 
-SchroederReverbAudioProcessorEditor::~SchroederReverbAudioProcessorEditor()
-{
-}
+SchroederReverbAudioProcessorEditor::~SchroederReverbAudioProcessorEditor() {}
 
 //==============================================================================
-void SchroederReverbAudioProcessorEditor::paint (juce::Graphics& g)
+void
+SchroederReverbAudioProcessorEditor::paint(juce::Graphics& g)
 {
     // (Our component is opaque, so we must completely fill the background with a solid colour)
-    g.fillAll (getLookAndFeel().findColour (juce::ResizableWindow::backgroundColourId));
+    g.fillAll(getLookAndFeel().findColour(juce::ResizableWindow::backgroundColourId));
 
-    g.setColour (juce::Colours::white);
-    g.setFont (15.0f);
-    g.drawFittedText ("Hello World!", getLocalBounds(), juce::Justification::centred, 1);
+    g.setColour(juce::Colours::white);
+    g.setFont(15.0f);
+    g.drawFittedText("Hello World!", getLocalBounds(), juce::Justification::centred, 1);
 }
 
-void SchroederReverbAudioProcessorEditor::resized()
+void
+SchroederReverbAudioProcessorEditor::resized()
 {
     // This is generally where you'll want to lay out the positions of any
     // subcomponents in your editor..
diff --git a/src/UI/PluginEditor.h b/src/UI/PluginEditor.h
index 1f30a89..1f7a5bb 100644
--- a/src/UI/PluginEditor.h
+++ b/src/UI/PluginEditor.h
@@ -5,18 +5,18 @@
 //==============================================================================
 class SchroederReverbAudioProcessorEditor final : public juce::AudioProcessorEditor
 {
-public:
-    explicit SchroederReverbAudioProcessorEditor (SchroederReverbAudioProcessor&);
+  public:
+    explicit SchroederReverbAudioProcessorEditor(SchroederReverbAudioProcessor&);
     ~SchroederReverbAudioProcessorEditor() override;
 
     //==============================================================================
-    void paint (juce::Graphics&) override;
+    void paint(juce::Graphics&) override;
     void resized() override;
 
-private:
+  private:
     // This reference is provided as a quick way for your editor to
     // access the processor object that created it.
     SchroederReverbAudioProcessor& processorRef;
 
-    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SchroederReverbAudioProcessorEditor)
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(SchroederReverbAudioProcessorEditor)
 };