third_party/freetype/include/internal/ftobjs.h - Issue 1413673003: Update bundled freetype to 2.6.1

Side by Side Diff: third_party/freetype/include/internal/ftobjs.h

Issue 1413673003: Update bundled freetype to 2.6.1 (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master

Patch Set: DEPS for corpus Created 5 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 /***************************************************************************/

2 /* */

3 /* ftobjs.h */

4 /* */

5 /* The FreeType private base classes (specification). */

6 /* */

7 /* Copyright 1996-2006, 2008, 2010, 2012-2013 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 /*************************************************************************/

20 /* */

21 /* This file contains the definition of all internal FreeType classes. */

22 /* */

23 /*************************************************************************/

24

25

26 #ifndef __FTOBJS_H__

27 #define __FTOBJS_H__

28

29 #include <ft2build.h>

30 #include FT_RENDER_H

31 #include FT_SIZES_H

32 #include FT_LCD_FILTER_H

33 #include FT_INTERNAL_MEMORY_H

34 #include FT_INTERNAL_GLYPH_LOADER_H

35 #include FT_INTERNAL_DRIVER_H

36 #include FT_INTERNAL_AUTOHINT_H

37 #include FT_INTERNAL_SERVICE_H

38 #include FT_INTERNAL_PIC_H

39

40 #ifdef FT_CONFIG_OPTION_INCREMENTAL

41 #include FT_INCREMENTAL_H

42 #endif

43

44

45 FT_BEGIN_HEADER

46

47

48 /*************************************************************************/

49 /* */

50 /* Some generic definitions. */

51 /* */

52 #ifndef TRUE

53 #define TRUE 1

54 #endif

55

56 #ifndef FALSE

57 #define FALSE 0

58 #endif

59

60 #ifndef NULL

61 #define NULL (void*)0

62 #endif

63

64

65 /*************************************************************************/

66 /* */

67 /* The min and max functions missing in C. As usual, be careful not to */

68 /* write things like FT_MIN( a++, b++ ) to avoid side effects. */

69 /* */

70 #define FT_MIN( a, b ) ( (a) < (b) ? (a) : (b) )

71 #define FT_MAX( a, b ) ( (a) > (b) ? (a) : (b) )

72

73 #define FT_ABS( a ) ( (a) < 0 ? -(a) : (a) )

74

75 /*

76 * Approximate sqrt(xx+yy) using the `alpha max plus beta min'

77 * algorithm. We use alpha = 1, beta = 3/8, giving us results with a

78 * largest error less than 7% compared to the exact value.

79 */

80 #define FT_HYPOT( x, y ) \

81 ( x = FT_ABS( x ), \

82 y = FT_ABS( y ), \

83 x > y ? x + ( 3 * y >> 3 ) \

84 : y + ( 3 * x >> 3 ) )

85

86 #define FT_PAD_FLOOR( x, n ) ( (x) & ~((n)-1) )

87 #define FT_PAD_ROUND( x, n ) FT_PAD_FLOOR( (x) + ((n)/2), n )

88 #define FT_PAD_CEIL( x, n ) FT_PAD_FLOOR( (x) + ((n)-1), n )

89

90 #define FT_PIX_FLOOR( x ) ( (x) & ~63 )

91 #define FT_PIX_ROUND( x ) FT_PIX_FLOOR( (x) + 32 )

92 #define FT_PIX_CEIL( x ) FT_PIX_FLOOR( (x) + 63 )

93

94

95 /*

96 * character classification functions -- since these are used to parse

97 * font files, we must not use those in <ctypes.h> which are

98 * locale-dependent

99 */

100 #define ft_isdigit( x ) ( ( (unsigned)(x) - '0' ) < 10U )

101

102 #define ft_isxdigit( x ) ( ( (unsigned)(x) - '0' ) < 10U \|\| \

103 ( (unsigned)(x) - 'a' ) < 6U \|\| \

104 ( (unsigned)(x) - 'A' ) < 6U )

105

106 /* the next two macros assume ASCII representation */

107 #define ft_isupper( x ) ( ( (unsigned)(x) - 'A' ) < 26U )

108 #define ft_islower( x ) ( ( (unsigned)(x) - 'a' ) < 26U )

109

110 #define ft_isalpha( x ) ( ft_isupper( x ) \|\| ft_islower( x ) )

111 #define ft_isalnum( x ) ( ft_isdigit( x ) \|\| ft_isalpha( x ) )

112

113

114 /*************************************************************************/

115 /*************************************************************************/

116 /*************************************************************************/

117 /** **/

118 /** **/

119 /** C H A R M A P S **/

120 /** **/

121 /** **/

122 /*************************************************************************/

123 /*************************************************************************/

124 /*************************************************************************/

125

126 /* handle to internal charmap object */

127 typedef struct FT_CMapRec_* FT_CMap;

128

129 /* handle to charmap class structure */

130 typedef const struct FT_CMap_ClassRec_* FT_CMap_Class;

131

132 /* internal charmap object structure */

133 typedef struct FT_CMapRec_

134 {

135 FT_CharMapRec charmap;

136 FT_CMap_Class clazz;

137

138 } FT_CMapRec;

139

140 /* typecase any pointer to a charmap handle */

141 #define FT_CMAP( x ) ((FT_CMap)( x ))

142

143 /* obvious macros */

144 #define FT_CMAP_PLATFORM_ID( x ) FT_CMAP( x )->charmap.platform_id

145 #define FT_CMAP_ENCODING_ID( x ) FT_CMAP( x )->charmap.encoding_id

146 #define FT_CMAP_ENCODING( x ) FT_CMAP( x )->charmap.encoding

147 #define FT_CMAP_FACE( x ) FT_CMAP( x )->charmap.face

148

149

150 /* class method definitions */

151 typedef FT_Error

152 (*FT_CMap_InitFunc)( FT_CMap cmap,

153 FT_Pointer init_data );

154

155 typedef void

156 (*FT_CMap_DoneFunc)( FT_CMap cmap );

157

158 typedef FT_UInt

159 (*FT_CMap_CharIndexFunc)( FT_CMap cmap,

160 FT_UInt32 char_code );

161

162 typedef FT_UInt

163 (*FT_CMap_CharNextFunc)( FT_CMap cmap,

164 FT_UInt32 *achar_code );

165

166 typedef FT_UInt

167 (*FT_CMap_CharVarIndexFunc)( FT_CMap cmap,

168 FT_CMap unicode_cmap,

169 FT_UInt32 char_code,

170 FT_UInt32 variant_selector );

171

172 typedef FT_Bool

173 (*FT_CMap_CharVarIsDefaultFunc)( FT_CMap cmap,

174 FT_UInt32 char_code,

175 FT_UInt32 variant_selector );

176

177 typedef FT_UInt32 *

