From 238bb38513dbc29081870757887c17c0c2c383e0 Mon Sep 17 00:00:00 2001 From: David Turner Date: Mon, 1 Sep 2008 21:35:53 +0000 Subject: [PATCH] ooops. Add missing files --- include/freetype/ftadvanc.h | 131 ++++++++++++++++++++++++++++++++++++ src/base/ftadvanc.c | 127 ++++++++++++++++++++++++++++++++++ 2 files changed, 258 insertions(+) create mode 100644 include/freetype/ftadvanc.h create mode 100644 src/base/ftadvanc.c diff --git a/include/freetype/ftadvanc.h b/include/freetype/ftadvanc.h new file mode 100644 index 000000000..02befa163 --- /dev/null +++ b/include/freetype/ftadvanc.h @@ -0,0 +1,131 @@ +/***************************************************************************/ +/* */ +/* ftadvanc.h */ +/* */ +/* FreeType access the glyph advances (specification only). */ +/* */ +/* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by */ +/* David Turner, Robert Wilhelm, and Werner Lemberg. */ +/* */ +/* This file is part of the FreeType project, and may only be used, */ +/* modified, and distributed under the terms of the FreeType project */ +/* license, LICENSE.TXT. By continuing to use, modify, or distribute */ +/* this file you indicate that you have read the license and */ +/* understand and accept it fully. */ +/* */ +/***************************************************************************/ + +#ifndef __FREETYPE_ADVANCE_H__ +#define __FREETYPE_ADVANCE_H__ + +#include +#include FT_FREETYPE_H + + /*************************************************************************/ + /* */ + /* */ + /* FT_ADVANCE_FLAG_FAST_ONLY */ + /* */ + /* */ + /* a bit-flag to be or-ed to the 'flags' parameter of the */ + /* @FT_Get_Advance and @FT_Get_Advances. */ + /* */ + /* when set, it indicates that you want these functions to fail */ + /* if the corresponding hinting mode or font driver doesn't */ + /* allow for very quick advance computation. */ + /* */ + /* typically, unscaled, unhinted, bitmapped and light-hinted glyphs */ + /* can have their advance width(s) computed very quickly. */ + /* */ + /* not so for normal and bytecode hinted modes, which require */ + /* loading/scaling/hinting the glyph outline instead, which is */ + /* extremely slow by comparison */ + /* */ +#define FT_ADVANCE_FLAG_FAST_ONLY 0x20000000U + + + /*************************************************************************/ + /* */ + /* */ + /* FT_Get_Advance */ + /* */ + /* */ + /* Retrieve the advance of a given glyph outline in a @FT_Face. */ + /* by default, the unhinted advance is returned in font units */ + /* */ + /* */ + /* face :: source @FT_Face handle */ + /* gindex :: glyph index */ + /* load_flags :: a set of bit-flags similar to those used */ + /* when calling @FT_Load_Glyph, used to determine */ + /* what kind of advances you need. */ + /* */ + /* padvance :: the advance value, in either font units or 16.16 */ + /* format. */ + /* */ + /* if @FT_LOAD_VERTICAL_LAYOUT is set, this is the */ + /* vertical advance corresponding to a vertical layout. */ + /* otherwise, it's the horizontal advance in an */ + /* horizontal layout. */ + /* */ + /* FreeType error code. 0 means success. */ + /* */ + /* */ + /* This function may fail if you use @FT_ADVANCE_FLAG_FAST_ONLY and */ + /* if the corresponding's font backend doesn't have a quick way to */ + /* retrieve the advances. */ + /* */ + /* A scaled advance is returned in 16.16 format, but isn't */ + /* transformed by the affine transform specified by @FT_Set_Transform */ + /* */ + FT_EXPORT( FT_Error ) + FT_Get_Advance( FT_Face face, + FT_UInt gindex, + FT_UInt load_flags, + FT_Fixed *padvance ); + + /*************************************************************************/ + /* */ + /* */ + /* FT_Get_Advances */ + /* */ + /* */ + /* Retrieve the advance of several glyph outlines in a @FT_Face. */ + /* by default, the unhinted advances are returned in font units */ + /* */ + /* */ + /* face :: source @FT_Face handle */ + /* start :: first glyph index */ + /* count :: number of advances you want to retrieve */ + /* load_flags :: a set of bit-flags similar to those used when */ + /* calling @FT_Load_Glyph. */ + /* */ + /* */ + /* padvance :: the advances, in either font units or 16.16 format. */ + /* this array must contain at least 'count' elements */ + /* */ + /* if @FT_LOAD_VERTICAL_LAYOUT is set, these are the */ + /* vertical advances corresponding to a vertical layout. */ + /* otherwise, they are the horizontal advances in an */ + /* horizontal layout. */ + /* */ + /* FreeType error code. 0 means success. */ + /* */ + /* */ + /* This function may fail if you use @FT_ADVANCE_FLAG_FAST_ONLY and */ + /* if the corresponding's font backend doesn't have a quick way to */ + /* retrieve the advances. */ + /* */ + /* Scaled advances are returned in 16.16 format, but aren't */ + /* transformed by the affine transform specified by @FT_Set_Transform */ + /* */ + FT_EXPORT( FT_Error ) + FT_Get_Advances( FT_Face face, + FT_UInt start, + FT_UInt count, + FT_UInt load_flags, + FT_Fixed *padvances ); + +/* */ + +#endif /* __FREETYPE_ADVANCE_H__ */ diff --git a/src/base/ftadvanc.c b/src/base/ftadvanc.c new file mode 100644 index 000000000..626a0cf02 --- /dev/null +++ b/src/base/ftadvanc.c @@ -0,0 +1,127 @@ +#include +#include FT_ADVANCES_H +#include FT_INTERNAL_OBJECTS_H + + static FT_Error + _ft_face_scale_advances( FT_Face face, + FT_Fixed* advances, + FT_UInt count, + FT_UInt flags ) + { + FT_Fixed scale; + FT_UInt nn; + + if ( (flags & FT_LOAD_NO_SCALE) ) + return FT_Err_Ok; + + if ( face->size == NULL ) + return FT_Err_Invalid_Size_Handle; + + if ( !(flags & FT_LOAD_VERTICAL_LAYOUT) ) + scale = face->size->metrics.x_scale; + else + scale = face->size->metrics.y_scale; + + /* this must be the same computation than to get linearHori/VertAdvance + * (see FT_Load_Glyph() implementation in src/base/ftobjs.c */ + for (nn = 0; nn < count; nn++) + advances[nn] = FT_MulDiv( advances[nn], scale, 64 ); + + return 0; + } + + +/* at the moment, we can perform fast advance retrieval only in + the following cases: + + - unscaled load + - unhinted load + - light-hinted load + */ +#define LOAD_ADVANCE_FAST_CHECK(flags) \ + (((flags & (FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING)) != 0) || \ + FT_LOAD_TARGET_MODE(flags) == FT_RENDER_MODE_LIGHT) + + FT_EXPORT_DEF(FT_Error) + FT_Get_Advance( FT_Face face, + FT_UInt gindex, + FT_UInt flags, + FT_Fixed *padvance ) + { + FT_Face_GetAdvancesFunc func; + + if ( !face ) + return FT_Err_Invalid_Face_Handle; + + if (gindex >= (FT_UInt) face->num_glyphs ) + return FT_Err_Invalid_Glyph_Index; + + func = face->driver->clazz->get_advances; + if (func != NULL && LOAD_ADVANCE_FAST_CHECK(flags)) + { + FT_Error error; + + error = func( face, gindex, 1, flags, padvance ); + if (!error) + return _ft_face_scale_advances( face, padvance, 1, flags ); + + if (error != FT_Err_Unimplemented_Feature) + return error; + } + + return FT_Get_Advances( face, gindex, 1, flags, padvance ); + } + + + FT_EXPORT_DEF(FT_Error) + FT_Get_Advances( FT_Face face, + FT_UInt start, + FT_UInt count, + FT_UInt flags, + FT_Fixed *padvances ) + { + FT_Face_GetAdvancesFunc func; + FT_UInt num, end, nn; + FT_Error error = 0; + + if ( !face ) + return FT_Err_Invalid_Face_Handle; + + num = (FT_UInt) face->num_glyphs; + end = start + count; + if (start >= num || end < start || end > num) + return FT_Err_Invalid_Glyph_Index; + + if (count == 0) + return FT_Err_Ok; + + func = face->driver->clazz->get_advances; + if (func != NULL && LOAD_ADVANCE_FAST_CHECK(flags)) + { + error = func( face, start, count, flags, padvances ); + if (!error) goto Exit; + + if (error != FT_Err_Unimplemented_Feature) + return error; + } + + error = 0; + + if ((flags & FT_ADVANCE_FLAG_FAST_ONLY) != 0) + return FT_Err_Unimplemented_Feature; + + flags |= FT_LOAD_ADVANCE_ONLY; + for (nn = 0; nn < count; nn++) + { + error = FT_Load_Glyph( face, start+nn, flags ); + if (error) break; + + padvances[nn] = (flags & FT_LOAD_VERTICAL_LAYOUT) + ? face->glyph->advance.x + : face->glyph->advance.y; + } + if (error) return error; + + Exit: + return _ft_face_scale_advances( face, padvances, count, flags ); + }