diff --git a/src/core/monique_core_Datastructures.cpp b/src/core/monique_core_Datastructures.cpp
index b30811d1..a7565929 100644
--- a/src/core/monique_core_Datastructures.cpp
+++ b/src/core/monique_core_Datastructures.cpp
@@ -2075,45 +2075,51 @@ COLD void MoniqueSynthData::init_morph_groups(DATA_TYPES data_type,
     right_morph_source_names.add("UNDEFINED");
     {
         // OSC'S
-        {{morph_group_1->register_parameter(osc_datas[0]->wave.ptr(), data_type == MASTER);
-        morph_group_1->register_parameter(fm_osc_data->master_shift.ptr(), data_type == MASTER);
-        morph_group_1->register_parameter(osc_datas[0]->fm_amount.ptr(), data_type == MASTER);
-
-        morph_group_1->register_switch_parameter(osc_datas[0]->is_lfo_modulated.bool_ptr(),
-                                                 data_type == MASTER);
-        morph_group_1->register_switch_parameter(osc_datas[0]->sync.bool_ptr(),
-                                                 data_type == MASTER);
-    }
-    {
-        morph_group_1->register_parameter(osc_datas[1]->wave.ptr(), data_type == MASTER);
-        morph_group_1->register_parameter(osc_datas[1]->tune.ptr(), data_type == MASTER);
-        morph_group_1->register_parameter(osc_datas[1]->fm_amount.ptr(), data_type == MASTER);
-
-        morph_group_1->register_switch_parameter(osc_datas[1]->is_lfo_modulated.bool_ptr(),
-                                                 data_type == MASTER);
-        morph_group_1->register_switch_parameter(osc_datas[1]->sync.bool_ptr(),
-                                                 data_type == MASTER);
-    }
-    {
-        morph_group_1->register_parameter(osc_datas[2]->wave.ptr(), data_type == MASTER);
-        morph_group_1->register_parameter(osc_datas[2]->tune.ptr(), data_type == MASTER);
-        morph_group_1->register_parameter(osc_datas[2]->fm_amount.ptr(), data_type == MASTER);
-
-        morph_group_1->register_switch_parameter(osc_datas[2]->is_lfo_modulated.bool_ptr(),
-                                                 data_type == MASTER);
-        morph_group_1->register_switch_parameter(osc_datas[2]->sync.bool_ptr(),
-                                                 data_type == MASTER);
-    }
-}
+        {
+            {
+                morph_group_1->register_parameter(osc_datas[0]->wave.ptr(), data_type == MASTER);
+                morph_group_1->register_parameter(fm_osc_data->master_shift.ptr(),
+                                                  data_type == MASTER);
+                morph_group_1->register_parameter(osc_datas[0]->fm_amount.ptr(),
+                                                  data_type == MASTER);
+
+                morph_group_1->register_switch_parameter(osc_datas[0]->is_lfo_modulated.bool_ptr(),
+                                                         data_type == MASTER);
+                morph_group_1->register_switch_parameter(osc_datas[0]->sync.bool_ptr(),
+                                                         data_type == MASTER);
+            }
+            {
+                morph_group_1->register_parameter(osc_datas[1]->wave.ptr(), data_type == MASTER);
+                morph_group_1->register_parameter(osc_datas[1]->tune.ptr(), data_type == MASTER);
+                morph_group_1->register_parameter(osc_datas[1]->fm_amount.ptr(),
+                                                  data_type == MASTER);
+
+                morph_group_1->register_switch_parameter(osc_datas[1]->is_lfo_modulated.bool_ptr(),
+                                                         data_type == MASTER);
+                morph_group_1->register_switch_parameter(osc_datas[1]->sync.bool_ptr(),
+                                                         data_type == MASTER);
+            }
+            {
+                morph_group_1->register_parameter(osc_datas[2]->wave.ptr(), data_type == MASTER);
+                morph_group_1->register_parameter(osc_datas[2]->tune.ptr(), data_type == MASTER);
+                morph_group_1->register_parameter(osc_datas[2]->fm_amount.ptr(),
+                                                  data_type == MASTER);
+
+                morph_group_1->register_switch_parameter(osc_datas[2]->is_lfo_modulated.bool_ptr(),
+                                                         data_type == MASTER);
+                morph_group_1->register_switch_parameter(osc_datas[2]->sync.bool_ptr(),
+                                                         data_type == MASTER);
+            }
+        }
 
-// FM
-{
-    morph_group_1->register_parameter(fm_osc_data->fm_freq.ptr(), data_type == MASTER);
-    morph_group_1->register_parameter(fm_osc_data->fm_swing.ptr(), data_type == MASTER);
-    morph_group_1->register_parameter(fm_osc_data->fm_shape.ptr(), data_type == MASTER);
-}
+        // FM
+        {
+            morph_group_1->register_parameter(fm_osc_data->fm_freq.ptr(), data_type == MASTER);
+            morph_group_1->register_parameter(fm_osc_data->fm_swing.ptr(), data_type == MASTER);
+            morph_group_1->register_parameter(fm_osc_data->fm_shape.ptr(), data_type == MASTER);
+        }
 
-// clang-format off
+        // clang-format off
 // FILTERS
 {
     { 
@@ -2320,155 +2326,158 @@ COLD void MoniqueSynthData::init_morph_groups(DATA_TYPES data_type,
                                           data_type == MASTER);
     }
 }
-// clang-format on
+        // clang-format on
 
-// MAIN
-{
-    morph_group_3->register_parameter(volume.ptr(), data_type == MASTER);
-    morph_group_3->register_parameter(env_data->attack.ptr(), data_type == MASTER);
-    morph_group_3->register_parameter(env_data->decay.ptr(), data_type == MASTER);
-    morph_group_3->register_parameter(env_data->sustain.ptr(), data_type == MASTER);
-    morph_group_3->register_parameter(env_data->sustain_time.ptr(), data_type == MASTER);
-    morph_group_3->register_parameter(env_data->release.ptr(), data_type == MASTER);
-    morph_group_3->register_parameter(env_data->shape.ptr(), data_type == MASTER);
+        // MAIN
+        {
+            morph_group_3->register_parameter(volume.ptr(), data_type == MASTER);
+            morph_group_3->register_parameter(env_data->attack.ptr(), data_type == MASTER);
+            morph_group_3->register_parameter(env_data->decay.ptr(), data_type == MASTER);
+            morph_group_3->register_parameter(env_data->sustain.ptr(), data_type == MASTER);
+            morph_group_3->register_parameter(env_data->sustain_time.ptr(), data_type == MASTER);
+            morph_group_3->register_parameter(env_data->release.ptr(), data_type == MASTER);
+            morph_group_3->register_parameter(env_data->shape.ptr(), data_type == MASTER);
 
-    // speed_multi
-}
+            // speed_multi
+        }
 
-// EQ
-{
-    for (int band_id = 0; band_id != SUM_EQ_BANDS; ++band_id)
-    {
-        morph_group_3->register_parameter(eq_data->velocity[band_id].ptr(), data_type == MASTER);
-        morph_group_3->register_parameter(eq_data->envs[band_id]->attack.ptr(),
-                                          data_type == MASTER);
-        morph_group_3->register_parameter(eq_data->envs[band_id]->decay.ptr(), data_type == MASTER);
-        morph_group_3->register_parameter(eq_data->envs[band_id]->sustain.ptr(),
-                                          data_type == MASTER);
-        morph_group_3->register_parameter(eq_data->envs[band_id]->sustain_time.ptr(),
-                                          data_type == MASTER);
-        morph_group_3->register_parameter(eq_data->envs[band_id]->release.ptr(),
-                                          data_type == MASTER);
-        morph_group_3->register_parameter(eq_data->envs[band_id]->shape.ptr(), data_type == MASTER);
+        // EQ
+        {
+            for (int band_id = 0; band_id != SUM_EQ_BANDS; ++band_id)
+            {
+                morph_group_3->register_parameter(eq_data->velocity[band_id].ptr(),
+                                                  data_type == MASTER);
+                morph_group_3->register_parameter(eq_data->envs[band_id]->attack.ptr(),
+                                                  data_type == MASTER);
+                morph_group_3->register_parameter(eq_data->envs[band_id]->decay.ptr(),
+                                                  data_type == MASTER);
+                morph_group_3->register_parameter(eq_data->envs[band_id]->sustain.ptr(),
+                                                  data_type == MASTER);
+                morph_group_3->register_parameter(eq_data->envs[band_id]->sustain_time.ptr(),
+                                                  data_type == MASTER);
+                morph_group_3->register_parameter(eq_data->envs[band_id]->release.ptr(),
+                                                  data_type == MASTER);
+                morph_group_3->register_parameter(eq_data->envs[band_id]->shape.ptr(),
+                                                  data_type == MASTER);
+
+                morph_group_3->register_switch_parameter(eq_data->hold[band_id].bool_ptr(),
+                                                         data_type == MASTER);
+            }
 
-        morph_group_3->register_switch_parameter(eq_data->hold[band_id].bool_ptr(),
-                                                 data_type == MASTER);
-    }
+            morph_group_3->register_parameter(eq_data->bypass.ptr(), data_type == MASTER);
+        }
 
-    morph_group_3->register_parameter(eq_data->bypass.ptr(), data_type == MASTER);
-}
+        // FX
+        {
+            // MAIN
+            morph_group_3->register_parameter(distortion.ptr(), data_type == MASTER);
+            morph_group_3->register_parameter(shape.ptr(), data_type == MASTER);
+            morph_group_3->register_parameter(effect_bypass.ptr(), data_type == MASTER);
+            // REVERB
+            morph_group_3->register_parameter(reverb_data->room.ptr(), data_type == MASTER);
+            morph_group_3->register_parameter(reverb_data->dry_wet_mix.ptr(), data_type == MASTER);
+            morph_group_3->register_parameter(reverb_data->width.ptr(), data_type == MASTER);
+            morph_group_3->register_parameter(reverb_data->pan.ptr(), data_type == MASTER);
+            master_data_->mono_parameters.add(&reverb_data->pan);
+            // DELAY
+            morph_group_3->register_parameter(delay.ptr(), data_type == MASTER);
+            morph_group_3->register_switch_parameter(delay_refexion.int_ptr(), data_type == MASTER);
+            morph_group_3->register_parameter(delay_pan.ptr(), data_type == MASTER);
+            master_data_->mono_parameters.add(&delay_pan);
+            // CHORUS
+            morph_group_3->register_parameter(chorus_data->modulation.ptr(), data_type == MASTER);
+            morph_group_3->register_parameter(chorus_data->pan.ptr(), data_type == MASTER);
+            master_data_->mono_parameters.add(&chorus_data->pan);
+        }
 
-// FX
-{
-    // MAIN
-    morph_group_3->register_parameter(distortion.ptr(), data_type == MASTER);
-    morph_group_3->register_parameter(shape.ptr(), data_type == MASTER);
-    morph_group_3->register_parameter(effect_bypass.ptr(), data_type == MASTER);
-    // REVERB
-    morph_group_3->register_parameter(reverb_data->room.ptr(), data_type == MASTER);
-    morph_group_3->register_parameter(reverb_data->dry_wet_mix.ptr(), data_type == MASTER);
-    morph_group_3->register_parameter(reverb_data->width.ptr(), data_type == MASTER);
-    morph_group_3->register_parameter(reverb_data->pan.ptr(), data_type == MASTER);
-    master_data_->mono_parameters.add(&reverb_data->pan);
-    // DELAY
-    morph_group_3->register_parameter(delay.ptr(), data_type == MASTER);
-    morph_group_3->register_switch_parameter(delay_refexion.int_ptr(), data_type == MASTER);
-    morph_group_3->register_parameter(delay_pan.ptr(), data_type == MASTER);
-    master_data_->mono_parameters.add(&delay_pan);
-    // CHORUS
-    morph_group_3->register_parameter(chorus_data->modulation.ptr(), data_type == MASTER);
-    morph_group_3->register_parameter(chorus_data->pan.ptr(), data_type == MASTER);
-    master_data_->mono_parameters.add(&chorus_data->pan);
-}
+        // ARP
+        {
+            for (int step_id = 0; step_id != SUM_ENV_ARP_STEPS; ++step_id)
+            {
+                morph_group_4->register_switch_parameter(
+                    arp_sequencer_data->tune[step_id].int_ptr(), data_type == MASTER);
+                morph_group_4->register_parameter(arp_sequencer_data->velocity[step_id].ptr(),
+                                                  data_type == MASTER);
+                morph_group_4->register_switch_parameter(
+                    arp_sequencer_data->step[step_id].bool_ptr(), data_type == MASTER);
+            }
+            morph_group_4->register_switch_parameter(arp_sequencer_data->connect.bool_ptr(),
+                                                     data_type == MASTER);
 
-// ARP
-{
-    for (int step_id = 0; step_id != SUM_ENV_ARP_STEPS; ++step_id)
-    {
-        morph_group_4->register_switch_parameter(arp_sequencer_data->tune[step_id].int_ptr(),
-                                                 data_type == MASTER);
-        morph_group_4->register_parameter(arp_sequencer_data->velocity[step_id].ptr(),
-                                          data_type == MASTER);
-        morph_group_4->register_switch_parameter(arp_sequencer_data->step[step_id].bool_ptr(),
-                                                 data_type == MASTER);
-    }
-    morph_group_4->register_switch_parameter(arp_sequencer_data->connect.bool_ptr(),
-                                             data_type == MASTER);
+            {
+                morph_group_4->register_switch_parameter(arp_sequencer_data->shuffle.int_ptr(),
+                                                         data_type == MASTER);
+                morph_group_4->register_switch_parameter(arp_sequencer_data->step_offset.int_ptr(),
+                                                         data_type == MASTER);
+                morph_group_4->register_switch_parameter(arp_sequencer_data->fine_offset.int_ptr(),
+                                                         data_type == MASTER);
+                morph_group_4->register_parameter(glide.ptr(), data_type == MASTER);
+            }
 
-    {
-        morph_group_4->register_switch_parameter(arp_sequencer_data->shuffle.int_ptr(),
-                                                 data_type == MASTER);
-        morph_group_4->register_switch_parameter(arp_sequencer_data->step_offset.int_ptr(),
-                                                 data_type == MASTER);
-        morph_group_4->register_switch_parameter(arp_sequencer_data->fine_offset.int_ptr(),
-                                                 data_type == MASTER);
-        morph_group_4->register_parameter(glide.ptr(), data_type == MASTER);
-    }
+            {
+                // is_on
+                // speed_multi
+                morph_group_4->register_switch_parameter(arp_sequencer_data->connect.bool_ptr(),
+                                                         data_type == MASTER);
+                // morph_group_arp_switchs->register_switch_parameter(
+                // arp_sequencer_data.connect.ptr(), data_type == MASTER  );
+                for (int step_id = 0; step_id != SUM_ENV_ARP_STEPS; ++step_id)
+                {
+                    morph_group_4->register_switch_parameter(
+                        arp_sequencer_data->step[step_id].bool_ptr(), data_type == MASTER);
+                }
+            }
 
-    {
-        // is_on
-        // speed_multi
-        morph_group_4->register_switch_parameter(arp_sequencer_data->connect.bool_ptr(),
-                                                 data_type == MASTER);
-        // morph_group_arp_switchs->register_switch_parameter( arp_sequencer_data.connect.ptr(),
-        // data_type == MASTER  );
-        for (int step_id = 0; step_id != SUM_ENV_ARP_STEPS; ++step_id)
-        {
-            morph_group_4->register_switch_parameter(arp_sequencer_data->step[step_id].bool_ptr(),
-                                                     data_type == MASTER);
+            {
+                morph_group_4->register_switch_parameter(velocity_glide_time.int_ptr(),
+                                                         data_type == MASTER);
+            }
         }
     }
 
+    // MAKE IT HOT
+    // ONLY THE MASTER HAS MORPH SOURCES - OTHERWISE WE BUILD UNLIMITED SOURCES FOR SOURCE
+    if (data_type == MASTER)
     {
-        morph_group_4->register_switch_parameter(velocity_glide_time.int_ptr(),
-                                                 data_type == MASTER);
-    }
-}
-}
-
-// MAKE IT HOT
-// ONLY THE MASTER HAS MORPH SOURCES - OTHERWISE WE BUILD UNLIMITED SOURCES FOR SOURCE
-if (data_type == MASTER)
-{
-    for (int i = 0; i != SUM_MORPHER_GROUPS; ++i)
-    {
-        MoniqueSynthData *morph_data;
-        morph_data = new MoniqueSynthData(static_cast<DATA_TYPES>(MORPH_LEFT), nullptr, nullptr,
-                                          nullptr, nullptr, nullptr, nullptr, this);
-        // hat eine änderungscaskade zur folge!!!
-        morph_data->load_default();
-        left_morph_sources.add(morph_data);
-
-        morph_data = new MoniqueSynthData(static_cast<DATA_TYPES>(MORPH), nullptr, nullptr, nullptr,
-                                          nullptr, nullptr, nullptr, this);
-        // hat eine änderungscaskade zur folge!!!
-        morph_data->load_default();
-        right_morph_sources.add(morph_data);
-    }
-
-    // SETUP THE MORPH GROUP
-    // TODO, do not initialize the unneeded morph groups
-    // TODO, only load and save the needed params
-    morph_group_1->set_sources(left_morph_sources[0]->morph_group_1.get(),
-                               right_morph_sources[0]->morph_group_1.get(), morhp_states[0],
-                               morhp_switch_states[0]);
-    morph_group_2->set_sources(left_morph_sources[1]->morph_group_2.get(),
-                               right_morph_sources[1]->morph_group_2.get(), morhp_states[1],
-                               morhp_switch_states[1]);
-    morph_group_3->set_sources(left_morph_sources[2]->morph_group_3.get(),
-                               right_morph_sources[2]->morph_group_3.get(), morhp_states[2],
-                               morhp_switch_states[2]);
-    morph_group_4->set_sources(left_morph_sources[3]->morph_group_4.get(),
-                               right_morph_sources[3]->morph_group_4.get(), morhp_states[3],
-                               morhp_switch_states[3]);
-
-    for (int morpher_id = 0; morpher_id != SUM_MORPHER_GROUPS; ++morpher_id)
-    {
-        morhp_states[morpher_id].register_listener(this);
-    }
-}
-left_morph_sources.minimiseStorageOverheads();
-right_morph_sources.minimiseStorageOverheads();
+        for (int i = 0; i != SUM_MORPHER_GROUPS; ++i)
+        {
+            MoniqueSynthData *morph_data;
+            morph_data = new MoniqueSynthData(static_cast<DATA_TYPES>(MORPH_LEFT), nullptr, nullptr,
+                                              nullptr, nullptr, nullptr, nullptr, this);
+            // hat eine änderungscaskade zur folge!!!
+            morph_data->load_default();
+            left_morph_sources.add(morph_data);
+
+            morph_data = new MoniqueSynthData(static_cast<DATA_TYPES>(MORPH), nullptr, nullptr,
+                                              nullptr, nullptr, nullptr, nullptr, this);
+            // hat eine änderungscaskade zur folge!!!
+            morph_data->load_default();
+            right_morph_sources.add(morph_data);
+        }
+
+        // SETUP THE MORPH GROUP
+        // TODO, do not initialize the unneeded morph groups
+        // TODO, only load and save the needed params
+        morph_group_1->set_sources(left_morph_sources[0]->morph_group_1.get(),
+                                   right_morph_sources[0]->morph_group_1.get(), morhp_states[0],
+                                   morhp_switch_states[0]);
+        morph_group_2->set_sources(left_morph_sources[1]->morph_group_2.get(),
+                                   right_morph_sources[1]->morph_group_2.get(), morhp_states[1],
+                                   morhp_switch_states[1]);
+        morph_group_3->set_sources(left_morph_sources[2]->morph_group_3.get(),
+                                   right_morph_sources[2]->morph_group_3.get(), morhp_states[2],
+                                   morhp_switch_states[2]);
+        morph_group_4->set_sources(left_morph_sources[3]->morph_group_4.get(),
+                                   right_morph_sources[3]->morph_group_4.get(), morhp_states[3],
+                                   morhp_switch_states[3]);
+
+        for (int morpher_id = 0; morpher_id != SUM_MORPHER_GROUPS; ++morpher_id)
+        {
+            morhp_states[morpher_id].register_listener(this);
+        }
+    }
+    left_morph_sources.minimiseStorageOverheads();
+    right_morph_sources.minimiseStorageOverheads();
 }
 const juce::String &MoniqueSynthData::get_morph_source_name(int id_abs_) const noexcept
 {
diff --git a/src/core/monique_core_Synth.cpp b/src/core/monique_core_Synth.cpp
index fb4424f9..cbea7b1d 100644
--- a/src/core/monique_core_Synth.cpp
+++ b/src/core/monique_core_Synth.cpp
@@ -1347,8 +1347,7 @@ class LFO : public RuntimeListener
   public:
     //==========================================================================
     LFO(RuntimeNotifyer *const notifyer_, MoniqueSynthData *synth_data_, LFOData *lfo_data_,
-        const float *const sine_lookup_)
-    noexcept
+        const float *const sine_lookup_) noexcept
         : RuntimeListener(notifyer_),
 
           sine_lookup(sine_lookup_),