178 (*FT_CMap_VariantListFunc)( FT_CMap cmap,

179 FT_Memory mem );

180

181 typedef FT_UInt32 *

182 (*FT_CMap_CharVariantListFunc)( FT_CMap cmap,

183 FT_Memory mem,

184 FT_UInt32 char_code );

185

186 typedef FT_UInt32 *

187 (*FT_CMap_VariantCharListFunc)( FT_CMap cmap,

188 FT_Memory mem,

189 FT_UInt32 variant_selector );

190

191

192 typedef struct FT_CMap_ClassRec_

193 {

194 FT_ULong size;

195 FT_CMap_InitFunc init;

196 FT_CMap_DoneFunc done;

197 FT_CMap_CharIndexFunc char_index;

198 FT_CMap_CharNextFunc char_next;

199

200 /* Subsequent entries are special ones for format 14 -- the variant */

201 /* selector subtable which behaves like no other */

202

203 FT_CMap_CharVarIndexFunc char_var_index;

204 FT_CMap_CharVarIsDefaultFunc char_var_default;

205 FT_CMap_VariantListFunc variant_list;

206 FT_CMap_CharVariantListFunc charvariant_list;

207 FT_CMap_VariantCharListFunc variantchar_list;

208

209 } FT_CMap_ClassRec;

210

211

212 #ifndef FT_CONFIG_OPTION_PIC

213

214 #define FT_DECLARE_CMAP_CLASS( class_ ) \

215 FT_CALLBACK_TABLE const FT_CMap_ClassRec class_;

216

217 #define FT_DEFINE_CMAP_CLASS( \

218 class_, \

219 size_, \

220 init_, \

221 done_, \

222 char_index_, \

223 char_next_, \

224 char_var_index_, \

225 char_var_default_, \

226 variant_list_, \

227 charvariant_list_, \

228 variantchar_list_ ) \

229 FT_CALLBACK_TABLE_DEF \

230 const FT_CMap_ClassRec class_ = \

231 { \

232 size_, \

233 init_, \

234 done_, \

235 char_index_, \

236 char_next_, \

237 char_var_index_, \

238 char_var_default_, \

239 variant_list_, \

240 charvariant_list_, \

241 variantchar_list_ \

242 };

243

244 #else /* FT_CONFIG_OPTION_PIC */

245

246 #define FT_DECLARE_CMAP_CLASS( class_ ) \

247 void \

248 FT_Init_Class_ ## class_( FT_Library library, \

249 FT_CMap_ClassRec* clazz );

250

251 #define FT_DEFINE_CMAP_CLASS( \

252 class_, \

253 size_, \

254 init_, \

255 done_, \

256 char_index_, \

257 char_next_, \

258 char_var_index_, \

259 char_var_default_, \

260 variant_list_, \

261 charvariant_list_, \

262 variantchar_list_ ) \

263 void \

264 FT_Init_Class_ ## class_( FT_Library library, \

265 FT_CMap_ClassRec* clazz ) \

266 { \

267 FT_UNUSED( library ); \

268 \

269 clazz->size = size_; \

270 clazz->init = init_; \

271 clazz->done = done_; \

272 clazz->char_index = char_index_; \

273 clazz->char_next = char_next_; \

274 clazz->char_var_index = char_var_index_; \

275 clazz->char_var_default = char_var_default_; \

276 clazz->variant_list = variant_list_; \

277 clazz->charvariant_list = charvariant_list_; \

278 clazz->variantchar_list = variantchar_list_; \

279 }

280

281 #endif /* FT_CONFIG_OPTION_PIC */

282

283

284 /* create a new charmap and add it to charmap->face */

285 FT_BASE( FT_Error )

286 FT_CMap_New( FT_CMap_Class clazz,

287 FT_Pointer init_data,

288 FT_CharMap charmap,

289 FT_CMap *acmap );

290

291 /* destroy a charmap and remove it from face's list */

292 FT_BASE( void )

293 FT_CMap_Done( FT_CMap cmap );

294

295

296 /*************************************************************************/

297 /* */

298 /* <Struct> */

299 /* FT_Face_InternalRec */

300 /* */

301 /* <Description> */

302 /* This structure contains the internal fields of each FT_Face */

303 /* object. These fields may change between different releases of */

304 /* FreeType. */

305 /* */

306 /* <Fields> */

307 /* max_points :: */

308 /* The maximum number of points used to store the vectorial outline */

309 /* of any glyph in this face. If this value cannot be known in */

310 /* advance, or if the face isn't scalable, this should be set to 0. */

311 /* Only relevant for scalable formats. */

312 /* */

313 /* max_contours :: */

314 /* The maximum number of contours used to store the vectorial */

315 /* outline of any glyph in this face. If this value cannot be */

316 /* known in advance, or if the face isn't scalable, this should be */

317 /* set to 0. Only relevant for scalable formats. */

318 /* */

319 /* transform_matrix :: */

320 /* A 2x2 matrix of 16.16 coefficients used to transform glyph */

321 /* outlines after they are loaded from the font. Only used by the */

322 /* convenience functions. */

323 /* */

324 /* transform_delta :: */

325 /* A translation vector used to transform glyph outlines after they */

326 /* are loaded from the font. Only used by the convenience */

327 /* functions. */

328 /* */

329 /* transform_flags :: */

330 /* Some flags used to classify the transform. Only used by the */

331 /* convenience functions. */

332 /* */

333 /* services :: */

334 /* A cache for frequently used services. It should be only */

335 /* accessed with the macro `FT_FACE_LOOKUP_SERVICE'. */

336 /* */

337 /* incremental_interface :: */

338 /* If non-null, the interface through which glyph data and metrics */

339 /* are loaded incrementally for faces that do not provide all of */

340 /* this data when first opened. This field exists only if */

341 /* @FT_CONFIG_OPTION_INCREMENTAL is defined. */

342 /* */

343 /* ignore_unpatented_hinter :: */

344 /* This boolean flag instructs the glyph loader to ignore the */

345 /* native font hinter, if one is found. This is exclusively used */

346 /* in the case when the unpatented hinter is compiled within the */

347 /* library. */

348 /* */

349 /* refcount :: */

350 /* A counter initialized to~1 at the time an @FT_Face structure is */

351 /* created. @FT_Reference_Face increments this counter, and */

352 /* @FT_Done_Face only destroys a face if the counter is~1, */

353 /* otherwise it simply decrements it. */

354 /* */

355 typedef struct FT_Face_InternalRec_

356 {

357 FT_Matrix transform_matrix;

358 FT_Vector transform_delta;

359 FT_Int transform_flags;

360

361 FT_ServiceCacheRec services;

362

363 #ifdef FT_CONFIG_OPTION_INCREMENTAL

364 FT_Incremental_InterfaceRec* incremental_interface;

365 #endif

366

367 FT_Bool ignore_unpatented_hinter;

368 FT_Int refcount;

369

370 } FT_Face_InternalRec;

