<?php

require_once(HTML2PS_DIR.'ot.class.php');

/**
 * @return Array font metrics hash or null of TTF file could not be parsed
 */
function ReadTTF($fontfile, $map) {
  if (!is_readable($fontfile)) { return null; };

  /**
   * Open font file and read metrics information
   */
  $font = new OpenTypeFile();
  $font->open($fontfile);
  
  $head =& $font->getTable('head');
  $name =& $font->getTable('name');
  $cmap =& $font->getTable('cmap');
  $hmtx =& $font->getTable('hmtx');
  $hhea =& $font->getTable('hhea');
  $post =& $font->getTable('post');
  $subtable =& $cmap->findSubtable(OT_CMAP_PLATFORM_WINDOWS,
                                   OT_CMAP_PLATFORM_WINDOWS_UNICODE);  
  
  /**
   * Prepare initial data
   */
  $widths = array();

  for ($i=0; $i<256; $i++) {
    $code = chr($i);
    if (!isset($map[$code])) {
      $widths[] = 1000;
      continue;
    };
    $ucs2 = $map[$code];

    /**
     * If the font is monospaced, only one entry need be in the array,
     * but  that entry  is required.  The  last entry  applies to  all
     * subsequent glyphs.
     */
    $glyphIndex = $subtable->lookup($ucs2);

    if (!is_null($glyphIndex)) {
      $realIndex = min($glyphIndex, $hhea->_numberOfHMetrics-1);
      $widths[]  = floor($hmtx->_hMetrics[$realIndex]['advanceWidth']*1000/$head->_unitsPerEm);
    } else {
      $widths[] = 1000;
    };
  };

  $font_info = array();

  /**
   * Here we use a hack; as, acording to OT specifications,
   *
   * When  translated  to  ASCII,  these  [...]  strings  must  be
   * identical; no  longer than 63  characters; and restricted  to the
   * printable ASCII subset,  codes 33 through 126, except  for the 10
   * characters: '[', ']', '(', ')', '{', '}', '<', '>', '/', '%'.
   *
   * we can assume that UCS-2 encoded string we receive can be easily 
   * translated to ASCII by removing the high-byte of all two-byte characters 
   */
  $ps_name_ucs2 = $name->lookup(OT_CMAP_PLATFORM_WINDOWS, 
                                OT_CMAP_PLATFORM_WINDOWS_UNICODE, 
                                OT_CMAP_LANGUAGE_WINDOWS_ENGLISH_AMERICAN, 
                                OT_NAME_ID_POSTSCRIPT_NAME);
  $ps_name_ascii = "";
  for ($i=0; $i<strlen($ps_name_ucs2); $i+=2) {
    $ps_name_ascii .= $ps_name_ucs2{$i+1};
  };

  $font_info['FontName']           = $ps_name_ascii;

  $font_info['Weight']             = $name->lookup(null, null, null, OT_NAME_ID_SUBFAMILY_NAME);
  $font_info['ItalicAngle']        = $post->_italicAngle;
  $font_info['IsFixedPitch']       = (bool)$post->_isFixedPitch;
  // $font_info['CapHeight']         
  // $font_info['StdVW']            
  $font_info['Ascender']           = floor($hhea->_ascender*1000/$head->_unitsPerEm);
  $font_info['Descender']          = floor($hhea->_descender*1000/$head->_unitsPerEm);
  $font_info['UnderlineThickness'] = floor($post->_underlineThickness*1000/$head->_unitsPerEm);
  $font_info['UnderlinePosition']  = floor($post->_underlinePosition*1000/$head->_unitsPerEm);
  $font_info['FontBBox']           = array($head->_xMin*1000/$head->_unitsPerEm,
                                           $head->_yMin*1000/$head->_unitsPerEm,
                                           $head->_xMax*1000/$head->_unitsPerEm,
                                           $head->_yMax*1000/$head->_unitsPerEm);
  $font_info['Widths']             = $widths;

  $font->_delete();
  unset($font);
  
  return $font_info;
}

/**
 * @return Array font metrics hash or null of AFM file is missing
 */
