Merge commit '46c429d87f916e2ae1f29bc8afa6c6f06ceca76b' into development

Author: HessDavid

src/dmt/app/AbstractPluginEditor.h

@@ -23,18 +23,100 @@ class AbstractPluginEditor
   using OpenGLContext = juce::OpenGLContext;
 
 public:
+  // Window sizing mode
+  enum class WindowMode
+  {
+    Fixed,
+    Dynamic
+  };
+
+  // Configuration for window sizing behavior
+  struct WindowConfig
+  {
+    int baseWidth;
+    int baseHeight;
+    WindowMode mode = WindowMode::Fixed;
+    float minSizeMultiplier = 0.5f;
+    float maxSizeMultiplier = 2.0f;
+    float minAspectRatio = 0.5f;
+    float maxAspectRatio = 2.0f;
+    int dynamicStartWidth = -1;
+    int dynamicStartHeight = -1;
+  };
+
+  // Custom constrainer that enforces aspect ratio bounds (min/max aspect
+  // ratios)
+  class AspectRatioBoundsConstrainer : public juce::ComponentBoundsConstrainer
+  {
+  public:
+    AspectRatioBoundsConstrainer(float minRatio,
+                                 float maxRatio,
+                                 int baseW,
+                                 int baseH,
+                                 int headerH)
+      : minAspectRatio(minRatio)
+      , maxAspectRatio(maxRatio)
+      , baseWidth(baseW)
+      , baseHeight(baseH)
+      , headerHeight(headerH)
+    {
+    }
+
+    void checkBounds(juce::Rectangle<int>& bounds,
+                     const juce::Rectangle<int>& previousBounds,
+                     const juce::Rectangle<int>& limits,
+                     bool isStretchingTop,
+                     bool isStretchingLeft,
+                     bool isStretchingBottom,
+                     bool isStretchingRight) override
+    {
+      // First apply default size limits
+      ComponentBoundsConstrainer::checkBounds(bounds,
+                                              previousBounds,
+                                              limits,
+                                              isStretchingTop,
+                                              isStretchingLeft,
+                                              isStretchingBottom,
+                                              isStretchingRight);
+
+      // Then enforce aspect ratio bounds
+      int w = bounds.getWidth();
+      int h = bounds.getHeight();
+      double currentRatio = (double)w / (double)h;
+
+      if (currentRatio < minAspectRatio) {
+        // Too narrow - increase width
+        w = static_cast<int>(h * minAspectRatio);
+      } else if (currentRatio > maxAspectRatio) {
+        // Too wide - decrease width
+        w = static_cast<int>(h * maxAspectRatio);
+      }
+
+      bounds.setSize(w, h);
+    }
+
+  private:
+    float minAspectRatio, maxAspectRatio;
+    int baseWidth, baseHeight, headerHeight;
+  };
+
   // Strategy function type for layout initialization
   using LayoutInitializer = std::function<void(dmt::gui::window::Layout&)>;
 
+  // Primary constructor with WindowConfig
   AbstractPluginEditor(dmt::app::AbstractPluginProcessor& _p,
                        juce::String _name,
-                       int _baseWidth,
-                       int _baseHeight,
+                       const WindowConfig& _windowConfig,
                        LayoutInitializer&& _layoutInit)
     : juce::AudioProcessorEditor(&_p)
     , p(_p)
-    , baseWidth(_baseWidth)
-    , baseHeight(_baseHeight)
+    , baseWidth(_windowConfig.baseWidth)
+    , baseHeight(_windowConfig.baseHeight)
+    , windowMode(_windowConfig.mode)
+    , minSizeMultiplier(_windowConfig.minSizeMultiplier)
+    , maxSizeMultiplier(_windowConfig.maxSizeMultiplier)
+    , minAspectRatio(_windowConfig.minAspectRatio)
+    , maxAspectRatio(_windowConfig.maxAspectRatio)
     , sizeFactor(p.sizeFactor)
     , mainLayout({}, {})
     , compositor(_name, mainLayout, p.apvts, p.properties, sizeFactor)
@@ -81,11 +163,46 @@ class AbstractPluginEditor
 
 #endif
 
-    setConstraints(baseWidth, baseHeight + headerHeight);
+    // Configure window constraints based on mode
+    if (windowMode == WindowMode::Dynamic) {
+      // Create custom constrainer for aspect ratio bounds
+      aspectRatioBoundsConstrainer =
+        std::make_unique<AspectRatioBoundsConstrainer>(
+          minAspectRatio,
+          maxAspectRatio,
+          baseWidth,
+          baseHeight,
+          static_cast<int>(dmt::Settings::Header::height));
+      setConstrainer(aspectRatioBoundsConstrainer.get());
+      activateDynamicWindowSize(minSizeMultiplier, maxSizeMultiplier);
+    } else {
+      setConstraints(baseWidth, baseHeight + headerHeight);
+    }
     setResizable(false, true);
 