371

372

373 /*************************************************************************/

374 /* */

375 /* <Struct> */

376 /* FT_Slot_InternalRec */

377 /* */

378 /* <Description> */

379 /* This structure contains the internal fields of each FT_GlyphSlot */

380 /* object. These fields may change between different releases of */

381 /* FreeType. */

382 /* */

383 /* <Fields> */

384 /* loader :: The glyph loader object used to load outlines */

385 /* into the glyph slot. */

386 /* */

387 /* flags :: Possible values are zero or */

388 /* FT_GLYPH_OWN_BITMAP. The latter indicates */

389 /* that the FT_GlyphSlot structure owns the */

390 /* bitmap buffer. */

391 /* */

392 /* glyph_transformed :: Boolean. Set to TRUE when the loaded glyph */

393 /* must be transformed through a specific */

394 /* font transformation. This is _not_ the same */

395 /* as the face transform set through */

396 /* FT_Set_Transform(). */

397 /* */

398 /* glyph_matrix :: The 2x2 matrix corresponding to the glyph */

399 /* transformation, if necessary. */

400 /* */

401 /* glyph_delta :: The 2d translation vector corresponding to */

402 /* the glyph transformation, if necessary. */

403 /* */

404 /* glyph_hints :: Format-specific glyph hints management. */

405 /* */

406

407 #define FT_GLYPH_OWN_BITMAP 0x1

408

409 typedef struct FT_Slot_InternalRec_

410 {

411 FT_GlyphLoader loader;

412 FT_UInt flags;

413 FT_Bool glyph_transformed;

414 FT_Matrix glyph_matrix;

415 FT_Vector glyph_delta;

416 void* glyph_hints;

417

418 } FT_GlyphSlot_InternalRec;

419

420

421 #if 0

422

423 /*************************************************************************/

424 /* */

425 /* <Struct> */

426 /* FT_Size_InternalRec */

427 /* */

428 /* <Description> */

429 /* This structure contains the internal fields of each FT_Size */

430 /* object. Currently, it's empty. */

431 /* */

432 /*************************************************************************/

433

434 typedef struct FT_Size_InternalRec_

435 {

436 /* empty */

437

438 } FT_Size_InternalRec;

439

440 #endif

441

442

443 /*************************************************************************/

444 /*************************************************************************/

445 /*************************************************************************/

446 /** **/

447 /** **/

448 /** M O D U L E S **/

449 /** **/

450 /** **/

451 /*************************************************************************/

452 /*************************************************************************/

453 /*************************************************************************/

454

455

456 /*************************************************************************/

457 /* */

458 /* <Struct> */

459 /* FT_ModuleRec */

460 /* */

461 /* <Description> */

462 /* A module object instance. */

463 /* */

464 /* <Fields> */

465 /* clazz :: A pointer to the module's class. */

466 /* */

467 /* library :: A handle to the parent library object. */

468 /* */

469 /* memory :: A handle to the memory manager. */

470 /* */

471 typedef struct FT_ModuleRec_

472 {

473 FT_Module_Class* clazz;

474 FT_Library library;

475 FT_Memory memory;

476

477 } FT_ModuleRec;

478

479

480 /* typecast an object to an FT_Module */

481 #define FT_MODULE( x ) ((FT_Module)( x ))

482 #define FT_MODULE_CLASS( x ) FT_MODULE( x )->clazz

483 #define FT_MODULE_LIBRARY( x ) FT_MODULE( x )->library

484 #define FT_MODULE_MEMORY( x ) FT_MODULE( x )->memory

485

486

487 #define FT_MODULE_IS_DRIVER( x ) ( FT_MODULE_CLASS( x )->module_flags & \

488 FT_MODULE_FONT_DRIVER )

489

490 #define FT_MODULE_IS_RENDERER( x ) ( FT_MODULE_CLASS( x )->module_flags & \

491 FT_MODULE_RENDERER )

492

493 #define FT_MODULE_IS_HINTER( x ) ( FT_MODULE_CLASS( x )->module_flags & \

494 FT_MODULE_HINTER )

495

496 #define FT_MODULE_IS_STYLER( x ) ( FT_MODULE_CLASS( x )->module_flags & \

497 FT_MODULE_STYLER )

498

499 #define FT_DRIVER_IS_SCALABLE( x ) ( FT_MODULE_CLASS( x )->module_flags & \

500 FT_MODULE_DRIVER_SCALABLE )

501

502 #define FT_DRIVER_USES_OUTLINES( x ) !( FT_MODULE_CLASS( x )->module_flags & \

503 FT_MODULE_DRIVER_NO_OUTLINES )

504

505 #define FT_DRIVER_HAS_HINTER( x ) ( FT_MODULE_CLASS( x )->module_flags & \

506 FT_MODULE_DRIVER_HAS_HINTER )

507

508

509 /*************************************************************************/

510 /* */

511 /* <Function> */

512 /* FT_Get_Module_Interface */

513 /* */

514 /* <Description> */

515 /* Finds a module and returns its specific interface as a typeless */

516 /* pointer. */

517 /* */

518 /* <Input> */

519 /* library :: A handle to the library object. */

520 /* */

521 /* module_name :: The module's name (as an ASCII string). */

522 /* */

523 /* <Return> */

524 /* A module-specific interface if available, 0 otherwise. */

525 /* */

526 /* <Note> */

527 /* You should better be familiar with FreeType internals to know */

528 /* which module to look for, and what its interface is :-) */

529 /* */

530 FT_BASE( const void* )

531 FT_Get_Module_Interface( FT_Library library,

532 const char* mod_name );

533

534 FT_BASE( FT_Pointer )

535 ft_module_get_service( FT_Module module,

536 const char* service_id );

537

538 /* */

539

540

541 /*************************************************************************/

542 /*************************************************************************/

543 /*************************************************************************/

544 /** **/

545 /** **/

546 /** F A C E, S I Z E & G L Y P H S L O T O B J E C T S **/

547 /** **/

548 /** **/

549 /*************************************************************************/

550 /*************************************************************************/

551 /*************************************************************************/

552

553 /* a few macros used to perform easy typecasts with minimal brain damage */

554

555 #define FT_FACE( x ) ((FT_Face)(x))

556 #define FT_SIZE( x ) ((FT_Size)(x))

557 #define FT_SLOT( x ) ((FT_GlyphSlot)(x))

558

559 #define FT_FACE_DRIVER( x ) FT_FACE( x )->driver

560 #define FT_FACE_LIBRARY( x ) FT_FACE_DRIVER( x )->root.library

561 #define FT_FACE_MEMORY( x ) FT_FACE( x )->memory

