Exemple #1
0
  cff_index_get_sid_string( CFF_Index        idx,
                            FT_UInt          sid,
                            PSNames_Service  psnames_service )
  {
    /* if it is not a standard string, return it */
    if ( sid > 390 )
      return cff_index_get_name( idx, sid - 391 );

    /* that's a standard string, fetch a copy from the PSName module */
    {
      FT_String*   name       = 0;
      const char*  adobe_name = psnames_service->adobe_std_strings( sid );
      FT_UInt      len;


      if ( adobe_name )
      {
        FT_Memory  memory = idx->stream->memory;
        FT_Error   error;


        len = (FT_UInt)ft_strlen( adobe_name );
        if ( !FT_ALLOC( name, len + 1 ) )
        {
          FT_MEM_COPY( name, adobe_name, len );
          name[len] = 0;
        }

        FT_UNUSED( error );
      }

      return name;
    }
  }
  static FT_Int
  t1_lookup_glyph_by_stdcharcode( T1_Decoder  decoder,
                                  FT_Int      charcode )
  {
    FT_UInt           n;
    const FT_String*  glyph_name;
    PSNames_Service   psnames = decoder->psnames;


    /* check range of standard char code */
    if ( charcode < 0 || charcode > 255 )
      return -1;

    glyph_name = psnames->adobe_std_strings(
                   psnames->adobe_std_encoding[charcode]);

    for ( n = 0; n < decoder->num_glyphs; n++ )
    {
      FT_String*  name = (FT_String*)decoder->glyph_names[n];


      if ( name && name[0] == glyph_name[0]  &&
           ft_strcmp( name,glyph_name ) == 0 )
        return n;
    }

    return -1;
  }
  static FT_Long
  CID_Get_Next_Char( FT_CharMap  charmap,
                     FT_Long     charcode )
  {
    T1_Face          face;
    PSNames_Service  psnames;


    face    = (T1_Face)charmap->face;
    psnames = (PSNames_Service)face->psnames;

    if ( psnames )
      switch ( charmap->encoding )
      {
        /*******************************************************************/
        /*                                                                 */
        /* Unicode encoding support                                        */
        /*                                                                 */
      case ft_encoding_unicode:
        /* use the `PSNames' module to synthetize the Unicode charmap */
        return psnames->next_unicode (&face->unicode_map,
                                      (FT_ULong)charcode );

        /*******************************************************************/
        /*                                                                 */
        /* Custom Type 1 encoding                                          */
        /*                                                                 */
      case ft_encoding_adobe_custom:
        {
          T1_Encoding  encoding = &face->type1.encoding;


          charcode++;
          if ( charcode < encoding->code_first )
            charcode = encoding->code_first;
          while ( charcode <= encoding->code_last )
          {
            if ( encoding->char_index[charcode] )
              return charcode;
            charcode++;
          }
        }
        break;

        /*******************************************************************/
        /*                                                                 */
        /* Adobe Standard & Expert encoding support                        */
        /*                                                                 */
      default:
        while ( ++charcode < 256 )
        {
          FT_UInt      code;
          FT_Int       n;
          const char*  glyph_name;


          code = psnames->adobe_std_encoding[charcode];
          if ( charmap->encoding == ft_encoding_adobe_expert )
            code = psnames->adobe_expert_encoding[charcode];

          glyph_name = psnames->adobe_std_strings( code );
          if ( !glyph_name )
            continue;

          for ( n = 0; n < face->type1.num_glyphs; n++ )
          {
            const char*  gname = face->type1.glyph_names[n];


            if ( gname && gname[0] == glyph_name[0] &&
                 ft_strcmp( gname, glyph_name ) == 0   )
            {
              return charcode;
            }
          }
        }
      }

    return 0;
  }
  static FT_UInt
  CID_Get_Char_Index( FT_CharMap  charmap,
                      FT_Long     charcode )
  {
    T1_Face          face;
    FT_UInt          result = 0;
    PSNames_Service  psnames;


    face = (T1_Face)charmap->face;
    psnames = (PSNames_Service)face->psnames;
    if ( psnames )
      switch ( charmap->encoding )
      {
        /*******************************************************************/
        /*                                                                 */
        /* Unicode encoding support                                        */
        /*                                                                 */
      case ft_encoding_unicode:
        /* use the `PSNames' module to synthetize the Unicode charmap */
        result = psnames->lookup_unicode( &face->unicode_map,
                                          (FT_ULong)charcode );

        /* the function returns 0xFFFF if the Unicode charcode has */
        /* no corresponding glyph.                                 */
        if ( result == 0xFFFF )
          result = 0;
        goto Exit;

        /*******************************************************************/
        /*                                                                 */
        /* Custom Type 1 encoding                                          */
        /*                                                                 */
      case ft_encoding_adobe_custom:
        {
          T1_Encoding  encoding = &face->type1.encoding;


          if ( charcode >= encoding->code_first &&
               charcode <= encoding->code_last  )
            result = encoding->char_index[charcode];
          goto Exit;
        }

        /*******************************************************************/
        /*                                                                 */
        /* Adobe Standard & Expert encoding support                        */
        /*                                                                 */
      default:
        if ( charcode < 256 )
        {
          FT_UInt      code;
          FT_Int       n;
          const char*  glyph_name;


          code = psnames->adobe_std_encoding[charcode];
          if ( charmap->encoding == ft_encoding_adobe_expert )
            code = psnames->adobe_expert_encoding[charcode];

          glyph_name = psnames->adobe_std_strings( code );
          if ( !glyph_name )
            break;

          for ( n = 0; n < face->type1.num_glyphs; n++ )
          {
            const char*  gname = face->type1.glyph_names[n];


            if ( gname && gname[0] == glyph_name[0] &&
                 ft_strcmp( gname, glyph_name ) == 0   )
            {
              result = n;
              break;
            }
          }
        }
      }

  Exit:
    return result;
  }
