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_basics/drawables/juce_Drawable.cpp

@@ -0,0 +1,201 @@
+/*
+  ==============================================================================
+
+   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
+{
+
+Drawable::Drawable()
+{
+    setInterceptsMouseClicks (false, false);
+    setPaintingIsUnclipped (true);
+    setAccessible (false);
+}
+
+Drawable::Drawable (const Drawable& other)
+    : Component (other.getName())
+{
+    setInterceptsMouseClicks (false, false);
+    setPaintingIsUnclipped (true);
+    setAccessible (false);
+
+    setComponentID (other.getComponentID());
+    setTransform (other.getTransform());
+
+    if (auto* clipPath = other.drawableClipPath.get())
+        setClipPath (clipPath->createCopy());
+}
+
+Drawable::~Drawable()
+{
+}
+
+void Drawable::applyDrawableClipPath (Graphics& g)
+{
+    if (drawableClipPath != nullptr)
+    {
+        auto clipPath = drawableClipPath->getOutlineAsPath();
+
+        if (! clipPath.isEmpty())
+            g.getInternalContext().clipToPath (clipPath, {});
+    }
+}
+
+//==============================================================================
+void Drawable::draw (Graphics& g, float opacity, const AffineTransform& transform) const
+{
+    const_cast<Drawable*> (this)->nonConstDraw (g, opacity, transform);
+}
+
+void Drawable::nonConstDraw (Graphics& g, float opacity, const AffineTransform& transform)
+{
+    Graphics::ScopedSaveState ss (g);
+
+    g.addTransform (AffineTransform::translation ((float) -(originRelativeToComponent.x),
+                                                  (float) -(originRelativeToComponent.y))
+                        .followedBy (getTransform())
+                        .followedBy (transform));
+
+    applyDrawableClipPath (g);
+
+    if (! g.isClipEmpty())
+    {
+        if (opacity < 1.0f)
+        {
+            g.beginTransparencyLayer (opacity);
+            paintEntireComponent (g, true);
+            g.endTransparencyLayer();
+        }
+        else
+        {
+            paintEntireComponent (g, true);
+        }
+    }
+}
+
+void Drawable::drawAt (Graphics& g, float x, float y, float opacity) const
+{
+    draw (g, opacity, AffineTransform::translation (x, y));
+}
+
+void Drawable::drawWithin (Graphics& g, Rectangle<float> destArea,
+                           RectanglePlacement placement, float opacity) const
+{
+    draw (g, opacity, placement.getTransformToFit (getDrawableBounds(), destArea));
+}
+
+//==============================================================================
+DrawableComposite* Drawable::getParent() const
+{
+    return dynamic_cast<DrawableComposite*> (getParentComponent());
+}
+
+void Drawable::setClipPath (std::unique_ptr<Drawable> clipPath)
+{
+    if (drawableClipPath != clipPath)
+    {
+        drawableClipPath = std::move (clipPath);
+        repaint();
+    }
+}
+
+void Drawable::transformContextToCorrectOrigin (Graphics& g)
+{
+    g.setOrigin (originRelativeToComponent);
+}
+
+void Drawable::parentHierarchyChanged()
+{
+    setBoundsToEnclose (getDrawableBounds());
+}
+
+void Drawable::setBoundsToEnclose (Rectangle<float> area)
+{
+    Point<int> parentOrigin;
+
+    if (auto* parent = getParent())
+        parentOrigin = parent->originRelativeToComponent;
+
+    auto newBounds = area.getSmallestIntegerContainer() + parentOrigin;
+    originRelativeToComponent = parentOrigin - newBounds.getPosition();
+    setBounds (newBounds);
+}
+
+//==============================================================================
+bool Drawable::replaceColour (Colour original, Colour replacement)
+{
+    bool changed = false;
+
+    for (auto* c : getChildren())
+        if (auto* d = dynamic_cast<Drawable*> (c))
+            changed = d->replaceColour (original, replacement) || changed;
+
+    return changed;
+}
+
+//==============================================================================
+void Drawable::setOriginWithOriginalSize (Point<float> originWithinParent)
+{
+    setTransform (AffineTransform::translation (originWithinParent.x, originWithinParent.y));
+}
+
+void Drawable::setTransformToFit (const Rectangle<float>& area, RectanglePlacement placement)
+{
+    if (! area.isEmpty())
+        setTransform (placement.getTransformToFit (getDrawableBounds(), area));
+}
+
+//==============================================================================
+std::unique_ptr<Drawable> Drawable::createFromImageData (const void* data, const size_t numBytes)
+{
+    auto image = ImageFileFormat::loadFrom (data, numBytes);
+
+    if (image.isValid())
+        return std::make_unique<DrawableImage> (image);
+
+    if (auto svg = parseXMLIfTagMatches (String::createStringFromData (data, (int) numBytes), "svg"))
+        return Drawable::createFromSVG (*svg);
+
+    return {};
+}
+
+std::unique_ptr<Drawable> Drawable::createFromImageDataStream (InputStream& dataSource)
+{
+    MemoryOutputStream mo;
+    mo << dataSource;
+
+    return createFromImageData (mo.getData(), mo.getDataSize());
+}
+
+std::unique_ptr<Drawable> Drawable::createFromImageFile (const File& file)
+{
+    FileInputStream fin (file);
+
+    if (fin.openedOk())
+        return createFromImageDataStream (fin);
+
+    return {};
+}
+
+} // namespace juce

deps/juce/modules/juce_gui_basics/drawables/juce_Drawable.h

@@ -0,0 +1,213 @@
+/*
+  ==============================================================================
+
+   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
+{
+
+//==============================================================================
+/**
+    The base class for objects which can draw themselves, e.g. polygons, images, etc.
+
+    @see DrawableComposite, DrawableImage, DrawablePath, DrawableText
+
+    @tags{GUI}
+*/
+class JUCE_API  Drawable  : public Component
+{
+protected:
+    //==============================================================================
+    /** The base class can't be instantiated directly.
+
+        @see DrawableComposite, DrawableImage, DrawablePath, DrawableText
+    */
+    Drawable();
+
+public:
+    /** Destructor. */
+    ~Drawable() override;
+
+    //==============================================================================
+    /** Creates a deep copy of this Drawable object.
+
+        Use this to create a new copy of this and any sub-objects in the tree.
+    */
+    virtual std::unique_ptr<Drawable> createCopy() const = 0;
+
+    /** Creates a path that describes the outline of this drawable. */
+    virtual Path getOutlineAsPath() const = 0;
+
+    //==============================================================================
+    /** Renders this Drawable object.
+
+        Note that the preferred way to render a drawable in future is by using it
+        as a component and adding it to a parent, so you might want to consider that
+        before using this method.
+
+        @see drawWithin
+    */
+    void draw (Graphics& g, float opacity,
+               const AffineTransform& transform = AffineTransform()) const;
+
+    /** Renders the Drawable at a given offset within the Graphics context.
+
+        The coordinates passed-in are used to translate the object relative to its own
+        origin before drawing it - this is basically a quick way of saying:
+
+        @code
+        draw (g, AffineTransform::translation (x, y)).
+        @endcode
+
+        Note that the preferred way to render a drawable in future is by using it
+        as a component and adding it to a parent, so you might want to consider that
+        before using this method.
+    */
+    void drawAt (Graphics& g, float x, float y, float opacity) const;
+
+    /** Renders the Drawable within a rectangle, scaling it to fit neatly inside without
+        changing its aspect-ratio.
+
+        The object can placed arbitrarily within the rectangle based on a Justification type,
+        and can either be made as big as possible, or just reduced to fit.
+
+        Note that the preferred way to render a drawable in future is by using it
+        as a component and adding it to a parent, so you might want to consider that
+        before using this method.
+
+        @param g                        the graphics context to render onto
+        @param destArea                 the target rectangle to fit the drawable into
+        @param placement                defines the alignment and rescaling to use to fit
+                                        this object within the target rectangle.
+        @param opacity                  the opacity to use, in the range 0 to 1.0
+    */
+    void drawWithin (Graphics& g,
+                     Rectangle<float> destArea,
+                     RectanglePlacement placement,
+                     float opacity) const;
+
+
+    //==============================================================================
+    /** Resets any transformations on this drawable, and positions its origin within
+        its parent component.
+    */
+    void setOriginWithOriginalSize (Point<float> originWithinParent);
+
+    /** Sets a transform for this drawable that will position it within the specified
+        area of its parent component.
+    */
+    void setTransformToFit (const Rectangle<float>& areaInParent, RectanglePlacement placement);
+
+    /** Returns the DrawableComposite that contains this object, if there is one. */
+    DrawableComposite* getParent() const;
+
+    /** Sets a the clipping region of this drawable using another drawable.
+        The drawable passed in will be deleted when no longer needed.
+    */
+    void setClipPath (std::unique_ptr<Drawable> drawableClipPath);
+
+    //==============================================================================
+    /** Tries to turn some kind of image file into a drawable.
+
+        The data could be an image that the ImageFileFormat class understands, or it
+        could be SVG.
+    */
+    static std::unique_ptr<Drawable> createFromImageData (const void* data, size_t numBytes);
+
+    /** Tries to turn a stream containing some kind of image data into a drawable.
+
+        The data could be an image that the ImageFileFormat class understands, or it
+        could be SVG.
+    */
+    static std::unique_ptr<Drawable> createFromImageDataStream (InputStream& dataSource);
+
+    /** Tries to turn a file containing some kind of image data into a drawable.
+
+        The data could be an image that the ImageFileFormat class understands, or it
+        could be SVG.
+    */
+    static std::unique_ptr<Drawable> createFromImageFile (const File& file);
+
+    /** Attempts to parse an SVG (Scalable Vector Graphics) document, and to turn this
+        into a Drawable tree.
+
+        If something goes wrong while parsing, it may return nullptr.
+
+        SVG is a pretty large and complex spec, and this doesn't aim to be a full
+        implementation, but it can return the basic vector objects.
+    */
+    static std::unique_ptr<Drawable> createFromSVG (const XmlElement& svgDocument);
+
+    /** Attempts to parse an SVG (Scalable Vector Graphics) document from a file,
+        and to turn this into a Drawable tree.
+
+        If something goes wrong while parsing, it may return nullptr.
+
+        SVG is a pretty large and complex spec, and this doesn't aim to be a full
+        implementation, but it can return the basic vector objects.
+
+        Any references to references to external image files will be relative to
+        the parent directory of the file passed.
+    */
+    static std::unique_ptr<Drawable> createFromSVGFile (const File& svgFile);
+
+    /** Parses an SVG path string and returns it. */
+    static Path parseSVGPath (const String& svgPath);
+
+    //==============================================================================
+    /** Returns the area that this drawable covers.
+        The result is expressed in this drawable's own coordinate space, and does not take
+        into account any transforms that may be applied to the component.
+    */
+    virtual Rectangle<float> getDrawableBounds() const = 0;
+
+    /** Recursively replaces a colour that might be used for filling or stroking.
+        return true if any instances of this colour were found.
+    */
+    virtual bool replaceColour (Colour originalColour, Colour replacementColour);
+
+protected:
+    //==============================================================================
+    friend class DrawableComposite;
+    friend class DrawableShape;
+
+    /** @internal */
+    void transformContextToCorrectOrigin (Graphics&);
+    /** @internal */
+    void parentHierarchyChanged() override;
+    /** @internal */
+    void setBoundsToEnclose (Rectangle<float>);
+    /** @internal */
+    void applyDrawableClipPath (Graphics&);
+
+    Point<int> originRelativeToComponent;
+    std::unique_ptr<Drawable> drawableClipPath;
+
+    void nonConstDraw (Graphics&, float opacity, const AffineTransform&);
+
+    Drawable (const Drawable&);
+    Drawable& operator= (const Drawable&);
+    JUCE_LEAK_DETECTOR (Drawable)
+};
+
+} // namespace juce