562 #define FT_FACE_STREAM( x ) FT_FACE( x )->stream

563

564 #define FT_SIZE_FACE( x ) FT_SIZE( x )->face

565 #define FT_SLOT_FACE( x ) FT_SLOT( x )->face

566

567 #define FT_FACE_SLOT( x ) FT_FACE( x )->glyph

568 #define FT_FACE_SIZE( x ) FT_FACE( x )->size

569

570

571 /*************************************************************************/

572 /* */

573 /* <Function> */

574 /* FT_New_GlyphSlot */

575 /* */

576 /* <Description> */

577 /* It is sometimes useful to have more than one glyph slot for a */

578 /* given face object. This function is used to create additional */

579 /* slots. All of them are automatically discarded when the face is */

580 /* destroyed. */

581 /* */

582 /* <Input> */

583 /* face :: A handle to a parent face object. */

584 /* */

585 /* <Output> */

586 /* aslot :: A handle to a new glyph slot object. */

587 /* */

588 /* <Return> */

589 /* FreeType error code. 0 means success. */

590 /* */

591 FT_BASE( FT_Error )

592 FT_New_GlyphSlot( FT_Face face,

593 FT_GlyphSlot *aslot );

594

595

596 /*************************************************************************/

597 /* */

598 /* <Function> */

599 /* FT_Done_GlyphSlot */

600 /* */

601 /* <Description> */

602 /* Destroys a given glyph slot. Remember however that all slots are */

603 /* automatically destroyed with its parent. Using this function is */

604 /* not always mandatory. */

605 /* */

606 /* <Input> */

607 /* slot :: A handle to a target glyph slot. */

608 /* */

609 FT_BASE( void )

610 FT_Done_GlyphSlot( FT_GlyphSlot slot );

611

612 /* */

613

614 #define FT_REQUEST_WIDTH( req ) \

615 ( (req)->horiResolution \

616 ? (FT_Pos)( (req)->width * (req)->horiResolution + 36 ) / 72 \

617 : (req)->width )

618

619 #define FT_REQUEST_HEIGHT( req ) \

620 ( (req)->vertResolution \

621 ? (FT_Pos)( (req)->height * (req)->vertResolution + 36 ) / 72 \

622 : (req)->height )

623

624

625 /* Set the metrics according to a bitmap strike. */

626 FT_BASE( void )

627 FT_Select_Metrics( FT_Face face,

628 FT_ULong strike_index );

629

630

631 /* Set the metrics according to a size request. */

632 FT_BASE( void )

633 FT_Request_Metrics( FT_Face face,

634 FT_Size_Request req );

635

636

637 /* Match a size request against `available_sizes'. */

638 FT_BASE( FT_Error )

639 FT_Match_Size( FT_Face face,

640 FT_Size_Request req,

641 FT_Bool ignore_width,

642 FT_ULong* size_index );

643

644

645 /* Use the horizontal metrics to synthesize the vertical metrics. */

646 /* If `advance' is zero, it is also synthesized. */

647 FT_BASE( void )

648 ft_synthesize_vertical_metrics( FT_Glyph_Metrics* metrics,

649 FT_Pos advance );

650

651

652 /* Free the bitmap of a given glyphslot when needed (i.e., only when it */

653 /* was allocated with ft_glyphslot_alloc_bitmap). */

654 FT_BASE( void )

655 ft_glyphslot_free_bitmap( FT_GlyphSlot slot );

656

657

658 /* Allocate a new bitmap buffer in a glyph slot. */

659 FT_BASE( FT_Error )

660 ft_glyphslot_alloc_bitmap( FT_GlyphSlot slot,

661 FT_ULong size );

662

663

664 /* Set the bitmap buffer in a glyph slot to a given pointer. The buffer */

665 /* will not be freed by a later call to ft_glyphslot_free_bitmap. */

666 FT_BASE( void )

667 ft_glyphslot_set_bitmap( FT_GlyphSlot slot,

668 FT_Byte* buffer );

669

670

671 /*************************************************************************/

672 /*************************************************************************/

673 /*************************************************************************/

674 /** **/

675 /** **/

676 /** R E N D E R E R S **/

677 /** **/

678 /** **/

679 /*************************************************************************/

680 /*************************************************************************/

681 /*************************************************************************/

682

683

684 #define FT_RENDERER( x ) ((FT_Renderer)( x ))

685 #define FT_GLYPH( x ) ((FT_Glyph)( x ))

686 #define FT_BITMAP_GLYPH( x ) ((FT_BitmapGlyph)( x ))

687 #define FT_OUTLINE_GLYPH( x ) ((FT_OutlineGlyph)( x ))

688

689

690 typedef struct FT_RendererRec_

691 {

692 FT_ModuleRec root;

693 FT_Renderer_Class* clazz;

694 FT_Glyph_Format glyph_format;

695 FT_Glyph_Class glyph_class;

696

697 FT_Raster raster;

698 FT_Raster_Render_Func raster_render;

699 FT_Renderer_RenderFunc render;

700

701 } FT_RendererRec;

702

703

704 /*************************************************************************/

705 /*************************************************************************/

706 /*************************************************************************/

707 /** **/

708 /** **/

709 /** F O N T D R I V E R S **/

710 /** **/

711 /** **/

712 /*************************************************************************/

713 /*************************************************************************/

714 /*************************************************************************/

715

716

717 /* typecast a module into a driver easily */

718 #define FT_DRIVER( x ) ((FT_Driver)(x))

719

720 /* typecast a module as a driver, and get its driver class */

721 #define FT_DRIVER_CLASS( x ) FT_DRIVER( x )->clazz

722

723

724 /*************************************************************************/

725 /* */

726 /* <Struct> */

727 /* FT_DriverRec */

728 /* */

729 /* <Description> */

730 /* The root font driver class. A font driver is responsible for */

731 /* managing and loading font files of a given format. */

732 /* */

733 /* <Fields> */

734 /* root :: Contains the fields of the root module class. */

735 /* */

736 /* clazz :: A pointer to the font driver's class. Note that */

737 /* this is NOT root.clazz. `class' wasn't used */

738 /* as it is a reserved word in C++. */

739 /* */

740 /* faces_list :: The list of faces currently opened by this */

741 /* driver. */

742 /* */

743 /* glyph_loader :: The glyph loader for all faces managed by this */

744 /* driver. This object isn't defined for unscalable */

745 /* formats. */

746 /* */

747 typedef struct FT_DriverRec_

748 {

749 FT_ModuleRec root;

750 FT_Driver_Class clazz;

751 FT_ListRec faces_list;

752 FT_GlyphLoader glyph_loader;

753

754 } FT_DriverRec;

755

756

757 /*************************************************************************/

758 /*************************************************************************/

759 /*************************************************************************/

760 /** **/

761 /** **/

