git subrepo clone --branch=sono6good https://github.com/essej/JUCE.git deps/juce

subrepo:
  subdir:   "deps/juce"
  merged:   "b13f9084e"
upstream:
  origin:   "https://github.com/essej/JUCE.git"
  branch:   "sono6good"
  commit:   "b13f9084e"
git-subrepo:
  version:  "0.4.3"
  origin:   "https://github.com/ingydotnet/git-subrepo.git"
  commit:   "2f68596"

deps/juce/modules/juce_gui_extra/misc/juce_AnimatedAppComponent.cpp

@@ -0,0 +1,54 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+AnimatedAppComponent::AnimatedAppComponent()
+    : lastUpdateTime (Time::getCurrentTime()), totalUpdates (0)
+{
+    setOpaque (true);
+}
+
+void AnimatedAppComponent::setFramesPerSecond (int framesPerSecond)
+{
+    jassert (framesPerSecond > 0 && framesPerSecond < 1000);
+    startTimerHz (framesPerSecond);
+}
+
+int AnimatedAppComponent::getMillisecondsSinceLastUpdate() const noexcept
+{
+    return (int) (Time::getCurrentTime() - lastUpdateTime).inMilliseconds();
+}
+
+void AnimatedAppComponent::timerCallback()
+{
+    ++totalUpdates;
+    update();
+    repaint();
+    lastUpdateTime = Time::getCurrentTime();
+}
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_AnimatedAppComponent.h

@@ -0,0 +1,77 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+//==============================================================================
+/**
+    A base class for writing simple one-page graphical apps.
+
+    A subclass can inherit from this and implement just a few methods such as
+    paint() and mouse-handling. The base class provides some simple abstractions
+    to take care of continuously repainting itself.
+
+    @tags{GUI}
+*/
+class AnimatedAppComponent   : public Component,
+                               private Timer
+{
+public:
+    AnimatedAppComponent();
+
+    /** Your subclass can call this to start a timer running which will
+        call update() and repaint the component at the given frequency.
+    */
+    void setFramesPerSecond (int framesPerSecond);
+
+    /** Called periodically, at the frequency specified by setFramesPerSecond().
+        This is a the best place to do things like advancing animation parameters,
+        checking the mouse position, etc.
+    */
+    virtual void update() = 0;
+
+    /** Returns the number of times that update() has been called since the component
+        started running.
+    */
+    int getFrameCounter() const noexcept        { return totalUpdates; }
+
+    /** When called from update(), this returns the number of milliseconds since the
+        last update call.
+        This might be useful for accurately timing animations, etc.
+    */
+    int getMillisecondsSinceLastUpdate() const noexcept;
+
+private:
+    //==============================================================================
+    Time lastUpdateTime;
+    int totalUpdates;
+
+    void timerCallback() override;
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AnimatedAppComponent)
+};
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_AppleRemote.h

@@ -0,0 +1,117 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+//==============================================================================
+#if JUCE_MAC || DOXYGEN
+/**
+    Receives events from an Apple IR remote control device (Only available in OSX!).
+
+    To use it, just create a subclass of this class, implementing the buttonPressed()
+    callback, then call start() and stop() to start or stop receiving events.
+
+    @tags{GUI}
+*/
+class JUCE_API  AppleRemoteDevice
+{
+public:
+    //==============================================================================
+    AppleRemoteDevice();
+    virtual ~AppleRemoteDevice();
+
+    //==============================================================================
+    /** The set of buttons that may be pressed.
+        @see buttonPressed
+    */
+    enum ButtonType
+    {
+        menuButton = 0,     /**< The menu button (if it's held for a short time). */
+        playButton,         /**< The play button. */
+        plusButton,         /**< The plus or volume-up button. */
+        minusButton,        /**< The minus or volume-down button. */
+        rightButton,        /**< The right button (if it's held for a short time). */
+        leftButton,         /**< The left button (if it's held for a short time). */
+        rightButton_Long,   /**< The right button (if it's held for a long time). */
+        leftButton_Long,    /**< The menu button (if it's held for a long time). */
+        menuButton_Long,    /**< The menu button (if it's held for a long time). */
+        playButtonSleepMode,
+        switched
+    };
+
+    //==============================================================================
+    /** Override this method to receive the callback about a button press.
+
+        The callback will happen on the application's message thread.
+
+        Some buttons trigger matching up and down events, in which the isDown parameter
+        will be true and then false. Others only send a single event when the
+        button is pressed.
+    */
+    virtual void buttonPressed (ButtonType buttonId, bool isDown) = 0;
+
+    //==============================================================================
+    /** Starts the device running and responding to events.
+
+        Returns true if it managed to open the device.
+
+        @param inExclusiveMode  if true, the remote will be grabbed exclusively for this app,
+                                and will not be available to any other part of the system. If
+                                false, it will be shared with other apps.
+        @see stop
+    */
+    bool start (bool inExclusiveMode);
+
+    /** Stops the device running.
+        @see start
+    */
+    void stop();
+
+    /** Returns true if the device has been started successfully.
+    */
+    bool isActive() const;
+
+    /** Returns the ID number of the remote, if it has sent one.
+    */
+    int getRemoteId() const                     { return remoteId; }
+
+    //==============================================================================
+    /** @internal */
+    void handleCallbackInternal();
+
+private:
+    void* device;
+    void* queue;
+    int remoteId;
+
+    bool open (bool openInExclusiveMode);
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AppleRemoteDevice)
+};
+
+#endif
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_BubbleMessageComponent.cpp

@@ -0,0 +1,124 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+BubbleMessageComponent::BubbleMessageComponent (int fadeOutLengthMs)
+    : fadeOutLength (fadeOutLengthMs), mouseClickCounter (0),
+      expiryTime (0), deleteAfterUse (false)
+{
+}
+
+BubbleMessageComponent::~BubbleMessageComponent()
+{
+}
+
+void BubbleMessageComponent::showAt (const Rectangle<int>& pos,
+                                     const AttributedString& text,
+                                     const int numMillisecondsBeforeRemoving,
+                                     const bool removeWhenMouseClicked,
+                                     const bool deleteSelfAfterUse)
+{
+    createLayout (text);
+    setPosition (pos);
+    init (numMillisecondsBeforeRemoving, removeWhenMouseClicked, deleteSelfAfterUse);
+}
+
+void BubbleMessageComponent::showAt (Component* const component,
+                                     const AttributedString& text,
+                                     const int numMillisecondsBeforeRemoving,
+                                     const bool removeWhenMouseClicked,
+                                     const bool deleteSelfAfterUse)
+{
+    createLayout (text);
+    setPosition (component);
+    init (numMillisecondsBeforeRemoving, removeWhenMouseClicked, deleteSelfAfterUse);
+}
+
+void BubbleMessageComponent::createLayout (const AttributedString& text)
+{
+    textLayout.createLayoutWithBalancedLineLengths (text, 256);
+}
+
+void BubbleMessageComponent::init (const int numMillisecondsBeforeRemoving,
+                                   const bool removeWhenMouseClicked,
+                                   const bool deleteSelfAfterUse)
+{
+    setAlpha (1.0f);
+    setVisible (true);
+    deleteAfterUse = deleteSelfAfterUse;
+
+    expiryTime = numMillisecondsBeforeRemoving > 0
+                    ? (Time::getMillisecondCounter() + (uint32) numMillisecondsBeforeRemoving) : 0;
+
+    mouseClickCounter = Desktop::getInstance().getMouseButtonClickCounter();
+
+    if (! (removeWhenMouseClicked && isShowing()))
+        mouseClickCounter += 0xfffff;
+
+    startTimer (77);
+    repaint();
+}
+
+const float bubblePaddingX = 20.0f;
+const float bubblePaddingY = 14.0f;
+
+void BubbleMessageComponent::getContentSize (int& w, int& h)
+{
+    w = (int) (bubblePaddingX + textLayout.getWidth());
+    h = (int) (bubblePaddingY + textLayout.getHeight());
+}
+
+void BubbleMessageComponent::paintContent (Graphics& g, int w, int h)
+{
+    g.setColour (findColour (TooltipWindow::textColourId));
+
+    textLayout.draw (g, Rectangle<float> (bubblePaddingX / 2.0f, bubblePaddingY / 2.0f,
+                                          (float) w - bubblePaddingX, (float) h - bubblePaddingY));
+}
+
+void BubbleMessageComponent::timerCallback()
+{
+    if (Desktop::getInstance().getMouseButtonClickCounter() > mouseClickCounter)
+        hide (false);
+    else if (expiryTime != 0 && Time::getMillisecondCounter() > expiryTime)
+        hide (true);
+}
+
+void BubbleMessageComponent::hide (const bool fadeOut)
+{
+    stopTimer();
+
+    if (fadeOut)
+        Desktop::getInstance().getAnimator().fadeOut (this, fadeOutLength);
+    else
+        setVisible (false);
+
+    if (deleteAfterUse)
+        delete this;
+}
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_BubbleMessageComponent.h

@@ -0,0 +1,125 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+//==============================================================================
+/**
+    A speech-bubble component that displays a short message.
+
+    This can be used to show a message with the tail of the speech bubble
+    pointing to a particular component or location on the screen.
+
+    @see BubbleComponent
+
+    @tags{GUI}
+*/
+class JUCE_API  BubbleMessageComponent  : public BubbleComponent,
+                                          private Timer
+{
+public:
+    //==============================================================================
+    /** Creates a bubble component.
+
+        After creating one a BubbleComponent, do the following:
+        - add it to an appropriate parent component, or put it on the
+          desktop with Component::addToDesktop (0).
+        - use the showAt() method to show a message.
+        - it will make itself invisible after it times-out (and can optionally
+          also delete itself), or you can reuse it somewhere else by calling
+          showAt() again.
+    */
+    BubbleMessageComponent (int fadeOutLengthMs = 150);
+
+    /** Destructor. */
+    ~BubbleMessageComponent() override;
+
+    //==============================================================================
+    /** Shows a message bubble at a particular position.
+
+        This shows the bubble with its stem pointing to the given location
+        (coordinates being relative to its parent component).
+
+        @param position                         the coords of the object to point to
+        @param message                          the text to display
+        @param numMillisecondsBeforeRemoving    how long to leave it on the screen before removing itself
+                                                from its parent component. If this is 0 or less, it
+                                                will stay there until manually removed.
+        @param removeWhenMouseClicked           if this is true, the bubble will disappear as soon as a
+                                                mouse button is pressed (anywhere on the screen)
+        @param deleteSelfAfterUse               if true, then the component will delete itself after
+                                                it becomes invisible
+    */
+    void showAt (const Rectangle<int>& position,
+                 const AttributedString& message,
+                 int numMillisecondsBeforeRemoving,
+                 bool removeWhenMouseClicked = true,
+                 bool deleteSelfAfterUse = false);
+
+    /** Shows a message bubble next to a particular component.
+
+        This shows the bubble with its stem pointing at the given component.
+
+        @param component                        the component that you want to point at
+        @param message                          the text to display
+        @param numMillisecondsBeforeRemoving    how long to leave it on the screen before removing itself
+                                                from its parent component. If this is 0 or less, it
+                                                will stay there until manually removed.
+        @param removeWhenMouseClicked           if this is true, the bubble will disappear as soon as a
+                                                mouse button is pressed (anywhere on the screen)
+        @param deleteSelfAfterUse               if true, then the component will delete itself after
+                                                it becomes invisible
+    */
+    void showAt (Component* component,
+                 const AttributedString& message,
+                 int numMillisecondsBeforeRemoving,
+                 bool removeWhenMouseClicked = true,
+                 bool deleteSelfAfterUse = false);
+
+
+    //==============================================================================
+    /** @internal */
+    void getContentSize (int& w, int& h) override;
+    /** @internal */
+    void paintContent (Graphics& g, int w, int h) override;
+    /** @internal */
+    void timerCallback() override;
+
+private:
+    //==============================================================================
+    int fadeOutLength, mouseClickCounter;
+    TextLayout textLayout;
+    int64 expiryTime;
+    bool deleteAfterUse;
+
+    void createLayout (const AttributedString&);
+    void init (int, bool, bool);
+    void hide (bool fadeOut);
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (BubbleMessageComponent)
+};
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_ColourSelector.cpp

