Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
4680 right-hear 1
/***************************************************************************/
2
/*                                                                         */
3
/*  ftadvanc.h                                                             */
4
/*                                                                         */
5
/*    Quick computation of advance widths (specification only).            */
6
/*                                                                         */
7
/*  Copyright 2008 by                                                      */
8
/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
9
/*                                                                         */
10
/*  This file is part of the FreeType project, and may only be used,       */
11
/*  modified, and distributed under the terms of the FreeType project      */
12
/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
13
/*  this file you indicate that you have read the license and              */
14
/*  understand and accept it fully.                                        */
15
/*                                                                         */
16
/***************************************************************************/
17
 
18
 
19
#ifndef __FTADVANC_H__
20
#define __FTADVANC_H__
21
 
22
 
23
#include 
24
#include FT_FREETYPE_H
25
 
26
#ifdef FREETYPE_H
27
#error "freetype.h of FreeType 1 has been loaded!"
28
#error "Please fix the directory search order for header files"
29
#error "so that freetype.h of FreeType 2 is found first."
30
#endif
31
 
32
 
33
FT_BEGIN_HEADER
34
 
35
 
36
  /**************************************************************************
37
   *
38
   * @section:
39
   *   quick_advance
40
   *
41
   * @title:
42
   *   Quick retrieval of advance values
43
   *
44
   * @abstract:
45
   *   Retrieve horizontal and vertical advance values without processing
46
   *   glyph outlines, if possible.
47
   *
48
   * @description:
49
   *   This section contains functions to quickly extract advance values
50
   *   without handling glyph outlines, if possible.
51
   */
52
 
53
 
54
  /*************************************************************************/
55
  /*                                                                       */
56
  /*                                                                */
57
  /*    FT_ADVANCE_FLAG_FAST_ONLY                                          */
58
  /*                                                                       */
59
  /*                                                          */
60
  /*    A bit-flag to be OR-ed with the `flags' parameter of the           */
61
  /*    @FT_Get_Advance and @FT_Get_Advances functions.                    */
62
  /*                                                                       */
63
  /*    If set, it indicates that you want these functions to fail if the  */
64
  /*    corresponding hinting mode or font driver doesn't allow for very   */
65
  /*    quick advance computation.                                         */
66
  /*                                                                       */
67
  /*    Typically, glyphs which are either unscaled, unhinted, bitmapped,  */
68
  /*    or light-hinted can have their advance width computed very         */
69
  /*    quickly.                                                           */
70
  /*                                                                       */
71
  /*    Normal and bytecode hinted modes, which require loading, scaling,  */
72
  /*    and hinting of the glyph outline, are extremely slow by            */
73
  /*    comparison.                                                        */
74
  /*                                                                       */
75
#define FT_ADVANCE_FLAG_FAST_ONLY  0x20000000UL
76
 
77
 
78
  /*************************************************************************/
79
  /*                                                                       */
80
  /*                                                             */
81
  /*    FT_Get_Advance                                                     */
82
  /*                                                                       */
83
  /*                                                          */
84
  /*    Retrieve the advance value of a given glyph outline in an          */
85
  /*    @FT_Face.  By default, the unhinted advance is returned in font    */
86
  /*    units.                                                             */
87
  /*                                                                       */
88
  /*                                                                */
89
  /*    face       :: The source @FT_Face handle.                          */
90
  /*                                                                       */
91
  /*    gindex     :: The glyph index.                                     */
92
  /*                                                                       */
93
  /*    load_flags :: A set of bit flags similar to those used when        */
94
  /*                  calling @FT_Load_Glyph, used to determine what kind  */
95
  /*                  of advances you need.                                */
96
  /*                                                               */
97
  /*    padvance :: The advance value, in either font units or 16.16       */
98
  /*                format.                                                */
99
  /*                                                                       */
100
  /*                If @FT_LOAD_VERTICAL_LAYOUT is set, this is the        */
101
  /*                vertical advance corresponding to a vertical layout.   */
102
  /*                Otherwise, it is the horizontal advance in a           */
103
  /*                horizontal layout.                                     */
104
  /*                                                                       */
105
  /*                                                               */
106
  /*    FreeType error code.  0 means success.                             */
107
  /*                                                                       */
108
  /*                                                                 */
109
  /*    This function may fail if you use @FT_ADVANCE_FLAG_FAST_ONLY and   */
110
  /*    if the corresponding font backend doesn't have a quick way to      */
111
  /*    retrieve the advances.                                             */
112
  /*                                                                       */
113
  /*    A scaled advance is returned in 16.16 format but isn't transformed */
114
  /*    by the affine transformation specified by @FT_Set_Transform.       */
115
  /*                                                                       */
116
  FT_EXPORT( FT_Error )
117
  FT_Get_Advance( FT_Face    face,
118
                  FT_UInt    gindex,
119
                  FT_Int32   load_flags,
120
                  FT_Fixed  *padvance );
121
 
122
 
123
  /*************************************************************************/
124
  /*                                                                       */
125
  /*                                                             */
126
  /*    FT_Get_Advances                                                    */
127
  /*                                                                       */
128
  /*                                                          */
129
  /*    Retrieve the advance values of several glyph outlines in an        */
130
  /*    @FT_Face.  By default, the unhinted advances are returned in font  */
131
  /*    units.                                                             */
132
  /*                                                                       */
133
  /*                                                                */
134
  /*    face        :: The source @FT_Face handle.                         */
135
  /*                                                                       */
136
  /*    start       :: The first glyph index.                              */
137
  /*                                                                       */
138
  /*    count       :: The number of advance values you want to retrieve.  */
139
  /*                                                                       */
140
  /*    load_flags  :: A set of bit flags similar to those used when       */
141
  /*                   calling @FT_Load_Glyph.                             */
142
  /*                                                                       */
143
  /*                                                               */
144
  /*    padvance :: The advances, in either font units or 16.16 format.    */
145
  /*                This array must contain at least `count' elements.     */
146
  /*                                                                       */
147
  /*                If @FT_LOAD_VERTICAL_LAYOUT is set, these are the      */
148
  /*                vertical advances corresponding to a vertical layout.  */
149
  /*                Otherwise, they are the horizontal advances in a       */
150
  /*                horizontal layout.                                     */
151
  /*                                                                       */
152
  /*                                                               */
153
  /*    FreeType error code.  0 means success.                             */
154
  /*                                                                       */
155
  /*                                                                 */
156
  /*    This function may fail if you use @FT_ADVANCE_FLAG_FAST_ONLY and   */
157
  /*    if the corresponding font backend doesn't have a quick way to      */
158
  /*    retrieve the advances.                                             */
159
  /*                                                                       */
160
  /*    Scaled advances are returned in 16.16 format but aren't            */
161
  /*    transformed by the affine transformation specified by              */
162
  /*    @FT_Set_Transform.                                                 */
163
  /*                                                                       */
164
  FT_EXPORT( FT_Error )
165
  FT_Get_Advances( FT_Face    face,
166
                   FT_UInt    start,
167
                   FT_UInt    count,
168
                   FT_Int32   load_flags,
169
                   FT_Fixed  *padvances );
170
 
171
/* */
172
 
173
 
174
FT_END_HEADER
175
 
176
#endif /* __FTADVANC_H__ */
177
 
178
 
179
/* END */