762 /** L I B R A R I E S **/

763 /** **/

764 /** **/

765 /*************************************************************************/

766 /*************************************************************************/

767 /*************************************************************************/

768

769

770 /* This hook is used by the TrueType debugger. It must be set to an */

771 /* alternate truetype bytecode interpreter function. */

772 #define FT_DEBUG_HOOK_TRUETYPE 0

773

774

775 /* Set this debug hook to a non-null pointer to force unpatented hinting */

776 /* for all faces when both TT_USE_BYTECODE_INTERPRETER and */

777 /* TT_CONFIG_OPTION_UNPATENTED_HINTING are defined. This is only used */

778 /* during debugging. */

779 #define FT_DEBUG_HOOK_UNPATENTED_HINTING 1

780

781

782 typedef void (FT_Bitmap_LcdFilterFunc)( FT_Bitmap bitmap,

783 FT_Render_Mode render_mode,

784 FT_Library library );

785

786

787 /*************************************************************************/

788 /* */

789 /* <Struct> */

790 /* FT_LibraryRec */

791 /* */

792 /* <Description> */

793 /* The FreeType library class. This is the root of all FreeType */

794 /* data. Use FT_New_Library() to create a library object, and */

795 /* FT_Done_Library() to discard it and all child objects. */

796 /* */

797 /* <Fields> */

798 /* memory :: The library's memory object. Manages memory */

799 /* allocation. */

800 /* */

801 /* version_major :: The major version number of the library. */

802 /* */

803 /* version_minor :: The minor version number of the library. */

804 /* */

805 /* version_patch :: The current patch level of the library. */

806 /* */

807 /* num_modules :: The number of modules currently registered */

808 /* within this library. This is set to 0 for new */

809 /* libraries. New modules are added through the */

810 /* FT_Add_Module() API function. */

811 /* */

812 /* modules :: A table used to store handles to the currently */

813 /* registered modules. Note that each font driver */

814 /* contains a list of its opened faces. */

815 /* */

816 /* renderers :: The list of renderers currently registered */

817 /* within the library. */

818 /* */

819 /* cur_renderer :: The current outline renderer. This is a */

820 /* shortcut used to avoid parsing the list on */

821 /* each call to FT_Outline_Render(). It is a */

822 /* handle to the current renderer for the */

823 /* FT_GLYPH_FORMAT_OUTLINE format. */

824 /* */

825 /* auto_hinter :: XXX */

826 /* */

827 /* raster_pool :: The raster object's render pool. This can */

828 /* ideally be changed dynamically at run-time. */

829 /* */

830 /* raster_pool_size :: The size of the render pool in bytes. */

831 /* */

832 /* debug_hooks :: XXX */

833 /* */

834 /* lcd_filter :: If subpixel rendering is activated, the */

835 /* selected LCD filter mode. */

836 /* */

837 /* lcd_extra :: If subpixel rendering is activated, the number */

838 /* of extra pixels needed for the LCD filter. */

839 /* */

840 /* lcd_weights :: If subpixel rendering is activated, the LCD */

841 /* filter weights, if any. */

842 /* */

843 /* lcd_filter_func :: If subpixel rendering is activated, the LCD */

844 /* filtering callback function. */

845 /* */

846 /* pic_container :: Contains global structs and tables, instead */

847 /* of defining them globallly. */

848 /* */

849 /* refcount :: A counter initialized to~1 at the time an */

850 /* @FT_Library structure is created. */

851 /* @FT_Reference_Library increments this counter, */

852 /* and @FT_Done_Library only destroys a library */

853 /* if the counter is~1, otherwise it simply */

854 /* decrements it. */

855 /* */

856 typedef struct FT_LibraryRec_

857 {

858 FT_Memory memory; /* library's memory manager */

859

860 FT_Int version_major;

861 FT_Int version_minor;

862 FT_Int version_patch;

863

864 FT_UInt num_modules;

865 FT_Module modules[FT_MAX_MODULES]; /* module objects */

866

867 FT_ListRec renderers; /* list of renderers */

868 FT_Renderer cur_renderer; /* current outline renderer */

869 FT_Module auto_hinter;

870

871 FT_Byte* raster_pool; /* scan-line conversion */

872 /* render pool */

873 FT_ULong raster_pool_size; /* size of render pool in bytes */

874

875 FT_DebugHook_Func debug_hooks[4];

876

877 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING

878 FT_LcdFilter lcd_filter;

879 FT_Int lcd_extra; /* number of extra pixels */

880 FT_Byte lcd_weights[7]; /* filter weights, if any */

881 FT_Bitmap_LcdFilterFunc lcd_filter_func; /* filtering callback */

882 #endif

883

884 #ifdef FT_CONFIG_OPTION_PIC

885 FT_PIC_Container pic_container;

886 #endif

887

888 FT_Int refcount;

889

890 } FT_LibraryRec;

891

892

893 FT_BASE( FT_Renderer )

894 FT_Lookup_Renderer( FT_Library library,

895 FT_Glyph_Format format,

896 FT_ListNode* node );

897

898 FT_BASE( FT_Error )

899 FT_Render_Glyph_Internal( FT_Library library,

900 FT_GlyphSlot slot,

901 FT_Render_Mode render_mode );

902

903 typedef const char*

904 (*FT_Face_GetPostscriptNameFunc)( FT_Face face );

905

906 typedef FT_Error

907 (*FT_Face_GetGlyphNameFunc)( FT_Face face,

908 FT_UInt glyph_index,

909 FT_Pointer buffer,

910 FT_UInt buffer_max );

911

912 typedef FT_UInt

913 (*FT_Face_GetGlyphNameIndexFunc)( FT_Face face,

914 FT_String* glyph_name );

915

916

917 #ifndef FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM

918

919 /*************************************************************************/

920 /* */

921 /* <Function> */

922 /* FT_New_Memory */

923 /* */

924 /* <Description> */

925 /* Creates a new memory object. */

926 /* */

927 /* <Return> */

928 /* A pointer to the new memory object. 0 in case of error. */

929 /* */

930 FT_BASE( FT_Memory )

931 FT_New_Memory( void );

932

933

934 /*************************************************************************/

935 /* */

936 /* <Function> */

937 /* FT_Done_Memory */

938 /* */

939 /* <Description> */

940 /* Discards memory manager. */

941 /* */

942 /* <Input> */

943 /* memory :: A handle to the memory manager. */

944 /* */

945 FT_BASE( void )

946 FT_Done_Memory( FT_Memory memory );

947

948 #endif /* !FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM */

949

950

951 /* Define default raster's interface. The default raster is located in */

952 /* `src/base/ftraster.c'. */

953 /* */

954 /* Client applications can register new rasters through the */

955 /* FT_Set_Raster() API. */

956