@@ -0,0 +1,651 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+struct ColourComponentSlider  : public Slider
+{
+    ColourComponentSlider (const String& name)  : Slider (name)
+    {
+        setRange (0.0, 255.0, 1.0);
+    }
+
+    String getTextFromValue (double value) override
+    {
+        return String::toHexString ((int) value).toUpperCase().paddedLeft ('0', 2);
+    }
+
+    double getValueFromText (const String& text) override
+    {
+        return (double) text.getHexValue32();
+    }
+};
+
+//==============================================================================
+class ColourSelector::ColourSpaceView  : public Component
+{
+public:
+    ColourSpaceView (ColourSelector& cs, float& hue, float& sat, float& val, int edgeSize)
+        : owner (cs), h (hue), s (sat), v (val), edge (edgeSize)
+    {
+        addAndMakeVisible (marker);
+        setMouseCursor (MouseCursor::CrosshairCursor);
+    }
+
+    void paint (Graphics& g) override
+    {
+        if (colours.isNull())
+        {
+            auto width = getWidth() / 2;
+            auto height = getHeight() / 2;
+            colours = Image (Image::RGB, width, height, false);
+
+            Image::BitmapData pixels (colours, Image::BitmapData::writeOnly);
+
+            for (int y = 0; y < height; ++y)
+            {
+                auto val = 1.0f - (float) y / (float) height;
+
+                for (int x = 0; x < width; ++x)
+                {
+                    auto sat = (float) x / (float) width;
+                    pixels.setPixelColour (x, y, Colour (h, sat, val, 1.0f));
+                }
+            }
+        }
+
+        g.setOpacity (1.0f);
+        g.drawImageTransformed (colours,
+                                RectanglePlacement (RectanglePlacement::stretchToFit)
+                                    .getTransformToFit (colours.getBounds().toFloat(),
+                                                        getLocalBounds().reduced (edge).toFloat()),
+                                false);
+    }
+
+    void mouseDown (const MouseEvent& e) override
+    {
+        mouseDrag (e);
+    }
+
+    void mouseDrag (const MouseEvent& e) override
+    {
+        auto sat =        (float) (e.x - edge) / (float) (getWidth()  - edge * 2);
+        auto val = 1.0f - (float) (e.y - edge) / (float) (getHeight() - edge * 2);
+
+        owner.setSV (sat, val);
+    }
+
+    void updateIfNeeded()
+    {
+        if (lastHue != h)
+        {
+            lastHue = h;
+            colours = {};
+            repaint();
+        }
+
+        updateMarker();
+    }
+
+    void resized() override
+    {
+        colours = {};
+        updateMarker();
+    }
+
+private:
+    ColourSelector& owner;
+    float& h;
+    float& s;
+    float& v;
+    float lastHue = 0;
+    const int edge;
+    Image colours;
+
+    struct ColourSpaceMarker  : public Component
+    {
+        ColourSpaceMarker()
+        {
+            setInterceptsMouseClicks (false, false);
+        }
+
+        void paint (Graphics& g) override
+        {
+            g.setColour (Colour::greyLevel (0.1f));
+            g.drawEllipse (1.0f, 1.0f, (float) getWidth() - 2.0f, (float) getHeight() - 2.0f, 1.0f);
+            g.setColour (Colour::greyLevel (0.9f));
+            g.drawEllipse (2.0f, 2.0f, (float) getWidth() - 4.0f, (float) getHeight() - 4.0f, 1.0f);
+        }
+    };
+
+    ColourSpaceMarker marker;
+
+    void updateMarker()
+    {
+        auto markerSize = jmax (14, edge * 2);
+        auto area = getLocalBounds().reduced (edge);
+
+        marker.setBounds (Rectangle<int> (markerSize, markerSize)
+                            .withCentre (area.getRelativePoint (s, 1.0f - v)));
+    }
+
+    JUCE_DECLARE_NON_COPYABLE (ColourSpaceView)
+};
+
+//==============================================================================
+class ColourSelector::HueSelectorComp  : public Component
+{
+public:
+    HueSelectorComp (ColourSelector& cs, float& hue, int edgeSize)
+        : owner (cs), h (hue), edge (edgeSize)
+    {
+        addAndMakeVisible (marker);
+    }
+
+    void paint (Graphics& g) override
+    {
+        ColourGradient cg;
+        cg.isRadial = false;
+        cg.point1.setXY (0.0f, (float) edge);
+        cg.point2.setXY (0.0f, (float) getHeight());
+
+        for (float i = 0.0f; i <= 1.0f; i += 0.02f)
+            cg.addColour (i, Colour (i, 1.0f, 1.0f, 1.0f));
+
+        g.setGradientFill (cg);
+        g.fillRect (getLocalBounds().reduced (edge));
+    }
+
+    void resized() override
+    {
+        auto markerSize = jmax (14, edge * 2);
+        auto area = getLocalBounds().reduced (edge);
+
+        marker.setBounds (Rectangle<int> (getWidth(), markerSize)
+                            .withCentre (area.getRelativePoint (0.5f, h)));
+    }
+
+    void mouseDown (const MouseEvent& e) override
+    {
+        mouseDrag (e);
+    }
+
+    void mouseDrag (const MouseEvent& e) override
+    {
+        owner.setHue ((float) (e.y - edge) / (float) (getHeight() - edge * 2));
+    }
+
+    void updateIfNeeded()
+    {
+        resized();
+    }
+
+private:
+    ColourSelector& owner;
+    float& h;
+    const int edge;
+
+    struct HueSelectorMarker  : public Component
+    {
+        HueSelectorMarker()
+        {
+            setInterceptsMouseClicks (false, false);
+        }
+
+        void paint (Graphics& g) override
+        {
+            auto cw = (float) getWidth();
+            auto ch = (float) getHeight();
+
+            Path p;
+            p.addTriangle (1.0f, 1.0f,
+                           cw * 0.3f, ch * 0.5f,
+                           1.0f, ch - 1.0f);
+
+            p.addTriangle (cw - 1.0f, 1.0f,
+                           cw * 0.7f, ch * 0.5f,
+                           cw - 1.0f, ch - 1.0f);
+
+            g.setColour (Colours::white.withAlpha (0.75f));
+            g.fillPath (p);
+
+            g.setColour (Colours::black.withAlpha (0.75f));
+            g.strokePath (p, PathStrokeType (1.2f));
+        }
+    };
+
+    HueSelectorMarker marker;
+
+    JUCE_DECLARE_NON_COPYABLE (HueSelectorComp)
+};
+
+//==============================================================================
+class ColourSelector::SwatchComponent   : public Component
+{
+public:
+    SwatchComponent (ColourSelector& cs, int itemIndex)
+        : owner (cs), index (itemIndex)
+    {
+    }
+
+    void paint (Graphics& g) override
+    {
+        auto col = owner.getSwatchColour (index);
+
+        g.fillCheckerBoard (getLocalBounds().toFloat(), 6.0f, 6.0f,
+                            Colour (0xffdddddd).overlaidWith (col),
+                            Colour (0xffffffff).overlaidWith (col));
+    }
+
+    void mouseDown (const MouseEvent&) override
+    {
+        PopupMenu m;
+        m.addItem (1, TRANS("Use this swatch as the current colour"));
+        m.addSeparator();
+        m.addItem (2, TRANS("Set this swatch to the current colour"));
+
+        m.showMenuAsync (PopupMenu::Options().withTargetComponent (this),
+                         ModalCallbackFunction::forComponent (menuStaticCallback, this));
+    }
+
+private:
+    ColourSelector& owner;
+    const int index;
+
+    static void menuStaticCallback (int result, SwatchComponent* comp)
+    {
+        if (comp != nullptr)
+        {
+            if (result == 1)  comp->setColourFromSwatch();
+            if (result == 2)  comp->setSwatchFromColour();
+        }
+    }
+
+    void setColourFromSwatch()
+    {
+        owner.setCurrentColour (owner.getSwatchColour (index));
+    }
+
+    void setSwatchFromColour()
+    {
+        if (owner.getSwatchColour (index) != owner.getCurrentColour())
+        {
+            owner.setSwatchColour (index, owner.getCurrentColour());
+            repaint();
+        }
+    }
+
+    JUCE_DECLARE_NON_COPYABLE (SwatchComponent)
+};
+
+//==============================================================================
+class ColourSelector::ColourPreviewComp  : public Component
+{
+public:
+    ColourPreviewComp (ColourSelector& cs, bool isEditable)
+        : owner (cs)
+    {
+        colourLabel.setFont (labelFont);
+        colourLabel.setJustificationType (Justification::centred);
+
+        if (isEditable)
+        {
+            colourLabel.setEditable (true);
+
+            colourLabel.onEditorShow = [this]
+            {
+                if (auto* ed = colourLabel.getCurrentTextEditor())
+                    ed->setInputRestrictions ((owner.flags & showAlphaChannel) ? 8 : 6, "1234567890ABCDEFabcdef");
+            };
+
+            colourLabel.onEditorHide = [this]
+            {
+                updateColourIfNecessary (colourLabel.getText());
+            };
+        }
+
+        addAndMakeVisible (colourLabel);
+    }
+
+    void updateIfNeeded()
+    {
+        auto newColour = owner.getCurrentColour();
+
+        if (currentColour != newColour)
+        {
+            currentColour = newColour;
+            auto textColour = (Colours::white.overlaidWith (currentColour).contrasting());
+
+            colourLabel.setColour (Label::textColourId,            textColour);
+            colourLabel.setColour (Label::textWhenEditingColourId, textColour);
+            colourLabel.setText (currentColour.toDisplayString ((owner.flags & showAlphaChannel) != 0), dontSendNotification);
+
+            labelWidth = labelFont.getStringWidth (colourLabel.getText());
+
+            repaint();
+        }
+    }
+
+    void paint (Graphics& g) override
+    {
+        g.fillCheckerBoard (getLocalBounds().toFloat(), 10.0f, 10.0f,
+                            Colour (0xffdddddd).overlaidWith (currentColour),
+                            Colour (0xffffffff).overlaidWith (currentColour));
+    }
+
+    void resized() override
+    {
+        colourLabel.centreWithSize (labelWidth + 10, (int) labelFont.getHeight() + 10);
+    }
+
+private:
+    void updateColourIfNecessary (const String& newColourString)
+    {
+        auto newColour = Colour::fromString (newColourString);
+
+        if (newColour != currentColour)
+            owner.setCurrentColour (newColour);
+    }
+
+    ColourSelector& owner;
+
+    Colour currentColour;
+    Font labelFont { 14.0f, Font::bold };
+    int labelWidth = 0;
+    Label colourLabel;
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ColourPreviewComp)
+};
+
+//==============================================================================
+ColourSelector::ColourSelector (int sectionsToShow, int edge, int gapAroundColourSpaceComponent)
+    : colour (Colours::white),
+      flags (sectionsToShow),
+      edgeGap (edge)
+{
+    // not much point having a selector with no components in it!
+    jassert ((flags & (showColourAtTop | showSliders | showColourspace)) != 0);
+
+    updateHSV();
+
+    if ((flags & showColourAtTop) != 0)
+    {
+        previewComponent.reset (new ColourPreviewComp (*this, (flags & editableColour) != 0));
+        addAndMakeVisible (previewComponent.get());
+    }
+
+    if ((flags & showSliders) != 0)
+    {
+        sliders[0].reset (new ColourComponentSlider (TRANS ("red")));
+        sliders[1].reset (new ColourComponentSlider (TRANS ("green")));
+        sliders[2].reset (new ColourComponentSlider (TRANS ("blue")));
+        sliders[3].reset (new ColourComponentSlider (TRANS ("alpha")));
+
+        addAndMakeVisible (sliders[0].get());
+        addAndMakeVisible (sliders[1].get());
+        addAndMakeVisible (sliders[2].get());
+        addChildComponent (sliders[3].get());
+
+        sliders[3]->setVisible ((flags & showAlphaChannel) != 0);
+
+        // VS2015 needs some scoping braces around this if statement to
+        // avoid a compiler bug.
+        for (auto& slider : sliders)
+        {
+            slider->onValueChange = [this] { changeColour(); };
+        }
+    }
+
+    if ((flags & showColourspace) != 0)
+    {
+        colourSpace.reset (new ColourSpaceView (*this, h, s, v, gapAroundColourSpaceComponent));
+        hueSelector.reset (new HueSelectorComp (*this, h, gapAroundColourSpaceComponent));
+
+        addAndMakeVisible (colourSpace.get());
+        addAndMakeVisible (hueSelector.get());
+    }
+
+    update (dontSendNotification);
+}
+
+ColourSelector::~ColourSelector()
+{
+    dispatchPendingMessages();
+    swatchComponents.clear();
+}
+
+//==============================================================================
+Colour ColourSelector::getCurrentColour() const
+{
+    return ((flags & showAlphaChannel) != 0) ? colour : colour.withAlpha ((uint8) 0xff);
+}
+
+void ColourSelector::setCurrentColour (Colour c, NotificationType notification)
+{
+    if (c != colour)
+    {
+        colour = ((flags & showAlphaChannel) != 0) ? c : c.withAlpha ((uint8) 0xff);
+
+        updateHSV();
+        update (notification);
+    }
+}
+
+void ColourSelector::setHue (float newH)
+{
+    newH = jlimit (0.0f, 1.0f, newH);
+
+    if (h != newH)
+    {
+        h = newH;
+        colour = Colour (h, s, v, colour.getFloatAlpha());
+        update (sendNotification);
+    }
+}
+
+void ColourSelector::setSV (float newS, float newV)
+{
+    newS = jlimit (0.0f, 1.0f, newS);
+    newV = jlimit (0.0f, 1.0f, newV);
+
+    if (s != newS || v != newV)
+    {
+        s = newS;
+        v = newV;
+        colour = Colour (h, s, v, colour.getFloatAlpha());
+        update (sendNotification);
+    }
+}
+
+//==============================================================================
+void ColourSelector::updateHSV()
+{
+    colour.getHSB (h, s, v);
+}
+
+void ColourSelector::update (NotificationType notification)
+{
+    if (sliders[0] != nullptr)
+    {
+        sliders[0]->setValue ((int) colour.getRed(),   notification);
+        sliders[1]->setValue ((int) colour.getGreen(), notification);
+        sliders[2]->setValue ((int) colour.getBlue(),  notification);
+        sliders[3]->setValue ((int) colour.getAlpha(), notification);
+    }
+
+    if (colourSpace != nullptr)
+    {
+        colourSpace->updateIfNeeded();
+        hueSelector->updateIfNeeded();
+    }
+
+    if (previewComponent != nullptr)
+        previewComponent->updateIfNeeded();
+
+    if (notification != dontSendNotification)
+        sendChangeMessage();
+
+    if (notification == sendNotificationSync)
+        dispatchPendingMessages();
+}
+
+//==============================================================================
+void ColourSelector::paint (Graphics& g)
+{
+    g.fillAll (findColour (backgroundColourId));
+
+    if ((flags & showSliders) != 0)
+    {
+        g.setColour (findColour (labelTextColourId));
+        g.setFont (11.0f);
+
+        for (auto& slider : sliders)
+        {
+            if (slider->isVisible())
+                g.drawText (slider->getName() + ":",
+                            0, slider->getY(),
+                            slider->getX() - 8, slider->getHeight(),
+                            Justification::centredRight, false);
+        }
+    }
+}
+
+void ColourSelector::resized()
+{
+    const int swatchesPerRow = 8;
+    const int swatchHeight = 22;
+
+    const int numSliders = ((flags & showAlphaChannel) != 0) ? 4 : 3;
+    const int numSwatches = getNumSwatches();
+
+    const int swatchSpace = numSwatches > 0 ? edgeGap + swatchHeight * ((numSwatches + 7) / swatchesPerRow) : 0;
+    const int sliderSpace = ((flags & showSliders) != 0)  ? jmin (22 * numSliders + edgeGap, proportionOfHeight (0.3f)) : 0;
+    const int topSpace = ((flags & showColourAtTop) != 0) ? jmin (30 + edgeGap * 2, proportionOfHeight (0.2f)) : edgeGap;
+
+    if (previewComponent != nullptr)
+        previewComponent->setBounds (edgeGap, edgeGap, getWidth() - edgeGap * 2, topSpace - edgeGap * 2);
+
+    int y = topSpace;
+
+    if ((flags & showColourspace) != 0)
+    {
+        const int hueWidth = jmin (50, proportionOfWidth (0.15f));
+
+        colourSpace->setBounds (edgeGap, y,
+                                getWidth() - hueWidth - edgeGap - 4,
+                                getHeight() - topSpace - sliderSpace - swatchSpace - edgeGap);
+
+        hueSelector->setBounds (colourSpace->getRight() + 4, y,
+                                getWidth() - edgeGap - (colourSpace->getRight() + 4),
+                                colourSpace->getHeight());
+
+        y = getHeight() - sliderSpace - swatchSpace - edgeGap;
+    }
+
+    if ((flags & showSliders) != 0)
+    {
+        auto sliderHeight = jmax (4, sliderSpace / numSliders);
+
+        for (int i = 0; i < numSliders; ++i)
+        {
+            sliders[i]->setBounds (proportionOfWidth (0.2f), y,
+                                   proportionOfWidth (0.72f), sliderHeight - 2);
+
+            y += sliderHeight;
+        }
+    }
+
+    if (numSwatches > 0)
+    {
+        const int startX = 8;
+        const int xGap = 4;
+        const int yGap = 4;
+        const int swatchWidth = (getWidth() - startX * 2) / swatchesPerRow;
+        y += edgeGap;
+
+        if (swatchComponents.size() != numSwatches)
+        {
+            swatchComponents.clear();
+
+            for (int i = 0; i < numSwatches; ++i)
+            {
+                auto* sc = new SwatchComponent (*this, i);
+                swatchComponents.add (sc);
+                addAndMakeVisible (sc);
+            }
+        }
+
+        int x = startX;
+
+        for (int i = 0; i < swatchComponents.size(); ++i)
+        {
+            auto* sc = swatchComponents.getUnchecked(i);
+
+            sc->setBounds (x + xGap / 2,
+                           y + yGap / 2,
+                           swatchWidth - xGap,
+                           swatchHeight - yGap);
+
+            if (((i + 1) % swatchesPerRow) == 0)
+            {
+                x = startX;
+                y += swatchHeight;
+            }
+            else
+            {
+                x += swatchWidth;
+            }
+        }
+    }
+}
+
+void ColourSelector::changeColour()
+{
+    if (sliders[0] != nullptr)
+        setCurrentColour (Colour ((uint8) sliders[0]->getValue(),
+                                  (uint8) sliders[1]->getValue(),
+                                  (uint8) sliders[2]->getValue(),
+                                  (uint8) sliders[3]->getValue()));
+}
+
+//==============================================================================
+int ColourSelector::getNumSwatches() const
+{
+    return 0;
+}
+
+Colour ColourSelector::getSwatchColour (int) const
+{
+    jassertfalse; // if you've overridden getNumSwatches(), you also need to implement this method
+    return Colours::black;
+}
+
+void ColourSelector::setSwatchColour (int, const Colour&)
+{
+    jassertfalse; // if you've overridden getNumSwatches(), you also need to implement this method
+}
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_ColourSelector.h

@@ -0,0 +1,167 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+//==============================================================================
+/**
+    A component that lets the user choose a colour.
+
+    This shows RGB sliders and a colourspace that the user can pick colours from.
+
+    This class is also a ChangeBroadcaster, so listeners can register to be told
+    when the colour changes.
+
+    @tags{GUI}
+*/
+class JUCE_API  ColourSelector  : public Component,
+                                  public ChangeBroadcaster
+{
+public:
+    //==============================================================================
+    /** Options for the type of selector to show. These are passed into the constructor. */
+    enum ColourSelectorOptions
+    {
+        showAlphaChannel    = 1 << 0,   /**< if set, the colour's alpha channel can be changed as well as its RGB. */
+
+        showColourAtTop     = 1 << 1,   /**< if set, a swatch of the colour is shown at the top of the component. */
+        editableColour      = 1 << 2,   /**< if set, the colour shows at the top of the component is editable. */
+        showSliders         = 1 << 3,   /**< if set, RGB sliders are shown at the bottom of the component. */
+        showColourspace     = 1 << 4    /**< if set, a big HSV selector is shown. */
+    };
+
+    //==============================================================================
+    /** Creates a ColourSelector object.
+
+        The flags are a combination of values from the ColourSelectorOptions enum, specifying
+        which of the selector's features should be visible.
+
+        The edgeGap value specifies the amount of space to leave around the edge.
+
+        gapAroundColourSpaceComponent indicates how much of a gap to put around the
+        colourspace and hue selector components.
+    */
+    ColourSelector (int flags = (showAlphaChannel | showColourAtTop | showSliders | showColourspace),
+                    int edgeGap = 4,
+                    int gapAroundColourSpaceComponent = 7);
+
+    /** Destructor. */
+    ~ColourSelector() override;
+
+    //==============================================================================
+    /** Returns the colour that the user has currently selected.
+
+        The ColourSelector class is also a ChangeBroadcaster, so listeners can
+        register to be told when the colour changes.
+
+        @see setCurrentColour
+    */
+    Colour getCurrentColour() const;
+
+    /** Changes the colour that is currently being shown.
+
+        @param newColour           the new colour to show
+        @param notificationType    whether to send a notification of the change to listeners.
+                                   A notification will only be sent if the colour has changed.
+    */
+    void setCurrentColour (Colour newColour, NotificationType notificationType = sendNotification);
+
+    //==============================================================================
+    /** Tells the selector how many preset colour swatches you want to have on the component.
+
+        To enable swatches, you'll need to override getNumSwatches(), getSwatchColour(), and
+        setSwatchColour(), to return the number of colours you want, and to set and retrieve
+        their values.
+    */
+    virtual int getNumSwatches() const;
+
+    /** Called by the selector to find out the colour of one of the swatches.
+
+        Your subclass should return the colour of the swatch with the given index.
+
+        To enable swatches, you'll need to override getNumSwatches(), getSwatchColour(), and
+        setSwatchColour(), to return the number of colours you want, and to set and retrieve
+        their values.
+    */
+    virtual Colour getSwatchColour (int index) const;
+
+    /** Called by the selector when the user puts a new colour into one of the swatches.
+
+        Your subclass should change the colour of the swatch with the given index.
+
+        To enable swatches, you'll need to override getNumSwatches(), getSwatchColour(), and
+        setSwatchColour(), to return the number of colours you want, and to set and retrieve
+        their values.
+    */
+    virtual void setSwatchColour (int index, const Colour& newColour);
+
+
+    //==============================================================================
+    /** A set of colour IDs to use to change the colour of various aspects of the keyboard.
+
+        These constants can be used either via the Component::setColour(), or LookAndFeel::setColour()
+        methods.
+
+        @see Component::setColour, Component::findColour, LookAndFeel::setColour, LookAndFeel::findColour
+    */
+    enum ColourIds
+    {
+        backgroundColourId              = 0x1007000,    /**< the colour used to fill the component's background. */
+        labelTextColourId               = 0x1007001     /**< the colour used for the labels next to the sliders. */
+    };
+
+    //==============================================================================
+    // These need to be public otherwise the Projucer's live-build engine will complain
+    class ColourSpaceView;
+    class HueSelectorComp;
+    class ColourPreviewComp;
+
+private:
+    //==============================================================================
+    class SwatchComponent;
+
+    Colour colour;
+    float h, s, v;
+    std::unique_ptr<Slider> sliders[4];
+    std::unique_ptr<ColourSpaceView> colourSpace;
+    std::unique_ptr<HueSelectorComp> hueSelector;
+    std::unique_ptr<ColourPreviewComp> previewComponent;
+    OwnedArray<SwatchComponent> swatchComponents;
+    const int flags;
+    int edgeGap;
+
+    void setHue (float newH);
+    void setSV (float newS, float newV);
+    void updateHSV();
+    void update (NotificationType);
+    void changeColour();
+    void paint (Graphics&) override;
+    void resized() override;
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ColourSelector)
+};
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_KeyMappingEditorComponent.cpp

