text.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_TEXT_H
#define EGT_TEXT_H
 
#include <egt/canvas.h>
#include <egt/detail/meta.h>
#include <egt/flags.h>
#include <egt/font.h>
#include <egt/image.h>
#include <egt/slider.h>
#include <egt/textwidget.h>
#include <egt/timer.h>
#include <egt/types.h>
#include <list>
#include <memory>
#include <string>
#include <vector>
 
namespace egt
{
inline namespace v1
{
 
 
class TextRect
{
public:
 
    enum class TextRectFlag : uint32_t
    {
        selected = detail::bit(0),
 
        eonel = detail::bit(1),
 
        bol = detail::bit(2),
    };
 
    using TextRectFlags = egt::Flags<TextRectFlag>;
 
    TextRect(uint32_t behave,
             const Rect& rect,
             std::string text,
             const cairo_text_extents_t& te,
             const TextRectFlags& flags = {}) noexcept
        : m_text(std::move(text)),
          m_rect(rect),
          m_text_rect_flags(flags),
          m_behave(behave),
          m_te(te)
    {}
 
    const std::string& text(void) const { return m_text; }
    const Rect& rect(void) const { return m_rect; }
    void rect(const Rect& r) { m_rect = r; }
    void point(const Point& p) { m_rect.point(p); }
    const TextRectFlags& flags(void) const { return m_text_rect_flags; }
    uint32_t behave(void) const { return m_behave; }
    const cairo_text_extents_t& text_extents(void) const { return m_te; }
    void select(void) { m_text_rect_flags.set(TextRectFlag::selected); }
    void deselect(void) { m_text_rect_flags.clear(TextRectFlag::selected); }
    bool is_selected(void) const { return m_text_rect_flags.is_set(TextRectFlag::selected); }
    bool end_of_non_empty_line(void) const { return m_text_rect_flags.is_set(TextRectFlag::eonel); }
    void mark_beginning_of_line(void) { m_text_rect_flags.set(TextRectFlag::bol); }
    bool beginning_of_line(void) const { return m_text_rect_flags.is_set(TextRectFlag::bol); }
 
    bool can_consolidate(const TextRect& r) const noexcept
    {
        return ((m_text_rect_flags == r.m_text_rect_flags) &&
                (m_rect.y() == r.m_rect.y()) &&
                (m_rect.height() == r.m_rect.height()) &&
                ((m_rect.x() + m_rect.width()) == r.m_rect.x()) &&
                (r.m_text != "\n"));
    }
 
    size_t length(void) const noexcept;
    TextRect& consolidate(const TextRect& r, cairo_t* cr) noexcept;
    TextRect split(size_t pos, cairo_t* cr) noexcept;
 
private:
 
    std::string m_text;
 
    Rect m_rect;
 
    TextRectFlags m_text_rect_flags{};
 
    uint32_t m_behave{0};
 
    cairo_text_extents_t m_te;
};
 
using TextRects = std::list<TextRect>;
 
class EGT_API TextBox : public TextWidget
{
public:
 
    enum class TextFlag : uint32_t
    {
        fit_to_width = detail::bit(0),
 
        multiline = detail::bit(1),
 
        word_wrap = detail::bit(2),
 
        no_virt_keyboard = detail::bit(3),
 
        horizontal_scrollable = detail::bit(4),
 
        vertical_scrollable = detail::bit(5),
    };
 
    using TextFlags = egt::Flags<TextFlag>;
 
    using ValidatorCallback = std::function<bool(const std::string&)>;
 
    static AlignFlags default_text_align();
    static void default_text_align(const AlignFlags& align);
 
    explicit TextBox(const std::string& text = {},
                     const AlignFlags& text_align = default_text_align(),
                     const TextFlags& flags = {}) noexcept;
 
    explicit TextBox(const std::string& text,
                     const TextFlags& flags,
                     const AlignFlags& text_align = default_text_align()) noexcept;
 
    TextBox(const std::string& text,
            const Rect& rect,
            const AlignFlags& text_align = default_text_align(),
            const TextFlags& flags = {}) noexcept;
 
    explicit TextBox(Frame& parent,
                     const std::string& text = {},
                     const AlignFlags& text_align = default_text_align(),
                     const TextFlags& flags = {}) noexcept;
 
    TextBox(Frame& parent,
            const std::string& text,
            const Rect& rect,
            const AlignFlags& text_align = default_text_align(),
            const TextFlags& flags = {}) noexcept;
 
    explicit TextBox(Serializer::Properties& props) noexcept
        : TextBox(props, false)
    {
    }
 
protected:
 
    explicit TextBox(Serializer::Properties& props, bool is_derived) noexcept;
 
public:
 
    TextBox(const TextBox&) = delete;
    TextBox& operator=(const TextBox&) = delete;
    TextBox(TextBox&&) = default;
    TextBox& operator=(TextBox&&) = default;
 
    void handle(Event& event) override;
 
    void draw(Painter& painter, const Rect& rect) override;
 
    void resize(const Size& size) override;
 
    using TextWidget::text;
 
    void text(const std::string& str) override;
 
    void clear() override;
 
    using TextWidget::min_size_hint;
 
    EGT_NODISCARD Size min_size_hint() const override;
 
    void max_length(size_t len);
 
    EGT_NODISCARD size_t max_length() const { return m_max_len;}
 
    void text_flags(const TextFlags& text_flags)
    {
        if (detail::change_if_diff<>(m_text_flags, text_flags))
        {
            resize_sliders();
            damage();
        }
    }
 
    EGT_NODISCARD const TextFlags& text_flags() const { return m_text_flags; }
 
    size_t append(const std::string& str);
 
    size_t insert(const std::string& str);
 
    EGT_NODISCARD size_t cursor() const;
 
    void cursor_begin();
 
    void cursor_end();
 
    void cursor_forward(size_t count = 1);
 
    void cursor_backward(size_t count = 1);
 
    void cursor_set(size_t pos);
 
    void selection_all();
 
    void selection(size_t pos, size_t length);
 
    void selection_forward(size_t count = 1);
 
    void selection_backward(size_t count = 1);
 
    void selection_move(size_t count, bool save_column = true);
 
    EGT_NODISCARD size_t selection_cursor();
 
    EGT_NODISCARD size_t selection_start() const
    {
        return m_select_start;
    }
 
    EGT_NODISCARD size_t selection_length() const
    {
        return m_select_len;
    }
 
    void selection_clear();
 
    EGT_NODISCARD std::string selected_text() const;
 
    void selection_delete();
 
    void input_validation_enabled(bool enabled);
 
    void add_validator_function(ValidatorCallback callback);
 
    EGT_NODISCARD Point text_offset() const;
 
    void text_offset(const Point& p);
 
    void serialize(Serializer& serializer) const override;
 
    ~TextBox() noexcept override;
 
protected:
 
    bool internal_drag() const override { return true; }
 
    EGT_NODISCARD Rect text_boundaries() const;
 
    EGT_NODISCARD Rect text_rect() const;
 
    using TextWidget::text_size;
    EGT_NODISCARD Size text_size() const;
 
    void invalidate_text_rect();
 
    using ValidatorCallbackArray = std::vector<ValidatorCallback>;
 
    void show_cursor();
 
    void continue_show_cursor();
 
    void hide_cursor();
 
    void cursor_set(size_t pos, bool save_column);
 
    void change_cursor(size_t pos, bool save_column = true);
 
    size_t point2pos(const Point& p) const;
 
    size_t beginning_of_line(size_t cursor_pos) const;
 
    size_t beginning_of_line() const { return beginning_of_line(m_cursor_pos); }
 
    size_t end_of_line(size_t cursor_pos) const;
 
    size_t end_of_line() const { return end_of_line(m_cursor_pos); }
 
    size_t up(size_t cursor_pos) const;
 
    size_t up() const { return up(m_cursor_pos); }
 
    size_t down(size_t cursor_pos) const;
 
    size_t down() const { return down(m_cursor_pos); }
 
    virtual void handle_key(const Key& key);
 
    bool validate_input(const std::string& str);
 
    void selection_damage();
 
    cairo_t* context() const { return m_cr; }
 
    void tokenize(TextRects& rects);
 
    void compute_layout(TextRects& rects);
 
    void consolidate(TextRects& rects);
 
    void clear_selection(TextRects& rects);
 
    void set_selection(TextRects& rects);
 
    static void get_line(const TextRects& rects,
                         TextRects::iterator& pos,
                         std::string& line,
                         Rect& rect);
 
    static std::string longest_prefix(const std::string& s1, const std::string& s2);
 
    static std::string longest_suffix(const std::string& s1, const std::string& s2);
 
    void tag_default_aligned_line(TextRects& prev,
                                  TextRects::iterator& prev_pos,
                                  TextRects& next,
                                  TextRects::iterator& next_pos);
 
    void tag_left_aligned_line(TextRects& prev,
                               TextRects::iterator& prev_pos,
                               TextRects& next,
                               TextRects::iterator& next_pos);
 
    void tag_right_aligned_line(TextRects& prev,
                                TextRects::iterator& prev_pos,
                                TextRects& next,
                                TextRects::iterator& next_pos);
 
    void tag_line(TextRects& prev,
                  TextRects::iterator& prev_pos,
                  TextRects& next,
                  TextRects::iterator& next_pos);
 
    void tag_text(TextRects& prev, TextRects& next);
 
    static void get_line_selection(const TextRects& rects,
                                   TextRects::const_iterator& pos,
                                   Rect& rect);
 
    void tag_line_selection(const TextRects& prev,
                            TextRects::const_iterator& prev_pos,
                            const TextRects& next,
                            TextRects::const_iterator& next_pos);
 
    void tag_text_selection(const TextRects& prev, const TextRects& next);
 
    void prepare_text(TextRects& rects);
 
    void get_cursor_rect();
 
    void draw_text(Painter& painter, const Rect& rect);
 
    void refresh_text_area();
 
    EGT_NODISCARD Rect text_area() const;
 
    void init_sliders();
 
    void resize_sliders();
 
    static DefaultDim half_screens(DefaultDim size, DefaultDim screen_size);
 
    void update_hslider();
 
    void update_vslider();
 
    void update_sliders();
 
    void move_hslider();
 
    void move_vslider();
 
    void move_sliders();
 
    void draw_sliders(Painter& painter, const Rect& rect);
 
    void damage_text(const Rect& rect)
    {
        damage(Rect::intersection(rect, text_area()));
    }
 
    void damage_cursor()
    {
        damage(Rect::intersection(m_cursor_rect, box()));
    }
 
    PeriodicTimer m_timer;
 
    size_t m_cursor_pos{0};
 
    size_t m_saved_column{0};
 
    size_t m_select_start{0};
 
    size_t m_select_len{0};
 
    size_t m_select_origin{0};
 
    size_t m_select_drag_start{0};
 
    bool m_validate_input{false};
 
    ValidatorCallbackArray m_validator_callbacks;
 
    Canvas m_canvas;
 
    mutable Rect m_text_rect;
    mutable bool m_text_rect_valid{false};
 
    cairo_t* m_cr{nullptr};
 
    TextRects m_rects;
    Rect m_cursor_rect;
 
    EGT_NODISCARD size_t width_to_len(const std::string& str) const;
 
private:
    class State
    {
    public:
        State() noexcept
        {}
 
        explicit State(const Font* font,
                       const Widget::Flags& flags,
                       const AlignFlags& text_align,
                       const TextFlags& text_flags) noexcept
            : m_font(font),
              m_flags(flags),
              m_text_align(text_align),
              m_text_flags(text_flags)
        {}
 
        State& operator=(const State& rhs) noexcept
        {
            m_font = rhs.m_font;
            m_flags = rhs.m_flags;
            m_text_align = rhs.m_text_align;
            m_text_flags = rhs.m_text_flags;
            return *this;
        }
 
        State& operator=(State&& rhs) noexcept
        {
            m_font = rhs.m_font;
            m_flags = std::move(rhs.m_flags);
            m_text_align = std::move(rhs.m_text_align);
            m_text_flags = std::move(rhs.m_text_flags);
            return *this;
        }
 
        bool operator==(const State& rhs) const noexcept
        {
            return m_font == rhs.m_font &&
                   m_flags == rhs.m_flags &&
                   m_text_align == rhs.m_text_align &&
                   m_text_flags == rhs.m_text_flags;
        }
 
        bool operator!=(const State& rhs) const noexcept
        {
            return !operator==(rhs);
        }
 
    private:
        const Font* m_font{nullptr};
        Widget::Flags m_flags;
        AlignFlags m_text_align;
        TextFlags m_text_flags;
    };
 
    void cursor_timeout();
 
    bool m_cursor_state{false};
 
    TextFlags m_text_flags{};
 
    size_t m_max_len{0};
 
    State m_state;
 
    Slider m_hslider;
 
    Slider m_vslider;
 
    DefaultDim m_slider_dim{8};
 
    Signal<>::RegisterHandle m_gain_focus_reg{};
 
    Signal<>::RegisterHandle m_lost_focus_reg{};
 
    void initialize(bool init_inherited_properties = true);
 
    void deserialize(Serializer::Properties& props);
};
 
namespace detail
{
EGT_API void draw_text(Painter& painter,
                       const Rect& b,
                       const std::string& text,
                       const Font& font,
                       const TextBox::TextFlags& flags,
                       const AlignFlags& text_align,
                       Justification justify,
                       const Pattern& text_color,
                       const std::function<void(const Point& offset, size_t height)>& draw_cursor = nullptr,
                       size_t cursor_pos = 0,
                       const Pattern& highlight_color = {},
                       size_t select_start = 0,
                       size_t select_len = 0);
 
EGT_API void draw_text(Painter& painter,
                       const Rect& b,
                       const std::string& text,
                       const Font& font,
                       const TextBox::TextFlags& flags,
                       const AlignFlags& text_align,
                       Justification justify,
                       const Pattern& text_color,
                       const AlignFlags& image_align,
                       const Image& image,
                       const std::function<void(const Point& offset, size_t height)>& draw_cursor = nullptr,
                       size_t cursor_pos = 0,
                       const Pattern& highlight_color = {},
                       size_t select_start = 0,
                       size_t select_len = 0);
}
 
}
}
 
#endif