957 #ifndef FT_NO_DEFAULT_RASTER

958 FT_EXPORT_VAR( FT_Raster_Funcs ) ft_default_raster;

959 #endif

960

961

962 /*************************************************************************/

963 /*************************************************************************/

964 /*************************************************************************/

965 /** **/

966 /** **/

967 /** P I C S U P P O R T **/

968 /** **/

969 /** **/

970 /*************************************************************************/

971 /*************************************************************************/

972 /*************************************************************************/

973

974

975 /* PIC support macros for ftimage.h */

976

977

978 /*************************************************************************/

979 /* */

980 /* <Macro> */

981 /* FT_DEFINE_OUTLINE_FUNCS */

982 /* */

983 /* <Description> */

984 /* Used to initialize an instance of FT_Outline_Funcs struct. */

985 /* When FT_CONFIG_OPTION_PIC is defined an init funtion will need to */

986 /* be called with a pre-allocated structure to be filled. */

987 /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */

988 /* allocated in the global scope (or the scope where the macro */

989 /* is used). */

990 /* */

991 #ifndef FT_CONFIG_OPTION_PIC

992

993 #define FT_DEFINE_OUTLINE_FUNCS( \

994 class_, \

995 move_to_, \

996 line_to_, \

997 conic_to_, \

998 cubic_to_, \

999 shift_, \

1000 delta_ ) \

1001 static const FT_Outline_Funcs class_ = \

1002 { \

1003 move_to_, \

1004 line_to_, \

1005 conic_to_, \

1006 cubic_to_, \

1007 shift_, \

1008 delta_ \

1009 };

1010

1011 #else /* FT_CONFIG_OPTION_PIC */

1012

1013 #define FT_DEFINE_OUTLINE_FUNCS( \

1014 class_, \

1015 move_to_, \

1016 line_to_, \

1017 conic_to_, \

1018 cubic_to_, \

1019 shift_, \

1020 delta_ ) \

1021 static FT_Error \

1022 Init_Class_ ## class_( FT_Outline_Funcs* clazz ) \

1023 { \

1024 clazz->move_to = move_to_; \

1025 clazz->line_to = line_to_; \

1026 clazz->conic_to = conic_to_; \

1027 clazz->cubic_to = cubic_to_; \

1028 clazz->shift = shift_; \

1029 clazz->delta = delta_; \

1030 \

1031 return FT_Err_Ok; \

1032 }

1033

1034 #endif /* FT_CONFIG_OPTION_PIC */

1035

1036

1037 /*************************************************************************/

1038 /* */

1039 /* <Macro> */

1040 /* FT_DEFINE_RASTER_FUNCS */

1041 /* */

1042 /* <Description> */

1043 /* Used to initialize an instance of FT_Raster_Funcs struct. */

1044 /* When FT_CONFIG_OPTION_PIC is defined an init funtion will need to */

1045 /* be called with a pre-allocated structure to be filled. */

1046 /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */

1047 /* allocated in the global scope (or the scope where the macro */

1048 /* is used). */

1049 /* */

1050 #ifndef FT_CONFIG_OPTION_PIC

1051

1052 #define FT_DEFINE_RASTER_FUNCS( \

1053 class_, \

1054 glyph_format_, \

1055 raster_new_, \

1056 raster_reset_, \

1057 raster_set_mode_, \

1058 raster_render_, \

1059 raster_done_ ) \

1060 const FT_Raster_Funcs class_ = \

1061 { \

1062 glyph_format_, \

1063 raster_new_, \

1064 raster_reset_, \

1065 raster_set_mode_, \

1066 raster_render_, \

1067 raster_done_ \

1068 };

1069

1070 #else /* FT_CONFIG_OPTION_PIC */

1071

1072 #define FT_DEFINE_RASTER_FUNCS( \

1073 class_, \

1074 glyph_format_, \

1075 raster_new_, \

1076 raster_reset_, \

1077 raster_set_mode_, \

1078 raster_render_, \

1079 raster_done_ ) \

1080 void \

1081 FT_Init_Class_ ## class_( FT_Raster_Funcs* clazz ) \

1082 { \

1083 clazz->glyph_format = glyph_format_; \

1084 clazz->raster_new = raster_new_; \

1085 clazz->raster_reset = raster_reset_; \

1086 clazz->raster_set_mode = raster_set_mode_; \

1087 clazz->raster_render = raster_render_; \

1088 clazz->raster_done = raster_done_; \

1089 }

1090

1091 #endif /* FT_CONFIG_OPTION_PIC */

1092

1093

1094 /* PIC support macros for ftrender.h */

1095

1096

1097 /*************************************************************************/

1098 /* */

1099 /* <Macro> */

1100 /* FT_DEFINE_GLYPH */

1101 /* */

1102 /* <Description> */

1103 /* Used to initialize an instance of FT_Glyph_Class struct. */

1104 /* When FT_CONFIG_OPTION_PIC is defined an init funtion will need to */

1105 /* be called with a pre-allocated stcture to be filled. */

1106 /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */

1107 /* allocated in the global scope (or the scope where the macro */

1108 /* is used). */

1109 /* */

1110 #ifndef FT_CONFIG_OPTION_PIC

1111

1112 #define FT_DEFINE_GLYPH( \

1113 class_, \

1114 size_, \

1115 format_, \

1116 init_, \

1117 done_, \

1118 copy_, \

1119 transform_, \

1120 bbox_, \

1121 prepare_ ) \

1122 FT_CALLBACK_TABLE_DEF \

1123 const FT_Glyph_Class class_ = \

1124 { \

1125 size_, \

1126 format_, \

1127 init_, \

1128 done_, \

1129 copy_, \

1130 transform_, \

1131 bbox_, \

1132 prepare_ \

1133 };

1134

1135 #else /* FT_CONFIG_OPTION_PIC */

1136

1137 #define FT_DEFINE_GLYPH( \

1138 class_, \

1139 size_, \

1140 format_, \

1141 init_, \

1142 done_, \

1143 copy_, \

1144 transform_, \

1145 bbox_, \

1146 prepare_ ) \

1147 void \

1148 FT_Init_Class_ ## class_( FT_Glyph_Class* clazz ) \

1149 { \

1150 clazz->glyph_size = size_; \

1151 clazz->glyph_format = format_; \

1152 clazz->glyph_init = init_; \

1153 clazz->glyph_done = done_; \

1154 clazz->glyph_copy = copy_; \

1155 clazz->glyph_transform = transform_; \

1156 clazz->glyph_bbox = bbox_; \

1157 clazz->glyph_prepare = prepare_; \

1158 }

1159

1160 #endif /* FT_CONFIG_OPTION_PIC */

1161

1162

1163 /*************************************************************************/

1164 /* */

1165 /* <Macro> */

1166 /* FT_DECLARE_RENDERER */