@@ -0,0 +1,480 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+class KeyMappingEditorComponent::ChangeKeyButton  : public Button
+{
+public:
+    ChangeKeyButton (KeyMappingEditorComponent& kec, CommandID command,
+                     const String& keyName, int keyIndex)
+        : Button (keyName),
+          owner (kec),
+          commandID (command),
+          keyNum (keyIndex)
+    {
+        setWantsKeyboardFocus (false);
+        setTriggeredOnMouseDown (keyNum >= 0);
+
+        setTooltip (keyIndex < 0 ? TRANS("Adds a new key-mapping")
+                                 : TRANS("Click to change this key-mapping"));
+    }
+
+    void paintButton (Graphics& g, bool /*isOver*/, bool /*isDown*/) override
+    {
+        getLookAndFeel().drawKeymapChangeButton (g, getWidth(), getHeight(), *this,
+                                                 keyNum >= 0 ? getName() : String());
+    }
+
+    void clicked() override
+    {
+        if (keyNum >= 0)
+        {
+            Component::SafePointer<ChangeKeyButton> button (this);
+            PopupMenu m;
+
+            m.addItem (TRANS("Change this key-mapping"),
+                       [button]
+                       {
+                           if (button != nullptr)
+                               button.getComponent()->assignNewKey();
+                       });
+
+            m.addSeparator();
+
+            m.addItem (TRANS("Remove this key-mapping"),
+                       [button]
+                       {
+                           if (button != nullptr)
+                               button->owner.getMappings().removeKeyPress (button->commandID,
+                                                                           button->keyNum);
+                       });
+
+            m.showMenuAsync (PopupMenu::Options().withTargetComponent (this));
+        }
+        else
+        {
+            assignNewKey();  // + button pressed..
+        }
+    }
+
+    using Button::clicked;
+
+    void fitToContent (const int h) noexcept
+    {
+        if (keyNum < 0)
+            setSize (h, h);
+        else
+            setSize (jlimit (h * 4, h * 8, 6 + Font ((float) h * 0.6f).getStringWidth (getName())), h);
+    }
+
+    //==============================================================================
+    class KeyEntryWindow  : public AlertWindow
+    {
+    public:
+        KeyEntryWindow (KeyMappingEditorComponent& kec)
+            : AlertWindow (TRANS("New key-mapping"),
+                           TRANS("Please press a key combination now..."),
+                           MessageBoxIconType::NoIcon),
+              owner (kec)
+        {
+            addButton (TRANS("OK"), 1);
+            addButton (TRANS("Cancel"), 0);
+
+            // (avoid return + escape keys getting processed by the buttons..)
+            for (auto* child : getChildren())
+                child->setWantsKeyboardFocus (false);
+
+            setWantsKeyboardFocus (true);
+            grabKeyboardFocus();
+        }
+
+        bool keyPressed (const KeyPress& key) override
+        {
+            lastPress = key;
+            String message (TRANS("Key") + ": " + owner.getDescriptionForKeyPress (key));
+
+            auto previousCommand = owner.getMappings().findCommandForKeyPress (key);
+
+            if (previousCommand != 0)
+                message << "\n\n("
+                        << TRANS("Currently assigned to \"CMDN\"")
+                            .replace ("CMDN", TRANS (owner.getCommandManager().getNameOfCommand (previousCommand)))
+                        << ')';
+
+            setMessage (message);
+            return true;
+        }
+
+        bool keyStateChanged (bool) override
+        {
+            return true;
+        }
+
+        KeyPress lastPress;
+
+    private:
+        KeyMappingEditorComponent& owner;
+
+        JUCE_DECLARE_NON_COPYABLE (KeyEntryWindow)
+    };
+
+    static void assignNewKeyCallback (int result, ChangeKeyButton* button, KeyPress newKey)
+    {
+        if (result != 0 && button != nullptr)
+            button->setNewKey (newKey, true);
+    }
+
+    void setNewKey (const KeyPress& newKey, bool dontAskUser)
+    {
+        if (newKey.isValid())
+        {
+            auto previousCommand = owner.getMappings().findCommandForKeyPress (newKey);
+
+            if (previousCommand == 0 || dontAskUser)
+            {
+                owner.getMappings().removeKeyPress (newKey);
+
+                if (keyNum >= 0)
+                    owner.getMappings().removeKeyPress (commandID, keyNum);
+
+                owner.getMappings().addKeyPress (commandID, newKey, keyNum);
+            }
+            else
+            {
+                AlertWindow::showOkCancelBox (MessageBoxIconType::WarningIcon,
+                                              TRANS("Change key-mapping"),
+                                              TRANS("This key is already assigned to the command \"CMDN\"")
+                                                  .replace ("CMDN", owner.getCommandManager().getNameOfCommand (previousCommand))
+                                                + "\n\n"
+                                                + TRANS("Do you want to re-assign it to this new command instead?"),
+                                              TRANS("Re-assign"),
+                                              TRANS("Cancel"),
+                                              this,
+                                              ModalCallbackFunction::forComponent (assignNewKeyCallback,
+                                                                                   this, KeyPress (newKey)));
+            }
+        }
+    }
+
+    static void keyChosen (int result, ChangeKeyButton* button)
+    {
+        if (button != nullptr && button->currentKeyEntryWindow != nullptr)
+        {
+            if (result != 0)
+            {
+                button->currentKeyEntryWindow->setVisible (false);
+                button->setNewKey (button->currentKeyEntryWindow->lastPress, false);
+            }
+
+            button->currentKeyEntryWindow.reset();
+        }
+    }
+
+    void assignNewKey()
+    {
+        currentKeyEntryWindow.reset (new KeyEntryWindow (owner));
+        currentKeyEntryWindow->enterModalState (true, ModalCallbackFunction::forComponent (keyChosen, this));
+    }
+
+private:
+    KeyMappingEditorComponent& owner;
+    const CommandID commandID;
+    const int keyNum;
+    std::unique_ptr<KeyEntryWindow> currentKeyEntryWindow;
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ChangeKeyButton)
+};
+
+//==============================================================================
+class KeyMappingEditorComponent::ItemComponent  : public Component
+{
+public:
+    ItemComponent (KeyMappingEditorComponent& kec, CommandID command)
+        : owner (kec), commandID (command)
+    {
+        setInterceptsMouseClicks (false, true);
+
+        const bool isReadOnly = owner.isCommandReadOnly (commandID);
+
+        auto keyPresses = owner.getMappings().getKeyPressesAssignedToCommand (commandID);
+
+        for (int i = 0; i < jmin ((int) maxNumAssignments, keyPresses.size()); ++i)
+            addKeyPressButton (owner.getDescriptionForKeyPress (keyPresses.getReference (i)), i, isReadOnly);
+
+        addKeyPressButton ("Change Key Mapping", -1, isReadOnly);
+    }
+
+    void addKeyPressButton (const String& desc, const int index, const bool isReadOnly)
+    {
+        auto* b = new ChangeKeyButton (owner, commandID, desc, index);
+        keyChangeButtons.add (b);
+
+        b->setEnabled (! isReadOnly);
+        b->setVisible (keyChangeButtons.size() <= (int) maxNumAssignments);
+        addChildComponent (b);
+    }
+
+    void paint (Graphics& g) override
+    {
+        g.setFont ((float) getHeight() * 0.7f);
+        g.setColour (owner.findColour (KeyMappingEditorComponent::textColourId));
+
+        g.drawFittedText (TRANS (owner.getCommandManager().getNameOfCommand (commandID)),
+                          4, 0, jmax (40, getChildComponent (0)->getX() - 5), getHeight(),
+                          Justification::centredLeft, true);
+    }
+
+    void resized() override
+    {
+        int x = getWidth() - 4;
+
+        for (int i = keyChangeButtons.size(); --i >= 0;)
+        {
+            auto* b = keyChangeButtons.getUnchecked(i);
+
+            b->fitToContent (getHeight() - 2);
+            b->setTopRightPosition (x, 1);
+            x = b->getX() - 5;
+        }
+    }
+
+private:
+    std::unique_ptr<AccessibilityHandler> createAccessibilityHandler() override
+    {
+        return createIgnoredAccessibilityHandler (*this);
+    }
+
+    KeyMappingEditorComponent& owner;
+    OwnedArray<ChangeKeyButton> keyChangeButtons;
+    const CommandID commandID;
+
+    enum { maxNumAssignments = 3 };
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ItemComponent)
+};
+
+//==============================================================================
+class KeyMappingEditorComponent::MappingItem  : public TreeViewItem
+{
+public:
+    MappingItem (KeyMappingEditorComponent& kec, CommandID command)
+        : owner (kec), commandID (command)
+    {}
+
+    String getUniqueName() const override                      { return String ((int) commandID) + "_id"; }
+    bool mightContainSubItems() override                       { return false; }
+    int getItemHeight() const override                         { return 20; }
+    std::unique_ptr<Component> createItemComponent() override  { return std::make_unique<ItemComponent> (owner, commandID); }
+    String getAccessibilityName() override                     { return TRANS (owner.getCommandManager().getNameOfCommand (commandID)); }
+
+private:
+    KeyMappingEditorComponent& owner;
+    const CommandID commandID;
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MappingItem)
+};
+
+
+//==============================================================================
+class KeyMappingEditorComponent::CategoryItem  : public TreeViewItem
+{
+public:
+    CategoryItem (KeyMappingEditorComponent& kec, const String& name)
+        : owner (kec), categoryName (name)
+    {}
+
+    String getUniqueName() const override       { return categoryName + "_cat"; }
+    bool mightContainSubItems() override        { return true; }
+    int getItemHeight() const override          { return 22; }
+    String getAccessibilityName() override      { return categoryName; }
+
+    void paintItem (Graphics& g, int width, int height) override
+    {
+        g.setFont (Font ((float) height * 0.7f, Font::bold));
+        g.setColour (owner.findColour (KeyMappingEditorComponent::textColourId));
+
+        g.drawText (TRANS (categoryName), 2, 0, width - 2, height, Justification::centredLeft, true);
+    }
+
+    void itemOpennessChanged (bool isNowOpen) override
+    {
+        if (isNowOpen)
+        {
+            if (getNumSubItems() == 0)
+                for (auto command : owner.getCommandManager().getCommandsInCategory (categoryName))
+                    if (owner.shouldCommandBeIncluded (command))
+                        addSubItem (new MappingItem (owner, command));
+        }
+        else
+        {
+            clearSubItems();
+        }
+    }
+
+private:
+    KeyMappingEditorComponent& owner;
+    String categoryName;
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (CategoryItem)
+};
+
+//==============================================================================
+class KeyMappingEditorComponent::TopLevelItem   : public TreeViewItem,
+                                                  private ChangeListener
+{
+public:
+    TopLevelItem (KeyMappingEditorComponent& kec)   : owner (kec)
+    {
+        setLinesDrawnForSubItems (false);
+        owner.getMappings().addChangeListener (this);
+    }
+
+    ~TopLevelItem() override
+    {
+        owner.getMappings().removeChangeListener (this);
+    }
+
+    bool mightContainSubItems() override             { return true; }
+    String getUniqueName() const override            { return "keys"; }
+
+    void changeListenerCallback (ChangeBroadcaster*) override
+    {
+        const OpennessRestorer opennessRestorer (*this);
+        clearSubItems();
+
+        for (auto category : owner.getCommandManager().getCommandCategories())
+        {
+            int count = 0;
+
+            for (auto command : owner.getCommandManager().getCommandsInCategory (category))
+                if (owner.shouldCommandBeIncluded (command))
+                    ++count;
+
+            if (count > 0)
+                addSubItem (new CategoryItem (owner, category));
+        }
+    }
+
+private:
+    KeyMappingEditorComponent& owner;
+};
+
+static void resetKeyMappingsToDefaultsCallback (int result, KeyMappingEditorComponent* owner)
+{
+    if (result != 0 && owner != nullptr)
+        owner->getMappings().resetToDefaultMappings();
+}
+
+//==============================================================================
+KeyMappingEditorComponent::KeyMappingEditorComponent (KeyPressMappingSet& mappingManager,
+                                                      const bool showResetToDefaultButton)
+    : mappings (mappingManager),
+      resetButton (TRANS ("reset to defaults"))
+{
+    treeItem.reset (new TopLevelItem (*this));
+
+    if (showResetToDefaultButton)
+    {
+        addAndMakeVisible (resetButton);
+
+        resetButton.onClick = [this]
+        {
+            AlertWindow::showOkCancelBox (MessageBoxIconType::QuestionIcon,
+                                          TRANS("Reset to defaults"),
+                                          TRANS("Are you sure you want to reset all the key-mappings to their default state?"),
+                                          TRANS("Reset"),
+                                          {}, this,
+                                          ModalCallbackFunction::forComponent (resetKeyMappingsToDefaultsCallback, this));
+        };
+    }
+
+    addAndMakeVisible (tree);
+    tree.setTitle ("Key Mappings");
+    tree.setColour (TreeView::backgroundColourId, findColour (backgroundColourId));
+    tree.setRootItemVisible (false);
+    tree.setDefaultOpenness (true);
+    tree.setRootItem (treeItem.get());
+    tree.setIndentSize (12);
+}
+
+KeyMappingEditorComponent::~KeyMappingEditorComponent()
+{
+    tree.setRootItem (nullptr);
+}
+
+//==============================================================================
+void KeyMappingEditorComponent::setColours (Colour mainBackground,
+                                            Colour textColour)
+{
+    setColour (backgroundColourId, mainBackground);
+    setColour (textColourId, textColour);
+    tree.setColour (TreeView::backgroundColourId, mainBackground);
+}
+
+void KeyMappingEditorComponent::parentHierarchyChanged()
+{
+    treeItem->changeListenerCallback (nullptr);
+}
+
+void KeyMappingEditorComponent::resized()
+{
+    int h = getHeight();
+
+    if (resetButton.isVisible())
+    {
+        const int buttonHeight = 20;
+        h -= buttonHeight + 8;
+        int x = getWidth() - 8;
+
+        resetButton.changeWidthToFitText (buttonHeight);
+        resetButton.setTopRightPosition (x, h + 6);
+    }
+
+    tree.setBounds (0, 0, getWidth(), h);
+}
+
+//==============================================================================
+bool KeyMappingEditorComponent::shouldCommandBeIncluded (const CommandID commandID)
+{
+    auto* ci = mappings.getCommandManager().getCommandForID (commandID);
+
+    return ci != nullptr && (ci->flags & ApplicationCommandInfo::hiddenFromKeyEditor) == 0;
+}
+
+bool KeyMappingEditorComponent::isCommandReadOnly (const CommandID commandID)
+{
+    auto* ci = mappings.getCommandManager().getCommandForID (commandID);
+
+    return ci != nullptr && (ci->flags & ApplicationCommandInfo::readOnlyInKeyEditor) != 0;
+}
+
+String KeyMappingEditorComponent::getDescriptionForKeyPress (const KeyPress& key)
+{
+    return key.getTextDescription();
+}
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_KeyMappingEditorComponent.h

@@ -0,0 +1,132 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+//==============================================================================
+/**
+    A component to allow editing of the keymaps stored by a KeyPressMappingSet
+    object.
+
+    @see KeyPressMappingSet
+
+    @tags{GUI}
+*/
+class JUCE_API  KeyMappingEditorComponent  : public Component
+{
+public:
+    //==============================================================================
+    /** Creates a KeyMappingEditorComponent.
+
+        @param mappingSet   this is the set of mappings to display and edit. Make sure the
+                            mappings object is not deleted before this component!
+        @param showResetToDefaultButton     if true, then at the bottom of the list, the
+                                            component will include a 'reset to defaults' button.
+    */
+    KeyMappingEditorComponent (KeyPressMappingSet& mappingSet,
+                               bool showResetToDefaultButton);
+
+    /** Destructor. */
+    ~KeyMappingEditorComponent() override;
+
+    //==============================================================================
+    /** Sets up the colours to use for parts of the component.
+
+        @param mainBackground       colour to use for most of the background
+        @param textColour           colour to use for the text
+    */
+    void setColours (Colour mainBackground,
+                     Colour textColour);
+
+    /** Returns the KeyPressMappingSet that this component is acting upon. */
+    KeyPressMappingSet& getMappings() const noexcept                { return mappings; }
+
+    /** Returns the ApplicationCommandManager that this component is connected to. */
+    ApplicationCommandManager& getCommandManager() const noexcept   { return mappings.getCommandManager(); }
+
+
+    //==============================================================================
+    /** Can be overridden if some commands need to be excluded from the list.
+
+        By default this will use the KeyPressMappingSet's shouldCommandBeVisibleInEditor()
+        method to decide what to return, but you can override it to handle special cases.
+    */
+    virtual bool shouldCommandBeIncluded (CommandID commandID);
+
+    /** Can be overridden to indicate that some commands are shown as read-only.
+
+        By default this will use the KeyPressMappingSet's shouldCommandBeReadOnlyInEditor()
+        method to decide what to return, but you can override it to handle special cases.
+    */
+    virtual bool isCommandReadOnly (CommandID commandID);
+
+    /** This can be overridden to let you change the format of the string used
+        to describe a keypress.
+
+        This is handy if you're using non-standard KeyPress objects, e.g. for custom
+        keys that are triggered by something else externally. If you override the
+        method, be sure to let the base class's method handle keys you're not
+        interested in.
+    */
+    virtual String getDescriptionForKeyPress (const KeyPress& key);
+
+    //==============================================================================
+    /** A set of colour IDs to use to change the colour of various aspects of the editor.
+
+        These constants can be used either via the Component::setColour(), or LookAndFeel::setColour()
+        methods.
+
+        @see Component::setColour, Component::findColour, LookAndFeel::setColour, LookAndFeel::findColour
+    */
+    enum ColourIds
+    {
+        backgroundColourId  = 0x100ad00,    /**< The background colour to fill the editor background. */
+        textColourId        = 0x100ad01,    /**< The colour for the text. */
+    };
+
+    //==============================================================================
+    /** @internal */
+    void parentHierarchyChanged() override;
+    /** @internal */
+    void resized() override;
+
+private:
+    //==============================================================================
+    KeyPressMappingSet& mappings;
+    TreeView tree;
+    TextButton resetButton;
+
+    class TopLevelItem;
+    class ChangeKeyButton;
+    class MappingItem;
+    class CategoryItem;
+    class ItemComponent;
+    std::unique_ptr<TopLevelItem> treeItem;
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (KeyMappingEditorComponent)
+};
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_LiveConstantEditor.cpp

