freegil.hpp

Go to the documentation of this file.

// Copyright Tom Brinkman 2008. Distributed under the Boost
// Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef _freegil_hpp_
#define _freegil_hpp_

#include <boost/gil/gil_all.hpp>
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_GLYPH_H
#include FT_CACHE_H

#include <blend.hpp>

namespace layer
{

struct glyph
{
        glyph(char ch, FT_Face face, boost::gil::rgb8_pixel_t pixel) :
                ch(ch), face(face), pixel(pixel){}

        char ch;
        FT_Face face;
        boost::gil::rgb8_pixel_t pixel;
};

struct make_metric
{
        FT_Glyph_Metrics operator()(glyph& glyph)
        {
                BOOST_ASSERT(glyph.face);
                int load_flags = FT_LOAD_DEFAULT;
                int index = FT_Get_Char_Index(glyph.face,glyph.ch);
                FT_Load_Glyph(glyph.face, index, load_flags);
                return glyph.face->glyph->metrics;
        }
};

struct make_width
{
        int advance;
        int lasbwidth;
        int lastadvance;
        make_width() : advance(0), lasbwidth(0), lastadvance(0) {}
        operator int(){return advance-(lastadvance-lasbwidth);}
        void operator()(FT_Glyph_Metrics metrics)
        {
                lastadvance = metrics.horiAdvance >> 6; 
                lasbwidth = (metrics.width >> 6);
                advance += lastadvance;
        }
};

struct make_advance_width
{
        int advance;
        make_advance_width() : advance(0){}
        operator int(){return advance;}
        void operator()(FT_Glyph_Metrics metrics)
        {
                advance += metrics.horiAdvance >> 6;
        }
};

struct make_advance_height
{
        int height;
        make_advance_height() : height(0){}
        operator int(){return height;}
        void operator()(FT_Glyph_Metrics metrics)
        {
                int advance = (metrics.vertAdvance >> 6);
                height = (std::max)(height,advance);
        }
};

struct make_height
{
        int height;
        make_height() : height(0){}
        operator int(){return height;}
        void operator()(FT_Glyph_Metrics metrics)
        {
                int h = (metrics.height >> 6);
                height = (std::max)(height,h);
        }
};

struct make_glyph_height
{
        int height;
        make_glyph_height() : height(0) {} 
        operator int(){return height;}
        void operator()(FT_Glyph_Metrics metrics)
        {
                int n = (metrics.height >> 6) -(metrics.horiBearingY >> 6);
                height = (std::max)(height,n);
        }
};

struct find_last_fitted_glyph
{
        int width,x;
        find_last_fitted_glyph(int width) : width(width),x(0){}
        bool operator()(FT_Glyph_Metrics metric)
        {
                int tmp = x + (metric.width >> 6);
                x += (metric.horiAdvance >> 6); 
                return tmp > width;
        }
};

template <typename view_t>
struct render_glyphs
{
        int x;
        const view_t& view;
        render_glyphs(const view_t& view) : view(view), x(0) {} 

        void operator()(glyph& glyph)
        {
                using namespace boost::gil;
                
                FT_GlyphSlot glyphslot = glyph.face->glyph; 
                FT_Face face = glyph.face;                      

                int load_flags = FT_LOAD_DEFAULT;
                int index = FT_Get_Char_Index(face,glyph.ch);
                FT_Load_Glyph(face, index, load_flags);
                FT_Render_Glyph(glyphslot, FT_RENDER_MODE_NORMAL);

                int y = view.height() - (face->glyph->metrics.horiBearingY >> 6);
                int width = face->glyph->metrics.width >> 6;
                int height = face->glyph->metrics.height >> 6;
                int xadvance = face->glyph->advance.x >> 6;

                BOOST_ASSERT(view.width());
                BOOST_ASSERT(width == glyphslot->bitmap.width);
                BOOST_ASSERT(height == glyphslot->bitmap.rows);

                gray8c_view_t gray = interleaved_view(width,height,
                        (gray8_pixel_t*)glyphslot->bitmap.buffer,glyphslot->bitmap.width);

                copy<alpha24_blend>(glyph.pixel,gray,subimage_view(view,x,y,width,height));
                x += xadvance; 
        }
};

static inline FT_Error face_requester(FTC_FaceID id, FT_Library library, void* data, FT_Face* face)
{
        char** paths = (char**)data;
        char* path = paths[(long)id]; 
        return FT_New_Face(library, path, 0, face);
}

template <typename view_t>
struct text
{
        enum 
        { 
                left = (0x1 << 0),
                center = (0x1 << 1),
                right = (0x1 << 2),
                top = (0x1 << 3),
                ftop = (0x1 << 4),
                middle = (0x1 << 5),  //when text is aligned adjacent to each other.
                fmiddle = (0x1 << 6), //when the text is all by itself
                bottom = (0x1 << 7),
        }; 

        enum
        {
                fill = (0x1 << 0),
                clipspecial = (0x1 << 1),
                fillexcess =  (0x1 << 2),
        };

        typedef typename view_t::value_type color_t;

        FTC_Manager manager;
        std::string str;
        int id;
        int size;
        int align;
        int options;
        char special;
        color_t color;
        std::vector<glyph> glyphs;

        text(FTC_Manager manager, std::string str, color_t color, 
                int id, int size, int align = center|middle, int options = 0, char special = '#') : 
                        manager(manager), str(str), id(id), size(size), align(align), 
                                color(color), options(options), special(special){}

