Layout-TNG.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Inkscape::Text::Layout - text layout engine
 *
 * Authors:
 *   Richard Hughes <cyreve@users.sf.net>
 *
 * Copyright (C) 2005 Richard Hughes
 *
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
#ifndef SEEN_LAYOUT_TNG_H
#define SEEN_LAYOUT_TNG_H
 
//#define DEBUG_TEXTLAYOUT_DUMPASTEXT
 
#include <2geom/affine.h>
#include <2geom/d2.h>
#include <algorithm>
#include <glibmm/ustring.h>
#include <memory>
#include <optional>
#include <pango/pango-break.h>
#include <svg/svg-length.h>
#include <vector>
 
#include "display/curve.h"
#include <sigc++/scoped_connection.h>
#include "livarot/Shape.h"
#include "style-enums.h"
 
namespace Inkscape::Extension::Internal {
class CairoRenderContext;
}
 
using Inkscape::Extension::Internal::CairoRenderContext;
 
class SPStyle;
class SPObject;
class Shape;
struct SPPrintContext;
class Path;
class FontInstance;
using PangoFontDescription = struct _PangoFontDescription;
 
namespace Inkscape {
class DrawingGroup;
 
namespace Text {
class StyleAttachments;
 
class Layout {
public:
    class iterator;
    friend class iterator;
    class Calculator;
    friend class Calculator;
    class ScanlineMaker;
    class InfiniteScanlineMaker;
    class ShapeScanlineMaker;
 
    Layout();
    virtual ~Layout();
 
    enum Direction {LEFT_TO_RIGHT, RIGHT_TO_LEFT, TOP_TO_BOTTOM, BOTTOM_TO_TOP};
 
    enum Orientation {ORIENTATION_UPRIGHT, ORIENTATION_SIDEWAYS};
 
 
    enum DisplayAlign {DISPLAY_ALIGN_BEFORE, DISPLAY_ALIGN_CENTER, DISPLAY_ALIGN_AFTER};
 
    enum LengthAdjust {LENGTHADJUST_SPACING, LENGTHADJUST_SPACINGANDGLYPHS};
 
    enum WrapMode {
        WRAP_NONE,         // No wrapping or wrapping via role="line".
        WRAP_WHITE_SPACE,  // Wrapping via 'white-space' property.
        WRAP_INLINE_SIZE,  // Wrapping via 'inline-size' property.
        WRAP_SHAPE_INSIDE  // Wrapping via 'shape-inside' propertry.
    } wrap_mode = WRAP_NONE;
 
    struct OptionalTextTagAttrs {
        std::vector<SVGLength> x;
        std::vector<SVGLength> y;
        std::vector<SVGLength> dx;
        std::vector<SVGLength> dy;
        std::vector<SVGLength> rotate;
        SVGLength textLength;
        LengthAdjust lengthAdjust;
    };
 
    enum TextControlCode {
        PARAGRAPH_BREAK,    
        SHAPE_BREAK,        
        ARBITRARY_GAP       
    };
 
    enum Alignment {LEFT, CENTER, RIGHT, FULL, NONE};
 
    static const double LINE_HEIGHT_NORMAL;
 
    // ************************** describing the stuff to flow *************************
 
 
    void clear();
 
    bool inputExists() const
        {return !_input_stream.empty();}
 
    bool _input_truncated = false;
    bool inputTruncated() const
        {return _input_truncated;}
 
    void appendText(Glib::ustring const &text, SPStyle *style, SPObject *source, OptionalTextTagAttrs const *optional_attributes, unsigned optional_attributes_offset, Glib::ustring::const_iterator text_begin, Glib::ustring::const_iterator text_end);
    inline void appendText(Glib::ustring const &text, SPStyle *style, SPObject *source, OptionalTextTagAttrs const *optional_attributes = nullptr, unsigned optional_attributes_offset = 0)
        {appendText(text, style, source, optional_attributes, optional_attributes_offset, text.begin(), text.end());}
 
    void appendControlCode(TextControlCode code, SPObject *source, double width = 0.0, double ascent = 0.0, double descent = 0.0);
 