@@ -0,0 +1,497 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+#if JUCE_ENABLE_LIVE_CONSTANT_EDITOR
+
+namespace LiveConstantEditor
+{
+
+//==============================================================================
+class AllComponentRepainter  : private Timer,
+                               private DeletedAtShutdown
+{
+public:
+    AllComponentRepainter()  {}
+    ~AllComponentRepainter() override  { clearSingletonInstance(); }
+
+    JUCE_DECLARE_SINGLETON (AllComponentRepainter, false)
+
+    void trigger()
+    {
+        if (! isTimerRunning())
+            startTimer (100);
+    }
+
+private:
+    void timerCallback() override
+    {
+        stopTimer();
+
+        Array<Component*> alreadyDone;
+
+        for (int i = TopLevelWindow::getNumTopLevelWindows(); --i >= 0;)
+            if (auto* c = TopLevelWindow::getTopLevelWindow(i))
+                repaintAndResizeAllComps (c, alreadyDone);
+
+        auto& desktop = Desktop::getInstance();
+
+        for (int i = desktop.getNumComponents(); --i >= 0;)
+            if (auto* c = desktop.getComponent(i))
+                repaintAndResizeAllComps (c, alreadyDone);
+    }
+
+    static void repaintAndResizeAllComps (Component::SafePointer<Component> c,
+                                          Array<Component*>& alreadyDone)
+    {
+        if (c->isVisible() && ! alreadyDone.contains (c))
+        {
+            c->repaint();
+            c->resized();
+
+            for (int i = c->getNumChildComponents(); --i >= 0;)
+            {
+                if (auto* child = c->getChildComponent(i))
+                {
+                    repaintAndResizeAllComps (child, alreadyDone);
+                    alreadyDone.add (child);
+                }
+
+                if (c == nullptr)
+                    break;
+            }
+        }
+    }
+};
+
+JUCE_IMPLEMENT_SINGLETON (AllComponentRepainter)
+JUCE_IMPLEMENT_SINGLETON (ValueList)
+
+//==============================================================================
+int64 parseInt (String s)
+{
+    s = s.trimStart();
+
+    if (s.startsWithChar ('-'))
+        return -parseInt (s.substring (1));
+
+    if (s.startsWith ("0x"))
+        return s.substring(2).getHexValue64();
+
+    return s.getLargeIntValue();
+}
+
+double parseDouble (const String& s)
+{
+    return s.retainCharacters ("0123456789.eE-").getDoubleValue();
+}
+
+String intToString (int   v, bool preferHex)    { return preferHex ? "0x" + String::toHexString (v) : String (v); }
+String intToString (int64 v, bool preferHex)    { return preferHex ? "0x" + String::toHexString (v) : String (v); }
+
+//==============================================================================
+LiveValueBase::LiveValueBase (const char* file, int line)
+    : sourceFile (file), sourceLine (line)
+{
+    name = File (sourceFile).getFileName() + " : " + String (sourceLine);
+}
+
+LiveValueBase::~LiveValueBase()
+{
+}
+
+//==============================================================================
+LivePropertyEditorBase::LivePropertyEditorBase (LiveValueBase& v, CodeDocument& d)
+    : value (v), document (d), sourceEditor (document, &tokeniser)
+{
+    setSize (600, 100);
+
+    addAndMakeVisible (name);
+    addAndMakeVisible (resetButton);
+    addAndMakeVisible (valueEditor);
+    addAndMakeVisible (sourceEditor);
+
+    findOriginalValueInCode();
+    selectOriginalValue();
+
+    name.setFont (13.0f);
+    name.setText (v.name, dontSendNotification);
+    valueEditor.setMultiLine (v.isString());
+    valueEditor.setReturnKeyStartsNewLine (v.isString());
+    valueEditor.setText (v.getStringValue (wasHex), dontSendNotification);
+    valueEditor.onTextChange = [this] { applyNewValue (valueEditor.getText()); };
+    sourceEditor.setReadOnly (true);
+    sourceEditor.setFont (sourceEditor.getFont().withHeight (13.0f));
+    resetButton.onClick = [this] { applyNewValue (value.getOriginalStringValue (wasHex)); };
+}
+
+void LivePropertyEditorBase::paint (Graphics& g)
+{
+    g.setColour (Colours::white);
+    g.fillRect (getLocalBounds().removeFromBottom (1));
+}
+
+void LivePropertyEditorBase::resized()
+{
+    auto r = getLocalBounds().reduced (0, 3).withTrimmedBottom (1);
+
+    auto left = r.removeFromLeft (jmax (200, r.getWidth() / 3));
+
+    auto top = left.removeFromTop (25);
+    resetButton.setBounds (top.removeFromRight (35).reduced (0, 3));
+    name.setBounds (top);
+
+    if (customComp != nullptr)
+    {
+        valueEditor.setBounds (left.removeFromTop (25));
+        left.removeFromTop (2);
+        customComp->setBounds (left);
+    }
+    else
+    {
+        valueEditor.setBounds (left);
+    }
+
+    r.removeFromLeft (4);
+    sourceEditor.setBounds (r);
+}
+
+void LivePropertyEditorBase::applyNewValue (const String& s)
+{
+    value.setStringValue (s);
+
+    document.replaceSection (valueStart.getPosition(), valueEnd.getPosition(), value.getCodeValue (wasHex));
+    document.clearUndoHistory();
+    selectOriginalValue();
+
+    valueEditor.setText (s, dontSendNotification);
+    AllComponentRepainter::getInstance()->trigger();
+}
+
+void LivePropertyEditorBase::selectOriginalValue()
+{
+    sourceEditor.selectRegion (valueStart, valueEnd);
+}
+
+void LivePropertyEditorBase::findOriginalValueInCode()
+{
+    CodeDocument::Position pos (document, value.sourceLine, 0);
+    auto line = pos.getLineText();
+    auto p = line.getCharPointer();
+
+    p = CharacterFunctions::find (p, CharPointer_ASCII ("JUCE_LIVE_CONSTANT"));
+
+    if (p.isEmpty())
+    {
+        // Not sure how this would happen - some kind of mix-up between source code and line numbers..
+        jassertfalse;
+        return;
+    }
+
+    p += (int) (sizeof ("JUCE_LIVE_CONSTANT") - 1);
+    p.incrementToEndOfWhitespace();
+
+    if (! CharacterFunctions::find (p, CharPointer_ASCII ("JUCE_LIVE_CONSTANT")).isEmpty())
+    {
+        // Aargh! You've added two JUCE_LIVE_CONSTANT macros on the same line!
+        // They're identified by their line number, so you must make sure each
+        // one goes on a separate line!
+        jassertfalse;
+    }
+
+    if (p.getAndAdvance() == '(')
+    {
+        auto start = p, end = p;
+
+        int depth = 1;
+
+        while (! end.isEmpty())
+        {
+            auto c = end.getAndAdvance();
+
+            if (c == '(')  ++depth;
+            if (c == ')')  --depth;
+
+            if (depth == 0)
+            {
+                --end;
+                break;
+            }
+        }
+
+        if (end > start)
+        {
+            valueStart = CodeDocument::Position (document, value.sourceLine, (int) (start - line.getCharPointer()));
+            valueEnd   = CodeDocument::Position (document, value.sourceLine, (int) (end   - line.getCharPointer()));
+
+            valueStart.setPositionMaintained (true);
+            valueEnd.setPositionMaintained (true);
+
+            wasHex = String (start, end).containsIgnoreCase ("0x");
+        }
+    }
+}
+
+//==============================================================================
+class ValueListHolderComponent  : public Component
+{
+public:
+    ValueListHolderComponent (ValueList& l) : valueList (l)
+    {
+        setVisible (true);
+    }
+
+    void addItem (int width, LiveValueBase& v, CodeDocument& doc)
+    {
+        addAndMakeVisible (editors.add (v.createPropertyComponent (doc)));
+        layout (width);
+    }
+
+    void layout (int width)
+    {
+        setSize (width, editors.size() * itemHeight);
+        resized();
+    }
+
+    void resized() override
+    {
+        auto r = getLocalBounds().reduced (2, 0);
+
+        for (int i = 0; i < editors.size(); ++i)
+            editors.getUnchecked(i)->setBounds (r.removeFromTop (itemHeight));
+    }
+
+    enum { itemHeight = 120 };
+
+    ValueList& valueList;
+    OwnedArray<LivePropertyEditorBase> editors;
+};
+
+//==============================================================================
+class ValueList::EditorWindow  : public DocumentWindow,
+                                 private DeletedAtShutdown
+{
+public:
+    EditorWindow (ValueList& list)
+        : DocumentWindow ("Live Values", Colours::lightgrey, DocumentWindow::closeButton)
+    {
+        setLookAndFeel (&lookAndFeel);
+        setUsingNativeTitleBar (true);
+
+        viewport.setViewedComponent (new ValueListHolderComponent (list), true);
+        viewport.setSize (700, 600);
+        viewport.setScrollBarsShown (true, false);
+
+        setContentNonOwned (&viewport, true);
+        setResizable (true, false);
+        setResizeLimits (500, 400, 10000, 10000);
+        centreWithSize (getWidth(), getHeight());
+        setVisible (true);
+    }
+
+    ~EditorWindow() override
+    {
+        setLookAndFeel (nullptr);
+    }
+
+    void closeButtonPressed() override
+    {
+        setVisible (false);
+    }
+
+    void updateItems (ValueList& list)
+    {
+        if (auto* l = dynamic_cast<ValueListHolderComponent*> (viewport.getViewedComponent()))
+        {
+            while (l->getNumChildComponents() < list.values.size())
+            {
+                if (auto* v = list.values [l->getNumChildComponents()])
+                    l->addItem (viewport.getMaximumVisibleWidth(), *v, list.getDocument (v->sourceFile));
+                else
+                    break;
+            }
+
+            setVisible (true);
+        }
+    }
+
+    void resized() override
+    {
+        DocumentWindow::resized();
+
+        if (auto* l = dynamic_cast<ValueListHolderComponent*> (viewport.getViewedComponent()))
+            l->layout (viewport.getMaximumVisibleWidth());
+    }
+
+    Viewport viewport;
+    LookAndFeel_V3 lookAndFeel;
+};
+
+//==============================================================================
+ValueList::ValueList()  {}
+ValueList::~ValueList() { clearSingletonInstance(); }
+
+void ValueList::addValue (LiveValueBase* v)
+{
+    values.add (v);
+    triggerAsyncUpdate();
+}
+
+void ValueList::handleAsyncUpdate()
+{
+    if (editorWindow == nullptr)
+        editorWindow = new EditorWindow (*this);
+
+    editorWindow->updateItems (*this);
+}
+
+CodeDocument& ValueList::getDocument (const File& file)
+{
+    const int index = documentFiles.indexOf (file.getFullPathName());
+
+    if (index >= 0)
+        return *documents.getUnchecked (index);
+
+    auto* doc = documents.add (new CodeDocument());
+    documentFiles.add (file);
+    doc->replaceAllContent (file.loadFileAsString());
+    doc->clearUndoHistory();
+    return *doc;
+}
+
+//==============================================================================
+struct ColourEditorComp  : public Component,
+                           private ChangeListener
+{
+    ColourEditorComp (LivePropertyEditorBase& e)  : editor (e)
+    {
+        setMouseCursor (MouseCursor::PointingHandCursor);
+    }
+
+    Colour getColour() const
+    {
+        return Colour ((uint32) parseInt (editor.value.getStringValue (false)));
+    }
+
+    void paint (Graphics& g) override
+    {
+        g.fillCheckerBoard (getLocalBounds().toFloat(), 6.0f, 6.0f,
+                            Colour (0xffdddddd).overlaidWith (getColour()),
+                            Colour (0xffffffff).overlaidWith (getColour()));
+    }
+
+    void mouseDown (const MouseEvent&) override
+    {
+        auto colourSelector = std::make_unique<ColourSelector>();
+        colourSelector->setName ("Colour");
+        colourSelector->setCurrentColour (getColour());
+        colourSelector->addChangeListener (this);
+        colourSelector->setColour (ColourSelector::backgroundColourId, Colours::transparentBlack);
+        colourSelector->setSize (300, 400);
+
+        CallOutBox::launchAsynchronously (std::move (colourSelector), getScreenBounds(), nullptr);
+    }
+
+    void changeListenerCallback (ChangeBroadcaster* source) override
+    {
+        if (auto* cs = dynamic_cast<ColourSelector*> (source))
+            editor.applyNewValue (getAsString (cs->getCurrentColour(), true));
+
+        repaint();
+    }
+
+    LivePropertyEditorBase& editor;
+};
+
+Component* createColourEditor (LivePropertyEditorBase& editor)
+{
+    return new ColourEditorComp (editor);
+}
+
+//==============================================================================
+struct SliderComp   : public Component
+{
+    SliderComp (LivePropertyEditorBase& e, bool useFloat)
+        : editor (e), isFloat (useFloat)
+    {
+        slider.setTextBoxStyle (Slider::NoTextBox, true, 0, 0);
+        addAndMakeVisible (slider);
+        updateRange();
+        slider.onDragEnd = [this] { updateRange(); };
+        slider.onValueChange = [this]
+        {
+            editor.applyNewValue (isFloat ? getAsString ((double) slider.getValue(), editor.wasHex)
+                                          : getAsString ((int64)  slider.getValue(), editor.wasHex));
+        };
+    }
+
+    virtual void updateRange()
+    {
+        double v = isFloat ? parseDouble (editor.value.getStringValue (false))
+                           : (double) parseInt (editor.value.getStringValue (false));
+
+        double range = isFloat ? 10 : 100;
+
+        slider.setRange (v - range, v + range);
+        slider.setValue (v, dontSendNotification);
+    }
+
+    void resized() override
+    {
+        slider.setBounds (getLocalBounds().removeFromTop (25));
+    }
+
+    LivePropertyEditorBase& editor;
+    Slider slider;
+    bool isFloat;
+};
+
+//==============================================================================
+struct BoolSliderComp  : public SliderComp
+{
+    BoolSliderComp (LivePropertyEditorBase& e)
+        : SliderComp (e, false)
+    {
+        slider.onValueChange = [this] { editor.applyNewValue (slider.getValue() > 0.5 ? "true" : "false"); };
+    }
+
+    void updateRange() override
+    {
+        slider.setRange (0.0, 1.0, dontSendNotification);
+        slider.setValue (editor.value.getStringValue (false) == "true", dontSendNotification);
+    }
+};
+
+Component* createIntegerSlider (LivePropertyEditorBase& editor)  { return new SliderComp (editor, false); }
+Component* createFloatSlider   (LivePropertyEditorBase& editor)  { return new SliderComp (editor, true);  }
+Component* createBoolSlider    (LivePropertyEditorBase& editor)  { return new BoolSliderComp (editor); }
+
+}
+
+#endif
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_LiveConstantEditor.h

@@ -0,0 +1,305 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+#if JUCE_ENABLE_LIVE_CONSTANT_EDITOR && ! defined (DOXYGEN)
+
+//==============================================================================
+/** You can safely ignore all the stuff in this namespace - it's a bunch of boilerplate
+    code used to implement the JUCE_LIVE_CONSTANT functionality.
+*/
+namespace LiveConstantEditor
+{
+    int64 parseInt (String);
+    double parseDouble (const String&);
+    String intToString (int, bool preferHex);
+    String intToString (int64, bool preferHex);
+
+    template <typename Type>
+    static void setFromString (Type& v,           const String& s)    { v = static_cast<Type> (s); }
+    inline void setFromString (char& v,           const String& s)    { v = (char)           parseInt (s); }
+    inline void setFromString (unsigned char& v,  const String& s)    { v = (unsigned char)  parseInt (s); }
+    inline void setFromString (short& v,          const String& s)    { v = (short)          parseInt (s); }
+    inline void setFromString (unsigned short& v, const String& s)    { v = (unsigned short) parseInt (s); }
+    inline void setFromString (int& v,            const String& s)    { v = (int)            parseInt (s); }
+    inline void setFromString (unsigned int& v,   const String& s)    { v = (unsigned int)   parseInt (s); }
+    inline void setFromString (long& v,           const String& s)    { v = (long)           parseInt (s); }
+    inline void setFromString (unsigned long& v,  const String& s)    { v = (unsigned long)  parseInt (s); }
+    inline void setFromString (int64& v,          const String& s)    { v = (int64)          parseInt (s); }
+    inline void setFromString (uint64& v,         const String& s)    { v = (uint64)         parseInt (s); }
+    inline void setFromString (double& v,         const String& s)    { v = parseDouble (s); }
+    inline void setFromString (float& v,          const String& s)    { v = (float) parseDouble (s); }
+    inline void setFromString (bool& v,           const String& s)    { v = (s == "true"); }
+    inline void setFromString (String& v,         const String& s)    { v = s; }
+    inline void setFromString (Colour& v,         const String& s)    { v = Colour ((uint32) parseInt (s)); }
+
+    template <typename Type>
+    inline String getAsString (const Type& v, bool)              { return String (v); }
+    inline String getAsString (char v, bool preferHex)           { return intToString ((int) v, preferHex); }
+    inline String getAsString (unsigned char v, bool preferHex)  { return intToString ((int) v, preferHex); }
+    inline String getAsString (short v, bool preferHex)          { return intToString ((int) v, preferHex); }
+    inline String getAsString (unsigned short v, bool preferHex) { return intToString ((int) v, preferHex); }
+    inline String getAsString (int v, bool preferHex)            { return intToString ((int) v, preferHex); }
+    inline String getAsString (unsigned int v, bool preferHex)   { return intToString ((int) v, preferHex); }
+    inline String getAsString (bool v, bool)                     { return v ? "true" : "false"; }
+    inline String getAsString (int64 v, bool preferHex)          { return intToString ((int64) v, preferHex); }
+    inline String getAsString (uint64 v, bool preferHex)         { return intToString ((int64) v, preferHex); }
+    inline String getAsString (Colour v, bool)                   { return intToString ((int) v.getARGB(), true); }
+
+    template <typename Type>    struct isStringType              { enum { value = 0 }; };
+    template <>                 struct isStringType<String>      { enum { value = 1 }; };
+
+    template <typename Type>
+    inline String getAsCode (Type& v, bool preferHex)       { return getAsString (v, preferHex); }
+    inline String getAsCode (Colour v, bool)                { return "Colour (0x" + String::toHexString ((int) v.getARGB()).paddedLeft ('0', 8) + ")"; }
+    inline String getAsCode (const String& v, bool)         { return CppTokeniserFunctions::addEscapeChars(v).quoted(); }
+    inline String getAsCode (const char* v, bool)           { return getAsCode (String (v), false); }
+
+    template <typename Type>
+    inline const char* castToCharPointer (const Type&)      { return ""; }
+    inline const char* castToCharPointer (const String& s)  { return s.toRawUTF8(); }
+
+    struct LivePropertyEditorBase;
+
+    //==============================================================================
+    struct JUCE_API  LiveValueBase
+    {
+        LiveValueBase (const char* file, int line);
+        virtual ~LiveValueBase();
+
+        virtual LivePropertyEditorBase* createPropertyComponent (CodeDocument&) = 0;
+        virtual String getStringValue (bool preferHex) const = 0;
+        virtual String getCodeValue (bool preferHex) const = 0;
+        virtual void setStringValue (const String&) = 0;
+        virtual String getOriginalStringValue (bool preferHex) const = 0;
+        virtual bool isString() const = 0;
+
+        String name, sourceFile;
+        int sourceLine;
+
+        JUCE_DECLARE_NON_COPYABLE (LiveValueBase)
+    };
+
+    //==============================================================================
+    struct JUCE_API  LivePropertyEditorBase  : public Component
+    {
+        LivePropertyEditorBase (LiveValueBase&, CodeDocument&);
+
+        void paint (Graphics&) override;
+        void resized() override;
+
+        void applyNewValue (const String&);
+        void selectOriginalValue();
+        void findOriginalValueInCode();
+
+        LiveValueBase& value;
+        Label name;
+        TextEditor valueEditor;
+        TextButton resetButton { "reset" };
+        CodeDocument& document;
+        CPlusPlusCodeTokeniser tokeniser;
+        CodeEditorComponent sourceEditor;
+        CodeDocument::Position valueStart, valueEnd;
+        std::unique_ptr<Component> customComp;
+        bool wasHex = false;
+
+        JUCE_DECLARE_NON_COPYABLE (LivePropertyEditorBase)
+    };
+
+    //==============================================================================
+    Component* createColourEditor (LivePropertyEditorBase&);
+    Component* createIntegerSlider (LivePropertyEditorBase&);
+    Component* createFloatSlider (LivePropertyEditorBase&);
+    Component* createBoolSlider (LivePropertyEditorBase&);
+
+    template <typename Type> struct CustomEditor    { static Component* create (LivePropertyEditorBase&)   { return nullptr; } };
+    template <> struct CustomEditor<char>           { static Component* create (LivePropertyEditorBase& e) { return createIntegerSlider (e); } };
+    template <> struct CustomEditor<unsigned char>  { static Component* create (LivePropertyEditorBase& e) { return createIntegerSlider (e); } };
+    template <> struct CustomEditor<int>            { static Component* create (LivePropertyEditorBase& e) { return createIntegerSlider (e); } };
+    template <> struct CustomEditor<unsigned int>   { static Component* create (LivePropertyEditorBase& e) { return createIntegerSlider (e); } };
+    template <> struct CustomEditor<short>          { static Component* create (LivePropertyEditorBase& e) { return createIntegerSlider (e); } };
+    template <> struct CustomEditor<unsigned short> { static Component* create (LivePropertyEditorBase& e) { return createIntegerSlider (e); } };
+    template <> struct CustomEditor<int64>          { static Component* create (LivePropertyEditorBase& e) { return createIntegerSlider (e); } };
+    template <> struct CustomEditor<uint64>         { static Component* create (LivePropertyEditorBase& e) { return createIntegerSlider (e); } };
+    template <> struct CustomEditor<float>          { static Component* create (LivePropertyEditorBase& e) { return createFloatSlider (e); } };
+    template <> struct CustomEditor<double>         { static Component* create (LivePropertyEditorBase& e) { return createFloatSlider (e); } };
+    template <> struct CustomEditor<Colour>         { static Component* create (LivePropertyEditorBase& e) { return createColourEditor (e); } };
+    template <> struct CustomEditor<bool>           { static Component* create (LivePropertyEditorBase& e) { return createBoolSlider (e); } };
+
+    template <typename Type>
+    struct LivePropertyEditor  : public LivePropertyEditorBase
+    {
+        template <typename ValueType>
+        LivePropertyEditor (ValueType& v, CodeDocument& d)  : LivePropertyEditorBase (v, d)
+        {
+            customComp.reset (CustomEditor<Type>::create (*this));
+            addAndMakeVisible (customComp.get());
+        }
+    };
+
+    //==============================================================================
+    template <typename Type>
+    struct LiveValue  : public LiveValueBase
+    {
+        LiveValue (const char* file, int line, const Type& initialValue)
+            : LiveValueBase (file, line), value (initialValue), originalValue (initialValue)
+        {}
+
+        operator Type() const noexcept   { return value; }
+        Type get() const noexcept        { return value; }
+        operator const char*() const     { return castToCharPointer (value); }
+
+        LivePropertyEditorBase* createPropertyComponent (CodeDocument& doc) override
+        {
+            return new LivePropertyEditor<Type> (*this, doc);
+        }
+
+        String getStringValue (bool preferHex) const override           { return getAsString (value, preferHex); }
+        String getCodeValue (bool preferHex) const override             { return getAsCode (value, preferHex); }
+        String getOriginalStringValue (bool preferHex) const override   { return getAsString (originalValue, preferHex); }
+        void setStringValue (const String& s) override                  { setFromString (value, s); }
+        bool isString() const override                                  { return isStringType<Type>::value; }
+
+        Type value, originalValue;
+
+        JUCE_DECLARE_NON_COPYABLE (LiveValue)
+    };
+
+    //==============================================================================
+    class JUCE_API ValueList  : private AsyncUpdater,
+                                private DeletedAtShutdown
+    {
+    public:
+        ValueList();
+        ~ValueList() override;
+
+        JUCE_DECLARE_SINGLETON (ValueList, false)
+
+        template <typename Type>
+        LiveValue<Type>& getValue (const char* file, int line, const Type& initialValue)
+        {
+            const ScopedLock sl (lock);
+            using ValueType = LiveValue<Type>;
+
+            for (auto* v : values)
+                if (v->sourceLine == line && v->sourceFile == file)
+                    return *static_cast<ValueType*> (v);
+
+            auto v = new ValueType (file, line, initialValue);
+            addValue (v);
+            return *v;
+        }
+
+    private:
+        OwnedArray<LiveValueBase> values;
+        OwnedArray<CodeDocument> documents;
+        Array<File> documentFiles;
+        class EditorWindow;
+        Component::SafePointer<EditorWindow> editorWindow;
+        CriticalSection lock;
+
+        CodeDocument& getDocument (const File&);
+        void addValue (LiveValueBase*);
+        void handleAsyncUpdate() override;
+    };
+
+    template <typename Type>
+    inline LiveValue<Type>& getValue (const char* file, int line, const Type& initialValue)
+    {
+        // If you hit this assertion then the __FILE__ macro is providing a
+        // relative path instead of an absolute path. On Windows this will be
+        // a path relative to the build directory rather than the currently
+        // running application. To fix this you must compile with the /FC flag.
+        jassert (File::isAbsolutePath (file));
+
+        return ValueList::getInstance()->getValue (file, line, initialValue);
+    }
+
+    inline LiveValue<String>& getValue (const char* file, int line, const char* initialValue)
+    {
+        return getValue (file, line, String (initialValue));
+    }
+}
+
+#endif
+
+//==============================================================================
+#if JUCE_ENABLE_LIVE_CONSTANT_EDITOR || DOXYGEN
+ /**
+    This macro wraps a primitive constant value in some cunning boilerplate code that allows
+    its value to be interactively tweaked in a popup window while your application is running.
+
+    In a release build, this macro disappears and is replaced by only the constant that it
+    wraps, but if JUCE_ENABLE_LIVE_CONSTANT_EDITOR is enabled, it injects a class wrapper
+    that automatically pops-up a window containing an editor that allows the value to be
+    tweaked at run-time. The editor window will also force all visible components to be
+    resized and repainted whenever a value is changed, so that if you use this to wrap
+    a colour or layout parameter, you'll be able to immediately see the effects of changing it.
+
+    The editor will also load the original source-file that contains each JUCE_LIVE_CONSTANT
+    macro, and will display a preview of the modified source code as you adjust the values.
+
+    Things to note:
+
+    - Only one of these per line! The __FILE__ and __LINE__ macros are used to identify
+      the value, so things will get confused if you have more than one per line
+    - Obviously because it needs to load the source code based on the __FILE__ macro,
+      it'll only work if the source files are stored locally in the same location as they
+      were when you compiled the program.
+    - It's only designed to cope with simple types: primitives, string literals, and
+      the Colour class, so if you try using it for other classes or complex expressions,
+      good luck!
+    - The editor window will get popped up whenever a new value is used for the first
+      time. You can close the window, but there's no way to get it back without restarting
+      the app!
+
+    e.g. in this example the colours, font size, and text used in the paint method can
+    all be adjusted live:
+    @code
+    void MyComp::paint (Graphics& g) override
+    {
+        g.fillAll (JUCE_LIVE_CONSTANT (Colour (0xffddddff)));
+
+        Colour fontColour = JUCE_LIVE_CONSTANT (Colour (0xff005500));
+        float fontSize = JUCE_LIVE_CONSTANT (16.0f);
+
+        g.setColour (fontColour);
+        g.setFont (fontSize);
+
+        g.drawFittedText (JUCE_LIVE_CONSTANT ("Hello world!"),
+                          getLocalBounds(), Justification::centred, 2);
+    }
+    @endcode
+ */
+ #define JUCE_LIVE_CONSTANT(initialValue) \
+    (juce::LiveConstantEditor::getValue (__FILE__, __LINE__ - 1, initialValue).get())
+#else
+ #define JUCE_LIVE_CONSTANT(initialValue) \
+    (initialValue)
+#endif
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_PreferencesPanel.cpp

