/***************************************************************************//*                                                                         *//*  cffdrivr.c                                                             *//*                                                                         *//*    OpenType font driver implementation (body).                          *//*                                                                         *//*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 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_SERVICE_POSTSCRIPT_CMAPS_H#include FT_SERVICE_POSTSCRIPT_INFO_H#include FT_SERVICE_TT_CMAP_H#include "cffdrivr.h"#include "cffgload.h"#include "cffload.h"#include "cffcmap.h"#include "cfferrs.h"#include FT_SERVICE_XFREE86_NAME_H#include FT_SERVICE_GLYPH_DICT_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>                                                            */  /*    cff_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.             */  /*                                                                       */  FT_CALLBACK_DEF( FT_Error )  cff_get_kerning( FT_Face     ttface,          /* TT_Face */                   FT_UInt     left_glyph,                   FT_UInt     right_glyph,                   FT_Vector*  kerning )  {    TT_Face       face = (TT_Face)ttface;    SFNT_Service  sfnt = (SFNT_Service)face->sfnt;    kerning->x = 0;    kerning->y = 0;    if ( sfnt )      kerning->x = sfnt->get_kerning( face, left_glyph, right_glyph );    return CFF_Err_Ok;  }#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 */  /*                   FT_LOAD_??? 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.                             */  /*                                                                       */  FT_CALLBACK_DEF( FT_Error )  Load_Glyph( FT_GlyphSlot  cffslot,        /* CFF_GlyphSlot */              FT_Size       cffsize,        /* CFF_Size      */              FT_UInt       glyph_index,              FT_Int32      load_flags )  {    FT_Error  error;    CFF_GlyphSlot  slot = (CFF_GlyphSlot)cffslot;    CFF_Size       size = (CFF_Size)cffsize;    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 objects must have the same parent */      if ( cffsize->face != cffslot->face )        return CFF_Err_Invalid_Face_Handle;    }    /* now load the glyph outline if necessary */    error = cff_slot_load( slot, size, glyph_index, load_flags );    /* force drop-out mode to 2 - irrelevant now */    /* slot->outline.dropout_mode = 2; */    return error;  } /*  *  GLYPH DICT SERVICE  *  */  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;    FT_Service_PsCMaps  psnames;    FT_Error            error;    FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );    if ( !psnames )    {      FT_ERROR(( "cff_get_glyph_name:" ));      FT_ERROR(( " cannot get glyph name from 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_index_get_sid_string( &font->string_index, sid, psnames );    if ( gname && buffer_max > 0 )    {      FT_UInt  len = (FT_UInt)ft_strlen( gname );      if ( len >= buffer_max )        len = buffer_max - 1;