1167 /* */

1168 /* <Description> */

1169 /* Used to create a forward declaration of a */

1170 /* FT_Renderer_Class struct instance. */

1171 /* */

1172 /* <Macro> */

1173 /* FT_DEFINE_RENDERER */

1174 /* */

1175 /* <Description> */

1176 /* Used to initialize an instance of FT_Renderer_Class struct. */

1177 /* */

1178 /* When FT_CONFIG_OPTION_PIC is defined a `create' funtion will need */

1179 /* to be called with a pointer where the allocated structure is */

1180 /* returned. And when it is no longer needed a `destroy' function */

1181 /* needs to be called to release that allocation. */

1182 /* `fcinit.c' (ft_create_default_module_classes) already contains */

1183 /* a mechanism to call these functions for the default modules */

1184 /* described in `ftmodule.h'. */

1185 /* */

1186 /* Notice that the created `create' and `destroy' functions call */

1187 /* `pic_init' and `pic_free' to allow you to manually allocate and */

1188 /* initialize any additional global data, like a module specific */

1189 /* interface, and put them in the global pic container defined in */

1190 /* `ftpic.h'. If you don't need them just implement the functions as */

1191 /* empty to resolve the link error. Also the `pic_init' and */

1192 /* `pic_free' functions should be declared in `pic.h', to be referred */

1193 /* by the renderer definition calling `FT_DEFINE_RENDERER' in the */

1194 /* following. */

1195 /* */

1196 /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */

1197 /* allocated in the global scope (or the scope where the macro */

1198 /* is used). */

1199 /* */

1200 #ifndef FT_CONFIG_OPTION_PIC

1201

1202 #define FT_DECLARE_RENDERER( class_ ) \

1203 FT_EXPORT_VAR( const FT_Renderer_Class ) class_;

1204

1205 #define FT_DEFINE_RENDERER( \

1206 class_, \

1207 flags_, \

1208 size_, \

1209 name_, \

1210 version_, \

1211 requires_, \

1212 interface_, \

1213 init_, \

1214 done_, \

1215 get_interface_, \

1216 glyph_format_, \

1217 render_glyph_, \

1218 transform_glyph_, \

1219 get_glyph_cbox_, \

1220 set_mode_, \

1221 raster_class_ ) \

1222 FT_CALLBACK_TABLE_DEF \

1223 const FT_Renderer_Class class_ = \

1224 { \

1225 FT_DEFINE_ROOT_MODULE( flags_, \

1226 size_, \

1227 name_, \

1228 version_, \

1229 requires_, \

1230 interface_, \

1231 init_, \

1232 done_, \

1233 get_interface_ ) \

1234 glyph_format_, \

1235 \

1236 render_glyph_, \

1237 transform_glyph_, \

1238 get_glyph_cbox_, \

1239 set_mode_, \

1240 \

1241 raster_class_ \

1242 };

1243

1244 #else /* FT_CONFIG_OPTION_PIC */

1245

1246 #define FT_DECLARE_RENDERER( class_ ) FT_DECLARE_MODULE( class_ )

1247

1248 #define FT_DEFINE_RENDERER( \

1249 class_, \

1250 flags_, \

1251 size_, \

1252 name_, \

1253 version_, \

1254 requires_, \

1255 interface_, \

1256 init_, \

1257 done_, \

1258 get_interface_, \

1259 glyph_format_, \

1260 render_glyph_, \

1261 transform_glyph_, \

1262 get_glyph_cbox_, \

1263 set_mode_, \

1264 raster_class_ ) \

1265 void \

1266 FT_Destroy_Class_ ## class_( FT_Library library, \

1267 FT_Module_Class* clazz ) \

1268 { \

1269 FT_Renderer_Class* rclazz = (FT_Renderer_Class*)clazz; \

1270 FT_Memory memory = library->memory; \

1271 \

1272 \

1273 class_ ## _pic_free( library ); \

1274 if ( rclazz ) \

1275 FT_FREE( rclazz ); \

1276 } \

1277 \

1278 \

1279 FT_Error \

1280 FT_Create_Class_ ## class_( FT_Library library, \

1281 FT_Module_Class** output_class ) \

1282 { \

1283 FT_Renderer_Class* clazz = NULL; \

1284 FT_Error error; \

1285 FT_Memory memory = library->memory; \

1286 \

1287 \

1288 if ( FT_ALLOC( clazz, sizeof ( *clazz ) ) ) \

1289 return error; \

1290 \

1291 error = class_ ## _pic_init( library ); \

1292 if ( error ) \

1293 { \

1294 FT_FREE( clazz ); \

1295 return error; \

1296 } \

1297 \

1298 FT_DEFINE_ROOT_MODULE( flags_, \

1299 size_, \

1300 name_, \

1301 version_, \

1302 requires_, \

1303 interface_, \

1304 init_, \

1305 done_, \

1306 get_interface_ ) \

1307 \

1308 clazz->glyph_format = glyph_format_; \

1309 \

1310 clazz->render_glyph = render_glyph_; \

1311 clazz->transform_glyph = transform_glyph_; \

1312 clazz->get_glyph_cbox = get_glyph_cbox_; \

1313 clazz->set_mode = set_mode_; \

1314 \

1315 clazz->raster_class = raster_class_; \

1316 \

1317 output_class = (FT_Module_Class)clazz; \

1318 \

1319 return FT_Err_Ok; \

1320 }

1321

1322 #endif /* FT_CONFIG_OPTION_PIC */

1323

1324

1325 /* PIC support macros for ftmodapi.h **/

1326

1327

1328 #ifdef FT_CONFIG_OPTION_PIC

1329

1330 /*************************************************************************/

1331 /* */

1332 /* <FuncType> */

1333 /* FT_Module_Creator */

1334 /* */

1335 /* <Description> */

1336 /* A function used to create (allocate) a new module class object. */

1337 /* The object's members are initialized, but the module itself is */

1338 /* not. */

1339 /* */

1340 /* <Input> */

1341 /* memory :: A handle to the memory manager. */

1342 /* output_class :: Initialized with the newly allocated class. */

1343 /* */

1344 typedef FT_Error

1345 (*FT_Module_Creator)( FT_Memory memory,

1346 FT_Module_Class** output_class );

1347

1348 /*************************************************************************/

1349 /* */

1350 /* <FuncType> */

1351 /* FT_Module_Destroyer */

1352 /* */

1353 /* <Description> */

1354 /* A function used to destroy (deallocate) a module class object. */

1355 /* */

1356 /* <Input> */

1357 /* memory :: A handle to the memory manager. */

1358 /* clazz :: Module class to destroy. */

1359 /* */

1360 typedef void

1361 (*FT_Module_Destroyer)( FT_Memory memory,

1362 FT_Module_Class* clazz );