@@ -0,0 +1,156 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+PreferencesPanel::PreferencesPanel()
+    : buttonSize (70)
+{
+}
+
+PreferencesPanel::~PreferencesPanel()
+{
+}
+
+int PreferencesPanel::getButtonSize() const noexcept
+{
+    return buttonSize;
+}
+
+void PreferencesPanel::setButtonSize (int newSize)
+{
+    buttonSize = newSize;
+    resized();
+}
+
+//==============================================================================
+void PreferencesPanel::addSettingsPage (const String& title,
+                                        const Drawable* icon,
+                                        const Drawable* overIcon,
+                                        const Drawable* downIcon)
+{
+    auto* button = new DrawableButton (title, DrawableButton::ImageAboveTextLabel);
+    buttons.add (button);
+
+    button->setImages (icon, overIcon, downIcon);
+    button->setRadioGroupId (1);
+    button->onClick = [this] { clickedPage(); };
+    button->setClickingTogglesState (true);
+    button->setWantsKeyboardFocus (false);
+    addAndMakeVisible (button);
+
+    resized();
+
+    if (currentPage == nullptr)
+        setCurrentPage (title);
+}
+
+void PreferencesPanel::addSettingsPage (const String& title, const void* imageData, int imageDataSize)
+{
+    DrawableImage icon, iconOver, iconDown;
+    icon.setImage (ImageCache::getFromMemory (imageData, imageDataSize));
+
+    iconOver.setImage (ImageCache::getFromMemory (imageData, imageDataSize));
+    iconOver.setOverlayColour (Colours::black.withAlpha (0.12f));
+
+    iconDown.setImage (ImageCache::getFromMemory (imageData, imageDataSize));
+    iconDown.setOverlayColour (Colours::black.withAlpha (0.25f));
+
+    addSettingsPage (title, &icon, &iconOver, &iconDown);
+}
+
+//==============================================================================
+void PreferencesPanel::showInDialogBox (const String& dialogTitle, int dialogWidth, int dialogHeight, Colour backgroundColour)
+{
+    setSize (dialogWidth, dialogHeight);
+
+    DialogWindow::LaunchOptions o;
+    o.content.setNonOwned (this);
+    o.dialogTitle                   = dialogTitle;
+    o.dialogBackgroundColour        = backgroundColour;
+    o.escapeKeyTriggersCloseButton  = false;
+    o.useNativeTitleBar             = false;
+    o.resizable                     = false;
+
+    o.launchAsync();
+}
+
+//==============================================================================
+void PreferencesPanel::resized()
+{
+    for (int i = 0; i < buttons.size(); ++i)
+        buttons.getUnchecked(i)->setBounds (i * buttonSize, 0, buttonSize, buttonSize);
+
+    if (currentPage != nullptr)
+        currentPage->setBounds (getLocalBounds().withTop (buttonSize + 5));
+}
+
+void PreferencesPanel::paint (Graphics& g)
+{
+    g.setColour (Colours::grey);
+    g.fillRect (0, buttonSize + 2, getWidth(), 1);
+}
+
+void PreferencesPanel::setCurrentPage (const String& pageName)
+{
+    if (currentPageName != pageName)
+    {
+        currentPageName = pageName;
+
+        currentPage.reset();
+        currentPage.reset (createComponentForPage (pageName));
+
+        if (currentPage != nullptr)
+        {
+            addAndMakeVisible (currentPage.get());
+            currentPage->toBack();
+            resized();
+        }
+
+        for (auto* b : buttons)
+        {
+            if (b->getName() == pageName)
+            {
+                b->setToggleState (true, dontSendNotification);
+                break;
+            }
+        }
+    }
+}
+
+void PreferencesPanel::clickedPage()
+{
+    for (auto* b : buttons)
+    {
+        if (b->getToggleState())
+        {
+            setCurrentPage (b->getName());
+            break;
+        }
+    }
+}
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_PreferencesPanel.h

@@ -0,0 +1,147 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+//==============================================================================
+/**
+    A component with a set of buttons at the top for changing between pages of
+    preferences.
+
+    This is just a handy way of writing a Mac-style preferences panel where you
+    have a row of buttons along the top for the different preference categories,
+    each button having an icon above its name. Clicking these will show an
+    appropriate prefs page below it.
+
+    You can either put one of these inside your own component, or just use the
+    showInDialogBox() method to show it in a window and run it modally.
+
+    To use it, just add a set of named pages with the addSettingsPage() method,
+    and implement the createComponentForPage() method to create suitable components
+    for each of these pages.
+
+    @tags{GUI}
+*/
+class JUCE_API  PreferencesPanel  : public Component
+{
+public:
+    //==============================================================================
+    /** Creates an empty panel.
+
+        Use addSettingsPage() to add some pages to it in your constructor.
+    */
+    PreferencesPanel();
+
+    /** Destructor. */
+    ~PreferencesPanel() override;
+
+    //==============================================================================
+    /** Creates a page using a set of drawables to define the page's icon.
+
+        Note that the other version of this method is much easier if you're using
+        an image instead of a custom drawable.
+
+        @param pageTitle    the name of this preferences page - you'll need to
+                            make sure your createComponentForPage() method creates
+                            a suitable component when it is passed this name
+        @param normalIcon   the drawable to display in the page's button normally
+        @param overIcon     the drawable to display in the page's button when the mouse is over
+        @param downIcon     the drawable to display in the page's button when the button is down
+        @see DrawableButton
+    */
+    void addSettingsPage (const String& pageTitle,
+                          const Drawable* normalIcon,
+                          const Drawable* overIcon,
+                          const Drawable* downIcon);
+
+    /** Creates a page using a set of drawables to define the page's icon.
+
+        The other version of this method gives you more control over the icon, but this
+        one is much easier if you're just loading it from a file.
+
+        @param pageTitle        the name of this preferences page - you'll need to
+                                make sure your createComponentForPage() method creates
+                                a suitable component when it is passed this name
+        @param imageData        a block of data containing an image file, e.g. a jpeg, png or gif.
+                                For this to look good, you'll probably want to use a nice
+                                transparent png file.
+        @param imageDataSize    the size of the image data, in bytes
+    */
+    void addSettingsPage (const String& pageTitle,
+                          const void* imageData,
+                          int imageDataSize);
+
+    /** Utility method to display this panel in a DialogWindow.
+
+        Calling this will create a DialogWindow containing this panel with the
+        given size and title, and will run it modally, returning when the user
+        closes the dialog box.
+    */
+    void showInDialogBox (const String& dialogTitle,
+                          int dialogWidth,
+                          int dialogHeight,
+                          Colour backgroundColour = Colours::white);
+
+    //==============================================================================
+    /** Subclasses must override this to return a component for each preferences page.
+
+        The subclass should return a pointer to a new component representing the named
+        page, which the panel will then display.
+
+        The panel will delete the component later when the user goes to another page
+        or deletes the panel.
+    */
+    virtual Component* createComponentForPage (const String& pageName) = 0;
+
+    //==============================================================================
+    /** Changes the current page being displayed. */
+    void setCurrentPage (const String& pageName);
+
+    /** Returns the size of the buttons shown along the top. */
+    int getButtonSize() const noexcept;
+
+    /** Changes the size of the buttons shown along the top. */
+    void setButtonSize (int newSize);
+
+    //==============================================================================
+    /** @internal */
+    void resized() override;
+    /** @internal */
+    void paint (Graphics&) override;
+
+private:
+    //==============================================================================
+    String currentPageName;
+    std::unique_ptr<Component> currentPage;
+    OwnedArray<DrawableButton> buttons;
+    int buttonSize;
+
+    void clickedPage();
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (PreferencesPanel)
+};
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_PushNotifications.cpp

@@ -0,0 +1,229 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+//==============================================================================
+#if ! JUCE_ANDROID && ! JUCE_IOS && ! JUCE_MAC
+bool PushNotifications::Notification::isValid() const noexcept { return true; }
+#endif
+
+PushNotifications::Notification::Notification (const Notification& other)
+    : identifier (other.identifier),
+      title (other.title),
+      body (other.body),
+      subtitle (other.subtitle),
+      groupId (other.groupId),
+      badgeNumber (other.badgeNumber),
+      soundToPlay (other.soundToPlay),
+      properties (other.properties),
+      category (other.category),
+      triggerIntervalSec (other.triggerIntervalSec),
+      repeat (other.repeat),
+      icon (other.icon),
+      channelId (other.channelId),
+      largeIcon (other.largeIcon),
+      tickerText (other.tickerText),
+      actions (other.actions),
+      progress (other.progress),
+      person (other.person),
+      type (other.type),
+      priority (other.priority),
+      lockScreenAppearance (other.lockScreenAppearance),
+      publicVersion (other.publicVersion.get() != nullptr ? new Notification (*other.publicVersion) : nullptr),
+      groupSortKey (other.groupSortKey),
+      groupSummary (other.groupSummary),
+      accentColour (other.accentColour),
+      ledColour (other.ledColour),
+      ledBlinkPattern (other.ledBlinkPattern),
+      vibrationPattern (other.vibrationPattern),
+      shouldAutoCancel (other.shouldAutoCancel),
+      localOnly (other.localOnly),
+      ongoing (other.ongoing),
+      alertOnlyOnce (other.alertOnlyOnce),
+      timestampVisibility (other.timestampVisibility),
+      badgeIconType (other.badgeIconType),
+      groupAlertBehaviour (other.groupAlertBehaviour),
+      timeoutAfterMs (other.timeoutAfterMs)
+{
+}
+
+//==============================================================================
+JUCE_IMPLEMENT_SINGLETON (PushNotifications)
+
+PushNotifications::PushNotifications()
+  #if JUCE_PUSH_NOTIFICATIONS
+    : pimpl (new Pimpl (*this))
+  #endif
+{
+}
+
+PushNotifications::~PushNotifications() { clearSingletonInstance(); }
+
+void PushNotifications::addListener (Listener* l)      { listeners.add (l); }
+void PushNotifications::removeListener (Listener* l)   { listeners.remove (l); }
+
+void PushNotifications::requestPermissionsWithSettings (const PushNotifications::Settings& settings)
+{
+  #if JUCE_PUSH_NOTIFICATIONS && (JUCE_IOS || JUCE_MAC)
+    pimpl->requestPermissionsWithSettings (settings);
+  #else
+    ignoreUnused (settings);
+    listeners.call ([] (Listener& l) { l.notificationSettingsReceived ({}); });
+  #endif
+}
+
+void PushNotifications::requestSettingsUsed()
+{
+  #if JUCE_PUSH_NOTIFICATIONS && (JUCE_IOS || JUCE_MAC)
+    pimpl->requestSettingsUsed();
+  #else
+    listeners.call ([] (Listener& l) { l.notificationSettingsReceived ({}); });
+  #endif
+}
+
+bool PushNotifications::areNotificationsEnabled() const
+{
+  #if JUCE_PUSH_NOTIFICATIONS
+    return pimpl->areNotificationsEnabled();
+  #else
+    return false;
+  #endif
+}
+
+void PushNotifications::getDeliveredNotifications() const
+{
+  #if JUCE_PUSH_NOTIFICATIONS
+    pimpl->getDeliveredNotifications();
+  #endif
+}
+
+void PushNotifications::removeAllDeliveredNotifications()
+{
+  #if JUCE_PUSH_NOTIFICATIONS
+    pimpl->removeAllDeliveredNotifications();
+  #endif
+}
+
+String PushNotifications::getDeviceToken() const
+{
+  #if JUCE_PUSH_NOTIFICATIONS
+    return pimpl->getDeviceToken();
+  #else
+    return {};
+  #endif
+}
+
+void PushNotifications::setupChannels (const Array<ChannelGroup>& groups, const Array<Channel>& channels)
+{
+  #if JUCE_PUSH_NOTIFICATIONS
+    pimpl->setupChannels (groups, channels);
+  #else
+    ignoreUnused (groups, channels);
+  #endif
+}
+
+void PushNotifications::getPendingLocalNotifications() const
+{
+  #if JUCE_PUSH_NOTIFICATIONS
+    pimpl->getPendingLocalNotifications();
+  #endif
+}
+
+void PushNotifications::removeAllPendingLocalNotifications()
+{
+  #if JUCE_PUSH_NOTIFICATIONS
+    pimpl->removeAllPendingLocalNotifications();
+  #endif
+}
+
+void PushNotifications::subscribeToTopic (const String& topic)
+{
+  #if JUCE_PUSH_NOTIFICATIONS
+    pimpl->subscribeToTopic (topic);
+  #else
+    ignoreUnused (topic);
+  #endif
+}
+
+void PushNotifications::unsubscribeFromTopic (const String& topic)
+{
+  #if JUCE_PUSH_NOTIFICATIONS
+    pimpl->unsubscribeFromTopic (topic);
+  #else
+    ignoreUnused (topic);
+  #endif
+}
+
+
+void PushNotifications::sendLocalNotification (const Notification& n)
+{
+  #if JUCE_PUSH_NOTIFICATIONS
+    pimpl->sendLocalNotification (n);
+  #else
+    ignoreUnused (n);
+  #endif
+}
+
+void PushNotifications::removeDeliveredNotification (const String& identifier)
+{
+  #if JUCE_PUSH_NOTIFICATIONS
+    pimpl->removeDeliveredNotification (identifier);
+  #else
+    ignoreUnused (identifier);
+  #endif
+}
+
+void PushNotifications::removePendingLocalNotification (const String& identifier)
+{
+  #if JUCE_PUSH_NOTIFICATIONS
+    pimpl->removePendingLocalNotification (identifier);
+  #else
+    ignoreUnused (identifier);
+  #endif
+}
+
+void PushNotifications::sendUpstreamMessage (const String& serverSenderId,
+                                             const String& collapseKey,
+                                             const String& messageId,
+                                             const String& messageType,
+                                             int timeToLive,
+                                             const StringPairArray& additionalData)
+{
+  #if JUCE_PUSH_NOTIFICATIONS
+    pimpl->sendUpstreamMessage (serverSenderId,
+                                collapseKey,
+                                messageId,
+                                messageType,
+                                timeToLive,
+                                additionalData);
+  #else
+    ignoreUnused (serverSenderId, collapseKey, messageId, messageType);
+    ignoreUnused (timeToLive, additionalData);
+  #endif
+}
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_PushNotifications.h

