shaped_text.hpp

// Copyright Take Vos 2020-2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "attributed_glyph_line.hpp"
#include "gstring.hpp"
#include "../required.hpp"
#include "../alignment.hpp"
#include "../graphic_path.hpp"
#include "../recursive_iterator.hpp"
#include "../geometry/extent.hpp"
#include "../geometry/point.hpp"
#include <string_view>
#include <optional>
 
namespace tt {
class font_book;
 
class shaped_text {
public:
    using iterator = recursive_iterator<std::vector<attributed_glyph_line>::iterator>;
 
    using const_iterator = recursive_iterator<std::vector<attributed_glyph_line>::const_iterator>;
 
    alignment alignment;
    aarectangle boundingBox;
    float width;
 
private:
    std::vector<attributed_glyph_line> lines;
    extent2 _preferred_extent;
 
public:
    shaped_text() noexcept :
        alignment(alignment::middle_center), boundingBox(), width(0.0f), _preferred_extent(), lines() {}
    shaped_text(shaped_text const &other) = default;
    shaped_text(shaped_text &&other) noexcept = default;
    shaped_text &operator=(shaped_text const &other) = default;
    shaped_text &operator=(shaped_text &&other) noexcept = default;
    ~shaped_text() = default;
 
    shaped_text(
        tt::font_book const &font_book,
        std::vector<attributed_grapheme> const &text,
        float width,
        tt::alignment const alignment=alignment::middle_center,
        bool wrap=true
    ) noexcept;
 
    shaped_text(
        tt::font_book const &font_book,
        gstring const &text,
        text_style const &style,
        float width,
        tt::alignment const alignment=alignment::middle_center,
        bool wrap=true
    ) noexcept;
 
    shaped_text(
        tt::font_book const &font_book,
        std::string_view text,
        text_style const &style,
        float width,
        tt::alignment const alignment=alignment::middle_center,
        bool wrap=true
    ) noexcept;
 
    [[nodiscard]] size_t size() const noexcept {
        ssize_t count = 0;
        for (ttlet &line: lines) {
            count += std::ssize(line);
        }
        return narrow_cast<size_t>(count);
    }
 
    [[nodiscard]] extent2 minimum_size() const noexcept
    {
        return _preferred_extent;
    }
 
    [[nodiscard]] extent2 preferred_size() const noexcept
    {
        return _preferred_extent;
    }
 
    [[nodiscard]] extent2 maximum_size() const noexcept
    {
        return _preferred_extent;
    }
 
    [[nodiscard]] iterator begin() noexcept { return recursive_iterator_begin(lines); }
    [[nodiscard]] const_iterator begin() const noexcept { return recursive_iterator_begin(lines); }
    [[nodiscard]] const_iterator cbegin() const noexcept { return recursive_iterator_begin(lines); }
 
    [[nodiscard]] iterator end() noexcept { return recursive_iterator_end(lines); }
    [[nodiscard]] const_iterator end() const noexcept { return recursive_iterator_end(lines); }
    [[nodiscard]] const_iterator cend() const noexcept { return recursive_iterator_end(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 ((std::ssize(lines) % 2) == 1) {
            return lines[std::ssize(lines) / 2].capHeight;
        } else {
            return (lines[std::ssize(lines) / 2 - 1].capHeight + lines[std::ssize(lines) / 2].capHeight) * 0.5f;
        }
    }
 
    float baselineOffset(float height) noexcept {
        if (alignment == vertical_alignment::top) {
            return height - topAccender();
        } else if (alignment == vertical_alignment::bottom) {
            return bottomDescender();
        } else if (alignment == vertical_alignment::middle) {
            return height * 0.5f - middleCapHeight() * 0.5f;
        } else {
            tt_no_default();
        }
    }
 
    float middleOffset(float height) const noexcept {
        if (alignment == vertical_alignment::top) {
            return height - topCapHeight() * 0.5f;
        } else if (alignment == vertical_alignment::bottom) {
            return height - bottomCapHeight() * 0.5f;
        } else if (alignment == vertical_alignment::middle) {
            return height - middleCapHeight() * 0.5f;
        } else {
            tt_no_default();
        }
    }
 
    translate2 translate_base_line(point2 position) noexcept
    {
        return translate2{position.x(), middleOffset(position.y())};
    }
 
    [[nodiscard]] const_iterator find(ssize_t position) const noexcept;
 
    [[nodiscard]] aarectangle rectangleOfgrapheme(ssize_t index) const noexcept;
 
    [[nodiscard]] aarectangle left_to_right_caret(ssize_t index, bool overwrite) const noexcept;
 
    [[nodiscard]] std::vector<aarectangle> selection_rectangles(ssize_t first, ssize_t last) const noexcept;
 
    [[nodiscard]] std::optional<ssize_t> index_of_grapheme_at_coordinate(point2 coordinate) const noexcept;
 
    [[nodiscard]] std::optional<ssize_t> indexOfCharOnTheLeft(ssize_t logical_index) const noexcept;
 
    [[nodiscard]] std::optional<ssize_t> indexOfCharOnTheRight(ssize_t logical_index) const noexcept;
 
    [[nodiscard]] std::pair<ssize_t,ssize_t> indices_of_word(ssize_t logical_index) const noexcept;
 
    [[nodiscard]] std::pair<ssize_t,ssize_t> indices_of_paragraph(ssize_t logical_index) const noexcept;
 
    [[nodiscard]] ssize_t indexAtRightSideOfWord(ssize_t logical_index) const noexcept;
 
    [[nodiscard]] std::optional<ssize_t> indexOfWordOnTheLeft(ssize_t logical_index) const noexcept;
 
    [[nodiscard]] std::optional<ssize_t> indexOfWordOnTheRight(ssize_t logical_index) const noexcept;
 
    [[nodiscard]] graphic_path get_path() const noexcept;
 
 
    [[nodiscard]] int indexFromCoordinate(point2 coordinate) const noexcept;
 
    [[nodiscard]] std::vector<int> indicesFromCoordinates(point2 start, point2 current) const noexcept;
};
 
 
 
}