deps/juce/modules/juce_gui_basics/drawables/juce_DrawableComposite.cpp

@@ -0,0 +1,164 @@
+/*
+  ==============================================================================
+
+   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
+{
+
+DrawableComposite::DrawableComposite()
+    : bounds ({ 0.0f, 0.0f, 100.0f, 100.0f })
+{
+    setContentArea ({ 0.0f, 0.0f, 100.0f, 100.0f });
+}
+
+DrawableComposite::DrawableComposite (const DrawableComposite& other)
+    : Drawable (other),
+      bounds (other.bounds),
+      contentArea (other.contentArea)
+{
+    for (auto* c : other.getChildren())
+        if (auto* d = dynamic_cast<const Drawable*> (c))
+            addAndMakeVisible (d->createCopy().release());
+}
+
+DrawableComposite::~DrawableComposite()
+{
+    deleteAllChildren();
+}
+
+std::unique_ptr<Drawable> DrawableComposite::createCopy() const
+{
+    return std::make_unique<DrawableComposite> (*this);
+}
+
+//==============================================================================
+Rectangle<float> DrawableComposite::getDrawableBounds() const
+{
+    Rectangle<float> r;
+
+    for (auto* c : getChildren())
+        if (auto* d = dynamic_cast<const Drawable*> (c))
+            r = r.getUnion (d->isTransformed() ? d->getDrawableBounds().transformedBy (d->getTransform())
+                                               : d->getDrawableBounds());
+
+    return r;
+}
+
+void DrawableComposite::setContentArea (Rectangle<float> newArea)
+{
+    contentArea = newArea;
+}
+
+void DrawableComposite::setBoundingBox (Rectangle<float> newBounds)
+{
+    setBoundingBox (Parallelogram<float> (newBounds));
+}
+
+void DrawableComposite::setBoundingBox (Parallelogram<float> newBounds)
+{
+    if (bounds != newBounds)
+    {
+        bounds = newBounds;
+
+        auto t = AffineTransform::fromTargetPoints (contentArea.getTopLeft(),     bounds.topLeft,
+                                                    contentArea.getTopRight(),    bounds.topRight,
+                                                    contentArea.getBottomLeft(),  bounds.bottomLeft);
+
+        if (t.isSingularity())
+            t = {};
+
+        setTransform (t);
+    }
+}
+
+void DrawableComposite::resetBoundingBoxToContentArea()
+{
+    setBoundingBox (contentArea);
+}
+
+void DrawableComposite::resetContentAreaAndBoundingBoxToFitChildren()
+{
+    setContentArea (getDrawableBounds());
+    resetBoundingBoxToContentArea();
+}
+
+void DrawableComposite::parentHierarchyChanged()
+{
+    if (auto* parent = getParent())
+        originRelativeToComponent = parent->originRelativeToComponent - getPosition();
+}
+
+void DrawableComposite::childBoundsChanged (Component*)
+{
+    updateBoundsToFitChildren();
+}
+
+void DrawableComposite::childrenChanged()
+{
+    updateBoundsToFitChildren();
+}
+
+void DrawableComposite::updateBoundsToFitChildren()
+{
+    if (! updateBoundsReentrant)
+    {
+        const ScopedValueSetter<bool> setter (updateBoundsReentrant, true, false);
+
+        Rectangle<int> childArea;
+
+        for (auto* c : getChildren())
+            childArea = childArea.getUnion (c->getBoundsInParent());
+
+        auto delta = childArea.getPosition();
+        childArea += getPosition();
+
+        if (childArea != getBounds())
+        {
+            if (! delta.isOrigin())
+            {
+                originRelativeToComponent -= delta;
+
+                for (auto* c : getChildren())
+                    c->setBounds (c->getBounds() - delta);
+            }
+
+            setBounds (childArea);
+        }
+    }
+}
+
+//==============================================================================
+Path DrawableComposite::getOutlineAsPath() const
+{
+    Path p;
+
+    for (auto* c : getChildren())
+        if (auto* d = dynamic_cast<Drawable*> (c))
+            p.addPath (d->getOutlineAsPath());
+
+    p.applyTransform (getTransform());
+    return p;
+}
+
+} // namespace juce

deps/juce/modules/juce_gui_basics/drawables/juce_DrawableComposite.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
+{
+
+//==============================================================================
+/**
+    A drawable object which acts as a container for a set of other Drawables.
+
+    Note that although this is a Component, it takes ownership of its child components
+    and will delete them, so that you can use it as a self-contained graphic object.
+    The intention is that you should not add your own components to it, only add other
+    Drawable objects.
+
+    @see Drawable
+
+    @tags{GUI}
+*/
+class JUCE_API  DrawableComposite  : public Drawable
+{
+public:
+    //==============================================================================
+    /** Creates a composite Drawable. */
+    DrawableComposite();
+
+    /** Creates a copy of a DrawableComposite. */
+    DrawableComposite (const DrawableComposite&);
+
+    /** Destructor. */
+    ~DrawableComposite() override;
+
+    //==============================================================================
+    /** Sets the parallelogram that defines the target position of the content rectangle when the drawable is rendered.
+        @see setContentArea
+    */
+    void setBoundingBox (Parallelogram<float> newBoundingBox);
+
+    /** Sets the rectangle that defines the target position of the content rectangle when the drawable is rendered.
+        @see setContentArea
+    */
+    void setBoundingBox (Rectangle<float> newBoundingBox);
+
+    /** Returns the parallelogram that defines the target position of the content rectangle when the drawable is rendered.
+        @see setBoundingBox
+    */
+    Parallelogram<float> getBoundingBox() const noexcept            { return bounds; }
+
+    /** Changes the bounding box transform to match the content area, so that any sub-items will
+        be drawn at their untransformed positions.
+    */
+    void resetBoundingBoxToContentArea();
+
+    /** Returns the main content rectangle.
+        @see contentLeftMarkerName, contentRightMarkerName, contentTopMarkerName, contentBottomMarkerName
+    */
+    Rectangle<float> getContentArea() const noexcept                { return contentArea; }
+
+    /** Changes the main content area.
+        @see setBoundingBox, contentLeftMarkerName, contentRightMarkerName, contentTopMarkerName, contentBottomMarkerName
+    */
+    void setContentArea (Rectangle<float> newArea);
+
+    /** Resets the content area and the bounding transform to fit around the area occupied
+        by the child components.
+    */
+    void resetContentAreaAndBoundingBoxToFitChildren();
+
+    //==============================================================================
+    /** @internal */
+    std::unique_ptr<Drawable> createCopy() const override;
+    /** @internal */
+    Rectangle<float> getDrawableBounds() const override;
+    /** @internal */
+    void childBoundsChanged (Component*) override;
+    /** @internal */
+    void childrenChanged() override;
+    /** @internal */
+    void parentHierarchyChanged() override;
+    /** @internal */
+    Path getOutlineAsPath() const override;
+
+private:
+    //==============================================================================
+    Parallelogram<float> bounds;
+    Rectangle<float> contentArea;
+    bool updateBoundsReentrant = false;
+
+    void updateBoundsToFitChildren();
+
+    DrawableComposite& operator= (const DrawableComposite&);
+    JUCE_LEAK_DETECTOR (DrawableComposite)
+};
+
+} // namespace juce