    void appendWrapShape(std::unique_ptr<Shape> shape, DisplayAlign display_align = DISPLAY_ALIGN_BEFORE);
 
    // ************************** textLength and friends *************************
 
    SVGLength textLength;
 
    LengthAdjust lengthAdjust = LENGTHADJUST_SPACING;
 
    double textLengthMultiplier = 1;
    double textLengthIncrement = 0;
 
    double getTextLengthIncrementDue() const;
    double getTextLengthMultiplierDue() const;
 
    double getActualLength() const;
 
    // ************************** doing the actual flowing *************************
 
 
    bool calculateFlow();
 
 
    // ************************** operating on the output glyphs *************************
 
 
    inline bool outputExists() const
        {return !_characters.empty();}
 
    void show(DrawingGroup *in_arena, StyleAttachments &style_attachments, Geom::OptRect const &paintbox) const;
 
    Geom::OptRect bounds(Geom::Affine const &transform, bool with_stroke = false, int start = -1, int length = -1) const;
 
    void print(SPPrintContext *ctx, Geom::OptRect const &pbox, Geom::OptRect const &dbox, Geom::OptRect const &bbox, Geom::Affine const &ctm) const;
 
    void showGlyphs(CairoRenderContext *ctx) const;
 
    Glib::ustring getFontFamily(unsigned span_index) const;
 
#if DEBUG_TEXTLAYOUT_DUMPASTEXT
    Glib::ustring dumpAsText() const;
#endif
 
    void fitToPathAlign(SVGLength const &startOffset, Path const &path);
 
    SPCurve convertToCurves(iterator const &from_glyph, iterator const &to_glyph) const;
    SPCurve convertToCurves() const;
 
    void transform(Geom::Affine const &transform);
 
 
    // **********
 
 
    inline iterator begin() const;
 
    inline iterator end() const;
 
    inline iterator charIndexToIterator(int char_index) const;
 
    inline int iteratorToCharIndex(iterator const &it) const;
 
    inline void validateIterator(iterator *it) const;
 
    iterator getNearestCursorPositionTo(double x, double y) const;
    inline iterator getNearestCursorPositionTo(Geom::Point const &point) const;
 
    iterator getLetterAt(double x, double y) const;
    inline iterator getLetterAt(Geom::Point &point) const;
 
    /* Returns an iterator pointing to the character in the output which
    was created from the given input. If the character at the given byte
    offset was removed (soft hyphens, for example) the next character after
    it is returned. If no input was added with the given object, end() is
    returned. If more than one input has the same object, the first will
    be used regardless of the value of \a text_iterator. If
    \a text_iterator is out of bounds, the first or last character belonging
    to the given input will be returned accordingly.
    iterator sourceToIterator(SPObject *source, Glib::ustring::const_iterator text_iterator) const;
 */
 
    iterator sourceToIterator(SPObject *source) const;
 
    // many functions acting on iterators, most of which are obvious
    // also most of them don't check that \a it != end(). Be careful.
 
    Geom::OptRect glyphBoundingBox(iterator const &it, double *rotation) const;
 
    inline unsigned lineIndex(iterator const &it) const;
 
    inline unsigned shapeIndex(iterator const &it) const;
 
    inline bool isWhitespace(iterator const &it) const;
 
    inline gunichar characterAt(iterator const &it) const;
 
    bool isHidden(iterator const &it) const;
 
    void getSourceOfCharacter(iterator const &it, SPObject **source, Glib::ustring::iterator *text_iterator = nullptr) const;
 
    Geom::Point characterAnchorPoint(iterator const &it) const;
 
    std::optional<Geom::Point> baselineAnchorPoint() const;
 
    Geom::Path baseline() const;
 
    std::vector<Geom::LineSegment> getBaselines() const { return _baselines; }
 
    Geom::Point chunkAnchorPoint(iterator const &it) const;
 
    Geom::Rect characterBoundingBox(iterator const &it, double *rotation = nullptr) const;
 