function ReadAFM($file, $map) {
  if (!is_readable($file)) { return null; };

  $afm_lines = file($file);
  $widths=array();
  $fm=array();

  foreach ($afm_lines as $l) {
    $e=explode(' ',rtrim($l));

    if (count($e)<2) {
      continue;
    };

    $code=$e[0];
    $param=$e[1];

    if ($code=='C') {
      //Character metrics
      $cc=(int)$e[1];
      $w=$e[4];
      $gn=$e[7];
      if (substr($gn,-4)=='20AC') {
        $gn='Euro';
      };
      
      $widths[$gn]=$w;

      if ($gn=='.notdef') {
        $fm['MissingWidth']=$w;
      };
    }
    elseif($code=='FontName')
      $fm['FontName']=$param;
    elseif($code=='Weight')
      $fm['Weight']=$param;
    elseif($code=='ItalicAngle')
      $fm['ItalicAngle']=(double)$param;
    elseif($code=='Ascender')
      $fm['Ascender']=(int)$param;
    elseif($code=='Descender')
      $fm['Descender']=(int)$param;
    elseif($code=='UnderlineThickness')
      $fm['UnderlineThickness']=(int)$param;
    elseif($code=='UnderlinePosition')
      $fm['UnderlinePosition']=(int)$param;
    elseif($code=='IsFixedPitch')
      $fm['IsFixedPitch']=($param=='true');
    elseif($code=='FontBBox')
      $fm['FontBBox']=array($e[1],$e[2],$e[3],$e[4]);
    elseif($code=='CapHeight')
      $fm['CapHeight']=(int)$param;
    elseif($code=='StdVW')
      $fm['StdVW']=(int)$param;
  }
  
  if(!isset($fm['FontName'])) {
    die('FontName not found');
  };

  if (!isset($widths['.notdef'])) {
    $widths['.notdef']=600;
  };

  if (!isset($widths['Delta']) and isset($widths['increment'])) {
    $widths['Delta']=$widths['increment'];
  };
      
  // Order widths according to map
  for ($i=0; $i<=255; $i++) {
    if(!isset($widths[$map[chr($i)]])) {
      error_log('<B>Warning:</B> character '.$map[chr($i)].' is missing<BR>');
      $widths[$i]=$widths['.notdef'];
    } else {
      $widths[$i]=$widths[$map[chr($i)]];
    };
  };

  $fm['Widths']=$widths;
  return $fm;
}

function MakeFontDescriptor($fm,$symbolic) {
  //Ascent
  $asc=(isset($fm['Ascender']) ? $fm['Ascender'] : 1000);
  $fd="array('Ascent'=>".$asc;

  //Descent
  $desc=(isset($fm['Descender']) ? $fm['Descender'] : -200);
  $fd.=",'Descent'=>".$desc;

  //CapHeight
  if (isset($fm['CapHeight'])) {
    $ch=$fm['CapHeight'];
  }  elseif(isset($fm['CapXHeight'])) {
    $ch=$fm['CapXHeight'];
  } else {
    $ch=$asc;
  };
  $fd.=",'CapHeight'=>".$ch;

  //Flags
  $flags=0;
  if (isset($fm['IsFixedPitch']) and $fm['IsFixedPitch']) {
    $flags+=1<<0;
  };

  if ($symbolic) {
    $flags+=1<<2;
  };

  if (!$symbolic) {
    $flags+=1<<5;
  };

  if (isset($fm['ItalicAngle']) and $fm['ItalicAngle']!=0) {
    $flags+=1<<6;
  };

  $fd.=",'Flags'=>".$flags;

  //FontBBox
  if (isset($fm['FontBBox'])) {
    $fbb=$fm['FontBBox'];
  } else {
    $fbb=array(0,$des-100,1000,$asc+100);
  };

  $fd.=",'FontBBox'=>'[".$fbb[0].' '.$fbb[1].' '.$fbb[2].' '.$fbb[3]."]'";

  //ItalicAngle
  $ia=(isset($fm['ItalicAngle']) ? $fm['ItalicAngle'] : 0);
  $fd.=",'ItalicAngle'=>".$ia;

  //StemV
  if (isset($fm['StdVW'])) {
    $stemv=$fm['StdVW'];
  } elseif(isset($fm['Weight']) and eregi('(bold|black)',$fm['Weight'])) {
    $stemv=120;
  } else {
    $stemv=70;
  };
  $fd.=",'StemV'=>".$stemv;

  //MissingWidth
  if (isset($fm['MissingWidth'])) {
    $fd.=",'MissingWidth'=>".$fm['MissingWidth'];
  };
  $fd.=')';

  return $fd;
}