deps/juce/modules/juce_gui_basics/drawables/juce_DrawableImage.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
+{
+
+DrawableImage::DrawableImage() : bounds ({ 0.0f, 0.0f, 1.0f, 1.0f })
+{
+}
+
+DrawableImage::DrawableImage (const DrawableImage& other)
+    : Drawable (other),
+      image (other.image),
+      opacity (other.opacity),
+      overlayColour (other.overlayColour),
+      bounds (other.bounds)
+{
+    setBounds (other.getBounds());
+}
+
+DrawableImage::DrawableImage (const Image& imageToUse)
+{
+    setImageInternal (imageToUse);
+}
+
+DrawableImage::~DrawableImage()
+{
+}
+
+std::unique_ptr<Drawable> DrawableImage::createCopy() const
+{
+    return std::make_unique<DrawableImage> (*this);
+}
+
+//==============================================================================
+void DrawableImage::setImage (const Image& imageToUse)
+{
+    if (setImageInternal (imageToUse))
+        repaint();
+}
+
+void DrawableImage::setOpacity (const float newOpacity)
+{
+    opacity = newOpacity;
+}
+
+void DrawableImage::setOverlayColour (Colour newOverlayColour)
+{
+    overlayColour = newOverlayColour;
+}
+
+void DrawableImage::setBoundingBox (Rectangle<float> newBounds)
+{
+    setBoundingBox (Parallelogram<float> (newBounds));
+}
+
+void DrawableImage::setBoundingBox (Parallelogram<float> newBounds)
+{
+    if (bounds != newBounds)
+    {
+        bounds = newBounds;
+
+        if (image.isValid())
+        {
+            auto tr = bounds.topLeft + (bounds.topRight   - bounds.topLeft) / (float) image.getWidth();
+            auto bl = bounds.topLeft + (bounds.bottomLeft - bounds.topLeft) / (float) image.getHeight();
+
+            auto t = AffineTransform::fromTargetPoints (bounds.topLeft.x, bounds.topLeft.y,
+                                                        tr.x, tr.y,
+                                                        bl.x, bl.y);
+
+            if (t.isSingularity())
+                t = {};
+
+            setTransform (t);
+        }
+    }
+}
+
+//==============================================================================
+void DrawableImage::paint (Graphics& g)
+{
+    if (image.isValid())
+    {
+        if (opacity > 0.0f && ! overlayColour.isOpaque())
+        {
+            g.setOpacity (opacity);
+            g.drawImageAt (image, 0, 0, false);
+        }
+
+        if (! overlayColour.isTransparent())
+        {
+            g.setColour (overlayColour.withMultipliedAlpha (opacity));
+            g.drawImageAt (image, 0, 0, true);
+        }
+    }
+}
+
+Rectangle<float> DrawableImage::getDrawableBounds() const
+{
+    return image.getBounds().toFloat();
+}
+
+bool DrawableImage::hitTest (int x, int y)
+{
+    return Drawable::hitTest (x, y) && image.isValid() && image.getPixelAt (x, y).getAlpha() >= 127;
+}
+
+Path DrawableImage::getOutlineAsPath() const
+{
+    return {}; // not applicable for images
+}
+
+//==============================================================================
+bool DrawableImage::setImageInternal (const Image& imageToUse)
+{
+    if (image != imageToUse)
+    {
+        image = imageToUse;
+        setBounds (image.getBounds());
+        setBoundingBox (image.getBounds().toFloat());
+        return true;
+    }
+
+    return false;
+}
+
+//==============================================================================
+std::unique_ptr<AccessibilityHandler> DrawableImage::createAccessibilityHandler()
+{
+    return std::make_unique<AccessibilityHandler> (*this, AccessibilityRole::image);
+}
+
+} // namespace juce