    std::vector<Geom::Point> createSelectionShape(iterator const &it_start, iterator const &it_end, Geom::Affine const &transform) const;
 
    inline bool isCursorPosition(iterator const &it) const;
 
    void queryCursorShape(iterator const &it, Geom::Point &position, double &height, double &rotation) const;
 
    inline bool isStartOfWord(iterator const &it) const;
 
    inline bool isEndOfWord(iterator const &it) const;
 
    inline bool isStartOfSentence(iterator const &it) const;
 
    inline bool isEndOfSentence(iterator const &it) const;
 
    inline unsigned paragraphIndex(iterator const &it) const;
 
    inline Alignment paragraphAlignment(iterator const &it) const;
 
    void simulateLayoutUsingKerning(iterator const &from, iterator const &to, OptionalTextTagAttrs *result) const;
 
 
 
    class FontMetrics {
 
    public:
        FontMetrics() { reset(); }
        
        void reset() {
            ascent      =  0.8;
            descent     =  0.2;
            xheight     =  0.5;
            ascent_max  =  0.8;
            descent_max =  0.2;
        }            
 
        void set(FontInstance const *font);
        
        // CSS 2.1 dictates that font-size is based on em-size which is defined as ascent + descent
        inline double emSize() const {return ascent + descent;}
        // Alternatively name function for use 2.
        inline double lineSize() const { return ascent + descent; }
        inline void setZero() {ascent = descent = xheight = ascent_max = descent_max = 0.0;}
 
        // For scaling for 'font-size'.
        inline FontMetrics& operator*=(double x) {
            ascent *= x; descent *= x; xheight *= x; ascent_max *= x; descent_max *= x;
            return *this;
        }
 
        void max(FontMetrics const &other);
 
        void computeEffective( const double &line_height );
 
        inline double getTypoAscent()  const {return ascent; }
        inline double getTypoDescent() const {return descent; }
        inline double getXHeight()     const {return xheight; }
        inline double getMaxAscent()   const {return ascent_max; }
        inline double getMaxDescent()  const {return descent_max; }
 
        // private:
        double ascent;      // Typographic ascent.
        double descent;     // Typographic descent. (Normally positive).
        double xheight;     // Height of 'x' measured from alphabetic baseline.
        double ascent_max;  // Maximum ascent of all glyphs in font.
        double descent_max; // Maximum descent of all glyphs in font.
 
    }; // End FontMetrics
 
    FontMetrics strut;
 
private:
    void _clearInputObjects();
 
    void _clearOutputObjects();
 
    static const gunichar UNICODE_SOFT_HYPHEN;
 
    // ******************* input flow
 
public:
    enum InputStreamItemType {TEXT_SOURCE, CONTROL_CODE};
 
    class InputStreamItem {
    public:
        virtual ~InputStreamItem() = default;
        virtual InputStreamItemType Type() const = 0;
        SPObject *source;
    };
 
    class InputStreamTextSource : public InputStreamItem {
    public:
        InputStreamItemType Type() const override {return TEXT_SOURCE;}
        ~InputStreamTextSource() override;
        Glib::ustring const *text;    
        Glib::ustring::const_iterator text_begin, text_end;
        int text_length;    
        SPStyle *style;
        sigc::scoped_connection style_conn;
        std::vector<SVGLength> x;
        std::vector<SVGLength> y;
        std::vector<SVGLength> dx;
        std::vector<SVGLength> dy;
        std::vector<SVGLength> rotate;
        SVGLength textLength;
        LengthAdjust lengthAdjust;
        Glib::ustring lang;
 
        // a few functions for some of the more complicated style accesses
        PangoFontDescription *styleGetFontDescription() const;
        std::shared_ptr<FontInstance> styleGetFontInstance() const;
        Direction styleGetBlockProgression() const;
        SPCSSTextOrientation styleGetTextOrientation() const;
        SPCSSBaseline styleGetDominantBaseline() const;
        Alignment styleGetAlignment(Direction para_direction, bool try_text_align) const;
    };
 
private:
    class InputStreamControlCode : public InputStreamItem {
    public:
        InputStreamItemType Type() const override {return CONTROL_CODE;}
        TextControlCode code;
        double ascent;
        double descent;
        double width;
    };
 
