source: trunk/poppler/freetype-2.1.10/src/base/ftgloadr.c @ 2

Last change on this file since 2 was 2, checked in by Eugene Romanenko, 15 years ago

First import

File size: 11.9 KB
Line 
1/***************************************************************************/
2/*                                                                         */
3/*  ftgloadr.c                                                             */
4/*                                                                         */
5/*    The FreeType glyph loader (body).                                    */
6/*                                                                         */
7/*  Copyright 2002, 2003, 2004 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#include <ft2build.h>
20#include FT_INTERNAL_GLYPH_LOADER_H
21#include FT_INTERNAL_MEMORY_H
22#include FT_INTERNAL_OBJECTS_H
23
24#undef  FT_COMPONENT
25#define FT_COMPONENT  trace_gloader
26
27
28  /*************************************************************************/
29  /*************************************************************************/
30  /*************************************************************************/
31  /*****                                                               *****/
32  /*****                                                               *****/
33  /*****                    G L Y P H   L O A D E R                    *****/
34  /*****                                                               *****/
35  /*****                                                               *****/
36  /*************************************************************************/
37  /*************************************************************************/
38  /*************************************************************************/
39
40  /*************************************************************************/
41  /*                                                                       */
42  /* The glyph loader is a simple object which is used to load a set of    */
43  /* glyphs easily.  It is critical for the correct loading of composites. */
44  /*                                                                       */
45  /* Ideally, one can see it as a stack of abstract `glyph' objects.       */
46  /*                                                                       */
47  /*   loader.base     Is really the bottom of the stack.  It describes a  */
48  /*                   single glyph image made of the juxtaposition of     */
49  /*                   several glyphs (those `in the stack').              */
50  /*                                                                       */
51  /*   loader.current  Describes the top of the stack, on which a new      */
52  /*                   glyph can be loaded.                                */
53  /*                                                                       */
54  /*   Rewind          Clears the stack.                                   */
55  /*   Prepare         Set up `loader.current' for addition of a new glyph */
56  /*                   image.                                              */
57  /*   Add             Add the `current' glyph image to the `base' one,    */
58  /*                   and prepare for another one.                        */
59  /*                                                                       */
60  /* The glyph loader is now a base object.  Each driver used to           */
61  /* re-implement it in one way or the other, which wasted code and        */
62  /* energy.                                                               */
63  /*                                                                       */
64  /*************************************************************************/
65
66
67  /* create a new glyph loader */
68  FT_BASE_DEF( FT_Error )
69  FT_GlyphLoader_New( FT_Memory        memory,
70                      FT_GlyphLoader  *aloader )
71  {
72    FT_GlyphLoader  loader;
73    FT_Error        error;
74
75
76    if ( !FT_NEW( loader ) )
77    {
78      loader->memory = memory;
79      *aloader       = loader;
80    }
81    return error;
82  }
83
84
85  /* rewind the glyph loader - reset counters to 0 */
86  FT_BASE_DEF( void )
87  FT_GlyphLoader_Rewind( FT_GlyphLoader  loader )
88  {
89    FT_GlyphLoad  base    = &loader->base;
90    FT_GlyphLoad  current = &loader->current;
91
92
93    base->outline.n_points   = 0;
94    base->outline.n_contours = 0;
95    base->num_subglyphs      = 0;
96
97    *current = *base;
98  }
99
100
101  /* reset the glyph loader, frees all allocated tables */
102  /* and starts from zero                               */
103  FT_BASE_DEF( void )
104  FT_GlyphLoader_Reset( FT_GlyphLoader  loader )
105  {
106    FT_Memory memory = loader->memory;
107
108
109    FT_FREE( loader->base.outline.points );
110    FT_FREE( loader->base.outline.tags );
111    FT_FREE( loader->base.outline.contours );
112    FT_FREE( loader->base.extra_points );
113    FT_FREE( loader->base.subglyphs );
114
115    loader->max_points    = 0;
116    loader->max_contours  = 0;
117    loader->max_subglyphs = 0;
118
119    FT_GlyphLoader_Rewind( loader );
120  }
121
122
123  /* delete a glyph loader */
124  FT_BASE_DEF( void )
125  FT_GlyphLoader_Done( FT_GlyphLoader  loader )
126  {
127    if ( loader )
128    {
129      FT_Memory memory = loader->memory;
130
131
132      FT_GlyphLoader_Reset( loader );
133      FT_FREE( loader );
134    }
135  }
136
137
138  /* re-adjust the `current' outline fields */
139  static void
140  FT_GlyphLoader_Adjust_Points( FT_GlyphLoader  loader )
141  {
142    FT_Outline*  base    = &loader->base.outline;
143    FT_Outline*  current = &loader->current.outline;
144
145
146    current->points   = base->points   + base->n_points;
147    current->tags     = base->tags     + base->n_points;
148    current->contours = base->contours + base->n_contours;
149
150    /* handle extra points table - if any */
151    if ( loader->use_extra )
152      loader->current.extra_points =
153        loader->base.extra_points + base->n_points;
154  }
155
156
157  FT_BASE_DEF( FT_Error )
158  FT_GlyphLoader_CreateExtra( FT_GlyphLoader  loader )
159  {
160    FT_Error   error;
161    FT_Memory  memory = loader->memory;
162
163
164    if ( !FT_NEW_ARRAY( loader->base.extra_points, loader->max_points ) )
165    {
166      loader->use_extra = 1;
167      FT_GlyphLoader_Adjust_Points( loader );
168    }
169    return error;
170  }
171
172
173  /* re-adjust the `current' subglyphs field */
174  static void
175  FT_GlyphLoader_Adjust_Subglyphs( FT_GlyphLoader  loader )
176  {
177    FT_GlyphLoad  base    = &loader->base;
178    FT_GlyphLoad  current = &loader->current;
179
180
181    current->subglyphs = base->subglyphs + base->num_subglyphs;
182  }
183
184
185  /* Ensure that we can add `n_points' and `n_contours' to our glyph.      */
186  /* This function reallocates its outline tables if necessary.  Note that */
187  /* it DOESN'T change the number of points within the loader!             */
188  /*                                                                       */
189  FT_BASE_DEF( FT_Error )
190  FT_GlyphLoader_CheckPoints( FT_GlyphLoader  loader,
191                              FT_UInt         n_points,
192                              FT_UInt         n_contours )
193  {
194    FT_Memory    memory  = loader->memory;
195    FT_Error     error   = FT_Err_Ok;
196    FT_Outline*  base    = &loader->base.outline;
197    FT_Outline*  current = &loader->current.outline;
198    FT_Bool      adjust  = 1;
199
200    FT_UInt      new_max, old_max;
201
202
203    /* check points & tags */
204    new_max = base->n_points + current->n_points + n_points;
205    old_max = loader->max_points;
206
207    if ( new_max > old_max )
208    {
209      new_max = FT_PAD_CEIL( new_max, 8 );
210
211      if ( FT_RENEW_ARRAY( base->points, old_max, new_max ) ||
212           FT_RENEW_ARRAY( base->tags,   old_max, new_max ) )
213        goto Exit;
214
215      if ( loader->use_extra &&
216           FT_RENEW_ARRAY( loader->base.extra_points, old_max, new_max ) )
217        goto Exit;
218
219      adjust = 1;
220      loader->max_points = new_max;
221    }
222
223    /* check contours */
224    old_max = loader->max_contours;
225    new_max = base->n_contours + current->n_contours +
226              n_contours;
227    if ( new_max > old_max )
228    {
229      new_max = FT_PAD_CEIL( new_max, 4 );
230      if ( FT_RENEW_ARRAY( base->contours, old_max, new_max ) )
231        goto Exit;
232
233      adjust = 1;
234      loader->max_contours = new_max;
235    }
236
237    if ( adjust )
238      FT_GlyphLoader_Adjust_Points( loader );
239
240  Exit:
241    return error;
242  }
243
244
245  /* Ensure that we can add `n_subglyphs' to our glyph. this function */
246  /* reallocates its subglyphs table if necessary.  Note that it DOES */
247  /* NOT change the number of subglyphs within the loader!            */
248  /*                                                                  */
249  FT_BASE_DEF( FT_Error )
250  FT_GlyphLoader_CheckSubGlyphs( FT_GlyphLoader  loader,
251                                 FT_UInt         n_subs )
252  {
253    FT_Memory     memory = loader->memory;
254    FT_Error      error  = FT_Err_Ok;
255    FT_UInt       new_max, old_max;
256
257    FT_GlyphLoad  base    = &loader->base;
258    FT_GlyphLoad  current = &loader->current;
259
260
261    new_max = base->num_subglyphs + current->num_subglyphs + n_subs;
262    old_max = loader->max_subglyphs;
263    if ( new_max > old_max )
264    {
265      new_max = FT_PAD_CEIL( new_max, 2 );
266      if ( FT_RENEW_ARRAY( base->subglyphs, old_max, new_max ) )
267        goto Exit;
268
269      loader->max_subglyphs = new_max;
270
271      FT_GlyphLoader_Adjust_Subglyphs( loader );
272    }
273
274  Exit:
275    return error;
276  }
277
278
279  /* prepare loader for the addition of a new glyph on top of the base one */
280  FT_BASE_DEF( void )
281  FT_GlyphLoader_Prepare( FT_GlyphLoader  loader )
282  {
283    FT_GlyphLoad  current = &loader->current;
284
285
286    current->outline.n_points   = 0;
287    current->outline.n_contours = 0;
288    current->num_subglyphs      = 0;
289
290    FT_GlyphLoader_Adjust_Points   ( loader );
291    FT_GlyphLoader_Adjust_Subglyphs( loader );
292  }
293
294
295  /* add current glyph to the base image - and prepare for another */
296  FT_BASE_DEF( void )
297  FT_GlyphLoader_Add( FT_GlyphLoader  loader )
298  {
299    FT_GlyphLoad  base    = &loader->base;
300    FT_GlyphLoad  current = &loader->current;
301
302    FT_UInt       n_curr_contours = current->outline.n_contours;
303    FT_UInt       n_base_points   = base->outline.n_points;
304    FT_UInt       n;
305
306
307    base->outline.n_points =
308      (short)( base->outline.n_points + current->outline.n_points );
309    base->outline.n_contours =
310      (short)( base->outline.n_contours + current->outline.n_contours );
311
312    base->num_subglyphs += current->num_subglyphs;
313
314    /* adjust contours count in newest outline */
315    for ( n = 0; n < n_curr_contours; n++ )
316      current->outline.contours[n] =
317        (short)( current->outline.contours[n] + n_base_points );
318
319    /* prepare for another new glyph image */
320    FT_GlyphLoader_Prepare( loader );
321  }
322
323
324  FT_BASE_DEF( FT_Error )
325  FT_GlyphLoader_CopyPoints( FT_GlyphLoader  target,
326                             FT_GlyphLoader  source )
327  {
328    FT_Error  error;
329    FT_UInt   num_points   = source->base.outline.n_points;
330    FT_UInt   num_contours = source->base.outline.n_contours;
331
332
333    error = FT_GlyphLoader_CheckPoints( target, num_points, num_contours );
334    if ( !error )
335    {
336      FT_Outline*  out = &target->base.outline;
337      FT_Outline*  in  = &source->base.outline;
338
339
340      FT_ARRAY_COPY( out->points, in->points,
341                     num_points );
342      FT_ARRAY_COPY( out->tags, in->tags,
343                     num_points );
344      FT_ARRAY_COPY( out->contours, in->contours,
345                     num_contours );
346
347      /* do we need to copy the extra points? */
348      if ( target->use_extra && source->use_extra )
349        FT_ARRAY_COPY( target->base.extra_points, source->base.extra_points,
350                       num_points );
351
352      out->n_points   = (short)num_points;
353      out->n_contours = (short)num_contours;
354
355      FT_GlyphLoader_Adjust_Points( target );
356    }
357
358    return error;
359  }
360
361
362/* END */
Note: See TracBrowser for help on using the repository browser.