deps/juce/modules/juce_gui_basics/drawables/juce_DrawableImage.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
+{
+
+//==============================================================================
+/**
+    A drawable object which is a bitmap image.
+
+    @see Drawable
+
+    @tags{GUI}
+*/
+class JUCE_API  DrawableImage  : public Drawable
+{
+public:
+    //==============================================================================
+    DrawableImage();
+    DrawableImage (const DrawableImage&);
+
+    /** Sets the image that this drawable will render. */
+    explicit DrawableImage (const Image& imageToUse);
+
+    /** Destructor. */
+    ~DrawableImage() override;
+
+    //==============================================================================
+    /** Sets the image that this drawable will render. */
+    void setImage (const Image& imageToUse);
+
+    /** Returns the current image. */
+    const Image& getImage() const noexcept                      { return image; }
+
+    /** Sets the opacity to use when drawing the image. */
+    void setOpacity (float newOpacity);
+
+    /** Returns the image's opacity. */
+    float getOpacity() const noexcept                           { return opacity; }
+
+    /** Sets a colour to draw over the image's alpha channel.
+
+        By default this is transparent so isn't drawn, but if you set a non-transparent
+        colour here, then it will be overlaid on the image, using the image's alpha
+        channel as a mask.
+
+        This is handy for doing things like darkening or lightening an image by overlaying
+        it with semi-transparent black or white.
+    */
+    void setOverlayColour (Colour newOverlayColour);
+
+    /** Returns the overlay colour. */
+    Colour getOverlayColour() const noexcept                    { return overlayColour; }
+
+    /** Sets the bounding box within which the image should be displayed. */
+    void setBoundingBox (Parallelogram<float> newBounds);
+
+    /** Sets the bounding box within which the image should be displayed. */
+    void setBoundingBox (Rectangle<float> newBounds);
+
+    /** Returns the position to which the image's top-left corner should be remapped in the target
+        coordinate space when rendering this object.
+        @see setTransform
+    */
+    Parallelogram<float> getBoundingBox() const noexcept        { return bounds; }
+
+    //==============================================================================
+    /** @internal */
+    void paint (Graphics&) override;
+    /** @internal */
+    bool hitTest (int x, int y) override;
+    /** @internal */
+    std::unique_ptr<Drawable> createCopy() const override;
+    /** @internal */
+    Rectangle<float> getDrawableBounds() const override;
+    /** @internal */
+    Path getOutlineAsPath() const override;
+
+private:
+    //==============================================================================
+    std::unique_ptr<AccessibilityHandler> createAccessibilityHandler() override;
+    bool setImageInternal (const Image&);
+
+    //==============================================================================
+    Image image;
+    float opacity = 1.0f;
+    Colour overlayColour { 0 };
+    Parallelogram<float> bounds;
+
+    DrawableImage& operator= (const DrawableImage&);
+    JUCE_LEAK_DETECTOR (DrawableImage)
+};
+
+} // namespace juce

