fix macOS build (following Projucer changes made in Windows, which removed /Applications/JUCE/modules from its headers). move JUCE headers under source control, so that Windows and macOS can both build against same version of JUCE. remove AUv3 target (I think it's an iOS thing, so it will never work with this macOS fluidsynth dylib).

modules/juce_gui_basics/drawables/juce_Drawable.cpp

@@ -0,0 +1,215 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2017 - ROLI Ltd.
+
+   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 5 End-User License
+   Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
+   27th April 2017).
+
+   End User License Agreement: www.juce.com/juce-5-licence
+   Privacy Policy: www.juce.com/juce-5-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);
+}
+
+Drawable::Drawable (const Drawable& other)
+    : Component (other.getName())
+{
+    setInterceptsMouseClicks (false, false);
+    setPaintingIsUnclipped (true);
+
+    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 (Drawable* clipPath)
+{
+    if (drawableClipPath.get() != clipPath)
+    {
+        drawableClipPath.reset (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));
+}
+
+//==============================================================================
+Drawable* Drawable::createFromImageData (const void* data, const size_t numBytes)
+{
+    Drawable* result = nullptr;
+
+    auto image = ImageFileFormat::loadFrom (data, numBytes);
+
+    if (image.isValid())
+    {
+        auto* di = new DrawableImage();
+        di->setImage (image);
+        result = di;
+    }
+    else
+    {
+        auto asString = String::createStringFromData (data, (int) numBytes);
+
+        XmlDocument doc (asString);
+        std::unique_ptr<XmlElement> outer (doc.getDocumentElement (true));
+
+        if (outer != nullptr && outer->hasTagName ("svg"))
+        {
+            std::unique_ptr<XmlElement> svg (doc.getDocumentElement());
+
+            if (svg != nullptr)
+                result = Drawable::createFromSVG (*svg);
+        }
+    }
+
+    return result;
+}
+
+Drawable* Drawable::createFromImageDataStream (InputStream& dataSource)
+{
+    MemoryOutputStream mo;
+    mo << dataSource;
+
+    return createFromImageData (mo.getData(), mo.getDataSize());
+}
+
+Drawable* Drawable::createFromImageFile (const File& file)
+{
+    FileInputStream fin (file);
+
+    return fin.openedOk() ? createFromImageDataStream (fin) : nullptr;
+}
+
+} // namespace juce

modules/juce_gui_basics/drawables/juce_Drawable.h

@@ -0,0 +1,216 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2017 - ROLI Ltd.
+
+   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 5 End-User License
+   Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
+   27th April 2017).
+
+   End User License Agreement: www.juce.com/juce-5-licence
+   Privacy Policy: www.juce.com/juce-5-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. */
+    virtual ~Drawable();
+
+    //==============================================================================
+    /** 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 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 drawbale passed in ill be deleted when no longer needed.
+    */
+    void setClipPath (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 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 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 Drawable* createFromImageFile (const File& file);
+
+    /** Attempts to parse an SVG (Scalable Vector Graphics) document, and to turn this
+        into a Drawable tree.
+
+        The object returned must be deleted by the caller. 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 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.
+
+        The object returned must be deleted by the caller. 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 Drawable* createFromSVGFile (const File& svgFile);
+
+    /** Parses an SVG path string and returns it. */
+    static Path parseSVGPath (const String& svgPath);
+
+    //==============================================================================
+    /** Returns the area that this drawble 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

modules/juce_gui_basics/drawables/juce_DrawableComposite.cpp

@@ -0,0 +1,165 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2017 - ROLI Ltd.
+
+   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 5 End-User License
+   Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
+   27th April 2017).
+
+   End User License Agreement: www.juce.com/juce-5-licence
+   Privacy Policy: www.juce.com/juce-5-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());
+}
+
+DrawableComposite::~DrawableComposite()
+{
+    deleteAllChildren();
+}
+
+Drawable* DrawableComposite::createCopy() const
+{
+    return new 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

modules/juce_gui_basics/drawables/juce_DrawableComposite.h

@@ -0,0 +1,118 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2017 - ROLI Ltd.
+
+   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 5 End-User License
+   Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
+   27th April 2017).
+
+   End User License Agreement: www.juce.com/juce-5-licence
+   Privacy Policy: www.juce.com/juce-5-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();
+
+    //==============================================================================
+    /** 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 */
+    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

modules/juce_gui_basics/drawables/juce_DrawableImage.cpp

@@ -0,0 +1,137 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2017 - ROLI Ltd.
+
+   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 5 End-User License
+   Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
+   27th April 2017).
+
+   End User License Agreement: www.juce.com/juce-5-licence
+   Privacy Policy: www.juce.com/juce-5-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()
+{
+}
+
+Drawable* DrawableImage::createCopy() const
+{
+    return new DrawableImage (*this);
+}
+
+//==============================================================================
+void DrawableImage::setImage (const Image& imageToUse)
+{
+    if (image != imageToUse)
+    {
+        image = imageToUse;
+        setBounds (image.getBounds());
+        setBoundingBox (image.getBounds().toFloat());
+        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
+}
+
+} // namespace juce

modules/juce_gui_basics/drawables/juce_DrawableImage.h