    std::vector<InputStreamItem*> _input_stream;
 
    static void _copyInputVector(std::vector<SVGLength> const &input_vector, unsigned input_offset, std::vector<SVGLength> *output_vector, size_t max_length);
 
    inline Direction _blockProgression() const
        {
            if(!_input_stream.empty())
                return static_cast<InputStreamTextSource*>(_input_stream.front())->styleGetBlockProgression();
            return TOP_TO_BOTTOM;
        }
 
    inline  SPCSSTextOrientation _blockTextOrientation() const
        {
            if(!_input_stream.empty())
                return static_cast<InputStreamTextSource*>(_input_stream.front())->styleGetTextOrientation();
            return SP_CSS_TEXT_ORIENTATION_MIXED;
        }
 
    inline  SPCSSBaseline _blockBaseline() const
        {
            if(!_input_stream.empty())
                return static_cast<InputStreamTextSource*>(_input_stream.front())->styleGetDominantBaseline();
            return SP_CSS_BASELINE_AUTO;
        }
 
    static bool _directions_are_orthogonal(Direction d1, Direction d2);
 
    void _calculateCursorShapeForEmpty();
 
    struct CursorShape {
        Geom::Point position;
        double height;
        double rotation;
    } _empty_cursor_shape;
 
    // ******************* input shapes
 
    struct InputWrapShape {
        std::unique_ptr<Shape> shape; 
        DisplayAlign display_align;   
    };
    std::vector<InputWrapShape> _input_wrap_shapes;
 
    // ******************* output
 
    Path const *_path_fitted = nullptr;
 
public:
    struct Glyph;
    struct Character;
    struct Span;
    struct Chunk;
    struct Line;
    struct Paragraph;
 
    // A glyph
    struct Glyph {
        unsigned int glyph;
        unsigned in_character;
        bool hidden;
        float x;         
        float y;         
        float rotation;  
        Orientation orientation; 
        float advance;   
        float vertical_scale; 
        inline std::vector<gunichar> const characters(Layout const *l) const {
            auto glyph_index = l->_characters[in_character].in_glyph;
            std::vector<gunichar> ret;
            for (auto i = in_character; i < l->_characters.size() && l->_characters[i].in_glyph == glyph_index; i++) {
                ret.push_back(l->_characters[i].the_char);
            }
            return ret;
        }
        inline Span  const & span (Layout const *l) const {return                      l->_spans[l->_characters[in_character].in_span];}
        inline Chunk const & chunk(Layout const *l) const {return           l->_chunks[l->_spans[l->_characters[in_character].in_span].in_chunk];}
        inline Line  const & line (Layout const *l) const {return l->_lines[l->_chunks[l->_spans[l->_characters[in_character].in_span].in_chunk].in_line];}
 
        // Get the total transformation for this glyph
        Geom::Affine transform(Layout const &layout) const;
    };
 
    // A unicode character
    struct Character {
        unsigned in_span;
        float x;      
        PangoLogAttr char_attributes;
        gunichar the_char = '#';
        int in_glyph;   
        inline Span      const & span     (Layout const *l) const {return                                     l->_spans[in_span];}
        inline Chunk     const & chunk    (Layout const *l) const {return                          l->_chunks[l->_spans[in_span].in_chunk];}
        inline Line      const & line     (Layout const *l) const {return                l->_lines[l->_chunks[l->_spans[in_span].in_chunk].in_line];}
        inline Paragraph const & paragraph(Layout const *l) const {return l->_paragraphs[l->_lines[l->_chunks[l->_spans[in_span].in_chunk].in_line].in_paragraph];}
        // to get the advance width of a character, subtract the x values if it's in the middle of a span, or use span.x_end if it's at the end
    };
 