deps/juce/modules/juce_gui_basics/drawables/juce_DrawablePath.cpp

@@ -0,0 +1,57 @@
+/*
+  ==============================================================================
+
+   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
+{
+
+DrawablePath::DrawablePath() {}
+DrawablePath::~DrawablePath() {}
+
+DrawablePath::DrawablePath (const DrawablePath& other)  : DrawableShape (other)
+{
+    setPath (other.path);
+}
+
+std::unique_ptr<Drawable> DrawablePath::createCopy() const
+{
+    return std::make_unique<DrawablePath> (*this);
+}
+
+void DrawablePath::setPath (const Path& newPath)
+{
+    path = newPath;
+    pathChanged();
+}
+
+void DrawablePath::setPath (Path&& newPath)
+{
+    path = std::move (newPath);
+    pathChanged();
+}
+
+const Path& DrawablePath::getPath() const           { return path; }
+const Path& DrawablePath::getStrokePath() const     { return strokePath; }
+
+} // namespace juce

deps/juce/modules/juce_gui_basics/drawables/juce_DrawablePath.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 drawable object which renders a filled or outlined shape.
+
+    For details on how to change the fill and stroke, see the DrawableShape class.
+
+    @see Drawable, DrawableShape
+
+    @tags{GUI}
+*/
+class JUCE_API  DrawablePath  : public DrawableShape
+{
+public:
+    //==============================================================================
+    /** Creates a DrawablePath. */
+    DrawablePath();
+    DrawablePath (const DrawablePath&);
+
+    /** Destructor. */
+    ~DrawablePath() override;
+
+    //==============================================================================
+    /** Changes the path that will be drawn.
+        @see setFill, setStrokeType
+    */
+    void setPath (const Path& newPath);
+
+    /** Changes the path that will be drawn.
+        @see setFill, setStrokeType
+    */
+    void setPath (Path&& newPath);
+
+    /** Returns the current path. */
+    const Path& getPath() const;
+
+    /** Returns the current path for the outline. */
+    const Path& getStrokePath() const;
+
+    //==============================================================================
+    /** @internal */
+    std::unique_ptr<Drawable> createCopy() const override;
+
+private:
+    //==============================================================================
+    DrawablePath& operator= (const DrawablePath&);
+    JUCE_LEAK_DETECTOR (DrawablePath)
+};
+
+} // namespace juce

deps/juce/modules/juce_gui_basics/drawables/juce_DrawableRectangle.cpp

@@ -0,0 +1,87 @@
+/*
+  ==============================================================================
+
+   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
+{
+
+DrawableRectangle::DrawableRectangle() {}
+DrawableRectangle::~DrawableRectangle() {}
+
+DrawableRectangle::DrawableRectangle (const DrawableRectangle& other)
+    : DrawableShape (other),
+      bounds (other.bounds),
+      cornerSize (other.cornerSize)
+{
+    rebuildPath();
+}
+
+std::unique_ptr<Drawable> DrawableRectangle::createCopy() const
+{
+    return std::make_unique<DrawableRectangle> (*this);
+}
+
+//==============================================================================
+void DrawableRectangle::setRectangle (Parallelogram<float> newBounds)
+{
+    if (bounds != newBounds)
+    {
+        bounds = newBounds;
+        rebuildPath();
+    }
+}
+
+void DrawableRectangle::setCornerSize (Point<float> newSize)
+{
+    if (cornerSize != newSize)
+    {
+        cornerSize = newSize;
+        rebuildPath();
+    }
+}
+
+void DrawableRectangle::rebuildPath()
+{
+    auto w = bounds.getWidth();
+    auto h = bounds.getHeight();
+
+    Path newPath;
+
+    if (cornerSize.x > 0 && cornerSize.y > 0)
+        newPath.addRoundedRectangle (0, 0, w, h, cornerSize.x, cornerSize.y);
+    else
+        newPath.addRectangle (0, 0, w, h);
+
+    newPath.applyTransform (AffineTransform::fromTargetPoints (Point<float>(),       bounds.topLeft,
+                                                               Point<float> (w, 0),  bounds.topRight,
+                                                               Point<float> (0, h),  bounds.bottomLeft));
+
+    if (path != newPath)
+    {
+        path.swapWithPath (newPath);
+        pathChanged();
+    }
+}
+
+} // namespace juce

deps/juce/modules/juce_gui_basics/drawables/juce_DrawableRectangle.h

@@ -0,0 +1,76 @@
+/*
+  ==============================================================================
+
+   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 Drawable object which draws a rectangle.
+
+    For details on how to change the fill and stroke, see the DrawableShape class.
+
+    @see Drawable, DrawableShape
+
+    @tags{GUI}
+*/
+class JUCE_API  DrawableRectangle  : public DrawableShape
+{
+public:
+    //==============================================================================
+    DrawableRectangle();
+    DrawableRectangle (const DrawableRectangle&);
+
+    /** Destructor. */
+    ~DrawableRectangle() override;
+
+    //==============================================================================
+    /** Sets the rectangle's bounds. */
+    void setRectangle (Parallelogram<float> newBounds);
+
+    /** Returns the rectangle's bounds. */
+    Parallelogram<float> getRectangle() const noexcept              { return bounds; }
+
+    /** Returns the corner size to be used. */
+    Point<float> getCornerSize() const noexcept                     { return cornerSize; }
+
+    /** Sets a new corner size for the rectangle */
+    void setCornerSize (Point<float> newSize);
+
+    //==============================================================================
+    /** @internal */
+    std::unique_ptr<Drawable> createCopy() const override;
+
+private:
+    Parallelogram<float> bounds;
+    Point<float> cornerSize;
+
+    void rebuildPath();
+
+    DrawableRectangle& operator= (const DrawableRectangle&);
+    JUCE_LEAK_DETECTOR (DrawableRectangle)
+};
+
+} // namespace juce