@@ -0,0 +1,715 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+#pragma once
+
+namespace juce
+{
+
+/** Singleton class responsible for push notifications functionality. Both remote and
+    local notifications are supported. To get information about notifications,
+    register a listener on your application startup. It is best to register the
+    listener as soon as possible, because your application can be launched from
+    a push notification too.
+
+    To send a local notification create an instance of Notification, fill the necessary
+    fields and call PushNotifications::sendLocalNotification(). When receiving local or
+    remote notifications, inspect the Notification's fields for notification details.
+    Bear in mind that some fields will not be available when receiving a remote
+    notification.
+
+    @tags{GUI}
+*/
+class JUCE_API PushNotifications    : private DeletedAtShutdown
+{
+public:
+   #ifndef DOXYGEN
+    JUCE_DECLARE_SINGLETON (PushNotifications, false)
+   #endif
+
+    //==============================================================================
+    /** Represents a notification that can be sent or received. */
+    struct Notification
+    {
+        Notification() = default;
+        Notification (const Notification& other);
+
+        /** Checks whether a given notification is correctly configured for a given OS. */
+        bool isValid() const noexcept;
+
+        /** Represents an action on a notification that can be presented as a button or a text input.
+            On Android, each notification has its action specified explicitly, on iOS you configure an
+            allowed set of actions on startup and pack them into categories (see Settings).
+        */
+        struct Action
+        {
+            /** Controls the appearance of this action. */
+            enum Style
+            {
+                button,                    /**< Show this action as a button. */
+                text                       /**< Show this action as a text input field (on Android API 20 or higher is required). */
+            };
+
+            /** @name Common fields */
+            /**@{*/
+            Style  style = button;
+            String title;                 /**< Required. the name of the action displayed to the user. */
+            String textInputPlaceholder;  /**< Optional: placeholder text for text input notification.
+                                               Note that it will be ignored if button style is used. */
+            var    parameters;            /**< Optional: additional parameters that can be passed. */
+            /**@}*/
+
+            /** @name iOS only fields */
+            /**@{*/
+            String  identifier;                    /**< Required: unique identifier. This should be one of the
+                                                        identifiers set with requestPermissionsWithSettings(). */
+            bool    triggerInBackground = false;   /**< Whether the app can process the action in background. */
+            bool    destructive = false;           /**< Whether to display the action as destructive. */
+            String  textInputButtonText;           /**< Optional: Text displayed on text input notification
+                                                        button (from iOS 10 only).
+                                                        Note that it will be ignored if style is set to Style::button. */
+            /**@}*/
+
+            /** @name Android only fields */
+            /**@{*/
+            String       icon;            /**< Optional: name of an icon file (without an extension) to be used for
+                                                         this action. This must be the name of one of the image
+                                                         files included into resources when exporting an Android project
+                                                         (see "Extra Android Raw Resources" setting in Projucer).
+                                                         Note that not all Android versions support an icon for an action, though
+                                                         it is recommended to provide it nevertheless. */
+
+            StringArray allowedResponses; /**< Optional: a list of possible answers if the answer set is limited.
+                                               When left empty, then the user will be able to input any text. */
+            /**@}*/
+        };
+
+        //==============================================================================
+        /** @name Common fields */
+        /**@{*/
+
+        String identifier;   /**< Required: unique id that can be used to later dismiss the notification
+                                  (on iOS available from version 10). */
+
+        String title;        /**< Required: the title of the notification, usually displayed in the first row. */
+        String body;         /**< Required: the content of the notification, usually displayed in the second row. */
+        String subtitle;     /**< Optional: additional text, that may be displayed e.g. in the third row or in the header
+                                  area. Note that on Android, depending on OS version, this may fight for
+                                  space with other components of the notification, so use this field
+                                  judiciously. On iOS available from version 10. On Android available from API 16. */
+
+        String groupId;      /**< Optional: allows the OS to visually group, collapse, and expand a set of notifications,
+                                  note that OS may automatically group notifications if no groupId is specified.
+                                  Available on Android API 20 or above and iOS 10 or above. */
+
+        int badgeNumber = 0; /**< Optional: on platforms that support it, can set a number this notification represents. */
+        URL soundToPlay;     /**< Optional: empty when the notification should be silent. When the name is set to
+                                  "default_os_sound", then a default sound will be used.
+
+                                  For a custom sound on OSX, set the URL to the name of a sound file (preferably without
+                                  an extension) and place the sound file directly in bundle's "Resources" directory (you
+                                  can use "Xcode Resource" tickbox in Projucer to achieve that), i.e. it cannot be in a
+                                  subdirectory of "Resources" like "Resources/sound". Alternatively, if a sound file
+                                  cannot be found in bundle's "Resources" directory, the OS may look for the sound in the
+                                  following paths: "~/Library/Sounds", "/Library/Sounds", "/Network/Library/Sounds",
+                                  "/System/Library/Sounds".
+
+                                  For a custom sound on iOS, set the URL to a relative path within your bundle, including
+                                  file extension. For instance, if your bundle contains "sounds" folder with "my_sound.caf"
+                                  file, then the URL should be "sounds/my_sound.caf".
+
+                                  For a custom sound on Android, set URL to the name of a raw resource file
+                                  (without an extension) that was included when exporting an Android project in
+                                  Projucer (see "Extra Android Raw Resources" setting). */
+
+        var properties;      /**< Optional: collection of additional properties that may be passed as a dictionary. */
+
+        /**@}*/
+
+        //==============================================================================
+        /** @name iOS only fields */
+        /**@{*/
+
+        String category;                /**< Required: determines set of actions that will appear (as per setup done
+                                             in requestPermissionsWithSettings()). */
+        double triggerIntervalSec = 0.; /**< Optional: specifies number of seconds before the notification should trigger. */
+        bool   repeat = false;          /**< Optional: allows the notification to continuously retrigger after
+                                             triggerIntervalSec seconds. Available from iOS 10. */
+
+        /**@}*/
+
+        //==============================================================================
+        /** @name Android only fields */
+        /**@{*/
+
+        String icon;             /**< Required: name of an icon file (without an extension) to be used for
+                                                this notification. This must be the name of one of the image
+                                                files included into resources when exporting an Android project
+                                                (see "Extra Android Raw Resources" setting in Projucer). */
+
+        String channelId;       /**< Required for Android API level 26 or above: specifies notification channel id. Refer to
+                                     setupChannels(). Ignored on earlier Android versions. */
+
+        Image largeIcon;        /**< Optional: an additional large icon displayed in the notification content view. */
+
+        String tickerText;      /**< Optional: ticker text used for accessibility services. */
+
+        Array<Action> actions;  /**< Optional: actions associated with the notification. Note that the OS may allow only a limited
+                                     number of actions to be presented, so always present most important actions first.
+                                     Available from Android API 16 or above. */
+
+        /** Used to represent a progress of some operation. */
+        struct Progress
+        {
+            int  max = 0;               /**< Max possible value of a progress. A typical usecase is to set max to 100 and increment
+                                             current's value as percentage complete. */
+            int  current = 0;           /**< Current progress value, should be from 0 to max. */
+            bool indeterminate = false; /**< If true, then the progress represents a continuing activity indicator with ongoing
+                                             animation and no numeric value. */
+        };
+
+        Progress progress;       /**< Optional: set to default (0, 0, false), to disable progress display. */
+
+        /** Metadata that can be used by the OS to better handle the notification, depending on its priority. */
+        enum Type
+        {
+            unspecified,       /**< Category not set. */
+            alarm,             /**< Alarm or timer. */
+            call,              /**< Incoming voice/video call or similar. */
+            email,             /**< Async message like email. */
+            error,             /**< Error in background operation or authentication status. */
+            event,             /**< Calendar event. */
+            message,           /**< Incoming message (sms, instant message etc.). */
+            taskProgress,      /**< Progress for a long-running background operation. */
+            promo,             /**< Promotion or advertisement. */
+            recommendation,    /**< Specific, single thing related recommendation. */
+            reminder,          /**< User-scheduled reminder. */
+            service,           /**< Running background service. */
+            social,            /**< Social network or sharing update. */
+            status,            /**< Ongoing information about device or contextual status. */
+            system,            /**< System or device status update. */
+            transport          /**< Media transport control for playback. */
+        };
+
+        /** Metadata used as a hint to the OS about the priority of the notification. */
+        enum Priority
+        {
+            veryLow  = -2,
+            low      = -1,
+            medium   =  0,
+            high     =  1,
+            veryHigh =  2
+        };
+
+        String person;               /**< Optional: additional metadata used as a hint to OS that a notification is
+                                          related to a specific person. Can be useful for instance messaging apps.
+                                          Available from Android API 21 or above. */
+
+        Type type = unspecified;     /**< Optional. Available from Android API 21 or above. */
+        Priority priority = medium;  /**< Optional. Available from Android API 16 or above. */
+
+        /** Describes how to show the notification when the screen is locked. Available from Android API 21 or above. */
+        enum LockScreenAppearance
+        {
+            dontShow       = -1,  /**< The notification is not allowed on the lock screen */
+            showPartially  =  0,  /**< Only some information is allowed on the lock screen */
+            showCompletely =  1   /**< The entire notification is allowed on the lock screen */
+        };
+
+        LockScreenAppearance lockScreenAppearance = showPartially;  /**< Optional. */
+
+        std::unique_ptr<Notification> publicVersion; /**< Optional: if you set lockScreenAppearance to showPartially,
+                                                          then you can provide "public version" of your notification
+                                                          that will be displayed on the lock screen. This way you can
+                                                          control what information is visible when the screen is locked. */
+
+        String groupSortKey;         /**< Optional: Used to order notifications within the same group. Available from Android API 20 or above. */
+        bool groupSummary = false;   /**< Optional: if true, then this notification will be a group summary of the group set with groupId.
+                                                    Available from Android API 20 or above. */
+
+        Colour accentColour;  /**< Optional: sets accent colour. The default colour will be used if accentColour is not set.
+                                             Available from Android API 21 or above. */
+        Colour ledColour;     /**< Optional: Sets the led colour. The hardware will do its best to approximate the colour.
+                                   The default colour will be used if ledColour is not set. */
+
+        /** Allows to control the time the device's led is on and off. */
+        struct LedBlinkPattern
+        {
+            int msToBeOn  = 0;   /**< The led will be on for the given number of milliseconds, after which it will turn off. */
+            int msToBeOff = 0;   /**< The led will be off for the given number of milliseconds, after which it will turn on. */
+        };
+
+        LedBlinkPattern ledBlinkPattern; /**< Optional. */
+
+        Array<int> vibrationPattern;  /**< Optional: sets the vibration pattern in milliseconds. The first value indicates how long
+                                           to wait until vibration starts. The second value indicates how long to vibrate. The third
+                                           value will say how long to not vibrate and so on. For instance, if the pattern is:
+                                           1000, 2000, 3000, 4000 - then one second after receiving a notification the device will
+                                           vibrate for two seconds, followed by 3 seconds of no vibration and finally, 4 seconds of
+                                           vibration. */
+
+        bool shouldAutoCancel = true; /**< Optional: If true, the notification will be automatically cancelled when a user clicks it in the panel. */
+
+        bool localOnly = true;  /**< Optional: whether or not the notification should bridge to other devices.
+                                               Available from Android API 20 or above. */
+
+        bool ongoing = false;   /**< Optional: If true, then it cannot be dismissed by the user and it must be dismissed manually.
+                                     Typically used for ongoing background tasks that the user is actively engaged with. To
+                                     dismiss such notification, you need to call removeDeliveredNotification() or
+                                     removeAllDeliveredNotifications(). */
+
+        bool alertOnlyOnce = false; /**< Optional: Set this flag if you would only like the sound, vibrate and ticker to be played if the notification
+                                         is not already showing. */
+
+        /** Controls timestamp visibility and format. */
+        enum TimestampVisibility
+        {
+            off,                    /**< Do not show timestamp. */
+            normal,                 /**< Show normal timestamp. */
+            chronometer,            /**< Show chronometer as a stopwatch. Available from Android API 16 or above. */
+            countDownChronometer    /**< Set the chronometer to count down instead of counting up. Available from Android API 24 or above.*/
+        };
+
+        TimestampVisibility timestampVisibility = normal;  /**< Optional. */
+
+        /** Controls badge icon type to use if a notification is shown as a badge. Available from Android API 26 or above. */
+        enum BadgeIconType
+        {
+            none,
+            small,
+            large
+        };
+
+        BadgeIconType badgeIconType = large;
+
+        /** Controls sound and vibration behaviour for group notifications. Available from Android API 26 or above. */
+        enum GroupAlertBehaviour
+        {
+            alertAll,           /**< both child notifications and group notifications should produce sound and vibration. */
+            AlertSummary,       /**< all child notifications in the group should have no sound nor vibration, even
+                                     if corresponding notification channel has sounds and vibrations enabled. */
+            AlertChildren       /**< summary notifications in the group should have no sound nor vibration, even if
+                                     corresponding notification channel has sounds and vibrations enabled. */
+        };
+
+        GroupAlertBehaviour groupAlertBehaviour = alertAll;
+
+        int timeoutAfterMs = 0;    /**< specifies a duration in milliseconds, after which the notification should be
+                                        cancelled, if it is not already cancelled. Available from Android API 26 or above. */
+        /**@}*/
+    };
+
+
+    //==============================================================================
+    /** Describes settings we want to use for current device. Note that at the
+        moment this is only used on iOS and partially on OSX.
+
+        On OSX only allow* flags are used and they control remote notifications only.
+        To control sound, alert and badge settings for local notifications on OSX,
+        use Notifications settings in System Preferences.
+
+        To setup push notifications for current device, provide permissions required,
+        as well as register categories of notifications you want to support. Each
+        category needs to have a unique identifier and it can optionally have multiple
+        actions. Each action also needs to have a unique identifier. The example setup
+        may look as follows:
+
+        @code
+
+        using Action   = PushNotifications::Settings::Action;
+        using Category = PushNotifications::Settings::Category;
+
+        Action okAction;
+        okAction.identifier = "okAction";
+        okAction.title = "OK!";
+        okAction.style = Action::button;
+        okAction.triggerInBackground = true;
+
+        Action cancelAction;
+        cancelAction.identifier = "cancelAction";
+        cancelAction.title = "Cancel";
+        cancelAction.style = Action::button;
+        cancelAction.triggerInBackground = true;
+        cancelAction.destructive = true;
+
+        Action textAction;
+        textAction.identifier = "textAction";
+        textAction.title = "Enter text";
+        textAction.style = Action::text;
+        textAction.triggerInBackground = true;
+        textAction.destructive = false;
+        textAction.textInputButtonText = "Ok";
+        textAction.textInputPlaceholder = "Enter text...";
+
+        Category okCategory;
+        okCategory.identifier = "okCategory";
+        okCategory.actions = { okAction };
+
+        Category okCancelCategory;
+        okCancelCategory.identifier = "okCancelCategory";
+        okCancelCategory.actions = { okAction, cancelAction };
+
+        Category textCategory;
+        textCategory.identifier = "textCategory";
+        textCategory.actions = { textAction };
+        textCategory.sendDismissAction = true;
+
+        PushNotifications::Settings settings;
+        settings.allowAlert = true;
+        settings.allowBadge = true;
+        settings.allowSound = true;
+        settings.categories = { okCategory, okCancelCategory, textCategory };
+
+        @endcode
+    */
+    struct Settings
+    {
+        using Action = Notification::Action;
+
+        /** Describes a category of a notification. Each category has a unique identifier
+            and a list of associated actions.
+            Note that the OS may allow only a limited number of actions to be presented, so
+            always present most important actions first.
+        */
+        struct Category
+        {
+            juce::String identifier;         /**< unique identifier */
+            juce::Array<Action> actions;     /**< optional list of actions within this category */
+            bool sendDismissAction = false;  /**< whether dismiss action will be sent to the app (from iOS 10 only) */
+        };
+
+        bool allowSound = false;      /**< whether the app should play a sound upon notification */
+        bool allowAlert = false;      /**< whether the app should present an alert upon notification */
+        bool allowBadge = false;      /**< whether the app may badge its icon upon notification */
+        Array<Category> categories;   /**< list of categories the app wants to support */
+    };
+
+    /** Initialises push notifications on current device with the settings provided.
+        Call this on your application startup and on iOS the first time the application starts,
+        a user will be presented with a permission request dialog to give push notifications permission.
+        Once a user responds, Listener::notificationSettingsReceived() will be called so that
+        you can check what permissions where actually granted. The listener callback will be called
+        on each subsequent startup too (provided you called requestPermissionsWithSettings() on previous
+        application run). This way you can check what are current push notifications permissions.
+
+        Note that settings are currently only used on iOS. When calling on other platforms, Settings
+        with no categories and all allow* flags set to true will be received in
+        Listener::notificationSettingsReceived().
+
+        You can also call requestSettingsUsed() to explicitly ask for current settings.
+    */
+    void requestPermissionsWithSettings (const Settings& settings);
+
+    /** Sends an asynchronous request to retrieve current settings that are currently in use.
+        These can be exactly the same as used in requestPermissionsWithSettings(), but depending
+        on user's subsequent changes in OS settings, the actual current settings may be
+        different (e.g. user might have later decided to disable sounds).
+
+        Note that settings are currently only used on iOS and partially on OSX.
+
+        On OSX, only allow* flags are used and they refer to remote notifications only. For
+        local notifications, refer to System Preferences.
+
+        When calling this function on other platforms, Settings with no categories and all allow*
+        flags set to true will be received in Listener::notificationSettingsReceived().
+    */
+    void requestSettingsUsed();
+
+    //==============================================================================
+    /** Android API level 26 or higher only: Represents notification channel through which
+        notifications will be sent. Starting from Android API level 26, you should call setupChannels()
+        at the start of your application, before posting any notifications. Then, when sending notifications,
+        assign a channel to each created notification.
+    */
+    struct Channel
+    {
+        String identifier;          /**< Required: Unique channel identifier. */
+        String name;                /**< Required: User facing name of the channel. */
+
+        /** Controls how interruptive the notification posted on this channel are. */
+        enum Importance
+        {
+            none,
+            min,
+            low,
+            normal,
+            high,
+            max
+        };
+
+        Importance importance = normal;     /**< Required. */
+        Notification::LockScreenAppearance lockScreenAppearance = Notification::showPartially;  /**< Optional. */
+
+        String description;                 /**< Optional: user visible description of the channel. */
+        String groupId;                     /**< Required: group this channel belongs to (see ChannelGroup). */
+        Colour ledColour;                   /**< Optional: sets the led colour for notifications in this channel. */
+        bool bypassDoNotDisturb = false;    /**< Optional: true if notifications in this channel can bypass do not disturb setting. */
+        bool canShowBadge = false;          /**< Optional: true if notifications in this channel can show badges in a Launcher application. */
+        bool enableLights = false;          /**< Optional: true if notifications in this channel should show lights (subject to hardware support). */
+        bool enableVibration = false;       /**< Optional: true if notifications in this channel should trigger vibrations. */
+
+        URL soundToPlay;                    /**< Optional: sound to play in this channel. See Notification::soundToPlay for more info. */
+        Array<int> vibrationPattern;        /**< Optional: vibration pattern for this channel. See Notification::vibrationPattern for more info. */
+    };
+
+    /** Android API level 26 or higher only: represents a channel group. This allows for
+        visual grouping of corresponding channels in notification settings presented to the user.
+        At least one channel group has to be specified before notifications can be sent.
+    */
+    struct ChannelGroup
+    {
+        String identifier;                  /**< Required: Unique channel group identifier. */
+        String name;                        /**< Required: User visible name of the channel group. */
+    };
+
+    /** Android API level 26 or higher only: configures notification channel groups and channels to be
+        used in the app. These have to be setup before notifications can be sent on Android API
+        level 26 or higher.
+    */
+    void setupChannels (const Array<ChannelGroup>& groups, const Array<Channel>& channels);
+
+    //==============================================================================
+    /** iOS only: sends an asynchronous request to retrieve a list of notifications that were
+        scheduled and not yet delivered.
+
+        When the list is retrieved, Listener::pendingLocalNotificationsListReceived() will be called.
+    */
+    void getPendingLocalNotifications() const;
+
+    /** Unschedules a pending local notification with a given identifier. Available from iOS 10. */
+    void removePendingLocalNotification (const String& identifier);
+
+    /** Unschedules all pending local notifications. iOS only. */
+    void removeAllPendingLocalNotifications();
+
+    //==============================================================================
+    /** Checks whether notifications are enabled for given application.
+        On iOS and OSX this will always return true, use requestSettingsUsed() instead.
+    */
+    bool areNotificationsEnabled() const;
+
+    /** On iOS as well as on Android, sends a local notification.
+        On Android and iOS 10 or above, this will refresh an existing notification
+        if the same identifier is used as in a notification that was already sent
+        and not yet responded by a user.
+    */
+    void sendLocalNotification (const Notification& notification);
+
+    /** Sends a request for a list of notifications delivered. Such notifications are visible in the
+        notification area on the device and they are still waiting for user action/response.
+        When the request is finished Listener::deliveredNotificationsListReceived() will be called.
+
+        On iOS, iOS version 10 or higher is required. On Android, API level 18 or higher is required.
+        For unsupported platforms, Listener::deliveredNotificationsListReceived() will return an empty array.
+    */
+    void getDeliveredNotifications() const;
+
+    /** Removes a previously delivered notification. This can be useful for instance when the
+        information in the notification becomes obsolete.
+    */
+    void removeDeliveredNotification (const String& identifier);
+
+    /** Removes all notifications that were delivered. */
+    void removeAllDeliveredNotifications();
+
+    //==============================================================================
+    /** Retrieves current device token. Note, it is not a good idea to cache this token
+        because it may change in the meantime. Always call this method to get the current
+        token value.
+    */
+    String getDeviceToken() const;
+
+    /** Android only: allows to subscribe to messages from a specific topic.
+        So you could for instance subscribe this device to all "sports" topic messages
+        to receive any remote notifications that have "sports" topic set.
+        Refer to Firebase documentation for how to send topic messages.
+    */
+    void subscribeToTopic (const String& topic);
+
+    /** Android only: allows to remove a topic subscription that was previously added with
+        subscribeToTopic().
+    */
+    void unsubscribeFromTopic (const String& topic);
+
+    /** Android only: sends an upstream message to your app server. The server must implement
+        XMPP Connection Server protocol (refer to Firebase documentation).
+
+        @param serverSenderId       Represents the sender. Consult your Firebase project
+                                    settings to retrieve the sender id.
+
+        @param collapseKey          Remote messages with the same collapse key that were not
+                                    yet delivered will be collapsed into one, with the
+                                    newest message replacing all the previous ones.
+                                    Note that there may be a limit of maximum collapse keys
+                                    used at the same time and beyond the limit (refer to
+                                    Firebase documentation) it is not guaranteed which keys
+                                    will be in use by the server.
+
+        @param messageId            A unique message ID. Used in error callbacks and debugging.
+
+        @param messageType          Message type.
+
+        @param timeToLive           TTL in seconds. If 0, the message sending will be attempted
+                                    immediately and it will be dropped if the device is not
+                                    connected. Otherwise, the message will be queued for the
+                                    period specified.
+
+        @param additionalData       Collection of key-value pairs to be used as an additional
+                                    data for the message.
+    */
+    void sendUpstreamMessage (const String& serverSenderId,
+                              const String& collapseKey,
+                              const String& messageId,
+                              const String& messageType,
+                              int timeToLive,
+                              const StringPairArray& additionalData);
+
+    //==============================================================================
+    /** Register a listener (ideally on application startup) to receive information about
+        notifications received and any callbacks to async functions called.
+    */
+    struct Listener
+    {
+        virtual ~Listener() = default;
+
+        /** This callback will be called after you call requestSettingsUsed() or
+            requestPermissionsWithSettings().
+
+            Note that settings are currently only used on iOS. When called on other platforms, Settings
+            with no categories and all allow flags set to true will be received in
+            Listener::notificationSettingsReceived().
+        */
+        virtual void notificationSettingsReceived (const Settings& settings) { ignoreUnused (settings); }
+
+        /** Called when the list of pending notifications, requested by calling
+            getPendingLocalNotifications() is returned. iOS 10 or above only.
+        */
+        virtual void pendingLocalNotificationsListReceived (const Array<Notification>& notifications) { ignoreUnused (notifications); }
+
+        /** This can be called in multiple different situations, depending on the OS and the situation.
+
+            On pre iOS 10 device it will be called when a user presses on a notification or when a
+            notification was received when the app was in the foreground already. On iOS 10 it will be
+            called when a user presses on a notification
+
+            Note: On Android, if remote notification was received while the app was in the background and
+            then user pressed on it, the notification object received in this callback will contain only
+            "properties" member set. Hence, if you want to know what was the notification title, content
+            etc, you need to set them as additional properties, so that you will be able to restore them
+            from "properties" dictionary.
+
+            Note you can receive this callback on startup, if the application was launched from a notification.
+        */
+        virtual void handleNotification (bool isLocalNotification, const Notification& notification) { ignoreUnused (isLocalNotification); ignoreUnused (notification); }
+
+        /** This can be called when a user performs some action on the notification such as
+            pressing on an action button or responding with a text input.
+            Note that pressing on a notification area, i.e. not on an action button is not considered
+            to be an action, and hence receivedNotification() will be called in that case.
+
+            Note you can receive this callback on startup, if the application was launched from a notification's action.
+
+            @param isLocalNotification If the notification is local
+            @param notification        The notification
+            @param actionIdentifier    A String identifying the action
+            @param optionalResponse    Text response a user inputs for notifications with a text input.
+                                       Empty for notifications without a text input option.
+
+        */
+        virtual void handleNotificationAction (bool isLocalNotification,
+                                               const Notification& notification,
+                                               const String& actionIdentifier,
+                                               const String& optionalResponse)
+        {
+            ignoreUnused (isLocalNotification);
+            ignoreUnused (notification);
+            ignoreUnused (actionIdentifier);
+            ignoreUnused (optionalResponse);
+        }
+
+        /** For iOS10 and Android, this can be also called when a user dismissed the notification before
+            responding to it.
+        */
+        virtual void localNotificationDismissedByUser (const Notification& notification) { ignoreUnused (notification); }
+
+        /** Called after getDeliveredNotifications() request is fulfilled. Returns notifications
+            that are visible in the notification area on the device and that are still waiting
+            for a user action/response.
+
+            On iOS, iOS version 10 or higher is required. On Android, API level 18 or higher is required.
+            For unsupported platforms, an empty array will be returned.
+         */
+        virtual void deliveredNotificationsListReceived (const Array<Notification>& notifications) { ignoreUnused (notifications); }
+
+        /** Called whenever a token gets refreshed. You should monitor any token updates, because
+            only the last token that is assigned to device is valid and can be used.
+        */
+        virtual void deviceTokenRefreshed (const String& token) { ignoreUnused (token); }
+
+        /** Called when Firebase Cloud Messaging server deletes pending messages. This can happen when
+            1) too many messages were sent to the server (hint: use collapsible messages).
+            2) the devices hasn't been online in a long time (refer to Firebase documentation for
+               the maximum time a message can be stored on FCM before expiring).
+        */
+        virtual void remoteNotificationsDeleted() {}
+
+        /** Called when an upstream message sent with PushNotifications::sendUpstreamMessage() has been
+            sent successfully.
+            Bear in mind that in may take several minutes or more to receive this callback.
+        */
+        virtual void upstreamMessageSent (const String& messageId) { ignoreUnused (messageId); }
+
+        /** Called when there was an error sending an upstream message with
+            PushNotifications::sendUpstreamMessage().
+            Bear in mind that in may take several minutes or more to receive this callback.
+        */
+        virtual void upstreamMessageSendingError (const String& messageId, const String& error) {  ignoreUnused (messageId); ignoreUnused (error); }
+    };
+
+    void addListener (Listener* l);
+    void removeListener (Listener* l);
+
+private:
+    PushNotifications();
+    ~PushNotifications() override;
+
+    ListenerList<PushNotifications::Listener> listeners;
+
+   #if JUCE_ANDROID
+    friend bool juce_handleNotificationIntent (void*);
+
+    friend struct JuceFirebaseInstanceIdService;
+    friend struct JuceFirebaseMessagingService;
+   #endif
+
+  #if JUCE_PUSH_NOTIFICATIONS
+    struct Pimpl;
+    friend struct Pimpl;
+
+    std::unique_ptr<Pimpl> pimpl;
+  #endif
+};
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_RecentlyOpenedFilesList.cpp

@@ -0,0 +1,188 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+RecentlyOpenedFilesList::RecentlyOpenedFilesList()
+    : maxNumberOfItems (10)
+{
+}
+
+RecentlyOpenedFilesList::~RecentlyOpenedFilesList()
+{
+}
+
+//==============================================================================
+void RecentlyOpenedFilesList::setMaxNumberOfItems (const int newMaxNumber)
+{
+    maxNumberOfItems = jmax (1, newMaxNumber);
+
+    files.removeRange (maxNumberOfItems, getNumFiles());
+}
+
+int RecentlyOpenedFilesList::getNumFiles() const
+{
+    return files.size();
+}
+
+File RecentlyOpenedFilesList::getFile (const int index) const
+{
+    return File (files [index]);
+}
+
+void RecentlyOpenedFilesList::clear()
+{
+    files.clear();
+}
+
+void RecentlyOpenedFilesList::addFile (const File& file)
+{
+    removeFile (file);
+    files.insert (0, file.getFullPathName());
+
+    setMaxNumberOfItems (maxNumberOfItems);
+}
+
+void RecentlyOpenedFilesList::removeFile (const File& file)
+{
+    files.removeString (file.getFullPathName());
+}
+
+void RecentlyOpenedFilesList::removeNonExistentFiles()
+{
+    for (int i = getNumFiles(); --i >= 0;)
+        if (! getFile(i).exists())
+            files.remove (i);
+}
+
+//==============================================================================
+int RecentlyOpenedFilesList::createPopupMenuItems (PopupMenu& menuToAddTo,
+                                                   const int baseItemId,
+                                                   const bool showFullPaths,
+                                                   const bool dontAddNonExistentFiles,
+                                                   const File** filesToAvoid)
+{
+    int num = 0;
+
+    for (int i = 0; i < getNumFiles(); ++i)
+    {
+        const File f (getFile(i));
+
+        if ((! dontAddNonExistentFiles) || f.exists())
+        {
+            bool needsAvoiding = false;
+
+            if (filesToAvoid != nullptr)
+            {
+                for (const File** avoid = filesToAvoid; *avoid != nullptr; ++avoid)
+                {
+                    if (f == **avoid)
+                    {
+                        needsAvoiding = true;
+                        break;
+                    }
+                }
+            }
+
+            if (! needsAvoiding)
+            {
+                menuToAddTo.addItem (baseItemId + i,
+                                     showFullPaths ? f.getFullPathName()
+                                                   : f.getFileName());
+                ++num;
+            }
+        }
+    }
+
+    return num;
+}
+
+//==============================================================================
+String RecentlyOpenedFilesList::toString() const
+{
+    return files.joinIntoString ("\n");
+}
+
+void RecentlyOpenedFilesList::restoreFromString (const String& stringifiedVersion)
+{
+    clear();
+    files.addLines (stringifiedVersion);
+
+    setMaxNumberOfItems (maxNumberOfItems);
+}
+
+
+//==============================================================================
+void RecentlyOpenedFilesList::registerRecentFileNatively (const File& file)
+{
+   #if JUCE_MAC
+    JUCE_AUTORELEASEPOOL
+    {
+        [[NSDocumentController sharedDocumentController] noteNewRecentDocumentURL: createNSURLFromFile (file)];
+    }
+   #else
+    ignoreUnused (file);
+   #endif
+}
+
+void RecentlyOpenedFilesList::forgetRecentFileNatively (const File& file)
+{
+   #if JUCE_MAC
+    JUCE_AUTORELEASEPOOL
+    {
+        // for some reason, OSX doesn't provide a method to just remove a single file
+        // from the recent list, so we clear them all and add them back excluding
+        // the specified file
+
+        auto sharedDocController = [NSDocumentController sharedDocumentController];
+        auto recentDocumentURLs  = [sharedDocController recentDocumentURLs];
+
+        [sharedDocController clearRecentDocuments: nil];
+
+        auto* nsFile = createNSURLFromFile (file);
+
+        auto reverseEnumerator = [recentDocumentURLs reverseObjectEnumerator];
+
+        for (NSURL* url : reverseEnumerator)
+            if (! [url isEqual:nsFile])
+                [sharedDocController noteNewRecentDocumentURL:url];
+    }
+   #else
+    ignoreUnused (file);
+   #endif
+}
+
+void RecentlyOpenedFilesList::clearRecentFilesNatively()
+{
+   #if JUCE_MAC
+    JUCE_AUTORELEASEPOOL
+    {
+        [[NSDocumentController sharedDocumentController] clearRecentDocuments: nil];
+    }
+   #endif
+}
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_RecentlyOpenedFilesList.h

@@ -0,0 +1,180 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+//==============================================================================
+/**
+    Manages a set of files for use as a list of recently-opened documents.
+
+    This is a handy class for holding your list of recently-opened documents, with
+    helpful methods for things like purging any non-existent files, automatically
+    adding them to a menu, and making persistence easy.
+
+    @see File, FileBasedDocument
+
+    @tags{GUI}
+*/
+class JUCE_API  RecentlyOpenedFilesList
+{
+public:
+    //==============================================================================
+    /** Creates an empty list.
+    */
+    RecentlyOpenedFilesList();
+
+    /** Destructor. */
+    ~RecentlyOpenedFilesList();
+
+    //==============================================================================
+    /** Sets a limit for the number of files that will be stored in the list.
+
+        When addFile() is called, then if there is no more space in the list, the
+        least-recently added file will be dropped.
+
+        @see getMaxNumberOfItems
+    */
+    void setMaxNumberOfItems (int newMaxNumber);
+
+    /** Returns the number of items that this list will store.
+        @see setMaxNumberOfItems
+    */
+    int getMaxNumberOfItems() const noexcept                            { return maxNumberOfItems; }
+
+    /** Returns the number of files in the list.
+
+        The most recently added file is always at index 0.
+    */
+    int getNumFiles() const;
+
+    /** Returns one of the files in the list.
+
+        The most recently added file is always at index 0.
+    */
+    File getFile (int index) const;
+
+    /** Returns an array of all the absolute pathnames in the list.
+    */
+    const StringArray& getAllFilenames() const noexcept                 { return files; }
+
+    /** Clears all the files from the list. */
+    void clear();
+
+    /** Adds a file to the list.
+
+        The file will be added at index 0. If this file is already in the list, it will
+        be moved up to index 0, but a file can only appear once in the list.
+
+        If the list already contains the maximum number of items that is permitted, the
+        least-recently added file will be dropped from the end.
+    */
+    void addFile (const File& file);
+
+    /** Removes a file from the list. */
+    void removeFile (const File& file);
+
+    /** Checks each of the files in the list, removing any that don't exist.
+
+        You might want to call this after reloading a list of files, or before putting them
+        on a menu.
+    */
+    void removeNonExistentFiles();
+
+    /** Tells the OS to add a file to the OS-managed list of recent documents for this app.
+
+        Not all OSes maintain a list of recent files for an application, so this
+        function will have no effect on some OSes. Currently it's just implemented for OSX.
+    */
+    static void registerRecentFileNatively (const File& file);
+
+    /** Tells the OS to remove a file from the OS-managed list of recent documents for this app.
+
+        Not all OSes maintain a list of recent files for an application, so this
+        function will have no effect on some OSes. Currently it's just implemented for OSX.
+    */
+    static void forgetRecentFileNatively (const File& file);
+
+    /** Tells the OS to clear the OS-managed list of recent documents for this app.
+
+        Not all OSes maintain a list of recent files for an application, so this
+        function will have no effect on some OSes. Currently it's just implemented for OSX.
+    */
+    static void clearRecentFilesNatively();
+
+    //==============================================================================
+    /** Adds entries to a menu, representing each of the files in the list.
+
+        This is handy for creating an "open recent file..." menu in your app. The
+        menu items are numbered consecutively starting with the baseItemId value,
+        and can either be added as complete pathnames, or just the last part of the
+        filename.
+
+        If dontAddNonExistentFiles is true, then each file will be checked and only those
+        that exist will be added.
+
+        If filesToAvoid is not a nullptr, then it is considered to be a zero-terminated array
+        of pointers to file objects. Any files that appear in this list will not be added to
+        the menu - the reason for this is that you might have a number of files already open,
+        so might not want these to be shown in the menu.
+
+        It returns the number of items that were added.
+    */
+    int createPopupMenuItems (PopupMenu& menuToAddItemsTo,
+                              int baseItemId,
+                              bool showFullPaths,
+                              bool dontAddNonExistentFiles,
+                              const File** filesToAvoid = nullptr);
+
+    //==============================================================================
+    /** Returns a string that encapsulates all the files in the list.
+
+        The string that is returned can later be passed into restoreFromString() in
+        order to recreate the list. This is handy for persisting your list, e.g. in
+        a PropertiesFile object.
+
+        @see restoreFromString
+    */
+    String toString() const;
+
+    /** Restores the list from a previously stringified version of the list.
+
+        Pass in a stringified version created with toString() in order to persist/restore
+        your list.
+
+        @see toString
+    */
+    void restoreFromString (const String& stringifiedVersion);
+
+
+private:
+    //==============================================================================
+    StringArray files;
+    int maxNumberOfItems;
+
+    JUCE_LEAK_DETECTOR (RecentlyOpenedFilesList)
+};
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_SplashScreen.cpp

@@ -0,0 +1,101 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+SplashScreen::SplashScreen (const String& title, const Image& image, bool useDropShadow)
+    : Component (title),
+      backgroundImage (image),
+      clickCountToDelete (0)
+{
+    // You must supply a valid image here!
+    jassert (backgroundImage.isValid());
+
+    setOpaque (! backgroundImage.hasAlphaChannel());
+
+   #if JUCE_IOS || JUCE_ANDROID
+    const bool useFullScreen = true;
+   #else
+    const bool useFullScreen = false;
+   #endif
+
+    makeVisible (image.getWidth(), image.getHeight(), useDropShadow, useFullScreen);
+}
+
+SplashScreen::SplashScreen (const String& title, int width, int height, bool useDropShadow)
+    : Component (title),
+      clickCountToDelete (0)
+{
+    makeVisible (width, height, useDropShadow, false);
+}
+
+void SplashScreen::makeVisible (int w, int h, bool useDropShadow, bool fullscreen)
+{
+    clickCountToDelete = Desktop::getInstance().getMouseButtonClickCounter();
+    creationTime = Time::getCurrentTime();
+
+    const Rectangle<int> screenSize = Desktop::getInstance().getDisplays().getPrimaryDisplay()->userArea;
+    const int width  = (fullscreen ? screenSize.getWidth()   : w);
+    const int height = (fullscreen ? screenSize.getHeight()  : h);
+
+    setAlwaysOnTop (true);
+    setVisible (true);
+    centreWithSize (width, height);
+    addToDesktop (useDropShadow ? ComponentPeer::windowHasDropShadow : 0);
+
+    if (fullscreen)
+        getPeer()->setFullScreen (true);
+
+    toFront (false);
+}
+
+SplashScreen::~SplashScreen() {}
+
+void SplashScreen::deleteAfterDelay (RelativeTime timeout, bool removeOnMouseClick)
+{
+    // Note that this method must be safe to call from non-GUI threads
+    if (! removeOnMouseClick)
+        clickCountToDelete = std::numeric_limits<int>::max();
+
+    minimumVisibleTime = timeout;
+
+    startTimer (50);
+}
+
+void SplashScreen::paint (Graphics& g)
+{
+    g.setOpacity (1.0f);
+    g.drawImage (backgroundImage, getLocalBounds().toFloat(), RectanglePlacement (RectanglePlacement::fillDestination));
+}
+
+void SplashScreen::timerCallback()
+{
+    if (Time::getCurrentTime() > creationTime + minimumVisibleTime
+         || Desktop::getInstance().getMouseButtonClickCounter() > clickCountToDelete)
+        delete this;
+}
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_SplashScreen.h

@@ -0,0 +1,156 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+//==============================================================================
+/** A component for showing a splash screen while your app starts up.
+
+    This will automatically position itself, and can be told to delete itself after
+    being on-screen for a minimum length of time.
+
+    To use it, just create one of these in your JUCEApplicationBase::initialise() method,
+    and when your initialisation tasks have finished running, call its deleteAfterDelay()
+    method to make it automatically get rid of itself.
+
+    Note that although you could call deleteAfterDelay() as soon as you create the
+    SplashScreen object, if you've got a long initialisation procedure, you probably
+    don't want the splash to time-out and disappear before the initialisation has
+    finished, which is why it makes sense to not call this method until the end of
+    your init tasks.
+
+    E.g. @code
+
+    void MyApp::initialise (const String& commandLine)
+    {
+        splash = new SplashScreen ("Welcome to my app!",
+                                   ImageFileFormat::loadFrom (File ("/foobar/splash.jpg")),
+                                   true);
+
+        // now kick off your initialisation work on some kind of thread or task, and
+        launchBackgroundInitialisationThread();
+    }
+
+    void MyApp::myInitialisationWorkFinished()
+    {
+        // ..assuming this is some kind of callback method that is triggered when
+        // your background initialisation threads have finished, and it's time to open
+        // your main window, etc..
+
+        splash->deleteAfterDelay (RelativeTime::seconds (4), false);
+
+        ...etc...
+    }
+
+    @endcode
+
+    @tags{GUI}
+*/
+class JUCE_API  SplashScreen  : public Component,
+                                private Timer,
+                                private DeletedAtShutdown
+{
+public:
+    //==============================================================================
+    /** Creates a SplashScreen object.
+
+        When called, the constructor will position the SplashScreen in the centre of the
+        display, and after the time specified, it will automatically delete itself.
+
+        Bear in mind that if you call this during your JUCEApplicationBase::initialise()
+        method and then block the message thread by performing some kind of task, then
+        obviously neither your splash screen nor any other GUI will appear until you
+        allow the message thread to resume and do its work. So if you have time-consuming
+        tasks to do during startup, use a background thread for them.
+
+        After creating one of these (or your subclass of it), you should do your app's
+        initialisation work, and then call the deleteAfterDelay() method to tell this object
+        to delete itself after the user has had chance to get a good look at it.
+
+        If you're writing a custom splash screen class, there's another protected constructor
+        that your subclass can call, which doesn't take an image.
+
+        @param title            the name to give the component
+        @param backgroundImage  an image to draw on the component. The component's size
+                                will be set to the size of this image, and if the image is
+                                semi-transparent, the component will be made non-opaque
+        @param useDropShadow    if true, the window will have a drop shadow
+
+    */
+    SplashScreen (const String& title,
+                  const Image& backgroundImage,
+                  bool useDropShadow);
+
+    /** Destructor. */
+    ~SplashScreen() override;
+
+    /** Tells the component to auto-delete itself after a timeout period, or when the
+        mouse is clicked.
+
+        You should call this after finishing your app's initialisation work.
+
+        Note that although you could call deleteAfterDelay() as soon as you create the
+        SplashScreen object, if you've got a long initialisation procedure, you probably
+        don't want the splash to time-out and disappear before your initialisation has
+        finished, which is why it makes sense to not call this method and start the
+        self-delete timer until you're ready.
+
+        It's safe to call this method from a non-GUI thread as long as there's no danger that
+        the object may be being deleted at the same time.
+
+        @param minimumTotalTimeToDisplayFor    how long the splash screen should stay visible for.
+                                Note that this time is measured from the construction-time of this
+                                object, not from the time that the deleteAfterDelay() method is
+                                called, so if you call this method after a long initialisation
+                                period, it may be deleted without any further delay.
+        @param removeOnMouseClick   if true, the window will be deleted as soon as the user clicks
+                                the mouse (anywhere)
+    */
+    void deleteAfterDelay (RelativeTime minimumTotalTimeToDisplayFor,
+                           bool removeOnMouseClick);
+
+protected:
+    //==============================================================================
+    /** This constructor is for use by custom sub-classes that don't want to provide an image. */
+    SplashScreen (const String& title, int width, int height, bool useDropShadow);
+
+    /** @internal */
+    void paint (Graphics&) override;
+
+private:
+    //==============================================================================
+    Image backgroundImage;
+    Time creationTime;
+    RelativeTime minimumVisibleTime;
+    int clickCountToDelete;
+
+    void timerCallback() override;
+    void makeVisible (int w, int h, bool shadow, bool fullscreen);
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SplashScreen)
+};
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_SystemTrayIconComponent.cpp

