font.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_FONT_H
#define EGT_FONT_H
 
#include <egt/detail/math.h>
#include <egt/geometry.h>
#include <egt/serialize.h>
#include <egt/types.h>
#include <iosfwd>
#include <map>
#include <string>
 
namespace egt
{
inline namespace v1
{
 
namespace detail
{
class InternalFont;
}
 
class EGT_API Font
{
public:
 
    using Extent = float;
 
    struct FontExtents
    {
        Extent ascent;
        Extent descent;
        Extent height;
        Extent max_x_advance;
        Extent max_y_advance;
    };
 
    struct TextExtents
    {
        Extent x_bearing;
        Extent y_bearing;
        Extent width;
        Extent height;
        Extent x_advance;
        Extent y_advance;
    };
 
    using Size = float;
 
    enum class Weight
    {
        normal = 0,
        bold = 1,
    };
 
    enum class Slant
    {
        normal = 0,
        italic = 1,
        oblique = 2,
    };
 
    static constexpr const char* DEFAULT_FACE = "Free Sans";
    static constexpr Font::Weight DEFAULT_WEIGHT = Font::Weight::normal;
    static constexpr Font::Size DEFAULT_SIZE = 18.f;
    static constexpr Font::Slant DEFAULT_SLANT = Font::Slant::normal;
 
    Font();
 
    explicit Font(const std::string& face);
 
    explicit Font(const unsigned char* data, size_t len,
                  Font::Size size);
 
    explicit Font(const std::string& face, Font::Size size,
                  Font::Weight weight = Weight::normal,
                  Font::Slant slant = Slant::normal);
 
    explicit Font(Font::Size size);
 
    explicit Font(Font::Size size, Font::Weight weight);
 
    explicit Font(Font::Weight weight);
 
    explicit Font(Font::Slant slant);
 
    EGT_NODISCARD const std::string& face() const { return m_face; }
 
    void face(const std::string& face) { m_face = face; direct_allocate(); }
 
    EGT_NODISCARD Font::Size size() const { return m_size; }
 
    void size(const Font::Size& s) { m_use_default_size = false; m_size = s; direct_allocate(); }
 
    EGT_NODISCARD Font::Weight weight() const { return m_weight; }
 
    void weight(Font::Weight w) { m_weight = w; direct_allocate(); }
 
    EGT_NODISCARD Font::Slant slant() const { return m_slant; }
 
    void slant(Font::Slant s) { m_slant = s; }
 
    EGT_NODISCARD Font::FontExtents extents() const;
 
    EGT_NODISCARD Font::TextExtents extents(const std::string& text) const;
 
    EGT_NODISCARD egt::Size text_size(const std::string& text) const;
 
    EGT_NODISCARD const detail::InternalFont& scaled_font() const;
 
    void serialize(const std::string& name, Serializer& serializer) const;
 
    void deserialize(const std::string& name, const std::string& value,
                     const Serializer::Attributes& attrs);
 
    void on_screen_resized();
 
    static void reset_font_cache();
 
    static void shutdown_fonts();
 
protected:
 
    void direct_allocate();
 
    std::string m_face{DEFAULT_FACE};
 
    Font::Size m_size;
 
    Font::Weight m_weight{DEFAULT_WEIGHT};
 
    Font::Slant m_slant{DEFAULT_SLANT};
 
    mutable std::shared_ptr<detail::InternalFont> m_scaled_font;
    const unsigned char* m_data{nullptr};
    size_t m_len{0};
 
    bool m_use_default_size{true};
 
private:
    Font::Size default_font_size();
};
 
static_assert(detail::rule_of_5<Font>(), "must fulfill rule of 5");
 
EGT_API std::ostream& operator<<(std::ostream& os, const Font& font);
 
inline bool EGT_API operator==(const Font& lhs, const Font& rhs)
{
    return lhs.face() == rhs.face() &&
           detail::float_equal(lhs.size(), rhs.size()) &&
           lhs.weight() == rhs.weight() &&
           lhs.slant() == rhs.slant();
}
 
inline bool EGT_API operator!=(const Font& lhs, const Font& rhs)
{
    return !(lhs == rhs);
}
 
EGT_API const Font* global_font();
 
EGT_API void global_font(std::unique_ptr<Font>&& font);
 
EGT_API void reset_global_font();
 
}
}
 
#endif