diff --git a/src/core/monique_core_Synth.h b/src/core/monique_core_Synth.h
index 60c8ced3..ab650080 100644
--- a/src/core/monique_core_Synth.h
+++ b/src/core/monique_core_Synth.h
@@ -57,7 +57,7 @@ class RuntimeNotifyer;
 class MoniqueSynthesizer;
 
 #define TABLESIZE_MULTI 1000
-//#define LOOKUP_TABLE_SIZE int(float_Pi*TABLESIZE_MULTI*2)
+// #define LOOKUP_TABLE_SIZE int(float_Pi*TABLESIZE_MULTI*2)
 static const int LOOKUP_TABLE_SIZE = int(juce::MathConstants<float>::twoPi * TABLESIZE_MULTI);
 
 class MoniqueSynthesiserVoice : public juce::SynthesiserVoice
diff --git a/src/ui/monique_ui_AmpPainter.cpp b/src/ui/monique_ui_AmpPainter.cpp
index 86b7eb1d..0a36dd16 100644
--- a/src/ui/monique_ui_AmpPainter.cpp
+++ b/src/ui/monique_ui_AmpPainter.cpp
@@ -230,7 +230,8 @@ void Monique_Ui_AmpPainter::paint(juce::Graphics &g)
                 g.setColour (colours.label_text_colour.withAlpha(0.3f));
                 g.fillRect (paint_start_offset_x, int(paint_start_offset_y+height/2), width, 1 );
             */
