---

font_bitmap.cpp

Go to the documentation of this file.

/*
        $Id: font_bitmap.cpp,v 1.1 2001/03/06 15:09:20 mbn Exp $

        ------------------------------------------------------------------------
        ClanLib, the platform independent game SDK.

        This library is distributed under the GNU LIBRARY GENERAL PUBLIC LICENSE
        version 2. See COPYING for details.

        For a total list of contributers see CREDITS.

        ------------------------------------------------------------------------

        File purpose:
                Bitmap font class.

*/

#include "Core/precomp.h"
#include <API/Display/Font/font.h>
#include <API/Display/Font/font_description.h>
#include <API/Display/Display/surfaceprovider.h>
#include <API/Display/Display/surface.h>

#include "font_bitmap.h"

CL_Font_Bitmap::CL_Font_Bitmap(CL_Font_Description *font_desc)
        : CL_Font_Generic()
{
        space_len = font_desc->space_len;
        subtract_width = font_desc->subtract_width;

        int len = font_desc->letters.length();
        for (int j=0; j<256; j++)
                chars[j] = NULL;

        font_desc->lock();
        for (int i=0; i<len; i++)
        {
                if (i == 0)
                        height = font_desc->letter_providers[i]->get_height();
        
                chars[(unsigned char) font_desc->letters[i]] = CL_Surface::create(
                        font_desc->letter_providers[i],
                        false);
        }
        font_desc->unlock();
}

CL_Font_Bitmap::~CL_Font_Bitmap()
{
        for (int i=0; i<256; i++)
                if (chars[i]!=NULL)
                        delete chars[i];
}

int CL_Font_Bitmap::get_height()
{
        return height;
}

int CL_Font_Bitmap::get_text_width(const char *_text)
{
        int len = 0;

        unsigned char *text = (unsigned char *) _text;

        while (*text != 0)
        {
                if (chars[*text] != NULL)
                        len += chars[*text]->get_width()-subtract_width;
                else
                        len += space_len;

                text++;
        }

        return len;
}

int CL_Font_Bitmap::get_char_width(const char _character)
{
        unsigned char character = (unsigned char) _character;
        
        if (chars[character] != NULL)
        {
                return chars[character]->get_width()-subtract_width;
        }
        else
        {
                return space_len;
        }
}

void CL_Font_Bitmap::print_left(int x, int y, const char *_text, int n_height)
{
        int pos_x = x;
        int pos_y = y;

        unsigned char *text = (unsigned char *) _text;

        while (*text != 0)
        {
                // new line on '\n'
                if( *text == '\n' )
                {
                        pos_x = x;
                        pos_y += (get_height() + n_height);
                        text++;
                }
        
                if (chars[*text] != NULL)
                {
                        int width = chars[*text]->get_width()-subtract_width;

                        chars[*text]->put_screen(pos_x, pos_y);

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

void CL_Font_Bitmap::print_left(int x, int y, float sx, float sy, const char *_text)
{
        int pos_x = x;

        unsigned char *text = (unsigned char *) _text;

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

                        chars[*text]->put_screen(pos_x, y, sx, sy);

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

                text++;
        }
}

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

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

void CL_Font_Bitmap::put_target(int x, int y, const char *_text, CL_Target *target, int alignment)
{
        int pos_x;
        unsigned char *text = (unsigned char *) _text;
                
        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, y, 0, target);

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

                text++;
        }
}

---