/***************************************************************************//*                                                                         *//*  cffdrivr.c                                                             *//*                                                                         *//*    OpenType font driver implementation (body).                          *//*                                                                         *//*  Copyright 1996-2001, 2002 by                                           *//*  David Turner, Robert Wilhelm, and Werner Lemberg.                      *//*                                                                         *//*  This file is part of the FreeType project, and may only be used,       *//*  modified, and distributed under the terms of the FreeType project      *//*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     *//*  this file you indicate that you have read the license and              *//*  understand and accept it fully.                                        *//*                                                                         *//***************************************************************************/#include <ft2build.h>#include FT_FREETYPE_H#include FT_INTERNAL_DEBUG_H#include FT_INTERNAL_STREAM_H#include FT_INTERNAL_SFNT_H#include FT_TRUETYPE_IDS_H#include FT_INTERNAL_POSTSCRIPT_NAMES_H#include "cffdrivr.h"#include "cffgload.h"#include "cffload.h"#include "cfferrs.h"  /*************************************************************************/  /*                                                                       */  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */  /* messages during execution.                                            */  /*                                                                       */#undef  FT_COMPONENT#define FT_COMPONENT  trace_cffdriver  /*************************************************************************/  /*************************************************************************/  /*************************************************************************/  /****                                                                 ****/  /****                                                                 ****/  /****                          F A C E S                              ****/  /****                                                                 ****/  /****                                                                 ****/  /*************************************************************************/  /*************************************************************************/  /*************************************************************************/#undef  PAIR_TAG#define PAIR_TAG( left, right )  ( ( (FT_ULong)left << 16 ) | \                                     (FT_ULong)right        )  /*************************************************************************/  /*                                                                       */  /* <Function>                                                            */  /*    Get_Kerning                                                        */  /*                                                                       */  /* <Description>                                                         */  /*    A driver method used to return the kerning vector between two      */  /*    glyphs of the same face.                                           */  /*                                                                       */  /* <Input>                                                               */  /*    face        :: A handle to the source face object.                 */  /*                                                                       */  /*    left_glyph  :: The index of the left glyph in the kern pair.       */  /*                                                                       */  /*    right_glyph :: The index of the right glyph in the kern pair.      */  /*                                                                       */  /* <Output>                                                              */  /*    kerning     :: The kerning vector.  This is in font units for      */  /*                   scalable formats, and in pixels for fixed-sizes     */  /*                   formats.                                            */  /*                                                                       */  /* <Return>                                                              */  /*    FreeType error code.  0 means success.                             */  /*                                                                       */  /* <Note>                                                                */  /*    Only horizontal layouts (left-to-right & right-to-left) are        */  /*    supported by this function.  Other layouts, or more sophisticated  */  /*    kernings, are out of scope of this method (the basic driver        */  /*    interface is meant to be simple).                                  */  /*                                                                       */  /*    They can be implemented by format-specific interfaces.             */  /*                                                                       */  static FT_Error  Get_Kerning( TT_Face     face,               FT_UInt     left_glyph,               FT_UInt     right_glyph,               FT_Vector*  kerning )  {    TT_Kern0_Pair  pair;    if ( !face )      return CFF_Err_Invalid_Face_Handle;    kerning->x = 0;    kerning->y = 0;    if ( face->kern_pairs )    {      /* there are some kerning pairs in this font file! */      FT_ULong  search_tag = PAIR_TAG( left_glyph, right_glyph );      FT_Long   left, right;      left  = 0;      right = face->num_kern_pairs - 1;      while ( left <= right )      {        FT_Int    middle = left + ( ( right - left ) >> 1 );        FT_ULong  cur_pair;        pair     = face->kern_pairs + middle;        cur_pair = PAIR_TAG( pair->left, pair->right );        if ( cur_pair == search_tag )          goto Found;        if ( cur_pair < search_tag )          left = middle + 1;        else          right = middle - 1;      }    }  Exit:    return CFF_Err_Ok;  Found:    kerning->x = pair->value;    goto Exit;  }#undef PAIR_TAG  /*************************************************************************/  /*                                                                       */  /* <Function>                                                            */  /*    Load_Glyph                                                         */  /*                                                                       */  /* <Description>                                                         */  /*    A driver method used to load a glyph within a given glyph slot.    */  /*                                                                       */  /* <Input>                                                               */  /*    slot        :: A handle to the target slot object where the glyph  */  /*                   will be loaded.                                     */  /*                                                                       */  /*    size        :: A handle to the source face size at which the glyph */  /*                   must be scaled, loaded, etc.                        */  /*                                                                       */  /*    glyph_index :: The index of the glyph in the font file.            */  /*                                                                       */  /*    load_flags  :: A flag indicating what to load for this glyph.  The */  /*                   FTLOAD_??? constants can be used to control the     */  /*                   glyph loading process (e.g., whether the outline    */  /*                   should be scaled, whether to load bitmaps or not,   */  /*                   whether to hint the outline, etc).                  */  /*                                                                       */  /* <Return>                                                              */  /*    FreeType error code.  0 means success.                             */  /*                                                                       */  static FT_Error  Load_Glyph( CFF_GlyphSlot  slot,              CFF_Size       size,              FT_UShort      glyph_index,              FT_UInt        load_flags )  {    FT_Error  error;    if ( !slot )      return CFF_Err_Invalid_Slot_Handle;    /* check whether we want a scaled outline or bitmap */    if ( !size )      load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;    if ( load_flags & FT_LOAD_NO_SCALE )      size = NULL;    /* reset the size object if necessary */    if ( size )    {      /* these two object must have the same parent */      if ( size->face != slot->root.face )        return CFF_Err_Invalid_Face_Handle;    }    /* now load the glyph outline if necessary */    error = CFF_Load_Glyph( slot, size, glyph_index, load_flags );    /* force drop-out mode to 2 - irrelevant now */    /* slot->outline.dropout_mode = 2; */    return error;  }  /*************************************************************************/  /*************************************************************************/  /*************************************************************************/  /****                                                                 ****/  /****                                                                 ****/  /****             C H A R A C T E R   M A P P I N G S                 ****/  /****                                                                 ****/  /****                                                                 ****/  /*************************************************************************/  /*************************************************************************/  /*************************************************************************/  static FT_Error  cff_get_glyph_name( CFF_Face    face,                      FT_UInt     glyph_index,                      FT_Pointer  buffer,                      FT_UInt     buffer_max )  {    CFF_Font         font   = (CFF_Font)face->extra.data;    FT_Memory        memory = FT_FACE_MEMORY( face );    FT_String*       gname;    FT_UShort        sid;    PSNames_Service  psnames;    FT_Error         error;    psnames = (PSNames_Service)FT_Get_Module_Interface(                face->root.driver->root.library, "psnames" );    if ( !psnames )    {      FT_ERROR(( "cff_get_glyph_name:" ));      FT_ERROR(( " cannot open CFF & CEF fonts\n" ));      FT_ERROR(( "                   " ));      FT_ERROR(( " without the `PSNames' module\n" ));      error = CFF_Err_Unknown_File_Format;      goto Exit;    }    /* first, locate the sid in the charset table */    sid = font->charset.sids[glyph_index];    /* now, lookup the name itself */    gname = CFF_Get_String( &font->string_index, sid, psnames );