Font.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: Font
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/File.h>
#include <NDEVR/RGBColor.h>
#include <NDEVR/Dictionary.h>
namespace NDEVR
{
    class UUID;

    class Font
    {
    public:
 
        String app_font_name; 
        fltp08 point_size = Constant<fltp08>::Invalid; 
        fltp08 pixel_size = Constant<fltp08>::Invalid; 
        fltp08 fixed_width = Constant<fltp08>::Invalid; 
        fltp08 tab_advance = Constant<fltp08>::Invalid; 
        uint04 index = 0; 
        RGBColor color = Constant<RGBColor>::Invalid; 
 
        bool is_underline = false; 
        bool is_overstrike = false; 
        bool is_strikethrough = false; 

        StringView name() const { return m_name; };

        bool isBold() const { return m_is_bold; };

        bool isItalic() const { return m_is_italic; };

        void setHasBoldFamily(bool has_bold_family) { m_has_bold_family = has_bold_family; }

        void setHasItalicFamily(bool has_italic_family) { m_has_italic_family = has_italic_family; }

        NDEVR_BASE_API bool hasItalicFamily() const;

        NDEVR_BASE_API bool hasBoldFamily() const;

        NDEVR_BASE_API void setName(const StringView& name);

        NDEVR_BASE_API void setIsBold(bool is_bold);

        NDEVR_BASE_API void setIsItalic(bool is_italic);

        NDEVR_BASE_API bool operator==(const Font& font) const;

        NDEVR_BASE_API bool operator!=(const Font& font) const;

        const File& file() const { return m_file; };

        NDEVR_BASE_API bool findBestFileIfNeeded(bool allow_backup_file = true);

        void setFile(const File& file) { m_file = file; }

        NDEVR_BASE_API bool executeAnsiiCode(uint04 ansii_code, const Font& default_font);
    protected:
        String m_name; 
        bool m_is_bold = false; 
        bool m_is_italic = false; 
        bool m_has_bold_family = false; 
        bool m_has_italic_family = false; 
        mutable File m_file; 
        mutable std::function<Font(wchar_t character)> m_fallback_font; 
    };

    class FontEngine
    {
    public:
        static constexpr StringView DefaultFont = "Default"; 

        NDEVR_BASE_API static void SetApplicationFont(const StringView& app_font, const Font& font);

        NDEVR_BASE_API static const Font& ApplicationFont(const StringView& app_font);

        NDEVR_BASE_API static bool HasApplicationFont(const StringView& app_font);

        NDEVR_BASE_API static File FindBestFitFontFile(Font& font, bool allow_backup_file = true);

        NDEVR_BASE_API static void PullFontFromFolder(const File& folder);

        NDEVR_BASE_API static bool HasFontFile(const StringView& font_name);

        NDEVR_BASE_API static void SetFontFile(const StringView& font_name, const File& file, uint04 index = 0);

        NDEVR_BASE_API static void SetSettingsFile(const File& file);

        NDEVR_BASE_API static void SaveFontSettings();

        NDEVR_BASE_API static void ReadFontSettings();

        NDEVR_BASE_API static void AddFontListener(const StringView& app_font, UUID id, std::function<void(const StringView&)> callback);

        NDEVR_BASE_API static void RemoveFontListener(const StringView& app_font, UUID id);

        NDEVR_BASE_API static Font FindFallbackFont(Font original, wchar_t character);
    protected:
        NDEVR_BASE_API static File TryFontName(const StringView& family);
    protected:
        NDEVR_BASE_API static Dictionary<String, Font> s_system_fonts; 
        NDEVR_BASE_API static Dictionary<String, Font> s_application_fonts; 
        NDEVR_BASE_API static Dictionary<String, String> s_font_files; 
        NDEVR_BASE_API static Dictionary<String, uint04> s_font_indices; 
        NDEVR_BASE_API static Dictionary<String, Dictionary<UUID, std::function<void(const StringView&)>>> s_app_font_listener; 
        NDEVR_BASE_API static File s_settings_file; 
    };

    struct TextBlock
    {
        StringAllocatingView text; 
        Font font; 
        uint01 alignment = Constant<uint01>::Invalid; 

        bool operator==(const TextBlock& block) const
        {
            return text == block.text && font == block.font && alignment == block.alignment;
        }

        bool operator!=(const TextBlock& block) const
        {
            return text != block.text || font != block.font || alignment != block.alignment;
        }
    };

    enum class TextAlignment
    {
          e_left = 0x01 
        , e_right = 0x02 
        , e_top = 0x04 
        , e_bottom = 0x08 
        , e_bottom_base = 0x10 
        , e_h_center = e_left | e_right 
        , e_v_center = e_top | e_bottom 
        , e_v_baseline_center = e_top | e_bottom_base 
        , e_center = e_v_center | e_h_center 
    };

    inline uint01 operator|(const TextAlignment& a, const TextAlignment& b)
    {
        return cast<uint01>(a) | cast<uint01>(b);
    }
}