-        } {
+        }
+        {
 #include "mono_ui_includeHacks_BEGIN.h"
             WIDTH_AND_HIGHT_FACTORS
 
diff --git a/src/ui/monique_ui_ENVPopup.cpp b/src/ui/monique_ui_ENVPopup.cpp
index d7faeebd..c440cd66 100644
--- a/src/ui/monique_ui_ENVPopup.cpp
+++ b/src/ui/monique_ui_ENVPopup.cpp
@@ -280,9 +280,9 @@ Monique_Ui_ENVPopup::Monique_Ui_ENVPopup(Monique_Ui_Refresher *ui_refresher_,
                                          Monique_Ui_Mainwindow *const parent_,
                                          ENVData *const env_data_, Parameter *const sustain_,
                                          bool left_, bool has_negative_sustain_)
-    : Monique_Ui_Refreshable(ui_refresher_), juce::DropShadower(juce::DropShadow(
-                                                 juce::Colours::black.withAlpha(0.8f), 10,
-                                                 juce::Point<int>(10, 10))),
+    : Monique_Ui_Refreshable(ui_refresher_),
+      juce::DropShadower(
+          juce::DropShadow(juce::Colours::black.withAlpha(0.8f), 10, juce::Point<int>(10, 10))),
       original_w(710), original_h(190), left(left_), parent(parent_), env_data(env_data_),
       sustain(sustain_)
 {
diff --git a/src/ui/monique_ui_LookAndFeel.cpp b/src/ui/monique_ui_LookAndFeel.cpp
index f67ead86..e417a536 100644
--- a/src/ui/monique_ui_LookAndFeel.cpp
+++ b/src/ui/monique_ui_LookAndFeel.cpp
@@ -2263,11 +2263,11 @@ void UiLookAndFeel::drawTooltip(juce::Graphics &g, const juce::String &text, int
 {
     g.fillAll(findColour(juce::TooltipWindow::backgroundColourId));
 
-    //#if ! JUCE_MAC // The mac windows already have a non-optional 1 pix outline, so don't double
-    // it here..
+    // #if ! JUCE_MAC // The mac windows already have a non-optional 1 pix outline, so don't double
+    //  it here..
     g.setColour(findColour(juce::TooltipWindow::outlineColourId));
     g.drawRect(0, 0, width, height, 1);
-    //#endif
+    // #endif
 
     juce::Rectangle<float> rect = juce::Rectangle<float>((float)width, (float)height);
     juce::TextLayout tl = LookAndFeelHelpers::layoutTooltipText(
diff --git a/src/ui/monique_ui_MFOPopup.cpp b/src/ui/monique_ui_MFOPopup.cpp
index ceb6a725..36a50e63 100644
--- a/src/ui/monique_ui_MFOPopup.cpp
+++ b/src/ui/monique_ui_MFOPopup.cpp
@@ -196,9 +196,9 @@ void Monique_Ui_MFOPopup::sliderClicked(juce::Slider *s_)
 Monique_Ui_MFOPopup::Monique_Ui_MFOPopup(Monique_Ui_Refresher *ui_refresher_,
                                          Monique_Ui_Mainwindow *const parent_,
                                          LFOData *const mfo_data_, COLOUR_THEMES theme_)
-    : Monique_Ui_Refreshable(ui_refresher_), juce::DropShadower(juce::DropShadow(
-                                                 juce::Colours::black.withAlpha(0.8f), 10,
-                                                 juce::Point<int>(10, 10))),
+    : Monique_Ui_Refreshable(ui_refresher_),
+      juce::DropShadower(
+          juce::DropShadow(juce::Colours::black.withAlpha(0.8f), 10, juce::Point<int>(10, 10))),
       original_w(540), original_h(190), parent(parent_), mfo_data(mfo_data_)
 {
     ui_refresher_->synth_data->midi_lfo_wave.set_value_without_notification(mfo_data_->wave);
diff --git a/src/ui/monique_ui_MidiLearnPopup.cpp b/src/ui/monique_ui_MidiLearnPopup.cpp
index 8b182fb0..cdd5775c 100644
--- a/src/ui/monique_ui_MidiLearnPopup.cpp
+++ b/src/ui/monique_ui_MidiLearnPopup.cpp
@@ -66,9 +66,9 @@ void Monique_Ui_MainwindowPopup::update_positions()
 Monique_Ui_MainwindowPopup::Monique_Ui_MainwindowPopup(Monique_Ui_Refresher *ui_refresher_,
                                                        Monique_Ui_Mainwindow *const parent_,
                                                        MIDIControl *midi_control_)
-    : Monique_Ui_Refreshable(ui_refresher_), juce::DropShadower(juce::DropShadow(
-                                                 juce::Colours::black.withAlpha(0.8f), 10,
-                                                 juce::Point<int>(10, 10))),
+    : Monique_Ui_Refreshable(ui_refresher_),
+      juce::DropShadower(
+          juce::DropShadow(juce::Colours::black.withAlpha(0.8f), 10, juce::Point<int>(10, 10))),
       original_w(80), original_h(95), parent(parent_), _midi_control(midi_control_)
 {
     setOwner(this);
diff --git a/src/ui/monique_ui_OptionPopup.cpp b/src/ui/monique_ui_OptionPopup.cpp
index d256dc05..4620279f 100644
--- a/src/ui/monique_ui_OptionPopup.cpp
+++ b/src/ui/monique_ui_OptionPopup.cpp
@@ -58,9 +58,9 @@ void Monique_Ui_OptionPopup::set_infos(juce::StringRef text_a, juce::StringRef t
 Monique_Ui_OptionPopup::Monique_Ui_OptionPopup(Monique_Ui_Refresher *ui_refresher_,
                                                Monique_Ui_Mainwindow *const parent_,
                                                BoolParameter *param_a_, BoolParameter *param_b_)
-    : Monique_Ui_Refreshable(ui_refresher_), juce::DropShadower(juce::DropShadow(
-                                                 juce::Colours::black.withAlpha(0.8f), 10,
-                                                 juce::Point<int>(10, 10))),
+    : Monique_Ui_Refreshable(ui_refresher_),
+      juce::DropShadower(
+          juce::DropShadow(juce::Colours::black.withAlpha(0.8f), 10, juce::Point<int>(10, 10))),
       param_a(param_a_), param_b(param_b_), original_w(140), original_h(90), parent(parent_)
 {
     setOwner(this);
diff --git a/src/ui/mono_ui_includeHacks_BEGIN.h b/src/ui/mono_ui_includeHacks_BEGIN.h
index 78a25074..bb87ddc5 100644
--- a/src/ui/mono_ui_includeHacks_BEGIN.h
+++ b/src/ui/mono_ui_includeHacks_BEGIN.h
@@ -90,4 +90,4 @@ COLOUR_REPLACEMENT_START
 #define lineTo(x, y)                                                                               \
     lineTo(x > 2 ? float(x) * width_factor : x, y > 2 ? float(y) * height_factor : y)
 #define quadraticTo(x, y, x2, y2)                                                                  \
-    quadraticTo(x *(1.0f / width_factor, y * height_factor, x2 * width_factor, y2 * height_factor))
+    quadraticTo(x * (1.0f / width_factor, y * height_factor, x2 * width_factor, y2 * height_factor))