font.c

Go to the documentation of this file.

#include <stdint.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>


#ifdef USER_CONFIG
#include "user_config.h"
#endif

#ifndef MEMSPACE
#define MEMSPACE_FONT MEMSPACE
#endif

#include "display/ili9341.h"
#include "display/font.h"

#include "fonts.h"

// All the fonts - defined in fonts.h
extern _font *allfonts[];

int font_max()
{
    int i;
    for(i=0;allfonts[i];++i)
        ;
    return(i);
}

int font_H(int font)
{
// check font
    _font *z = allfonts[font];
    return(z->Height);
}

int font_W(int font)
{
// check font
    _font *z = allfonts[font];
    return(z->Width);
}



int font_attr(window *win, int c, _fontc *f)
{
    int offset;
    int num;
    unsigned char *ptr;

// check font
    _font *z = allfonts[win->font];
    _fontspecs s;

    num = c - z->First;
    if(num < 0 || num >= z->Glyphs)
        return(-1);

    f->ptr = z->bitmap;

// If we have font specifications defined and included we can use them.
// Notes: Normally for small fixed fonts we do not want to included them.
// However; if the font is large we can define just the active part of 
// the character to reduce the overall size.

    if(z->specs)
    {
        f->Width = z->Width;
        f->Height = z->Height;

// Copy the full font specification into ram for easy access
// This does not use much memory as it does not include the bitmap itself
// This method avoids memory alignment access errors on the ESP8266.

        cpy_flash((uint8_t *)&(z->specs[num]), (uint8_t *)&s,sizeof(_fontspecs));

        // Fonts Width,Height,X,Y
        f->w = s.Width;
        f->h = s.Height;
        f->x= s.X;
        f->y= s.Y;

        // Bitmap offset
        offset = s.Offset;
        f->ptr += offset;

    
        // The user may override the fixed variable font flag
        // This reduces the width of fixed fonts to just the active pixels.
        f->flags = win->flags;

        // Skip is the combined width, and an optional character spacing gap
        // Some characters have no active size (like the space character )
        // so we just use the master font width and gap
        if( !(f->flags & FONT_VAR) || !f->w )
            f->skip = z->Width + z->gap;
        else
            f->skip = f->x + f->w + z->gap; // Include the X offset, Width and Gap
    }

    else   
    {
        // No Specifications, therefore the font must be fixed.
        // We create one using the master font size spec
        // There are no proportional options here.
        f->Width = z->Width;
        f->Height = z->Height;

        f->w = z->Width;
        f->h = z->Height;
        f->x = 0;
        f->y = 0;

        // FIXME - fixed fonts without specs have no proportional modes to use
        f->flags = win->flags;

        f->skip = z->Width + z->gap;

        // Each bitmap is a bit array w by h in size without any padding
        // except at the end of the array which is rounded to the next byte boundary.
        offset = ((z->Width * z->Height)+7)/8; /* round to byte boundary */
        f->ptr += (offset * num);

    }

    // FIXME
    // This zero size skip test should never be needed - for now we increase to 1..
    if(!f->skip)
        f->skip++;
// =====================================

#if ILI9341_DEBUG & 2
    printf("c: %02x font:%d w:%d h:%d x:%d y:%d skip:%d, W:%d, H:%d\r\n",
        0xff & c, 0xff & win->font, f->w, f->h, f->x, f->y, f->skip, f->Width, f->Height);
#endif
    return(win->font);
}


void tft_drawChar(window *win, uint8_t c)
{
    _fontc f;
    int ret;
    int yskip;

    ret = font_attr(win, c, &f);
    if(ret < 0)
        return;

// process wrapping - will the character fit ?
    if((win->xpos + f.skip - 1)  >= win->w)
    {
        if(win->flags & WRAP_H)
        {
            win->ypos += f.Height;
            win->xpos = 0;
        }
        else
        {
            // TODO H scroll
            return;
        }
    }

    // Will the character fit ?
    if((win->ypos+f.Height-1) >= win->h)
    {
        if(win->flags & WRAP_V)
        {
            win->ypos = 0;
        }
        else
        {
            win->ypos -= f.Height;
            tft_Vscroll(win,f.Height);
        }
    }

// Conditionally clear the character area - not needed for full size fixed fonts..
// If the character is not full size then pre-clear the full font bit array
// (saves the more complex tests of clearing additional areas around the active font)
// Note: We use skip instead of Width because of the additional gap that must also
// be cleared..

// FIXME we should do this in two parts - font area and then the gap area.
// Since we always want to clear the gap - but not always the font - when fixed.

// Optionally clear the font area, then the gap
    if(f.h != f.Height ||  f.w != f.skip || f.x != 0 || f.y != 0)
        tft_fillRectWH(win, win->xpos, win->ypos, f.skip, f.Height, win->bg);

// This can happen for characters with no active pixels like the space character.
    if(!f.h || !f.w)
    {
        win->xpos += f.skip;
        return;
    }

// Top of bit bounding box ( first row with a 1 bit in it)
    yskip = f.Height - (f.y+f.h);

// Write the font to the screen
    tft_bit_blit(win, f.ptr, win->xpos+f.x, win->ypos+yskip, f.w, f.h);

    // skip is the offset to the next character
    win->xpos += f.skip;
}