ShapedText.hpp

// Copyright 2020 Pokitec
// All rights reserved.
 
#pragma once
 
#include "TTauri/Text/AttributedGlyphLine.hpp"
#include "TTauri/Text/gstring.hpp"
#include "TTauri/Foundation/required.hpp"
#include "TTauri/Foundation/attributes.hpp"
#include "TTauri/Foundation/Path.hpp"
#include "TTauri/Foundation/vec.hpp"
#include "TTauri/Foundation/nested_vector_iterator.hpp"
#include <string_view>
#include <optional>
 
namespace tt {
 
 
class ShapedText {
public:
    using iterator = nested_vector_iterator<
        std::vector<AttributedGlyphLine>::const_iterator,
        std::vector<AttributedGlyphLine>::iterator,
        AttributedGlyphLine::iterator>;
 
    using const_iterator = nested_vector_iterator<
        std::vector<AttributedGlyphLine>::const_iterator,
        std::vector<AttributedGlyphLine>::const_iterator,
        AttributedGlyphLine::const_iterator>;
 
    Alignment alignment;
    aarect boundingBox;
    float width;
    vec preferredExtent;
 
private:
    std::vector<AttributedGlyphLine> lines;
 
public:
    ShapedText() noexcept :
        alignment(Alignment::MiddleCenter), boundingBox(), width(0.0f), preferredExtent(), lines() {}
    ShapedText(ShapedText const &other) = default;
    ShapedText(ShapedText &&other) noexcept = default;
    ShapedText &operator=(ShapedText const &other) = default;
    ShapedText &operator=(ShapedText &&other) noexcept = default;
    ~ShapedText() = default;
 
    ShapedText(
        std::vector<AttributedGrapheme> const &text,
        float width,
        Alignment const alignment=Alignment::MiddleCenter,
        bool wrap=true
    ) noexcept;
 
    ShapedText(
        gstring const &text,
        TextStyle const &style,
        float width,
        Alignment const alignment=Alignment::MiddleCenter,
        bool wrap=true
    ) noexcept;
 
    ShapedText(
        std::string_view text,
        TextStyle const &style,
        float width,
        Alignment const alignment=Alignment::MiddleCenter,
        bool wrap=true
    ) noexcept;
 
    [[nodiscard]] size_t size() const noexcept {
        ssize_t count = 0;
        for (ttlet &line: lines) {
            count += ssize(line);
        }
        return numeric_cast<size_t>(count);
    }
 
    [[nodiscard]] iterator begin() noexcept { return nested_vector_iterator_begin(lines); }
    [[nodiscard]] const_iterator begin() const noexcept { return nested_vector_iterator_cbegin(lines); }
    [[nodiscard]] const_iterator cbegin() const noexcept { return nested_vector_iterator_cbegin(lines); }
 
    [[nodiscard]] iterator end() noexcept { return nested_vector_iterator_end(lines); }
    [[nodiscard]] const_iterator end() const noexcept { return nested_vector_iterator_cend(lines); }
    [[nodiscard]] const_iterator cend() const noexcept { return nested_vector_iterator_cend(lines); }
 
    float topAccender() const noexcept {
        return lines.front().ascender;
    }
 
    float bottomDescender() const noexcept {
        return lines.back().descender;
    }
 
    float topCapHeight() const noexcept {
        return lines.front().capHeight;
    }
 
    float bottomCapHeight() const noexcept {
        return lines.back().capHeight;
    }
 
    float middleCapHeight() const noexcept {
        if ((ssize(lines) % 2) == 1) {
            return lines[ssize(lines) / 2].capHeight;
        } else {
            return (lines[ssize(lines) / 2 - 1].capHeight + lines[ssize(lines) / 2].capHeight) * 0.5f;
        }
    }
 
    float baselineOffset(float height) noexcept {
        if (alignment == VerticalAlignment::Top) {
            return height - topAccender();
        } else if (alignment == VerticalAlignment::Bottom) {
            return bottomDescender();
        } else if (alignment == VerticalAlignment::Middle) {
            return height * 0.5f - middleCapHeight() * 0.5f;
        } else {
            tt_no_default;
        }
    }
 
    float middleOffset(float height) const noexcept {
        if (alignment == VerticalAlignment::Top) {
            return height - topCapHeight() * 0.5f;
        } else if (alignment == VerticalAlignment::Bottom) {
            return height - bottomCapHeight() * 0.5f;
        } else if (alignment == VerticalAlignment::Middle) {
            return height - middleCapHeight() * 0.5f;
        } else {
            tt_no_default;
        }
    }
 
    mat::T2 T(aarect rectangle) noexcept {
        return {
            rectangle.x(),
            rectangle.y() + baselineOffset(rectangle.height())
        };
    }
 
    mat::T2 TMiddle(vec position) noexcept {
        return {
            position.x(),
            middleOffset(position.y())
        };
    }
 
 
    [[nodiscard]] const_iterator find(ssize_t position) const noexcept;
 
    [[nodiscard]] aarect rectangleOfGrapheme(ssize_t index) const noexcept;
 
    [[nodiscard]] aarect leftToRightCaret(ssize_t index, bool overwrite) const noexcept;
 
    [[nodiscard]] std::vector<aarect> selectionRectangles(ssize_t first, ssize_t last) const noexcept;
 
    [[nodiscard]] std::optional<ssize_t> indexOfCharAtCoordinate(vec coordinate) const noexcept;
 
    [[nodiscard]] std::optional<ssize_t> indexOfCharOnTheLeft(ssize_t logicalIndex) const noexcept;
 
    [[nodiscard]] std::optional<ssize_t> indexOfCharOnTheRight(ssize_t logicalIndex) const noexcept;
 
    [[nodiscard]] std::pair<ssize_t,ssize_t> indicesOfWord(ssize_t logicalIndex) const noexcept;
 
    [[nodiscard]] std::pair<ssize_t,ssize_t> indicesOfParagraph(ssize_t logicalIndex) const noexcept;
 
    [[nodiscard]] ssize_t indexAtRightSideOfWord(ssize_t logicalIndex) const noexcept;
 
    [[nodiscard]] std::optional<ssize_t> indexOfWordOnTheLeft(ssize_t logicalIndex) const noexcept;
 
    [[nodiscard]] std::optional<ssize_t> indexOfWordOnTheRight(ssize_t logicalIndex) const noexcept;
 
    [[nodiscard]] Path get_path() const noexcept;
 
 
    [[nodiscard]] int indexFromCoordinate(vec coordinate) const noexcept;
 
    [[nodiscard]] std::vector<int> indicesFromCoordinates(vec start, vec current) const noexcept;
};
 
 
 
}