juce_TextLayout.h

Go to the documentation of this file.

 /*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2022 - 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 7 End-User License
   Agreement and JUCE Privacy Policy.
 
   End User License Agreement: www.juce.com/juce-7-licence
   Privacy Policy: www.juce.com/juce-privacy-policy
 
   Or: You may also use this code under the terms of the GPL v3 (see
   www.gnu.org/licenses).
 
   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
   DISCLAIMED.
 
  ==============================================================================
*/
 
namespace juce
{
 
//==============================================================================
class JUCE_API  TextLayout  final
{
private:
    template <typename Iterator>
    class DereferencingIterator
    {
    public:
        using value_type = std::remove_reference_t<decltype(**std::declval<Iterator>())>;
        using difference_type = typename std::iterator_traits<Iterator>::difference_type;
        using pointer = value_type*;
        using reference = value_type&;
        using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
 
        explicit DereferencingIterator (Iterator in) : iterator (std::move (in)) {}
 
        DereferencingIterator& operator+= (difference_type distance)
        {
            iterator += distance;
            return *this;
        }
 
        friend DereferencingIterator operator+ (DereferencingIterator i, difference_type d) { return i += d; }
        friend DereferencingIterator operator+ (difference_type d, DereferencingIterator i) { return i += d; }
 
        DereferencingIterator& operator-= (difference_type distance)
        {
            iterator -= distance;
            return *this;
        }
 
        friend DereferencingIterator operator- (DereferencingIterator i, difference_type d) { return i -= d; }
 
        friend difference_type operator- (DereferencingIterator a, DereferencingIterator b)   { return a.iterator - b.iterator; }
 
        reference operator[] (difference_type d) const { return *iterator[d]; }
 
        friend bool operator<  (DereferencingIterator a, DereferencingIterator b) { return a.iterator <  b.iterator; }
        friend bool operator<= (DereferencingIterator a, DereferencingIterator b) { return a.iterator <= b.iterator; }
        friend bool operator>  (DereferencingIterator a, DereferencingIterator b) { return a.iterator >  b.iterator; }
        friend bool operator>= (DereferencingIterator a, DereferencingIterator b) { return a.iterator >= b.iterator; }
        friend bool operator== (DereferencingIterator a, DereferencingIterator b) { return a.iterator == b.iterator; }
        friend bool operator!= (DereferencingIterator a, DereferencingIterator b) { return a.iterator != b.iterator; }
 
        DereferencingIterator& operator++()           { ++iterator; return *this; }
        DereferencingIterator& operator--()           { --iterator; return *this; }
        DereferencingIterator  operator++ (int) const { DereferencingIterator copy (*this); ++(*this); return copy; }
        DereferencingIterator  operator-- (int) const { DereferencingIterator copy (*this); --(*this); return copy; }
 
        reference operator* () const { return **iterator; }
        pointer   operator->() const { return  *iterator; }
 
    private:
        Iterator iterator;
    };
 
public:
    TextLayout();
    TextLayout (const TextLayout&);
    TextLayout& operator= (const TextLayout&);
    TextLayout (TextLayout&&) noexcept;
    TextLayout& operator= (TextLayout&&) noexcept;
 
    ~TextLayout();
 
    //==============================================================================
    void createLayout (const AttributedString&, float maxWidth);
 
    void createLayout (const AttributedString&, float maxWidth, float maxHeight);
 
    void createLayoutWithBalancedLineLengths (const AttributedString&, float maxWidth);
 
    void createLayoutWithBalancedLineLengths (const AttributedString&, float maxWidth, float maxHeight);
 
    void draw (Graphics&, Rectangle<float> area) const;
 
    //==============================================================================
    class JUCE_API  Glyph
    {
    public:
        Glyph (int glyphCode, Point<float> anchor, float width) noexcept;
 
        int glyphCode;
 
        Point<float> anchor;
 
        float width;
 
    private:
        JUCE_LEAK_DETECTOR (Glyph)
    };
 
    //==============================================================================
    class JUCE_API  Run
    {
    public:
        Run() = default;
        Run (Range<int> stringRange, int numGlyphsToPreallocate);
 
        Range<float> getRunBoundsX() const noexcept;
 
        Font font;                      
        Colour colour { 0xff000000 };   
        Array<Glyph> glyphs;            
        Range<int> stringRange;         
    private:
        JUCE_LEAK_DETECTOR (Run)
    };
 
    //==============================================================================
    class JUCE_API  Line
    {
    public:
        Line() = default;
        Line (Range<int> stringRange, Point<float> lineOrigin,
              float ascent, float descent, float leading, int numRunsToPreallocate);
 
        Line (const Line&);
        Line& operator= (const Line&);
 
        Line (Line&&) noexcept = default;
        Line& operator= (Line&&) noexcept = default;
 
        ~Line() noexcept = default;
 
        Range<float> getLineBoundsX() const noexcept;
 
        Range<float> getLineBoundsY() const noexcept;
 
        Rectangle<float> getLineBounds() const noexcept;
 
        void swap (Line& other) noexcept;
 
        OwnedArray<Run> runs;           
        Range<int> stringRange;         
        Point<float> lineOrigin;        
        float ascent = 0.0f, descent = 0.0f, leading = 0.0f;
 
    private:
        JUCE_LEAK_DETECTOR (Line)
    };
 
    //==============================================================================
    float getWidth() const noexcept     { return width; }
 
    float getHeight() const noexcept    { return height; }
 
    int getNumLines() const noexcept    { return lines.size(); }
 
    Line& getLine (int index) const noexcept;
 
    void addLine (std::unique_ptr<Line>);
 
    void ensureStorageAllocated (int numLinesNeeded);
 
    using       iterator = DereferencingIterator<      Line* const*>;
    using const_iterator = DereferencingIterator<const Line* const*>;
 
          iterator  begin()       { return       iterator (lines.begin()); }
    const_iterator  begin() const { return const_iterator (lines.begin()); }
    const_iterator cbegin() const { return const_iterator (lines.begin()); }
 
          iterator  end()       { return       iterator (lines.end()); }
    const_iterator  end() const { return const_iterator (lines.end()); }
    const_iterator cend() const { return const_iterator (lines.end()); }
 
    void recalculateSize();
 
private:
    OwnedArray<Line> lines;
    float width, height;
    Justification justification;
 
    void createStandardLayout (const AttributedString&);
    bool createNativeLayout (const AttributedString&);
 
    JUCE_LEAK_DETECTOR (TextLayout)
};
 
} // namespace juce