font.hpp

#ifndef FONT_CHEF_FONT_HPP
#define FONT_CHEF_FONT_HPP
 
#include "font-chef/font-chef-export.h"
#include "font-chef/font.h"
#include <cstring>
 
#include <string>
#include <vector>
 
#include "font-chef/font-size.hpp"
#include "font-chef/color.hpp"
#include "font-chef/render-result.hpp"
 
namespace fc {
  class FONT_CHEF_EXPORT font {
    private:
      fc_font * data;
 
    public:
      font(font && other) noexcept : data(other.data) {
        other.data = nullptr;
      };
 
      font(font const & other)
      : data(fc_construct(
          fc_get_font_data(other.data),
          fc_get_font_size(other.data),
          fc_get_color(other.data))
      ) {
        size_t block_count = fc_get_block_count(other.data);
        for (size_t i = 0; i < block_count; i++) add(fc_get_block_at(other.data, i));
        if (fc_get_pixels(other.data) != nullptr) cook();
      }
 
      font(uint8_t const * font_data, fc::font_size const & font_size, fc::color const & font_color)
        : data(fc_construct(font_data, font_size.data, font_color.data)) { };
 
      ~font() {
        if (data) fc_destruct(data);
      }
 
      font & add(fc_unicode_block const & block) & {
        return add(block.first, block.last);
      }
 
 
      font && add(fc_unicode_block const & block) && {
        return std::move(add(block.first, block.last));
      }
 
      font & add(uint32_t first, uint32_t last) & {
        fc_add(data, first, last);
        return *this;
      }
 
 
      font && add(uint32_t first, uint32_t last) && {
        fc_add(data, first, last);
        return std::move(*this);
      }
 
      font & cook() & {
        fc_cook(data);
        return *this;
      }
 
 
      font && cook() && {
        fc_cook(data);
        return std::move(*this);
      }
 
      fc_pixels pixels() const {
        return *fc_get_pixels(data);
      }
 
      fc::render_result render(std::string const & text) const {
        fc::render_result result(data);
        return std::move(render(text, result));
      }
 
      fc::render_result & render(std::string const & text, fc::render_result & result) const {
        result.font = data;
        std::vector<fc_character_mapping> & mapping = result.mapping;
        if (mapping.size() < text.length()) mapping.resize(text.length());
        struct fc_render_result r = fc_render(data, (uint8_t *) text.data(), text.size(), mapping.data());
        mapping.resize(r.glyph_count);
        result.line_count = r.line_count;
        return result;
      }
  };
 
  FONT_CHEF_EXPORT font from(uint8_t const * font_data, fc::font_size const & font_size, fc::color const & font_color) {
    font r(font_data, font_size, font_color);
    return r;
  }
}
 
#endif //FONT_CHEF_FONT_HPP