source-class-TCPDF_STATIC

It appears that you are using AdBlocking software. The cost of running this website is covered by advertisements. If you like it please feel free to a small amount of money to secure the future of this website.
   1: <?php
   2: //============================================================+
   3: // File name   : tcpdf_static.php
   4: // Version     : 1.1.3
   5: // Begin       : 2002-08-03
   6: // Last Update : 2015-04-28
   7: // Author      : Nicola Asuni - Tecnick.com LTD - www.tecnick.com - info@tecnick.com
   8: // License     : GNU-LGPL v3 (http://www.gnu.org/copyleft/lesser.html)
   9: // -------------------------------------------------------------------
  10: // Copyright (C) 2002-2015 Nicola Asuni - Tecnick.com LTD
  11: //
  12: // This file is part of TCPDF software library.
  13: //
  14: // TCPDF is free software: you can redistribute it and/or modify it
  15: // under the terms of the GNU Lesser General Public License as
  16: // published by the Free Software Foundation, either version 3 of the
  17: // License, or (at your option) any later version.
  18: //
  19: // TCPDF is distributed in the hope that it will be useful, but
  20: // WITHOUT ANY WARRANTY; without even the implied warranty of
  21: // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  22: // See the GNU Lesser General Public License for more details.
  23: //
  24: // You should have received a copy of the License
  25: // along with TCPDF. If not, see
  26: // <http://www.tecnick.com/pagefiles/tcpdf/LICENSE.TXT>.
  27: //
  28: // See LICENSE.TXT file for more information.
  29: // -------------------------------------------------------------------
  30: //
  31: // Description :
  32: //   Static methods used by the TCPDF class.
  33: //
  34: //============================================================+
  35: 
  36: /**
  37:  * @file
  38:  * This is a PHP class that contains static methods for the TCPDF class.<br>
  39:  * @package com.tecnick.tcpdf
  40:  * @author Nicola Asuni
  41:  * @version 1.1.2
  42:  */
  43: 
  44: /**
  45:  * @class TCPDF_STATIC
  46:  * Static methods used by the TCPDF class.
  47:  * @package com.tecnick.tcpdf
  48:  * @brief PHP class for generating PDF documents without requiring external extensions.
  49:  * @version 1.1.1
  50:  * @author Nicola Asuni - info@tecnick.com
  51:  */
  52: class TCPDF_STATIC {
  53: 
  54:     /**
  55:      * Current TCPDF version.
  56:      * @private static
  57:      */
  58:     private static $tcpdf_version = '6.2.17';
  59: 
  60:     /**
  61:      * String alias for total number of pages.
  62:      * @public static
  63:      */
  64:     public static $alias_tot_pages = '{:ptp:}';
  65: 
  66:     /**
  67:      * String alias for page number.
  68:      * @public static
  69:      */
  70:     public static $alias_num_page = '{:pnp:}';
  71: 
  72:     /**
  73:      * String alias for total number of pages in a single group.
  74:      * @public static
  75:      */
  76:     public static $alias_group_tot_pages = '{:ptg:}';
  77: 
  78:     /**
  79:      * String alias for group page number.
  80:      * @public static
  81:      */
  82:     public static $alias_group_num_page = '{:png:}';
  83: 
  84:     /**
  85:      * String alias for right shift compensation used to correctly align page numbers on the right.
  86:      * @public static
  87:      */
  88:     public static $alias_right_shift = '{rsc:';
  89: 
  90:     /**
  91:      * Encryption padding string.
  92:      * @public static
  93:      */
  94:     public static $enc_padding = "\x28\xBF\x4E\x5E\x4E\x75\x8A\x41\x64\x00\x4E\x56\xFF\xFA\x01\x08\x2E\x2E\x00\xB6\xD0\x68\x3E\x80\x2F\x0C\xA9\xFE\x64\x53\x69\x7A";
  95: 
  96:     /**
  97:      * ByteRange placemark used during digital signature process.
  98:      * @since 4.6.028 (2009-08-25)
  99:      * @public static
 100:      */
 101:     public static $byterange_string = '/ByteRange[0 ********** ********** **********]';
 102: 
 103:     /**
 104:      * Array page boxes names
 105:      * @public static
 106:      */
 107:     public static $pageboxes = array('MediaBox', 'CropBox', 'BleedBox', 'TrimBox', 'ArtBox');
 108: 
 109:     // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 110: 
 111:     /**
 112:      * Return the current TCPDF version.
 113:      * @return TCPDF version string
 114:      * @since 5.9.012 (2010-11-10)
 115:      * @public static
 116:      */
 117:     public static function getTCPDFVersion() {
 118:         return self::$tcpdf_version;
 119:     }
 120: 
 121:     /**
 122:      * Return the current TCPDF producer.
 123:      * @return TCPDF producer string
 124:      * @since 6.0.000 (2013-03-16)
 125:      * @public static
 126:      */
 127:     public static function getTCPDFProducer() {
 128:         return "\x54\x43\x50\x44\x46\x20".self::getTCPDFVersion()."\x20\x28\x68\x74\x74\x70\x3a\x2f\x2f\x77\x77\x77\x2e\x74\x63\x70\x64\x66\x2e\x6f\x72\x67\x29";
 129:     }
 130: 
 131:     /**
 132:      * Sets the current active configuration setting of magic_quotes_runtime (if the set_magic_quotes_runtime function exist)
 133:      * @param $mqr (boolean) FALSE for off, TRUE for on.
 134:      * @since 4.6.025 (2009-08-17)
 135:      * @public static
 136:      */
 137:     public static function set_mqr($mqr) {
 138:         if (!defined('PHP_VERSION_ID')) {
 139:             $version = PHP_VERSION;
 140:             define('PHP_VERSION_ID', (($version[0] * 10000) + ($version[2] * 100) + $version[4]));
 141:         }
 142:         if (PHP_VERSION_ID < 50300) {
 143:             @set_magic_quotes_runtime($mqr);
 144:         }
 145:     }
 146: 
 147:     /**
 148:      * Gets the current active configuration setting of magic_quotes_runtime (if the get_magic_quotes_runtime function exist)
 149:      * @return Returns 0 if magic quotes runtime is off or get_magic_quotes_runtime doesn't exist, 1 otherwise.
 150:      * @since 4.6.025 (2009-08-17)
 151:      * @public static
 152:      */
 153:     public static function get_mqr() {
 154:         if (!defined('PHP_VERSION_ID')) {
 155:             $version = PHP_VERSION;
 156:             define('PHP_VERSION_ID', (($version[0] * 10000) + ($version[2] * 100) + $version[4]));
 157:         }
 158:         if (PHP_VERSION_ID < 50300) {
 159:             return @get_magic_quotes_runtime();
 160:         }
 161:         return 0;
 162:     }
 163: 
 164:     /**
 165:      * Check if the URL exist.
 166:      * @param $url (string) URL to check.
 167:      * @return Boolean true if the URl exist, false otherwise.
 168:      * @since 5.9.204 (2013-01-28)
 169:      * @public static
 170:      */
 171:     public static function isValidURL($url) {
 172:         $headers = @get_headers($url);
 173:         return (strpos($headers[0], '200') !== false);
 174:     }
 175: 
 176:     /**
 177:      * Removes SHY characters from text.
 178:      * Unicode Data:<ul>
 179:      * <li>Name : SOFT HYPHEN, commonly abbreviated as SHY</li>
 180:      * <li>HTML Entity (decimal): "&amp;#173;"</li>
 181:      * <li>HTML Entity (hex): "&amp;#xad;"</li>
 182:      * <li>HTML Entity (named): "&amp;shy;"</li>
 183:      * <li>How to type in Microsoft Windows: [Alt +00AD] or [Alt 0173]</li>
 184:      * <li>UTF-8 (hex): 0xC2 0xAD (c2ad)</li>
 185:      * <li>UTF-8 character: chr(194).chr(173)</li>
 186:      * </ul>
 187:      * @param $txt (string) input string
 188:      * @param $unicode (boolean) True if we are in unicode mode, false otherwise.
 189:      * @return string without SHY characters.
 190:      * @since (4.5.019) 2009-02-28
 191:      * @public static
 192:      */
 193:     public static function removeSHY($txt='', $unicode=true) {
 194:         $txt = preg_replace('/([\\xc2]{1}[\\xad]{1})/', '', $txt);
 195:         if (!$unicode) {
 196:             $txt = preg_replace('/([\\xad]{1})/', '', $txt);
 197:         }
 198:         return $txt;
 199:     }
 200: 
 201: 
 202:     /**
 203:      * Get the border mode accounting for multicell position (opens bottom side of multicell crossing pages)
 204:      * @param $brd (mixed) Indicates if borders must be drawn around the cell block. The value can be a number:<ul><li>0: no border (default)</li><li>1: frame</li></ul>or a string containing some or all of the following characters (in any order):<ul><li>L: left</li><li>T: top</li><li>R: right</li><li>B: bottom</li></ul> or an array of line styles for each border group: array('LTRB' => array('width' => 2, 'cap' => 'butt', 'join' => 'miter', 'dash' => 0, 'color' => array(0, 0, 0)))
 205:      * @param $position (string) multicell position: 'start', 'middle', 'end'
 206:      * @param $opencell (boolean) True when the cell is left open at the page bottom, false otherwise.
 207:      * @return border mode array
 208:      * @since 4.4.002 (2008-12-09)
 209:      * @public static
 210:      */
 211:     public static function getBorderMode($brd, $position='start', $opencell=true) {
 212:         if ((!$opencell) OR empty($brd)) {
 213:             return $brd;
 214:         }
 215:         if ($brd == 1) {
 216:             $brd = 'LTRB';
 217:         }
 218:         if (is_string($brd)) {
 219:             // convert string to array
 220:             $slen = strlen($brd);
 221:             $newbrd = array();
 222:             for ($i = 0; $i < $slen; ++$i) {
 223:                 $newbrd[$brd[$i]] = array('cap' => 'square', 'join' => 'miter');
 224:             }
 225:             $brd = $newbrd;
 226:         }
 227:         foreach ($brd as $border => $style) {
 228:             switch ($position) {
 229:                 case 'start': {
 230:                     if (strpos($border, 'B') !== false) {
 231:                         // remove bottom line
 232:                         $newkey = str_replace('B', '', $border);
 233:                         if (strlen($newkey) > 0) {
 234:                             $brd[$newkey] = $style;
 235:                         }
 236:                         unset($brd[$border]);
 237:                     }
 238:                     break;
 239:                 }
 240:                 case 'middle': {
 241:                     if (strpos($border, 'B') !== false) {
 242:                         // remove bottom line
 243:                         $newkey = str_replace('B', '', $border);
 244:                         if (strlen($newkey) > 0) {
 245:                             $brd[$newkey] = $style;
 246:                         }
 247:                         unset($brd[$border]);
 248:                         $border = $newkey;
 249:                     }
 250:                     if (strpos($border, 'T') !== false) {
 251:                         // remove bottom line
 252:                         $newkey = str_replace('T', '', $border);
 253:                         if (strlen($newkey) > 0) {
 254:                             $brd[$newkey] = $style;
 255:                         }
 256:                         unset($brd[$border]);
 257:                     }
 258:                     break;
 259:                 }
 260:                 case 'end': {
 261:                     if (strpos($border, 'T') !== false) {
 262:                         // remove bottom line
 263:                         $newkey = str_replace('T', '', $border);
 264:                         if (strlen($newkey) > 0) {
 265:                             $brd[$newkey] = $style;
 266:                         }
 267:                         unset($brd[$border]);
 268:                     }
 269:                     break;
 270:                 }
 271:             }
 272:         }
 273:         return $brd;
 274:     }
 275: 
 276:     /**
 277:      * Determine whether a string is empty.
 278:      * @param $str (string) string to be checked
 279:      * @return boolean true if string is empty
 280:      * @since 4.5.044 (2009-04-16)
 281:      * @public static
 282:      */
 283:     public static function empty_string($str) {
 284:         return (is_null($str) OR (is_string($str) AND (strlen($str) == 0)));
 285:     }
 286: 
 287:     /**
 288:      * Returns a temporary filename for caching object on filesystem.
 289:      * @param $type (string) Type of file (name of the subdir on the tcpdf cache folder).
 290:      * @param $file_id (string) TCPDF file_id.
 291:      * @return string filename.
 292:      * @since 4.5.000 (2008-12-31)
 293:      * @public static
 294:      */
 295:     public static function getObjFilename($type='tmp', $file_id='') {
 296:         return tempnam(K_PATH_CACHE, '__tcpdf_'.$file_id.'_'.$type.'_'.md5(TCPDF_STATIC::getRandomSeed()).'_');
 297:     }
 298: 
 299:     /**
 300:      * Add "\" before "\", "(" and ")"
 301:      * @param $s (string) string to escape.
 302:      * @return string escaped string.
 303:      * @public static
 304:      */
 305:     public static function _escape($s) {
 306:         // the chr(13) substitution fixes the Bugs item #1421290.
 307:         return strtr($s, array(')' => '\\)', '(' => '\\(', '\\' => '\\\\', chr(13) => '\r'));
 308:     }
 309: 
 310:     /**
 311:     * Escape some special characters (&lt; &gt; &amp;) for XML output.
 312:     * @param $str (string) Input string to convert.
 313:     * @return converted string
 314:     * @since 5.9.121 (2011-09-28)
 315:      * @public static
 316:      */
 317:     public static function _escapeXML($str) {
 318:         $replaceTable = array("\0" => '', '&' => '&amp;', '<' => '&lt;', '>' => '&gt;');
 319:         $str = strtr($str, $replaceTable);
 320:         return $str;
 321:     }
 322: 
 323:     /**
 324:      * Creates a copy of a class object
 325:      * @param $object (object) class object to be cloned
 326:      * @return cloned object
 327:      * @since 4.5.029 (2009-03-19)
 328:      * @public static
 329:      */
 330:     public static function objclone($object) {
 331:         if (($object instanceof Imagick) AND (version_compare(phpversion('imagick'), '3.0.1') !== 1)) {
 332:             // on the versions after 3.0.1 the clone() method was deprecated in favour of clone keyword
 333:             return @$object->clone();
 334:         }
 335:         return @clone($object);
 336:     }
 337: 
 338:     /**
 339:      * Output input data and compress it if possible.
 340:      * @param $data (string) Data to output.
 341:      * @param $length (int) Data length in bytes.
 342:      * @since 5.9.086
 343:      * @public static
 344:      */
 345:     public static function sendOutputData($data, $length) {
 346:         if (!isset($_SERVER['HTTP_ACCEPT_ENCODING']) OR empty($_SERVER['HTTP_ACCEPT_ENCODING'])) {
 347:             // the content length may vary if the server is using compression
 348:             header('Content-Length: '.$length);
 349:         }
 350:         echo $data;
 351:     }
 352: 
 353:     /**
 354:      * Replace page number aliases with number.
 355:      * @param $page (string) Page content.
 356:      * @param $replace (array) Array of replacements (array keys are replacement strings, values are alias arrays).
 357:      * @param $diff (int) If passed, this will be set to the total char number difference between alias and replacements.
 358:      * @return replaced page content and updated $diff parameter as array.
 359:      * @public static
 360:      */
 361:     public static function replacePageNumAliases($page, $replace, $diff=0) {
 362:         foreach ($replace as $rep) {
 363:             foreach ($rep[3] as $a) {
 364:                 if (strpos($page, $a) !== false) {
 365:                     $page = str_replace($a, $rep[0], $page);
 366:                     $diff += ($rep[2] - $rep[1]);
 367:                 }
 368:             }
 369:         }
 370:         return array($page, $diff);
 371:     }
 372: 
 373:     /**
 374:      * Returns timestamp in seconds from formatted date-time.
 375:      * @param $date (string) Formatted date-time.
 376:      * @return int seconds.
 377:      * @since 5.9.152 (2012-03-23)
 378:      * @public static
 379:      */
 380:     public static function getTimestamp($date) {
 381:         if (($date[0] == 'D') AND ($date[1] == ':')) {
 382:             // remove date prefix if present
 383:             $date = substr($date, 2);
 384:         }
 385:         return strtotime($date);
 386:     }
 387: 
 388:     /**
 389:      * Returns a formatted date-time.
 390:      * @param $time (int) Time in seconds.
 391:      * @return string escaped date string.
 392:      * @since 5.9.152 (2012-03-23)
 393:      * @public static
 394:      */
 395:     public static function getFormattedDate($time) {
 396:         return substr_replace(date('YmdHisO', intval($time)), '\'', (0 - 2), 0).'\'';
 397:     }
 398: 
 399:     /**
 400:      * Returns a string containing random data to be used as a seed for encryption methods.
 401:      * @param $seed (string) starting seed value
 402:      * @return string containing random data
 403:      * @author Nicola Asuni
 404:      * @since 5.9.006 (2010-10-19)
 405:      * @public static
 406:      */
 407:     public static function getRandomSeed($seed='') {
 408:         $rnd = uniqid(rand().microtime(true), true);
 409:         if (function_exists('posix_getpid')) {
 410:             $rnd .= posix_getpid();
 411:         }
 412:         if (function_exists('openssl_random_pseudo_bytes') AND (strtoupper(substr(PHP_OS, 0, 3)) !== 'WIN')) {
 413:             // this is not used on windows systems because it is very slow for a know bug
 414:             $rnd .= openssl_random_pseudo_bytes(512);
 415:         } else {
 416:             for ($i = 0; $i < 23; ++$i) {
 417:                 $rnd .= uniqid('', true);
 418:             }
 419:         }
 420:         return $rnd.$seed.__FILE__.serialize($_SERVER).microtime(true);
 421:     }
 422: 
 423:     /**
 424:      * Encrypts a string using MD5 and returns it's value as a binary string.
 425:      * @param $str (string) input string
 426:      * @return String MD5 encrypted binary string
 427:      * @since 2.0.000 (2008-01-02)
 428:      * @public static
 429:      */
 430:     public static function _md5_16($str) {
 431:         return pack('H*', md5($str));
 432:     }
 433: 
 434:     /**
 435:      * Returns the input text exrypted using AES algorithm and the specified key.
 436:      * This method requires openssl or mcrypt. Text is padded to 16bytes blocks
 437:      * @param $key (string) encryption key
 438:      * @param $text (String) input text to be encrypted
 439:      * @return String encrypted text
 440:      * @author Nicola Asuni
 441:      * @since 5.0.005 (2010-05-11)
 442:      * @public static
 443:      */
 444:     public static function _AES($key, $text) {
 445:         // padding (RFC 2898, PKCS #5: Password-Based Cryptography Specification Version 2.0)
 446:         $padding = 16 - (strlen($text) % 16);
 447:         $text .= str_repeat(chr($padding), $padding);
 448:         if (extension_loaded('openssl')) {
 449:             $iv = openssl_random_pseudo_bytes (openssl_cipher_iv_length('aes-256-cbc'));
 450:             $text = openssl_encrypt($text, 'aes-256-cbc', $key, OPENSSL_RAW_DATA, $iv);
 451:             return $iv.substr($text, 0, -16);
 452:         }
 453:         $iv = mcrypt_create_iv(mcrypt_get_iv_size(MCRYPT_RIJNDAEL_128, MCRYPT_MODE_CBC), MCRYPT_RAND);
 454:         $text = mcrypt_encrypt(MCRYPT_RIJNDAEL_128, $key, $text, MCRYPT_MODE_CBC, $iv);
 455:         $text = $iv.$text;
 456:         return $text;
 457:     }
 458: 
 459:     /**
 460:      * Returns the input text exrypted using AES algorithm and the specified key.
 461:      * This method requires openssl or mcrypt. Text is not padded
 462:      * @param $key (string) encryption key
 463:      * @param $text (String) input text to be encrypted
 464:      * @return String encrypted text
 465:      * @author Nicola Asuni
 466:      * @since TODO
 467:      * @public static
 468:      */
 469:     public static function _AESnopad($key, $text) {
 470:         if (extension_loaded('openssl')) {
 471:             $iv = str_repeat("\x00", openssl_cipher_iv_length('aes-256-cbc'));
 472:             $text = openssl_encrypt($text, 'aes-256-cbc', $key, OPENSSL_RAW_DATA, $iv);
 473:             return substr($text, 0, -16);
 474:         }
 475:         $iv = str_repeat("\x00", mcrypt_get_iv_size(MCRYPT_RIJNDAEL_128, MCRYPT_MODE_CBC));
 476:         $text = mcrypt_encrypt(MCRYPT_RIJNDAEL_128, $key, $text, MCRYPT_MODE_CBC, $iv);
 477:         return $text;
 478:     }
 479: 
 480:     /**
 481:      * Returns the input text encrypted using RC4 algorithm and the specified key.
 482:      * RC4 is the standard encryption algorithm used in PDF format
 483:      * @param $key (string) Encryption key.
 484:      * @param $text (String) Input text to be encrypted.
 485:      * @param $last_enc_key (String) Reference to last RC4 key encrypted.
 486:      * @param $last_enc_key_c (String) Reference to last RC4 computed key.
 487:      * @return String encrypted text
 488:      * @since 2.0.000 (2008-01-02)
 489:      * @author Klemen Vodopivec, Nicola Asuni
 490:      * @public static
 491:      */
 492:     public static function _RC4($key, $text, &$last_enc_key, &$last_enc_key_c) {
 493:         if (function_exists('mcrypt_encrypt') AND ($out = @mcrypt_encrypt(MCRYPT_ARCFOUR, $key, $text, MCRYPT_MODE_STREAM, ''))) {
 494:             // try to use mcrypt function if exist
 495:             return $out;
 496:         }
 497:         if ($last_enc_key != $key) {
 498:             $k = str_repeat($key, ((256 / strlen($key)) + 1));
 499:             $rc4 = range(0, 255);
 500:             $j = 0;
 501:             for ($i = 0; $i < 256; ++$i) {
 502:                 $t = $rc4[$i];
 503:                 $j = ($j + $t + ord($k[$i])) % 256;
 504:                 $rc4[$i] = $rc4[$j];
 505:                 $rc4[$j] = $t;
 506:             }
 507:             $last_enc_key = $key;
 508:             $last_enc_key_c = $rc4;
 509:         } else {
 510:             $rc4 = $last_enc_key_c;
 511:         }
 512:         $len = strlen($text);
 513:         $a = 0;
 514:         $b = 0;
 515:         $out = '';
 516:         for ($i = 0; $i < $len; ++$i) {
 517:             $a = ($a + 1) % 256;
 518:             $t = $rc4[$a];
 519:             $b = ($b + $t) % 256;
 520:             $rc4[$a] = $rc4[$b];
 521:             $rc4[$b] = $t;
 522:             $k = $rc4[($rc4[$a] + $rc4[$b]) % 256];
 523:             $out .= chr(ord($text[$i]) ^ $k);
 524:         }
 525:         return $out;
 526:     }
 527: 
 528:     /**
 529:      * Return the permission code used on encryption (P value).
 530:      * @param $permissions (Array) the set of permissions (specify the ones you want to block).
 531:      * @param $mode (int) encryption strength: 0 = RC4 40 bit; 1 = RC4 128 bit; 2 = AES 128 bit; 3 = AES 256 bit.
 532:      * @since 5.0.005 (2010-05-12)
 533:      * @author Nicola Asuni
 534:      * @public static
 535:      */
 536:     public static function getUserPermissionCode($permissions, $mode=0) {
 537:         $options = array(
 538:             'owner' => 2, // bit 2 -- inverted logic: cleared by default
 539:             'print' => 4, // bit 3
 540:             'modify' => 8, // bit 4
 541:             'copy' => 16, // bit 5
 542:             'annot-forms' => 32, // bit 6
 543:             'fill-forms' => 256, // bit 9
 544:             'extract' => 512, // bit 10
 545:             'assemble' => 1024,// bit 11
 546:             'print-high' => 2048 // bit 12
 547:             );
 548:         $protection = 2147422012; // 32 bit: (01111111 11111111 00001111 00111100)
 549:         foreach ($permissions as $permission) {
 550:             if (isset($options[$permission])) {
 551:                 if (($mode > 0) OR ($options[$permission] <= 32)) {
 552:                     // set only valid permissions
 553:                     if ($options[$permission] == 2) {
 554:                         // the logic for bit 2 is inverted (cleared by default)
 555:                         $protection += $options[$permission];
 556:                     } else {
 557:                         $protection -= $options[$permission];
 558:                     }
 559:                 }
 560:             }
 561:         }
 562:         return $protection;
 563:     }
 564: 
 565:     /**
 566:      * Convert hexadecimal string to string
 567:      * @param $bs (string) byte-string to convert
 568:      * @return String
 569:      * @since 5.0.005 (2010-05-12)
 570:      * @author Nicola Asuni
 571:      * @public static
 572:      */
 573:     public static function convertHexStringToString($bs) {
 574:         $string = ''; // string to be returned
 575:         $bslength = strlen($bs);
 576:         if (($bslength % 2) != 0) {
 577:             // padding
 578:             $bs .= '0';
 579:             ++$bslength;
 580:         }
 581:         for ($i = 0; $i < $bslength; $i += 2) {
 582:             $string .= chr(hexdec($bs[$i].$bs[($i + 1)]));
 583:         }
 584:         return $string;
 585:     }
 586: 
 587:     /**
 588:      * Convert string to hexadecimal string (byte string)
 589:      * @param $s (string) string to convert
 590:      * @return byte string
 591:      * @since 5.0.010 (2010-05-17)
 592:      * @author Nicola Asuni
 593:      * @public static
 594:      */
 595:     public static function convertStringToHexString($s) {
 596:         $bs = '';
 597:         $chars = preg_split('//', $s, -1, PREG_SPLIT_NO_EMPTY);
 598:         foreach ($chars as $c) {
 599:             $bs .= sprintf('%02s', dechex(ord($c)));
 600:         }
 601:         return $bs;
 602:     }
 603: 
 604:     /**
 605:      * Convert encryption P value to a string of bytes, low-order byte first.
 606:      * @param $protection (string) 32bit encryption permission value (P value)
 607:      * @return String
 608:      * @since 5.0.005 (2010-05-12)
 609:      * @author Nicola Asuni
 610:      * @public static
 611:      */
 612:     public static function getEncPermissionsString($protection) {
 613:         $binprot = sprintf('%032b', $protection);
 614:         $str = chr(bindec(substr($binprot, 24, 8)));
 615:         $str .= chr(bindec(substr($binprot, 16, 8)));
 616:         $str .= chr(bindec(substr($binprot, 8, 8)));
 617:         $str .= chr(bindec(substr($binprot, 0, 8)));
 618:         return $str;
 619:     }
 620: 
 621:     /**
 622:      * Encode a name object.
 623:      * @param $name (string) Name object to encode.
 624:      * @return (string) Encoded name object.
 625:      * @author Nicola Asuni
 626:      * @since 5.9.097 (2011-06-23)
 627:      * @public static
 628:      */
 629:     public static function encodeNameObject($name) {
 630:         $escname = '';
 631:         $length = strlen($name);
 632:         for ($i = 0; $i < $length; ++$i) {
 633:             $chr = $name[$i];
 634:             if (preg_match('/[0-9a-zA-Z#_=-]/', $chr) == 1) {
 635:                 $escname .= $chr;
 636:             } else {
 637:                 $escname .= sprintf('#%02X', ord($chr));
 638:             }
 639:         }
 640:         return $escname;
 641:     }
 642: 
 643:     /**
 644:      * Convert JavaScript form fields properties array to Annotation Properties array.
 645:      * @param $prop (array) javascript field properties. Possible values are described on official Javascript for Acrobat API reference.
 646:      * @param $spot_colors (array) Reference to spot colors array.
 647:      * @param $rtl (boolean) True if in Right-To-Left text direction mode, false otherwise.
 648:      * @return array of annotation properties
 649:      * @author Nicola Asuni
 650:      * @since 4.8.000 (2009-09-06)
 651:      * @public static
 652:      */
 653:     public static function getAnnotOptFromJSProp($prop, &$spot_colors, $rtl=false) {
 654:         if (isset($prop['aopt']) AND is_array($prop['aopt'])) {
 655:             // the annotation options area lready defined
 656:             return $prop['aopt'];
 657:         }
 658:         $opt = array(); // value to be returned
 659:         // alignment: Controls how the text is laid out within the text field.
 660:         if (isset($prop['alignment'])) {
 661:             switch ($prop['alignment']) {
 662:                 case 'left': {
 663:                     $opt['q'] = 0;
 664:                     break;
 665:                 }
 666:                 case 'center': {
 667:                     $opt['q'] = 1;
 668:                     break;
 669:                 }
 670:                 case 'right': {
 671:                     $opt['q'] = 2;
 672:                     break;
 673:                 }
 674:                 default: {
 675:                     $opt['q'] = ($rtl)?2:0;
 676:                     break;
 677:                 }
 678:             }
 679:         }
 680:         // lineWidth: Specifies the thickness of the border when stroking the perimeter of a field's rectangle.
 681:         if (isset($prop['lineWidth'])) {
 682:             $linewidth = intval($prop['lineWidth']);
 683:         } else {
 684:             $linewidth = 1;
 685:         }
 686:         // borderStyle: The border style for a field.
 687:         if (isset($prop['borderStyle'])) {
 688:             switch ($prop['borderStyle']) {
 689:                 case 'border.d':
 690:                 case 'dashed': {
 691:                     $opt['border'] = array(0, 0, $linewidth, array(3, 2));
 692:                     $opt['bs'] = array('w'=>$linewidth, 's'=>'D', 'd'=>array(3, 2));
 693:                     break;
 694:                 }
 695:                 case 'border.b':
 696:                 case 'beveled': {
 697:                     $opt['border'] = array(0, 0, $linewidth);
 698:                     $opt['bs'] = array('w'=>$linewidth, 's'=>'B');
 699:                     break;
 700:                 }
 701:                 case 'border.i':
 702:                 case 'inset': {
 703:                     $opt['border'] = array(0, 0, $linewidth);
 704:                     $opt['bs'] = array('w'=>$linewidth, 's'=>'I');
 705:                     break;
 706:                 }
 707:                 case 'border.u':
 708:                 case 'underline': {
 709:                     $opt['border'] = array(0, 0, $linewidth);
 710:                     $opt['bs'] = array('w'=>$linewidth, 's'=>'U');
 711:                     break;
 712:                 }
 713:                 case 'border.s':
 714:                 case 'solid': {
 715:                     $opt['border'] = array(0, 0, $linewidth);
 716:                     $opt['bs'] = array('w'=>$linewidth, 's'=>'S');
 717:                     break;
 718:                 }
 719:                 default: {
 720:                     break;
 721:                 }
 722:             }
 723:         }
 724:         if (isset($prop['border']) AND is_array($prop['border'])) {
 725:             $opt['border'] = $prop['border'];
 726:         }
 727:         if (!isset($opt['mk'])) {
 728:             $opt['mk'] = array();
 729:         }
 730:         if (!isset($opt['mk']['if'])) {
 731:             $opt['mk']['if'] = array();
 732:         }
 733:         $opt['mk']['if']['a'] = array(0.5, 0.5);
 734:         // buttonAlignX: Controls how space is distributed from the left of the button face with respect to the icon.
 735:         if (isset($prop['buttonAlignX'])) {
 736:             $opt['mk']['if']['a'][0] = $prop['buttonAlignX'];
 737:         }
 738:         // buttonAlignY: Controls how unused space is distributed from the bottom of the button face with respect to the icon.
 739:         if (isset($prop['buttonAlignY'])) {
 740:             $opt['mk']['if']['a'][1] = $prop['buttonAlignY'];
 741:         }
 742:         // buttonFitBounds: If true, the extent to which the icon may be scaled is set to the bounds of the button field.
 743:         if (isset($prop['buttonFitBounds']) AND ($prop['buttonFitBounds'] == 'true')) {
 744:             $opt['mk']['if']['fb'] = true;
 745:         }
 746:         // buttonScaleHow: Controls how the icon is scaled (if necessary) to fit inside the button face.
 747:         if (isset($prop['buttonScaleHow'])) {
 748:             switch ($prop['buttonScaleHow']) {
 749:                 case 'scaleHow.proportional': {
 750:                     $opt['mk']['if']['s'] = 'P';
 751:                     break;
 752:                 }
 753:                 case 'scaleHow.anamorphic': {
 754:                     $opt['mk']['if']['s'] = 'A';
 755:                     break;
 756:                 }
 757:             }
 758:         }
 759:         // buttonScaleWhen: Controls when an icon is scaled to fit inside the button face.
 760:         if (isset($prop['buttonScaleWhen'])) {
 761:             switch ($prop['buttonScaleWhen']) {
 762:                 case 'scaleWhen.always': {
 763:                     $opt['mk']['if']['sw'] = 'A';
 764:                     break;
 765:                 }
 766:                 case 'scaleWhen.never': {
 767:                     $opt['mk']['if']['sw'] = 'N';
 768:                     break;
 769:                 }
 770:                 case 'scaleWhen.tooBig': {
 771:                     $opt['mk']['if']['sw'] = 'B';
 772:                     break;
 773:                 }
 774:                 case 'scaleWhen.tooSmall': {
 775:                     $opt['mk']['if']['sw'] = 'S';
 776:                     break;
 777:                 }
 778:             }
 779:         }
 780:         // buttonPosition: Controls how the text and the icon of the button are positioned with respect to each other within the button face.
 781:         if (isset($prop['buttonPosition'])) {
 782:             switch ($prop['buttonPosition']) {
 783:                 case 0:
 784:                 case 'position.textOnly': {
 785:                     $opt['mk']['tp'] = 0;
 786:                     break;
 787:                 }
 788:                 case 1:
 789:                 case 'position.iconOnly': {
 790:                     $opt['mk']['tp'] = 1;
 791:                     break;
 792:                 }
 793:                 case 2:
 794:                 case 'position.iconTextV': {
 795:                     $opt['mk']['tp'] = 2;
 796:                     break;
 797:                 }
 798:                 case 3:
 799:                 case 'position.textIconV': {
 800:                     $opt['mk']['tp'] = 3;
 801:                     break;
 802:                 }
 803:                 case 4:
 804:                 case 'position.iconTextH': {
 805:                     $opt['mk']['tp'] = 4;
 806:                     break;
 807:                 }
 808:                 case 5:
 809:                 case 'position.textIconH': {
 810:                     $opt['mk']['tp'] = 5;
 811:                     break;
 812:                 }
 813:                 case 6:
 814:                 case 'position.overlay': {
 815:                     $opt['mk']['tp'] = 6;
 816:                     break;
 817:                 }
 818:             }
 819:         }
 820:         // fillColor: Specifies the background color for a field.
 821:         if (isset($prop['fillColor'])) {
 822:             if (is_array($prop['fillColor'])) {
 823:                 $opt['mk']['bg'] = $prop['fillColor'];
 824:             } else {
 825:                 $opt['mk']['bg'] = TCPDF_COLORS::convertHTMLColorToDec($prop['fillColor'], $spot_colors);
 826:             }
 827:         }
 828:         // strokeColor: Specifies the stroke color for a field that is used to stroke the rectangle of the field with a line as large as the line width.
 829:         if (isset($prop['strokeColor'])) {
 830:             if (is_array($prop['strokeColor'])) {
 831:                 $opt['mk']['bc'] = $prop['strokeColor'];
 832:             } else {
 833:                 $opt['mk']['bc'] = TCPDF_COLORS::convertHTMLColorToDec($prop['strokeColor'], $spot_colors);
 834:             }
 835:         }
 836:         // rotation: The rotation of a widget in counterclockwise increments.
 837:         if (isset($prop['rotation'])) {
 838:             $opt['mk']['r'] = $prop['rotation'];
 839:         }
 840:         // charLimit: Limits the number of characters that a user can type into a text field.
 841:         if (isset($prop['charLimit'])) {
 842:             $opt['maxlen'] = intval($prop['charLimit']);
 843:         }
 844:         if (!isset($ff)) {
 845:             $ff = 0; // default value
 846:         }
 847:         // readonly: The read-only characteristic of a field. If a field is read-only, the user can see the field but cannot change it.
 848:         if (isset($prop['readonly']) AND ($prop['readonly'] == 'true')) {
 849:             $ff += 1 << 0;
 850:         }
 851:         // required: Specifies whether a field requires a value.
 852:         if (isset($prop['required']) AND ($prop['required'] == 'true')) {
 853:             $ff += 1 << 1;
 854:         }
 855:         // multiline: Controls how text is wrapped within the field.
 856:         if (isset($prop['multiline']) AND ($prop['multiline'] == 'true')) {
 857:             $ff += 1 << 12;
 858:         }
 859:         // password: Specifies whether the field should display asterisks when data is entered in the field.
 860:         if (isset($prop['password']) AND ($prop['password'] == 'true')) {
 861:             $ff += 1 << 13;
 862:         }
 863:         // NoToggleToOff: If set, exactly one radio button shall be selected at all times; selecting the currently selected button has no effect.
 864:         if (isset($prop['NoToggleToOff']) AND ($prop['NoToggleToOff'] == 'true')) {
 865:             $ff += 1 << 14;
 866:         }
 867:         // Radio: If set, the field is a set of radio buttons.
 868:         if (isset($prop['Radio']) AND ($prop['Radio'] == 'true')) {
 869:             $ff += 1 << 15;
 870:         }
 871:         // Pushbutton: If set, the field is a pushbutton that does not retain a permanent value.
 872:         if (isset($prop['Pushbutton']) AND ($prop['Pushbutton'] == 'true')) {
 873:             $ff += 1 << 16;
 874:         }
 875:         // Combo: If set, the field is a combo box; if clear, the field is a list box.
 876:         if (isset($prop['Combo']) AND ($prop['Combo'] == 'true')) {
 877:             $ff += 1 << 17;
 878:         }
 879:         // editable: Controls whether a combo box is editable.
 880:         if (isset($prop['editable']) AND ($prop['editable'] == 'true')) {
 881:             $ff += 1 << 18;
 882:         }
 883:         // Sort: If set, the field's option items shall be sorted alphabetically.
 884:         if (isset($prop['Sort']) AND ($prop['Sort'] == 'true')) {
 885:             $ff += 1 << 19;
 886:         }
 887:         // fileSelect: If true, sets the file-select flag in the Options tab of the text field (Field is Used for File Selection).
 888:         if (isset($prop['fileSelect']) AND ($prop['fileSelect'] == 'true')) {
 889:             $ff += 1 << 20;
 890:         }
 891:         // multipleSelection: If true, indicates that a list box allows a multiple selection of items.
 892:         if (isset($prop['multipleSelection']) AND ($prop['multipleSelection'] == 'true')) {
 893:             $ff += 1 << 21;
 894:         }
 895:         // doNotSpellCheck: If true, spell checking is not performed on this editable text field.
 896:         if (isset($prop['doNotSpellCheck']) AND ($prop['doNotSpellCheck'] == 'true')) {
 897:             $ff += 1 << 22;
 898:         }
 899:         // doNotScroll: If true, the text field does not scroll and the user, therefore, is limited by the rectangular region designed for the field.
 900:         if (isset($prop['doNotScroll']) AND ($prop['doNotScroll'] == 'true')) {
 901:             $ff += 1 << 23;
 902:         }
 903:         // comb: If set to true, the field background is drawn as series of boxes (one for each character in the value of the field) and each character of the content is drawn within those boxes. The number of boxes drawn is determined from the charLimit property. It applies only to text fields. The setter will also raise if any of the following field properties are also set multiline, password, and fileSelect. A side-effect of setting this property is that the doNotScroll property is also set.
 904:         if (isset($prop['comb']) AND ($prop['comb'] == 'true')) {
 905:             $ff += 1 << 24;
 906:         }
 907:         // radiosInUnison: If false, even if a group of radio buttons have the same name and export value, they behave in a mutually exclusive fashion, like HTML radio buttons.
 908:         if (isset($prop['radiosInUnison']) AND ($prop['radiosInUnison'] == 'true')) {
 909:             $ff += 1 << 25;
 910:         }
 911:         // richText: If true, the field allows rich text formatting.
 912:         if (isset($prop['richText']) AND ($prop['richText'] == 'true')) {
 913:             $ff += 1 << 25;
 914:         }
 915:         // commitOnSelChange: Controls whether a field value is committed after a selection change.
 916:         if (isset($prop['commitOnSelChange']) AND ($prop['commitOnSelChange'] == 'true')) {
 917:             $ff += 1 << 26;
 918:         }
 919:         $opt['ff'] = $ff;
 920:         // defaultValue: The default value of a field - that is, the value that the field is set to when the form is reset.
 921:         if (isset($prop['defaultValue'])) {
 922:             $opt['dv'] = $prop['defaultValue'];
 923:         }
 924:         $f = 4; // default value for annotation flags
 925:         // readonly: The read-only characteristic of a field. If a field is read-only, the user can see the field but cannot change it.
 926:         if (isset($prop['readonly']) AND ($prop['readonly'] == 'true')) {
 927:             $f += 1 << 6;
 928:         }
 929:         // display: Controls whether the field is hidden or visible on screen and in print.
 930:         if (isset($prop['display'])) {
 931:             if ($prop['display'] == 'display.visible') {
 932:                 //
 933:             } elseif ($prop['display'] == 'display.hidden') {
 934:                 $f += 1 << 1;
 935:             } elseif ($prop['display'] == 'display.noPrint') {
 936:                 $f -= 1 << 2;
 937:             } elseif ($prop['display'] == 'display.noView') {
 938:                 $f += 1 << 5;
 939:             }
 940:         }
 941:         $opt['f'] = $f;
 942:         // currentValueIndices: Reads and writes single or multiple values of a list box or combo box.
 943:         if (isset($prop['currentValueIndices']) AND is_array($prop['currentValueIndices'])) {
 944:             $opt['i'] = $prop['currentValueIndices'];
 945:         }
 946:         // value: The value of the field data that the user has entered.
 947:         if (isset($prop['value'])) {
 948:             if (is_array($prop['value'])) {
 949:                 $opt['opt'] = array();
 950:                 foreach ($prop['value'] AS $key => $optval) {
 951:                     // exportValues: An array of strings representing the export values for the field.
 952:                     if (isset($prop['exportValues'][$key])) {
 953:                         $opt['opt'][$key] = array($prop['exportValues'][$key], $prop['value'][$key]);
 954:                     } else {
 955:                         $opt['opt'][$key] = $prop['value'][$key];
 956:                     }
 957:                 }
 958:             } else {
 959:                 $opt['v'] = $prop['value'];
 960:             }
 961:         }
 962:         // richValue: This property specifies the text contents and formatting of a rich text field.
 963:         if (isset($prop['richValue'])) {
 964:             $opt['rv'] = $prop['richValue'];
 965:         }
 966:         // submitName: If nonempty, used during form submission instead of name. Only applicable if submitting in HTML format (that is, URL-encoded).
 967:         if (isset($prop['submitName'])) {
 968:             $opt['tm'] = $prop['submitName'];
 969:         }
 970:         // name: Fully qualified field name.
 971:         if (isset($prop['name'])) {
 972:             $opt['t'] = $prop['name'];
 973:         }
 974:         // userName: The user name (short description string) of the field.
 975:         if (isset($prop['userName'])) {
 976:             $opt['tu'] = $prop['userName'];
 977:         }
 978:         // highlight: Defines how a button reacts when a user clicks it.
 979:         if (isset($prop['highlight'])) {
 980:             switch ($prop['highlight']) {
 981:                 case 'none':
 982:                 case 'highlight.n': {
 983:                     $opt['h'] = 'N';
 984:                     break;
 985:                 }
 986:                 case 'invert':
 987:                 case 'highlight.i': {
 988:                     $opt['h'] = 'i';
 989:                     break;
 990:                 }
 991:                 case 'push':
 992:                 case 'highlight.p': {
 993:                     $opt['h'] = 'P';
 994:                     break;
 995:                 }
 996:                 case 'outline':
 997:                 case 'highlight.o': {
 998:                     $opt['h'] = 'O';
 999:                     break;
1000:                 }
1001:             }
1002:         }
1003:         // Unsupported options:
1004:         // - calcOrderIndex: Changes the calculation order of fields in the document.
1005:         // - delay: Delays the redrawing of a field's appearance.
1006:         // - defaultStyle: This property defines the default style attributes for the form field.
1007:         // - style: Allows the user to set the glyph style of a check box or radio button.
1008:         // - textColor, textFont, textSize
1009:         return $opt;
1010:     }
1011: 
1012:     /**
1013:      * Format the page numbers.
1014:      * This method can be overriden for custom formats.
1015:      * @param $num (int) page number
1016:      * @since 4.2.005 (2008-11-06)
1017:      * @public static
1018:      */
1019:     public static function formatPageNumber($num) {
1020:         return number_format((float)$num, 0, '', '.');
1021:     }
1022: 
1023:     /**
1024:      * Format the page numbers on the Table Of Content.
1025:      * This method can be overriden for custom formats.
1026:      * @param $num (int) page number
1027:      * @since 4.5.001 (2009-01-04)
1028:      * @see addTOC(), addHTMLTOC()
1029:      * @public static
1030:      */
1031:     public static function formatTOCPageNumber($num) {
1032:         return number_format((float)$num, 0, '', '.');
1033:     }
1034: 
1035:     /**
1036:      * Extracts the CSS properties from a CSS string.
1037:      * @param $cssdata (string) string containing CSS definitions.
1038:      * @return An array where the keys are the CSS selectors and the values are the CSS properties.
1039:      * @author Nicola Asuni
1040:      * @since 5.1.000 (2010-05-25)
1041:      * @public static
1042:      */
1043:     public static function extractCSSproperties($cssdata) {
1044:         if (empty($cssdata)) {
1045:             return array();
1046:         }
1047:         // remove comments
1048:         $cssdata = preg_replace('/\/\*[^\*]*\*\//', '', $cssdata);
1049:         // remove newlines and multiple spaces
1050:         $cssdata = preg_replace('/[\s]+/', ' ', $cssdata);
1051:         // remove some spaces
1052:         $cssdata = preg_replace('/[\s]*([;:\{\}]{1})[\s]*/', '\\1', $cssdata);
1053:         // remove empty blocks
1054:         $cssdata = preg_replace('/([^\}\{]+)\{\}/', '', $cssdata);
1055:         // replace media type parenthesis
1056:         $cssdata = preg_replace('/@media[\s]+([^\{]*)\{/i', '@media \\1§', $cssdata);
1057:         $cssdata = preg_replace('/\}\}/si', '}§', $cssdata);
1058:         // trim string
1059:         $cssdata = trim($cssdata);
1060:         // find media blocks (all, braille, embossed, handheld, print, projection, screen, speech, tty, tv)
1061:         $cssblocks = array();
1062:         $matches = array();
1063:         if (preg_match_all('/@media[\s]+([^\§]*)§([^§]*)§/i', $cssdata, $matches) > 0) {
1064:             foreach ($matches[1] as $key => $type) {
1065:                 $cssblocks[$type] = $matches[2][$key];
1066:             }
1067:             // remove media blocks
1068:             $cssdata = preg_replace('/@media[\s]+([^\§]*)§([^§]*)§/i', '', $cssdata);
1069:         }
1070:         // keep 'all' and 'print' media, other media types are discarded
1071:         if (isset($cssblocks['all']) AND !empty($cssblocks['all'])) {
1072:             $cssdata .= $cssblocks['all'];
1073:         }
1074:         if (isset($cssblocks['print']) AND !empty($cssblocks['print'])) {
1075:             $cssdata .= $cssblocks['print'];
1076:         }
1077:         // reset css blocks array
1078:         $cssblocks = array();
1079:         $matches = array();
1080:         // explode css data string into array
1081:         if (substr($cssdata, -1) == '}') {
1082:             // remove last parethesis
1083:             $cssdata = substr($cssdata, 0, -1);
1084:         }
1085:         $matches = explode('}', $cssdata);
1086:         foreach ($matches as $key => $block) {
1087:             // index 0 contains the CSS selector, index 1 contains CSS properties
1088:             $cssblocks[$key] = explode('{', $block);
1089:             if (!isset($cssblocks[$key][1])) {
1090:                 // remove empty definitions
1091:                 unset($cssblocks[$key]);
1092:             }
1093:         }
1094:         // split groups of selectors (comma-separated list of selectors)
1095:         foreach ($cssblocks as $key => $block) {
1096:             if (strpos($block[0], ',') > 0) {
1097:                 $selectors = explode(',', $block[0]);
1098:                 foreach ($selectors as $sel) {
1099:                     $cssblocks[] = array(0 => trim($sel), 1 => $block[1]);
1100:                 }
1101:                 unset($cssblocks[$key]);
1102:             }
1103:         }
1104:         // covert array to selector => properties
1105:         $cssdata = array();
1106:         foreach ($cssblocks as $block) {
1107:             $selector = $block[0];
1108:             // calculate selector's specificity
1109:             $matches = array();
1110:             $a = 0; // the declaration is not from is a 'style' attribute
1111:             $b = intval(preg_match_all('/[\#]/', $selector, $matches)); // number of ID attributes
1112:             $c = intval(preg_match_all('/[\[\.]/', $selector, $matches)); // number of other attributes
1113:             $c += intval(preg_match_all('/[\:]link|visited|hover|active|focus|target|lang|enabled|disabled|checked|indeterminate|root|nth|first|last|only|empty|contains|not/i', $selector, $matches)); // number of pseudo-classes
1114:             $d = intval(preg_match_all('/[\>\+\~\s]{1}[a-zA-Z0-9]+/', ' '.$selector, $matches)); // number of element names
1115:             $d += intval(preg_match_all('/[\:][\:]/', $selector, $matches)); // number of pseudo-elements
1116:             $specificity = $a.$b.$c.$d;
1117:             // add specificity to the beginning of the selector
1118:             $cssdata[$specificity.' '.$selector] = $block[1];
1119:         }
1120:         // sort selectors alphabetically to account for specificity
1121:         ksort($cssdata, SORT_STRING);
1122:         // return array
1123:         return $cssdata;
1124:     }
1125: 
1126:     /**
1127:      * Cleanup HTML code (requires HTML Tidy library).
1128:      * @param $html (string) htmlcode to fix
1129:      * @param $default_css (string) CSS commands to add
1130:      * @param $tagvs (array) parameters for setHtmlVSpace method
1131:      * @param $tidy_options (array) options for tidy_parse_string function
1132:      * @param $tagvspaces (array) Array of vertical spaces for tags.
1133:      * @return string XHTML code cleaned up
1134:      * @author Nicola Asuni
1135:      * @since 5.9.017 (2010-11-16)
1136:      * @see setHtmlVSpace()
1137:      * @public static
1138:      */
1139:     public static function fixHTMLCode($html, $default_css='', $tagvs='', $tidy_options='', &$tagvspaces) {
1140:         // configure parameters for HTML Tidy
1141:         if ($tidy_options === '') {
1142:             $tidy_options = array (
1143:                 'clean' => 1,
1144:                 'drop-empty-paras' => 0,
1145:                 'drop-proprietary-attributes' => 1,
1146:                 'fix-backslash' => 1,
1147:                 'hide-comments' => 1,
1148:                 'join-styles' => 1,
1149:                 'lower-literals' => 1,
1150:                 'merge-divs' => 1,
1151:                 'merge-spans' => 1,
1152:                 'output-xhtml' => 1,
1153:                 'word-2000' => 1,
1154:                 'wrap' => 0,
1155:                 'output-bom' => 0,
1156:                 //'char-encoding' => 'utf8',
1157:                 //'input-encoding' => 'utf8',
1158:                 //'output-encoding' => 'utf8'
1159:             );
1160:         }
1161:         // clean up the HTML code
1162:         $tidy = tidy_parse_string($html, $tidy_options);
1163:         // fix the HTML
1164:         $tidy->cleanRepair();
1165:         // get the CSS part
1166:         $tidy_head = tidy_get_head($tidy);
1167:         $css = $tidy_head->value;
1168:         $css = preg_replace('/<style([^>]+)>/ims', '<style>', $css);
1169:         $css = preg_replace('/<\/style>(.*)<style>/ims', "\n", $css);
1170:         $css = str_replace('/*<![CDATA[*/', '', $css);
1171:         $css = str_replace('/*]]>*/', '', $css);
1172:         preg_match('/<style>(.*)<\/style>/ims', $css, $matches);
1173:         if (isset($matches[1])) {
1174:             $css = strtolower($matches[1]);
1175:         } else {
1176:             $css = '';
1177:         }
1178:         // include default css
1179:         $css = '<style>'.$default_css.$css.'</style>';
1180:         // get the body part
1181:         $tidy_body = tidy_get_body($tidy);
1182:         $html = $tidy_body->value;
1183:         // fix some self-closing tags
1184:         $html = str_replace('<br>', '<br />', $html);
1185:         // remove some empty tag blocks
1186:         $html = preg_replace('/<div([^\>]*)><\/div>/', '', $html);
1187:         $html = preg_replace('/<p([^\>]*)><\/p>/', '', $html);
1188:         if ($tagvs !== '') {
1189:             // set vertical space for some XHTML tags
1190:             $tagvspaces = $tagvs;
1191:         }
1192:         // return the cleaned XHTML code + CSS
1193:         return $css.$html;
1194:     }
1195: 
1196:     /**
1197:      * Returns true if the CSS selector is valid for the selected HTML tag
1198:      * @param $dom (array) array of HTML tags and properties
1199:      * @param $key (int) key of the current HTML tag
1200:      * @param $selector (string) CSS selector string
1201:      * @return true if the selector is valid, false otherwise
1202:      * @since 5.1.000 (2010-05-25)
1203:      * @public static
1204:      */
1205:     public static function isValidCSSSelectorForTag($dom, $key, $selector) {
1206:         $valid = false; // value to be returned
1207:         $tag = $dom[$key]['value'];
1208:         $class = array();
1209:         if (isset($dom[$key]['attribute']['class']) AND !empty($dom[$key]['attribute']['class'])) {
1210:             $class = explode(' ', strtolower($dom[$key]['attribute']['class']));
1211:         }
1212:         $id = '';
1213:         if (isset($dom[$key]['attribute']['id']) AND !empty($dom[$key]['attribute']['id'])) {
1214:             $id = strtolower($dom[$key]['attribute']['id']);
1215:         }
1216:         $selector = preg_replace('/([\>\+\~\s]{1})([\.]{1})([^\>\+\~\s]*)/si', '\\1*.\\3', $selector);
1217:         $matches = array();
1218:         if (preg_match_all('/([\>\+\~\s]{1})([a-zA-Z0-9\*]+)([^\>\+\~\s]*)/si', $selector, $matches, PREG_PATTERN_ORDER | PREG_OFFSET_CAPTURE) > 0) {
1219:             $parentop = array_pop($matches[1]);
1220:             $operator = $parentop[0];
1221:             $offset = $parentop[1];
1222:             $lasttag = array_pop($matches[2]);
1223:             $lasttag = strtolower(trim($lasttag[0]));
1224:             if (($lasttag == '*') OR ($lasttag == $tag)) {
1225:                 // the last element on selector is our tag or 'any tag'
1226:                 $attrib = array_pop($matches[3]);
1227:                 $attrib = strtolower(trim($attrib[0]));
1228:                 if (!empty($attrib)) {
1229:                     // check if matches class, id, attribute, pseudo-class or pseudo-element
1230:                     switch ($attrib[0]) {
1231:                         case '.': { // class
1232:                             if (in_array(substr($attrib, 1), $class)) {
1233:                                 $valid = true;
1234:                             }
1235:                             break;
1236:                         }
1237:                         case '#': { // ID
1238:                             if (substr($attrib, 1) == $id) {
1239:                                 $valid = true;
1240:                             }
1241:                             break;
1242:                         }
1243:                         case '[': { // attribute
1244:                             $attrmatch = array();
1245:                             if (preg_match('/\[([a-zA-Z0-9]*)[\s]*([\~\^\$\*\|\=]*)[\s]*["]?([^"\]]*)["]?\]/i', $attrib, $attrmatch) > 0) {
1246:                                 $att = strtolower($attrmatch[1]);
1247:                                 $val = $attrmatch[3];
1248:                                 if (isset($dom[$key]['attribute'][$att])) {
1249:                                     switch ($attrmatch[2]) {
1250:                                         case '=': {
1251:                                             if ($dom[$key]['attribute'][$att] == $val) {
1252:                                                 $valid = true;
1253:                                             }
1254:                                             break;
1255:                                         }
1256:                                         case '~=': {
1257:                                             if (in_array($val, explode(' ', $dom[$key]['attribute'][$att]))) {
1258:                                                 $valid = true;
1259:                                             }
1260:                                             break;
1261:                                         }
1262:                                         case '^=': {
1263:                                             if ($val == substr($dom[$key]['attribute'][$att], 0, strlen($val))) {
1264:                                                 $valid = true;
1265:                                             }
1266:                                             break;
1267:                                         }
1268:                                         case '$=': {
1269:                                             if ($val == substr($dom[$key]['attribute'][$att], -strlen($val))) {
1270:                                                 $valid = true;
1271:                                             }
1272:                                             break;
1273:                                         }
1274:                                         case '*=': {
1275:                                             if (strpos($dom[$key]['attribute'][$att], $val) !== false) {
1276:                                                 $valid = true;
1277:                                             }
1278:                                             break;
1279:                                         }
1280:                                         case '|=': {
1281:                                             if ($dom[$key]['attribute'][$att] == $val) {
1282:                                                 $valid = true;
1283:                                             } elseif (preg_match('/'.$val.'[\-]{1}/i', $dom[$key]['attribute'][$att]) > 0) {
1284:                                                 $valid = true;
1285:                                             }
1286:                                             break;
1287:                                         }
1288:                                         default: {
1289:                                             $valid = true;
1290:                                         }
1291:                                     }
1292:                                 }
1293:                             }
1294:                             break;
1295:                         }
1296:                         case ':': { // pseudo-class or pseudo-element
1297:                             if ($attrib[1] == ':') { // pseudo-element
1298:                                 // pseudo-elements are not supported!
1299:                                 // (::first-line, ::first-letter, ::before, ::after)
1300:                             } else { // pseudo-class
1301:                                 // pseudo-classes are not supported!
1302:                                 // (:root, :nth-child(n), :nth-last-child(n), :nth-of-type(n), :nth-last-of-type(n), :first-child, :last-child, :first-of-type, :last-of-type, :only-child, :only-of-type, :empty, :link, :visited, :active, :hover, :focus, :target, :lang(fr), :enabled, :disabled, :checked)
1303:                             }
1304:                             break;
1305:                         }
1306:                     } // end of switch
1307:                 } else {
1308:                     $valid = true;
1309:                 }
1310:                 if ($valid AND ($offset > 0)) {
1311:                     $valid = false;
1312:                     // check remaining selector part
1313:                     $selector = substr($selector, 0, $offset);
1314:                     switch ($operator) {
1315:                         case ' ': { // descendant of an element
1316:                             while ($dom[$key]['parent'] > 0) {
1317:                                 if (self::isValidCSSSelectorForTag($dom, $dom[$key]['parent'], $selector)) {
1318:                                     $valid = true;
1319:                                     break;
1320:                                 } else {
1321:                                     $key = $dom[$key]['parent'];
1322:                                 }
1323:                             }
1324:                             break;
1325:                         }
1326:                         case '>': { // child of an element
1327:                             $valid = self::isValidCSSSelectorForTag($dom, $dom[$key]['parent'], $selector);
1328:                             break;
1329:                         }
1330:                         case '+': { // immediately preceded by an element
1331:                             for ($i = ($key - 1); $i > $dom[$key]['parent']; --$i) {
1332:                                 if ($dom[$i]['tag'] AND $dom[$i]['opening']) {
1333:                                     $valid = self::isValidCSSSelectorForTag($dom, $i, $selector);
1334:                                     break;
1335:                                 }
1336:                             }
1337:                             break;
1338:                         }
1339:                         case '~': { // preceded by an element
1340:                             for ($i = ($key - 1); $i > $dom[$key]['parent']; --$i) {
1341:                                 if ($dom[$i]['tag'] AND $dom[$i]['opening']) {
1342:                                     if (self::isValidCSSSelectorForTag($dom, $i, $selector)) {
1343:                                         break;
1344:                                     }
1345:                                 }
1346:                             }
1347:                             break;
1348:                         }
1349:                     }
1350:                 }
1351:             }
1352:         }
1353:         return $valid;
1354:     }
1355: 
1356:     /**
1357:      * Returns the styles array that apply for the selected HTML tag.
1358:      * @param $dom (array) array of HTML tags and properties
1359:      * @param $key (int) key of the current HTML tag
1360:      * @param $css (array) array of CSS properties
1361:      * @return array containing CSS properties
1362:      * @since 5.1.000 (2010-05-25)
1363:      * @public static
1364:      */
1365:     public static function getCSSdataArray($dom, $key, $css) {
1366:         $cssarray = array(); // style to be returned
1367:         // get parent CSS selectors
1368:         $selectors = array();
1369:         if (isset($dom[($dom[$key]['parent'])]['csssel'])) {
1370:             $selectors = $dom[($dom[$key]['parent'])]['csssel'];
1371:         }
1372:         // get all styles that apply
1373:         foreach($css as $selector => $style) {
1374:             $pos = strpos($selector, ' ');
1375:             // get specificity
1376:             $specificity = substr($selector, 0, $pos);
1377:             // remove specificity
1378:             $selector = substr($selector, $pos);
1379:             // check if this selector apply to current tag
1380:             if (self::isValidCSSSelectorForTag($dom, $key, $selector)) {
1381:                 if (!in_array($selector, $selectors)) {
1382:                     // add style if not already added on parent selector
1383:                     $cssarray[] = array('k' => $selector, 's' => $specificity, 'c' => $style);
1384:                     $selectors[] = $selector;
1385:                 }
1386:             }
1387:         }
1388:         if (isset($dom[$key]['attribute']['style'])) {
1389:             // attach inline style (latest properties have high priority)
1390:             $cssarray[] = array('k' => '', 's' => '1000', 'c' => $dom[$key]['attribute']['style']);
1391:         }
1392:         // order the css array to account for specificity
1393:         $cssordered = array();
1394:         foreach ($cssarray as $key => $val) {
1395:             $skey = sprintf('%04d', $key);
1396:             $cssordered[$val['s'].'_'.$skey] = $val;
1397:         }
1398:         // sort selectors alphabetically to account for specificity
1399:         ksort($cssordered, SORT_STRING);
1400:         return array($selectors, $cssordered);
1401:     }
1402: 
1403:     /**
1404:      * Compact CSS data array into single string.
1405:      * @param $css (array) array of CSS properties
1406:      * @return string containing merged CSS properties
1407:      * @since 5.9.070 (2011-04-19)
1408:      * @public static
1409:      */
1410:     public static function getTagStyleFromCSSarray($css) {
1411:         $tagstyle = ''; // value to be returned
1412:         foreach ($css as $style) {
1413:             // split single css commands
1414:             $csscmds = explode(';', $style['c']);
1415:             foreach ($csscmds as $cmd) {
1416:                 if (!empty($cmd)) {
1417:                     $pos = strpos($cmd, ':');
1418:                     if ($pos !== false) {
1419:                         $cmd = substr($cmd, 0, ($pos + 1));
1420:                         if (strpos($tagstyle, $cmd) !== false) {
1421:                             // remove duplicate commands (last commands have high priority)
1422:                             $tagstyle = preg_replace('/'.$cmd.'[^;]+/i', '', $tagstyle);
1423:                         }
1424:                     }
1425:                 }
1426:             }
1427:             $tagstyle .= ';'.$style['c'];
1428:         }
1429:         // remove multiple semicolons
1430:         $tagstyle = preg_replace('/[;]+/', ';', $tagstyle);
1431:         return $tagstyle;
1432:     }
1433: 
1434:     /**
1435:      * Returns the Roman representation of an integer number
1436:      * @param $number (int) number to convert
1437:      * @return string roman representation of the specified number
1438:      * @since 4.4.004 (2008-12-10)
1439:      * @public static
1440:      */
1441:     public static function intToRoman($number) {
1442:         $roman = '';
1443:         while ($number >= 1000) {
1444:             $roman .= 'M';
1445:             $number -= 1000;
1446:         }
1447:         while ($number >= 900) {
1448:             $roman .= 'CM';
1449:             $number -= 900;
1450:         }
1451:         while ($number >= 500) {
1452:             $roman .= 'D';
1453:             $number -= 500;
1454:         }
1455:         while ($number >= 400) {
1456:             $roman .= 'CD';
1457:             $number -= 400;
1458:         }
1459:         while ($number >= 100) {
1460:             $roman .= 'C';
1461:             $number -= 100;
1462:         }
1463:         while ($number >= 90) {
1464:             $roman .= 'XC';
1465:             $number -= 90;
1466:         }
1467:         while ($number >= 50) {
1468:             $roman .= 'L';
1469:             $number -= 50;
1470:         }
1471:         while ($number >= 40) {
1472:             $roman .= 'XL';
1473:             $number -= 40;
1474:         }
1475:         while ($number >= 10) {
1476:             $roman .= 'X';
1477:             $number -= 10;
1478:         }
1479:         while ($number >= 9) {
1480:             $roman .= 'IX';
1481:             $number -= 9;
1482:         }
1483:         while ($number >= 5) {
1484:             $roman .= 'V';
1485:             $number -= 5;
1486:         }
1487:         while ($number >= 4) {
1488:             $roman .= 'IV';
1489:             $number -= 4;
1490:         }
1491:         while ($number >= 1) {
1492:             $roman .= 'I';
1493:             --$number;
1494:         }
1495:         return $roman;
1496:     }
1497: 
1498:     /**
1499:      * Find position of last occurrence of a substring in a string
1500:      * @param $haystack (string) The string to search in.
1501:      * @param $needle (string) substring to search.
1502:      * @param $offset (int) May be specified to begin searching an arbitrary number of characters into the string.
1503:      * @return Returns the position where the needle exists. Returns FALSE if the needle was not found.
1504:      * @since 4.8.038 (2010-03-13)
1505:      * @public static
1506:      */
1507:     public static function revstrpos($haystack, $needle, $offset = 0) {
1508:         $length = strlen($haystack);
1509:         $offset = ($offset > 0)?($length - $offset):abs($offset);
1510:         $pos = strpos(strrev($haystack), strrev($needle), $offset);
1511:         return ($pos === false)?false:($length - $pos - strlen($needle));
1512:     }
1513: 
1514:     /**
1515:      * Returns an array of hyphenation patterns.
1516:      * @param $file (string) TEX file containing hypenation patterns. TEX pattrns can be downloaded from http://www.ctan.org/tex-archive/language/hyph-utf8/tex/generic/hyph-utf8/patterns/
1517:      * @return array of hyphenation patterns
1518:      * @author Nicola Asuni
1519:      * @since 4.9.012 (2010-04-12)
1520:      * @public static
1521:      */
1522:     public static function getHyphenPatternsFromTEX($file) {
1523:         // TEX patterns are available at:
1524:         // http://www.ctan.org/tex-archive/language/hyph-utf8/tex/generic/hyph-utf8/patterns/
1525:         $data = file_get_contents($file);
1526:         $patterns = array();
1527:         // remove comments
1528:         $data = preg_replace('/\%[^\n]*/', '', $data);
1529:         // extract the patterns part
1530:         preg_match('/\\\\patterns\{([^\}]*)\}/i', $data, $matches);
1531:         $data = trim(substr($matches[0], 10, -1));
1532:         // extract each pattern
1533:         $patterns_array = preg_split('/[\s]+/', $data);
1534:         // create new language array of patterns
1535:         $patterns = array();
1536:         foreach($patterns_array as $val) {
1537:             if (!TCPDF_STATIC::empty_string($val)) {
1538:                 $val = trim($val);
1539:                 $val = str_replace('\'', '\\\'', $val);
1540:                 $key = preg_replace('/[0-9]+/', '', $val);
1541:                 $patterns[$key] = $val;
1542:             }
1543:         }
1544:         return $patterns;
1545:     }
1546: 
1547:     /**
1548:      * Get the Path-Painting Operators.
1549:      * @param $style (string) Style of rendering. Possible values are:
1550:      * <ul>
1551:      *   <li>S or D: Stroke the path.</li>
1552:      *   <li>s or d: Close and stroke the path.</li>
1553:      *   <li>f or F: Fill the path, using the nonzero winding number rule to determine the region to fill.</li>
1554:      *   <li>f* or F*: Fill the path, using the even-odd rule to determine the region to fill.</li>
1555:      *   <li>B or FD or DF: Fill and then stroke the path, using the nonzero winding number rule to determine the region to fill.</li>
1556:      *   <li>B* or F*D or DF*: Fill and then stroke the path, using the even-odd rule to determine the region to fill.</li>
1557:      *   <li>b or fd or df: Close, fill, and then stroke the path, using the nonzero winding number rule to determine the region to fill.</li>
1558:      *   <li>b or f*d or df*: Close, fill, and then stroke the path, using the even-odd rule to determine the region to fill.</li>
1559:      *   <li>CNZ: Clipping mode using the even-odd rule to determine which regions lie inside the clipping path.</li>
1560:      *   <li>CEO: Clipping mode using the nonzero winding number rule to determine which regions lie inside the clipping path</li>
1561:      *   <li>n: End the path object without filling or stroking it.</li>
1562:      * </ul>
1563:      * @param $default (string) default style
1564:      * @author Nicola Asuni
1565:      * @since 5.0.000 (2010-04-30)
1566:      * @public static
1567:      */
1568:     public static function getPathPaintOperator($style, $default='S') {
1569:         $op = '';
1570:         switch($style) {
1571:             case 'S':
1572:             case 'D': {
1573:                 $op = 'S';
1574:                 break;
1575:             }
1576:             case 's':
1577:             case 'd': {
1578:                 $op = 's';
1579:                 break;
1580:             }
1581:             case 'f':
1582:             case 'F': {
1583:                 $op = 'f';
1584:                 break;
1585:             }
1586:             case 'f*':
1587:             case 'F*': {
1588:                 $op = 'f*';
1589:                 break;
1590:             }
1591:             case 'B':
1592:             case 'FD':
1593:             case 'DF': {
1594:                 $op = 'B';
1595:                 break;
1596:             }
1597:             case 'B*':
1598:             case 'F*D':
1599:             case 'DF*': {
1600:                 $op = 'B*';
1601:                 break;
1602:             }
1603:             case 'b':
1604:             case 'fd':
1605:             case 'df': {
1606:                 $op = 'b';
1607:                 break;
1608:             }
1609:             case 'b*':
1610:             case 'f*d':
1611:             case 'df*': {
1612:                 $op = 'b*';
1613:                 break;
1614:             }
1615:             case 'CNZ': {
1616:                 $op = 'W n';
1617:                 break;
1618:             }
1619:             case 'CEO': {
1620:                 $op = 'W* n';
1621:                 break;
1622:             }
1623:             case 'n': {
1624:                 $op = 'n';
1625:                 break;
1626:             }
1627:             default: {
1628:                 if (!empty($default)) {
1629:                     $op = self::getPathPaintOperator($default, '');
1630:                 } else {
1631:                     $op = '';
1632:                 }
1633:             }
1634:         }
1635:         return $op;
1636:     }
1637: 
1638:     /**
1639:      * Get the product of two SVG tranformation matrices
1640:      * @param $ta (array) first SVG tranformation matrix
1641:      * @param $tb (array) second SVG tranformation matrix
1642:      * @return transformation array
1643:      * @author Nicola Asuni
1644:      * @since 5.0.000 (2010-05-02)
1645:      * @public static
1646:      */
1647:     public static function getTransformationMatrixProduct($ta, $tb) {
1648:         $tm = array();
1649:         $tm[0] = ($ta[0] * $tb[0]) + ($ta[2] * $tb[1]);
1650:         $tm[1] = ($ta[1] * $tb[0]) + ($ta[3] * $tb[1]);
1651:         $tm[2] = ($ta[0] * $tb[2]) + ($ta[2] * $tb[3]);
1652:         $tm[3] = ($ta[1] * $tb[2]) + ($ta[3] * $tb[3]);
1653:         $tm[4] = ($ta[0] * $tb[4]) + ($ta[2] * $tb[5]) + $ta[4];
1654:         $tm[5] = ($ta[1] * $tb[4]) + ($ta[3] * $tb[5]) + $ta[5];
1655:         return $tm;
1656:     }
1657: 
1658:     /**
1659:      * Get the tranformation matrix from SVG transform attribute
1660:      * @param $attribute (string) transformation
1661:      * @return array of transformations
1662:      * @author Nicola Asuni
1663:      * @since 5.0.000 (2010-05-02)
1664:      * @public static
1665:      */
1666:     public static function getSVGTransformMatrix($attribute) {
1667:         // identity matrix
1668:         $tm = array(1, 0, 0, 1, 0, 0);
1669:         $transform = array();
1670:         if (preg_match_all('/(matrix|translate|scale|rotate|skewX|skewY)[\s]*\(([^\)]+)\)/si', $attribute, $transform, PREG_SET_ORDER) > 0) {
1671:             foreach ($transform as $key => $data) {
1672:                 if (!empty($data[2])) {
1673:                     $a = 1;
1674:                     $b = 0;
1675:                     $c = 0;
1676:                     $d = 1;
1677:                     $e = 0;
1678:                     $f = 0;
1679:                     $regs = array();
1680:                     switch ($data[1]) {
1681:                         case 'matrix': {
1682:                             if (preg_match('/([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)/si', $data[2], $regs)) {
1683:                                 $a = $regs[1];
1684:                                 $b = $regs[2];
1685:                                 $c = $regs[3];
1686:                                 $d = $regs[4];
1687:                                 $e = $regs[5];
1688:                                 $f = $regs[6];
1689:                             }
1690:                             break;
1691:                         }
1692:                         case 'translate': {
1693:                             if (preg_match('/([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)/si', $data[2], $regs)) {
1694:                                 $e = $regs[1];
1695:                                 $f = $regs[2];
1696:                             } elseif (preg_match('/([a-z0-9\-\.]+)/si', $data[2], $regs)) {
1697:                                 $e = $regs[1];
1698:                             }
1699:                             break;
1700:                         }
1701:                         case 'scale': {
1702:                             if (preg_match('/([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)/si', $data[2], $regs)) {
1703:                                 $a = $regs[1];
1704:                                 $d = $regs[2];
1705:                             } elseif (preg_match('/([a-z0-9\-\.]+)/si', $data[2], $regs)) {
1706:                                 $a = $regs[1];
1707:                                 $d = $a;
1708:                             }
1709:                             break;
1710:                         }
1711:                         case 'rotate': {
1712:                             if (preg_match('/([0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)/si', $data[2], $regs)) {
1713:                                 $ang = deg2rad($regs[1]);
1714:                                 $x = $regs[2];
1715:                                 $y = $regs[3];
1716:                                 $a = cos($ang);
1717:                                 $b = sin($ang);
1718:                                 $c = -$b;
1719:                                 $d = $a;
1720:                                 $e = ($x * (1 - $a)) - ($y * $c);
1721:                                 $f = ($y * (1 - $d)) - ($x * $b);
1722:                             } elseif (preg_match('/([0-9\-\.]+)/si', $data[2], $regs)) {
1723:                                 $ang = deg2rad($regs[1]);
1724:                                 $a = cos($ang);
1725:                                 $b = sin($ang);
1726:                                 $c = -$b;
1727:                                 $d = $a;
1728:                                 $e = 0;
1729:                                 $f = 0;
1730:                             }
1731:                             break;
1732:                         }
1733:                         case 'skewX': {
1734:                             if (preg_match('/([0-9\-\.]+)/si', $data[2], $regs)) {
1735:                                 $c = tan(deg2rad($regs[1]));
1736:                             }
1737:                             break;
1738:                         }
1739:                         case 'skewY': {
1740:                             if (preg_match('/([0-9\-\.]+)/si', $data[2], $regs)) {
1741:                                 $b = tan(deg2rad($regs[1]));
1742:                             }
1743:                             break;
1744:                         }
1745:                     }
1746:                     $tm = self::getTransformationMatrixProduct($tm, array($a, $b, $c, $d, $e, $f));
1747:                 }
1748:             }
1749:         }
1750:         return $tm;
1751:     }
1752: 
1753:     /**
1754:      * Returns the angle in radiants between two vectors
1755:      * @param $x1 (int) X coordinate of first vector point
1756:      * @param $y1 (int) Y coordinate of first vector point
1757:      * @param $x2 (int) X coordinate of second vector point
1758:      * @param $y2 (int) Y coordinate of second vector point
1759:      * @author Nicola Asuni
1760:      * @since 5.0.000 (2010-05-04)
1761:      * @public static
1762:      */
1763:     public static function getVectorsAngle($x1, $y1, $x2, $y2) {
1764:         $dprod = ($x1 * $x2) + ($y1 * $y2);
1765:         $dist1 = sqrt(($x1 * $x1) + ($y1 * $y1));
1766:         $dist2 = sqrt(($x2 * $x2) + ($y2 * $y2));
1767:         $angle = acos($dprod / ($dist1 * $dist2));
1768:         if (is_nan($angle)) {
1769:             $angle = M_PI;
1770:         }
1771:         if ((($x1 * $y2) - ($x2 * $y1)) < 0) {
1772:             $angle *= -1;
1773:         }
1774:         return $angle;
1775:     }
1776: 
1777: 
1778: 
1779: 
1780: 
1781: 
1782: 
1783: 
1784: 
1785: 
1786: 
1787: 
1788: 
1789: 
1790: 
1791: 
1792: 
1793: // ====================================================================================================================
1794: // REIMPLEMENTED
1795: // ====================================================================================================================
1796: 
1797: 
1798: 
1799: 
1800: 
1801: 
1802: 
1803: 
1804: 
1805: 
1806: 
1807: 
1808: 
1809: 
1810:     /**
1811:      * Split string by a regular expression.
1812:      * This is a wrapper for the preg_split function to avoid the bug: https://bugs.php.net/bug.php?id=45850
1813:      * @param $pattern (string) The regular expression pattern to search for without the modifiers, as a string.
1814:      * @param $modifiers (string) The modifiers part of the pattern,
1815:      * @param $subject (string) The input string.
1816:      * @param $limit (int) If specified, then only substrings up to limit are returned with the rest of the string being placed in the last substring. A limit of -1, 0 or NULL means "no limit" and, as is standard across PHP, you can use NULL to skip to the flags parameter.
1817:      * @param $flags (int) The flags as specified on the preg_split PHP function.
1818:      * @return Returns an array containing substrings of subject split along boundaries matched by pattern.modifier
1819:      * @author Nicola Asuni
1820:      * @since 6.0.023
1821:      * @public static
1822:      */
1823:     public static function pregSplit($pattern, $modifiers, $subject, $limit=NULL, $flags=NULL) {
1824:         // the bug only happens on PHP 5.2 when using the u modifier
1825:         if ((strpos($modifiers, 'u') === FALSE) OR (count(preg_split('//u', "\n\t", -1, PREG_SPLIT_NO_EMPTY)) == 2)) {
1826:             return preg_split($pattern.$modifiers, $subject, $limit, $flags);
1827:         }
1828:         // preg_split is bugged - try alternative solution
1829:         $ret = array();
1830:         while (($nl = strpos($subject, "\n")) !== FALSE) {
1831:             $ret = array_merge($ret, preg_split($pattern.$modifiers, substr($subject, 0, $nl), $limit, $flags));
1832:             $ret[] = "\n";
1833:             $subject = substr($subject, ($nl + 1));
1834:         }
1835:         if (strlen($subject) > 0) {
1836:             $ret = array_merge($ret, preg_split($pattern.$modifiers, $subject, $limit, $flags));
1837:         }
1838:         return $ret;
1839:     }
1840: 
1841:     /**
1842:      * Wrapper to use fopen only with local files
1843:      * @param filename (string) Name of the file to open
1844:      * @param $mode (string) 
1845:      * @return Returns a file pointer resource on success, or FALSE on error.  
1846:      * @public static
1847:      */
1848:     public static function fopenLocal($filename, $mode) {
1849:         if (strpos($filename, '://') === false) {
1850:             $filename = 'file://'.$filename;
1851:         } elseif (stream_is_local($filename) !== true) {
1852:             return false;
1853:         }
1854:         return fopen($filename, $mode);
1855:     }
1856: 
1857:     /**
1858:      * Reads entire file into a string.
1859:      * The file can be also an URL.
1860:      * @param $file (string) Name of the file or URL to read.
1861:      * @return The function returns the read data or FALSE on failure. 
1862:      * @author Nicola Asuni
1863:      * @since 6.0.025
1864:      * @public static
1865:      */
1866:     public static function fileGetContents($file) {
1867:         $alt = array($file);
1868:         //
1869:         if ((strlen($file) > 1)
1870:             && ($file[0] === '/')
1871:             && ($file[1] !== '/')
1872:             && !empty($_SERVER['DOCUMENT_ROOT'])
1873:             && ($_SERVER['DOCUMENT_ROOT'] !== '/')
1874:         ) {
1875:             $findroot = strpos($file, $_SERVER['DOCUMENT_ROOT']);
1876:             if (($findroot === false) || ($findroot > 1)) {
1877:             $alt[] = htmlspecialchars_decode(urldecode($_SERVER['DOCUMENT_ROOT'].$file));
1878:             }
1879:         }
1880:         //
1881:         $protocol = 'http';
1882:         if (!empty($_SERVER['HTTPS']) && (strtolower($_SERVER['HTTPS']) != 'off')) {
1883:             $protocol .= 's';
1884:         }
1885:         //
1886:         $url = $file;
1887:         if (preg_match('%^//%', $url) && !empty($_SERVER['HTTP_HOST'])) {
1888:             $url = $protocol.':'.str_replace(' ', '%20', $url);
1889:         }
1890:         $url = htmlspecialchars_decode($url);
1891:         $alt[] = $url;
1892:         //
1893:         if (preg_match('%^(https?)://%', $url)
1894:             && empty($_SERVER['HTTP_HOST'])
1895:             && empty($_SERVER['DOCUMENT_ROOT'])
1896:         ) {
1897:             $urldata = parse_url($url);
1898:             if (empty($urldata['query'])) {
1899:                 $host = $protocol.'://'.$_SERVER['HTTP_HOST'];
1900:                 if (strpos($url, $host) === 0) {
1901:                     // convert URL to full server path
1902:                     $tmp = str_replace($host, $_SERVER['DOCUMENT_ROOT'], $url);
1903:                     $alt[] = htmlspecialchars_decode(urldecode($tmp));
1904:                 }
1905:             }
1906:         }
1907:         //
1908:         if (isset($_SERVER['SCRIPT_URI'])
1909:             && !preg_match('%^(https?|ftp)://%', $file)
1910:             && !preg_match('%^//%', $file)
1911:         ) {
1912:             $urldata = @parse_url($_SERVER['SCRIPT_URI']);
1913:             $alt[] = $urldata['scheme'].'://'.$urldata['host'].(($file[0] == '/') ? '' : '/').$file;
1914:         }
1915:         //
1916:         $alt = array_unique($alt);
1917:         //var_dump($alt);exit;//DEBUG
1918:         foreach ($alt as $path) {
1919:             $ret = @file_get_contents($path);
1920:             if ($ret !== false) {
1921:                 return $ret;
1922:             }
1923:             // try to use CURL for URLs
1924:             if (!ini_get('allow_url_fopen')
1925:                 && function_exists('curl_init')
1926:                 && preg_match('%^(https?|ftp)://%', $path)
1927:             ) {
1928:                 // try to get remote file data using cURL
1929:                 $crs = curl_init();
1930:                 curl_setopt($crs, CURLOPT_URL, $path);
1931:                 curl_setopt($crs, CURLOPT_BINARYTRANSFER, true);
1932:                 curl_setopt($crs, CURLOPT_FAILONERROR, true);
1933:                 curl_setopt($crs, CURLOPT_RETURNTRANSFER, true);
1934:                 if ((ini_get('open_basedir') == '') && (!ini_get('safe_mode'))) {
1935:                     curl_setopt($crs, CURLOPT_FOLLOWLOCATION, true);
1936:                 }
1937:                 curl_setopt($crs, CURLOPT_CONNECTTIMEOUT, 5);
1938:                 curl_setopt($crs, CURLOPT_TIMEOUT, 30);
1939:                 curl_setopt($crs, CURLOPT_SSL_VERIFYPEER, false);
1940:                 curl_setopt($crs, CURLOPT_SSL_VERIFYHOST, false);
1941:                 curl_setopt($crs, CURLOPT_USERAGENT, 'tc-lib-file');
1942:                 $ret = curl_exec($crs);
1943:                 curl_close($crs);
1944:                 if ($ret !== false) {
1945:                     return $ret;
1946:                 }
1947:             }
1948:         }
1949:         return false;
1950:     }
1951: 
1952:     
1953: 
1954:     /**
1955:      * Get ULONG from string (Big Endian 32-bit unsigned integer).
1956:      * @param $str (string) string from where to extract value
1957:      * @param $offset (int) point from where to read the data
1958:      * @return int 32 bit value
1959:      * @author Nicola Asuni
1960:      * @since 5.2.000 (2010-06-02)
1961:      * @public static
1962:      */
1963:     public static function _getULONG($str, $offset) {
1964:         $v = unpack('Ni', substr($str, $offset, 4));
1965:         return $v['i'];
1966:     }
1967: 
1968:     /**
1969:      * Get USHORT from string (Big Endian 16-bit unsigned integer).
1970:      * @param $str (string) string from where to extract value
1971:      * @param $offset (int) point from where to read the data
1972:      * @return int 16 bit value
1973:      * @author Nicola Asuni
1974:      * @since 5.2.000 (2010-06-02)
1975:      * @public static
1976:      */
1977:     public static function _getUSHORT($str, $offset) {
1978:         $v = unpack('ni', substr($str, $offset, 2));
1979:         return $v['i'];
1980:     }
1981: 
1982:     /**
1983:      * Get SHORT from string (Big Endian 16-bit signed integer).
1984:      * @param $str (string) String from where to extract value.
1985:      * @param $offset (int) Point from where to read the data.
1986:      * @return int 16 bit value
1987:      * @author Nicola Asuni
1988:      * @since 5.2.000 (2010-06-02)
1989:      * @public static
1990:      */
1991:     public static function _getSHORT($str, $offset) {
1992:         $v = unpack('si', substr($str, $offset, 2));
1993:         return $v['i'];
1994:     }
1995: 
1996:     /**
1997:      * Get FWORD from string (Big Endian 16-bit signed integer).
1998:      * @param $str (string) String from where to extract value.
1999:      * @param $offset (int) Point from where to read the data.
2000:      * @return int 16 bit value
2001:      * @author Nicola Asuni
2002:      * @since 5.9.123 (2011-09-30)
2003:      * @public static
2004:      */
2005:     public static function _getFWORD($str, $offset) {
2006:         $v = self::_getUSHORT($str, $offset);
2007:         if ($v > 0x7fff) {
2008:             $v -= 0x10000;
2009:         }
2010:         return $v;
2011:     }
2012: 
2013:     /**
2014:      * Get UFWORD from string (Big Endian 16-bit unsigned integer).
2015:      * @param $str (string) string from where to extract value
2016:      * @param $offset (int) point from where to read the data
2017:      * @return int 16 bit value
2018:      * @author Nicola Asuni
2019:      * @since 5.9.123 (2011-09-30)
2020:      * @public static
2021:      */
2022:     public static function _getUFWORD($str, $offset) {
2023:         $v = self::_getUSHORT($str, $offset);
2024:         return $v;
2025:     }
2026: 
2027:     /**
2028:      * Get FIXED from string (32-bit signed fixed-point number (16.16).
2029:      * @param $str (string) string from where to extract value
2030:      * @param $offset (int) point from where to read the data
2031:      * @return int 16 bit value
2032:      * @author Nicola Asuni
2033:      * @since 5.9.123 (2011-09-30)
2034:      * @public static
2035:      */
2036:     public static function _getFIXED($str, $offset) {
2037:         // mantissa
2038:         $m = self::_getFWORD($str, $offset);
2039:         // fraction
2040:         $f = self::_getUSHORT($str, ($offset + 2));
2041:         $v = floatval(''.$m.'.'.$f.'');
2042:         return $v;
2043:     }
2044: 
2045:     /**
2046:      * Get BYTE from string (8-bit unsigned integer).
2047:      * @param $str (string) String from where to extract value.
2048:      * @param $offset (int) Point from where to read the data.
2049:      * @return int 8 bit value
2050:      * @author Nicola Asuni
2051:      * @since 5.2.000 (2010-06-02)
2052:      * @public static
2053:      */
2054:     public static function _getBYTE($str, $offset) {
2055:         $v = unpack('Ci', substr($str, $offset, 1));
2056:         return $v['i'];
2057:     }
2058:     /**
2059:      * Binary-safe and URL-safe file read.
2060:      * Reads up to length bytes from the file pointer referenced by handle. Reading stops as soon as one of the following conditions is met: length bytes have been read; EOF (end of file) is reached.
2061:      * @param $handle (resource)
2062:      * @param $length (int)
2063:      * @return Returns the read string or FALSE in case of error.
2064:      * @author Nicola Asuni
2065:      * @since 4.5.027 (2009-03-16)
2066:      * @public static
2067:      */
2068:     public static function rfread($handle, $length) {
2069:         $data = fread($handle, $length);
2070:         if ($data === false) {
2071:             return false;
2072:         }
2073:         $rest = ($length - strlen($data));
2074:         if (($rest > 0) && !feof($handle)) {
2075:             $data .= self::rfread($handle, $rest);
2076:         }
2077:         return $data;
2078:     }
2079: 
2080:     /**
2081:      * Read a 4-byte (32 bit) integer from file.
2082:      * @param $f (string) file name.
2083:      * @return 4-byte integer
2084:      * @public static
2085:      */
2086:     public static function _freadint($f) {
2087:         $a = unpack('Ni', fread($f, 4));
2088:         return $a['i'];
2089:     }
2090: 
2091:     
2092:     /**
2093:      * Array of page formats
2094:      * measures are calculated in this way: (inches * 72) or (millimeters * 72 / 25.4)
2095:      * @public static
2096:      */
2097:     public static $page_formats = array(
2098:         // ISO 216 A Series + 2 SIS 014711 extensions
2099:         'A0'                     => array( 2383.937,  3370.394), // = (  841 x 1189 ) mm  = ( 33.11 x 46.81 ) in
2100:         'A1'                     => array( 1683.780,  2383.937), // = (  594 x 841  ) mm  = ( 23.39 x 33.11 ) in
2101:         'A2'                     => array( 1190.551,  1683.780), // = (  420 x 594  ) mm  = ( 16.54 x 23.39 ) in
2102:         'A3'                     => array(  841.890,  1190.551), // = (  297 x 420  ) mm  = ( 11.69 x 16.54 ) in
2103:         'A4'                     => array(  595.276,   841.890), // = (  210 x 297  ) mm  = (  8.27 x 11.69 ) in
2104:         'A5'                     => array(  419.528,   595.276), // = (  148 x 210  ) mm  = (  5.83 x 8.27  ) in
2105:         'A6'                     => array(  297.638,   419.528), // = (  105 x 148  ) mm  = (  4.13 x 5.83  ) in
2106:         'A7'                     => array(  209.764,   297.638), // = (   74 x 105  ) mm  = (  2.91 x 4.13  ) in
2107:         'A8'                     => array(  147.402,   209.764), // = (   52 x 74   ) mm  = (  2.05 x 2.91  ) in
2108:         'A9'                     => array(  104.882,   147.402), // = (   37 x 52   ) mm  = (  1.46 x 2.05  ) in
2109:         'A10'                    => array(   73.701,   104.882), // = (   26 x 37   ) mm  = (  1.02 x 1.46  ) in
2110:         'A11'                    => array(   51.024,    73.701), // = (   18 x 26   ) mm  = (  0.71 x 1.02  ) in
2111:         'A12'                    => array(   36.850,    51.024), // = (   13 x 18   ) mm  = (  0.51 x 0.71  ) in
2112:         // ISO 216 B Series + 2 SIS 014711 extensions
2113:         'B0'                     => array( 2834.646,  4008.189), // = ( 1000 x 1414 ) mm  = ( 39.37 x 55.67 ) in
2114:         'B1'                     => array( 2004.094,  2834.646), // = (  707 x 1000 ) mm  = ( 27.83 x 39.37 ) in
2115:         'B2'                     => array( 1417.323,  2004.094), // = (  500 x 707  ) mm  = ( 19.69 x 27.83 ) in
2116:         'B3'                     => array( 1000.630,  1417.323), // = (  353 x 500  ) mm  = ( 13.90 x 19.69 ) in
2117:         'B4'                     => array(  708.661,  1000.630), // = (  250 x 353  ) mm  = (  9.84 x 13.90 ) in
2118:         'B5'                     => array(  498.898,   708.661), // = (  176 x 250  ) mm  = (  6.93 x 9.84  ) in
2119:         'B6'                     => array(  354.331,   498.898), // = (  125 x 176  ) mm  = (  4.92 x 6.93  ) in
2120:         'B7'                     => array(  249.449,   354.331), // = (   88 x 125  ) mm  = (  3.46 x 4.92  ) in
2121:         'B8'                     => array(  175.748,   249.449), // = (   62 x 88   ) mm  = (  2.44 x 3.46  ) in
2122:         'B9'                     => array(  124.724,   175.748), // = (   44 x 62   ) mm  = (  1.73 x 2.44  ) in
2123:         'B10'                    => array(   87.874,   124.724), // = (   31 x 44   ) mm  = (  1.22 x 1.73  ) in
2124:         'B11'                    => array(   62.362,    87.874), // = (   22 x 31   ) mm  = (  0.87 x 1.22  ) in
2125:         'B12'                    => array(   42.520,    62.362), // = (   15 x 22   ) mm  = (  0.59 x 0.87  ) in
2126:         // ISO 216 C Series + 2 SIS 014711 extensions + 5 EXTENSION
2127:         'C0'                     => array( 2599.370,  3676.535), // = (  917 x 1297 ) mm  = ( 36.10 x 51.06 ) in
2128:         'C1'                     => array( 1836.850,  2599.370), // = (  648 x 917  ) mm  = ( 25.51 x 36.10 ) in
2129:         'C2'                     => array( 1298.268,  1836.850), // = (  458 x 648  ) mm  = ( 18.03 x 25.51 ) in
2130:         'C3'                     => array(  918.425,  1298.268), // = (  324 x 458  ) mm  = ( 12.76 x 18.03 ) in
2131:         'C4'                     => array(  649.134,   918.425), // = (  229 x 324  ) mm  = (  9.02 x 12.76 ) in
2132:         'C5'                     => array(  459.213,   649.134), // = (  162 x 229  ) mm  = (  6.38 x 9.02  ) in
2133:         'C6'                     => array(  323.150,   459.213), // = (  114 x 162  ) mm  = (  4.49 x 6.38  ) in
2134:         'C7'                     => array(  229.606,   323.150), // = (   81 x 114  ) mm  = (  3.19 x 4.49  ) in
2135:         'C8'                     => array(  161.575,   229.606), // = (   57 x 81   ) mm  = (  2.24 x 3.19  ) in
2136:         'C9'                     => array(  113.386,   161.575), // = (   40 x 57   ) mm  = (  1.57 x 2.24  ) in
2137:         'C10'                    => array(   79.370,   113.386), // = (   28 x 40   ) mm  = (  1.10 x 1.57  ) in
2138:         'C11'                    => array(   56.693,    79.370), // = (   20 x 28   ) mm  = (  0.79 x 1.10  ) in
2139:         'C12'                    => array(   39.685,    56.693), // = (   14 x 20   ) mm  = (  0.55 x 0.79  ) in
2140:         'C76'                    => array(  229.606,   459.213), // = (   81 x 162  ) mm  = (  3.19 x 6.38  ) in
2141:         'DL'                     => array(  311.811,   623.622), // = (  110 x 220  ) mm  = (  4.33 x 8.66  ) in
2142:         'DLE'                    => array(  323.150,   637.795), // = (  114 x 225  ) mm  = (  4.49 x 8.86  ) in
2143:         'DLX'                    => array(  340.158,   666.142), // = (  120 x 235  ) mm  = (  4.72 x 9.25  ) in
2144:         'DLP'                    => array(  280.630,   595.276), // = (   99 x 210  ) mm  = (  3.90 x 8.27  ) in (1/3 A4)
2145:         // SIS 014711 E Series
2146:         'E0'                     => array( 2491.654,  3517.795), // = (  879 x 1241 ) mm  = ( 34.61 x 48.86 ) in
2147:         'E1'                     => array( 1757.480,  2491.654), // = (  620 x 879  ) mm  = ( 24.41 x 34.61 ) in
2148:         'E2'                     => array( 1247.244,  1757.480), // = (  440 x 620  ) mm  = ( 17.32 x 24.41 ) in
2149:         'E3'                     => array(  878.740,  1247.244), // = (  310 x 440  ) mm  = ( 12.20 x 17.32 ) in
2150:         'E4'                     => array(  623.622,   878.740), // = (  220 x 310  ) mm  = (  8.66 x 12.20 ) in
2151:         'E5'                     => array(  439.370,   623.622), // = (  155 x 220  ) mm  = (  6.10 x 8.66  ) in
2152:         'E6'                     => array(  311.811,   439.370), // = (  110 x 155  ) mm  = (  4.33 x 6.10  ) in
2153:         'E7'                     => array(  221.102,   311.811), // = (   78 x 110  ) mm  = (  3.07 x 4.33  ) in
2154:         'E8'                     => array(  155.906,   221.102), // = (   55 x 78   ) mm  = (  2.17 x 3.07  ) in
2155:         'E9'                     => array(  110.551,   155.906), // = (   39 x 55   ) mm  = (  1.54 x 2.17  ) in
2156:         'E10'                    => array(   76.535,   110.551), // = (   27 x 39   ) mm  = (  1.06 x 1.54  ) in
2157:         'E11'                    => array(   53.858,    76.535), // = (   19 x 27   ) mm  = (  0.75 x 1.06  ) in
2158:         'E12'                    => array(   36.850,    53.858), // = (   13 x 19   ) mm  = (  0.51 x 0.75  ) in
2159:         // SIS 014711 G Series
2160:         'G0'                     => array( 2715.591,  3838.110), // = (  958 x 1354 ) mm  = ( 37.72 x 53.31 ) in
2161:         'G1'                     => array( 1919.055,  2715.591), // = (  677 x 958  ) mm  = ( 26.65 x 37.72 ) in
2162:         'G2'                     => array( 1357.795,  1919.055), // = (  479 x 677  ) mm  = ( 18.86 x 26.65 ) in
2163:         'G3'                     => array(  958.110,  1357.795), // = (  338 x 479  ) mm  = ( 13.31 x 18.86 ) in
2164:         'G4'                     => array(  677.480,   958.110), // = (  239 x 338  ) mm  = (  9.41 x 13.31 ) in
2165:         'G5'                     => array(  479.055,   677.480), // = (  169 x 239  ) mm  = (  6.65 x 9.41  ) in
2166:         'G6'                     => array(  337.323,   479.055), // = (  119 x 169  ) mm  = (  4.69 x 6.65  ) in
2167:         'G7'                     => array(  238.110,   337.323), // = (   84 x 119  ) mm  = (  3.31 x 4.69  ) in
2168:         'G8'                     => array(  167.244,   238.110), // = (   59 x 84   ) mm  = (  2.32 x 3.31  ) in
2169:         'G9'                     => array(  119.055,   167.244), // = (   42 x 59   ) mm  = (  1.65 x 2.32  ) in
2170:         'G10'                    => array(   82.205,   119.055), // = (   29 x 42   ) mm  = (  1.14 x 1.65  ) in
2171:         'G11'                    => array(   59.528,    82.205), // = (   21 x 29   ) mm  = (  0.83 x 1.14  ) in
2172:         'G12'                    => array(   39.685,    59.528), // = (   14 x 21   ) mm  = (  0.55 x 0.83  ) in
2173:         // ISO Press
2174:         'RA0'                    => array( 2437.795,  3458.268), // = (  860 x 1220 ) mm  = ( 33.86 x 48.03 ) in
2175:         'RA1'                    => array( 1729.134,  2437.795), // = (  610 x 860  ) mm  = ( 24.02 x 33.86 ) in
2176:         'RA2'                    => array( 1218.898,  1729.134), // = (  430 x 610  ) mm  = ( 16.93 x 24.02 ) in
2177:         'RA3'                    => array(  864.567,  1218.898), // = (  305 x 430  ) mm  = ( 12.01 x 16.93 ) in
2178:         'RA4'                    => array(  609.449,   864.567), // = (  215 x 305  ) mm  = (  8.46 x 12.01 ) in
2179:         'SRA0'                   => array( 2551.181,  3628.346), // = (  900 x 1280 ) mm  = ( 35.43 x 50.39 ) in
2180:         'SRA1'                   => array( 1814.173,  2551.181), // = (  640 x 900  ) mm  = ( 25.20 x 35.43 ) in
2181:         'SRA2'                   => array( 1275.591,  1814.173), // = (  450 x 640  ) mm  = ( 17.72 x 25.20 ) in
2182:         'SRA3'                   => array(  907.087,  1275.591), // = (  320 x 450  ) mm  = ( 12.60 x 17.72 ) in
2183:         'SRA4'                   => array(  637.795,   907.087), // = (  225 x 320  ) mm  = (  8.86 x 12.60 ) in
2184:         // German DIN 476
2185:         '4A0'                    => array( 4767.874,  6740.787), // = ( 1682 x 2378 ) mm  = ( 66.22 x 93.62 ) in
2186:         '2A0'                    => array( 3370.394,  4767.874), // = ( 1189 x 1682 ) mm  = ( 46.81 x 66.22 ) in
2187:         // Variations on the ISO Standard
2188:         'A2_EXTRA'               => array( 1261.417,  1754.646), // = (  445 x 619  ) mm  = ( 17.52 x 24.37 ) in
2189:         'A3+'                    => array(  932.598,  1369.134), // = (  329 x 483  ) mm  = ( 12.95 x 19.02 ) in
2190:         'A3_EXTRA'               => array(  912.756,  1261.417), // = (  322 x 445  ) mm  = ( 12.68 x 17.52 ) in
2191:         'A3_SUPER'               => array(  864.567,  1440.000), // = (  305 x 508  ) mm  = ( 12.01 x 20.00 ) in
2192:         'SUPER_A3'               => array(  864.567,  1380.472), // = (  305 x 487  ) mm  = ( 12.01 x 19.17 ) in
2193:         'A4_EXTRA'               => array(  666.142,   912.756), // = (  235 x 322  ) mm  = (  9.25 x 12.68 ) in
2194:         'A4_SUPER'               => array(  649.134,   912.756), // = (  229 x 322  ) mm  = (  9.02 x 12.68 ) in
2195:         'SUPER_A4'               => array(  643.465,  1009.134), // = (  227 x 356  ) mm  = (  8.94 x 14.02 ) in
2196:         'A4_LONG'                => array(  595.276,   986.457), // = (  210 x 348  ) mm  = (  8.27 x 13.70 ) in
2197:         'F4'                     => array(  595.276,   935.433), // = (  210 x 330  ) mm  = (  8.27 x 12.99 ) in
2198:         'SO_B5_EXTRA'            => array(  572.598,   782.362), // = (  202 x 276  ) mm  = (  7.95 x 10.87 ) in
2199:         'A5_EXTRA'               => array(  490.394,   666.142), // = (  173 x 235  ) mm  = (  6.81 x 9.25  ) in
2200:         // ANSI Series
2201:         'ANSI_E'                 => array( 2448.000,  3168.000), // = (  864 x 1118 ) mm  = ( 34.00 x 44.00 ) in
2202:         'ANSI_D'                 => array( 1584.000,  2448.000), // = (  559 x 864  ) mm  = ( 22.00 x 34.00 ) in
2203:         'ANSI_C'                 => array( 1224.000,  1584.000), // = (  432 x 559  ) mm  = ( 17.00 x 22.00 ) in
2204:         'ANSI_B'                 => array(  792.000,  1224.000), // = (  279 x 432  ) mm  = ( 11.00 x 17.00 ) in
2205:         'ANSI_A'                 => array(  612.000,   792.000), // = (  216 x 279  ) mm  = (  8.50 x 11.00 ) in
2206:         // Traditional 'Loose' North American Paper Sizes
2207:         'USLEDGER'               => array( 1224.000,   792.000), // = (  432 x 279  ) mm  = ( 17.00 x 11.00 ) in
2208:         'LEDGER'                 => array( 1224.000,   792.000), // = (  432 x 279  ) mm  = ( 17.00 x 11.00 ) in
2209:         'ORGANIZERK'             => array(  792.000,  1224.000), // = (  279 x 432  ) mm  = ( 11.00 x 17.00 ) in
2210:         'BIBLE'                  => array(  792.000,  1224.000), // = (  279 x 432  ) mm  = ( 11.00 x 17.00 ) in
2211:         'USTABLOID'              => array(  792.000,  1224.000), // = (  279 x 432  ) mm  = ( 11.00 x 17.00 ) in
2212:         'TABLOID'                => array(  792.000,  1224.000), // = (  279 x 432  ) mm  = ( 11.00 x 17.00 ) in
2213:         'ORGANIZERM'             => array(  612.000,   792.000), // = (  216 x 279  ) mm  = (  8.50 x 11.00 ) in
2214:         'USLETTER'               => array(  612.000,   792.000), // = (  216 x 279  ) mm  = (  8.50 x 11.00 ) in
2215:         'LETTER'                 => array(  612.000,   792.000), // = (  216 x 279  ) mm  = (  8.50 x 11.00 ) in
2216:         'USLEGAL'                => array(  612.000,  1008.000), // = (  216 x 356  ) mm  = (  8.50 x 14.00 ) in
2217:         'LEGAL'                  => array(  612.000,  1008.000), // = (  216 x 356  ) mm  = (  8.50 x 14.00 ) in
2218:         'GOVERNMENTLETTER'       => array(  576.000,   756.000), // = (  203 x 267  ) mm  = (  8.00 x 10.50 ) in
2219:         'GLETTER'                => array(  576.000,   756.000), // = (  203 x 267  ) mm  = (  8.00 x 10.50 ) in
2220:         'JUNIORLEGAL'            => array(  576.000,   360.000), // = (  203 x 127  ) mm  = (  8.00 x 5.00  ) in
2221:         'JLEGAL'                 => array(  576.000,   360.000), // = (  203 x 127  ) mm  = (  8.00 x 5.00  ) in
2222:         // Other North American Paper Sizes
2223:         'QUADDEMY'               => array( 2520.000,  3240.000), // = (  889 x 1143 ) mm  = ( 35.00 x 45.00 ) in
2224:         'SUPER_B'                => array(  936.000,  1368.000), // = (  330 x 483  ) mm  = ( 13.00 x 19.00 ) in
2225:         'QUARTO'                 => array(  648.000,   792.000), // = (  229 x 279  ) mm  = (  9.00 x 11.00 ) in
2226:         'GOVERNMENTLEGAL'        => array(  612.000,   936.000), // = (  216 x 330  ) mm  = (  8.50 x 13.00 ) in
2227:         'FOLIO'                  => array(  612.000,   936.000), // = (  216 x 330  ) mm  = (  8.50 x 13.00 ) in
2228:         'MONARCH'                => array(  522.000,   756.000), // = (  184 x 267  ) mm  = (  7.25 x 10.50 ) in
2229:         'EXECUTIVE'              => array(  522.000,   756.000), // = (  184 x 267  ) mm  = (  7.25 x 10.50 ) in
2230:         'ORGANIZERL'             => array(  396.000,   612.000), // = (  140 x 216  ) mm  = (  5.50 x 8.50  ) in
2231:         'STATEMENT'              => array(  396.000,   612.000), // = (  140 x 216  ) mm  = (  5.50 x 8.50  ) in
2232:         'MEMO'                   => array(  396.000,   612.000), // = (  140 x 216  ) mm  = (  5.50 x 8.50  ) in
2233:         'FOOLSCAP'               => array(  595.440,   936.000), // = (  210 x 330  ) mm  = (  8.27 x 13.00 ) in
2234:         'COMPACT'                => array(  306.000,   486.000), // = (  108 x 171  ) mm  = (  4.25 x 6.75  ) in
2235:         'ORGANIZERJ'             => array(  198.000,   360.000), // = (   70 x 127  ) mm  = (  2.75 x 5.00  ) in
2236:         // Canadian standard CAN 2-9.60M
2237:         'P1'                     => array( 1587.402,  2437.795), // = (  560 x 860  ) mm  = ( 22.05 x 33.86 ) in
2238:         'P2'                     => array( 1218.898,  1587.402), // = (  430 x 560  ) mm  = ( 16.93 x 22.05 ) in
2239:         'P3'                     => array(  793.701,  1218.898), // = (  280 x 430  ) mm  = ( 11.02 x 16.93 ) in
2240:         'P4'                     => array(  609.449,   793.701), // = (  215 x 280  ) mm  = (  8.46 x 11.02 ) in
2241:         'P5'                     => array(  396.850,   609.449), // = (  140 x 215  ) mm  = (  5.51 x 8.46  ) in
2242:         'P6'                     => array(  303.307,   396.850), // = (  107 x 140  ) mm  = (  4.21 x 5.51  ) in
2243:         // North American Architectural Sizes
2244:         'ARCH_E'                 => array( 2592.000,  3456.000), // = (  914 x 1219 ) mm  = ( 36.00 x 48.00 ) in
2245:         'ARCH_E1'                => array( 2160.000,  3024.000), // = (  762 x 1067 ) mm  = ( 30.00 x 42.00 ) in
2246:         'ARCH_D'                 => array( 1728.000,  2592.000), // = (  610 x 914  ) mm  = ( 24.00 x 36.00 ) in
2247:         'BROADSHEET'             => array( 1296.000,  1728.000), // = (  457 x 610  ) mm  = ( 18.00 x 24.00 ) in
2248:         'ARCH_C'                 => array( 1296.000,  1728.000), // = (  457 x 610  ) mm  = ( 18.00 x 24.00 ) in
2249:         'ARCH_B'                 => array(  864.000,  1296.000), // = (  305 x 457  ) mm  = ( 12.00 x 18.00 ) in
2250:         'ARCH_A'                 => array(  648.000,   864.000), // = (  229 x 305  ) mm  = (  9.00 x 12.00 ) in
2251:         // -- North American Envelope Sizes
2252:         // - Announcement Envelopes
2253:         'ANNENV_A2'              => array(  314.640,   414.000), // = (  111 x 146  ) mm  = (  4.37 x 5.75  ) in
2254:         'ANNENV_A6'              => array(  342.000,   468.000), // = (  121 x 165  ) mm  = (  4.75 x 6.50  ) in
2255:         'ANNENV_A7'              => array(  378.000,   522.000), // = (  133 x 184  ) mm  = (  5.25 x 7.25  ) in
2256:         'ANNENV_A8'              => array(  396.000,   584.640), // = (  140 x 206  ) mm  = (  5.50 x 8.12  ) in
2257:         'ANNENV_A10'             => array(  450.000,   692.640), // = (  159 x 244  ) mm  = (  6.25 x 9.62  ) in
2258:         'ANNENV_SLIM'            => array(  278.640,   638.640), // = (   98 x 225  ) mm  = (  3.87 x 8.87  ) in
2259:         // - Commercial Envelopes
2260:         'COMMENV_N6_1/4'         => array(  252.000,   432.000), // = (   89 x 152  ) mm  = (  3.50 x 6.00  ) in
2261:         'COMMENV_N6_3/4'         => array(  260.640,   468.000), // = (   92 x 165  ) mm  = (  3.62 x 6.50  ) in
2262:         'COMMENV_N8'             => array(  278.640,   540.000), // = (   98 x 191  ) mm  = (  3.87 x 7.50  ) in
2263:         'COMMENV_N9'             => array(  278.640,   638.640), // = (   98 x 225  ) mm  = (  3.87 x 8.87  ) in
2264:         'COMMENV_N10'            => array(  296.640,   684.000), // = (  105 x 241  ) mm  = (  4.12 x 9.50  ) in
2265:         'COMMENV_N11'            => array(  324.000,   746.640), // = (  114 x 263  ) mm  = (  4.50 x 10.37 ) in
2266:         'COMMENV_N12'            => array(  342.000,   792.000), // = (  121 x 279  ) mm  = (  4.75 x 11.00 ) in
2267:         'COMMENV_N14'            => array(  360.000,   828.000), // = (  127 x 292  ) mm  = (  5.00 x 11.50 ) in
2268:         // - Catalogue Envelopes
2269:         'CATENV_N1'              => array(  432.000,   648.000), // = (  152 x 229  ) mm  = (  6.00 x 9.00  ) in
2270:         'CATENV_N1_3/4'          => array(  468.000,   684.000), // = (  165 x 241  ) mm  = (  6.50 x 9.50  ) in
2271:         'CATENV_N2'              => array(  468.000,   720.000), // = (  165 x 254  ) mm  = (  6.50 x 10.00 ) in
2272:         'CATENV_N3'              => array(  504.000,   720.000), // = (  178 x 254  ) mm  = (  7.00 x 10.00 ) in
2273:         'CATENV_N6'              => array(  540.000,   756.000), // = (  191 x 267  ) mm  = (  7.50 x 10.50 ) in
2274:         'CATENV_N7'              => array(  576.000,   792.000), // = (  203 x 279  ) mm  = (  8.00 x 11.00 ) in
2275:         'CATENV_N8'              => array(  594.000,   810.000), // = (  210 x 286  ) mm  = (  8.25 x 11.25 ) in
2276:         'CATENV_N9_1/2'          => array(  612.000,   756.000), // = (  216 x 267  ) mm  = (  8.50 x 10.50 ) in
2277:         'CATENV_N9_3/4'          => array(  630.000,   810.000), // = (  222 x 286  ) mm  = (  8.75 x 11.25 ) in
2278:         'CATENV_N10_1/2'         => array(  648.000,   864.000), // = (  229 x 305  ) mm  = (  9.00 x 12.00 ) in
2279:         'CATENV_N12_1/2'         => array(  684.000,   900.000), // = (  241 x 318  ) mm  = (  9.50 x 12.50 ) in
2280:         'CATENV_N13_1/2'         => array(  720.000,   936.000), // = (  254 x 330  ) mm  = ( 10.00 x 13.00 ) in
2281:         'CATENV_N14_1/4'         => array(  810.000,   882.000), // = (  286 x 311  ) mm  = ( 11.25 x 12.25 ) in
2282:         'CATENV_N14_1/2'         => array(  828.000,  1044.000), // = (  292 x 368  ) mm  = ( 11.50 x 14.50 ) in
2283:         // Japanese (JIS P 0138-61) Standard B-Series
2284:         'JIS_B0'                 => array( 2919.685,  4127.244), // = ( 1030 x 1456 ) mm  = ( 40.55 x 57.32 ) in
2285:         'JIS_B1'                 => array( 2063.622,  2919.685), // = (  728 x 1030 ) mm  = ( 28.66 x 40.55 ) in
2286:         'JIS_B2'                 => array( 1459.843,  2063.622), // = (  515 x 728  ) mm  = ( 20.28 x 28.66 ) in
2287:         'JIS_B3'                 => array( 1031.811,  1459.843), // = (  364 x 515  ) mm  = ( 14.33 x 20.28 ) in
2288:         'JIS_B4'                 => array(  728.504,  1031.811), // = (  257 x 364  ) mm  = ( 10.12 x 14.33 ) in
2289:         'JIS_B5'                 => array(  515.906,   728.504), // = (  182 x 257  ) mm  = (  7.17 x 10.12 ) in
2290:         'JIS_B6'                 => array(  362.835,   515.906), // = (  128 x 182  ) mm  = (  5.04 x 7.17  ) in
2291:         'JIS_B7'                 => array(  257.953,   362.835), // = (   91 x 128  ) mm  = (  3.58 x 5.04  ) in
2292:         'JIS_B8'                 => array(  181.417,   257.953), // = (   64 x 91   ) mm  = (  2.52 x 3.58  ) in
2293:         'JIS_B9'                 => array(  127.559,   181.417), // = (   45 x 64   ) mm  = (  1.77 x 2.52  ) in
2294:         'JIS_B10'                => array(   90.709,   127.559), // = (   32 x 45   ) mm  = (  1.26 x 1.77  ) in
2295:         'JIS_B11'                => array(   62.362,    90.709), // = (   22 x 32   ) mm  = (  0.87 x 1.26  ) in
2296:         'JIS_B12'                => array(   45.354,    62.362), // = (   16 x 22   ) mm  = (  0.63 x 0.87  ) in
2297:         // PA Series
2298:         'PA0'                    => array( 2381.102,  3174.803), // = (  840 x 1120 ) mm  = ( 33.07 x 44.09 ) in
2299:         'PA1'                    => array( 1587.402,  2381.102), // = (  560 x 840  ) mm  = ( 22.05 x 33.07 ) in
2300:         'PA2'                    => array( 1190.551,  1587.402), // = (  420 x 560  ) mm  = ( 16.54 x 22.05 ) in
2301:         'PA3'                    => array(  793.701,  1190.551), // = (  280 x 420  ) mm  = ( 11.02 x 16.54 ) in
2302:         'PA4'                    => array(  595.276,   793.701), // = (  210 x 280  ) mm  = (  8.27 x 11.02 ) in
2303:         'PA5'                    => array(  396.850,   595.276), // = (  140 x 210  ) mm  = (  5.51 x 8.27  ) in
2304:         'PA6'                    => array(  297.638,   396.850), // = (  105 x 140  ) mm  = (  4.13 x 5.51  ) in
2305:         'PA7'                    => array(  198.425,   297.638), // = (   70 x 105  ) mm  = (  2.76 x 4.13  ) in
2306:         'PA8'                    => array(  147.402,   198.425), // = (   52 x 70   ) mm  = (  2.05 x 2.76  ) in
2307:         'PA9'                    => array(   99.213,   147.402), // = (   35 x 52   ) mm  = (  1.38 x 2.05  ) in
2308:         'PA10'                   => array(   73.701,    99.213), // = (   26 x 35   ) mm  = (  1.02 x 1.38  ) in
2309:         // Standard Photographic Print Sizes
2310:         'PASSPORT_PHOTO'         => array(   99.213,   127.559), // = (   35 x 45   ) mm  = (  1.38 x 1.77  ) in
2311:         'E'                      => array(  233.858,   340.157), // = (   82 x 120  ) mm  = (  3.25 x 4.72  ) in
2312:         'L'                      => array(  252.283,   360.000), // = (   89 x 127  ) mm  = (  3.50 x 5.00  ) in
2313:         '3R'                     => array(  252.283,   360.000), // = (   89 x 127  ) mm  = (  3.50 x 5.00  ) in
2314:         'KG'                     => array(  289.134,   430.866), // = (  102 x 152  ) mm  = (  4.02 x 5.98  ) in
2315:         '4R'                     => array(  289.134,   430.866), // = (  102 x 152  ) mm  = (  4.02 x 5.98  ) in
2316:         '4D'                     => array(  340.157,   430.866), // = (  120 x 152  ) mm  = (  4.72 x 5.98  ) in
2317:         '2L'                     => array(  360.000,   504.567), // = (  127 x 178  ) mm  = (  5.00 x 7.01  ) in
2318:         '5R'                     => array(  360.000,   504.567), // = (  127 x 178  ) mm  = (  5.00 x 7.01  ) in
2319:         '8P'                     => array(  430.866,   575.433), // = (  152 x 203  ) mm  = (  5.98 x 7.99  ) in
2320:         '6R'                     => array(  430.866,   575.433), // = (  152 x 203  ) mm  = (  5.98 x 7.99  ) in
2321:         '6P'                     => array(  575.433,   720.000), // = (  203 x 254  ) mm  = (  7.99 x 10.00 ) in
2322:         '8R'                     => array(  575.433,   720.000), // = (  203 x 254  ) mm  = (  7.99 x 10.00 ) in
2323:         '6PW'                    => array(  575.433,   864.567), // = (  203 x 305  ) mm  = (  7.99 x 12.01 ) in
2324:         'S8R'                    => array(  575.433,   864.567), // = (  203 x 305  ) mm  = (  7.99 x 12.01 ) in
2325:         '4P'                     => array(  720.000,   864.567), // = (  254 x 305  ) mm  = ( 10.00 x 12.01 ) in
2326:         '10R'                    => array(  720.000,   864.567), // = (  254 x 305  ) mm  = ( 10.00 x 12.01 ) in
2327:         '4PW'                    => array(  720.000,  1080.000), // = (  254 x 381  ) mm  = ( 10.00 x 15.00 ) in
2328:         'S10R'                   => array(  720.000,  1080.000), // = (  254 x 381  ) mm  = ( 10.00 x 15.00 ) in
2329:         '11R'                    => array(  790.866,  1009.134), // = (  279 x 356  ) mm  = ( 10.98 x 14.02 ) in
2330:         'S11R'                   => array(  790.866,  1224.567), // = (  279 x 432  ) mm  = ( 10.98 x 17.01 ) in
2331:         '12R'                    => array(  864.567,  1080.000), // = (  305 x 381  ) mm  = ( 12.01 x 15.00 ) in
2332:         'S12R'                   => array(  864.567,  1292.598), // = (  305 x 456  ) mm  = ( 12.01 x 17.95 ) in
2333:         // Common Newspaper Sizes
2334:         'NEWSPAPER_BROADSHEET'   => array( 2125.984,  1700.787), // = (  750 x 600  ) mm  = ( 29.53 x 23.62 ) in
2335:         'NEWSPAPER_BERLINER'     => array( 1332.283,   892.913), // = (  470 x 315  ) mm  = ( 18.50 x 12.40 ) in
2336:         'NEWSPAPER_TABLOID'      => array( 1218.898,   793.701), // = (  430 x 280  ) mm  = ( 16.93 x 11.02 ) in
2337:         'NEWSPAPER_COMPACT'      => array( 1218.898,   793.701), // = (  430 x 280  ) mm  = ( 16.93 x 11.02 ) in
2338:         // Business Cards
2339:         'CREDIT_CARD'            => array(  153.014,   242.646), // = (   54 x 86   ) mm  = (  2.13 x 3.37  ) in
2340:         'BUSINESS_CARD'          => array(  153.014,   242.646), // = (   54 x 86   ) mm  = (  2.13 x 3.37  ) in
2341:         'BUSINESS_CARD_ISO7810'  => array(  153.014,   242.646), // = (   54 x 86   ) mm  = (  2.13 x 3.37  ) in
2342:         'BUSINESS_CARD_ISO216'   => array(  147.402,   209.764), // = (   52 x 74   ) mm  = (  2.05 x 2.91  ) in
2343:         'BUSINESS_CARD_IT'       => array(  155.906,   240.945), // = (   55 x 85   ) mm  = (  2.17 x 3.35  ) in
2344:         'BUSINESS_CARD_UK'       => array(  155.906,   240.945), // = (   55 x 85   ) mm  = (  2.17 x 3.35  ) in
2345:         'BUSINESS_CARD_FR'       => array(  155.906,   240.945), // = (   55 x 85   ) mm  = (  2.17 x 3.35  ) in
2346:         'BUSINESS_CARD_DE'       => array(  155.906,   240.945), // = (   55 x 85   ) mm  = (  2.17 x 3.35  ) in
2347:         'BUSINESS_CARD_ES'       => array(  155.906,   240.945), // = (   55 x 85   ) mm  = (  2.17 x 3.35  ) in
2348:         'BUSINESS_CARD_CA'       => array(  144.567,   252.283), // = (   51 x 89   ) mm  = (  2.01 x 3.50  ) in
2349:         'BUSINESS_CARD_US'       => array(  144.567,   252.283), // = (   51 x 89   ) mm  = (  2.01 x 3.50  ) in
2350:         'BUSINESS_CARD_JP'       => array(  155.906,   257.953), // = (   55 x 91   ) mm  = (  2.17 x 3.58  ) in
2351:         'BUSINESS_CARD_HK'       => array(  153.071,   255.118), // = (   54 x 90   ) mm  = (  2.13 x 3.54  ) in
2352:         'BUSINESS_CARD_AU'       => array(  155.906,   255.118), // = (   55 x 90   ) mm  = (  2.17 x 3.54  ) in
2353:         'BUSINESS_CARD_DK'       => array(  155.906,   255.118), // = (   55 x 90   ) mm  = (  2.17 x 3.54  ) in
2354:         'BUSINESS_CARD_SE'       => array(  155.906,   255.118), // = (   55 x 90   ) mm  = (  2.17 x 3.54  ) in
2355:         'BUSINESS_CARD_RU'       => array(  141.732,   255.118), // = (   50 x 90   ) mm  = (  1.97 x 3.54  ) in
2356:         'BUSINESS_CARD_CZ'       => array(  141.732,   255.118), // = (   50 x 90   ) mm  = (  1.97 x 3.54  ) in
2357:         'BUSINESS_CARD_FI'       => array(  141.732,   255.118), // = (   50 x 90   ) mm  = (  1.97 x 3.54  ) in
2358:         'BUSINESS_CARD_HU'       => array(  141.732,   255.118), // = (   50 x 90   ) mm  = (  1.97 x 3.54  ) in
2359:         'BUSINESS_CARD_IL'       => array(  141.732,   255.118), // = (   50 x 90   ) mm  = (  1.97 x 3.54  ) in
2360:         // Billboards
2361:         '4SHEET'                 => array( 2880.000,  4320.000), // = ( 1016 x 1524 ) mm  = ( 40.00 x 60.00 ) in
2362:         '6SHEET'                 => array( 3401.575,  5102.362), // = ( 1200 x 1800 ) mm  = ( 47.24 x 70.87 ) in
2363:         '12SHEET'                => array( 8640.000,  4320.000), // = ( 3048 x 1524 ) mm  = (120.00 x 60.00 ) in
2364:         '16SHEET'                => array( 5760.000,  8640.000), // = ( 2032 x 3048 ) mm  = ( 80.00 x 120.00) in
2365:         '32SHEET'                => array(11520.000,  8640.000), // = ( 4064 x 3048 ) mm  = (160.00 x 120.00) in
2366:         '48SHEET'                => array(17280.000,  8640.000), // = ( 6096 x 3048 ) mm  = (240.00 x 120.00) in
2367:         '64SHEET'                => array(23040.000,  8640.000), // = ( 8128 x 3048 ) mm  = (320.00 x 120.00) in
2368:         '96SHEET'                => array(34560.000,  8640.000), // = (12192 x 3048 ) mm  = (480.00 x 120.00) in
2369:         // -- Old European Sizes
2370:         // - Old Imperial English Sizes
2371:         'EN_EMPEROR'             => array( 3456.000,  5184.000), // = ( 1219 x 1829 ) mm  = ( 48.00 x 72.00 ) in
2372:         'EN_ANTIQUARIAN'         => array( 2232.000,  3816.000), // = (  787 x 1346 ) mm  = ( 31.00 x 53.00 ) in
2373:         'EN_GRAND_EAGLE'         => array( 2070.000,  3024.000), // = (  730 x 1067 ) mm  = ( 28.75 x 42.00 ) in
2374:         'EN_DOUBLE_ELEPHANT'     => array( 1926.000,  2880.000), // = (  679 x 1016 ) mm  = ( 26.75 x 40.00 ) in
2375:         'EN_ATLAS'               => array( 1872.000,  2448.000), // = (  660 x 864  ) mm  = ( 26.00 x 34.00 ) in
2376:         'EN_COLOMBIER'           => array( 1692.000,  2484.000), // = (  597 x 876  ) mm  = ( 23.50 x 34.50 ) in
2377:         'EN_ELEPHANT'            => array( 1656.000,  2016.000), // = (  584 x 711  ) mm  = ( 23.00 x 28.00 ) in
2378:         'EN_DOUBLE_DEMY'         => array( 1620.000,  2556.000), // = (  572 x 902  ) mm  = ( 22.50 x 35.50 ) in
2379:         'EN_IMPERIAL'            => array( 1584.000,  2160.000), // = (  559 x 762  ) mm  = ( 22.00 x 30.00 ) in
2380:         'EN_PRINCESS'            => array( 1548.000,  2016.000), // = (  546 x 711  ) mm  = ( 21.50 x 28.00 ) in
2381:         'EN_CARTRIDGE'           => array( 1512.000,  1872.000), // = (  533 x 660  ) mm  = ( 21.00 x 26.00 ) in
2382:         'EN_DOUBLE_LARGE_POST'   => array( 1512.000,  2376.000), // = (  533 x 838  ) mm  = ( 21.00 x 33.00 ) in
2383:         'EN_ROYAL'               => array( 1440.000,  1800.000), // = (  508 x 635  ) mm  = ( 20.00 x 25.00 ) in
2384:         'EN_SHEET'               => array( 1404.000,  1692.000), // = (  495 x 597  ) mm  = ( 19.50 x 23.50 ) in
2385:         'EN_HALF_POST'           => array( 1404.000,  1692.000), // = (  495 x 597  ) mm  = ( 19.50 x 23.50 ) in
2386:         'EN_SUPER_ROYAL'         => array( 1368.000,  1944.000), // = (  483 x 686  ) mm  = ( 19.00 x 27.00 ) in
2387:         'EN_DOUBLE_POST'         => array( 1368.000,  2196.000), // = (  483 x 775  ) mm  = ( 19.00 x 30.50 ) in
2388:         'EN_MEDIUM'              => array( 1260.000,  1656.000), // = (  445 x 584  ) mm  = ( 17.50 x 23.00 ) in
2389:         'EN_DEMY'                => array( 1260.000,  1620.000), // = (  445 x 572  ) mm  = ( 17.50 x 22.50 ) in
2390:         'EN_LARGE_POST'          => array( 1188.000,  1512.000), // = (  419 x 533  ) mm  = ( 16.50 x 21.00 ) in
2391:         'EN_COPY_DRAUGHT'        => array( 1152.000,  1440.000), // = (  406 x 508  ) mm  = ( 16.00 x 20.00 ) in
2392:         'EN_POST'                => array( 1116.000,  1386.000), // = (  394 x 489  ) mm  = ( 15.50 x 19.25 ) in
2393:         'EN_CROWN'               => array( 1080.000,  1440.000), // = (  381 x 508  ) mm  = ( 15.00 x 20.00 ) in
2394:         'EN_PINCHED_POST'        => array( 1062.000,  1332.000), // = (  375 x 470  ) mm  = ( 14.75 x 18.50 ) in
2395:         'EN_BRIEF'               => array(  972.000,  1152.000), // = (  343 x 406  ) mm  = ( 13.50 x 16.00 ) in
2396:         'EN_FOOLSCAP'            => array(  972.000,  1224.000), // = (  343 x 432  ) mm  = ( 13.50 x 17.00 ) in
2397:         'EN_SMALL_FOOLSCAP'      => array(  954.000,  1188.000), // = (  337 x 419  ) mm  = ( 13.25 x 16.50 ) in
2398:         'EN_POTT'                => array(  900.000,  1080.000), // = (  318 x 381  ) mm  = ( 12.50 x 15.00 ) in
2399:         // - Old Imperial Belgian Sizes
2400:         'BE_GRAND_AIGLE'         => array( 1984.252,  2948.031), // = (  700 x 1040 ) mm  = ( 27.56 x 40.94 ) in
2401:         'BE_COLOMBIER'           => array( 1757.480,  2409.449), // = (  620 x 850  ) mm  = ( 24.41 x 33.46 ) in
2402:         'BE_DOUBLE_CARRE'        => array( 1757.480,  2607.874), // = (  620 x 920  ) mm  = ( 24.41 x 36.22 ) in
2403:         'BE_ELEPHANT'            => array( 1746.142,  2182.677), // = (  616 x 770  ) mm  = ( 24.25 x 30.31 ) in
2404:         'BE_PETIT_AIGLE'         => array( 1700.787,  2381.102), // = (  600 x 840  ) mm  = ( 23.62 x 33.07 ) in
2405:         'BE_GRAND_JESUS'         => array( 1559.055,  2069.291), // = (  550 x 730  ) mm  = ( 21.65 x 28.74 ) in
2406:         'BE_JESUS'               => array( 1530.709,  2069.291), // = (  540 x 730  ) mm  = ( 21.26 x 28.74 ) in
2407:         'BE_RAISIN'              => array( 1417.323,  1842.520), // = (  500 x 650  ) mm  = ( 19.69 x 25.59 ) in
2408:         'BE_GRAND_MEDIAN'        => array( 1303.937,  1714.961), // = (  460 x 605  ) mm  = ( 18.11 x 23.82 ) in
2409:         'BE_DOUBLE_POSTE'        => array( 1233.071,  1601.575), // = (  435 x 565  ) mm  = ( 17.13 x 22.24 ) in
2410:         'BE_COQUILLE'            => array( 1218.898,  1587.402), // = (  430 x 560  ) mm  = ( 16.93 x 22.05 ) in
2411:         'BE_PETIT_MEDIAN'        => array( 1176.378,  1502.362), // = (  415 x 530  ) mm  = ( 16.34 x 20.87 ) in
2412:         'BE_RUCHE'               => array( 1020.472,  1303.937), // = (  360 x 460  ) mm  = ( 14.17 x 18.11 ) in
2413:         'BE_PROPATRIA'           => array(  977.953,  1218.898), // = (  345 x 430  ) mm  = ( 13.58 x 16.93 ) in
2414:         'BE_LYS'                 => array(  898.583,  1125.354), // = (  317 x 397  ) mm  = ( 12.48 x 15.63 ) in
2415:         'BE_POT'                 => array(  870.236,  1088.504), // = (  307 x 384  ) mm  = ( 12.09 x 15.12 ) in
2416:         'BE_ROSETTE'             => array(  765.354,   983.622), // = (  270 x 347  ) mm  = ( 10.63 x 13.66 ) in
2417:         // - Old Imperial French Sizes
2418:         'FR_UNIVERS'             => array( 2834.646,  3685.039), // = ( 1000 x 1300 ) mm  = ( 39.37 x 51.18 ) in
2419:         'FR_DOUBLE_COLOMBIER'    => array( 2551.181,  3571.654), // = (  900 x 1260 ) mm  = ( 35.43 x 49.61 ) in
2420:         'FR_GRANDE_MONDE'        => array( 2551.181,  3571.654), // = (  900 x 1260 ) mm  = ( 35.43 x 49.61 ) in
2421:         'FR_DOUBLE_SOLEIL'       => array( 2267.717,  3401.575), // = (  800 x 1200 ) mm  = ( 31.50 x 47.24 ) in
2422:         'FR_DOUBLE_JESUS'        => array( 2154.331,  3174.803), // = (  760 x 1120 ) mm  = ( 29.92 x 44.09 ) in
2423:         'FR_GRAND_AIGLE'         => array( 2125.984,  3004.724), // = (  750 x 1060 ) mm  = ( 29.53 x 41.73 ) in
2424:         'FR_PETIT_AIGLE'         => array( 1984.252,  2664.567), // = (  700 x 940  ) mm  = ( 27.56 x 37.01 ) in
2425:         'FR_DOUBLE_RAISIN'       => array( 1842.520,  2834.646), // = (  650 x 1000 ) mm  = ( 25.59 x 39.37 ) in
2426:         'FR_JOURNAL'             => array( 1842.520,  2664.567), // = (  650 x 940  ) mm  = ( 25.59 x 37.01 ) in
2427:         'FR_COLOMBIER_AFFICHE'   => array( 1785.827,  2551.181), // = (  630 x 900  ) mm  = ( 24.80 x 35.43 ) in
2428:         'FR_DOUBLE_CAVALIER'     => array( 1757.480,  2607.874), // = (  620 x 920  ) mm  = ( 24.41 x 36.22 ) in
2429:         'FR_CLOCHE'              => array( 1700.787,  2267.717), // = (  600 x 800  ) mm  = ( 23.62 x 31.50 ) in
2430:         'FR_SOLEIL'              => array( 1700.787,  2267.717), // = (  600 x 800  ) mm  = ( 23.62 x 31.50 ) in
2431:         'FR_DOUBLE_CARRE'        => array( 1587.402,  2551.181), // = (  560 x 900  ) mm  = ( 22.05 x 35.43 ) in
2432:         'FR_DOUBLE_COQUILLE'     => array( 1587.402,  2494.488), // = (  560 x 880  ) mm  = ( 22.05 x 34.65 ) in
2433:         'FR_JESUS'               => array( 1587.402,  2154.331), // = (  560 x 760  ) mm  = ( 22.05 x 29.92 ) in
2434:         'FR_RAISIN'              => array( 1417.323,  1842.520), // = (  500 x 650  ) mm  = ( 19.69 x 25.59 ) in
2435:         'FR_CAVALIER'            => array( 1303.937,  1757.480), // = (  460 x 620  ) mm  = ( 18.11 x 24.41 ) in
2436:         'FR_DOUBLE_COURONNE'     => array( 1303.937,  2040.945), // = (  460 x 720  ) mm  = ( 18.11 x 28.35 ) in
2437:         'FR_CARRE'               => array( 1275.591,  1587.402), // = (  450 x 560  ) mm  = ( 17.72 x 22.05 ) in
2438:         'FR_COQUILLE'            => array( 1247.244,  1587.402), // = (  440 x 560  ) mm  = ( 17.32 x 22.05 ) in
2439:         'FR_DOUBLE_TELLIERE'     => array( 1247.244,  1927.559), // = (  440 x 680  ) mm  = ( 17.32 x 26.77 ) in
2440:         'FR_DOUBLE_CLOCHE'       => array( 1133.858,  1700.787), // = (  400 x 600  ) mm  = ( 15.75 x 23.62 ) in
2441:         'FR_DOUBLE_POT'          => array( 1133.858,  1757.480), // = (  400 x 620  ) mm  = ( 15.75 x 24.41 ) in
2442:         'FR_ECU'                 => array( 1133.858,  1474.016), // = (  400 x 520  ) mm  = ( 15.75 x 20.47 ) in
2443:         'FR_COURONNE'            => array( 1020.472,  1303.937), // = (  360 x 460  ) mm  = ( 14.17 x 18.11 ) in
2444:         'FR_TELLIERE'            => array(  963.780,  1247.244), // = (  340 x 440  ) mm  = ( 13.39 x 17.32 ) in
2445:         'FR_POT'                 => array(  878.740,  1133.858), // = (  310 x 400  ) mm  = ( 12.20 x 15.75 ) in
2446:     );
2447: 
2448: 
2449:     /**
2450:      * Get page dimensions from format name.
2451:      * @param $format (mixed) The format name @see self::$page_format<ul>
2452:      * @return array containing page width and height in points
2453:      * @since 5.0.010 (2010-05-17)
2454:      * @public static
2455:      */
2456:     public static function getPageSizeFromFormat($format) {
2457:         if (isset(self::$page_formats[$format])) {
2458:             return self::$page_formats[$format];
2459:         }
2460:         return self::$page_formats['A4'];
2461:     }
2462: 
2463:     /**
2464:      * Set page boundaries.
2465:      * @param $page (int) page number
2466:      * @param $type (string) valid values are: <ul><li>'MediaBox' : the boundaries of the physical medium on which the page shall be displayed or printed;</li><li>'CropBox' : the visible region of default user space;</li><li>'BleedBox' : the region to which the contents of the page shall be clipped when output in a production environment;</li><li>'TrimBox' : the intended dimensions of the finished page after trimming;</li><li>'ArtBox' : the page's meaningful content (including potential white space).</li></ul>
2467:      * @param $llx (float) lower-left x coordinate in user units.
2468:      * @param $lly (float) lower-left y coordinate in user units.
2469:      * @param $urx (float) upper-right x coordinate in user units.
2470:      * @param $ury (float) upper-right y coordinate in user units.
2471:      * @param $points (boolean) If true uses user units as unit of measure, otherwise uses PDF points.
2472:      * @param $k (float) Scale factor (number of points in user unit).
2473:      * @param $pagedim (array) Array of page dimensions.
2474:      * @return pagedim array of page dimensions.
2475:      * @since 5.0.010 (2010-05-17)
2476:      * @public static
2477:      */
2478:     public static function setPageBoxes($page, $type, $llx, $lly, $urx, $ury, $points=false, $k, $pagedim=array()) {
2479:         if (!isset($pagedim[$page])) {
2480:             // initialize array
2481:             $pagedim[$page] = array();
2482:         }
2483:         if (!in_array($type, self::$pageboxes)) {
2484:             return;
2485:         }
2486:         if ($points) {
2487:             $k = 1;
2488:         }
2489:         $pagedim[$page][$type]['llx'] = ($llx * $k);
2490:         $pagedim[$page][$type]['lly'] = ($lly * $k);
2491:         $pagedim[$page][$type]['urx'] = ($urx * $k);
2492:         $pagedim[$page][$type]['ury'] = ($ury * $k);
2493:         return $pagedim;
2494:     }
2495: 
2496:     /**
2497:      * Swap X and Y coordinates of page boxes (change page boxes orientation).
2498:      * @param $page (int) page number
2499:      * @param $pagedim (array) Array of page dimensions.
2500:      * @return pagedim array of page dimensions.
2501:      * @since 5.0.010 (2010-05-17)
2502:      * @public static
2503:      */
2504:     public static function swapPageBoxCoordinates($page, $pagedim) {
2505:         foreach (self::$pageboxes as $type) {
2506:             // swap X and Y coordinates
2507:             if (isset($pagedim[$page][$type])) {
2508:                 $tmp = $pagedim[$page][$type]['llx'];
2509:                 $pagedim[$page][$type]['llx'] = $pagedim[$page][$type]['lly'];
2510:                 $pagedim[$page][$type]['lly'] = $tmp;
2511:                 $tmp = $pagedim[$page][$type]['urx'];
2512:                 $pagedim[$page][$type]['urx'] = $pagedim[$page][$type]['ury'];
2513:                 $pagedim[$page][$type]['ury'] = $tmp;
2514:             }
2515:         }
2516:         return $pagedim;
2517:     }
2518: 
2519:     /**
2520:      * Get the canonical page layout mode.
2521:      * @param $layout (string) The page layout. Possible values are:<ul><li>SinglePage Display one page at a time</li><li>OneColumn Display the pages in one column</li><li>TwoColumnLeft Display the pages in two columns, with odd-numbered pages on the left</li><li>TwoColumnRight Display the pages in two columns, with odd-numbered pages on the right</li><li>TwoPageLeft (PDF 1.5) Display the pages two at a time, with odd-numbered pages on the left</li><li>TwoPageRight (PDF 1.5) Display the pages two at a time, with odd-numbered pages on the right</li></ul>
2522:      * @return (string) Canonical page layout name.
2523:      * @public static
2524:      */
2525:     public static function getPageLayoutMode($layout='SinglePage') {
2526:         switch ($layout) {
2527:             case 'default':
2528:             case 'single':
2529:             case 'SinglePage': {
2530:                 $layout_mode = 'SinglePage';
2531:                 break;
2532:             }
2533:             case 'continuous':
2534:             case 'OneColumn': {
2535:                 $layout_mode = 'OneColumn';
2536:                 break;
2537:             }
2538:             case 'two':
2539:             case 'TwoColumnLeft': {
2540:                 $layout_mode = 'TwoColumnLeft';
2541:                 break;
2542:             }
2543:             case 'TwoColumnRight': {
2544:                 $layout_mode = 'TwoColumnRight';
2545:                 break;
2546:             }
2547:             case 'TwoPageLeft': {
2548:                 $layout_mode = 'TwoPageLeft';
2549:                 break;
2550:             }
2551:             case 'TwoPageRight': {
2552:                 $layout_mode = 'TwoPageRight';
2553:                 break;
2554:             }
2555:             default: {
2556:                 $layout_mode = 'SinglePage';
2557:             }
2558:         }
2559:         return $layout_mode;
2560:     }
2561: 
2562:     /**
2563:      * Get the canonical page layout mode.
2564:      * @param $mode (string) A name object specifying how the document should be displayed when opened:<ul><li>UseNone Neither document outline nor thumbnail images visible</li><li>UseOutlines Document outline visible</li><li>UseThumbs Thumbnail images visible</li><li>FullScreen Full-screen mode, with no menu bar, window controls, or any other window visible</li><li>UseOC (PDF 1.5) Optional content group panel visible</li><li>UseAttachments (PDF 1.6) Attachments panel visible</li></ul>
2565:      * @return (string) Canonical page mode name.
2566:      * @public static
2567:      */
2568:     public static function getPageMode($mode='UseNone') {
2569:         switch ($mode) {
2570:             case 'UseNone': {
2571:                 $page_mode = 'UseNone';
2572:                 break;
2573:             }
2574:             case 'UseOutlines': {
2575:                 $page_mode = 'UseOutlines';
2576:                 break;
2577:             }
2578:             case 'UseThumbs': {
2579:                 $page_mode = 'UseThumbs';
2580:                 break;
2581:             }
2582:             case 'FullScreen': {
2583:                 $page_mode = 'FullScreen';
2584:                 break;
2585:             }
2586:             case 'UseOC': {
2587:                 $page_mode = 'UseOC';
2588:                 break;
2589:             }
2590:             case '': {
2591:                 $page_mode = 'UseAttachments';
2592:                 break;
2593:             }
2594:             default: {
2595:                 $page_mode = 'UseNone';
2596:             }
2597:         }
2598:         return $page_mode;
2599:     }
2600: 
2601: 
2602: } // END OF TCPDF_STATIC CLASS
2603: 
2604: //============================================================+
2605: // END OF FILE
2606: //============================================================+
2607: 
 

© 2004-2018 – Nicola Asuni - Tecnick.com - All rights reserved.
about - disclaimer - privacy