@@ -0,0 +1,42 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+#if JUCE_WINDOWS || JUCE_LINUX || JUCE_BSD || JUCE_MAC
+
+SystemTrayIconComponent::SystemTrayIconComponent()
+{
+    addToDesktop (0);
+}
+
+SystemTrayIconComponent::~SystemTrayIconComponent()
+{
+}
+
+#endif
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_SystemTrayIconComponent.h

@@ -0,0 +1,116 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+#if JUCE_WINDOWS || JUCE_LINUX || JUCE_BSD || JUCE_MAC || DOXYGEN
+
+//==============================================================================
+/**
+    This component sits in the taskbar tray as a small icon.
+
+    (NB: The exact behaviour of this class will differ between OSes, and it
+    isn't fully implemented for all OSes)
+
+    To use it, just create one of these components, but don't attempt to make it
+    visible, add it to a parent, or put it on the desktop.
+
+    You can then call setIconImage() to create an icon for it in the taskbar.
+
+    To change the icon's tooltip, you can use setIconTooltip().
+
+    To respond to mouse-events, you can override the normal mouseDown(),
+    mouseUp(), mouseDoubleClick() and mouseMove() methods, and although the x, y
+    position will not be valid, you can use this to respond to clicks. Traditionally
+    you'd use a left-click to show your application's window, and a right-click
+    to show a pop-up menu.
+
+    @tags{GUI}
+*/
+class JUCE_API  SystemTrayIconComponent  : public Component
+{
+public:
+    //==============================================================================
+    /** Constructor. */
+    SystemTrayIconComponent();
+
+    /** Destructor. */
+    ~SystemTrayIconComponent() override;
+
+    //==============================================================================
+    /** Changes the image shown in the taskbar.
+
+        On Windows and Linux a full colour Image is used as an icon.
+        On macOS a template image is used, where all non-transparent regions will be
+        rendered in a monochrome colour selected dynamically by the operating system.
+
+        @param colourImage     An colour image to use as an icon on Windows and Linux
+        @param templateImage   A template image to use as an icon on macOS
+    */
+    void setIconImage (const Image& colourImage, const Image& templateImage);
+
+    /** Changes the icon's tooltip (if the current OS supports this). */
+    void setIconTooltip (const String& tooltip);
+
+    /** Highlights the icon (if the current OS supports this). */
+    void setHighlighted (bool);
+
+    /** Shows a floating text bubble pointing to the icon (if the current OS supports this). */
+    void showInfoBubble (const String& title, const String& content);
+
+    /** Hides the icon's floating text bubble (if the current OS supports this). */
+    void hideInfoBubble();
+
+    /** Returns the raw handle to whatever kind of internal OS structure is
+        involved in showing this icon.
+        @see ComponentPeer::getNativeHandle()
+    */
+    void* getNativeHandle() const;
+
+   #if JUCE_LINUX || JUCE_BSD
+    /** @internal */
+    void paint (Graphics&) override;
+   #endif
+
+   #if JUCE_MAC
+    /** Shows a menu attached to the OSX menu bar icon. */
+    void showDropdownMenu (const PopupMenu& menu);
+   #endif
+
+private:
+    //==============================================================================
+    JUCE_PUBLIC_IN_DLL_BUILD (class Pimpl)
+    std::unique_ptr<Pimpl> pimpl;
+
+    [[deprecated ("The new setIconImage function signature requires different images for macOS and the other platforms.")]]
+    void setIconImage (const Image& newImage);
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SystemTrayIconComponent)
+};
+
+#endif
+
+} // namespace juce

deps/juce/modules/juce_gui_extra/misc/juce_WebBrowserComponent.h

@@ -0,0 +1,287 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2020 - Raw Material Software Limited
+
+   JUCE is an open source library subject to commercial or open-source
+   licensing.
+
+   By using JUCE, you agree to the terms of both the JUCE 6 End-User License
+   Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
+
+   End User License Agreement: www.juce.com/juce-6-licence
+   Privacy Policy: www.juce.com/juce-privacy-policy
+
+   Or: You may also use this code under the terms of the GPL v3 (see
+   www.gnu.org/licenses).
+
+   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+#if JUCE_WEB_BROWSER || DOXYGEN
+
+//==============================================================================
+/**
+    A component that displays an embedded web browser.
+
+    The browser itself will be platform-dependent. On Mac and iOS it will be
+    WebKit, on Android it will be Chrome, and on Linux it will be WebKit.
+
+    On Windows it will be IE, but if JUCE_USE_WIN_WEBVIEW2 is enabled then using
+    the WindowsWebView2WebBrowserComponent wrapper instead of this class directly
+    will attempt to use the Microsoft Edge (Chromium) WebView2. See the documentation
+    of that class for more information about its requirements.
+
+    @tags{GUI}
+*/
+class JUCE_API  WebBrowserComponent  : public Component
+{
+public:
+    //==============================================================================
+    /** Creates a WebBrowserComponent.
+
+        Once it's created and visible, send the browser to a URL using goToURL().
+
+        @param unloadPageWhenBrowserIsHidden  if this is true, then when the browser
+                            component is taken offscreen, it'll clear the current page
+                            and replace it with a blank page - this can be handy to stop
+                            the browser using resources in the background when it's not
+                            actually being used.
+    */
+    explicit WebBrowserComponent (bool unloadPageWhenBrowserIsHidden = true);
+
+    /** Destructor. */
+    ~WebBrowserComponent() override;
+
+    //==============================================================================
+    /** Sends the browser to a particular URL.
+
+        @param url      the URL to go to.
+        @param headers  an optional set of parameters to put in the HTTP header. If
+                        you supply this, it should be a set of string in the form
+                        "HeaderKey: HeaderValue"
+        @param postData an optional block of data that will be attached to the HTTP
+                        POST request
+    */
+    void goToURL (const String& url,
+                  const StringArray* headers = nullptr,
+                  const MemoryBlock* postData = nullptr);
+
+    /** Stops the current page loading. */
+    void stop();
+
+    /** Sends the browser back one page. */
+    void goBack();
+
+    /** Sends the browser forward one page. */
+    void goForward();
+
+    /** Refreshes the browser. */
+    void refresh();
+
+    /** Clear cookies that the OS has stored for the WebComponents of this application */
+    static void clearCookies();
+
+    //==============================================================================
+    /** This callback is called when the browser is about to navigate
+        to a new location.
+
+        You can override this method to perform some action when the user
+        tries to go to a particular URL. To allow the operation to carry on,
+        return true, or return false to stop the navigation happening.
+    */
+    virtual bool pageAboutToLoad (const String& newURL)             { ignoreUnused (newURL); return true; }
+
+    /** This callback happens when the browser has finished loading a page. */
+    virtual void pageFinishedLoading (const String& url)            { ignoreUnused (url); }
+
+    /** This callback happens when a network error was encountered while
+        trying to load a page.
+
+        You can override this method to show some other error page by calling
+        goToURL. Return true to allow the browser to carry on to the internal
+        browser error page.
+
+        The errorInfo contains some platform dependent string describing the
+        error.
+    */
+    virtual bool pageLoadHadNetworkError (const String& errorInfo)  { ignoreUnused (errorInfo); return true; }
+
+    /** This callback occurs when a script or other activity in the browser asks for
+        the window to be closed.
+    */
+    virtual void windowCloseRequest()                               {}
+
+    /** This callback occurs when the browser attempts to load a URL in a new window.
+        This won't actually load the window but gives you a chance to either launch a
+        new window yourself or just load the URL into the current window with goToURL().
+     */
+    virtual void newWindowAttemptingToLoad (const String& newURL)   { ignoreUnused (newURL); }
+
+    //==============================================================================
+    /** @internal */
+    void paint (Graphics&) override;
+    /** @internal */
+    void resized() override;
+    /** @internal */
+    void parentHierarchyChanged() override;
+    /** @internal */
+    void visibilityChanged() override;
+    /** @internal */
+    void focusGained (FocusChangeType) override;
+
+    /** @internal */
+    class Pimpl;
+
+protected:
+    friend class WindowsWebView2WebBrowserComponent;
+
+    /** @internal */
+    struct ConstructWithoutPimpl
+    {
+        explicit ConstructWithoutPimpl (bool unloadOnHide) : unloadWhenHidden (unloadOnHide) {}
+        const bool unloadWhenHidden;
+    };
+    explicit WebBrowserComponent (ConstructWithoutPimpl);
+
+private:
+    //==============================================================================
+    std::unique_ptr<Pimpl> browser;
+    bool blankPageShown = false, unloadPageWhenHidden;
+    String lastURL;
+    StringArray lastHeaders;
+    MemoryBlock lastPostData;
+
+    void reloadLastURL();
+    void checkWindowAssociation();
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WebBrowserComponent)
+};
+
+//==============================================================================
+/** Class used to create a set of preferences to pass to the WindowsWebView2WebBrowserComponent
+    wrapper constructor to modify aspects of its behaviour and settings.
+
+    You can chain together a series of calls to this class's methods to create a set of whatever
+    preferences you want to specify.
+
+    @tags{GUI}
+*/
+class JUCE_API  WebView2Preferences
+{
+public:
+    //==============================================================================
+    /** Sets a custom location for the WebView2Loader.dll that is not a part of the
+        standard system DLL search paths.
+    */
+    WebView2Preferences withDLLLocation (const File& location) const   { return with (&WebView2Preferences::dllLocation, location); }
+
+    /** Sets a non-default location for storing user data for the browser instance. */
+    WebView2Preferences withUserDataFolder (const File& folder) const  { return with (&WebView2Preferences::userDataFolder, folder); }
+
+    /** If this is set, the status bar usually displayed in the lower-left of the webview
+        will be disabled.
+    */
+    WebView2Preferences withStatusBarDisabled() const                  { return with (&WebView2Preferences::disableStatusBar, true); }
+
+    /** If this is set, a blank page will be displayed on error instead of the default
+        built-in error page.
+    */
+    WebView2Preferences withBuiltInErrorPageDisabled() const           { return with (&WebView2Preferences::disableBuiltInErrorPage, true); }
+
+    /** Sets the background colour that WebView2 renders underneath all web content.
+
+        This colour must either be fully opaque or transparent. On Windows 7 this
+        colour must be opaque.
+    */
+    WebView2Preferences withBackgroundColour (const Colour& colour) const
+    {
+        // the background colour must be either fully opaque or transparent!
+        jassert (colour.isOpaque() || colour.isTransparent());
+
+        return with (&WebView2Preferences::backgroundColour, colour);
+    }
+
+    //==============================================================================
+    File getDLLLocation() const                          { return dllLocation; }
+    File getUserDataFolder() const                       { return userDataFolder; }
+    bool getIsStatusBarDisabled() const noexcept         { return disableStatusBar; }
+    bool getIsBuiltInErrorPageDisabled() const noexcept  { return disableBuiltInErrorPage; }
+    Colour getBackgroundColour() const                   { return backgroundColour; }
+
+private:
+    //==============================================================================
+    template <typename Member, typename Item>
+    WebView2Preferences with (Member&& member, Item&& item) const
+    {
+        auto options = *this;
+        options.*member = std::forward<Item> (item);
+
+        return options;
+    }
+
+    File dllLocation, userDataFolder;
+    bool disableStatusBar = false, disableBuiltInErrorPage = false;
+    Colour backgroundColour = Colours::white;
+};
+
+/**
+    If you have enabled the JUCE_USE_WIN_WEBVIEW2 flag then this wrapper will attempt to
+    use the Microsoft Edge (Chromium) WebView2 control instead of IE on Windows. It will
+    behave the same as WebBrowserComponent on all other platforms and will fall back to
+    IE on Windows if the WebView2 requirements are not met.
+
+    This requires Microsoft Edge (minimum version 82.0.488.0) to be installed at runtime.
+
+    Currently this also requires that WebView2Loader.dll, which can be found in the
+    Microsoft.Web.WebView package, is installed at runtime. As this is not a standard
+    system DLL, we can't rely on it being found via the normal system DLL search paths.
+    Therefore in order to use WebView2 you need to ensure that WebView2Loader.dll is
+    installed either to a location covered by the Windows DLL system search paths or
+    to the folder specified in the WebView2Preferences.
+
+    @tags{GUI}
+*/
+class WindowsWebView2WebBrowserComponent  : public WebBrowserComponent
+{
+public:
+    //==============================================================================
+    /** Creates a WebBrowserComponent that is compatible with the WebView2 control
+        on Windows.
+
+        @param unloadPageWhenBrowserIsHidden  if this is true, then when the browser
+                               component is taken offscreen, it'll clear the current page
+                               and replace it with a blank page - this can be handy to stop
+                               the browser using resources in the background when it's not
+                               actually being used.
+        @param preferences     a set of preferences used to control aspects of the webview's
+                               behaviour.
+
+        @see WebView2Preferences
+    */
+    WindowsWebView2WebBrowserComponent (bool unloadPageWhenBrowserIsHidden = true,
+                                        const WebView2Preferences& preferences = {});
+
+    // This constructor has been deprecated. Use the new constructor that takes a
+    // WebView2Preferences instead.
+    explicit WindowsWebView2WebBrowserComponent (bool unloadPageWhenBrowserIsHidden = true,
+                                                 const File& dllLocation = {},
+                                                 const File& userDataFolder = {})
+                                  : WindowsWebView2WebBrowserComponent (unloadPageWhenBrowserIsHidden,
+                                                                        WebView2Preferences().withDLLLocation (dllLocation)
+                                                                                             .withUserDataFolder (userDataFolder))
+    {
+    }
+};
+
+#endif
+
+} // namespace juce