-    const auto startWidth = baseWidth * sizeFactor;
-    const auto startHeight = (baseHeight + headerHeight) * sizeFactor;
+    // Resolve initial window size using priority order
+    int initialWidth = baseWidth;
+    int initialHeight = baseHeight + headerHeight;
+
+    // Priority 1: Check for saved window state
+    int savedWidth = p.getSavedWindowWidth();
+    int savedHeight = p.getSavedWindowHeight();
+    if (savedWidth > 0 && savedHeight > 0) {
+      initialWidth = savedWidth;
+      initialHeight = savedHeight;
+      isHeaderHidden = p.getSavedHeaderHiddenState();
+    }
+    // Priority 2: Use dynamic start dimensions if in dynamic mode
+    else if (windowMode == WindowMode::Dynamic &&
+             _windowConfig.dynamicStartWidth > 0 &&
+             _windowConfig.dynamicStartHeight > 0) {
+      initialWidth = _windowConfig.dynamicStartWidth;
+      initialHeight = _windowConfig.dynamicStartHeight;
+    }
+    // Priority 3: Use base dimensions (default, already set above)
+
+    const auto startWidth = initialWidth * sizeFactor;
+    const auto startHeight = initialHeight * sizeFactor;
     setSize(startWidth, startHeight);
 
     // Set the callback for header visibility changes
@@ -94,6 +211,20 @@ class AbstractPluginEditor
     });
   }
 
+  // Deprecated: Use the WindowConfig constructor instead
+  [[deprecated("Use constructor with WindowConfig parameter instead")]]
+  AbstractPluginEditor(dmt::app::AbstractPluginProcessor& _p,
+                       juce::String _name,
+                       int _baseWidth,
+                       int _baseHeight,
+                       LayoutInitializer&& _layoutInit)
+    : AbstractPluginEditor(_p,
+                           _name,
+                           WindowConfig{ _baseWidth, _baseHeight },
+                           std::forward<LayoutInitializer>(_layoutInit))
+  {
+  }
+
   ~AbstractPluginEditor()
   {
     // Ensure OpenGL context is detached before destruction
@@ -153,11 +284,6 @@ class AbstractPluginEditor
     detachCompositorForResize();
   }
 
-  //==============================================================================
-  // Handle peer creation for Windows Direct2D setup
-
-  void parentHierarchyChanged() override {}
-
   //==============================================================================
   // JUCE overrides
 
@@ -176,12 +302,51 @@ class AbstractPluginEditor
     }
   }
 
+  void activateDynamicWindowSize(float minRatio, float maxRatio)
+  {
+    if (auto* constrainer = this->getConstrainer()) {
+      constrainer->setFixedAspectRatio(0.0); // Allow variable aspect ratio
+      // Only limit height; width is controlled by aspect ratio bounds
+      const auto minHeight = static_cast<int>(baseHeight * minRatio);
+      const auto maxHeight = static_cast<int>(baseHeight * maxRatio);
+      // Calculate width range based on aspect ratio bounds and height range
+      const auto minWidth = static_cast<int>(minHeight * minAspectRatio);
+      const auto maxWidth = static_cast<int>(maxHeight * maxAspectRatio);
+      constrainer->setSizeLimits(minWidth, minHeight, maxWidth, maxHeight);
+    } else {
+      jassertfalse; // Constrainer not set
+    }
+  }
+
   void handleHeaderVisibilityChange(bool isHeaderVisible)
   {
+    isHeaderHidden = !isHeaderVisible;
     const int adjustedHeight =
       isHeaderVisible ? baseHeight + headerHeight : baseHeight;
-    setConstraints(baseWidth, adjustedHeight);
-    setSize(baseWidth * sizeFactor, adjustedHeight * sizeFactor);
+
+    if (windowMode == WindowMode::Dynamic) {
+      // In dynamic mode, recalculate size limits but keep aspect ratio bounds
+      if (auto* constrainer = this->getConstrainer()) {
+        const auto minHeight =
+          static_cast<int>(adjustedHeight * minSizeMultiplier);
+        const auto maxHeight =
+          static_cast<int>(adjustedHeight * maxSizeMultiplier);
+        const auto minWidth = static_cast<int>(minHeight * minAspectRatio);
+        const auto maxWidth = static_cast<int>(maxHeight * maxAspectRatio);
+        constrainer->setSizeLimits(minWidth, minHeight, maxWidth, maxHeight);
+      }
+      // Keep width the same, only adjust height by header height
+      int heightAdjustment = static_cast<int>(
+        (isHeaderVisible ? headerHeight : -headerHeight) * sizeFactor);
+      setSize(getWidth(), getHeight() + heightAdjustment);
+    } else {
+      // In fixed mode, enforce fixed aspect ratio
+      setConstraints(baseWidth, adjustedHeight);
+      setSize(baseWidth * sizeFactor, adjustedHeight * sizeFactor);
+    }
+
+    // Save the header visibility state
+    p.saveWindowState(getWidth(), getHeight(), isHeaderHidden);
   }
 
   dmt::gui::window::Layout& getMainLayout() { return mainLayout; }
@@ -218,30 +383,36 @@ class AbstractPluginEditor
   void attachCompositorAfterResize()
   {
     if (!compositorAttached) {
-      // Snap to the correct aspect ratio, considering header visibility
-      auto bounds = getLocalBounds();
-      bool headerVisible = compositor.isHeaderVisible();
-      int aspectHeight =
-        headerVisible ? (baseHeight + headerHeight) : baseHeight;
-      const double aspect = (double)baseWidth / (double)aspectHeight;
-      int w = bounds.getWidth();
-      int h = bounds.getHeight();
-      double currentAspect = (double)w / (double)h;
-
-      if (currentAspect > aspect) {
-        // Too wide, adjust width
-        w = static_cast<int>(h * aspect);
-      } else if (currentAspect < aspect) {
-        // Too tall, adjust height
-        h = static_cast<int>(w / aspect);
+      // For fixed mode, snap to the correct aspect ratio
+      // For dynamic mode, keep the current size as-is
+      if (windowMode == WindowMode::Fixed) {
+        auto bounds = getLocalBounds();
+        bool headerVisible = compositor.isHeaderVisible();
+        int aspectHeight =
+          headerVisible ? (baseHeight + headerHeight) : baseHeight;
+        const double aspect = (double)baseWidth / (double)aspectHeight;
+        int w = bounds.getWidth();
+        int h = bounds.getHeight();
+        double currentAspect = (double)w / (double)h;
+
+        if (currentAspect > aspect) {
+          // Too wide, adjust width
+          w = static_cast<int>(h * aspect);
+        } else if (currentAspect < aspect) {
+          // Too tall, adjust height
+          h = static_cast<int>(w / aspect);
+        }
+        setSize(w, h);
       }
-      setSize(w, h);
 
       // Set compositor bounds to fill the editor
       addAndMakeVisible(compositor);
       compositor.setBounds(getLocalBounds());
       compositorAttached = true;
       repaint();
+
+      // Save the current window state after size correction
+      p.saveWindowState(getWidth(), getHeight(), isHeaderHidden);
     }
   }
 
@@ -333,6 +504,12 @@ class AbstractPluginEditor
   const int& headerHeight = dmt::Settings::Header::height;
   const int baseWidth;
   const int baseHeight;
+  WindowMode windowMode = WindowMode::Fixed;
+  float minSizeMultiplier = 0.5f;
+  float maxSizeMultiplier = 2.0f;
+  float minAspectRatio = 0.5f;
+  float maxAspectRatio = 2.0f;
+  bool isHeaderHidden = false;
   int lastWidth = baseWidth;
   int lastHeight = baseHeight;
   double ratio = baseWidth / baseHeight;
@@ -349,6 +526,7 @@ class AbstractPluginEditor
   dmt::gui::window::Compositor compositor;
 
   OpenGLContext openGLContext;
+  std::unique_ptr<AspectRatioBoundsConstrainer> aspectRatioBoundsConstrainer;
   JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(AbstractPluginEditor)
 };
 } // namespace app

src/dmt/app/AbstractPluginProcessor.h

@@ -12,7 +12,9 @@ class AbstractPluginProcessor : public juce::AudioProcessor
   //==============================================================================
   AbstractPluginProcessor(
     std::function<juce::AudioProcessorValueTreeState::ParameterLayout()>
-      createParameterLayout)
+      createParameterLayout,
+    dmt::configuration::SettingsOverrides overrides = {},
+    dmt::configuration::SettingsReplacements replacements = {})
     : AudioProcessor(
         BusesProperties()
 #if !JucePlugin_IsMidiEffect
@@ -27,7 +29,7 @@ class AbstractPluginProcessor : public juce::AudioProcessor
 #if PERFETTO
     MelatoninPerfetto::get().beginSession();
 #endif
-    properties.initialize();
+    properties.initialize(overrides, replacements);
   }
 
   //==============================================================================
@@ -156,6 +158,31 @@ class AbstractPluginProcessor : public juce::AudioProcessor
   float getSizeFactor() const { return sizeFactor; }
   void setSizeFactor(float newSize) { sizeFactor = newSize; }
 
+  //==============================================================================
+  // Window State Management
+
+  void saveWindowState(int width, int height, bool isHeaderHidden)
+  {
+    apvts.state.setProperty("windowWidth", width, nullptr);
+    apvts.state.setProperty("windowHeight", height, nullptr);
+    apvts.state.setProperty("isHeaderHidden", isHeaderHidden, nullptr);
+  }
+
+  int getSavedWindowWidth() const
+  {
+    return static_cast<int>(apvts.state.getProperty("windowWidth", -1));
+  }
+
+  int getSavedWindowHeight() const
+  {
+    return static_cast<int>(apvts.state.getProperty("windowHeight", -1));
+  }
+
+  bool getSavedHeaderHiddenState() const
+  {
+    return static_cast<bool>(apvts.state.getProperty("isHeaderHidden", false));
+  }
+
   //==============================================================================
 private:
 #if PERFETTO