function MakeWidthArray($fm) {
  //Make character width array
  $s="array(\n\t";
  $cw=$fm['Widths'];
  for ($i=0; $i<=255; $i++) {
    if (chr($i)=="'") {
      $s.="'\\''";
    } elseif (chr($i)=="\\") {
      $s.="'\\\\'";
    } elseif($i>=32 and $i<=126) {
      $s.="'".chr($i)."'";
    } else {
      $s.="chr($i)";
    };
    $s.='=>'.$fm['Widths'][$i];
    if ($i<255) {
      $s.=',';
    };

    if(($i+1)%22==0) {
      $s.="\n\t";
    };
  }
  $s.=')';
  return $s;
}

function MakeFontEncoding($map) {
  //Build differences from reference encoding
  $manager = ManagerEncoding::get();
  $ref = $manager->get_encoding_glyphs('windows-1252');

  $s='';
  $last=0;
  for($i=32;$i<=255;$i++) {
    if ($map[chr($i)]!=$ref[chr($i)]) {
      if ($i!=$last+1) {
        $s.=$i.' ';
      };
      $last=$i;
      $s.='/'.$map[chr($i)].' ';
    };
  }

  return rtrim($s);
}

function MakeFontCMap($encoding) {
  //Build differences from reference encoding
  $manager = ManagerEncoding::get();
  $ref = $manager->get_encoding_vector($encoding);

  $s  = "array(\n";
  foreach ($ref as $char => $ucs) {
    $s .= sprintf("0x%02X => 0x%04X,\n", ord($char), $ucs);
  };
  $s .= ")";

  return trim($s);
}

function SaveToFile($file,$s,$mode='t')
{
  $f=fopen($file,'w'.$mode);
  if(!$f)
    die('Can\'t write to file '.$file);
  fwrite($f,$s,strlen($s));
  fclose($f);
}

function ReadShort($f)
{
  $a=unpack('n1n',fread($f,2));
  return $a['n'];
}

function ReadLong($f)
{
  $a=unpack('N1N',fread($f,4));
  return $a['N'];
}

function CheckTTF($file)
{
  //Check if font license allows embedding
  $f=fopen($file,'rb');
  if(!$f)
    die('<B>Error:</B> Can\'t open '.$file);
  //Extract number of tables
  fseek($f,4,SEEK_CUR);
  $nb=ReadShort($f);
  fseek($f,6,SEEK_CUR);
  //Seek OS/2 table
  $found=false;

  for ($i=0;$i<$nb;$i++) {
    if (fread($f,4)=='OS/2') {
      $found=true;
      break;
    }
    fseek($f,12,SEEK_CUR);
  };

  if (!$found) {
    fclose($f);
    return;
  };

  fseek($f,4,SEEK_CUR);
  $offset=ReadLong($f);
  fseek($f,$offset,SEEK_SET);

  //Extract fsType flags
  fseek($f,8,SEEK_CUR);
  $fsType=ReadShort($f);
  $rl=($fsType & 0x02)!=0;
  $pp=($fsType & 0x04)!=0;
  $e=($fsType & 0x08)!=0;
  fclose($f);
  if ($rl and !$pp and !$e) {
    echo '<B>Warning:</B> font license does not allow embedding';
  };
}

/*******************************************************************************
 * $fontfile : chemin du fichier TTF (ou chaîne vide si pas d'incorporation)    *
 * $afmfile :  chemin du fichier AFM                                            *
 * $enc :      encodage (ou chaîne vide si la police est symbolique)            *
 * $patch :    patch optionnel pour l'encodage                                  *
 * $type :     type de la police si $fontfile est vide                          *
 *******************************************************************************/
