---

font_ttf.cpp

Go to the documentation of this file.

#include "Core/precomp.h"
#include <API/Core/IOData/inputsource_provider.h>
#include <API/Core/IOData/inputsource.h>
#include <API/Core/System/clanstring.h>
#include <API/Display/SurfaceProviders/canvas.h>
#include <API/Display/Display/surface.h>
#include <API/Display/Font/font.h>
#include <malloc.h>
#include "Display/Font/font_generic.h"

#include <freetype/freetype.h>

#include "font_ttf.h"

CL_Font_TTF::CL_Font_TTF(CL_String name, CL_InputSourceProvider* provider)
: CL_Font_Generic()
{
        // Init the class
        filename = name;
        font_mem = NULL;
        font_sizes = NULL;
        chars_init = false;
        a = 255;
        r = b = g = 0;

        // Ensure the proper target to load a TTF file
        if(provider != NULL)
                input_provider = provider->clone();
        else 
        input_provider = CL_InputSourceProvider::create_file_provider(".");

        // Open the font
        input_source = input_provider->open_source(filename);

        // Allocate memory for the font
        font_mem = (unsigned char*)malloc(input_source->size());
        size = input_source->size();
        if(font_mem == NULL)
                throw CL_Error("Out of Memory");
        memset((void*)font_mem, 0, size);

        // Buffered to the size of the font+1 to prevent overflow
        input_source->read(font_mem, size);

        height = 12; // Freetype defaults to font size 10 if it uses scaleable fonts
        width = 12;
        space_len = 10;
        subtract_width = 0; // I dunno about this one

        generate_font();
}

void CL_Font_TTF::generate_font() 
{
        if(chars_init)
        {
                for(int i=0;i<256;i++)
                        delete chars[i];
        }
        FT_Library library;
        FT_Face face;
        int error=0;

        // Initialize 'library' as a freetype library.
        error = FT_Init_FreeType( &library );
        if (error != 0)
                throw(CL_Error("Cannot initialize the FreeType Library"));

        // Turn 'face' into a handle to the font library stored in memory and use 'library' as the library handle
        error = FT_New_Memory_Face(library, font_mem, size, 0, &face);
        // This loads 'library' with the font at filename with the font face index 0(always valid).

        if( error == FT_Err_Unknown_File_Format)
                throw CL_Error("I can't understand what the file format is.");
        else if (error != 0)
                throw CL_Error("I can't access the font file or the font may be broken");

        num_faces = face->num_faces; // Total number of available faces
        num_fixed_sizes = face->num_fixed_sizes; // Fixed sizes for non-scallable fonts
        num_glyphs = face->num_glyphs; // Number of characters

        if(num_fixed_sizes>0)
        {
                font_sizes = new int[num_fixed_sizes];
                for(int i=0;i<num_fixed_sizes;i++) 
                        font_sizes[i] = face->available_sizes[i].height;
                
                height = font_sizes[0];
                width = font_sizes[0];
        }

        FT_Set_Char_Size(face,height<<6,width<<6,72,72);

        CL_Canvas *canvas=NULL;

        int index;

        for(int i=0;i<num_glyphs;i++)
        {
                index = FT_Get_Char_Index(face,i);

                error = FT_Load_Glyph(face,index,FT_LOAD_DEFAULT);

                if(error!=0) continue;

                error = FT_Render_Glyph(face->glyph,ft_render_mode_normal );

                if(error!=0) continue;

                adjust[i].top = face->glyph->bitmap_top;
                adjust[i].left = face->glyph->bitmap_left;

        canvas = new CL_Canvas(face->glyph->bitmap.width , face->glyph->bitmap.rows);
                canvas->lock();

                unsigned char *buffer =(unsigned char*) canvas->get_data();
                unsigned char *bmp = (unsigned char*)face->glyph->bitmap.buffer;

                for(int j=0;j<(face->glyph->bitmap.rows*face->glyph->bitmap.width);j++) 
                {
                        *buffer = (*bmp) & a;
                        *(buffer+1) = (*bmp) & b;
                        *(buffer+2) = (*bmp) & g;
                        *(buffer+3) = (*bmp) & r;
                        bmp++;
                        buffer+=4;
                }
                
                canvas->unlock();
                chars[i] = CL_Surface::create(canvas);
        }
        chars_init = true;
        FT_Done_Face(face);
        FT_Done_FreeType(library);
}