Exemple #5
0
  T42_CMap_CharIndex( FT_CharMap  charmap,
                      FT_Long     charcode )
  {
    T42_Face         face;
    FT_UInt          result = 0;
    PSNames_Service  psnames;


    face    = (T42_Face)charmap->face;
    psnames = (PSNames_Service)face->psnames;
    if (!psnames )
      goto Exit;

    switch ( charmap->encoding )
    {
      /*******************************************************************/
      /*                                                                 */
      /* Unicode encoding support                                        */
      /*                                                                 */
    case ft_encoding_unicode:
      /* if this charmap is used, we ignore the encoding of the font and */
      /* use the `PSNames' module to synthetize the Unicode charmap      */
      result = psnames->lookup_unicode( &face->unicode_map,
                                        (FT_ULong)charcode );

      /* the function returns 0xFFFF if the Unicode charcode has */
      /* no corresponding glyph                                  */
      if ( result == 0xFFFFU )
        result = 0;

      /* The result returned is the index (position)in the CharStrings */
      /* array.  This must be used now to get the value associated to  */
      /* that glyph_name, which is the real index within the truetype  */
      /* structure.                                                    */
      result = ft_atoi( (const char*)face->type1.charstrings[result] );
      goto Exit;

      /*******************************************************************/
      /*                                                                 */
      /* ISOLatin1 encoding support                                      */
      /*                                                                 */
    case ft_encoding_latin_1:
      /* ISOLatin1 is the first page of Unicode */
      if ( charcode < 256 && psnames->unicode_value )
      {
        result = psnames->lookup_unicode( &face->unicode_map,
                                          (FT_ULong)charcode );

        /* the function returns 0xFFFF if the Unicode charcode has */
        /* no corresponding glyph                                  */
        if ( result == 0xFFFFU )
          result = 0;
      }
      goto Exit;

      /*******************************************************************/
      /*                                                                 */
      /* Custom Type 1 encoding                                          */
      /*                                                                 */
    case ft_encoding_adobe_custom:
      {
        T1_Encoding  encoding = &face->type1.encoding;


        if ( charcode >= encoding->code_first &&
             charcode <= encoding->code_last  )
        {
          FT_UInt idx = encoding->char_index[charcode];


          result = ft_atoi( (const char *)face->type1.charstrings[idx] );
        }
        goto Exit;
      }

      /*******************************************************************/
      /*                                                                 */
      /* Adobe Standard & Expert encoding support                        */
      /*                                                                 */
    default:
      if ( charcode < 256 )
      {
        FT_UInt      code;
        FT_Int       n;
        const char*  glyph_name;


        code = psnames->adobe_std_encoding[charcode];
        if ( charmap->encoding == ft_encoding_adobe_expert )
          code = psnames->adobe_expert_encoding[charcode];

        glyph_name = psnames->adobe_std_strings( code );
        if ( !glyph_name )
          break;

        for ( n = 0; n < face->type1.num_glyphs; n++ )
        {
          const char*  gname = face->type1.glyph_names[n];

          if ( gname && ( ft_strcmp( gname, glyph_name ) == 0 ) )
          {
            result = ft_atoi( (const char *)face->type1.charstrings[n] );
            break;
          }
        }
      }
    }

  Exit:
    return result;
  }