        text(FTC_Manager manager, color_t color, 
                int id, int size, int align = center|middle, int options = 0, char special = '.') : 
                        manager(manager), id(id), size(size), align(align), 
                                color(color), options(options), special(special){}

        void operator()(view_t& view)
        {
                FTC_ScalerRec_ scaler;
                scaler.face_id = (FTC_FaceID)id;
                scaler.width = size;
                scaler.height = size;
                scaler.pixel = 1;
                scaler.x_res = 0;
                scaler.y_res = 0;
                
                FT_Size asize;
                FT_Error error = FTC_Manager_LookupSize(manager, &scaler, &asize);
                if (error)
                        return;
                
                for (int n = 0; n < str.size(); ++n)
                        glyphs.push_back(glyph(str[n],asize->face,color));

                std::vector<FT_Glyph_Metrics> m;                        
                std::transform(glyphs.begin(),glyphs.end(), std::back_inserter(m), make_metric());              

                int mwidth = std::for_each(m.begin(), m.end(), make_width());

                if (options & fill || (options & fillexcess && mwidth > view.width()))
                {
                        glyphs.clear();
                        for (int n = 0; n < 500; ++n)
                                glyphs.push_back(glyph(special,asize->face,color));

                        m.clear();                      
                        std::transform(glyphs.begin(),glyphs.end(),
                                std::back_inserter(m), make_metric());
                }

                if (options & clipspecial)
                {
                        int pos = -1;
                        for (pos = 0; pos < glyphs.size(); ++pos)
                                if (glyphs[pos].ch == special)
                                        break;
                
                        if (pos >= 1 && pos < glyphs.size())
                        {
                                std::vector<glyph> front,back;
                                std::copy(glyphs.begin(), glyphs.begin()+pos, std::back_inserter(front));
                                std::copy(glyphs.begin()+pos, glyphs.end(), std::back_inserter(back));
                                glyphs.clear();
                
                                while (true)
                                {
                                        std::vector<glyph> glyphs2;
                                        std::copy(front.begin(),front.end(), std::back_inserter(glyphs2));      
                                        std::copy(back.begin(),back.end(), std::back_inserter(glyphs2));        
                
                                        std::vector<FT_Glyph_Metrics> metrics;          
                                        std::transform(glyphs2.begin(),glyphs2.end(),
                                                std::back_inserter(metrics), make_metric());
                
                                        std::vector<FT_Glyph_Metrics>::iterator it = 
                                                std::find_if(metrics.begin(),metrics.end(),
                                                        find_last_fitted_glyph(view.width()));

                                        if (it != metrics.end())
                                                front.pop_back();
                                        else
                                                break;
                                }
                
                                std::copy(front.begin(), front.end(), std::back_inserter(glyphs));
                                std::copy(back.begin(), back.end(), std::back_inserter(glyphs));
                        }
                }

                m.clear();              
                std::transform(glyphs.begin(),glyphs.end(), std::back_inserter(m), make_metric());

                std::vector<FT_Glyph_Metrics>::iterator it = 
                        std::find_if(m.begin(), m.end(), find_last_fitted_glyph(view.width()));
                int distance = (int)std::distance(it,m.end());
                glyphs.erase(glyphs.end()-distance,glyphs.end());
                
                m.clear();              
                std::transform(glyphs.begin(),glyphs.end(), std::back_inserter(m), make_metric());

                mwidth = std::for_each(m.begin(), m.end(), make_width());
                int mheight = std::for_each(m.begin(), m.end(), make_height());
                int gheight = std::for_each(m.begin(), m.end(), make_glyph_height());

                int x = 0;
                if (align & center)
                        x = (view.width()-mwidth)/2;
                else if (align & right)
                        x = view.width()-mwidth;
        
                int y = 0;
                if (align & middle)
                        y = (view.height()-mheight-gheight)/2;
                else if (align & fmiddle)
                        y = (view.height()-mheight)/2;
                else if (align & bottom)
                        y = view.height()-mheight;

                BOOST_ASSERT(!glyphs.empty());
                view = subimage_view(view,x,y,mwidth,mheight);
                std::for_each(glyphs.begin(), glyphs.end(), render_glyphs<view_t>(view));
        }
};

template <typename view_t>
struct elipsed_layer
{
        typedef typename view_t::value_type color_t;

        FTC_Manager manager;
        std::string sfront;
        std::string sback;
        int id;
        int size;
        color_t color;
        static const int dwidth = 30;

        elipsed_layer(FTC_Manager manager, std::string sfront, std::string sback, color_t color, int id, int size) : 
                        manager(manager), sfront(sfront), sback(sback), id(id), size(size), color(color){}

        void operator()(view_t& view)
        {
                typedef text<view_t> text_t;

                text_t lback(manager,sback,color,id,size,
                        text_t::right|text_t::bottom);
                view_t vback = view;
                lback(vback);
                
                text_t lfront(manager,sfront,color,id,size,
                        text_t::left|text_t::bottom);
                int width = view.width()-vback.width()-dwidth;
                view_t vfront = subimage_view(view,0,0,width,view.height());
                lfront(vfront);

                text_t ldots(manager,color,id,size,     
                        text_t::center|text_t::bottom,text_t::fill,'.');
                width = view.width()-vfront.width()-vback.width();
                view_t vdots = subimage_view(view,vfront.width(),0,width,view.height());                
                ldots(vdots);
        }       
};

}

#endif