    // A collection of characters that share the same style and position start (<text> or <tspan> x, y attributes).
    struct Span {
        unsigned in_chunk;
        std::shared_ptr<FontInstance> font;
        float font_size;
        float x_start;   
        float x_end;     
        float y_offset;  
        inline float width() const {return std::abs(x_start - x_end);}
        FontMetrics line_height;
        double baseline_shift;  
        SPCSSTextOrientation text_orientation;
        Direction direction;     
        Direction block_progression;  
        unsigned in_input_stream_item;
        Glib::ustring::const_iterator input_stream_first_character;
        inline Chunk     const & chunk    (Layout const *l) const {return                          l->_chunks[in_chunk];                       }
        inline Line      const & line     (Layout const *l) const {return                l->_lines[l->_chunks[in_chunk].in_line];              }
        inline Paragraph const & paragraph(Layout const *l) const {return l->_paragraphs[l->_lines[l->_chunks[in_chunk].in_line].in_paragraph];}
    };
 
    // A part of a line that is not broken.
    struct Chunk {
        unsigned in_line;
        double left_x;
    };
 
    // A line of text. Depending on the shape, it may contain one or more chunks.
    struct Line {
        unsigned in_paragraph;
        double baseline_y;
        unsigned in_shape;
        bool hidden;
    };
 
    // A paragraph. SVG 2 does not contain native paragraphs.
    struct Paragraph {
        Direction base_direction;    
        Alignment alignment;
    };
 
    std::vector<Layout::Glyph> const &glyphs() const { return _glyphs; }
    std::vector<Layout::Span> const &spans() const { return _spans; }
    std::vector<InputStreamItem *> const &input_stream() const { return _input_stream; }
 
private:
    std::vector<Paragraph> _paragraphs;
    std::vector<Line> _lines;
    std::vector<Chunk> _chunks;
    std::vector<Span> _spans;
    std::vector<Character> _characters;
    std::vector<Glyph> _glyphs;
    std::vector<Geom::LineSegment> _baselines;
 
    inline unsigned _lineToSpan(unsigned line_index) const
    {
        return std::distance(_spans.begin(),
            std::lower_bound(_spans.begin(), _spans.end(), line_index, [this] (auto &span, unsigned index) {
                return _chunks[span.in_chunk].in_line < index;
            })
        );
    }
 
    inline unsigned _lineToCharacter(unsigned line_index) const
    {
        return std::distance(_characters.begin(),
            std::lower_bound(_characters.begin(), _characters.end(), line_index, [this] (auto &character, unsigned index) {
                return _chunks[_spans[character.in_span].in_chunk].in_line < index;
            })
        );
    }
 
    inline unsigned _spanToCharacter(unsigned span_index) const
    {
        return std::distance(_characters.begin(),
            std::lower_bound(_characters.begin(), _characters.end(), span_index, [] (auto &character, unsigned index) {
                return character.in_span < index;
            })
        );
    }
 
    inline unsigned _sourceToCharacter(unsigned source_index) const
    {
        return std::distance(_characters.begin(),
            std::lower_bound(_characters.begin(), _characters.end(), source_index, [this] (auto &character, unsigned index) {
                return _spans[character.in_span].in_input_stream_item < index;
            })
        );
    }
 
    iterator _cursorXOnLineToIterator(unsigned line_index, double local_x, double local_y = 0) const;
 
    double _getChunkWidth(unsigned chunk_index) const;
 
    void _calculateBaselines();
};
 
class Layout::iterator {
public:
    friend class Layout;
    // this is just so you can create uninitialised iterators - don't actually try to use one
    iterator() :
        _parent_layout(nullptr),
        _glyph_index(-1),
        _char_index(0),
        _cursor_moving_vertically(false),
        _x_coordinate(0.0){}
    // no copy constructor required, the default does what we want
    bool operator== (iterator const &other) const
        {return _glyph_index == other._glyph_index && _char_index == other._char_index;}
    bool operator!= (iterator const &other) const
        {return _glyph_index != other._glyph_index || _char_index != other._char_index;}
 
