include/text/GP_Font.h

   1 /*****************************************************************************
   2  * This file is part of gfxprim library.                                     *
   3  *                                                                           *
   4  * Gfxprim is free software; you can redistribute it and/or                  *
   5  * modify it under the terms of the GNU Lesser General Public                *
   6  * License as published by the Free Software Foundation; either              *
   7  * version 2.1 of the License, or (at your option) any later version.        *
   8  *                                                                           *
   9  * Gfxprim is distributed in the hope that it will be useful,                *
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  12  * Lesser General Public License for more details.                           *
  13  *                                                                           *
  14  * You should have received a copy of the GNU Lesser General Public          *
  15  * License along with gfxprim; if not, write to the Free Software            *
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor,                        *
  17  * Boston, MA  02110-1301  USA                                               *
  18  *                                                                           *
  19  * Copyright (C) 2009-2012 Cyril Hrubis <metan@ucw.cz>                       *
  20  *                                                                           *
  21  *****************************************************************************/
  22
  23 #ifndef TEXT_GP_FONT_H
  24 #define TEXT_GP_FONT_H
  25
  26 #include <stdint.h>
  27
  28 #define GP_FONT_NAME_MAX 64
  29
  30 /*
  31  * Data describing single Glyph.
  32  *
  33  * Note that glyph do not necessarily correspond to one character (for example
  34  * ligature is a glyph but corresponds to at least two characters).
  35  *
  36  * The glyphs are rendered to horizontal baseline, vertical rendering is not
  37  * supported.
  38  *
  39  * The structure could contain glyphs of different BPP and information about
  40  * the bitmap format is stored in the font structure. The bitmap lines are byte
  41  * aligned.
  42  */
  43 typedef struct GP_GlyphBitmap {
  44         /*
  45          * Bitmap width in pixels.
  46          */
  47         uint8_t width;
  48
  49         /*
  50          * Bitmap heigth in pixels.
  51          */
  52         uint8_t height;
  53
  54         /*
  55          * X offset to be applied before we start drawing.
  56          */
  57         int8_t bearing_x;
  58
  59         /*
  60          * Y offset from baseline to the top of the bitmap.
  61          */
  62         int8_t bearing_y;
  63
  64         /*
  65          * Offset to be applied after drawing, defines
  66          * basepoint for next glyph.
  67          */
  68         uint8_t advance_x;
  69
  70         /*
  71          * Character bitmap, byte aligned bitmap.
  72          */
  73         uint8_t bitmap[];
  74 } GP_GlyphBitmap;
  75
  76 typedef enum GP_CharSet {
  77         GP_CHARSET_7BIT,
  78 } GP_CharSet;
  79
  80 /*
  81  * Glyph bitmap data format.
  82  *
  83  * The bitmap is byte aligned and for 1BPP the number of bytes per row is
  84  * rounted to bytes.
  85  *
  86  */
  87 typedef enum GP_FontBitmapFormat {
  88         GP_FONT_BITMAP_1BPP,
  89         GP_FONT_BITMAP_8BPP,
  90 } GP_FontBitmapFormat;
  91
  92 /*
  93  * Font face
  94  */
  95 typedef struct GP_FontFace {
  96         /*
  97          * Font family name - eg. Sans, Serif ...
  98          */
  99         char family_name[GP_FONT_NAME_MAX];
 100
 101         /*
 102          * Font style name - Medium, Bold, Italic ...
 103          */
 104         char style_name[GP_FONT_NAME_MAX];
 105
 106         /*
 107          * Enum for supported charsets.
 108          */
 109         uint8_t charset;
 110
 111         /*
 112          * Maximal height of font glyph from baseline to the top.
 113          */
 114         uint16_t ascend;
 115
 116         /*
 117          * Maximal length of font glyph from baseline to the bottom.
 118          */
 119         uint16_t descend;
 120
 121         /*
 122          * Maximal width of font glyph.
 123          *
 124          * (basically max from glyph->width + glyph->bearing_x)
 125          */
 126         uint16_t max_glyph_width;
 127
 128         /*
 129          * Maximal glyph advance.
 130          */
 131         uint16_t max_glyph_advance;
 132
 133         /*
 134          * Bitmap format for all glyphs
 135          */
 136         GP_FontBitmapFormat glyph_bitmap_format;
 137
 138         /*
 139          * Pointer to glyph bitmap buffer.
 140          */
 141         void *glyphs;
 142
 143         /*
 144          * Offsets to the glyph data.
 145          *
 146          * If glyph_offset[0] == 0, the table glyph_offsets holds offsets for
 147          * all characters in glyphs, the last offset i.e. offsets[len] holds
 148          * the size of glyphs array.
 149          *
 150          * If glyph_offset[0] != 0 the glyph_offset[0] defines step in the
 151          * glyph table.
 152          */
 153         uint32_t glyph_offsets[];
 154 } GP_FontFace;
 155
 156 /*
 157  * Returns font height eg. ascend + descend
 158  */
 159 static inline unsigned int GP_FontHeight(const GP_FontFace *font)
 160 {
 161         return font->ascend + font->descend;
 162 }
 163
 164 static inline unsigned int GP_FontAscend(const GP_FontFace *font)
 165 {
 166         return font->ascend;
 167 }
 168
 169 static inline unsigned int GP_FontDescend(const GP_FontFace *font)
 170 {
 171         return font->descend;
 172 }
 173
 174 static inline unsigned int GP_FontMaxWidth(const GP_FontFace *font)
 175 {
 176         return font->max_glyph_width;
 177 }
 178
 179 static inline unsigned int GP_FontMaxAdvanceX(const GP_FontFace *font)
 180 {
 181         return font->max_glyph_advance;
 182 }
 183
 184 static inline const char *GP_FontFamily(const GP_FontFace *font)
 185 {
 186         return font->family_name;
 187 }
 188
 189 static inline const char *GP_FontStyle(const GP_FontFace *font)
 190 {
 191         return font->style_name;
 192 }
 193
 194 /*
 195  * Returns glyph count for charset.
 196  */
 197 uint32_t GP_GetGlyphCount(GP_CharSet charset);
 198
 199 /*
 200  * Returns glyph mapping
 201  */
 202 GP_GlyphBitmap *GP_GetGlyphBitmap(const GP_FontFace *font, int c);
 203
 204 /*
 205  * Loads font face from file.
 206  */
 207 GP_FontFace *GP_FontFaceLoad(const char *path, uint32_t width, uint32_t height);
 208
 209 /*
 210  * Free the font face memory.
 211  */
 212 void GP_FontFaceFree(GP_FontFace *self);
 213
 214 #endif /* TEXT_GP_FONT_H */