reactos/lib/3rdparty/freetype/src/cff/cffdrivr.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  cffdrivr.c                                                             */
   4 /*                                                                         */
   5 /*    OpenType font driver implementation (body).                          */
   6 /*                                                                         */
   7 /*  Copyright 1996-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 #include <ft2build.h>
  20 #include FT_FREETYPE_H
  21 #include FT_INTERNAL_DEBUG_H
  22 #include FT_INTERNAL_STREAM_H
  23 #include FT_INTERNAL_SFNT_H
  24 #include FT_SERVICE_CID_H
  25 #include FT_SERVICE_POSTSCRIPT_INFO_H
  26 #include FT_SERVICE_POSTSCRIPT_NAME_H
  27 #include FT_SERVICE_TT_CMAP_H
  28
  29 #include "cffdrivr.h"
  30 #include "cffgload.h"
  31 #include "cffload.h"
  32 #include "cffcmap.h"
  33 #include "cffparse.h"
  34
  35 #include "cfferrs.h"
  36 #include "cffpic.h"
  37
  38 #include FT_SERVICE_XFREE86_NAME_H
  39 #include FT_SERVICE_GLYPH_DICT_H
  40 #include FT_SERVICE_PROPERTIES_H
  41 #include FT_CFF_DRIVER_H
  42
  43
  44   /*************************************************************************/
  45   /*                                                                       */
  46   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  47   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  48   /* messages during execution.                                            */
  49   /*                                                                       */
  50 #undef  FT_COMPONENT
  51 #define FT_COMPONENT  trace_cffdriver
  52
  53
  54   /*************************************************************************/
  55   /*************************************************************************/
  56   /*************************************************************************/
  57   /****                                                                 ****/
  58   /****                                                                 ****/
  59   /****                          F A C E S                              ****/
  60   /****                                                                 ****/
  61   /****                                                                 ****/
  62   /*************************************************************************/
  63   /*************************************************************************/
  64   /*************************************************************************/
  65
  66
  67 #undef  PAIR_TAG
  68 #define PAIR_TAG( left, right )  ( ( (FT_ULong)left << 16 ) | \
  69                                      (FT_ULong)right        )
  70
  71
  72   /*************************************************************************/
  73   /*                                                                       */
  74   /* <Function>                                                            */
  75   /*    cff_get_kerning                                                    */
  76   /*                                                                       */
  77   /* <Description>                                                         */
  78   /*    A driver method used to return the kerning vector between two      */
  79   /*    glyphs of the same face.                                           */
  80   /*                                                                       */
  81   /* <Input>                                                               */
  82   /*    face        :: A handle to the source face object.                 */
  83   /*                                                                       */
  84   /*    left_glyph  :: The index of the left glyph in the kern pair.       */
  85   /*                                                                       */
  86   /*    right_glyph :: The index of the right glyph in the kern pair.      */
  87   /*                                                                       */
  88   /* <Output>                                                              */
  89   /*    kerning     :: The kerning vector.  This is in font units for      */
  90   /*                   scalable formats, and in pixels for fixed-sizes     */
  91   /*                   formats.                                            */
  92   /*                                                                       */
  93   /* <Return>                                                              */
  94   /*    FreeType error code.  0 means success.                             */
  95   /*                                                                       */
  96   /* <Note>                                                                */
  97   /*    Only horizontal layouts (left-to-right & right-to-left) are        */
  98   /*    supported by this function.  Other layouts, or more sophisticated  */
  99   /*    kernings, are out of scope of this method (the basic driver        */
 100   /*    interface is meant to be simple).                                  */
 101   /*                                                                       */
 102   /*    They can be implemented by format-specific interfaces.             */
 103   /*                                                                       */
 104   FT_CALLBACK_DEF( FT_Error )
 105   cff_get_kerning( FT_Face     ttface,          /* TT_Face */
 106                    FT_UInt     left_glyph,
 107                    FT_UInt     right_glyph,
 108                    FT_Vector*  kerning )
 109   {
 110     TT_Face       face = (TT_Face)ttface;
 111     SFNT_Service  sfnt = (SFNT_Service)face->sfnt;
 112
 113
 114     kerning->x = 0;
 115     kerning->y = 0;
 116
 117     if ( sfnt )
 118       kerning->x = sfnt->get_kerning( face, left_glyph, right_glyph );
 119
 120     return FT_Err_Ok;
 121   }
 122
 123
 124 #undef PAIR_TAG
 125
 126
 127   /*************************************************************************/
 128   /*                                                                       */
 129   /* <Function>                                                            */
 130   /*    cff_glyph_load                                                     */
 131   /*                                                                       */
 132   /* <Description>                                                         */
 133   /*    A driver method used to load a glyph within a given glyph slot.    */
 134   /*                                                                       */
 135   /* <Input>                                                               */
 136   /*    slot        :: A handle to the target slot object where the glyph  */
 137   /*                   will be loaded.                                     */
 138   /*                                                                       */
 139   /*    size        :: A handle to the source face size at which the glyph */
 140   /*                   must be scaled, loaded, etc.                        */
 141   /*                                                                       */
 142   /*    glyph_index :: The index of the glyph in the font file.            */
 143   /*                                                                       */
 144   /*    load_flags  :: A flag indicating what to load for this glyph.  The */
 145   /*                   FT_LOAD_??? constants can be used to control the    */
 146   /*                   glyph loading process (e.g., whether the outline    */
 147   /*                   should be scaled, whether to load bitmaps or not,   */
 148   /*                   whether to hint the outline, etc).                  */
 149   /*                                                                       */
 150   /* <Return>                                                              */
 151   /*    FreeType error code.  0 means success.                             */
 152   /*                                                                       */
 153   FT_CALLBACK_DEF( FT_Error )
 154   cff_glyph_load( FT_GlyphSlot  cffslot,      /* CFF_GlyphSlot */
 155                   FT_Size       cffsize,      /* CFF_Size      */
 156                   FT_UInt       glyph_index,
 157                   FT_Int32      load_flags )
 158   {
 159     FT_Error       error;
 160     CFF_GlyphSlot  slot = (CFF_GlyphSlot)cffslot;
 161     CFF_Size       size = (CFF_Size)cffsize;
 162
 163
 164     if ( !slot )
 165       return FT_THROW( Invalid_Slot_Handle );
 166
 167     FT_TRACE1(( "cff_glyph_load: glyph index %d\n", glyph_index ));
 168
 169     /* check whether we want a scaled outline or bitmap */
 170     if ( !size )
 171       load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
 172
 173     /* reset the size object if necessary */
 174     if ( load_flags & FT_LOAD_NO_SCALE )
 175       size = NULL;
 176
 177     if ( size )
 178     {
 179       /* these two objects must have the same parent */
 180       if ( cffsize->face != cffslot->face )
 181         return FT_THROW( Invalid_Face_Handle );
 182     }
 183
 184     /* now load the glyph outline if necessary */
 185     error = cff_slot_load( slot, size, glyph_index, load_flags );
 186
 187     /* force drop-out mode to 2 - irrelevant now */
 188     /* slot->outline.dropout_mode = 2; */
 189
 190     return error;
 191   }
 192
 193
 194   FT_CALLBACK_DEF( FT_Error )
 195   cff_get_advances( FT_Face    face,
 196                     FT_UInt    start,
 197                     FT_UInt    count,
 198                     FT_Int32   flags,
 199                     FT_Fixed*  advances )
 200   {
 201     FT_UInt       nn;
 202     FT_Error      error = FT_Err_Ok;
 203     FT_GlyphSlot  slot  = face->glyph;
 204
 205
 206     flags |= (FT_UInt32)FT_LOAD_ADVANCE_ONLY;
 207
 208     for ( nn = 0; nn < count; nn++ )
 209     {
 210       error = cff_glyph_load( slot, face->size, start + nn, flags );
 211       if ( error )
 212         break;
 213
 214       advances[nn] = ( flags & FT_LOAD_VERTICAL_LAYOUT )
 215                      ? slot->linearVertAdvance
 216                      : slot->linearHoriAdvance;
 217     }
 218
 219     return error;
 220   }
 221
 222
 223   /*
 224    *  GLYPH DICT SERVICE
 225    *
 226    */
 227
 228   static FT_Error
 229   cff_get_glyph_name( CFF_Face    face,
 230                       FT_UInt     glyph_index,
 231                       FT_Pointer  buffer,
 232                       FT_UInt     buffer_max )
 233   {
 234     CFF_Font    font   = (CFF_Font)face->extra.data;
 235     FT_String*  gname;
 236     FT_UShort   sid;
 237     FT_Error    error;
 238
 239
 240     if ( !font->psnames )
 241     {
 242       FT_ERROR(( "cff_get_glyph_name:"
 243                  " cannot get glyph name from CFF & CEF fonts\n"
 244                  "                   "
 245                  " without the `PSNames' module\n" ));
 246       error = FT_THROW( Missing_Module );
 247       goto Exit;
 248     }
 249
 250     /* first, locate the sid in the charset table */
 251     sid = font->charset.sids[glyph_index];
 252
 253     /* now, lookup the name itself */
 254     gname = cff_index_get_sid_string( font, sid );
 255
 256     if ( gname )
 257       FT_STRCPYN( buffer, gname, buffer_max );
 258
 259     error = FT_Err_Ok;
 260
 261   Exit:
 262     return error;
 263   }
 264
 265
 266   static FT_UInt
 267   cff_get_name_index( CFF_Face    face,
 268                       FT_String*  glyph_name )
 269   {
 270     CFF_Font            cff;
 271     CFF_Charset         charset;
 272     FT_Service_PsCMaps  psnames;
 273     FT_String*          name;
 274     FT_UShort           sid;
 275     FT_UInt             i;
 276
 277
 278     cff     = (CFF_FontRec *)face->extra.data;
 279     charset = &cff->charset;
 280
 281     FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );
 282     if ( !psnames )
 283       return 0;
 284
 285     for ( i = 0; i < cff->num_glyphs; i++ )
 286     {
 287       sid = charset->sids[i];
 288
 289       if ( sid > 390 )
 290         name = cff_index_get_string( cff, sid - 391 );
 291       else
 292         name = (FT_String *)psnames->adobe_std_strings( sid );
 293
 294       if ( !name )
 295         continue;
 296
 297       if ( !ft_strcmp( glyph_name, name ) )
 298         return i;
 299     }
 300
 301     return 0;
 302   }
 303
 304
 305   FT_DEFINE_SERVICE_GLYPHDICTREC(
 306     cff_service_glyph_dict,
 307     (FT_GlyphDict_GetNameFunc)  cff_get_glyph_name,
 308     (FT_GlyphDict_NameIndexFunc)cff_get_name_index
 309   )
 310
 311
 312   /*
 313    *  POSTSCRIPT INFO SERVICE
 314    *
 315    */
 316
 317   static FT_Int
 318   cff_ps_has_glyph_names( FT_Face  face )
 319   {
 320     return ( face->face_flags & FT_FACE_FLAG_GLYPH_NAMES ) > 0;
 321   }
 322
 323
 324   static FT_Error
 325   cff_ps_get_font_info( CFF_Face         face,
 326                         PS_FontInfoRec*  afont_info )
 327   {
 328     CFF_Font  cff   = (CFF_Font)face->extra.data;
 329     FT_Error  error = FT_Err_Ok;
 330
 331
 332     if ( cff && cff->font_info == NULL )
 333     {
 334       CFF_FontRecDict  dict   = &cff->top_font.font_dict;
 335       PS_FontInfoRec  *font_info = NULL;
 336       FT_Memory        memory = face->root.memory;
 337
 338
 339       if ( FT_ALLOC( font_info, sizeof ( *font_info ) ) )
 340         goto Fail;
 341
 342       font_info->version     = cff_index_get_sid_string( cff,
 343                                                          dict->version );
 344       font_info->notice      = cff_index_get_sid_string( cff,
 345                                                          dict->notice );
 346       font_info->full_name   = cff_index_get_sid_string( cff,
 347                                                          dict->full_name );
 348       font_info->family_name = cff_index_get_sid_string( cff,
 349                                                          dict->family_name );
 350       font_info->weight      = cff_index_get_sid_string( cff,
 351                                                          dict->weight );
 352       font_info->italic_angle        = dict->italic_angle;
 353       font_info->is_fixed_pitch      = dict->is_fixed_pitch;
 354       font_info->underline_position  = (FT_Short)dict->underline_position;
 355       font_info->underline_thickness = (FT_Short)dict->underline_thickness;
 356
 357       cff->font_info = font_info;
 358     }
 359
 360     if ( cff )
 361       *afont_info = *cff->font_info;
 362
 363   Fail:
 364     return error;
 365   }
 366
 367
 368   FT_DEFINE_SERVICE_PSINFOREC(
 369     cff_service_ps_info,
 370     (PS_GetFontInfoFunc)   cff_ps_get_font_info,
 371     (PS_GetFontExtraFunc)  NULL,
 372     (PS_HasGlyphNamesFunc) cff_ps_has_glyph_names,
 373     (PS_GetFontPrivateFunc)NULL,        /* unsupported with CFF fonts */
 374     (PS_GetFontValueFunc)  NULL         /* not implemented            */
 375   )
 376
 377
 378   /*
 379    *  POSTSCRIPT NAME SERVICE
 380    *
 381    */
 382
 383   static const char*
 384   cff_get_ps_name( CFF_Face  face )
 385   {
 386     CFF_Font  cff = (CFF_Font)face->extra.data;
 387
 388
 389     return (const char*)cff->font_name;
 390   }
 391
 392
 393   FT_DEFINE_SERVICE_PSFONTNAMEREC(
 394     cff_service_ps_name,
 395     (FT_PsName_GetFunc)cff_get_ps_name
 396   )
 397
 398
 399   /*
 400    * TT CMAP INFO
 401    *
 402    * If the charmap is a synthetic Unicode encoding cmap or
 403    * a Type 1 standard (or expert) encoding cmap, hide TT CMAP INFO
 404    * service defined in SFNT module.
 405    *
 406    * Otherwise call the service function in the sfnt module.
 407    *
 408    */
 409   static FT_Error
 410   cff_get_cmap_info( FT_CharMap    charmap,
 411                      TT_CMapInfo  *cmap_info )
 412   {
 413     FT_CMap   cmap  = FT_CMAP( charmap );
 414     FT_Error  error = FT_Err_Ok;
 415
 416     FT_Face     face    = FT_CMAP_FACE( cmap );
 417     FT_Library  library = FT_FACE_LIBRARY( face );
 418
 419
 420     cmap_info->language = 0;
 421     cmap_info->format   = 0;
 422
 423     if ( cmap->clazz != &CFF_CMAP_ENCODING_CLASS_REC_GET &&
 424          cmap->clazz != &CFF_CMAP_UNICODE_CLASS_REC_GET  )
 425     {
 426       FT_Module           sfnt    = FT_Get_Module( library, "sfnt" );
 427       FT_Service_TTCMaps  service =
 428         (FT_Service_TTCMaps)ft_module_get_service( sfnt,
 429                                                    FT_SERVICE_ID_TT_CMAP );
 430
 431
 432       if ( service && service->get_cmap_info )
 433         error = service->get_cmap_info( charmap, cmap_info );
 434     }
 435
 436     return error;
 437   }
 438
 439
 440   FT_DEFINE_SERVICE_TTCMAPSREC(
 441     cff_service_get_cmap_info,
 442     (TT_CMap_Info_GetFunc)cff_get_cmap_info
 443   )
 444
 445
 446   /*
 447    *  CID INFO SERVICE
 448    *
 449    */
 450   static FT_Error
 451   cff_get_ros( CFF_Face      face,
 452                const char*  *registry,
 453                const char*  *ordering,
 454                FT_Int       *supplement )
 455   {
 456     FT_Error  error = FT_Err_Ok;
 457     CFF_Font  cff   = (CFF_Font)face->extra.data;
 458
 459
 460     if ( cff )
 461     {
 462       CFF_FontRecDict  dict = &cff->top_font.font_dict;
 463
 464
 465       if ( dict->cid_registry == 0xFFFFU )
 466       {
 467         error = FT_THROW( Invalid_Argument );
 468         goto Fail;
 469       }
 470
 471       if ( registry )
 472       {
 473         if ( cff->registry == NULL )
 474           cff->registry = cff_index_get_sid_string( cff,
 475                                                     dict->cid_registry );
 476         *registry = cff->registry;
 477       }
 478
 479       if ( ordering )
 480       {
 481         if ( cff->ordering == NULL )
 482           cff->ordering = cff_index_get_sid_string( cff,
 483                                                     dict->cid_ordering );
 484         *ordering = cff->ordering;
 485       }
 486
 487       /*
 488        * XXX: According to Adobe TechNote #5176, the supplement in CFF
 489        *      can be a real number. We truncate it to fit public API
 490        *      since freetype-2.3.6.
 491        */
 492       if ( supplement )
 493       {
 494         if ( dict->cid_supplement < FT_INT_MIN ||
 495              dict->cid_supplement > FT_INT_MAX )
 496           FT_TRACE1(( "cff_get_ros: too large supplement %d is truncated\n",
 497                       dict->cid_supplement ));
 498         *supplement = (FT_Int)dict->cid_supplement;
 499       }
 500     }
 501
 502   Fail:
 503     return error;
 504   }
 505
 506
 507   static FT_Error
 508   cff_get_is_cid( CFF_Face  face,
 509                   FT_Bool  *is_cid )
 510   {
 511     FT_Error  error = FT_Err_Ok;
 512     CFF_Font  cff   = (CFF_Font)face->extra.data;
 513
 514
 515     *is_cid = 0;
 516
 517     if ( cff )
 518     {
 519       CFF_FontRecDict  dict = &cff->top_font.font_dict;
 520
 521
 522       if ( dict->cid_registry != 0xFFFFU )
 523         *is_cid = 1;
 524     }
 525
 526     return error;
 527   }
 528
 529
 530   static FT_Error
 531   cff_get_cid_from_glyph_index( CFF_Face  face,
 532                                 FT_UInt   glyph_index,
 533                                 FT_UInt  *cid )
 534   {
 535     FT_Error  error = FT_Err_Ok;
 536     CFF_Font  cff;
 537
 538
 539     cff = (CFF_Font)face->extra.data;
 540
 541     if ( cff )
 542     {
 543       FT_UInt          c;
 544       CFF_FontRecDict  dict = &cff->top_font.font_dict;
 545
 546
 547       if ( dict->cid_registry == 0xFFFFU )
 548       {
 549         error = FT_THROW( Invalid_Argument );
 550         goto Fail;
 551       }
 552
 553       if ( glyph_index > cff->num_glyphs )
 554       {
 555         error = FT_THROW( Invalid_Argument );
 556         goto Fail;
 557       }
 558
 559       c = cff->charset.sids[glyph_index];
 560
 561       if ( cid )
 562         *cid = c;
 563     }
 564
 565   Fail:
 566     return error;
 567   }
 568
 569
 570   FT_DEFINE_SERVICE_CIDREC(
 571     cff_service_cid_info,
 572     (FT_CID_GetRegistryOrderingSupplementFunc)cff_get_ros,
 573     (FT_CID_GetIsInternallyCIDKeyedFunc)      cff_get_is_cid,
 574     (FT_CID_GetCIDFromGlyphIndexFunc)         cff_get_cid_from_glyph_index
 575   )
 576
 577
 578   /*
 579    *  PROPERTY SERVICE
 580    *
 581    */
 582   static FT_Error
 583   cff_property_set( FT_Module    module,         /* CFF_Driver */
 584                     const char*  property_name,
 585                     const void*  value )
 586   {
 587     FT_Error    error  = FT_Err_Ok;
 588     CFF_Driver  driver = (CFF_Driver)module;
 589
 590
 591     if ( !ft_strcmp( property_name, "darkening-parameters" ) )
 592     {
 593       FT_Int*  darken_params = (FT_Int*)value;
 594
 595       FT_Int  x1 = darken_params[0];
 596       FT_Int  y1 = darken_params[1];
 597       FT_Int  x2 = darken_params[2];
 598       FT_Int  y2 = darken_params[3];
 599       FT_Int  x3 = darken_params[4];
 600       FT_Int  y3 = darken_params[5];
 601       FT_Int  x4 = darken_params[6];
 602       FT_Int  y4 = darken_params[7];
 603
 604
 605       if ( x1 < 0   || x2 < 0   || x3 < 0   || x4 < 0   ||
 606            y1 < 0   || y2 < 0   || y3 < 0   || y4 < 0   ||
 607            x1 > x2  || x2 > x3  || x3 > x4              ||
 608            y1 > 500 || y2 > 500 || y3 > 500 || y4 > 500 )
 609         return FT_THROW( Invalid_Argument );
 610
 611       driver->darken_params[0] = x1;
 612       driver->darken_params[1] = y1;
 613       driver->darken_params[2] = x2;
 614       driver->darken_params[3] = y2;
 615       driver->darken_params[4] = x3;
 616       driver->darken_params[5] = y3;
 617       driver->darken_params[6] = x4;
 618       driver->darken_params[7] = y4;
 619
 620       return error;
 621     }
 622     else if ( !ft_strcmp( property_name, "hinting-engine" ) )
 623     {
 624       FT_UInt*  hinting_engine = (FT_UInt*)value;
 625
 626
 627 #ifndef CFF_CONFIG_OPTION_OLD_ENGINE
 628       if ( *hinting_engine != FT_CFF_HINTING_ADOBE )
 629         error = FT_ERR( Unimplemented_Feature );
 630       else
 631 #endif
 632         driver->hinting_engine = *hinting_engine;
 633
 634       return error;
 635     }
 636     else if ( !ft_strcmp( property_name, "no-stem-darkening" ) )
 637     {
 638       FT_Bool*  no_stem_darkening = (FT_Bool*)value;
 639
 640
 641       driver->no_stem_darkening = *no_stem_darkening;
 642
 643       return error;
 644     }
 645
 646     FT_TRACE0(( "cff_property_set: missing property `%s'\n",
 647                 property_name ));
 648     return FT_THROW( Missing_Property );
 649   }
 650
 651
 652   static FT_Error
 653   cff_property_get( FT_Module    module,         /* CFF_Driver */
 654                     const char*  property_name,
 655                     const void*  value )
 656   {
 657     FT_Error    error  = FT_Err_Ok;
 658     CFF_Driver  driver = (CFF_Driver)module;
 659
 660
 661     if ( !ft_strcmp( property_name, "darkening-parameters" ) )
 662     {
 663       FT_Int*  darken_params = driver->darken_params;
 664       FT_Int*  val           = (FT_Int*)value;
 665
 666
 667       val[0] = darken_params[0];
 668       val[1] = darken_params[1];
 669       val[2] = darken_params[2];
 670       val[3] = darken_params[3];
 671       val[4] = darken_params[4];
 672       val[5] = darken_params[5];
 673       val[6] = darken_params[6];
 674       val[7] = darken_params[7];
 675
 676       return error;
 677     }
 678     else if ( !ft_strcmp( property_name, "hinting-engine" ) )
 679     {
 680       FT_UInt   hinting_engine    = driver->hinting_engine;
 681       FT_UInt*  val               = (FT_UInt*)value;
 682
 683
 684       *val = hinting_engine;
 685
 686       return error;
 687     }
 688     else if ( !ft_strcmp( property_name, "no-stem-darkening" ) )
 689     {
 690       FT_Bool   no_stem_darkening = driver->no_stem_darkening;
 691       FT_Bool*  val               = (FT_Bool*)value;
 692
 693
 694       *val = no_stem_darkening;
 695
 696       return error;
 697     }
 698
 699     FT_TRACE0(( "cff_property_get: missing property `%s'\n",
 700                 property_name ));
 701     return FT_THROW( Missing_Property );
 702   }
 703
 704
 705   FT_DEFINE_SERVICE_PROPERTIESREC(
 706     cff_service_properties,
 707     (FT_Properties_SetFunc)cff_property_set,
 708     (FT_Properties_GetFunc)cff_property_get )
 709
 710
 711   /*************************************************************************/
 712   /*************************************************************************/
 713   /*************************************************************************/
 714   /****                                                                 ****/
 715   /****                                                                 ****/
 716   /****                D R I V E R  I N T E R F A C E                   ****/
 717   /****                                                                 ****/
 718   /****                                                                 ****/
 719   /*************************************************************************/
 720   /*************************************************************************/
 721   /*************************************************************************/
 722
 723 #ifndef FT_CONFIG_OPTION_NO_GLYPH_NAMES
 724   FT_DEFINE_SERVICEDESCREC7(
 725     cff_services,
 726     FT_SERVICE_ID_XF86_NAME,            FT_XF86_FORMAT_CFF,
 727     FT_SERVICE_ID_POSTSCRIPT_INFO,      &CFF_SERVICE_PS_INFO_GET,
 728     FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &CFF_SERVICE_PS_NAME_GET,
 729     FT_SERVICE_ID_GLYPH_DICT,           &CFF_SERVICE_GLYPH_DICT_GET,
 730     FT_SERVICE_ID_TT_CMAP,              &CFF_SERVICE_GET_CMAP_INFO_GET,
 731     FT_SERVICE_ID_CID,                  &CFF_SERVICE_CID_INFO_GET,
 732     FT_SERVICE_ID_PROPERTIES,           &CFF_SERVICE_PROPERTIES_GET
 733   )
 734 #else
 735   FT_DEFINE_SERVICEDESCREC6(
 736     cff_services,
 737     FT_SERVICE_ID_XF86_NAME,            FT_XF86_FORMAT_CFF,
 738     FT_SERVICE_ID_POSTSCRIPT_INFO,      &CFF_SERVICE_PS_INFO_GET,
 739     FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &CFF_SERVICE_PS_NAME_GET,
 740     FT_SERVICE_ID_TT_CMAP,              &CFF_SERVICE_GET_CMAP_INFO_GET,
 741     FT_SERVICE_ID_CID,                  &CFF_SERVICE_CID_INFO_GET,
 742     FT_SERVICE_ID_PROPERTIES,           &CFF_SERVICE_PROPERTIES_GET
 743   )
 744 #endif
 745
 746
 747   FT_CALLBACK_DEF( FT_Module_Interface )
 748   cff_get_interface( FT_Module    driver,       /* CFF_Driver */
 749                      const char*  module_interface )
 750   {
 751     FT_Library           library;
 752     FT_Module            sfnt;
 753     FT_Module_Interface  result;
 754
 755
 756     /* CFF_SERVICES_GET derefers `library' in PIC mode */
 757 #ifdef FT_CONFIG_OPTION_PIC
 758     if ( !driver )
 759       return NULL;
 760     library = driver->library;
 761     if ( !library )
 762       return NULL;
 763 #endif
 764
 765     result = ft_service_list_lookup( CFF_SERVICES_GET, module_interface );
 766     if ( result != NULL )
 767       return result;
 768
 769     /* `driver' is not yet evaluated in non-PIC mode */
 770 #ifndef FT_CONFIG_OPTION_PIC
 771     if ( !driver )
 772       return NULL;
 773     library = driver->library;
 774     if ( !library )
 775       return NULL;
 776 #endif
 777
 778     /* we pass our request to the `sfnt' module */
 779     sfnt = FT_Get_Module( library, "sfnt" );
 780
 781     return sfnt ? sfnt->clazz->get_interface( sfnt, module_interface ) : 0;
 782   }
 783
 784
 785   /* The FT_DriverInterface structure is defined in ftdriver.h. */
 786
 787 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
 788 #define CFF_SIZE_SELECT cff_size_select
 789 #else
 790 #define CFF_SIZE_SELECT 0
 791 #endif
 792
 793   FT_DEFINE_DRIVER(
 794     cff_driver_class,
 795
 796       FT_MODULE_FONT_DRIVER       |
 797       FT_MODULE_DRIVER_SCALABLE   |
 798       FT_MODULE_DRIVER_HAS_HINTER,
 799
 800       sizeof ( CFF_DriverRec ),
 801       "cff",
 802       0x10000L,
 803       0x20000L,
 804
 805       0,   /* module-specific interface */
 806
 807       cff_driver_init,
 808       cff_driver_done,
 809       cff_get_interface,
 810
 811     /* now the specific driver fields */
 812     sizeof ( TT_FaceRec ),
 813     sizeof ( CFF_SizeRec ),
 814     sizeof ( CFF_GlyphSlotRec ),
 815
 816     cff_face_init,
 817     cff_face_done,
 818     cff_size_init,
 819     cff_size_done,
 820     cff_slot_init,
 821     cff_slot_done,
 822
 823     cff_glyph_load,
 824
 825     cff_get_kerning,
 826     0,                       /* FT_Face_AttachFunc */
 827     cff_get_advances,
 828
 829     cff_size_request,
 830
 831     CFF_SIZE_SELECT
 832   )
 833
 834
 835 /* END */