    /* mustn't compare _glyph_index in these operators because for characters
    that don't have glyphs (line breaks, elided soft hyphens, etc), the glyph
    index is -1 which makes them not well-ordered. To be honest, iterating by
    glyphs is not very useful and should be avoided. */
    bool operator< (iterator const &other) const
        {return _char_index < other._char_index;}
    bool operator<= (iterator const &other) const
        {return _char_index <= other._char_index;}
    bool operator> (iterator const &other) const
        {return _char_index > other._char_index;}
    bool operator>= (iterator const &other) const
        {return _char_index >= other._char_index;}
 
    /* **** visual-oriented methods **** */
 
    //glyphs
    inline bool prevGlyph();
    inline bool nextGlyph();
 
    //span
    bool prevStartOfSpan();
    bool thisStartOfSpan();
    bool nextStartOfSpan();
 
    //chunk
    bool prevStartOfChunk();
    bool thisStartOfChunk();
    bool nextStartOfChunk();
 
    //line
    bool prevStartOfLine();
    bool thisStartOfLine();
    bool nextStartOfLine();
    bool thisEndOfLine();
 
    //shape
    bool prevStartOfShape();
    bool thisStartOfShape();
    bool nextStartOfShape();
 
    /* **** text-oriented methods **** */
 
    //characters
    inline bool nextCharacter();
    inline bool prevCharacter();
 
    bool nextCursorPosition();
    bool prevCursorPosition();
    bool nextLineCursor(int n = 1);
    bool prevLineCursor(int n = 1);
 
    //words
    bool nextStartOfWord();
    bool prevStartOfWord();
    bool nextEndOfWord();
    bool prevEndOfWord();
 
    //sentences
    bool nextStartOfSentence();
    bool prevStartOfSentence();
    bool nextEndOfSentence();
    bool prevEndOfSentence();
 
    //paragraphs
    bool prevStartOfParagraph();
    bool thisStartOfParagraph();
    bool nextStartOfParagraph();
    //no endOfPara methods because that's just the previous char
 
    //sources
    bool prevStartOfSource();
    bool thisStartOfSource();
    bool nextStartOfSource();
 
    //logical cursor movement
    bool cursorUp(int n = 1);
    bool cursorDown(int n = 1);
    bool cursorLeft();
    bool cursorRight();
 
    //logical cursor movement (by word or paragraph)
    bool cursorUpWithControl();
    bool cursorDownWithControl();
    bool cursorLeftWithControl();
    bool cursorRightWithControl();
 
private:
    Layout const *_parent_layout;
    int _glyph_index;      
    unsigned _char_index;       
    bool _cursor_moving_vertically;
    double _x_coordinate;
 
    inline iterator(Layout const *p, unsigned c, int g)
        : _parent_layout(p), _glyph_index(g), _char_index(c), _cursor_moving_vertically(false), _x_coordinate(0.0) {}
    inline iterator(Layout const *p, unsigned c)
        : _parent_layout(p), _glyph_index(p->_characters[c].in_glyph), _char_index(c), _cursor_moving_vertically(false), _x_coordinate(0.0) {}
    // no dtor required
    void beginCursorUpDown();  
 
    bool _cursorLeftOrRightLocalX(Direction direction);
 