1363

1364 #endif

1365

1366

1367 /*************************************************************************/

1368 /* */

1369 /* <Macro> */

1370 /* FT_DECLARE_MODULE */

1371 /* */

1372 /* <Description> */

1373 /* Used to create a forward declaration of a */

1374 /* FT_Module_Class struct instance. */

1375 /* */

1376 /* <Macro> */

1377 /* FT_DEFINE_MODULE */

1378 /* */

1379 /* <Description> */

1380 /* Used to initialize an instance of an FT_Module_Class struct. */

1381 /* */

1382 /* When FT_CONFIG_OPTION_PIC is defined a `create' funtion needs to */

1383 /* be called with a pointer where the allocated structure is */

1384 /* returned. And when it is no longer needed a `destroy' function */

1385 /* needs to be called to release that allocation. */

1386 /* `fcinit.c' (ft_create_default_module_classes) already contains */

1387 /* a mechanism to call these functions for the default modules */

1388 /* described in `ftmodule.h'. */

1389 /* */

1390 /* Notice that the created `create' and `destroy' functions call */

1391 /* `pic_init' and `pic_free' to allow you to manually allocate and */

1392 /* initialize any additional global data, like a module specific */

1393 /* interface, and put them in the global pic container defined in */

1394 /* `ftpic.h'. If you don't need them just implement the functions as */

1395 /* empty to resolve the link error. Also the `pic_init' and */

1396 /* `pic_free' functions should be declared in `pic.h', to be referred */

1397 /* by the module definition calling `FT_DEFINE_MODULE' in the */

1398 /* following. */

1399 /* */

1400 /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */

1401 /* allocated in the global scope (or the scope where the macro */

1402 /* is used). */

1403 /* */

1404 /* <Macro> */

1405 /* FT_DEFINE_ROOT_MODULE */

1406 /* */

1407 /* <Description> */

1408 /* Used to initialize an instance of an FT_Module_Class struct inside */

1409 /* another struct that contains it or in a function that initializes */

1410 /* that containing struct. */

1411 /* */

1412 #ifndef FT_CONFIG_OPTION_PIC

1413

1414 #define FT_DECLARE_MODULE( class_ ) \

1415 FT_CALLBACK_TABLE \

1416 const FT_Module_Class class_;

1417

1418 #define FT_DEFINE_ROOT_MODULE( \

1419 flags_, \

1420 size_, \

1421 name_, \

1422 version_, \

1423 requires_, \

1424 interface_, \

1425 init_, \

1426 done_, \

1427 get_interface_ ) \

1428 { \

1429 flags_, \

1430 size_, \

1431 \

1432 name_, \

1433 version_, \

1434 requires_, \

1435 \

1436 interface_, \

1437 \

1438 init_, \

1439 done_, \

1440 get_interface_, \

1441 },

1442

1443 #define FT_DEFINE_MODULE( \

1444 class_, \

1445 flags_, \

1446 size_, \

1447 name_, \

1448 version_, \

1449 requires_, \

1450 interface_, \

1451 init_, \

1452 done_, \

1453 get_interface_ ) \

1454 FT_CALLBACK_TABLE_DEF \

1455 const FT_Module_Class class_ = \

1456 { \

1457 flags_, \

1458 size_, \

1459 \

1460 name_, \

1461 version_, \

1462 requires_, \

1463 \

1464 interface_, \

1465 \

1466 init_, \

1467 done_, \

1468 get_interface_, \

1469 };

1470

1471

1472 #else /* FT_CONFIG_OPTION_PIC */

1473

1474 #define FT_DECLARE_MODULE( class_ ) \

1475 FT_Error \

1476 FT_Create_Class_ ## class_( FT_Library library, \

1477 FT_Module_Class** output_class ); \

1478 void \

1479 FT_Destroy_Class_ ## class_( FT_Library library, \

1480 FT_Module_Class* clazz );

1481

1482 #define FT_DEFINE_ROOT_MODULE( \

1483 flags_, \

1484 size_, \

1485 name_, \

1486 version_, \

1487 requires_, \

1488 interface_, \

1489 init_, \

1490 done_, \

1491 get_interface_ ) \

1492 clazz->root.module_flags = flags_; \

1493 clazz->root.module_size = size_; \

1494 clazz->root.module_name = name_; \

1495 clazz->root.module_version = version_; \

1496 clazz->root.module_requires = requires_; \

1497 \

1498 clazz->root.module_interface = interface_; \

1499 \

1500 clazz->root.module_init = init_; \

1501 clazz->root.module_done = done_; \

1502 clazz->root.get_interface = get_interface_;

1503

1504 #define FT_DEFINE_MODULE( \

1505 class_, \

1506 flags_, \

1507 size_, \

1508 name_, \

1509 version_, \

1510 requires_, \

1511 interface_, \

1512 init_, \

1513 done_, \

1514 get_interface_ ) \

1515 void \

1516 FT_Destroy_Class_ ## class_( FT_Library library, \

1517 FT_Module_Class* clazz ) \

1518 { \

1519 FT_Memory memory = library->memory; \

1520 \

1521 \

1522 class_ ## _pic_free( library ); \

1523 if ( clazz ) \

1524 FT_FREE( clazz ); \

1525 } \

1526 \

1527 \

1528 FT_Error \

1529 FT_Create_Class_ ## class_( FT_Library library, \

1530 FT_Module_Class** output_class ) \

1531 { \

1532 FT_Memory memory = library->memory; \

1533 FT_Module_Class* clazz = NULL; \

1534 FT_Error error; \

1535 \

1536 \

1537 if ( FT_ALLOC( clazz, sizeof ( *clazz ) ) ) \

1538 return error; \

1539 error = class_ ## _pic_init( library ); \

1540 if ( error ) \

1541 { \

1542 FT_FREE( clazz ); \

1543 return error; \

1544 } \

1545 \

1546 clazz->module_flags = flags_; \

1547 clazz->module_size = size_; \

1548 clazz->module_name = name_; \

1549 clazz->module_version = version_; \

1550 clazz->module_requires = requires_; \

1551 \

1552 clazz->module_interface = interface_; \

1553 \

1554 clazz->module_init = init_; \

1555 clazz->module_done = done_; \

1556 clazz->get_interface = get_interface_; \

1557 \

1558 *output_class = clazz; \

1559 \

1560 return FT_Err_Ok; \

1561 }

1562

1563 #endif /* FT_CONFIG_OPTION_PIC */

1564

1565

1566 FT_END_HEADER

1567

1568 #endif /* __FTOBJS_H__ */

1569

1570

1571 /* END */

OLD	NEW

« no previous file with comments | « third_party/freetype/include/internal/ftmemory.h ('k') | third_party/freetype/include/internal/ftpic.h » ('j') | no next file with comments »