CL_Font_TTF::~CL_Font_TTF()
{
        free((void*)font_mem);
        delete[] chars;
        delete[] font_sizes;
}

int CL_Font_TTF::get_text_width(const char *text)
{
        int width=0;
        while(*text != 0) 
        {
                width += chars[*text]->get_width()-subtract_width;
                text++;
        }
        return width;
}

int CL_Font_TTF::get_char_width(const char character)
{
        return (chars[character]->get_width());
}

void CL_Font_TTF::print_left(int x, int y, const char *_text, int n_height)
{
        int pos_x = x;
        const unsigned char *text = (unsigned char*)_text;
        while(*text!=0)
        {
                if(*text == '\n')
                {
                        x = pos_x; 
                        y += (get_height() + n_height);
                        text++;
                        continue;
                }
                if (chars[*text] != NULL)
                {
                        int width = chars[*text]->get_width()-subtract_width;

                        chars[*text]->put_screen(x + adjust[*text].left, y-adjust[*text].top);

                        x += width;
                        if(*text == 0x20) // Space
                                x += space_len;
                }
                else
                        x += space_len;
                text++;
  }
}


void CL_Font_TTF::print_left(int x, int y, float scale_x, float scale_y, const char *text)
{
        int pos_x = x;

        while (*text != 0)
        {
                if (chars[*text] != NULL)
                {
                        int width = (int) ((chars[*text]->get_width()-subtract_width)*scale_x);

                        chars[*text]->put_screen(pos_x+(adjust[*text].left*scale_y), y-(adjust[*text].top*scale_y));

                        pos_x += width;
                }
                else
                {
                        pos_x += (int) (space_len*scale_x);
                }

                text++;
        }
}

void CL_Font_TTF::print_center(int x, int y, const char *text)
{
        print_left(x - get_text_width(text)/2, y, text); 
}

void CL_Font_TTF::print_right(int x, int y, const char *text)
{
        print_left(x - get_text_width(text), y, text);
}

void CL_Font_TTF::put_target(int x, int y, const char *text, CL_Target *target, int alignment)
{
        int pos_x;
                
        switch(alignment)
        {
                case CL_Font::ALIGN_CENTER:
                        pos_x = x - get_text_width(text)/2;
                        break;
                case CL_Font::ALIGN_RIGHT:
                        pos_x = x - get_text_width(text);
                        break;
                default:
                        pos_x = x;
        }       
        
        while (*text != 0)
        {
                if (chars[*text] != NULL)
                {
                        int width = chars[*text]->get_width()-subtract_width;

                        chars[*text]->put_target(pos_x+adjust[*text].left, y-adjust[*text].top, 0, target);

                        pos_x += width;
                }
                else
                {
                        pos_x += space_len;
                }

                text++;
        }
}

int CL_Font_TTF::change_size(int size)
{
        if(num_fixed_sizes>0)
        {
                for(int i=0;i<num_fixed_sizes;i++)
                {
                        if(font_sizes[i] == size)
                        {
                                width = size;
                                height = size;
                                generate_font();
                                return size;
                        }
                }
                return -1;
        }
        else
        {
                width = size;
                height = size;

                try
                {
                        generate_font();
                }
                catch(...) {return -1;}
    
                return size;
        }
}

unsigned int CL_Font_TTF::change_colour(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
        this->r = r;
        this->g = g;
        this->b = b;
        this->a = a;

        generate_font();
}

---