    bool _cursorLeftOrRightLocalXByWord(Direction direction);
};
 
// ************************** inline methods
 
inline Layout::iterator Layout::begin() const
    {return iterator(this, 0, 0);}
 
inline Layout::iterator Layout::end() const
    {return iterator(this, _characters.size(), _glyphs.size());}
 
inline Layout::iterator Layout::charIndexToIterator(int char_index) const
{
    if (char_index < 0) return begin();
    if (char_index >= (int)_characters.size()) return end();
    return iterator(this, char_index);
}
 
inline int Layout::iteratorToCharIndex(Layout::iterator const &it) const
    {return it._char_index;}
 
inline void Layout::validateIterator(Layout::iterator *it) const
{
    it->_parent_layout = this;
    if (it->_char_index >= _characters.size()) {
        it->_char_index = _characters.size();
        it->_glyph_index = _glyphs.size();
    } else
        it->_glyph_index = _characters[it->_char_index].in_glyph;
}
 
inline Layout::iterator Layout::getNearestCursorPositionTo(Geom::Point const &point) const
    {return getNearestCursorPositionTo(point[0], point[1]);}
 
inline Layout::iterator Layout::getLetterAt(Geom::Point &point) const
    {return getLetterAt(point[0], point[1]);}
 
inline unsigned Layout::lineIndex(iterator const &it) const
    {return it._char_index == _characters.size() ? _lines.size() - 1 : _characters[it._char_index].chunk(this).in_line;}
 
inline unsigned Layout::shapeIndex(iterator const &it) const
    {return it._char_index == _characters.size() ? _input_wrap_shapes.size() - 1 : _characters[it._char_index].line(this).in_shape;}
 
inline bool Layout::isWhitespace(iterator const &it) const
    {return it._char_index == _characters.size() || _characters[it._char_index].char_attributes.is_white;}
 
inline gunichar Layout::characterAt(iterator const &it) const
{
    return _characters[it._char_index].the_char;
}
 
inline bool Layout::isCursorPosition(iterator const &it) const
    {return it._char_index == _characters.size() || _characters[it._char_index].char_attributes.is_cursor_position;}
 
inline bool Layout::isStartOfWord(iterator const &it) const
    {return it._char_index != _characters.size() && _characters[it._char_index].char_attributes.is_word_start;}
 
inline bool Layout::isEndOfWord(iterator const &it) const
    {return it._char_index == _characters.size() || _characters[it._char_index].char_attributes.is_word_end;}
 
inline bool Layout::isStartOfSentence(iterator const &it) const
    {return it._char_index != _characters.size() && _characters[it._char_index].char_attributes.is_sentence_start;}
 
inline bool Layout::isEndOfSentence(iterator const &it) const
    {return it._char_index == _characters.size() || _characters[it._char_index].char_attributes.is_sentence_end;}
 
inline unsigned Layout::paragraphIndex(iterator const &it) const
    {return it._char_index == _characters.size() ? _paragraphs.size() - 1 : _characters[it._char_index].line(this).in_paragraph;}
 
inline Layout::Alignment Layout::paragraphAlignment(iterator const &it) const
    {return (_paragraphs.size() == 0) ? NONE : _paragraphs[paragraphIndex(it)].alignment;}
 
inline bool Layout::iterator::nextGlyph()
{
    _cursor_moving_vertically = false;
    if (_glyph_index >= (int)_parent_layout->_glyphs.size() - 1) {
        if (_glyph_index == (int)_parent_layout->_glyphs.size()) return false;
        _char_index = _parent_layout->_characters.size();
        _glyph_index = _parent_layout->_glyphs.size();
    }
    else _char_index = _parent_layout->_glyphs[++_glyph_index].in_character;
    return true;
}
 
inline bool Layout::iterator::prevGlyph()
{
    _cursor_moving_vertically = false;
    if (_glyph_index == 0) return false;
    _char_index = _parent_layout->_glyphs[--_glyph_index].in_character;
    return true;
}
 
inline bool Layout::iterator::nextCharacter()
{
    _cursor_moving_vertically = false;
    if (_char_index + 1 >= _parent_layout->_characters.size()) {
        if (_char_index == _parent_layout->_characters.size()) return false;
        _char_index = _parent_layout->_characters.size();
        _glyph_index = _parent_layout->_glyphs.size();
    }
    else _glyph_index = _parent_layout->_characters[++_char_index].in_glyph;
    return true;
}
 
inline bool Layout::iterator::prevCharacter()
{
    _cursor_moving_vertically = false;
    if (_char_index == 0) return false;
    _glyph_index = _parent_layout->_characters[--_char_index].in_glyph;
    return true;
}
 
}//namespace Text
}//namespace Inkscape
 
std::ostream &operator<<(std::ostream &out, const Inkscape::Text::Layout::FontMetrics &f);
std::ostream &operator<<(std::ostream &out, const Inkscape::Text::Layout::FontMetrics *f);
 
 
#endif
 
 
/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  indent-tabs-mode:nil
  fill-column:99
  End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :