Dimethoxy
diff --git a/‎README.md‎
Lines changed: 23 additions & 0 deletions b/‎README.md‎
Lines changed: 23 additions & 0 deletions
diff --git a/‎app/AbstractPluginEditor.h‎
Lines changed: 219 additions & 32 deletions b/‎app/AbstractPluginEditor.h‎
Lines changed: 219 additions & 32 deletions
@@ -1,5 +1,27 @@
 # Dimethoxy Library
 
+<<<<<<< HEAD
+> [!WARNING]
+> This library is under active development and primarily intended for use within Dimethoxy projects \
+> External use is unsupported.
+
+The Dimethoxy Library is the core engine behind all Dimethoxy plugins — a modular C++ codebase built for high-performance digital signal processing and plugin development.
+From custom DSP algorithms to GUI systems and utility wrappers, this library powers nearly every aspect of our audio tools.
+
+## Features
+- 🚀 High-performance DSP tailored for aggressive electronic music (Hardstyle, Hardcore, Uptempo, etc.)
+- 🎛️ Modular components for efficient plugin development
+- 🧱 Shared utilities, math, parameter handling, and UI helpers
+- 🧪 Designed for maintainability and extensibility across multiple projects
+
+## Used In
+- [Disflux](https://github.com/Dimethoxy/Disflux) — Transient Smearing Audio Plugin for Windows, MacOS and Linux 
+- [Oscilloscope](https://github.com/Dimethoxy/Oscilloscope) — Work in Progress Oscilloscope Audio Plugin for Windows, MacOS and Linux 
+
+
+## License
+This project is licensed under AGPLv3. \
+=======
 > [!CAUTION]
 > **Do NOT use this library in your own projects if you expect support.** <br>
 > We will **not fix your issues, bugs, or integration problems** if you use it externally.
@@ -27,4 +49,5 @@ If it breaks, you own the pieces.
 ## License
 
 This project is licensed under AGPLv3.
+>>>>>>> a5e5c670fddd956080480f24e1397fa5872f9993
 Any project using **any** part of this library **must** also be licensed under AGPLv3 or a compatible open-source license.
@@ -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,7 +211,30 @@ class AbstractPluginEditor
     });
   }
 
-  ~AbstractPluginEditor() override = default;
+  // 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
+    if (openGLContext.isAttached()) {
+      openGLContext.detach();
+    }
+
+    // Stop the debounce timer if it's running
+    stopTimer();
+  }
 
   //==============================================================================
   // JUCE overrides
@@ -144,11 +284,6 @@ class AbstractPluginEditor
     detachCompositorForResize();
   }
 
-  //==============================================================================
-  // Handle peer creation for Windows Direct2D setup
-
-  void parentHierarchyChanged() override {}
-
   //==============================================================================
   // JUCE overrides
 
@@ -167,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; }
@@ -209,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);
     }
   }
 
@@ -324,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;
@@ -340,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