generated from jric11/baseProject
742 lines
24 KiB
PHP
742 lines
24 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
/**
|
|
* Import.php
|
|
*
|
|
* @since 2011-05-23
|
|
* @category Library
|
|
* @package PdfFont
|
|
* @author Nicola Asuni <info@tecnick.com>
|
|
* @copyright 2011-2026 Nicola Asuni - Tecnick.com LTD
|
|
* @license https://www.gnu.org/copyleft/lesser.html GNU-LGPL v3 (see LICENSE)
|
|
* @link https://github.com/tecnickcom/tc-lib-pdf-font
|
|
*
|
|
* This file is part of tc-lib-pdf-font software library.
|
|
*/
|
|
|
|
namespace Com\Tecnick\Pdf\Font;
|
|
|
|
use Com\Tecnick\File\Byte;
|
|
use Com\Tecnick\File\Dir;
|
|
use Com\Tecnick\File\Exception as FileException;
|
|
use Com\Tecnick\File\File as ObjFile;
|
|
use Com\Tecnick\Pdf\Font\Exception as FontException;
|
|
use Com\Tecnick\Pdf\Font\Import\Core;
|
|
use Com\Tecnick\Pdf\Font\Import\TrueType;
|
|
use Com\Tecnick\Pdf\Font\Import\TypeOne;
|
|
use Com\Tecnick\Unicode\Data\Encoding;
|
|
|
|
/**
|
|
* Com\Tecnick\Pdf\Font\Import
|
|
*
|
|
* @since 2011-05-23
|
|
* @category Library
|
|
* @package PdfFont
|
|
* @author Nicola Asuni <info@tecnick.com>
|
|
* @copyright 2011-2026 Nicola Asuni - Tecnick.com LTD
|
|
* @license https://www.gnu.org/copyleft/lesser.html GNU-LGPL v3 (see LICENSE)
|
|
* @link https://github.com/tecnickcom/tc-lib-pdf-font
|
|
*
|
|
* @phpstan-import-type TFontData from Load
|
|
*
|
|
* @SuppressWarnings("PHPMD.ExcessiveClassComplexity")
|
|
*/
|
|
class Import
|
|
{
|
|
/**
|
|
* File helper used to load font definition files.
|
|
*/
|
|
protected ObjFile $fileHelper;
|
|
|
|
/**
|
|
* True when the file helper is created internally by this class.
|
|
*/
|
|
protected bool $ownsFileHelper = false;
|
|
|
|
/**
|
|
* Content of the input font file
|
|
*/
|
|
protected string $font = '';
|
|
|
|
/**
|
|
* Object used to read font bytes
|
|
*/
|
|
protected Byte $fbyte;
|
|
|
|
/**
|
|
* Extracted font metrics
|
|
*
|
|
* @var TFontData
|
|
*/
|
|
protected array $fdt = [
|
|
'Ascender' => 0,
|
|
'Ascent' => 0,
|
|
'AvgWidth' => 0.0,
|
|
'CapHeight' => 0,
|
|
'CharacterSet' => '',
|
|
'Descender' => 0,
|
|
'Descent' => 0,
|
|
'EncodingScheme' => '',
|
|
'FamilyName' => '',
|
|
'Flags' => 0,
|
|
'FontBBox' => [],
|
|
'FontName' => '',
|
|
'FullName' => '',
|
|
'IsFixedPitch' => false,
|
|
'ItalicAngle' => 0,
|
|
'Leading' => 0,
|
|
'MaxWidth' => 0,
|
|
'MissingWidth' => 0,
|
|
'StdHW' => 0,
|
|
'StdVW' => 0,
|
|
'StemH' => 0,
|
|
'StemV' => 0,
|
|
'UnderlinePosition' => 0,
|
|
'UnderlineThickness' => 0,
|
|
'Version' => '',
|
|
'Weight' => '',
|
|
'XHeight' => 0,
|
|
'bbox' => '',
|
|
'cbbox' => [],
|
|
'cidinfo' => [
|
|
'Ordering' => '',
|
|
'Registry' => '',
|
|
'Supplement' => 0,
|
|
'uni2cid' => [],
|
|
],
|
|
'compress' => false,
|
|
'ctg' => '',
|
|
'ctgdata' => [],
|
|
'cw' => [],
|
|
'cwu' => [],
|
|
'datafile' => '',
|
|
'desc' => [
|
|
'Ascent' => 0,
|
|
'AvgWidth' => 0,
|
|
'CapHeight' => 0,
|
|
'Descent' => 0,
|
|
'Flags' => 0,
|
|
'FontBBox' => '',
|
|
'ItalicAngle' => 0,
|
|
'Leading' => 0,
|
|
'MaxWidth' => 0,
|
|
'MissingWidth' => 0,
|
|
'StemH' => 0,
|
|
'StemV' => 0,
|
|
'XHeight' => 0,
|
|
],
|
|
'diff' => '',
|
|
'diff_n' => 0,
|
|
'dir' => '',
|
|
'dw' => 0,
|
|
'enc' => '',
|
|
'enc_map' => [],
|
|
'encodingTables' => [],
|
|
'encoding_id' => 0,
|
|
'encrypted' => '',
|
|
'fakestyle' => false,
|
|
'family' => '',
|
|
'file' => '',
|
|
'file_n' => 0,
|
|
'file_name' => '',
|
|
'i' => 0,
|
|
'ifile' => '',
|
|
'indexToLoc' => [],
|
|
'input_file' => '',
|
|
'isUnicode' => false,
|
|
'italicAngle' => 0,
|
|
'key' => '',
|
|
'lenIV' => 0,
|
|
'length1' => 0,
|
|
'length2' => 0,
|
|
'linked' => false,
|
|
'mode' => [
|
|
'bold' => false,
|
|
'italic' => false,
|
|
'linethrough' => false,
|
|
'overline' => false,
|
|
'underline' => false,
|
|
],
|
|
'n' => 0,
|
|
'name' => '',
|
|
'numGlyphs' => 0,
|
|
'numHMetrics' => 0,
|
|
'originalsize' => 0,
|
|
'pdfa' => false,
|
|
'platform_id' => 0,
|
|
'settype' => '',
|
|
'short_offset' => false,
|
|
'size1' => 0,
|
|
'size2' => 0,
|
|
'style' => '',
|
|
'subset' => false,
|
|
'subsetchars' => [],
|
|
'table' => [],
|
|
'tot_num_glyphs' => 0,
|
|
'type' => '',
|
|
'underlinePosition' => 0,
|
|
'underlineThickness' => 0,
|
|
'unicode' => false,
|
|
'unitsPerEm' => 0,
|
|
'up' => 0,
|
|
'urk' => 0.0,
|
|
'ut' => 0,
|
|
'weight' => '',
|
|
];
|
|
|
|
/**
|
|
* Import the specified font and create output files.
|
|
*
|
|
* @param string $file Font file to process
|
|
* @param string $output_path Output path for generated font files (must be writeable by the web server).
|
|
* Leave null for default font folder.
|
|
* @param string|FontType $type Font type (or FontType enum case). Leave empty for autodetect mode.
|
|
* Valid values are:
|
|
* Core (AFM - Adobe Font Metrics) TrueTypeUnicode TrueType
|
|
* Type1 CID0JP (CID-0 Japanese) CID0KR (CID-0 Korean) CID0CS
|
|
* (CID-0 Chinese Simplified) CID0CT (CID-0 Chinese Traditional)
|
|
* @param string $encoding Name of the encoding table to use. Leave empty for default mode.
|
|
* Omit this parameter for TrueType Unicode and symbolic fonts like
|
|
* Symbol or ZapfDingBats.
|
|
* @param int $flags Unsigned 32-bit integer containing flags specifying various characteristics
|
|
* of the font as described in "PDF32000:2008 - 9.8.2 Font Descriptor Flags":
|
|
* +1 for fixed width font +4 for symbol or +32 for non-symbol +64 for italic
|
|
* Note: Fixed and Italic mode are generally autodetected, so you have to set
|
|
* it to 32 = non-symbolic font (default) or 4 = symbolic font.
|
|
* @param int $platform_id Platform ID for CMAP table to extract.
|
|
* For a Unicode font for Windows this
|
|
* value should be 3, for Macintosh
|
|
* should be 1.
|
|
* @param int $encoding_id Encoding ID for CMAP table to extract.
|
|
* For a Unicode font for Windows this
|
|
* value should be 1, for Macintosh
|
|
* should be 0. When Platform ID is 3,
|
|
* legal values for Encoding ID are: 0 =
|
|
* Symbol, 1 = Unicode, 2 = ShiftJIS, 3 =
|
|
* PRC, 4 = Big5, 5 = Wansung, 6 = Johab,
|
|
* 7 = Reserved, 8 = Reserved, 9 =
|
|
* Reserved, 10 = UCS-4.
|
|
* @param bool $linked If true, links the font file to system font instead of copying the font data
|
|
* (not transportable). Note: this option do not work with Type1 fonts.
|
|
* @param ObjFile|null $fileHelper Optional file helper for font loading.
|
|
*
|
|
* @throws FileException in case of error
|
|
* @throws FontException in case of error
|
|
* @throws \RangeException in case of byte-range errors
|
|
*/
|
|
public function __construct(
|
|
string $file,
|
|
string $output_path = '',
|
|
string|FontType $type = '',
|
|
string $encoding = '',
|
|
int $flags = 32,
|
|
int $platform_id = 3,
|
|
int $encoding_id = 1,
|
|
bool $linked = false,
|
|
?ObjFile $fileHelper = null,
|
|
) {
|
|
$this->ownsFileHelper = $fileHelper === null;
|
|
$this->fileHelper = $fileHelper ?? new ObjFile(allowedPaths: self::buildAllowedPaths($file));
|
|
$validatedFile = $file;
|
|
if (!$this->fileHelper->isValidFile($validatedFile)) {
|
|
throw new FontException('Invalid font file name: ' . $file);
|
|
}
|
|
|
|
$this->fdt['input_file'] = $file;
|
|
$this->fdt['file_name'] = $this->makeFontName($file);
|
|
if ($this->fdt['file_name'] === '') {
|
|
throw new FontException('the font name is empty');
|
|
}
|
|
|
|
$this->fdt['dir'] = $this->findOutputPath($output_path);
|
|
if ($this->ownsFileHelper) {
|
|
$this->fileHelper->setAllowedPaths(self::buildAllowedPaths($file, $this->fdt['dir']));
|
|
}
|
|
|
|
$this->fdt['datafile'] = $this->fdt['dir'] . $this->fdt['file_name'] . '.json';
|
|
if (\file_exists($this->fdt['datafile'])) {
|
|
throw new FontException('this font has been already imported: ' . $this->fdt['datafile']);
|
|
}
|
|
|
|
// get font data
|
|
if (!is_file($file)) {
|
|
throw new FontException('invalid font file: ' . $file);
|
|
}
|
|
|
|
if (($font = $this->fileHelper->getLocalFileData($file)) === false) {
|
|
throw new FontException('unable to read the input font file: ' . $file);
|
|
}
|
|
|
|
$this->font = $font;
|
|
|
|
$this->fbyte = new Byte($this->font);
|
|
|
|
if ($type instanceof FontType) {
|
|
$type = $type->value;
|
|
}
|
|
|
|
$this->fdt['settype'] = $type;
|
|
$this->fdt['type'] = $this->getFontType($type);
|
|
$this->fdt['isUnicode'] = $this->fdt['type'] === 'TrueTypeUnicode' || $this->fdt['type'] === 'cidfont0';
|
|
$this->fdt['Flags'] = $flags;
|
|
$this->initFlags();
|
|
$this->fdt['enc'] = $this->getEncodingTable($encoding);
|
|
$this->fdt['diff'] = $this->getEncodingDiff();
|
|
$this->fdt['originalsize'] = \strlen($this->font);
|
|
$this->fdt['ctg'] = $this->fdt['file_name'] . '.ctg.z';
|
|
$this->fdt['platform_id'] = $platform_id;
|
|
$this->fdt['encoding_id'] = $encoding_id;
|
|
$this->fdt['linked'] = $linked;
|
|
|
|
$processor = match ($this->fdt['type']) {
|
|
'Core' => new Core(font: $this->font, fdt: $this->fdt, fileHelper: $this->fileHelper),
|
|
'Type1' => new TypeOne(font: $this->font, fdt: $this->fdt, fileHelper: $this->fileHelper),
|
|
default => new TrueType(
|
|
font: $this->font,
|
|
fdt: $this->fdt,
|
|
fileHelper: $this->fileHelper,
|
|
fbyte: $this->fbyte,
|
|
),
|
|
};
|
|
|
|
$this->fdt = $processor->getFontMetrics();
|
|
|
|
$this->saveFontData();
|
|
}
|
|
|
|
/**
|
|
* Get all the extracted font metrics
|
|
*
|
|
* @return TFontData
|
|
*/
|
|
public function getFontMetrics(): array
|
|
{
|
|
return $this->fdt;
|
|
}
|
|
|
|
/**
|
|
* Get the output font name
|
|
*/
|
|
public function getFontName(): string
|
|
{
|
|
return $this->fdt['file_name'];
|
|
}
|
|
|
|
/**
|
|
* Initialize font flags from font name
|
|
*/
|
|
protected function initFlags(): void
|
|
{
|
|
$filename = \strtolower(\basename($this->fdt['input_file']));
|
|
|
|
if (
|
|
\str_contains($filename, 'mono')
|
|
|| \str_contains($filename, 'courier')
|
|
|| \str_contains($filename, 'fixed')
|
|
) {
|
|
$this->fdt['Flags'] |= 1;
|
|
}
|
|
|
|
if (\str_contains($filename, 'symbol') || \str_contains($filename, 'zapfdingbats')) {
|
|
$this->fdt['Flags'] |= 4;
|
|
}
|
|
|
|
if (\str_contains($filename, 'italic') || \str_contains($filename, 'oblique')) {
|
|
$this->fdt['Flags'] |= 64;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check for unsafe path components that were previously rejected by the
|
|
* file helper's internal validation.
|
|
*/
|
|
private static function hasUnsafePath(string $path): bool
|
|
{
|
|
return (
|
|
$path !== ''
|
|
&& (
|
|
\str_contains($path, '://')
|
|
|| \str_contains(\str_ireplace('%2E', '.', \html_entity_decode($path, ENT_QUOTES, 'UTF-8')), '..')
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Build trusted roots for local file validation.
|
|
*
|
|
* The minimum roots required by Import are:
|
|
* - the input font directory (read access)
|
|
* - the output directory (write access), when available
|
|
*
|
|
* For each root we include both the given path and, when resolvable,
|
|
* its canonical realpath to support symlinked directories.
|
|
*
|
|
* @return array<string>
|
|
*/
|
|
private static function buildAllowedPaths(string $fontFile, string $outputDir = ''): array
|
|
{
|
|
$roots = [];
|
|
|
|
$fontDir = \dirname($fontFile);
|
|
if ($fontDir !== '' && $fontDir !== '.') {
|
|
$roots[] = $fontDir;
|
|
}
|
|
|
|
if ($outputDir !== '') {
|
|
$roots[] = $outputDir;
|
|
}
|
|
|
|
$allowed = [];
|
|
foreach ($roots as $root) {
|
|
$normalized = \rtrim($root, '/\\');
|
|
if ($normalized === '') {
|
|
continue;
|
|
}
|
|
|
|
$allowed[] = $normalized;
|
|
|
|
$resolved = \realpath($normalized);
|
|
if ($resolved !== false) {
|
|
$allowed[] = \rtrim($resolved, '/\\');
|
|
}
|
|
}
|
|
|
|
return \array_values(\array_unique($allowed));
|
|
}
|
|
|
|
/**
|
|
* Save the exported metadata font file
|
|
*
|
|
* @throws FileException
|
|
* @throws FontException
|
|
*
|
|
* @SuppressWarnings("PHPMD.CyclomaticComplexity")
|
|
* @SuppressWarnings("PHPMD.NPathComplexity")
|
|
* @SuppressWarnings("PHPMD.ExcessiveMethodLength")
|
|
*/
|
|
protected function saveFontData(): void
|
|
{
|
|
$missingWidth = $this->fdt['MissingWidth'];
|
|
$pfile =
|
|
'{"type":"'
|
|
. $this->fdt['type']
|
|
. '"'
|
|
. ',"name":"'
|
|
. $this->fdt['name']
|
|
. '"'
|
|
. ',"up":'
|
|
. $this->fdt['underlinePosition']
|
|
. ',"ut":'
|
|
. $this->fdt['underlineThickness']
|
|
. ',"dw":'
|
|
. ($missingWidth !== null && $missingWidth > 0 ? $missingWidth : $this->fdt['AvgWidth'])
|
|
. ',"diff":"'
|
|
. $this->fdt['diff']
|
|
. '"'
|
|
. ',"platform_id":'
|
|
. $this->fdt['platform_id']
|
|
. ',"encoding_id":'
|
|
. $this->fdt['encoding_id'];
|
|
|
|
if ($this->fdt['type'] === 'Core') {
|
|
// Core
|
|
$pfile .= ',"enc":""';
|
|
} elseif ($this->fdt['type'] === 'Type1') {
|
|
// Type 1
|
|
$pfile .=
|
|
',"enc":"'
|
|
. $this->fdt['enc']
|
|
. '"'
|
|
. ',"file":"'
|
|
. $this->fdt['file']
|
|
. '"'
|
|
. ',"size1":'
|
|
. $this->fdt['size1']
|
|
. ',"size2":'
|
|
. $this->fdt['size2'];
|
|
} else {
|
|
$pfile .= ',"originalsize":' . $this->fdt['originalsize'];
|
|
if ($this->fdt['type'] === 'cidfont0') {
|
|
$pfile .= ',' . (UniToCid::TYPE[$this->fdt['settype']] ?? '');
|
|
} else {
|
|
// TrueType
|
|
$pfile .=
|
|
',"enc":"'
|
|
. $this->fdt['enc']
|
|
. '"'
|
|
. ',"file":"'
|
|
. $this->fdt['file']
|
|
. '"'
|
|
. ',"ctg":"'
|
|
. $this->fdt['ctg']
|
|
. '"';
|
|
// create CIDToGIDMap
|
|
$cidtogidmap = \str_pad('', 131_072, "\x00"); // (256 * 256 * 2) = 131072
|
|
foreach ($this->fdt['ctgdata'] as $cid => $gid) {
|
|
$cidtogidmap = $this->updateCIDtoGIDmap($cidtogidmap, (int) $cid, (int) $gid);
|
|
}
|
|
|
|
// store compressed CIDToGIDMap
|
|
$fpt = $this->fileHelper->fopenLocal($this->fdt['dir'] . $this->fdt['ctg'], 'wb');
|
|
|
|
$cmpr = \gzcompress($cidtogidmap);
|
|
if ($cmpr === false) {
|
|
throw new FontException('unable to compress CIDToGIDMap');
|
|
}
|
|
|
|
\fwrite($fpt, $cmpr);
|
|
\fclose($fpt);
|
|
}
|
|
}
|
|
|
|
if ($this->fdt['isUnicode']) {
|
|
$pfile .= ',"isUnicode":true';
|
|
} else {
|
|
$pfile .= ',"isUnicode":false';
|
|
}
|
|
|
|
$pfile .=
|
|
',"desc":{"Flags":'
|
|
. $this->fdt['Flags']
|
|
. ',"FontBBox":"['
|
|
. $this->fdt['bbox']
|
|
. ']"'
|
|
. ',"ItalicAngle":'
|
|
. $this->fdt['italicAngle']
|
|
. ',"Ascent":'
|
|
. $this->fdt['Ascent']
|
|
. ',"Descent":'
|
|
. $this->fdt['Descent']
|
|
. ',"Leading":'
|
|
. $this->fdt['Leading']
|
|
. ',"CapHeight":'
|
|
. $this->fdt['CapHeight']
|
|
. ',"XHeight":'
|
|
. $this->fdt['XHeight']
|
|
. ',"StemV":'
|
|
. $this->fdt['StemV']
|
|
. ',"StemH":'
|
|
. $this->fdt['StemH']
|
|
. ',"AvgWidth":'
|
|
. $this->fdt['AvgWidth']
|
|
. ',"MaxWidth":'
|
|
. $this->fdt['MaxWidth']
|
|
. ',"MissingWidth":'
|
|
. (string) ($missingWidth ?? 0)
|
|
. '}';
|
|
if ($this->fdt['cbbox'] !== []) {
|
|
$ccboxstr = '';
|
|
foreach ($this->fdt['cbbox'] as $cid => $bbox) {
|
|
$box = \array_pad(\array_values($bbox), 4, 0);
|
|
$ccboxstr .= ',"' . $cid . '":[' . $box[0] . ',' . $box[1] . ',' . $box[2] . ',' . $box[3] . ']';
|
|
}
|
|
|
|
$pfile .= ',"cbbox":{' . \substr($ccboxstr, 1) . '}';
|
|
}
|
|
|
|
if ($this->fdt['cw'] !== []) {
|
|
$cwstr = '';
|
|
foreach ($this->fdt['cw'] as $cid => $width) {
|
|
$cwstr .= ',"' . $cid . '":' . $width;
|
|
}
|
|
|
|
$pfile .= ',"cw":{' . \substr($cwstr, 1) . '}';
|
|
}
|
|
|
|
if ($this->fdt['cwu'] !== []) {
|
|
$cwustr = '';
|
|
foreach ($this->fdt['cwu'] as $codepoint => $width) {
|
|
$cwustr .= ',"' . $codepoint . '":' . $width;
|
|
}
|
|
|
|
$pfile .= ',"cwu":{' . \substr($cwustr, 1) . '}';
|
|
}
|
|
|
|
$pfile .= '}' . "\n";
|
|
|
|
// store file
|
|
$fpt = $this->fileHelper->fopenLocal($this->fdt['datafile'], 'wb');
|
|
\fwrite($fpt, $pfile);
|
|
\fclose($fpt);
|
|
}
|
|
|
|
/**
|
|
* Make the output font name
|
|
*
|
|
* @param string $font_file Input font file
|
|
*
|
|
* @throws FontException
|
|
*/
|
|
protected function makeFontName(string $font_file): string
|
|
{
|
|
$font_path_parts = \pathinfo($font_file);
|
|
if ($font_path_parts['filename'] === '') {
|
|
throw new FontException('Invalid font file name: ' . $font_file);
|
|
}
|
|
|
|
$fname = \preg_replace('/[^a-z0-9_]/', '', \strtolower($font_path_parts['filename']));
|
|
if ($fname === null) {
|
|
throw new FontException('Invalid font file name: ' . $font_file);
|
|
}
|
|
|
|
return \str_replace(['bold', 'oblique', 'italic', 'regular'], ['b', 'i', 'i', ''], $fname);
|
|
}
|
|
|
|
/**
|
|
* Find the path where to store the processed font.
|
|
*
|
|
* @param string $output_path Output path for generated font files (must be writeable by the web server).
|
|
* Leave null for default font folder (K_PATH_FONTS).
|
|
*/
|
|
protected function findOutputPath(string $output_path = ''): string
|
|
{
|
|
if ($output_path !== '' && !self::hasUnsafePath($output_path) && \is_writable($output_path)) {
|
|
return $output_path;
|
|
}
|
|
|
|
if (\defined('K_PATH_FONTS')) {
|
|
$kpathfonts = (string) \constant('K_PATH_FONTS');
|
|
if ($kpathfonts !== '' && \is_writable($kpathfonts)) {
|
|
return $kpathfonts;
|
|
}
|
|
}
|
|
|
|
$dirobj = new Dir();
|
|
$dir = $dirobj->findParentDir('fonts', __DIR__);
|
|
if ($dir === '/') {
|
|
$dir = \sys_get_temp_dir();
|
|
}
|
|
|
|
if (!\str_ends_with($dir, '/')) {
|
|
$dir .= '/';
|
|
}
|
|
|
|
return $dir;
|
|
}
|
|
|
|
/**
|
|
* Get the font type
|
|
*
|
|
* @param string $font_type Font type. Leave empty for autodetect mode.
|
|
*
|
|
* @throws FontException
|
|
*/
|
|
protected function getFontType(string $font_type): string
|
|
{
|
|
// autodetect font type
|
|
if ($font_type === '') {
|
|
if (\str_starts_with($this->font, 'StartFontMetrics')) {
|
|
// AFM type - we use this type only for the 14 Core fonts
|
|
return 'Core';
|
|
}
|
|
|
|
if (\str_starts_with($this->font, 'OTTO')) {
|
|
throw new FontException('Unsupported font format: OpenType with CFF data');
|
|
}
|
|
|
|
if ($this->fbyte->getULong(0) === 0x1_0000) {
|
|
return 'TrueTypeUnicode';
|
|
}
|
|
|
|
return 'Type1';
|
|
}
|
|
|
|
if (\str_starts_with($font_type, 'CID0')) {
|
|
return 'cidfont0';
|
|
}
|
|
|
|
if (\in_array($font_type, ['Core', 'Type1', 'TrueType', 'TrueTypeUnicode'], true)) {
|
|
return $font_type;
|
|
}
|
|
|
|
throw new FontException('unknown or unsupported font type: ' . $font_type);
|
|
}
|
|
|
|
/**
|
|
* Get the encoding table
|
|
*
|
|
* @param string $encoding Name of the encoding table to use. Leave empty for default mode.
|
|
* Omit this parameter for TrueType Unicode and symbolic fonts like
|
|
* Symbol or ZapfDingBats.
|
|
*
|
|
* @throws FontException
|
|
*/
|
|
protected function getEncodingTable(string $encoding = ''): string
|
|
{
|
|
if ($encoding === '') {
|
|
if ($this->fdt['type'] === 'Type1' && ($this->fdt['Flags'] & 4) === 0) {
|
|
return 'cp1252';
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
$enc = \preg_replace('/[^A-Za-z0-9_\-]/', '', $encoding);
|
|
if ($enc === null) {
|
|
throw new FontException('Invalid encoding name: ' . $encoding);
|
|
}
|
|
|
|
return $enc;
|
|
}
|
|
|
|
/**
|
|
* If required, get differences between the reference encoding (cp1252) and the current encoding
|
|
*
|
|
* @SuppressWarnings("PHPMD.CyclomaticComplexity")
|
|
*/
|
|
protected function getEncodingDiff(): string
|
|
{
|
|
$diff = '';
|
|
if (
|
|
($this->fdt['type'] === 'TrueType' || $this->fdt['type'] === 'Type1')
|
|
&& ($this->fdt['enc'] !== '' && $this->fdt['enc'] !== 'cp1252' && isset(Encoding::MAP[$this->fdt['enc']]))
|
|
) {
|
|
// build differences from reference encoding
|
|
$enc_ref = Encoding::MAP['cp1252'] ?? [];
|
|
$enc_target = Encoding::MAP[$this->fdt['enc']];
|
|
$last = 0;
|
|
for ($idx = 32; $idx <= 255; ++$idx) {
|
|
$target = $enc_target[$idx] ?? '';
|
|
$ref = $enc_ref[$idx] ?? '';
|
|
if ($target === $ref) {
|
|
continue;
|
|
}
|
|
|
|
if ($idx !== ($last + 1)) {
|
|
$diff .= $idx . ' ';
|
|
}
|
|
|
|
$last = $idx;
|
|
$diff .= '/' . $target . ' ';
|
|
}
|
|
}
|
|
|
|
return $diff;
|
|
}
|
|
|
|
/**
|
|
* Update the CIDToGIDMap string with a new value
|
|
*
|
|
* The CIDToGIDMap is made up of 16-bit values mapping a zero-based
|
|
* Character Identifier index to its zero-based glyph id index.
|
|
*
|
|
* @param string $map CIDToGIDMap (binary).
|
|
* @param int $cid CID value.
|
|
* @param int $gid GID value.
|
|
*/
|
|
protected function updateCIDtoGIDmap(string $map, int $cid, int $gid): string
|
|
{
|
|
// The CIDToGIDMap is a table of 16-bit big-endian values, so a glyph id outside
|
|
// 0..0xFFFF cannot be represented; such entries are left as 0 (notdef) rather than
|
|
// being silently wrapped into a bogus glyph id.
|
|
if ($cid >= 0 && $cid <= 0xFFFF && $gid >= 0 && $gid <= 0xFFFF) {
|
|
$map[$cid * 2] = \chr($gid >> 8);
|
|
$map[($cid * 2) + 1] = \chr($gid & 0xFF);
|
|
}
|
|
|
|
return $map;
|
|
}
|
|
}
|