src/type1/t1objs.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  t1objs.c                                                               */
   4 /*                                                                         */
   5 /*    Type 1 objects manager (body).                                       */
   6 /*                                                                         */
   7 /*  Copyright 1996-2016 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_CALC_H
  21 #include FT_INTERNAL_DEBUG_H
  22 #include FT_INTERNAL_STREAM_H
  23 #include FT_TRUETYPE_IDS_H
  24
  25 #include "t1gload.h"
  26 #include "t1load.h"
  27
  28 #include "t1errors.h"
  29
  30 #ifndef T1_CONFIG_OPTION_NO_AFM
  31 #include "t1afm.h"
  32 #endif
  33
  34 #include FT_SERVICE_POSTSCRIPT_CMAPS_H
  35 #include FT_INTERNAL_POSTSCRIPT_AUX_H
  36
  37
  38   /*************************************************************************/
  39   /*                                                                       */
  40   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  41   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  42   /* messages during execution.                                            */
  43   /*                                                                       */
  44 #undef  FT_COMPONENT
  45 #define FT_COMPONENT  trace_t1objs
  46
  47
  48   /*************************************************************************/
  49   /*                                                                       */
  50   /*                            SIZE FUNCTIONS                             */
  51   /*                                                                       */
  52   /*  note that we store the global hints in the size's "internal" root    */
  53   /*  field                                                                */
  54   /*                                                                       */
  55   /*************************************************************************/
  56
  57
  58   static PSH_Globals_Funcs
  59   T1_Size_Get_Globals_Funcs( T1_Size  size )
  60   {
  61     T1_Face           face     = (T1_Face)size->root.face;
  62     PSHinter_Service  pshinter = (PSHinter_Service)face->pshinter;
  63     FT_Module         module;
  64
  65
  66     module = FT_Get_Module( size->root.face->driver->root.library,
  67                             "pshinter" );
  68     return ( module && pshinter && pshinter->get_globals_funcs )
  69            ? pshinter->get_globals_funcs( module )
  70            : 0;
  71   }
  72
  73
  74   FT_LOCAL_DEF( void )
  75   T1_Size_Done( FT_Size  t1size )          /* T1_Size */
  76   {
  77     T1_Size  size = (T1_Size)t1size;
  78
  79
  80     if ( size->root.internal )
  81     {
  82       PSH_Globals_Funcs  funcs;
  83
  84
  85       funcs = T1_Size_Get_Globals_Funcs( size );
  86       if ( funcs )
  87         funcs->destroy( (PSH_Globals)size->root.internal );
  88
  89       size->root.internal = NULL;
  90     }
  91   }
  92
  93
  94   FT_LOCAL_DEF( FT_Error )
  95   T1_Size_Init( FT_Size  t1size )      /* T1_Size */
  96   {
  97     T1_Size            size  = (T1_Size)t1size;
  98     FT_Error           error = FT_Err_Ok;
  99     PSH_Globals_Funcs  funcs = T1_Size_Get_Globals_Funcs( size );
 100
 101
 102     if ( funcs )
 103     {
 104       PSH_Globals  globals;
 105       T1_Face      face = (T1_Face)size->root.face;
 106
 107
 108       error = funcs->create( size->root.face->memory,
 109                              &face->type1.private_dict, &globals );
 110       if ( !error )
 111         size->root.internal = (FT_Size_Internal)(void*)globals;
 112     }
 113
 114     return error;
 115   }
 116
 117
 118   FT_LOCAL_DEF( FT_Error )
 119   T1_Size_Request( FT_Size          t1size,     /* T1_Size */
 120                    FT_Size_Request  req )
 121   {
 122     T1_Size            size  = (T1_Size)t1size;
 123     PSH_Globals_Funcs  funcs = T1_Size_Get_Globals_Funcs( size );
 124
 125
 126     FT_Request_Metrics( size->root.face, req );
 127
 128     if ( funcs )
 129       funcs->set_scale( (PSH_Globals)size->root.internal,
 130                         size->root.metrics.x_scale,
 131                         size->root.metrics.y_scale,
 132                         0, 0 );
 133
 134     return FT_Err_Ok;
 135   }
 136
 137
 138   /*************************************************************************/
 139   /*                                                                       */
 140   /*                            SLOT  FUNCTIONS                            */
 141   /*                                                                       */
 142   /*************************************************************************/
 143
 144   FT_LOCAL_DEF( void )
 145   T1_GlyphSlot_Done( FT_GlyphSlot  slot )
 146   {
 147     slot->internal->glyph_hints = NULL;
 148   }
 149
 150
 151   FT_LOCAL_DEF( FT_Error )
 152   T1_GlyphSlot_Init( FT_GlyphSlot  slot )
 153   {
 154     T1_Face           face;
 155     PSHinter_Service  pshinter;
 156
 157
 158     face     = (T1_Face)slot->face;
 159     pshinter = (PSHinter_Service)face->pshinter;
 160
 161     if ( pshinter )
 162     {
 163       FT_Module  module;
 164
 165
 166       module = FT_Get_Module( slot->face->driver->root.library,
 167                               "pshinter" );
 168       if ( module )
 169       {
 170         T1_Hints_Funcs  funcs;
 171
 172
 173         funcs = pshinter->get_t1_funcs( module );
 174         slot->internal->glyph_hints = (void*)funcs;
 175       }
 176     }
 177
 178     return 0;
 179   }
 180
 181
 182   /*************************************************************************/
 183   /*                                                                       */
 184   /*                            FACE  FUNCTIONS                            */
 185   /*                                                                       */
 186   /*************************************************************************/
 187
 188
 189   /*************************************************************************/
 190   /*                                                                       */
 191   /* <Function>                                                            */
 192   /*    T1_Face_Done                                                       */
 193   /*                                                                       */
 194   /* <Description>                                                         */
 195   /*    The face object destructor.                                        */
 196   /*                                                                       */
 197   /* <Input>                                                               */
 198   /*    face :: A typeless pointer to the face object to destroy.          */
 199   /*                                                                       */
 200   FT_LOCAL_DEF( void )
 201   T1_Face_Done( FT_Face  t1face )         /* T1_Face */
 202   {
 203     T1_Face    face = (T1_Face)t1face;
 204     FT_Memory  memory;
 205     T1_Font    type1;
 206
 207
 208     if ( !face )
 209       return;
 210
 211     memory = face->root.memory;
 212     type1  = &face->type1;
 213
 214 #ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
 215     /* release multiple masters information */
 216     FT_ASSERT( ( face->len_buildchar == 0 ) == ( face->buildchar == NULL ) );
 217
 218     if ( face->buildchar )
 219     {
 220       FT_FREE( face->buildchar );
 221
 222       face->buildchar     = NULL;
 223       face->len_buildchar = 0;
 224     }
 225
 226     T1_Done_Blend( face );
 227     face->blend = NULL;
 228 #endif
 229
 230     /* release font info strings */
 231     {
 232       PS_FontInfo  info = &type1->font_info;
 233
 234
 235       FT_FREE( info->version );
 236       FT_FREE( info->notice );
 237       FT_FREE( info->full_name );
 238       FT_FREE( info->family_name );
 239       FT_FREE( info->weight );
 240     }
 241
 242     /* release top dictionary */
 243     FT_FREE( type1->charstrings_len );
 244     FT_FREE( type1->charstrings );
 245     FT_FREE( type1->glyph_names );
 246
 247     FT_FREE( type1->subrs );
 248     FT_FREE( type1->subrs_len );
 249
 250     ft_hash_num_free( type1->subrs_hash, memory );
 251     FT_FREE( type1->subrs_hash );
 252
 253     FT_FREE( type1->subrs_block );
 254     FT_FREE( type1->charstrings_block );
 255     FT_FREE( type1->glyph_names_block );
 256
 257     FT_FREE( type1->encoding.char_index );
 258     FT_FREE( type1->encoding.char_name );
 259     FT_FREE( type1->font_name );
 260
 261 #ifndef T1_CONFIG_OPTION_NO_AFM
 262     /* release afm data if present */
 263     if ( face->afm_data )
 264       T1_Done_Metrics( memory, (AFM_FontInfo)face->afm_data );
 265 #endif
 266
 267     /* release unicode map, if any */
 268 #if 0
 269     FT_FREE( face->unicode_map_rec.maps );
 270     face->unicode_map_rec.num_maps = 0;
 271     face->unicode_map              = NULL;
 272 #endif
 273
 274     face->root.family_name = NULL;
 275     face->root.style_name  = NULL;
 276   }
 277
 278
 279   /*************************************************************************/
 280   /*                                                                       */
 281   /* <Function>                                                            */
 282   /*    T1_Face_Init                                                       */
 283   /*                                                                       */
 284   /* <Description>                                                         */
 285   /*    The face object constructor.                                       */
 286   /*                                                                       */
 287   /* <Input>                                                               */
 288   /*    stream     ::  input stream where to load font data.               */
 289   /*                                                                       */
 290   /*    face_index :: The index of the font face in the resource.          */
 291   /*                                                                       */
 292   /*    num_params :: Number of additional generic parameters.  Ignored.   */
 293   /*                                                                       */
 294   /*    params     :: Additional generic parameters.  Ignored.             */
 295   /*                                                                       */
 296   /* <InOut>                                                               */
 297   /*    face       :: The face record to build.                            */
 298   /*                                                                       */
 299   /* <Return>                                                              */
 300   /*    FreeType error code.  0 means success.                             */
 301   /*                                                                       */
 302   FT_LOCAL_DEF( FT_Error )
 303   T1_Face_Init( FT_Stream      stream,
 304                 FT_Face        t1face,          /* T1_Face */
 305                 FT_Int         face_index,
 306                 FT_Int         num_params,
 307                 FT_Parameter*  params )
 308   {
 309     T1_Face             face = (T1_Face)t1face;
 310     FT_Error            error;
 311     FT_Service_PsCMaps  psnames;
 312     PSAux_Service       psaux;
 313     T1_Font             type1 = &face->type1;
 314     PS_FontInfo         info = &type1->font_info;
 315
 316     FT_UNUSED( num_params );
 317     FT_UNUSED( params );
 318     FT_UNUSED( stream );
 319
 320
 321     face->root.num_faces = 1;
 322
 323     FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );
 324     face->psnames = psnames;
 325
 326     face->psaux = FT_Get_Module_Interface( FT_FACE_LIBRARY( face ),
 327                                            "psaux" );
 328     psaux = (PSAux_Service)face->psaux;
 329     if ( !psaux )
 330     {
 331       FT_ERROR(( "T1_Face_Init: cannot access `psaux' module\n" ));
 332       error = FT_THROW( Missing_Module );
 333       goto Exit;
 334     }
 335
 336     face->pshinter = FT_Get_Module_Interface( FT_FACE_LIBRARY( face ),
 337                                               "pshinter" );
 338
 339     FT_TRACE2(( "Type 1 driver\n" ));
 340
 341     /* open the tokenizer; this will also check the font format */
 342     error = T1_Open_Face( face );
 343     if ( error )
 344       goto Exit;
 345
 346     /* if we just wanted to check the format, leave successfully now */
 347     if ( face_index < 0 )
 348       goto Exit;
 349
 350     /* check the face index */
 351     if ( ( face_index & 0xFFFF ) > 0 )
 352     {
 353       FT_ERROR(( "T1_Face_Init: invalid face index\n" ));
 354       error = FT_THROW( Invalid_Argument );
 355       goto Exit;
 356     }
 357
 358     /* now load the font program into the face object */
 359
 360     /* initialize the face object fields */
 361
 362     /* set up root face fields */
 363     {
 364       FT_Face  root = (FT_Face)&face->root;
 365
 366
 367       root->num_glyphs = type1->num_glyphs;
 368       root->face_index = 0;
 369
 370       root->face_flags |= FT_FACE_FLAG_SCALABLE    |
 371                           FT_FACE_FLAG_HORIZONTAL  |
 372                           FT_FACE_FLAG_GLYPH_NAMES |
 373                           FT_FACE_FLAG_HINTER;
 374
 375       if ( info->is_fixed_pitch )
 376         root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
 377
 378       if ( face->blend )
 379         root->face_flags |= FT_FACE_FLAG_MULTIPLE_MASTERS;
 380
 381       /* The following code to extract the family and the style is very   */
 382       /* simplistic and might get some things wrong.  For a full-featured */
 383       /* algorithm you might have a look at the whitepaper given at       */
 384       /*                                                                  */
 385       /*   http://blogs.msdn.com/text/archive/2007/04/23/wpf-font-selection-model.aspx */
 386
 387       /* get style name -- be careful, some broken fonts only */
 388       /* have a `/FontName' dictionary entry!                 */
 389       root->family_name = info->family_name;
 390       root->style_name  = NULL;
 391
 392       if ( root->family_name )
 393       {
 394         char*  full   = info->full_name;
 395         char*  family = root->family_name;
 396
 397
 398         if ( full )
 399         {
 400           FT_Bool  the_same = TRUE;
 401
 402
 403           while ( *full )
 404           {
 405             if ( *full == *family )
 406             {
 407               family++;
 408               full++;
 409             }
 410             else
 411             {
 412               if ( *full == ' ' || *full == '-' )
 413                 full++;
 414               else if ( *family == ' ' || *family == '-' )
 415                 family++;
 416               else
 417               {
 418                 the_same = FALSE;
 419
 420                 if ( !*family )
 421                   root->style_name = full;
 422                 break;
 423               }
 424             }
 425           }
 426
 427           if ( the_same )
 428             root->style_name = (char *)"Regular";
 429         }
 430       }
 431       else
 432       {
 433         /* do we have a `/FontName'? */
 434         if ( type1->font_name )
 435           root->family_name = type1->font_name;
 436       }
 437
 438       if ( !root->style_name )
 439       {
 440         if ( info->weight )
 441           root->style_name = info->weight;
 442         else
 443           /* assume `Regular' style because we don't know better */
 444           root->style_name = (char *)"Regular";
 445       }
 446
 447       /* compute style flags */
 448       root->style_flags = 0;
 449       if ( info->italic_angle )
 450         root->style_flags |= FT_STYLE_FLAG_ITALIC;
 451       if ( info->weight )
 452       {
 453         if ( !ft_strcmp( info->weight, "Bold"  ) ||
 454              !ft_strcmp( info->weight, "Black" ) )
 455           root->style_flags |= FT_STYLE_FLAG_BOLD;
 456       }
 457
 458       /* no embedded bitmap support */
 459       root->num_fixed_sizes = 0;
 460       root->available_sizes = NULL;
 461
 462       root->bbox.xMin =   type1->font_bbox.xMin            >> 16;
 463       root->bbox.yMin =   type1->font_bbox.yMin            >> 16;
 464       /* no `U' suffix here to 0xFFFF! */
 465       root->bbox.xMax = ( type1->font_bbox.xMax + 0xFFFF ) >> 16;
 466       root->bbox.yMax = ( type1->font_bbox.yMax + 0xFFFF ) >> 16;
 467
 468       /* Set units_per_EM if we didn't set it in t1_parse_font_matrix. */
 469       if ( !root->units_per_EM )
 470         root->units_per_EM = 1000;
 471
 472       root->ascender  = (FT_Short)( root->bbox.yMax );
 473       root->descender = (FT_Short)( root->bbox.yMin );
 474
 475       root->height = (FT_Short)( ( root->units_per_EM * 12 ) / 10 );
 476       if ( root->height < root->ascender - root->descender )
 477         root->height = (FT_Short)( root->ascender - root->descender );
 478
 479       /* now compute the maximum advance width */
 480       root->max_advance_width =
 481         (FT_Short)( root->bbox.xMax );
 482       {
 483         FT_Pos  max_advance;
 484
 485
 486         error = T1_Compute_Max_Advance( face, &max_advance );
 487
 488         /* in case of error, keep the standard width */
 489         if ( !error )
 490           root->max_advance_width = (FT_Short)FIXED_TO_INT( max_advance );
 491         else
 492           error = FT_Err_Ok;   /* clear error */
 493       }
 494
 495       root->max_advance_height = root->height;
 496
 497       root->underline_position  = (FT_Short)info->underline_position;
 498       root->underline_thickness = (FT_Short)info->underline_thickness;
 499     }
 500
 501     {
 502       FT_Face  root = &face->root;
 503
 504
 505       if ( psnames )
 506       {
 507         FT_CharMapRec    charmap;
 508         T1_CMap_Classes  cmap_classes = psaux->t1_cmap_classes;
 509         FT_CMap_Class    clazz;
 510
 511
 512         charmap.face = root;
 513
 514         /* first of all, try to synthesize a Unicode charmap */
 515         charmap.platform_id = TT_PLATFORM_MICROSOFT;
 516         charmap.encoding_id = TT_MS_ID_UNICODE_CS;
 517         charmap.encoding    = FT_ENCODING_UNICODE;
 518
 519         error = FT_CMap_New( cmap_classes->unicode, NULL, &charmap, NULL );
 520         if ( error                                      &&
 521              FT_ERR_NEQ( error, No_Unicode_Glyph_Name ) )
 522           goto Exit;
 523         error = FT_Err_Ok;
 524
 525         /* now, generate an Adobe Standard encoding when appropriate */
 526         charmap.platform_id = TT_PLATFORM_ADOBE;
 527         clazz               = NULL;
 528
 529         switch ( type1->encoding_type )
 530         {
 531         case T1_ENCODING_TYPE_STANDARD:
 532           charmap.encoding    = FT_ENCODING_ADOBE_STANDARD;
 533           charmap.encoding_id = TT_ADOBE_ID_STANDARD;
 534           clazz               = cmap_classes->standard;
 535           break;
 536
 537         case T1_ENCODING_TYPE_EXPERT:
 538           charmap.encoding    = FT_ENCODING_ADOBE_EXPERT;
 539           charmap.encoding_id = TT_ADOBE_ID_EXPERT;
 540           clazz               = cmap_classes->expert;
 541           break;
 542
 543         case T1_ENCODING_TYPE_ARRAY:
 544           charmap.encoding    = FT_ENCODING_ADOBE_CUSTOM;
 545           charmap.encoding_id = TT_ADOBE_ID_CUSTOM;
 546           clazz               = cmap_classes->custom;
 547           break;
 548
 549         case T1_ENCODING_TYPE_ISOLATIN1:
 550           charmap.encoding    = FT_ENCODING_ADOBE_LATIN_1;
 551           charmap.encoding_id = TT_ADOBE_ID_LATIN_1;
 552           clazz               = cmap_classes->unicode;
 553           break;
 554
 555         default:
 556           ;
 557         }
 558
 559         if ( clazz )
 560           error = FT_CMap_New( clazz, NULL, &charmap, NULL );
 561
 562 #if 0
 563         /* Select default charmap */
 564         if (root->num_charmaps)
 565           root->charmap = root->charmaps[0];
 566 #endif
 567       }
 568     }
 569
 570   Exit:
 571     return error;
 572   }
 573
 574
 575   /*************************************************************************/
 576   /*                                                                       */
 577   /* <Function>                                                            */
 578   /*    T1_Driver_Init                                                     */
 579   /*                                                                       */
 580   /* <Description>                                                         */
 581   /*    Initializes a given Type 1 driver object.                          */
 582   /*                                                                       */
 583   /* <Input>                                                               */
 584   /*    driver :: A handle to the target driver object.                    */
 585   /*                                                                       */
 586   /* <Return>                                                              */
 587   /*    FreeType error code.  0 means success.                             */
 588   /*                                                                       */
 589   FT_LOCAL_DEF( FT_Error )
 590   T1_Driver_Init( FT_Module  driver )
 591   {
 592     FT_UNUSED( driver );
 593
 594     return FT_Err_Ok;
 595   }
 596
 597
 598   /*************************************************************************/
 599   /*                                                                       */
 600   /* <Function>                                                            */
 601   /*    T1_Driver_Done                                                     */
 602   /*                                                                       */
 603   /* <Description>                                                         */
 604   /*    Finalizes a given Type 1 driver.                                   */
 605   /*                                                                       */
 606   /* <Input>                                                               */
 607   /*    driver :: A handle to the target Type 1 driver.                    */
 608   /*                                                                       */
 609   FT_LOCAL_DEF( void )
 610   T1_Driver_Done( FT_Module  driver )
 611   {
 612     FT_UNUSED( driver );
 613   }
 614
 615
 616 /* END */