deps/juce/modules/juce_gui_basics/drawables/juce_DrawableShape.cpp

@@ -0,0 +1,181 @@
+/*
+  ==============================================================================
+
+   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
+{
+
+DrawableShape::DrawableShape()
+    : strokeType (0.0f),
+      mainFill (Colours::black),
+      strokeFill (Colours::black)
+{
+}
+
+DrawableShape::DrawableShape (const DrawableShape& other)
+    : Drawable (other),
+      strokeType (other.strokeType),
+      dashLengths (other.dashLengths),
+      mainFill (other.mainFill),
+      strokeFill (other.strokeFill)
+{
+}
+
+DrawableShape::~DrawableShape()
+{
+}
+
+//==============================================================================
+void DrawableShape::setFill (const FillType& newFill)
+{
+    if (mainFill != newFill)
+    {
+        mainFill = newFill;
+        repaint();
+    }
+}
+
+void DrawableShape::setStrokeFill (const FillType& newFill)
+{
+    if (strokeFill != newFill)
+    {
+        strokeFill = newFill;
+        repaint();
+    }
+}
+
+void DrawableShape::setStrokeType (const PathStrokeType& newStrokeType)
+{
+    if (strokeType != newStrokeType)
+    {
+        strokeType = newStrokeType;
+        strokeChanged();
+    }
+}
+
+void DrawableShape::setDashLengths (const Array<float>& newDashLengths)
+{
+    if (dashLengths != newDashLengths)
+    {
+        dashLengths = newDashLengths;
+        strokeChanged();
+    }
+}
+
+void DrawableShape::setStrokeThickness (const float newThickness)
+{
+    setStrokeType (PathStrokeType (newThickness, strokeType.getJointStyle(), strokeType.getEndStyle()));
+}
+
+bool DrawableShape::isStrokeVisible() const noexcept
+{
+    return strokeType.getStrokeThickness() > 0.0f && ! strokeFill.isInvisible();
+}
+
+//==============================================================================
+void DrawableShape::paint (Graphics& g)
+{
+    transformContextToCorrectOrigin (g);
+    applyDrawableClipPath (g);
+
+    g.setFillType (mainFill);
+    g.fillPath (path);
+
+    if (isStrokeVisible())
+    {
+        g.setFillType (strokeFill);
+        g.fillPath (strokePath);
+    }
+}
+
+void DrawableShape::pathChanged()
+{
+    strokeChanged();
+}
+
+void DrawableShape::strokeChanged()
+{
+    strokePath.clear();
+    const float extraAccuracy = 4.0f;
+
+    if (dashLengths.isEmpty())
+        strokeType.createStrokedPath (strokePath, path, AffineTransform(), extraAccuracy);
+    else
+        strokeType.createDashedStroke (strokePath, path, dashLengths.getRawDataPointer(),
+                                       dashLengths.size(), AffineTransform(), extraAccuracy);
+
+    setBoundsToEnclose (getDrawableBounds());
+    repaint();
+}
+
+Rectangle<float> DrawableShape::getDrawableBounds() const
+{
+    if (isStrokeVisible())
+        return strokePath.getBounds();
+
+    return path.getBounds();
+}
+
+bool DrawableShape::hitTest (int x, int y)
+{
+    bool allowsClicksOnThisComponent, allowsClicksOnChildComponents;
+    getInterceptsMouseClicks (allowsClicksOnThisComponent, allowsClicksOnChildComponents);
+
+    if (! allowsClicksOnThisComponent)
+        return false;
+
+    auto globalX = (float) (x - originRelativeToComponent.x);
+    auto globalY = (float) (y - originRelativeToComponent.y);
+
+    return path.contains (globalX, globalY)
+            || (isStrokeVisible() && strokePath.contains (globalX, globalY));
+}
+
+//==============================================================================
+static bool replaceColourInFill (FillType& fill, Colour original, Colour replacement)
+{
+    if (fill.colour == original && fill.isColour())
+    {
+        fill = FillType (replacement);
+        return true;
+    }
+
+    return false;
+}
+
+bool DrawableShape::replaceColour (Colour original, Colour replacement)
+{
+    bool changed1 = replaceColourInFill (mainFill,   original, replacement);
+    bool changed2 = replaceColourInFill (strokeFill, original, replacement);
+    return changed1 || changed2;
+}
+
+Path DrawableShape::getOutlineAsPath() const
+{
+    auto outline = isStrokeVisible() ? strokePath : path;
+    outline.applyTransform (getTransform());
+    return outline;
+}
+
+} // namespace juce

deps/juce/modules/juce_gui_basics/drawables/juce_DrawableShape.h

@@ -0,0 +1,126 @@
+/*
+  ==============================================================================
+
+   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 implementing common functionality for Drawable classes which
+    consist of some kind of filled and stroked outline.
+
+    @see DrawablePath, DrawableRectangle
+
+    @tags{GUI}
+*/
+class JUCE_API  DrawableShape   : public Drawable
+{
+protected:
+    //==============================================================================
+    DrawableShape();
+    DrawableShape (const DrawableShape&);
+
+public:
+    /** Destructor. */
+    ~DrawableShape() override;
+
+    //==============================================================================
+    /** Sets a fill type for the path.
+        This colour is used to fill the path - if you don't want the path to be
+        filled (e.g. if you're just drawing an outline), set this to a transparent
+        colour.
+
+        @see setPath, setStrokeFill
+    */
+    void setFill (const FillType& newFill);
+
+    /** Returns the current fill type.
+        @see setFill
+    */
+    const FillType& getFill() const noexcept                        { return mainFill; }
+
+    /** Sets the fill type with which the outline will be drawn.
+        @see setFill
+    */
+    void setStrokeFill (const FillType& newStrokeFill);
+
+    /** Returns the current stroke fill.
+        @see setStrokeFill
+    */
+    const FillType& getStrokeFill() const noexcept                  { return strokeFill; }
+
+    /** Changes the properties of the outline that will be drawn around the path.
+        If the stroke has 0 thickness, no stroke will be drawn.
+        @see setStrokeThickness, setStrokeColour
+    */
+    void setStrokeType (const PathStrokeType& newStrokeType);
+
+    /** Changes the stroke thickness.
+        This is a shortcut for calling setStrokeType.
+    */
+    void setStrokeThickness (float newThickness);
+
+    /** Returns the current outline style. */
+    const PathStrokeType& getStrokeType() const noexcept            { return strokeType; }
+
+    /** Provides a set of dash lengths to use for stroking the path. */
+    void setDashLengths (const Array<float>& newDashLengths);
+
+    /** Returns the set of dash lengths that the path is using. */
+    const Array<float>& getDashLengths() const noexcept             { return dashLengths; }
+
+    //==============================================================================
+    /** @internal */
+    Rectangle<float> getDrawableBounds() const override;
+    /** @internal */
+    void paint (Graphics&) override;
+    /** @internal */
+    bool hitTest (int x, int y) override;
+    /** @internal */
+    bool replaceColour (Colour originalColour, Colour replacementColour) override;
+    /** @internal */
+    Path getOutlineAsPath() const override;
+
+protected:
+    //==============================================================================
+    /** Called when the cached path should be updated. */
+    void pathChanged();
+    /** Called when the cached stroke should be updated. */
+    void strokeChanged();
+    /** True if there's a stroke with a non-zero thickness and non-transparent colour. */
+    bool isStrokeVisible() const noexcept;
+
+    //==============================================================================
+    PathStrokeType strokeType;
+    Array<float> dashLengths;
+    Path path, strokePath;
+
+private:
+    FillType mainFill, strokeFill;
+
+    DrawableShape& operator= (const DrawableShape&);
+};
+
+} // namespace juce

deps/juce/modules/juce_gui_basics/drawables/juce_DrawableText.cpp

@@ -0,0 +1,232 @@
+/*
+  ==============================================================================
+
+   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
+{
+
+DrawableText::DrawableText()
+    : colour (Colours::black),
+      justification (Justification::centredLeft)
+{
+    setBoundingBox (Parallelogram<float> ({ 0.0f, 0.0f, 50.0f, 20.0f }));
+    setFont (Font (15.0f), true);
+}
+
+DrawableText::DrawableText (const DrawableText& other)
+    : Drawable (other),
+      bounds (other.bounds),
+      fontHeight (other.fontHeight),
+      fontHScale (other.fontHScale),
+      font (other.font),
+      text (other.text),
+      colour (other.colour),
+      justification (other.justification)
+{
+    refreshBounds();
+}
+
+DrawableText::~DrawableText()
+{
+}
+
+std::unique_ptr<Drawable> DrawableText::createCopy() const
+{
+    return std::make_unique<DrawableText> (*this);
+}
+
+//==============================================================================
+void DrawableText::setText (const String& newText)
+{
+    if (text != newText)
+    {
+        text = newText;
+        refreshBounds();
+    }
+}
+
+void DrawableText::setColour (Colour newColour)
+{
+    if (colour != newColour)
+    {
+        colour = newColour;
+        repaint();
+    }
+}
+
+void DrawableText::setFont (const Font& newFont, bool applySizeAndScale)
+{
+    if (font != newFont)
+    {
+        font = newFont;
+
+        if (applySizeAndScale)
+        {
+            fontHeight = font.getHeight();
+            fontHScale = font.getHorizontalScale();
+        }
+
+        refreshBounds();
+    }
+}
+
+void DrawableText::setJustification (Justification newJustification)
+{
+    justification = newJustification;
+    repaint();
+}
+
+void DrawableText::setBoundingBox (Parallelogram<float> newBounds)
+{
+    if (bounds != newBounds)
+    {
+        bounds = newBounds;
+        refreshBounds();
+    }
+}
+
+void DrawableText::setFontHeight (float newHeight)
+{
+    if (fontHeight != newHeight)
+    {
+        fontHeight = newHeight;
+        refreshBounds();
+    }
+}
+
+void DrawableText::setFontHorizontalScale (float newScale)
+{
+    if (fontHScale != newScale)
+    {
+        fontHScale = newScale;
+        refreshBounds();
+    }
+}
+
+void DrawableText::refreshBounds()
+{
+    auto w = bounds.getWidth();
+    auto h = bounds.getHeight();
+
+    auto height = jlimit (0.01f, jmax (0.01f, h), fontHeight);
+    auto hscale = jlimit (0.01f, jmax (0.01f, w), fontHScale);
+
+    scaledFont = font;
+    scaledFont.setHeight (height);
+    scaledFont.setHorizontalScale (hscale);
+
+    setBoundsToEnclose (getDrawableBounds());
+    repaint();
+}
+
+//==============================================================================
+Rectangle<int> DrawableText::getTextArea (float w, float h) const
+{
+    return Rectangle<float> (w, h).getSmallestIntegerContainer();
+}
+
+AffineTransform DrawableText::getTextTransform (float w, float h) const
+{
+    return AffineTransform::fromTargetPoints (Point<float>(),       bounds.topLeft,
+                                              Point<float> (w, 0),  bounds.topRight,
+                                              Point<float> (0, h),  bounds.bottomLeft);
+}
+
+void DrawableText::paint (Graphics& g)
+{
+    transformContextToCorrectOrigin (g);
+
+    auto w = bounds.getWidth();
+    auto h = bounds.getHeight();
+
+    g.addTransform (getTextTransform (w, h));
+    g.setFont (scaledFont);
+    g.setColour (colour);
+
+    g.drawFittedText (text, getTextArea (w, h), justification, 0x100000);
+}
+
+Rectangle<float> DrawableText::getDrawableBounds() const
+{
+    return bounds.getBoundingBox();
+}
+
+Path DrawableText::getOutlineAsPath() const
+{
+    auto w = bounds.getWidth();
+    auto h = bounds.getHeight();
+    auto area = getTextArea (w, h).toFloat();
+
+    GlyphArrangement arr;
+    arr.addFittedText (scaledFont, text,
+                       area.getX(), area.getY(),
+                       area.getWidth(), area.getHeight(),
+                       justification,
+                       0x100000);
+
+    Path pathOfAllGlyphs;
+
+    for (auto& glyph : arr)
+    {
+        Path gylphPath;
+        glyph.createPath (gylphPath);
+        pathOfAllGlyphs.addPath (gylphPath);
+    }
+
+    pathOfAllGlyphs.applyTransform (getTextTransform (w, h).followedBy (getTransform()));
+
+    return pathOfAllGlyphs;
+}
+
+bool DrawableText::replaceColour (Colour originalColour, Colour replacementColour)
+{
+    if (colour != originalColour)
+        return false;
+
+    setColour (replacementColour);
+    return true;
+}
+
+//==============================================================================
+std::unique_ptr<AccessibilityHandler> DrawableText::createAccessibilityHandler()
+{
+    class DrawableTextAccessibilityHandler  : public AccessibilityHandler
+    {
+    public:
+        DrawableTextAccessibilityHandler (DrawableText& drawableTextToWrap)
+            : AccessibilityHandler (drawableTextToWrap, AccessibilityRole::staticText),
+              drawableText (drawableTextToWrap)
+        {
+        }
+
+        String getTitle() const override  { return drawableText.getText(); }
+
+    private:
+        DrawableText& drawableText;
+    };
+
+    return std::make_unique<DrawableTextAccessibilityHandler> (*this);
+}
+
+} // namespace juce

deps/juce/modules/juce_gui_basics/drawables/juce_DrawableText.h

@@ -0,0 +1,120 @@
+/*
+  ==============================================================================
+
+   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 drawable object which renders a line of text.
+
+    @see Drawable
+
+    @tags{GUI}
+*/
+class JUCE_API  DrawableText  : public Drawable
+{
+public:
+    //==============================================================================
+    /** Creates a DrawableText object. */
+    DrawableText();
+    DrawableText (const DrawableText&);
+
+    /** Destructor. */
+    ~DrawableText() override;
+
+    //==============================================================================
+    /** Sets the text to display.*/
+    void setText (const String& newText);
+
+    /** Returns the currently displayed text */
+    const String& getText() const noexcept                              { return text;}
+
+    /** Sets the colour of the text. */
+    void setColour (Colour newColour);
+
+    /** Returns the current text colour. */
+    Colour getColour() const noexcept                                   { return colour; }
+
+    /** Sets the font to use.
+        Note that the font height and horizontal scale are set using setFontHeight() and
+        setFontHorizontalScale(). If applySizeAndScale is true, then these height
+        and scale values will be changed to match the dimensions of the font supplied;
+        if it is false, then the new font object's height and scale are ignored.
+    */
+    void setFont (const Font& newFont, bool applySizeAndScale);
+
+    /** Returns the current font. */
+    const Font& getFont() const noexcept                                { return font; }
+
+    /** Changes the justification of the text within the bounding box. */
+    void setJustification (Justification newJustification);
+
+    /** Returns the current justification. */
+    Justification getJustification() const noexcept                     { return justification; }
+
+    /** Returns the parallelogram that defines the text bounding box. */
+    Parallelogram<float> getBoundingBox() const noexcept                { return bounds; }
+
+    /** Sets the bounding box that contains the text. */
+    void setBoundingBox (Parallelogram<float> newBounds);
+
+    float getFontHeight() const noexcept                                { return fontHeight; }
+    void setFontHeight (float newHeight);
+
+    float getFontHorizontalScale() const noexcept                       { return fontHScale; }
+    void setFontHorizontalScale (float newScale);
+
+    //==============================================================================
+    /** @internal */
+    void paint (Graphics&) override;
+    /** @internal */
+    std::unique_ptr<Drawable> createCopy() const override;
+    /** @internal */
+    Rectangle<float> getDrawableBounds() const override;
+    /** @internal */
+    Path getOutlineAsPath() const override;
+    /** @internal */
+    bool replaceColour (Colour originalColour, Colour replacementColour) override;
+
+private:
+    //==============================================================================
+    Parallelogram<float> bounds;
+    float fontHeight, fontHScale;
+    Font font, scaledFont;
+    String text;
+    Colour colour;
+    Justification justification;
+
+    std::unique_ptr<AccessibilityHandler> createAccessibilityHandler() override;
+    void refreshBounds();
+    Rectangle<int> getTextArea (float width, float height) const;
+    AffineTransform getTextTransform (float width, float height) const;
+
+    DrawableText& operator= (const DrawableText&);
+    JUCE_LEAK_DETECTOR (DrawableText)
+};
+
+} // namespace juce