@@ -0,0 +1,110 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2017 - ROLI Ltd.
+
+   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 5 End-User License
+   Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
+   27th April 2017).
+
+   End User License Agreement: www.juce.com/juce-5-licence
+   Privacy Policy: www.juce.com/juce-5-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&);
+
+    /** Destructor. */
+    ~DrawableImage();
+
+    //==============================================================================
+    /** 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 */
+    Drawable* createCopy() const override;
+    /** @internal */
+    Rectangle<float> getDrawableBounds() const override;
+    /** @internal */
+    Path getOutlineAsPath() const override;
+
+private:
+    //==============================================================================
+    Image image;
+    float opacity = 1.0f;
+    Colour overlayColour { 0 };
+    Parallelogram<float> bounds;
+
+    DrawableImage& operator= (const DrawableImage&);
+    JUCE_LEAK_DETECTOR (DrawableImage)
+};
+
+} // namespace juce

modules/juce_gui_basics/drawables/juce_DrawablePath.cpp

@@ -0,0 +1,58 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2017 - ROLI Ltd.
+
+   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 5 End-User License
+   Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
+   27th April 2017).
+
+   End User License Agreement: www.juce.com/juce-5-licence
+   Privacy Policy: www.juce.com/juce-5-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);
+}
+
+Drawable* DrawablePath::createCopy() const
+{
+    return new DrawablePath (*this);
+}
+
+void DrawablePath::setPath (const Path& newPath)
+{
+    path = newPath;
+    pathChanged();
+}
+
+void DrawablePath::setPath (Path&& newPath)
+{
+    path = static_cast<Path&&> (newPath);
+    pathChanged();
+}
+
+const Path& DrawablePath::getPath() const           { return path; }
+const Path& DrawablePath::getStrokePath() const     { return strokePath; }
+
+} // namespace juce

modules/juce_gui_basics/drawables/juce_DrawablePath.h

@@ -0,0 +1,78 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2017 - ROLI Ltd.
+
+   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 5 End-User License
+   Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
+   27th April 2017).
+
+   End User License Agreement: www.juce.com/juce-5-licence
+   Privacy Policy: www.juce.com/juce-5-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();
+
+    //==============================================================================
+    /** 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 */
+    Drawable* createCopy() const;
+
+private:
+    //==============================================================================
+    DrawablePath& operator= (const DrawablePath&);
+    JUCE_LEAK_DETECTOR (DrawablePath)
+};
+
+} // namespace juce

modules/juce_gui_basics/drawables/juce_DrawableRectangle.cpp

@@ -0,0 +1,88 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2017 - ROLI Ltd.
+
+   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 5 End-User License
+   Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
+   27th April 2017).
+
+   End User License Agreement: www.juce.com/juce-5-licence
+   Privacy Policy: www.juce.com/juce-5-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();
+}
+
+Drawable* DrawableRectangle::createCopy() const
+{
+    return new 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

modules/juce_gui_basics/drawables/juce_DrawableRectangle.h

@@ -0,0 +1,77 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2017 - ROLI Ltd.
+
+   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 5 End-User License
+   Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
+   27th April 2017).
+
+   End User License Agreement: www.juce.com/juce-5-licence
+   Privacy Policy: www.juce.com/juce-5-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();
+
+    //==============================================================================
+    /** 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 */
+    Drawable* createCopy() const;
+
+private:
+    Parallelogram<float> bounds;
+    Point<float> cornerSize;
+
+    void rebuildPath();
+
+    DrawableRectangle& operator= (const DrawableRectangle&);
+    JUCE_LEAK_DETECTOR (DrawableRectangle)
+};
+
+} // namespace juce

modules/juce_gui_basics/drawables/juce_DrawableShape.cpp

@@ -0,0 +1,182 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2017 - ROLI Ltd.
+
+   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 5 End-User License
+   Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
+   27th April 2017).
+
+   End User License Agreement: www.juce.com/juce-5-licence
+   Privacy Policy: www.juce.com/juce-5-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

modules/juce_gui_basics/drawables/juce_DrawableShape.h

@@ -0,0 +1,127 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2017 - ROLI Ltd.
+
+   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 5 End-User License
+   Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
+   27th April 2017).
+
+   End User License Agreement: www.juce.com/juce-5-licence
+   Privacy Policy: www.juce.com/juce-5-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();
+
+    //==============================================================================
+    /** 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

modules/juce_gui_basics/drawables/juce_DrawableText.cpp

@@ -0,0 +1,203 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2017 - ROLI Ltd.
+
+   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 5 End-User License
+   Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
+   27th April 2017).
+
+   End User License Agreement: www.juce.com/juce-5-licence
+   Privacy Policy: www.juce.com/juce-5-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()
+{
+}
+
+Drawable* DrawableText::createCopy() const
+{
+    return new 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;
+}
+
+} // namespace juce

modules/juce_gui_basics/drawables/juce_DrawableText.h

@@ -0,0 +1,118 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE library.
+   Copyright (c) 2017 - ROLI Ltd.
+
+   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 5 End-User License
+   Agreement and JUCE 5 Privacy Policy (both updated and effective as of the
+   27th April 2017).
+
+   End User License Agreement: www.juce.com/juce-5-licence
+   Privacy Policy: www.juce.com/juce-5-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();
+
+    //==============================================================================
+    /** 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 */
+    Drawable* createCopy() const override;
+    /** @internal */
+    Rectangle<float> getDrawableBounds() const override;
+    /** @internal */
+    Path getOutlineAsPath() const override;
+
+private:
+    //==============================================================================
+    Parallelogram<float> bounds;
+    float fontHeight, fontHScale;
+    Font font, scaledFont;
+    String text;
+    Colour colour;
+    Justification justification;
+
+    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