layouterFont.h

Go to the documentation of this file.

/*
 * STLL Simple Text Layouting Library
 *
 * STLL is the legal property of its developers, whose
 * names are listed in the COPYRIGHT file, which is included
 * within the source distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#ifndef STLL_LAYOUTER_FONT_H
#define STLL_LAYOUTER_FONT_H

#include "internal/layouterFont_internal.h"

#include <boost/utility.hpp>

#include <string>
#include <memory>
#include <map>
#include <vector>

#include <stdint.h>
#include <stdexcept>

struct FT_FaceRec_;
struct FT_LibraryRec_;
struct FT_GlyphSlotRec_;

namespace STLL {

typedef uint32_t glyphIndex_t;


typedef enum
{
  SUBP_NONE,   
  SUBP_RGB,    
  SUBP_BGR,    
  SUBP_RGB_V,  
  SUBP_BGR_V   
} SubPixelArrangement;

class FreetypeException_c : public std::runtime_error
{
  public:
    explicit FreetypeException_c(const std::string & what_arg) : std::runtime_error(what_arg) {}
};

class FreeTypeLibrary_c;

class FontResource_c
{
  private:
    std::vector<internal::FontFileResource_c> resources;

  public:
    template <typename... Args>
    FontResource_c(Args... par) { addFont(par...); }

    void addFont(const std::string & pathname)
    {
      resources.emplace_back(internal::FontFileResource_c(pathname));
    };

    void addFont(std::pair<std::shared_ptr<uint8_t>, size_t> data, const std::string & descr)
    {
      resources.emplace_back(internal::FontFileResource_c(data.first, data.second, descr));
    }

    size_t size(void) const { return resources.size(); }

    auto begin(void) const { return resources.begin(); }
    auto end(void) const { return resources.end(); }

    FontResource_c(void) {}

    internal::FontFileResource_c getRessource(size_t idx) const { return resources[idx]; }

    bool operator<(const FontResource_c & b) const
    {
      return std::lexicographical_compare(resources.begin(), resources.end(), b.resources.begin(), b.resources.end());
    }
};

class FontFace_c : boost::noncopyable
{
  public:

    class GlyphSlot_c
    {
      public:
        int w, h;
        int top, left;
        int pitch;
        const uint8_t * data;

        GlyphSlot_c(const FT_GlyphSlotRec_ * g);
        GlyphSlot_c(int width, int height) : w(width), h(height), top(0), left(0), pitch(0), data(0) {}
    };

    FontFace_c(std::shared_ptr<FreeTypeLibrary_c> l, const internal::FontFileResource_c & r, uint32_t size);
    ~FontFace_c();

    FT_FaceRec_ * getFace(void) const { return f; }

    uint32_t getSize(void) const { return size; }

    const internal::FontFileResource_c & getResource(void) const { return rec; }

    uint32_t getHeight(void) const;

    int32_t getAscender(void) const;

    int32_t getDescender(void) const;

    int32_t getUnderlinePosition(void) const;

    int32_t getUnderlineThickness(void) const;
    GlyphSlot_c renderGlyph(glyphIndex_t glyphIndex, SubPixelArrangement sp);

    bool containsGlyph(char32_t ch);

  private:
    FT_FaceRec_ *f;
    std::shared_ptr<FreeTypeLibrary_c> lib;
    internal::FontFileResource_c rec;
    uint32_t size;
};

class Font_c
{
  public:

    Font_c(void) {}

    void add(std::shared_ptr<FontFace_c> f) { fonts.emplace_back(std::move(f)); }

    auto begin(void) const { return fonts.begin(); }
    auto end(void) const { return fonts.end(); }

    std::shared_ptr<FontFace_c> get(char32_t codepoint) const;

    // some functions that get metrics of this font, they are always taken from the
    // first font face in the font
    uint32_t getHeight(void) const { return fonts[0]->getHeight(); }
    int32_t getAscender(void) const { return fonts[0]->getAscender(); }
    int32_t getDescender(void) const { return fonts[0]->getDescender(); }
    int32_t getUnderlinePosition(void) const { return fonts[0]->getUnderlinePosition(); }
    int32_t getUnderlineThickness(void) const { return fonts[0]->getUnderlineThickness(); }

    explicit operator bool() const { return fonts.size() > 0; }

    bool operator==(const Font_c & rhs) const { return std::equal(fonts.begin(), fonts.end(), rhs.fonts.begin(), rhs.fonts.end()); }

  private:
    std::vector<std::shared_ptr<FontFace_c>> fonts;
};

class FreeTypeLibrary_c : boost::noncopyable
{
  public:

    FreeTypeLibrary_c();
    ~FreeTypeLibrary_c();

    FT_FaceRec_ * newFace(const internal::FontFileResource_c & r, uint32_t size);

    void doneFace(FT_FaceRec_ * f);

  private:

    FT_LibraryRec_ *lib;
};

class FontCache_c
{
  public:

    FontCache_c(std::shared_ptr<FreeTypeLibrary_c> l) : lib(l) {}

    FontCache_c(void) : lib(std::make_shared<FreeTypeLibrary_c>()) {}

    Font_c getFont(const FontResource_c & res, uint32_t size);

    std::shared_ptr<FontFace_c> getFont(const internal::FontFileResource_c & res, uint32_t size);

    void clear(void)
    {
      for(auto it = fonts.begin(); it != fonts.end(); )
      {
        if(it->second.use_count() == 1)
        {
          it = fonts.erase(it);
        }
        else
        {
          ++it;
        }
      }
    }

  private:

    class FontFaceParameter_c
    {
      public:
        internal::FontFileResource_c res;
        uint32_t size;

        FontFaceParameter_c(const internal::FontFileResource_c r, uint32_t s) : res(std::move(r)), size(s) {}

        bool operator<(const FontFaceParameter_c & b) const
        {
          if (res < b.res) return true;
          if (b.res < res) return false;

          if (size < b.size) return true;
          return false;
        }
    };

    // all open fonts, used to check whether they have all been released
    // on library destruction
    std::map<FontFaceParameter_c, std::shared_ptr<FontFace_c> > fonts;

    // the library to use
    std::shared_ptr<FreeTypeLibrary_c> lib;
};

class FontFamily_c
{
  private:

    // a class containing all the variables for a
    // font inside a family, it is used as the key inside the map
    // for all font files
    class FontFamilyParameter_c
    {
      public:
        std::string style;
        std::string variant;
        std::string weight;
        std::string stretch;

        bool operator<(const FontFamilyParameter_c & b) const
        {
          if (style < b.style) return true;
          if (style > b.style) return false;
          if (variant < b.variant) return true;
          if (variant > b.variant) return false;
          if (weight < b.weight) return true;
          if (weight > b.weight) return false;
          if (stretch < b.stretch) return true;
          return false;
        }
    };

  public:

    FontFamily_c(std::shared_ptr<FontCache_c> c) : cache(c) {}

    FontFamily_c(void) : cache(std::make_shared<FontCache_c>()) {}

    Font_c getFont(uint32_t size,
                   const std::string & style = "normal",
                   const std::string & variant = "normal",
                   const std::string & weight = "normal",
                   const std::string & stretch = "normal");

    void addFont(const FontResource_c & res,
                 const std::string & style = "normal",
                 const std::string & variant = "normal",
                 const std::string & weight = "normal",
                 const std::string & stretch = "normal");

  private:
    std::map<FontFamilyParameter_c, FontResource_c> fonts;
    std::shared_ptr<FontCache_c> cache;
};


}

#endif