mirror of
https://github.com/Icinga/icingaweb2.git
synced 2025-11-18 20:10:04 +01:00
124b42c9f1
Remove tcpdf because of improper CSS support and use Dompdf instead, to be able to generate pdfs that look similar to the html views refs #4356
336 lines
9.1 KiB
PHP
336 lines
9.1 KiB
PHP
<?php
|
|
/**
|
|
* @package dompdf
|
|
* @link http://www.dompdf.com/
|
|
* @author Benj Carson <benjcarson@digitaljunkies.ca>
|
|
* @author Helmut Tischer <htischer@weihenstephan.org>
|
|
* @author Fabien Ménager <fabien.menager@gmail.com>
|
|
* @license http://www.gnu.org/copyleft/lesser.html GNU Lesser General Public License
|
|
* @version $Id: font_metrics.cls.php 469 2012-02-05 22:25:30Z fabien.menager $
|
|
*/
|
|
|
|
require_once DOMPDF_LIB_DIR . "/class.pdf.php";
|
|
require_once DOMPDF_LIB_DIR . "/php-font-lib/classes/font.cls.php";
|
|
|
|
/**
|
|
* Name of the font cache file
|
|
*
|
|
* This file must be writable by the webserver process only to update it
|
|
* with save_font_families() after adding the .afm file references of a new font family
|
|
* with Font_Metrics::save_font_families().
|
|
* This is typically done only from command line with load_font.php on converting
|
|
* ttf fonts to ufm with php-font-lib.
|
|
*
|
|
* Declared here because PHP5 prevents constants from being declared with expressions
|
|
*/
|
|
if (!defined("__DOMPDF_FONT_CACHE_FILE")) {
|
|
if (file_exists(DOMPDF_FONT_DIR . "dompdf_font_family_cache")) {
|
|
define('__DOMPDF_FONT_CACHE_FILE', DOMPDF_FONT_DIR . "dompdf_font_family_cache");
|
|
} else {
|
|
define('__DOMPDF_FONT_CACHE_FILE', DOMPDF_FONT_DIR . "dompdf_font_family_cache.dist.php");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The font metrics class
|
|
*
|
|
* This class provides information about fonts and text. It can resolve
|
|
* font names into actual installed font files, as well as determine the
|
|
* size of text in a particular font and size.
|
|
*
|
|
* @static
|
|
* @package dompdf
|
|
*/
|
|
class Font_Metrics {
|
|
|
|
/**
|
|
* @see __DOMPDF_FONT_CACHE_FILE
|
|
*/
|
|
const CACHE_FILE = __DOMPDF_FONT_CACHE_FILE;
|
|
|
|
/**
|
|
* Underlying {@link Canvas} object to perform text size calculations
|
|
*
|
|
* @var Canvas
|
|
*/
|
|
static protected $_pdf = null;
|
|
|
|
/**
|
|
* Array of font family names to font files
|
|
*
|
|
* Usually cached by the {@link load_font.php} script
|
|
*
|
|
* @var array
|
|
*/
|
|
static protected $_font_lookup = array();
|
|
|
|
|
|
/**
|
|
* Class initialization
|
|
*
|
|
*/
|
|
static function init(Canvas $canvas = null) {
|
|
if (!self::$_pdf) {
|
|
if (!$canvas) {
|
|
$canvas = Canvas_Factory::get_instance();
|
|
}
|
|
|
|
self::$_pdf = $canvas;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculates text size, in points
|
|
*
|
|
* @param string $text the text to be sized
|
|
* @param string $font the desired font
|
|
* @param float $size the desired font size
|
|
* @param float $spacing word spacing, if any
|
|
* @return float
|
|
*/
|
|
static function get_text_width($text, $font, $size, $word_spacing = 0, $char_spacing = 0) {
|
|
//return self::$_pdf->get_text_width($text, $font, $size, $word_spacing, $char_spacing);
|
|
|
|
// @todo Make sure this cache is efficient before enabling it
|
|
static $cache = array();
|
|
|
|
if ( $text === "" ) {
|
|
return 0;
|
|
}
|
|
|
|
// Don't cache long strings
|
|
$use_cache = !isset($text[50]); // Faster than strlen
|
|
|
|
$key = "$font/$size/$word_spacing/$char_spacing";
|
|
|
|
if ( $use_cache && isset($cache[$key][$text]) ) {
|
|
return $cache[$key]["$text"];
|
|
}
|
|
|
|
$width = self::$_pdf->get_text_width($text, $font, $size, $word_spacing, $char_spacing);
|
|
|
|
if ( $use_cache ) {
|
|
$cache[$key][$text] = $width;
|
|
}
|
|
|
|
return $width;
|
|
}
|
|
|
|
/**
|
|
* Calculates font height
|
|
*
|
|
* @param string $font
|
|
* @param float $size
|
|
* @return float
|
|
*/
|
|
static function get_font_height($font, $size) {
|
|
return self::$_pdf->get_font_height($font, $size);
|
|
}
|
|
|
|
/**
|
|
* Resolves a font family & subtype into an actual font file
|
|
*
|
|
* Subtype can be one of 'normal', 'bold', 'italic' or 'bold_italic'. If
|
|
* the particular font family has no suitable font file, the default font
|
|
* ({@link DOMPDF_DEFAULT_FONT}) is used. The font file returned
|
|
* is the absolute pathname to the font file on the system.
|
|
*
|
|
* @param string $family
|
|
* @param string $subtype
|
|
* @return string
|
|
*/
|
|
static function get_font($family, $subtype = "normal") {
|
|
|
|
/* Allow calling for various fonts in search path. Therefore not immediately
|
|
* return replacement on non match.
|
|
* Only when called with NULL try replacement.
|
|
* When this is also missing there is really trouble.
|
|
* If only the subtype fails, nevertheless return failure.
|
|
* Only on checking the fallback font, check various subtypes on same font.
|
|
*/
|
|
|
|
if ( $family ) {
|
|
$family = str_replace( array("'", '"'), "", mb_strtolower($family));
|
|
$subtype = mb_strtolower($subtype);
|
|
|
|
if ( isset(self::$_font_lookup[$family][$subtype]) ) {
|
|
return self::$_font_lookup[$family][$subtype];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
$family = DOMPDF_DEFAULT_FONT;
|
|
|
|
if ( isset(self::$_font_lookup[$family][$subtype]) ) {
|
|
return self::$_font_lookup[$family][$subtype];
|
|
}
|
|
|
|
foreach ( self::$_font_lookup[$family] as $sub => $font ) {
|
|
if (strpos($subtype, $sub) !== false) {
|
|
return $font;
|
|
}
|
|
}
|
|
|
|
if ($subtype !== "normal") {
|
|
foreach ( self::$_font_lookup[$family] as $sub => $font ) {
|
|
if ($sub !== "normal") {
|
|
return $font;
|
|
}
|
|
}
|
|
}
|
|
|
|
$subtype = "normal";
|
|
|
|
if ( isset(self::$_font_lookup[$family][$subtype]) ) {
|
|
return self::$_font_lookup[$family][$subtype];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static function get_family($family) {
|
|
$family = str_replace( array("'", '"'), "", mb_strtolower($family));
|
|
|
|
if ( isset(self::$_font_lookup[$family]) ) {
|
|
return self::$_font_lookup[$family];
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Saves the stored font family cache
|
|
*
|
|
* The name and location of the cache file are determined by {@link
|
|
* Font_Metrics::CACHE_FILE}. This file should be writable by the
|
|
* webserver process.
|
|
*
|
|
* @see Font_Metrics::load_font_families()
|
|
*/
|
|
static function save_font_families() {
|
|
// replace the path to the DOMPDF font directory with "DOMPDF_FONT_DIR" (allows for more portability)
|
|
$cache_data = var_export(self::$_font_lookup, true);
|
|
$cache_data = str_replace('\''.DOMPDF_FONT_DIR , 'DOMPDF_FONT_DIR . \'' , $cache_data);
|
|
$cache_data = "<"."?php return $cache_data ?".">";
|
|
file_put_contents(self::CACHE_FILE, $cache_data);
|
|
}
|
|
|
|
/**
|
|
* Loads the stored font family cache
|
|
*
|
|
* @see save_font_families()
|
|
*/
|
|
static function load_font_families() {
|
|
if ( !is_readable(self::CACHE_FILE) )
|
|
return;
|
|
|
|
self::$_font_lookup = require_once(self::CACHE_FILE);
|
|
|
|
// If the font family cache is still in the old format
|
|
if ( self::$_font_lookup === 1 ) {
|
|
$cache_data = file_get_contents(self::CACHE_FILE);
|
|
file_put_contents(self::CACHE_FILE, "<"."?php return $cache_data ?".">");
|
|
self::$_font_lookup = require_once(self::CACHE_FILE);
|
|
}
|
|
}
|
|
|
|
static function get_type($type) {
|
|
if (preg_match("/bold/i", $type)) {
|
|
if (preg_match("/italic|oblique/i", $type)) {
|
|
$type = "bold_italic";
|
|
}
|
|
else {
|
|
$type = "bold";
|
|
}
|
|
}
|
|
elseif (preg_match("/italic|oblique/i", $type)) {
|
|
$type = "italic";
|
|
}
|
|
else {
|
|
$type = "normal";
|
|
}
|
|
|
|
return $type;
|
|
}
|
|
|
|
static function install_fonts($files) {
|
|
$names = array();
|
|
|
|
foreach($files as $file) {
|
|
$font = Font::load($file);
|
|
$records = $font->getData("name", "records");
|
|
$type = self::get_type($records[2]);
|
|
$names[mb_strtolower($records[1])][$type] = $file;
|
|
}
|
|
|
|
return $names;
|
|
}
|
|
|
|
static function get_system_fonts() {
|
|
$files = glob("/usr/share/fonts/truetype/*.ttf") +
|
|
glob("/usr/share/fonts/truetype/*/*.ttf") +
|
|
glob("/usr/share/fonts/truetype/*/*/*.ttf") +
|
|
glob("C:\\Windows\\fonts\\*.ttf") +
|
|
glob("C:\\WinNT\\fonts\\*.ttf") +
|
|
glob("/mnt/c_drive/WINDOWS/Fonts/");
|
|
|
|
return self::install_fonts($files);
|
|
}
|
|
|
|
/**
|
|
* Returns the current font lookup table
|
|
*
|
|
* @return array
|
|
*/
|
|
static function get_font_families() {
|
|
return self::$_font_lookup;
|
|
}
|
|
|
|
static function set_font_family($fontname, $entry) {
|
|
self::$_font_lookup[mb_strtolower($fontname)] = $entry;
|
|
}
|
|
|
|
static function register_font($style, $remote_file) {
|
|
$fontname = mb_strtolower($style["family"]);
|
|
$families = Font_Metrics::get_font_families();
|
|
|
|
$entry = array();
|
|
if ( isset($families[$fontname]) ) {
|
|
$entry = $families[$fontname];
|
|
}
|
|
|
|
$remote_file = $remote_file;
|
|
$local_file = DOMPDF_FONT_DIR . md5($remote_file);
|
|
$cache_entry = $local_file;
|
|
$local_file .= ".ttf";
|
|
|
|
$style_string = Font_Metrics::get_type("{$style['weight']} {$style['style']}");
|
|
|
|
if ( !isset($entry[$style_string]) ) {
|
|
$entry[$style_string] = $cache_entry;
|
|
|
|
Font_Metrics::set_font_family($fontname, $entry);
|
|
|
|
// Download the remote file
|
|
if ( !is_file($local_file) ) {
|
|
file_put_contents($local_file, file_get_contents($remote_file));
|
|
}
|
|
|
|
$font = Font::load($local_file);
|
|
|
|
if (!$font) {
|
|
return false;
|
|
}
|
|
|
|
$font->parse();
|
|
$font->saveAdobeFontMetrics("$cache_entry.ufm");
|
|
|
|
// Save the changes
|
|
Font_Metrics::save_font_families();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
Font_Metrics::load_font_families();
|