/* * Freetype 2 driver for Microwindows * * Originally written by Koninklijke Philips Electronics N.V. * * (Loosly) Based on the FreeType 1.x driver, font_freetype.c. * * Portions contributed by Koninklijke Philips Electronics N.V. * These portions are Copyright 2002 Koninklijke Philips Electronics * N.V. All Rights Reserved. These portions are licensed under the * terms of the Mozilla Public License, version 1.1, or, at your * option, the GNU General Public License version 2.0. Please see * the file "ChangeLog" for documentation regarding these * contributions. */ /* * Note on FreeType versions: * 2.0.9 - worked (not tested recently) * 2.1.0 - not tested * 2.1.1 - worked (switch CONFIG_OPTION_USE_CMAPS off if your fonts are * rejected as invalid). * 2.1.2 - avoid this release. Rotations were the wrong way. There is * no way to test for this and correct it, because this version of * the library mis-reports the version number as 2.1.1. * 2.1.3 - works. */ /*#define NDEBUG*/ #include #include #include #include #include #include #include "device.h" #include "devfont.h" #if (UNIX | DOS_DJGPP) #define strcmpi strcasecmp #endif /* temp extern decls*/ extern MWPIXELVAL gr_foreground; extern MWPIXELVAL gr_background; extern MWBOOL gr_usebg; /* * Enable the Freetype 2 font cache. Only applicable if * FreeType 2 itself is enabled. * * It is STRONGLY recommended that you turn this option on, * as to will give a HUGE speed boost. If you are using many * Microwindows font objects, this can also save memory (since * there is a single cache with a fixed size shared across * the system, but the memory use without caching is * proportional to the number of MWFREETYPE2FONT objects). * * FIXME: This option should be in the config file. */ #define HAVE_FREETYPE_2_CACHE 1 /* * Enable the Freetype 2 character map cache. Only applicable if * FreeType 2 itself is enabled, and HAVE_FREETYPE_2_CACHE is also * enabled. * * It is recommended that you turn this option on if you are * using FreeType 2.1.1 or later, as it should give a small * speed boost. (With earlier releases, this should work but * might actually slow down rendering slightly - the cache was * much slower before FreeType 2.1.1.) * * FIXME: This option should be in the config file. */ #define HAVE_FREETYPE_2_CMAP_CACHE 0 /* **************************************************************************/ /* FreeType 2.x */ /* **************************************************************************/ #include #include FT_FREETYPE_H #include FT_TRIGONOMETRY_H #include FT_GLYPH_H #if HAVE_FREETYPE_2_CACHE # include FT_CACHE_H # include FT_CACHE_SMALL_BITMAPS_H # if HAVE_FREETYPE_2_CMAP_CACHE # include FT_CACHE_CHARMAP_H # endif #endif /* Checking FreeType version numbers */ /** * Change a major.minor.patch version number into a single number, which * is much simpler to compare. * * If the paramaters are compile-time constants, then the result is also * a compile-time constant (and so can be used in #if statements). * * @param major Version number part * @param minor Version number part * @param patch Version number part * @return Single version number */ #define SIMPLIFY_VERSION_NUMBER(major,minor,patch) \ ((major)*0x01000000UL + (minor)*0x01000UL + (patch)*0x01UL) /** * The FreeType version number, in simplified format. */ #define FREETYPE_VERSION_NUMBER_SIMPLE \ SIMPLIFY_VERSION_NUMBER(FREETYPE_MAJOR,FREETYPE_MINOR,FREETYPE_PATCH) /** * TRUE if the FreeType version number is equal to or greater than the * specified version. * * If the paramaters are compile-time constants, then the result is also * a compile-time constant (and so can be used in #if statements). * * @param major Version number part * @param minor Version number part * @param patch Version number part * @return Single version number */ #define HAVE_FREETYPE_VERSION_AFTER_OR_EQUAL(major,minor,patch) \ (FREETYPE_VERSION_NUMBER_SIMPLE >= SIMPLIFY_VERSION_NUMBER(major,minor,patch)) #ifndef FREETYPE_FONT_DIR /** * The default Freetype font directory. */ #define FREETYPE_FONT_DIR "/usr/local/microwin/fonts" #endif /** * The Freetype 2 font directory. */ char *freetype2_font_dir; typedef struct freetype2_fontdata_ freetype2_fontdata; struct freetype2_fontdata_ { int isBuffer; union { char *filename; struct { unsigned char *data; unsigned length; } buffer; } data; int refcount; /* Currently only used for buffers, not files */ #if HAVE_FREETYPE_2_CACHE freetype2_fontdata *next; #endif }; struct MWFREETYPE2FONT_STRUCT { PMWFONTPROCS fontprocs; /* common hdr */ MWCOORD fontsize; int fontrotation; int fontattr; /* freetype stuff */ char *filename; /* NULL if buffered */ freetype2_fontdata *faceid; /* only used if HAVE_FREETYPE_2_CACHE or buffered. */ #if HAVE_FREETYPE_2_CACHE #if HAVE_FREETYPE_VERSION_AFTER_OR_EQUAL(2,1,3) FTC_ImageTypeRec imagedesc; #else FTC_ImageDesc imagedesc; #endif #if HAVE_FREETYPE_2_CMAP_CACHE FTC_CMapDescRec cmapdesc; #endif #else FT_Face face; #endif FT_Matrix matrix; }; static MWBOOL freetype2_getfontinfo(PMWFONT pfont, PMWFONTINFO pfontinfo); static void freetype2_gettextsize(PMWFONT pfont, const void *text, int cc, MWTEXTFLAGS flags, MWCOORD *pwidth, MWCOORD *pheight, MWCOORD *pbase); static void freetype2_destroyfont(PMWFONT pfont); static void freetype2_drawtext(PMWFONT pfont, PSD psd, MWCOORD x, MWCOORD y, const void *text, int cc, MWTEXTFLAGS flags); static void freetype2_setfontsize(PMWFONT pfont, MWCOORD fontsize); static void freetype2_setfontrotation(PMWFONT pfont, int tenthdegrees); static void freetype2_setfontattr(PMWFONT pfont, int setflags, int clrflags); static PMWFONT freetype2_duplicate(PMWFONT psrcfont, MWCOORD fontsize); /** * The virtual method table for FreeType 2 fonts (i.e. class MWFREETYPE2FONT). */ static MWFONTPROCS freetype2_procs = { MWTF_UC16, /* routines expect unicode 16 */ freetype2_getfontinfo, freetype2_gettextsize, NULL, /* gettextbits */ freetype2_destroyfont, freetype2_drawtext, freetype2_setfontsize, freetype2_setfontrotation, freetype2_setfontattr, freetype2_duplicate, }; static PMWFREETYPE2FONT freetype2_createfont_internal(freetype2_fontdata * faceid, char *filename, MWCOORD height); /** * The freetype library instance - a singleton. */ static FT_Library freetype2_library = NULL; #if HAVE_FREETYPE_2_CACHE /** * The Freetype 2 cache subsystem requires a 1-1 mapping * between "void *" pointers and actual font files. The * only almost-sane way to do this is to have a linked list * of font file names, and use pointers to the entries * in that array. Font names are added to the list the * first time the font is used, and never removed. */ static freetype2_fontdata *freetype2_fonts = NULL; /** * The FreeType 2 cache. */ static FTC_Manager freetype2_cache_manager; /** * The FreeType 2 cache for glyph bitmaps. */ static FTC_SBitCache freetype2_cache_sbit; #if HAVE_FREETYPE_2_CMAP_CACHE /** * The FreeType 2 cache for charater->glyph mappings. */ static FTC_CMapCache freetype2_cache_cmap; #endif #if HAVE_FREETYPE_2_CMAP_CACHE /** * Look up a glyph index from a character code. * There are two implementations of this macro, which one is used * depends on the setting of HAVE_FREETYPE_2_CMAP_CACHE * * @param pf_ The Microwindows font * @param face_ The equivalent FreeType 2 font * @param ch_ The character to look up * @return The glyph index. */ #define LOOKUP_CHAR(pf_,face_,ch_) \ (FTC_CMapCache_Lookup(freetype2_cache_cmap, \ &((pf_)->cmapdesc), \ (ch_))) #else #define LOOKUP_CHAR(pf_,face_,ch_) \ (FT_Get_Char_Index((face_), (ch_))) #endif /** * The FreeType 2 sbit cache does not support bitmaps >256x256. * For fonts up to and including the following height, use the cache. * For larger fonts, do it the slow way. * * Note: Should probably detect this using the maximum ascent and * maximum descent values. FIXME. */ #define FREETYPE2_CACHE_FONT_SIZE_LIMIT 100 /** * Test if a font can use the FreeType 2 cache. * * To use the cache, there must be no rotation, and the font must be * small enough for the bitmaps to be supported (i.e. it must be under * FREETYPE2_CACHE_FONT_SIZE_LIMIT). */ #define CAN_USE_FT2_CACHE(pf_) \ (((pf_)->fontrotation == 0) && \ ((pf_)->fontsize < FREETYPE2_CACHE_FONT_SIZE_LIMIT)) /** * Called from the FreeType 2 cache to load a font file. * * @param face_id The font ID. This is a pointer to a freetype2_fontdata structure. * @param library the FreeType library instance. * @param request_data FIXME * @param aface FIXME */ static FT_Error freetype2_face_requester(FTC_FaceID face_id, FT_Library library, FT_Pointer request_data, FT_Face * aface) { freetype2_fontdata *fontdata = (freetype2_fontdata *) face_id; // simple typecast assert(fontdata); if (fontdata->isBuffer) { unsigned char * buffer = fontdata->data.buffer.data; unsigned length = fontdata->data.buffer.length; /* DPRINTF("Font magic = '%c%c%c%c', len = %u @ freetype2_face_requester\n", (char)buffer[0], (char)buffer[1], (char)buffer[2], (char)buffer[3], length); */ assert(buffer); return FT_New_Memory_Face(library, buffer, length, 0, aface); } else { char * filename = fontdata->data.filename; /* DPRINTF("Loading font from file '%s' @ freetype2_face_requester\n", filename); */ assert(filename); return FT_New_Face(library, filename, 0, aface); } } #endif /** * Initialize the FreeType 2 driver. If successful, this is a one-time * operation. Subsequent calls will do nothing, successfully. * * @param psd Unused. * @return 0 on error, nonzero on success. */ int freetype2_init(PSD psd) { FT_Error err; if (freetype2_library != NULL) { return 1; } if ((freetype2_font_dir = getenv("MWFONTS")) == NULL) { freetype2_font_dir = FREETYPE_FONT_DIR; } /* Init freetype library */ err = FT_Init_FreeType(&freetype2_library); if (err != FT_Err_Ok) { freetype2_library = NULL; EPRINTF("Error 0x%x initializing FreeType 2\n", err); return 0; } #if HAVE_FREETYPE_2_CACHE /* initialize cache manager */ err = FTC_Manager_New(freetype2_library, 3, /* Faces */ 5, /* Sizes */ 512 * 1024, /* Bytes - 512K */ &freetype2_face_requester, NULL, &freetype2_cache_manager); if (err != FT_Err_Ok) { EPRINTF("Error 0x%x initializing FreeType 2 cache system\n", err); freetype2_cache_manager = NULL; FT_Done_FreeType(freetype2_library); freetype2_library = NULL; return 0; } err = FTC_SBitCache_New(freetype2_cache_manager, &freetype2_cache_sbit); if (err != FT_Err_Ok) { EPRINTF("Error 0x%x initializing FreeType 2 sbit cache system\n", err); freetype2_cache_sbit = NULL; FTC_Manager_Done(freetype2_cache_manager); freetype2_cache_manager = NULL; FT_Done_FreeType(freetype2_library); freetype2_library = NULL; return 0; } #if HAVE_FREETYPE_2_CMAP_CACHE err = FTC_CMapCache_New(freetype2_cache_manager, &freetype2_cache_cmap); if (err != FT_Err_Ok) { EPRINTF("Error 0x%x initializing FreeType 2 cmap cache system\n", err); freetype2_cache_cmap = NULL; // FIXME: Should we free the SBit cache here? freetype2_cache_sbit = NULL; FTC_Manager_Done(freetype2_cache_manager); freetype2_cache_manager = NULL; FT_Done_FreeType(freetype2_library); freetype2_library = NULL; return 0; } #endif #endif return 1; } /** * Create a font from a disk file. * * @param name The font file name or path. If no directory is specified, * freetype2_font_dir will be prepended. If no extension is * specified, ".ttf" will be added. * @param height The height of the font, in pixels. * @param attr The font attributes - a bitmask. * @return The new font, or NULL on error. */ PMWFREETYPE2FONT freetype2_createfont(const char *name, MWCOORD height, int attr) { PMWFREETYPE2FONT pf; char *p; char *fontname; freetype2_fontdata *faceid = NULL; #if HAVE_FREETYPE_2_CACHE int first_time = 0; #endif /* Initialization */ if (freetype2_library == NULL) { /* Init freetype library */ if (!freetype2_init(NULL)) { return NULL; } } fontname = malloc(6 + strlen(name) + strlen(freetype2_font_dir)); if (fontname == NULL) return NULL; /* check for pathname prefix */ if (strchr(name, '/') != NULL) { strcpy(fontname, name); } else { strcpy(fontname, freetype2_font_dir); strcat(fontname, "/"); strcat(fontname, name); } /* check for extension */ if ((p = strrchr(fontname, '.')) == NULL || ((strcmpi(p, ".ttf") != 0) && (strcmpi(p, ".pfr") != 0))) { strcat(fontname, ".ttf"); } #if HAVE_FREETYPE_2_CACHE faceid = freetype2_fonts; while ( (faceid != NULL) && (0 != strcmpi(faceid->data.filename, fontname)) ) { faceid = faceid->next; } if (faceid == NULL) { /* Not found in list, so add it. */ DPRINTF("Nano-X-Freetype2: Adding new font: %s\n", fontname); faceid = (freetype2_fontdata *) calloc(sizeof(*faceid), 1); if (faceid == NULL) { free(fontname); return NULL; } /* faceid->isBuffer = 0; - implied by calloc */ faceid->data.filename = fontname; /* Add to font list. */ faceid->next = freetype2_fonts; freetype2_fonts = faceid; /* Set a special flag. If we can't load the font, * we want to destroy the faceid. */ first_time = 1; } else { free(fontname); } fontname = faceid->data.filename; #else faceid = NULL; #endif pf = freetype2_createfont_internal(faceid, fontname, height); if (!pf) { #if HAVE_FREETYPE_2_CACHE if (first_time) { assert(freetype2_fonts == faceid); freetype2_fonts = faceid->next; free(fontname); free(faceid); } #else free(fontname); #endif return NULL; } GdSetFontAttr((PMWFONT) pf, attr, 0); return pf; } /** * Create a font from a memory buffer. * * @param buffer The font data. This will be copied by this function. * @param length The length of the font data. * @param height The height of the font, in pixels. * @return The new font, or NULL on error. */ PMWFREETYPE2FONT freetype2_createfontfrombuffer(const unsigned char *buffer, unsigned length, MWCOORD height) { PMWFREETYPE2FONT pf; freetype2_fontdata *faceid = NULL; unsigned char *buffercopy; assert(buffer); /* Initialization */ if (freetype2_library == NULL) { /* Init freetype library */ if (!freetype2_init(NULL)) { return NULL; } } faceid = (freetype2_fontdata *) calloc(sizeof(freetype2_fontdata), 1); if (!faceid) return NULL; buffercopy = (unsigned char *) malloc(length); if (!buffercopy) { free(faceid); return NULL; } memcpy(buffercopy, buffer, length); faceid->isBuffer = TRUE; faceid->data.buffer.length = length; faceid->data.buffer.data = buffercopy; faceid->refcount = 1; /*DPRINTF("Font magic = '%c%c%c%c', len = %u @ freetype2_createfontfrombuffer\n", (char)buffercopy[0], (char)buffercopy[1], (char)buffercopy[2], (char)buffercopy[3], length); */ pf = freetype2_createfont_internal(faceid, NULL, height); if (!pf) { free(faceid); } return pf; } /** * Finish loading a font. This is used for both disk-based and * memory-based fonts. * * Allocates the actual PMWFREETYPE2FONT structure, fills it in, and * actually loads the font using FreeType 2 to check the font is valid. * * @param faceid Information on how to load the font. * @param filename The filename, or NULL if loaded from memory. * @param height The font height in pixels. * @return The new font, or NULL on error. * * @internal */ static PMWFREETYPE2FONT freetype2_createfont_internal(freetype2_fontdata * faceid, char *filename, MWCOORD height) { PMWFREETYPE2FONT pf; #if HAVE_FREETYPE_2_CACHE FT_Face face; FT_Size size; #endif FT_Error error; /* allocate font structure */ pf = (PMWFREETYPE2FONT) calloc(sizeof(MWFREETYPE2FONT), 1); if (!pf) { return NULL; } pf->fontprocs = &freetype2_procs; pf->faceid = faceid; pf->filename = filename; #if HAVE_FREETYPE_2_CACHE pf->imagedesc.font.face_id = faceid; pf->imagedesc.font.pix_width = 0; /* Will be set by GdSetFontSize */ pf->imagedesc.font.pix_height = 0; /* Will be set by GdSetFontSize */ #if HAVE_FREETYPE_VERSION_AFTER_OR_EQUAL(2,1,3) pf->imagedesc.flags = 0; /* Will be set by GdSetFontAttr */ #else pf->imagedesc.type = 0; /* Will be set by GdSetFontAttr */ #endif #if HAVE_FREETYPE_2_CMAP_CACHE pf->cmapdesc.face_id = faceid; pf->cmapdesc.type = FTC_CMAP_BY_ENCODING; pf->cmapdesc.u.encoding = ft_encoding_unicode; #endif #else /* Load face */ if (filename) { error = FT_New_Face(freetype2_library, filename, 0, &pf->face); if (error != FT_Err_Ok) { EPRINTF("Nano-X-Freetype2: Can't load font from file \"%s\" - %lx\n", filename, (unsigned long) error); goto out; } /*DPRINTF("Nano-X-Freetype2: Loading font from file \"%s\"\n", filename); */ } else { error = FT_New_Memory_Face(freetype2_library, buffer, length, 0, &pf->face); if (error != FT_Err_Ok) { EPRINTF("Nano-X-Freetype2: Can't load font from memory - %lx\n", (unsigned long) error); goto out; } /*DPRINTF("Nano-X-Freetype2: Loading font from memory\n"); */ } error = FT_Select_Charmap(pf->face, ft_encoding_unicode); if (error != FT_Err_Ok) { EPRINTF("freetype2_createfont: no unicode map table - %lx\n", (unsigned long) error); goto out; } #endif GdSetFontSize((PMWFONT) pf, height); GdSetFontRotation((PMWFONT) pf, 0); GdSetFontAttr((PMWFONT) pf, 0, 0); #if HAVE_FREETYPE_2_CACHE /* Check that the font file exists and is valid */ /*DPRINTF("freetype2_createfont_internal(): testing\n");*/ error = FTC_Manager_Lookup_Size(freetype2_cache_manager, &(pf->imagedesc.font), &face, &size); if (error != FT_Err_Ok) { EPRINTF("Nano-X-Freetype2: Freetype 2 error %lx trying to load font.\n", (unsigned long)error); free(pf); return NULL; } #endif return pf; #if ! HAVE_FREETYPE_2_CACHE out: if (pf->face != NULL) { FT_Done_Face(pf->face); } free(pf); return NULL; #endif } /** * Frees a font. * * @param pfont The font to free. Must not be NULL. */ static void freetype2_destroyfont(PMWFONT pfont) { PMWFREETYPE2FONT pf = (PMWFREETYPE2FONT) pfont; assert(pf); #if ! HAVE_FREETYPE_2_CACHE FT_Done_Face(pf->face); if (pf->filename) free(pf->filename); #endif if (pf->faceid && pf->faceid->isBuffer) { if (--pf->faceid->refcount <= 0) { #if HAVE_FREETYPE_2_CACHE FTC_Manager_Reset(freetype2_cache_manager); #endif free(pf->faceid->data.buffer.data); free(pf->faceid); } } free(pf); } /** * Duplicates a font. Makes a new font that has the same face, attributes * and rotation as the source font. The height can be copied or a new * height can be specified. * * If the old font is a memory font, then this function does not copy the * actual buffer of font data, it merely adds another reference to it. * The reference count ensures that the buffer of font data is freed * correctly when the last font using it is freed. * * @param psrcfont The font to copy. * @param height The height of the new font, in pixels, or 0 to copy from * the source font. * @return A new font, or NULL on error. */ static PMWFONT freetype2_duplicate(PMWFONT psrcfont, MWCOORD height) { PMWFREETYPE2FONT pf = (PMWFREETYPE2FONT) psrcfont; PMWFREETYPE2FONT pnewf; assert(pf); if (height == 0) { height = pf->fontsize; } if (pf->filename) { /* Font from disk file */ char *filename; #if HAVE_FREETYPE_2_CACHE /* Stored in faceid, which is effectively static. No need * to copy. */ filename = pf->filename; #else /* Dynamically allocated, must copy. */ filename = malloc(1 + strlen(pf->filename)); if (!filename) return NULL; strcpy(filename, pf->filename); #endif pnewf = freetype2_createfont_internal(pf->faceid, filename, height); if (!pnewf) { free(filename); return NULL; } } else { pf->faceid->refcount++; pnewf = freetype2_createfont_internal(pf->faceid, NULL, height); if (!pnewf) { pf->faceid->refcount--; return NULL; } } GdSetFontAttr((PMWFONT) pnewf, pf->fontattr, 0); if (pf->fontrotation) GdSetFontRotation((PMWFONT) pnewf, pf->fontrotation); return (PMWFONT) pnewf; } /** * Set the size of a font. Caller must update pfont->fontsize. * * @param pfont The font to update. * @param fontsize The new height in pixels. */ static void freetype2_setfontsize(PMWFONT pfont, MWCOORD fontsize) { PMWFREETYPE2FONT pf = (PMWFREETYPE2FONT) pfont; MWCOORD pixel_height; MWCOORD pixel_width; assert(pf); pf->fontsize = fontsize; /* allow create font with height=0*/ if (!fontsize) return; /* In future, set these differently to support different aspect ratios. */ pixel_height = fontsize; pixel_width = fontsize; #if HAVE_FREETYPE_2_CACHE pf->imagedesc.font.pix_width = pixel_width; pf->imagedesc.font.pix_height = pixel_height; #else /* We want real pixel sizes ... not points ... */ FT_Set_Pixel_Sizes(pf->face, pixel_width, pixel_height); #endif } /** * Set the rotation of a font. Caller must update pfont->fontrotation. * * @param pfont The font to update. * @param tenthdegrees The new rotation in tenths of degrees. */ static void freetype2_setfontrotation(PMWFONT pfont, int tenthdegrees) { PMWFREETYPE2FONT pf = (PMWFREETYPE2FONT) pfont; assert(pf); /* Normalize so that 0 <= tenthdegrees < 3600 */ if ((tenthdegrees < 0) || (tenthdegrees >= 3600)) { tenthdegrees = tenthdegrees % 3600; if (tenthdegrees < 0) { tenthdegrees += 3600; } } pf->fontrotation = tenthdegrees; if (pf->fontrotation == 0) { /* Identity transform */ pf->matrix.yy = (FT_Fixed) (1 << 16); pf->matrix.xx = (FT_Fixed) (1 << 16); pf->matrix.yx = (FT_Fixed) 0; pf->matrix.xy = (FT_Fixed) 0; } else { FT_Angle angle = (tenthdegrees << 16) / 10; FT_Vector sincosvec; FT_Vector_Unit(&sincosvec, angle); pf->matrix.yy = sincosvec.y; pf->matrix.xx = sincosvec.y; pf->matrix.yx = sincosvec.x; pf->matrix.xy = -sincosvec.x; } } /** * Set the attributes of a font. Caller must update pfont->fontattr * before calling this function. * * @param pfont The font to update. * @param setflags Bits being set. Overrides clrflags. * @param clrflags Bits being cleared. */ static void freetype2_setfontattr(PMWFONT pfont, int setflags, int clrflags) { #if HAVE_FREETYPE_2_CACHE PMWFREETYPE2FONT pf = (PMWFREETYPE2FONT) pfont; assert(pf); #if HAVE_FREETYPE_VERSION_AFTER_OR_EQUAL(2,1,3) pf->imagedesc.flags = FT_LOAD_DEFAULT; if (!(pf->fontattr & MWTF_ANTIALIAS)) { pf->imagedesc.flags |= (FT_LOAD_MONOCHROME | FT_LOAD_TARGET_MONO); } #else pf->imagedesc.type = ((pf->fontattr & MWTF_ANTIALIAS) ? ftc_image_grays : ftc_image_mono); #endif #else /* No cache. Nothing to do, just check paramater is valid. */ assert(pfont); #endif } #define ROUND_26_6_TO_INT(valuetoround) (((valuetoround) + 63) >> 6) /** * Get the advance width, ascent and descent of a character. * Complicated by the need to use the cache if possible, and to handle rotated text. * * The face and pf arguments must refer to the same font. * * Any of the output paramater pointers may be NULL if you only care * about some of the values. * * @param pf The font to use * @param face A FreeType2 face generated from pf * @param glyph_index The glyph to measure * @param padvance [out] advance width. * @param pascent [out] character ascent. * @param pdescent [out] character descent. * @return FreeType error code (0 on success). */ static FT_Error freetype2_get_glyph_size(PMWFREETYPE2FONT pf, FT_Face face, int glyph_index, int *padvance, int *pascent, int *pdescent) { FT_Error error; assert (pf); assert (face); #if HAVE_FREETYPE_2_CACHE if (CAN_USE_FT2_CACHE(pf)) { FTC_SBit sbit; error = FTC_SBitCache_Lookup(freetype2_cache_sbit, &(pf->imagedesc), glyph_index, &sbit, NULL); if (error) return error; /*DPRINTF("sbit->top = %d, sbit->height = %d\n", sbit->top, sbit->height);*/ if (padvance) *padvance = sbit->xadvance; if (pascent) *pascent = sbit->top; if (pdescent) *pdescent = sbit->height - sbit->top; return 0; } else #endif { error = FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT); if (error) return error; if (padvance) *padvance = ROUND_26_6_TO_INT(face->glyph->advance.x); if (pascent || pdescent) { FT_Glyph glyph; FT_BBox bbox; error = FT_Get_Glyph(face->glyph, &glyph); if (error) return error; FT_Glyph_Get_CBox(glyph, ft_glyph_bbox_pixels, &bbox); FT_Done_Glyph(glyph); if (pascent) *pascent = bbox.yMax; if (pdescent) *pdescent = -bbox.yMin; } return 0; } } /** * Get the advance width, ascent and descent of a character. * Complicated by the need to use the cache if possible, and to handle rotated text. * * The face and pf arguments must refer to the same font. * * Any of the output paramater pointers may be NULL if you only care * about some of the values. * * @param pf The font to use * @param face A FreeType2 face generated from pf * @param ch The character to measure * @param padvance [out] advance width. * @param pascent [out] character ascent. * @param pdescent [out] character descent. * @return FreeType error code (0 on success). */ static FT_Error freetype2_get_char_size(PMWFREETYPE2FONT pf, FT_Face face, int ch, int *padvance, int *pascent, int *pdescent) { int glyph = LOOKUP_CHAR(pf, face, ch); return freetype2_get_glyph_size(pf, face, glyph, padvance, pascent, pdescent); } /** * Return information about a specified font. * * @param pfont The font to query * @param pfontinfo The destination for the font metrics information. * @return TRUE on success, FALSE on error. */ static MWBOOL freetype2_getfontinfo(PMWFONT pfont, PMWFONTINFO pfontinfo) { PMWFREETYPE2FONT pf = (PMWFREETYPE2FONT) pfont; FT_Face face; FT_Size size; FT_BBox *bbox; FT_Size_Metrics *metrics; int ch; int leading; #if HAVE_FREETYPE_2_CACHE FT_Error error; #endif #if MW_FEATURE_DO_NOT_TRUST_FONT_ASCENT_AND_DESCENT int font_ascent; int font_descent; #endif assert(pf); assert(pfontinfo); #if HAVE_FREETYPE_2_CACHE error = FTC_Manager_Lookup_Size(freetype2_cache_manager, &(pf->imagedesc.font), &face, &size); if (error) { EPRINTF("Freetype 2 error 0x%x getting font info.\n", error); return FALSE; } #else face = pf->face; size = face->size; #endif bbox = &(face->bbox); metrics = &(size->metrics); if (!FT_IS_SCALABLE(face)) { /* FIXME */ return FALSE; } /* Fill up the fields */ pfontinfo->maxwidth = ROUND_26_6_TO_INT(metrics->max_advance); pfontinfo->maxascent = ROUND_26_6_TO_INT(FT_MulFix(bbox->yMax, metrics->y_scale)); pfontinfo->maxdescent = ROUND_26_6_TO_INT(FT_MulFix(-bbox->yMin, metrics->y_scale)); pfontinfo->fixed = ((face->face_flags & FT_FACE_FLAG_FIXED_WIDTH) != 0); pfontinfo->baseline = ROUND_26_6_TO_INT(metrics->ascender); pfontinfo->descent = ROUND_26_6_TO_INT(abs(metrics->descender)); pfontinfo->height = pfontinfo->baseline + pfontinfo->descent; leading = ROUND_26_6_TO_INT(metrics->height - (metrics->ascender + abs(metrics->descender))); pfontinfo->linespacing = pfontinfo->height + leading; //DPRINTF("Nano-X-Freetype2: Font metrics:" // "\n maxwidth = %3d" // "\n baseline = %3d max_ascent = %3d" // "\n descent = %3d max_descent = %3d" // "\n height = %3d line_spacing = %3d" // "\n\n", // pfontinfo->maxwidth, // pfontinfo->baseline, pfontinfo->max_ascent, // pfontinfo->descent, pfontinfo->max_descent, // pfontinfo->height, pfontinfo->line_spacing // ); /* FIXME: Following are hacks... */ pfontinfo->firstchar = 0; pfontinfo->lastchar = 0xFFFFU; for (ch = 0; ch < 256; ch++) { int advance; if (freetype2_get_char_size(pf, face, ch, &advance, NULL, NULL)) { /* Error - assume default */ pfontinfo->widths[ch] = pfontinfo->maxwidth; } else { /* OK, found the value. */ pfontinfo->widths[ch] = advance; } //EPRINTF("pfontinfo->widths[%d]=%d\n", i, pfontinfo->widths[i]); } return TRUE; } /** * Draws text onto a screen or pixmap. * * @param pfont The font to use. * @param psd The device to draw on. * @param ax The destination X co-ordinate. * @param ay The destination Y co-ordinate. * @param text The string to display, in 16-bit Unicode form. * @param cc The number of characters (not bytes) in text. * @param flags Flags. */ static void freetype2_drawtext(PMWFONT pfont, PSD psd, MWCOORD ax, MWCOORD ay, const void *text, int cc, MWTEXTFLAGS flags) { PMWFREETYPE2FONT pf = (PMWFREETYPE2FONT) pfont; FT_Face face; FT_Size size; const unsigned short *str = text; FT_Vector pos; int i; FT_Glyph glyph; FT_Error error; FT_Vector kerning_delta; int curchar; int use_kerning; int last_glyph_code = 0; /* Used for kerning */ driver_gc_t blit_instructions; int blit_op; assert(pf); assert(psd); assert(text); //DPRINTF("Nano-X-Freetype2: freetype2_drawtext(x=%d, y=%d) called\n", ax, ay); #if HAVE_FREETYPE_2_CACHE error = FTC_Manager_Lookup_Size(freetype2_cache_manager, &(pf->imagedesc.font), &face, &size); if (error) { EPRINTF("Freetype 2 error 0x%x getting font for drawtext.\n", error); return; } #else face = pf->face; size = face->size; #endif use_kerning = ((pf->fontattr & MWTF_KERNING) && FT_HAS_KERNING(face)); /* Initialize the parts of blit_instructions we won't change */ blit_instructions.fg_color = gr_foreground; blit_instructions.bg_color = gr_background; blit_instructions.gr_usebg = gr_usebg; blit_instructions.srcx = 0; blit_instructions.srcy = 0; blit_instructions.dst_linelen = 0; /* Unused. */ if (pf->fontattr & MWTF_ANTIALIAS) { blit_op = PSDOP_ALPHACOL; } else { blit_op = PSDOP_BITMAP_BYTES_MSB_FIRST; } /* * Offset the starting point if necessary, * FreeType always aligns at baseline */ if (flags & MWTF_BOTTOM) { pos.y = (abs(size->metrics.descender) + 63) & ~63; /* descent */ } else if (flags & MWTF_TOP) { pos.y = -(size->metrics.ascender + 63) & ~63; /* -ascent */ } else { pos.y = 0; } #if 1 if ((pf->fontrotation != 0) #if HAVE_FREETYPE_2_CACHE || (!CAN_USE_FT2_CACHE(pf)) /* Cache does not support bitmaps >256x256 */ #endif ) { /* Use slow routine for rotated text */ #endif FT_BitmapGlyph bitmapglyph; FT_Bitmap *bitmap; FT_Render_Mode render_mode = (pf-> fontattr & MWTF_ANTIALIAS) ? ft_render_mode_normal : ft_render_mode_mono; /*DPRINTF("Nano-X-Freetype2: freetype2_drawtext() using SLOW routine\n"); */ pos.x = 0; for (i = 0; i < cc; i++) { curchar = LOOKUP_CHAR(pf, face, str[i]); if (use_kerning && last_glyph_code && curchar) { FT_Get_Kerning(face, last_glyph_code, curchar, ft_kerning_default, &kerning_delta); //DPRINTF("Nano-X-Freetype2: freetype2_drawtext(): kerning_delta.x=%d, /64=%d\n", // (int)kerning_delta.x, (int)kerning_delta.x/64); pos.x += kerning_delta.x & (~63); } last_glyph_code = curchar; /* FIXME: Should use an image cache to optimize * rendering of rotated text. */ error = FT_Load_Glyph(face, curchar, FT_LOAD_DEFAULT); if (error) continue; error = FT_Get_Glyph(face->glyph, &glyph); if (error) continue; // translate the glyph image now.. FT_Glyph_Transform(glyph, 0, &pos); //DPRINTF("Nano-X-Freetype2: freetype2_drawtext(): glyph->advance.x=%d, >>16=%d\n", (int)glyph->advance.x, (int)glyph->advance.x>>16); pos.x += (glyph->advance.x >> 10) & (~63); if (pf->fontrotation) { // rotate the glyph image now.. FT_Glyph_Transform(glyph, &pf->matrix, 0); } // convert glyph image to bitmap // error = FT_Glyph_To_Bitmap(&glyph, render_mode, 0, // no additional translation 1); // do not destroy copy in "image" if (!error) { bitmapglyph = (FT_BitmapGlyph) glyph; bitmap = &(bitmapglyph->bitmap); blit_instructions.dstx = ax + bitmapglyph->left; blit_instructions.dsty = ay - bitmapglyph->top; blit_instructions.dstw = bitmap->width; blit_instructions.dsth = bitmap->rows; blit_instructions.src_linelen = bitmap->pitch; blit_instructions.pixels = bitmap->buffer; blit_instructions.misc = bitmap->buffer; //DPRINTF("Nano-X-Freetype2: freetype2_draw_bitmap_%s(ax=%d, ay=%d, gl->l=%d, gl->t=%d)\n", // ((pf->fontattr & MWTF_ANTIALIAS) ? "alpha" : "mono"), ax, ay, bitmapglyph->left, bitmapglyph->top); if ((blit_instructions.dstw > 0) && (blit_instructions.dsth > 0)) { GdDrawAreaInternal(psd, &blit_instructions, blit_op); } FT_Done_Glyph(glyph); } } #if 1 } else { /* No rotation - optimized loop */ #if HAVE_FREETYPE_2_CACHE FTC_SBit sbit; #else FT_Bitmap *bitmap; #endif ay += (pos.y >> 6); for (i = 0; i < cc; i++) { curchar = LOOKUP_CHAR(pf, face, str[i]); if (use_kerning && last_glyph_code && curchar) { FT_Get_Kerning(face, last_glyph_code, curchar, ft_kerning_default, &kerning_delta); ax += (kerning_delta.x >> 6); } last_glyph_code = curchar; #if HAVE_FREETYPE_2_CACHE error = FTC_SBitCache_Lookup(freetype2_cache_sbit, &(pf->imagedesc), curchar, &sbit, NULL); if (error) continue; blit_instructions.dstx = ax + sbit->left; blit_instructions.dsty = ay - sbit->top; blit_instructions.dstw = sbit->width; blit_instructions.dsth = sbit->height; blit_instructions.src_linelen = sbit->pitch; blit_instructions.pixels = sbit->buffer; blit_instructions.misc = sbit->buffer; ax += sbit->xadvance; #else error = FT_Load_Glyph(face, curchar, (pf->fontattr & MWTF_ANTIALIAS) ? (FT_LOAD_RENDER | FT_LOAD_MONOCHROME) : FT_LOAD_RENDER); if (error) continue; bitmap = &(face->glyph->bitmap); blit_instructions.dstx = ax + face->glyph->bitmap_left; blit_instructions.dsty = ay - face->glyph->bitmap_top; blit_instructions.dstw = bitmap->width; blit_instructions.dsth = bitmap->rows; blit_instructions.src_linelen = bitmap->pitch; blit_instructions.pixels = bitmap->buffer; blit_instructions.misc = bitmap->buffer; /* Wierdness: After FT_Load_Glyph, face->glyph->advance.x is in 26.6. * After a translation with FT_Glyph_Transform, it is in 16.16. * Must be a FreeType 2.0.8 bug. */ ax += (face->glyph->advance.x >> 6); #endif if ((blit_instructions.dstw > 0) && (blit_instructions.dsth > 0)) { GdDrawAreaInternal(psd, &blit_instructions, blit_op); } } } #endif GdFixCursor(psd); // FIXME // if (pf->fontattr & MWTF_UNDERLINE) // GdLine(psd, startx, starty, x, y, FALSE); } /** * Measures text, which can be rotated. This is slower than the * non-rotated version. * * @param pf The font to use. * @param text The string to measure, in 16-bit Unicode form. * @param cc The number of characters (not bytes) in text. * @param pwidth [out] the width in pixels * @param pheight [out] the height in pixels * @param pbase [out] the base in pixels * * @internal */ static void freetype2_gettextsize_rotated(PMWFREETYPE2FONT pf, const void *text, int cc, MWCOORD * pwidth, MWCOORD * pheight, MWCOORD * pbase) { FT_Face face; FT_Size size; const unsigned short *str = text; FT_Vector pos; int i; FT_Glyph glyph; FT_Error error; FT_Vector kerning_delta; int curchar; int use_kerning; int last_glyph_code = 0; /* Used for kerning */ FT_BBox bbox; FT_BBox glyph_bbox; #if HAVE_FREETYPE_2_CACHE error = FTC_Manager_Lookup_Size(freetype2_cache_manager, &(pf->imagedesc.font), &face, &size); if (error) { EPRINTF("Freetype 2 error 0x%x getting font info.\n", error); *pwidth = 0; *pheight = 0; *pbase = 0; return; } #else face = pf->face; size = face->size; #endif use_kerning = ((pf->fontattr & MWTF_KERNING) && FT_HAS_KERNING(face)); bbox.xMin = 0; bbox.yMin = 0; bbox.xMax = 0; bbox.yMax = 0; /* * Starting point */ pos.x = 0; pos.y = 0; for (i = 0; i < cc; i++) { curchar = LOOKUP_CHAR(pf, face, str[i]); if (use_kerning && last_glyph_code && curchar) { FT_Get_Kerning(face, last_glyph_code, curchar, ft_kerning_default, &kerning_delta); pos.x += kerning_delta.x & (~63); } last_glyph_code = curchar; /* FIXME: Should use an image cache to optimize * rendering of rotated text. */ error = FT_Load_Glyph(face, curchar, FT_LOAD_DEFAULT); if (error) continue; error = FT_Get_Glyph(face->glyph, &glyph); if (error) continue; //DPRINTF("Nano-X-Freetype2: freetype2_gettextsize(): glyph '%c' at %d,%d, advance=%d\n", // str[i], (pos.x>>6), (pos.y>>6), (glyph->advance.x >> 16)); // translate the glyph image now.. FT_Glyph_Transform(glyph, 0, &pos); pos.x += (glyph->advance.x >> 10) & (~63); if (pf->fontrotation) { // rotate the glyph image now.. FT_Glyph_Transform(glyph, &pf->matrix, 0); } if (i == 0) { FT_Glyph_Get_CBox(glyph, ft_glyph_bbox_pixels, &bbox); } else { FT_Glyph_Get_CBox(glyph, ft_glyph_bbox_pixels, &glyph_bbox); //DPRINTF("Nano-X-Freetype2: freetype2_gettextsize(): glyph cbox (%d,%d)-(%d,%d)\n", // (glyph_bbox.xMin/*>>6*/), (glyph_bbox.yMin/*>>6*/), // (glyph_bbox.xMax/*>>6*/), (glyph_bbox.yMax/*>>6*/)); if (glyph_bbox.xMin < bbox.xMin) bbox.xMin = glyph_bbox.xMin; if (glyph_bbox.yMin < bbox.yMin) bbox.yMin = glyph_bbox.yMin; if (glyph_bbox.xMax > bbox.xMax) bbox.xMax = glyph_bbox.xMax; if (glyph_bbox.yMax > bbox.yMax) bbox.yMax = glyph_bbox.yMax; } FT_Done_Glyph(glyph); //DPRINTF("Nano-X-Freetype2: freetype2_gettextsize(): total cbox (%d,%d)-(%d,%d)\n", // (bbox.xMin/*>>6*/), (bbox.yMin/*>>6*/), (bbox.xMax/*>>6*/), (bbox.yMax/*>>6*/)); } *pwidth = bbox.xMax /*>> 6 */ ; *pheight = (bbox.yMax - bbox.yMin) /*>> 6 */ ; *pbase = -(bbox.yMin /*>> 6 */ ); //DPRINTF("Nano-X-Freetype2: freetype2_gettextsize(): numchars = %d, w = %d, h = %d, base = %d\n", // cc, *pwidth, *pheight, *pbase); } /** * Measures text, which must not be rotated. This is faster than the * rotated version. This uses the cache system, if available, so * the caller must check that they CAN_USE_FT2_CACHE(). * * @param pf The font to use. * @param text The string to measure, in 16-bit Unicode form. * @param char_count The number of characters (not bytes) in text. * @param pwidth [out] the width in pixels * @param pheight [out] the height in pixels * @param pbase [out] the base in pixels * * @internal */ static void freetype2_gettextsize_fast(PMWFREETYPE2FONT pf, const void *text, int char_count, MWCOORD * pwidth, MWCOORD * pheight, MWCOORD * pbase) { FT_Face face; FT_Size size; const unsigned short *str = text; int char_index; int total_advance; int max_ascent; int max_descent; int advance; int ascent; int descent; FT_Error error; FT_Vector kerning_delta; int use_kerning; int cur_glyph_code; int last_glyph_code = 0; /* Used for kerning */ #if HAVE_FREETYPE_2_CACHE error = FTC_Manager_Lookup_Size(freetype2_cache_manager, &(pf->imagedesc.font), &face, &size); if (error) { EPRINTF("Freetype 2 error 0x%x getting font info.\n", error); *pwidth = 0; *pheight = 0; *pbase = 0; return; } #else face = pf->face; size = face->size; #endif use_kerning = ((pf->fontattr & MWTF_KERNING) && FT_HAS_KERNING(face)); /* * Starting point */ total_advance = 0; max_ascent = 0; max_descent = 0; for (char_index = 0; char_index < char_count; char_index++) { cur_glyph_code = LOOKUP_CHAR(pf, face, str[char_index]); if (use_kerning && last_glyph_code && cur_glyph_code) { FT_Get_Kerning(face, last_glyph_code, cur_glyph_code, ft_kerning_default, &kerning_delta); /*EPRINTF("Nano-X-Freetype2: freetype2_gettextsize(): %d + kerning %d (delta was %d unscaled).\n", (int)ax, (int)(kerning_delta.x >> 6), (int)kerning_delta.x); */ total_advance += (kerning_delta.x >> 6); } last_glyph_code = cur_glyph_code; error = freetype2_get_glyph_size(pf, face, cur_glyph_code, &advance, &ascent, &descent); if (error) continue; total_advance += advance; if (max_ascent < ascent) max_ascent = ascent; if (max_descent < descent) max_descent = descent; } *pwidth = total_advance; *pheight = max_ascent + max_descent; *pbase = max_ascent; /*EPRINTF("Nano-X-Freetype2: freetype2_gettextsize(): numchars = %d, w = %d, h = %d, base = %d\n", cc, *pwidth, *pheight, *pbase); */ } /** * Measures text. * * @param pfont The font to use. * @param text The string to measure, in 16-bit Unicode form. * @param cc The number of characters (not bytes) in text. * @param flags Flags specifying the encoding of text. * @param pwidth [out] the width in pixels * @param pheight [out] the height in pixels * @param pbase [out] the base in pixels */ static void freetype2_gettextsize(PMWFONT pfont, const void *text, int cc,MWTEXTFLAGS flags, MWCOORD * pwidth, MWCOORD * pheight, MWCOORD * pbase) { PMWFREETYPE2FONT pf = (PMWFREETYPE2FONT) pfont; assert(pf); assert(text); assert(pwidth); assert(pheight); assert(pbase); if ((pf->fontrotation != 0) #if HAVE_FREETYPE_2_CACHE || (!CAN_USE_FT2_CACHE(pf)) #endif ) { /* Use slow routine for rotated text */ /* EPRINTF("Nano-X-Freetype2: freetype2_gettextsize() using SLOW routine\n"); */ freetype2_gettextsize_rotated(pf, text, cc, pwidth, pheight, pbase); } else { freetype2_gettextsize_fast(pf, text, cc, pwidth, pheight, pbase); } } #if 0 /* FIXME not yet used */ /* * Get the human-readable name of a font, given it's filename. * * Returns NULL if font is invalid or does not contain a name. * Otherwise, returns a malloc'd ASCII string. */ char * freetype2_get_name(const char *filename) { FT_Face face; char *result = NULL; assert(filename); /* Load face */ if (FT_New_Face(freetype2_library, filename, 0, &face) == FT_Err_Ok) { result = malloc(strlen(face->family_name) + 1); if (result != NULL) { strcpy(result, face->family_name); } FT_Done_Face(face); } return result; } #endif