function MakeFont($fontfile, $afmfile, $destdir, $destfile, $enc) {
  // Generate a font definition file
  set_magic_quotes_runtime(0);
  ini_set('auto_detect_line_endings','1');

  $manager = ManagerEncoding::get();
  $map     = $manager->get_encoding_glyphs($enc);

  $fm = ReadAFM($afmfile, $map);

  if (is_null($fm)) {
    error_log(sprintf("Notice: Missing AFM file '%s'; attempting to parse font file '%s' directly",
                      $afmfile,
                      $fontfile));
    
    $fm = ReadTTF($fontfile, $manager->get_encoding_vector($enc));

    if (is_null($fm)) {
      die(sprintf("Cannot get font metrics for '%s'", $fontfile));
    };
  }

  $diff = MakeFontEncoding($map);
  $cmap = MakeFontCMap($enc);
  $fd   = MakeFontDescriptor($fm,empty($map));

  //Find font type
  if ($fontfile) {
    $ext=strtolower(substr($fontfile,-3));
    if ($ext=='ttf') { 
      $type='TrueType';
    }  elseif($ext=='pfb') {
      $type='Type1';
    } else {
      die('<B>Error:</B> unrecognized font file extension: '.$ext);
    };
  } else {
    if ($type!='TrueType' and $type!='Type1') {
      die('<B>Error:</B> incorrect font type: '.$type);
    };
  }

  //Start generation
  $s='<?php'."\n";
  $s.='$type=\''.$type."';\n";
  $s.='$name=\''.$fm['FontName']."';\n";
  $s.='$desc='.$fd.";\n";
  if (!isset($fm['UnderlinePosition'])) {
    $fm['UnderlinePosition']=-100;
  };
  if (!isset($fm['UnderlineThickness'])) {
    $fm['UnderlineThickness']=50;
  };
  $s.='$up='.$fm['UnderlinePosition'].";\n";
  $s.='$ut='.$fm['UnderlineThickness'].";\n";
  $w=MakeWidthArray($fm);
  $s.='$cw='.$w.";\n";
  $s.='$enc=\''.$enc."';\n";
  $s.='$diff=\''.$diff."';\n";
  $s.='$cmap='.$cmap.";\n";

  $basename=substr(basename($afmfile),0,-4);

  if ($fontfile) {
    //Embedded font
    if (!file_exists($fontfile)) {
      die('<B>Error:</B> font file not found: '.$fontfile);
    };

    if ($type=='TrueType') {
      CheckTTF($fontfile);
    };

    $f=fopen($fontfile,'rb');
    if (!$f) {
      die('<B>Error:</B> Can\'t open '.$fontfile);
    };

    $file=fread($f,filesize($fontfile));
    fclose($f);
    if ($type=='Type1') {
      //Find first two sections and discard third one
      $header=(ord($file{0})==128);
      if ($header) {
        //Strip first binary header
        $file=substr($file,6);
      }
      $pos=strpos($file,'eexec');
      if(!$pos) {
        die('<B>Error:</B> font file does not seem to be valid Type1');
      };
      $size1=$pos+6;
      if($header and ord($file{$size1})==128) {
        //Strip second binary header
        $file=substr($file,0,$size1).substr($file,$size1+6);
      }
      $pos=strpos($file,'00000000');
      if (!$pos) {
        die('<B>Error:</B> font file does not seem to be valid Type1');
      };
      
      $size2=$pos-$size1;
      $file=substr($file,0,$size1+$size2);
    }

    $gzcompress_exists = function_exists('gzcompress');
    if ($gzcompress_exists) {
      $cmp = $basename.'.z';
      SaveToFile($destdir.$cmp, gzcompress($file), 'b');

      $s.='$file=\''.$cmp."';\n";
    } else {
      $cmp = $basename.'.ttf';
      SaveToFile($destdir.$cmp, $file, 'b');

      $s.='$file=\''.basename($fontfile)."';\n";
      error_log('Notice: font file could not be compressed (zlib extension not available)');
    }
    
    if ($type=='Type1') {
      $s.='$size1='.$size1.";\n";
      $s.='$size2='.$size2.";\n";
    } else {
      $s.='$originalsize='.filesize($fontfile).";\n";
    }
  } else {
    //Not embedded font
    $s.='$file='."'';\n";
  }

  $s.="?>\n";
  SaveToFile($destdir.$destfile,$s);
}
?>