source: trunk/client/inc/hpdf5/tecnickcom/tcpdf/include/tcpdf_static.php@ 412

Last change on this file since 412 was 347, checked in by roby, 4 years ago

Aggiornamento per compatibilità con php7.4
File size: 107.5 KB
Line 
1<?php
2//============================================================+
3// File name : tcpdf_static.php
4// Version : 1.1.4
5// Begin : 2002-08-03
6// Last Update : 2019-11-01
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 */
52class TCPDF_STATIC {
53
54 /**
55 * Current TCPDF version.
56 * @private static
57 */
58 private static $tcpdf_version = '6.3.5';
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 bool 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 if ($number >= 4000) {
1444 // do not represent numbers above 4000 in Roman numerals
1445 return strval($number);
1446 }
1447 while ($number >= 1000) {
1448 $roman .= 'M';
1449 $number -= 1000;
1450 }
1451 while ($number >= 900) {
1452 $roman .= 'CM';
1453 $number -= 900;
1454 }
1455 while ($number >= 500) {
1456 $roman .= 'D';
1457 $number -= 500;
1458 }
1459 while ($number >= 400) {
1460 $roman .= 'CD';
1461 $number -= 400;
1462 }
1463 while ($number >= 100) {
1464 $roman .= 'C';
1465 $number -= 100;
1466 }
1467 while ($number >= 90) {
1468 $roman .= 'XC';
1469 $number -= 90;
1470 }
1471 while ($number >= 50) {
1472 $roman .= 'L';
1473 $number -= 50;
1474 }
1475 while ($number >= 40) {
1476 $roman .= 'XL';
1477 $number -= 40;
1478 }
1479 while ($number >= 10) {
1480 $roman .= 'X';
1481 $number -= 10;
1482 }
1483 while ($number >= 9) {
1484 $roman .= 'IX';
1485 $number -= 9;
1486 }
1487 while ($number >= 5) {
1488 $roman .= 'V';
1489 $number -= 5;
1490 }
1491 while ($number >= 4) {
1492 $roman .= 'IV';
1493 $number -= 4;
1494 }
1495 while ($number >= 1) {
1496 $roman .= 'I';
1497 --$number;
1498 }
1499 return $roman;
1500 }
1501
1502 /**
1503 * Find position of last occurrence of a substring in a string
1504 * @param $haystack (string) The string to search in.
1505 * @param $needle (string) substring to search.
1506 * @param $offset (int) May be specified to begin searching an arbitrary number of characters into the string.
1507 * @return Returns the position where the needle exists. Returns FALSE if the needle was not found.
1508 * @since 4.8.038 (2010-03-13)
1509 * @public static
1510 */
1511 public static function revstrpos($haystack, $needle, $offset = 0) {
1512 $length = strlen($haystack);
1513 $offset = ($offset > 0)?($length - $offset):abs($offset);
1514 $pos = strpos(strrev($haystack), strrev($needle), $offset);
1515 return ($pos === false)?false:($length - $pos - strlen($needle));
1516 }
1517
1518 /**
1519 * Returns an array of hyphenation patterns.
1520 * @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/
1521 * @return array of hyphenation patterns
1522 * @author Nicola Asuni
1523 * @since 4.9.012 (2010-04-12)
1524 * @public static
1525 */
1526 public static function getHyphenPatternsFromTEX($file) {
1527 // TEX patterns are available at:
1528 // http://www.ctan.org/tex-archive/language/hyph-utf8/tex/generic/hyph-utf8/patterns/
1529 $data = file_get_contents($file);
1530 $patterns = array();
1531 // remove comments
1532 $data = preg_replace('/\%[^\n]*/', '', $data);
1533 // extract the patterns part
1534 preg_match('/\\\\patterns\{([^\}]*)\}/i', $data, $matches);
1535 $data = trim(substr($matches[0], 10, -1));
1536 // extract each pattern
1537 $patterns_array = preg_split('/[\s]+/', $data);
1538 // create new language array of patterns
1539 $patterns = array();
1540 foreach($patterns_array as $val) {
1541 if (!TCPDF_STATIC::empty_string($val)) {
1542 $val = trim($val);
1543 $val = str_replace('\'', '\\\'', $val);
1544 $key = preg_replace('/[0-9]+/', '', $val);
1545 $patterns[$key] = $val;
1546 }
1547 }
1548 return $patterns;
1549 }
1550
1551 /**
1552 * Get the Path-Painting Operators.
1553 * @param $style (string) Style of rendering. Possible values are:
1554 * <ul>
1555 * <li>S or D: Stroke the path.</li>
1556 * <li>s or d: Close and stroke the path.</li>
1557 * <li>f or F: Fill the path, using the nonzero winding number rule to determine the region to fill.</li>
1558 * <li>f* or F*: Fill the path, using the even-odd rule to determine the region to fill.</li>
1559 * <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>
1560 * <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>
1561 * <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>
1562 * <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>
1563 * <li>CNZ: Clipping mode using the even-odd rule to determine which regions lie inside the clipping path.</li>
1564 * <li>CEO: Clipping mode using the nonzero winding number rule to determine which regions lie inside the clipping path</li>
1565 * <li>n: End the path object without filling or stroking it.</li>
1566 * </ul>
1567 * @param $default (string) default style
1568 * @author Nicola Asuni
1569 * @since 5.0.000 (2010-04-30)
1570 * @public static
1571 */
1572 public static function getPathPaintOperator($style, $default='S') {
1573 $op = '';
1574 switch($style) {
1575 case 'S':
1576 case 'D': {
1577 $op = 'S';
1578 break;
1579 }
1580 case 's':
1581 case 'd': {
1582 $op = 's';
1583 break;
1584 }
1585 case 'f':
1586 case 'F': {
1587 $op = 'f';
1588 break;
1589 }
1590 case 'f*':
1591 case 'F*': {
1592 $op = 'f*';
1593 break;
1594 }
1595 case 'B':
1596 case 'FD':
1597 case 'DF': {
1598 $op = 'B';
1599 break;
1600 }
1601 case 'B*':
1602 case 'F*D':
1603 case 'DF*': {
1604 $op = 'B*';
1605 break;
1606 }
1607 case 'b':
1608 case 'fd':
1609 case 'df': {
1610 $op = 'b';
1611 break;
1612 }
1613 case 'b*':
1614 case 'f*d':
1615 case 'df*': {
1616 $op = 'b*';
1617 break;
1618 }
1619 case 'CNZ': {
1620 $op = 'W n';
1621 break;
1622 }
1623 case 'CEO': {
1624 $op = 'W* n';
1625 break;
1626 }
1627 case 'n': {
1628 $op = 'n';
1629 break;
1630 }
1631 default: {
1632 if (!empty($default)) {
1633 $op = self::getPathPaintOperator($default, '');
1634 } else {
1635 $op = '';
1636 }
1637 }
1638 }
1639 return $op;
1640 }
1641
1642 /**
1643 * Get the product of two SVG tranformation matrices
1644 * @param $ta (array) first SVG tranformation matrix
1645 * @param $tb (array) second SVG tranformation matrix
1646 * @return transformation array
1647 * @author Nicola Asuni
1648 * @since 5.0.000 (2010-05-02)
1649 * @public static
1650 */
1651 public static function getTransformationMatrixProduct($ta, $tb) {
1652 $tm = array();
1653 $tm[0] = ($ta[0] * $tb[0]) + ($ta[2] * $tb[1]);
1654 $tm[1] = ($ta[1] * $tb[0]) + ($ta[3] * $tb[1]);
1655 $tm[2] = ($ta[0] * $tb[2]) + ($ta[2] * $tb[3]);
1656 $tm[3] = ($ta[1] * $tb[2]) + ($ta[3] * $tb[3]);
1657 $tm[4] = ($ta[0] * $tb[4]) + ($ta[2] * $tb[5]) + $ta[4];
1658 $tm[5] = ($ta[1] * $tb[4]) + ($ta[3] * $tb[5]) + $ta[5];
1659 return $tm;
1660 }
1661
1662 /**
1663 * Get the tranformation matrix from SVG transform attribute
1664 * @param $attribute (string) transformation
1665 * @return array of transformations
1666 * @author Nicola Asuni
1667 * @since 5.0.000 (2010-05-02)
1668 * @public static
1669 */
1670 public static function getSVGTransformMatrix($attribute) {
1671 // identity matrix
1672 $tm = array(1, 0, 0, 1, 0, 0);
1673 $transform = array();
1674 if (preg_match_all('/(matrix|translate|scale|rotate|skewX|skewY)[\s]*\(([^\)]+)\)/si', $attribute, $transform, PREG_SET_ORDER) > 0) {
1675 foreach ($transform as $key => $data) {
1676 if (!empty($data[2])) {
1677 $a = 1;
1678 $b = 0;
1679 $c = 0;
1680 $d = 1;
1681 $e = 0;
1682 $f = 0;
1683 $regs = array();
1684 switch ($data[1]) {
1685 case 'matrix': {
1686 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)) {
1687 $a = $regs[1];
1688 $b = $regs[2];
1689 $c = $regs[3];
1690 $d = $regs[4];
1691 $e = $regs[5];
1692 $f = $regs[6];
1693 }
1694 break;
1695 }
1696 case 'translate': {
1697 if (preg_match('/([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)/si', $data[2], $regs)) {
1698 $e = $regs[1];
1699 $f = $regs[2];
1700 } elseif (preg_match('/([a-z0-9\-\.]+)/si', $data[2], $regs)) {
1701 $e = $regs[1];
1702 }
1703 break;
1704 }
1705 case 'scale': {
1706 if (preg_match('/([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)/si', $data[2], $regs)) {
1707 $a = $regs[1];
1708 $d = $regs[2];
1709 } elseif (preg_match('/([a-z0-9\-\.]+)/si', $data[2], $regs)) {
1710 $a = $regs[1];
1711 $d = $a;
1712 }
1713 break;
1714 }
1715 case 'rotate': {
1716 if (preg_match('/([0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)/si', $data[2], $regs)) {
1717 $ang = deg2rad($regs[1]);
1718 $x = $regs[2];
1719 $y = $regs[3];
1720 $a = cos($ang);
1721 $b = sin($ang);
1722 $c = -$b;
1723 $d = $a;
1724 $e = ($x * (1 - $a)) - ($y * $c);
1725 $f = ($y * (1 - $d)) - ($x * $b);
1726 } elseif (preg_match('/([0-9\-\.]+)/si', $data[2], $regs)) {
1727 $ang = deg2rad($regs[1]);
1728 $a = cos($ang);
1729 $b = sin($ang);
1730 $c = -$b;
1731 $d = $a;
1732 $e = 0;
1733 $f = 0;
1734 }
1735 break;
1736 }
1737 case 'skewX': {
1738 if (preg_match('/([0-9\-\.]+)/si', $data[2], $regs)) {
1739 $c = tan(deg2rad($regs[1]));
1740 }
1741 break;
1742 }
1743 case 'skewY': {
1744 if (preg_match('/([0-9\-\.]+)/si', $data[2], $regs)) {
1745 $b = tan(deg2rad($regs[1]));
1746 }
1747 break;
1748 }
1749 }
1750 $tm = self::getTransformationMatrixProduct($tm, array($a, $b, $c, $d, $e, $f));
1751 }
1752 }
1753 }
1754 return $tm;
1755 }
1756
1757 /**
1758 * Returns the angle in radiants between two vectors
1759 * @param $x1 (int) X coordinate of first vector point
1760 * @param $y1 (int) Y coordinate of first vector point
1761 * @param $x2 (int) X coordinate of second vector point
1762 * @param $y2 (int) Y coordinate of second vector point
1763 * @author Nicola Asuni
1764 * @since 5.0.000 (2010-05-04)
1765 * @public static
1766 */
1767 public static function getVectorsAngle($x1, $y1, $x2, $y2) {
1768 $dprod = ($x1 * $x2) + ($y1 * $y2);
1769 $dist1 = sqrt(($x1 * $x1) + ($y1 * $y1));
1770 $dist2 = sqrt(($x2 * $x2) + ($y2 * $y2));
1771 $angle = acos($dprod / ($dist1 * $dist2));
1772 if (is_nan($angle)) {
1773 $angle = M_PI;
1774 }
1775 if ((($x1 * $y2) - ($x2 * $y1)) < 0) {
1776 $angle *= -1;
1777 }
1778 return $angle;
1779 }
1780
1781 /**
1782 * Split string by a regular expression.
1783 * This is a wrapper for the preg_split function to avoid the bug: https://bugs.php.net/bug.php?id=45850
1784 * @param $pattern (string) The regular expression pattern to search for without the modifiers, as a string.
1785 * @param $modifiers (string) The modifiers part of the pattern,
1786 * @param $subject (string) The input string.
1787 * @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.
1788 * @param $flags (int) The flags as specified on the preg_split PHP function.
1789 * @return Returns an array containing substrings of subject split along boundaries matched by pattern.modifier
1790 * @author Nicola Asuni
1791 * @since 6.0.023
1792 * @public static
1793 */
1794 public static function pregSplit($pattern, $modifiers, $subject, $limit=NULL, $flags=NULL) {
1795 // the bug only happens on PHP 5.2 when using the u modifier
1796 if ((strpos($modifiers, 'u') === FALSE) OR (count(preg_split('//u', "\n\t", -1, PREG_SPLIT_NO_EMPTY)) == 2)) {
1797 return preg_split($pattern.$modifiers, $subject, $limit, $flags);
1798 }
1799 // preg_split is bugged - try alternative solution
1800 $ret = array();
1801 while (($nl = strpos($subject, "\n")) !== FALSE) {
1802 $ret = array_merge($ret, preg_split($pattern.$modifiers, substr($subject, 0, $nl), $limit, $flags));
1803 $ret[] = "\n";
1804 $subject = substr($subject, ($nl + 1));
1805 }
1806 if (strlen($subject) > 0) {
1807 $ret = array_merge($ret, preg_split($pattern.$modifiers, $subject, $limit, $flags));
1808 }
1809 return $ret;
1810 }
1811
1812 /**
1813 * Wrapper to use fopen only with local files
1814 * @param filename (string) Name of the file to open
1815 * @param $mode (string)
1816 * @return Returns a file pointer resource on success, or FALSE on error.
1817 * @public static
1818 */
1819 public static function fopenLocal($filename, $mode) {
1820 if (strpos($filename, '://') === false) {
1821 $filename = 'file://'.$filename;
1822 } elseif (stream_is_local($filename) !== true) {
1823 return false;
1824 }
1825 return fopen($filename, $mode);
1826 }
1827
1828 /**
1829 * Check if the URL exist.
1830 * @param url (string) URL to check.
1831 * @return Returns TRUE if the URL exists; FALSE otherwise.
1832 * @public static
1833 */
1834 public static function url_exists($url) {
1835 $crs = curl_init();
1836 // encode query params in URL to get right response form the server
1837 $url = self::encodeUrlQuery($url);
1838 curl_setopt($crs, CURLOPT_URL, $url);
1839 curl_setopt($crs, CURLOPT_NOBODY, true);
1840 curl_setopt($crs, CURLOPT_FAILONERROR, true);
1841 if ((ini_get('open_basedir') == '') && (!ini_get('safe_mode'))) {
1842 curl_setopt($crs, CURLOPT_FOLLOWLOCATION, true);
1843 }
1844 curl_setopt($crs, CURLOPT_CONNECTTIMEOUT, 5);
1845 curl_setopt($crs, CURLOPT_TIMEOUT, 30);
1846 curl_setopt($crs, CURLOPT_SSL_VERIFYPEER, false);
1847 curl_setopt($crs, CURLOPT_SSL_VERIFYHOST, false);
1848 curl_setopt($crs, CURLOPT_USERAGENT, 'tc-lib-file');
1849 curl_setopt($crs, CURLOPT_MAXREDIRS, 5);
1850 if (defined('CURLOPT_PROTOCOLS')) {
1851 curl_setopt($crs, CURLOPT_PROTOCOLS, CURLPROTO_HTTPS | CURLPROTO_HTTP | CURLPROTO_FTP | CURLPROTO_FTPS);
1852 }
1853 curl_exec($crs);
1854 $code = curl_getinfo($crs, CURLINFO_HTTP_CODE);
1855 curl_close($crs);
1856 return ($code == 200);
1857 }
1858
1859 /**
1860 * Encode query params in URL
1861 *
1862 * @param string $url
1863 * @return string
1864 * @since 6.3.3 (2019-11-01)
1865 * @public static
1866 */
1867 public static function encodeUrlQuery($url) {
1868 $urlData = parse_url($url);
1869 if (isset($urlData['query']) && $urlData['query']) {
1870 $urlQueryData = array();
1871 parse_str(urldecode($urlData['query']), $urlQueryData);
1872 $updatedUrl = $urlData['scheme'] . '://' . $urlData['host'] . $urlData['path'] . '?' . http_build_query($urlQueryData);
1873 } else {
1874 $updatedUrl = $url;
1875 }
1876 return $updatedUrl;
1877 }
1878
1879 /**
1880 * Wrapper for file_exists.
1881 * Checks whether a file or directory exists.
1882 * Only allows some protocols and local files.
1883 * @param filename (string) Path to the file or directory.
1884 * @return Returns TRUE if the file or directory specified by filename exists; FALSE otherwise.
1885 * @public static
1886 */
1887 public static function file_exists($filename) {
1888 if (preg_match('|^https?://|', $filename) == 1) {
1889 return self::url_exists($filename);
1890 }
1891 if (strpos($filename, '://')) {
1892 return false; // only support http and https wrappers for security reasons
1893 }
1894 return @file_exists($filename);
1895 }
1896
1897 /**
1898 * Reads entire file into a string.
1899 * The file can be also an URL.
1900 * @param $file (string) Name of the file or URL to read.
1901 * @return The function returns the read data or FALSE on failure.
1902 * @author Nicola Asuni
1903 * @since 6.0.025
1904 * @public static
1905 */
1906 public static function fileGetContents($file) {
1907 $alt = array($file);
1908 //
1909 if ((strlen($file) > 1)
1910 && ($file[0] === '/')
1911 && ($file[1] !== '/')
1912 && !empty($_SERVER['DOCUMENT_ROOT'])
1913 && ($_SERVER['DOCUMENT_ROOT'] !== '/')
1914 ) {
1915 $findroot = strpos($file, $_SERVER['DOCUMENT_ROOT']);
1916 if (($findroot === false) || ($findroot > 1)) {
1917 $alt[] = htmlspecialchars_decode(urldecode($_SERVER['DOCUMENT_ROOT'].$file));
1918 }
1919 }
1920 //
1921 $protocol = 'http';
1922 if (!empty($_SERVER['HTTPS']) && (strtolower($_SERVER['HTTPS']) != 'off')) {
1923 $protocol .= 's';
1924 }
1925 //
1926 $url = $file;
1927 if (preg_match('%^//%', $url) && !empty($_SERVER['HTTP_HOST'])) {
1928 $url = $protocol.':'.str_replace(' ', '%20', $url);
1929 }
1930 $url = htmlspecialchars_decode($url);
1931 $alt[] = $url;
1932 //
1933 if (preg_match('%^(https?)://%', $url)
1934 && empty($_SERVER['HTTP_HOST'])
1935 && empty($_SERVER['DOCUMENT_ROOT'])
1936 ) {
1937 $urldata = parse_url($url);
1938 if (empty($urldata['query'])) {
1939 $host = $protocol.'://'.$_SERVER['HTTP_HOST'];
1940 if (strpos($url, $host) === 0) {
1941 // convert URL to full server path
1942 $tmp = str_replace($host, $_SERVER['DOCUMENT_ROOT'], $url);
1943 $alt[] = htmlspecialchars_decode(urldecode($tmp));
1944 }
1945 }
1946 }
1947 //
1948 if (isset($_SERVER['SCRIPT_URI'])
1949 && !preg_match('%^(https?|ftp)://%', $file)
1950 && !preg_match('%^//%', $file)
1951 ) {
1952 $urldata = @parse_url($_SERVER['SCRIPT_URI']);
1953 $alt[] = $urldata['scheme'].'://'.$urldata['host'].(($file[0] == '/') ? '' : '/').$file;
1954 }
1955 //
1956 $alt = array_unique($alt);
1957 foreach ($alt as $path) {
1958 if (!self::file_exists($path)) {
1959 continue;
1960 }
1961 $ret = @file_get_contents($path);
1962 if ( $ret != false ) {
1963 return $ret;
1964 }
1965 // try to use CURL for URLs
1966 if (!ini_get('allow_url_fopen')
1967 && function_exists('curl_init')
1968 && preg_match('%^(https?|ftp)://%', $path)
1969 ) {
1970 // try to get remote file data using cURL
1971 $crs = curl_init();
1972 curl_setopt($crs, CURLOPT_URL, $path);
1973 curl_setopt($crs, CURLOPT_BINARYTRANSFER, true);
1974 curl_setopt($crs, CURLOPT_FAILONERROR, true);
1975 curl_setopt($crs, CURLOPT_RETURNTRANSFER, true);
1976 if ((ini_get('open_basedir') == '') && (!ini_get('safe_mode'))) {
1977 curl_setopt($crs, CURLOPT_FOLLOWLOCATION, true);
1978 }
1979 curl_setopt($crs, CURLOPT_CONNECTTIMEOUT, 5);
1980 curl_setopt($crs, CURLOPT_TIMEOUT, 30);
1981 curl_setopt($crs, CURLOPT_SSL_VERIFYPEER, false);
1982 curl_setopt($crs, CURLOPT_SSL_VERIFYHOST, false);
1983 curl_setopt($crs, CURLOPT_USERAGENT, 'tc-lib-file');
1984 curl_setopt($crs, CURLOPT_MAXREDIRS, 5);
1985 if (defined('CURLOPT_PROTOCOLS')) {
1986 curl_setopt($crs, CURLOPT_PROTOCOLS, CURLPROTO_HTTPS | CURLPROTO_HTTP | CURLPROTO_FTP | CURLPROTO_FTPS);
1987 }
1988 $ret = curl_exec($crs);
1989 curl_close($crs);
1990 if ($ret !== false) {
1991 return $ret;
1992 }
1993 }
1994 }
1995 return false;
1996 }
1997
1998 /**
1999 * Get ULONG from string (Big Endian 32-bit unsigned integer).
2000 * @param $str (string) string from where to extract value
2001 * @param $offset (int) point from where to read the data
2002 * @return int 32 bit value
2003 * @author Nicola Asuni
2004 * @since 5.2.000 (2010-06-02)
2005 * @public static
2006 */
2007 public static function _getULONG($str, $offset) {
2008 $v = unpack('Ni', substr($str, $offset, 4));
2009 return $v['i'];
2010 }
2011
2012 /**
2013 * Get USHORT from string (Big Endian 16-bit unsigned integer).
2014 * @param $str (string) string from where to extract value
2015 * @param $offset (int) point from where to read the data
2016 * @return int 16 bit value
2017 * @author Nicola Asuni
2018 * @since 5.2.000 (2010-06-02)
2019 * @public static
2020 */
2021 public static function _getUSHORT($str, $offset) {
2022 $v = unpack('ni', substr($str, $offset, 2));
2023 return $v['i'];
2024 }
2025
2026 /**
2027 * Get SHORT from string (Big Endian 16-bit signed integer).
2028 * @param $str (string) String from where to extract value.
2029 * @param $offset (int) Point from where to read the data.
2030 * @return int 16 bit value
2031 * @author Nicola Asuni
2032 * @since 5.2.000 (2010-06-02)
2033 * @public static
2034 */
2035 public static function _getSHORT($str, $offset) {
2036 $v = unpack('si', substr($str, $offset, 2));
2037 return $v['i'];
2038 }
2039
2040 /**
2041 * Get FWORD from string (Big Endian 16-bit signed integer).
2042 * @param $str (string) String from where to extract value.
2043 * @param $offset (int) Point from where to read the data.
2044 * @return int 16 bit value
2045 * @author Nicola Asuni
2046 * @since 5.9.123 (2011-09-30)
2047 * @public static
2048 */
2049 public static function _getFWORD($str, $offset) {
2050 $v = self::_getUSHORT($str, $offset);
2051 if ($v > 0x7fff) {
2052 $v -= 0x10000;
2053 }
2054 return $v;
2055 }
2056
2057 /**
2058 * Get UFWORD from string (Big Endian 16-bit unsigned integer).
2059 * @param $str (string) string from where to extract value
2060 * @param $offset (int) point from where to read the data
2061 * @return int 16 bit value
2062 * @author Nicola Asuni
2063 * @since 5.9.123 (2011-09-30)
2064 * @public static
2065 */
2066 public static function _getUFWORD($str, $offset) {
2067 $v = self::_getUSHORT($str, $offset);
2068 return $v;
2069 }
2070
2071 /**
2072 * Get FIXED from string (32-bit signed fixed-point number (16.16).
2073 * @param $str (string) string from where to extract value
2074 * @param $offset (int) point from where to read the data
2075 * @return int 16 bit value
2076 * @author Nicola Asuni
2077 * @since 5.9.123 (2011-09-30)
2078 * @public static
2079 */
2080 public static function _getFIXED($str, $offset) {
2081 // mantissa
2082 $m = self::_getFWORD($str, $offset);
2083 // fraction
2084 $f = self::_getUSHORT($str, ($offset + 2));
2085 $v = floatval(''.$m.'.'.$f.'');
2086 return $v;
2087 }
2088
2089 /**
2090 * Get BYTE from string (8-bit unsigned integer).
2091 * @param $str (string) String from where to extract value.
2092 * @param $offset (int) Point from where to read the data.
2093 * @return int 8 bit value
2094 * @author Nicola Asuni
2095 * @since 5.2.000 (2010-06-02)
2096 * @public static
2097 */
2098 public static function _getBYTE($str, $offset) {
2099 $v = unpack('Ci', substr($str, $offset, 1));
2100 return $v['i'];
2101 }
2102 /**
2103 * Binary-safe and URL-safe file read.
2104 * 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.
2105 * @param $handle (resource)
2106 * @param $length (int)
2107 * @return Returns the read string or FALSE in case of error.
2108 * @author Nicola Asuni
2109 * @since 4.5.027 (2009-03-16)
2110 * @public static
2111 */
2112 public static function rfread($handle, $length) {
2113 $data = fread($handle, $length);
2114 if ($data === false) {
2115 return false;
2116 }
2117 $rest = ($length - strlen($data));
2118 if (($rest > 0) && !feof($handle)) {
2119 $data .= self::rfread($handle, $rest);
2120 }
2121 return $data;
2122 }
2123
2124 /**
2125 * Read a 4-byte (32 bit) integer from file.
2126 * @param $f (string) file name.
2127 * @return 4-byte integer
2128 * @public static
2129 */
2130 public static function _freadint($f) {
2131 $a = unpack('Ni', fread($f, 4));
2132 return $a['i'];
2133 }
2134
2135
2136 /**
2137 * Array of page formats
2138 * measures are calculated in this way: (inches * 72) or (millimeters * 72 / 25.4)
2139 * @public static
2140 */
2141 public static $page_formats = array(
2142 // ISO 216 A Series + 2 SIS 014711 extensions
2143 'A0' => array( 2383.937, 3370.394), // = ( 841 x 1189 ) mm = ( 33.11 x 46.81 ) in
2144 'A1' => array( 1683.780, 2383.937), // = ( 594 x 841 ) mm = ( 23.39 x 33.11 ) in
2145 'A2' => array( 1190.551, 1683.780), // = ( 420 x 594 ) mm = ( 16.54 x 23.39 ) in
2146 'A3' => array( 841.890, 1190.551), // = ( 297 x 420 ) mm = ( 11.69 x 16.54 ) in
2147 'A4' => array( 595.276, 841.890), // = ( 210 x 297 ) mm = ( 8.27 x 11.69 ) in
2148 'A5' => array( 419.528, 595.276), // = ( 148 x 210 ) mm = ( 5.83 x 8.27 ) in
2149 'A6' => array( 297.638, 419.528), // = ( 105 x 148 ) mm = ( 4.13 x 5.83 ) in
2150 'A7' => array( 209.764, 297.638), // = ( 74 x 105 ) mm = ( 2.91 x 4.13 ) in
2151 'A8' => array( 147.402, 209.764), // = ( 52 x 74 ) mm = ( 2.05 x 2.91 ) in
2152 'A9' => array( 104.882, 147.402), // = ( 37 x 52 ) mm = ( 1.46 x 2.05 ) in
2153 'A10' => array( 73.701, 104.882), // = ( 26 x 37 ) mm = ( 1.02 x 1.46 ) in
2154 'A11' => array( 51.024, 73.701), // = ( 18 x 26 ) mm = ( 0.71 x 1.02 ) in
2155 'A12' => array( 36.850, 51.024), // = ( 13 x 18 ) mm = ( 0.51 x 0.71 ) in
2156 // ISO 216 B Series + 2 SIS 014711 extensions
2157 'B0' => array( 2834.646, 4008.189), // = ( 1000 x 1414 ) mm = ( 39.37 x 55.67 ) in
2158 'B1' => array( 2004.094, 2834.646), // = ( 707 x 1000 ) mm = ( 27.83 x 39.37 ) in
2159 'B2' => array( 1417.323, 2004.094), // = ( 500 x 707 ) mm = ( 19.69 x 27.83 ) in
2160 'B3' => array( 1000.630, 1417.323), // = ( 353 x 500 ) mm = ( 13.90 x 19.69 ) in
2161 'B4' => array( 708.661, 1000.630), // = ( 250 x 353 ) mm = ( 9.84 x 13.90 ) in
2162 'B5' => array( 498.898, 708.661), // = ( 176 x 250 ) mm = ( 6.93 x 9.84 ) in
2163 'B6' => array( 354.331, 498.898), // = ( 125 x 176 ) mm = ( 4.92 x 6.93 ) in
2164 'B7' => array( 249.449, 354.331), // = ( 88 x 125 ) mm = ( 3.46 x 4.92 ) in
2165 'B8' => array( 175.748, 249.449), // = ( 62 x 88 ) mm = ( 2.44 x 3.46 ) in
2166 'B9' => array( 124.724, 175.748), // = ( 44 x 62 ) mm = ( 1.73 x 2.44 ) in
2167 'B10' => array( 87.874, 124.724), // = ( 31 x 44 ) mm = ( 1.22 x 1.73 ) in
2168 'B11' => array( 62.362, 87.874), // = ( 22 x 31 ) mm = ( 0.87 x 1.22 ) in
2169 'B12' => array( 42.520, 62.362), // = ( 15 x 22 ) mm = ( 0.59 x 0.87 ) in
2170 // ISO 216 C Series + 2 SIS 014711 extensions + 5 EXTENSION
2171 'C0' => array( 2599.370, 3676.535), // = ( 917 x 1297 ) mm = ( 36.10 x 51.06 ) in
2172 'C1' => array( 1836.850, 2599.370), // = ( 648 x 917 ) mm = ( 25.51 x 36.10 ) in
2173 'C2' => array( 1298.268, 1836.850), // = ( 458 x 648 ) mm = ( 18.03 x 25.51 ) in
2174 'C3' => array( 918.425, 1298.268), // = ( 324 x 458 ) mm = ( 12.76 x 18.03 ) in
2175 'C4' => array( 649.134, 918.425), // = ( 229 x 324 ) mm = ( 9.02 x 12.76 ) in
2176 'C5' => array( 459.213, 649.134), // = ( 162 x 229 ) mm = ( 6.38 x 9.02 ) in
2177 'C6' => array( 323.150, 459.213), // = ( 114 x 162 ) mm = ( 4.49 x 6.38 ) in
2178 'C7' => array( 229.606, 323.150), // = ( 81 x 114 ) mm = ( 3.19 x 4.49 ) in
2179 'C8' => array( 161.575, 229.606), // = ( 57 x 81 ) mm = ( 2.24 x 3.19 ) in
2180 'C9' => array( 113.386, 161.575), // = ( 40 x 57 ) mm = ( 1.57 x 2.24 ) in
2181 'C10' => array( 79.370, 113.386), // = ( 28 x 40 ) mm = ( 1.10 x 1.57 ) in
2182 'C11' => array( 56.693, 79.370), // = ( 20 x 28 ) mm = ( 0.79 x 1.10 ) in
2183 'C12' => array( 39.685, 56.693), // = ( 14 x 20 ) mm = ( 0.55 x 0.79 ) in
2184 'C76' => array( 229.606, 459.213), // = ( 81 x 162 ) mm = ( 3.19 x 6.38 ) in
2185 'DL' => array( 311.811, 623.622), // = ( 110 x 220 ) mm = ( 4.33 x 8.66 ) in
2186 'DLE' => array( 323.150, 637.795), // = ( 114 x 225 ) mm = ( 4.49 x 8.86 ) in
2187 'DLX' => array( 340.158, 666.142), // = ( 120 x 235 ) mm = ( 4.72 x 9.25 ) in
2188 'DLP' => array( 280.630, 595.276), // = ( 99 x 210 ) mm = ( 3.90 x 8.27 ) in (1/3 A4)
2189 // SIS 014711 E Series
2190 'E0' => array( 2491.654, 3517.795), // = ( 879 x 1241 ) mm = ( 34.61 x 48.86 ) in
2191 'E1' => array( 1757.480, 2491.654), // = ( 620 x 879 ) mm = ( 24.41 x 34.61 ) in
2192 'E2' => array( 1247.244, 1757.480), // = ( 440 x 620 ) mm = ( 17.32 x 24.41 ) in
2193 'E3' => array( 878.740, 1247.244), // = ( 310 x 440 ) mm = ( 12.20 x 17.32 ) in
2194 'E4' => array( 623.622, 878.740), // = ( 220 x 310 ) mm = ( 8.66 x 12.20 ) in
2195 'E5' => array( 439.370, 623.622), // = ( 155 x 220 ) mm = ( 6.10 x 8.66 ) in
2196 'E6' => array( 311.811, 439.370), // = ( 110 x 155 ) mm = ( 4.33 x 6.10 ) in
2197 'E7' => array( 221.102, 311.811), // = ( 78 x 110 ) mm = ( 3.07 x 4.33 ) in
2198 'E8' => array( 155.906, 221.102), // = ( 55 x 78 ) mm = ( 2.17 x 3.07 ) in
2199 'E9' => array( 110.551, 155.906), // = ( 39 x 55 ) mm = ( 1.54 x 2.17 ) in
2200 'E10' => array( 76.535, 110.551), // = ( 27 x 39 ) mm = ( 1.06 x 1.54 ) in
2201 'E11' => array( 53.858, 76.535), // = ( 19 x 27 ) mm = ( 0.75 x 1.06 ) in
2202 'E12' => array( 36.850, 53.858), // = ( 13 x 19 ) mm = ( 0.51 x 0.75 ) in
2203 // SIS 014711 G Series
2204 'G0' => array( 2715.591, 3838.110), // = ( 958 x 1354 ) mm = ( 37.72 x 53.31 ) in
2205 'G1' => array( 1919.055, 2715.591), // = ( 677 x 958 ) mm = ( 26.65 x 37.72 ) in
2206 'G2' => array( 1357.795, 1919.055), // = ( 479 x 677 ) mm = ( 18.86 x 26.65 ) in
2207 'G3' => array( 958.110, 1357.795), // = ( 338 x 479 ) mm = ( 13.31 x 18.86 ) in
2208 'G4' => array( 677.480, 958.110), // = ( 239 x 338 ) mm = ( 9.41 x 13.31 ) in
2209 'G5' => array( 479.055, 677.480), // = ( 169 x 239 ) mm = ( 6.65 x 9.41 ) in
2210 'G6' => array( 337.323, 479.055), // = ( 119 x 169 ) mm = ( 4.69 x 6.65 ) in
2211 'G7' => array( 238.110, 337.323), // = ( 84 x 119 ) mm = ( 3.31 x 4.69 ) in
2212 'G8' => array( 167.244, 238.110), // = ( 59 x 84 ) mm = ( 2.32 x 3.31 ) in
2213 'G9' => array( 119.055, 167.244), // = ( 42 x 59 ) mm = ( 1.65 x 2.32 ) in
2214 'G10' => array( 82.205, 119.055), // = ( 29 x 42 ) mm = ( 1.14 x 1.65 ) in
2215 'G11' => array( 59.528, 82.205), // = ( 21 x 29 ) mm = ( 0.83 x 1.14 ) in
2216 'G12' => array( 39.685, 59.528), // = ( 14 x 21 ) mm = ( 0.55 x 0.83 ) in
2217 // ISO Press
2218 'RA0' => array( 2437.795, 3458.268), // = ( 860 x 1220 ) mm = ( 33.86 x 48.03 ) in
2219 'RA1' => array( 1729.134, 2437.795), // = ( 610 x 860 ) mm = ( 24.02 x 33.86 ) in
2220 'RA2' => array( 1218.898, 1729.134), // = ( 430 x 610 ) mm = ( 16.93 x 24.02 ) in
2221 'RA3' => array( 864.567, 1218.898), // = ( 305 x 430 ) mm = ( 12.01 x 16.93 ) in
2222 'RA4' => array( 609.449, 864.567), // = ( 215 x 305 ) mm = ( 8.46 x 12.01 ) in
2223 'SRA0' => array( 2551.181, 3628.346), // = ( 900 x 1280 ) mm = ( 35.43 x 50.39 ) in
2224 'SRA1' => array( 1814.173, 2551.181), // = ( 640 x 900 ) mm = ( 25.20 x 35.43 ) in
2225 'SRA2' => array( 1275.591, 1814.173), // = ( 450 x 640 ) mm = ( 17.72 x 25.20 ) in
2226 'SRA3' => array( 907.087, 1275.591), // = ( 320 x 450 ) mm = ( 12.60 x 17.72 ) in
2227 'SRA4' => array( 637.795, 907.087), // = ( 225 x 320 ) mm = ( 8.86 x 12.60 ) in
2228 // German DIN 476
2229 '4A0' => array( 4767.874, 6740.787), // = ( 1682 x 2378 ) mm = ( 66.22 x 93.62 ) in
2230 '2A0' => array( 3370.394, 4767.874), // = ( 1189 x 1682 ) mm = ( 46.81 x 66.22 ) in
2231 // Variations on the ISO Standard
2232 'A2_EXTRA' => array( 1261.417, 1754.646), // = ( 445 x 619 ) mm = ( 17.52 x 24.37 ) in
2233 'A3+' => array( 932.598, 1369.134), // = ( 329 x 483 ) mm = ( 12.95 x 19.02 ) in
2234 'A3_EXTRA' => array( 912.756, 1261.417), // = ( 322 x 445 ) mm = ( 12.68 x 17.52 ) in
2235 'A3_SUPER' => array( 864.567, 1440.000), // = ( 305 x 508 ) mm = ( 12.01 x 20.00 ) in
2236 'SUPER_A3' => array( 864.567, 1380.472), // = ( 305 x 487 ) mm = ( 12.01 x 19.17 ) in
2237 'A4_EXTRA' => array( 666.142, 912.756), // = ( 235 x 322 ) mm = ( 9.25 x 12.68 ) in
2238 'A4_SUPER' => array( 649.134, 912.756), // = ( 229 x 322 ) mm = ( 9.02 x 12.68 ) in
2239 'SUPER_A4' => array( 643.465, 1009.134), // = ( 227 x 356 ) mm = ( 8.94 x 14.02 ) in
2240 'A4_LONG' => array( 595.276, 986.457), // = ( 210 x 348 ) mm = ( 8.27 x 13.70 ) in
2241 'F4' => array( 595.276, 935.433), // = ( 210 x 330 ) mm = ( 8.27 x 12.99 ) in
2242 'SO_B5_EXTRA' => array( 572.598, 782.362), // = ( 202 x 276 ) mm = ( 7.95 x 10.87 ) in
2243 'A5_EXTRA' => array( 490.394, 666.142), // = ( 173 x 235 ) mm = ( 6.81 x 9.25 ) in
2244 // ANSI Series
2245 'ANSI_E' => array( 2448.000, 3168.000), // = ( 864 x 1118 ) mm = ( 34.00 x 44.00 ) in
2246 'ANSI_D' => array( 1584.000, 2448.000), // = ( 559 x 864 ) mm = ( 22.00 x 34.00 ) in
2247 'ANSI_C' => array( 1224.000, 1584.000), // = ( 432 x 559 ) mm = ( 17.00 x 22.00 ) in
2248 'ANSI_B' => array( 792.000, 1224.000), // = ( 279 x 432 ) mm = ( 11.00 x 17.00 ) in
2249 'ANSI_A' => array( 612.000, 792.000), // = ( 216 x 279 ) mm = ( 8.50 x 11.00 ) in
2250 // Traditional 'Loose' North American Paper Sizes
2251 'USLEDGER' => array( 1224.000, 792.000), // = ( 432 x 279 ) mm = ( 17.00 x 11.00 ) in
2252 'LEDGER' => array( 1224.000, 792.000), // = ( 432 x 279 ) mm = ( 17.00 x 11.00 ) in
2253 'ORGANIZERK' => array( 792.000, 1224.000), // = ( 279 x 432 ) mm = ( 11.00 x 17.00 ) in
2254 'BIBLE' => array( 792.000, 1224.000), // = ( 279 x 432 ) mm = ( 11.00 x 17.00 ) in
2255 'USTABLOID' => array( 792.000, 1224.000), // = ( 279 x 432 ) mm = ( 11.00 x 17.00 ) in
2256 'TABLOID' => array( 792.000, 1224.000), // = ( 279 x 432 ) mm = ( 11.00 x 17.00 ) in
2257 'ORGANIZERM' => array( 612.000, 792.000), // = ( 216 x 279 ) mm = ( 8.50 x 11.00 ) in
2258 'USLETTER' => array( 612.000, 792.000), // = ( 216 x 279 ) mm = ( 8.50 x 11.00 ) in
2259 'LETTER' => array( 612.000, 792.000), // = ( 216 x 279 ) mm = ( 8.50 x 11.00 ) in
2260 'USLEGAL' => array( 612.000, 1008.000), // = ( 216 x 356 ) mm = ( 8.50 x 14.00 ) in
2261 'LEGAL' => array( 612.000, 1008.000), // = ( 216 x 356 ) mm = ( 8.50 x 14.00 ) in
2262 'GOVERNMENTLETTER' => array( 576.000, 756.000), // = ( 203 x 267 ) mm = ( 8.00 x 10.50 ) in
2263 'GLETTER' => array( 576.000, 756.000), // = ( 203 x 267 ) mm = ( 8.00 x 10.50 ) in
2264 'JUNIORLEGAL' => array( 576.000, 360.000), // = ( 203 x 127 ) mm = ( 8.00 x 5.00 ) in
2265 'JLEGAL' => array( 576.000, 360.000), // = ( 203 x 127 ) mm = ( 8.00 x 5.00 ) in
2266 // Other North American Paper Sizes
2267 'QUADDEMY' => array( 2520.000, 3240.000), // = ( 889 x 1143 ) mm = ( 35.00 x 45.00 ) in
2268 'SUPER_B' => array( 936.000, 1368.000), // = ( 330 x 483 ) mm = ( 13.00 x 19.00 ) in
2269 'QUARTO' => array( 648.000, 792.000), // = ( 229 x 279 ) mm = ( 9.00 x 11.00 ) in
2270 'GOVERNMENTLEGAL' => array( 612.000, 936.000), // = ( 216 x 330 ) mm = ( 8.50 x 13.00 ) in
2271 'FOLIO' => array( 612.000, 936.000), // = ( 216 x 330 ) mm = ( 8.50 x 13.00 ) in
2272 'MONARCH' => array( 522.000, 756.000), // = ( 184 x 267 ) mm = ( 7.25 x 10.50 ) in
2273 'EXECUTIVE' => array( 522.000, 756.000), // = ( 184 x 267 ) mm = ( 7.25 x 10.50 ) in
2274 'ORGANIZERL' => array( 396.000, 612.000), // = ( 140 x 216 ) mm = ( 5.50 x 8.50 ) in
2275 'STATEMENT' => array( 396.000, 612.000), // = ( 140 x 216 ) mm = ( 5.50 x 8.50 ) in
2276 'MEMO' => array( 396.000, 612.000), // = ( 140 x 216 ) mm = ( 5.50 x 8.50 ) in
2277 'FOOLSCAP' => array( 595.440, 936.000), // = ( 210 x 330 ) mm = ( 8.27 x 13.00 ) in
2278 'COMPACT' => array( 306.000, 486.000), // = ( 108 x 171 ) mm = ( 4.25 x 6.75 ) in
2279 'ORGANIZERJ' => array( 198.000, 360.000), // = ( 70 x 127 ) mm = ( 2.75 x 5.00 ) in
2280 // Canadian standard CAN 2-9.60M
2281 'P1' => array( 1587.402, 2437.795), // = ( 560 x 860 ) mm = ( 22.05 x 33.86 ) in
2282 'P2' => array( 1218.898, 1587.402), // = ( 430 x 560 ) mm = ( 16.93 x 22.05 ) in
2283 'P3' => array( 793.701, 1218.898), // = ( 280 x 430 ) mm = ( 11.02 x 16.93 ) in
2284 'P4' => array( 609.449, 793.701), // = ( 215 x 280 ) mm = ( 8.46 x 11.02 ) in
2285 'P5' => array( 396.850, 609.449), // = ( 140 x 215 ) mm = ( 5.51 x 8.46 ) in
2286 'P6' => array( 303.307, 396.850), // = ( 107 x 140 ) mm = ( 4.21 x 5.51 ) in
2287 // North American Architectural Sizes
2288 'ARCH_E' => array( 2592.000, 3456.000), // = ( 914 x 1219 ) mm = ( 36.00 x 48.00 ) in
2289 'ARCH_E1' => array( 2160.000, 3024.000), // = ( 762 x 1067 ) mm = ( 30.00 x 42.00 ) in
2290 'ARCH_D' => array( 1728.000, 2592.000), // = ( 610 x 914 ) mm = ( 24.00 x 36.00 ) in
2291 'BROADSHEET' => array( 1296.000, 1728.000), // = ( 457 x 610 ) mm = ( 18.00 x 24.00 ) in
2292 'ARCH_C' => array( 1296.000, 1728.000), // = ( 457 x 610 ) mm = ( 18.00 x 24.00 ) in
2293 'ARCH_B' => array( 864.000, 1296.000), // = ( 305 x 457 ) mm = ( 12.00 x 18.00 ) in
2294 'ARCH_A' => array( 648.000, 864.000), // = ( 229 x 305 ) mm = ( 9.00 x 12.00 ) in
2295 // -- North American Envelope Sizes
2296 // - Announcement Envelopes
2297 'ANNENV_A2' => array( 314.640, 414.000), // = ( 111 x 146 ) mm = ( 4.37 x 5.75 ) in
2298 'ANNENV_A6' => array( 342.000, 468.000), // = ( 121 x 165 ) mm = ( 4.75 x 6.50 ) in
2299 'ANNENV_A7' => array( 378.000, 522.000), // = ( 133 x 184 ) mm = ( 5.25 x 7.25 ) in
2300 'ANNENV_A8' => array( 396.000, 584.640), // = ( 140 x 206 ) mm = ( 5.50 x 8.12 ) in
2301 'ANNENV_A10' => array( 450.000, 692.640), // = ( 159 x 244 ) mm = ( 6.25 x 9.62 ) in
2302 'ANNENV_SLIM' => array( 278.640, 638.640), // = ( 98 x 225 ) mm = ( 3.87 x 8.87 ) in
2303 // - Commercial Envelopes
2304 'COMMENV_N6_1/4' => array( 252.000, 432.000), // = ( 89 x 152 ) mm = ( 3.50 x 6.00 ) in
2305 'COMMENV_N6_3/4' => array( 260.640, 468.000), // = ( 92 x 165 ) mm = ( 3.62 x 6.50 ) in
2306 'COMMENV_N8' => array( 278.640, 540.000), // = ( 98 x 191 ) mm = ( 3.87 x 7.50 ) in
2307 'COMMENV_N9' => array( 278.640, 638.640), // = ( 98 x 225 ) mm = ( 3.87 x 8.87 ) in
2308 'COMMENV_N10' => array( 296.640, 684.000), // = ( 105 x 241 ) mm = ( 4.12 x 9.50 ) in
2309 'COMMENV_N11' => array( 324.000, 746.640), // = ( 114 x 263 ) mm = ( 4.50 x 10.37 ) in
2310 'COMMENV_N12' => array( 342.000, 792.000), // = ( 121 x 279 ) mm = ( 4.75 x 11.00 ) in
2311 'COMMENV_N14' => array( 360.000, 828.000), // = ( 127 x 292 ) mm = ( 5.00 x 11.50 ) in
2312 // - Catalogue Envelopes
2313 'CATENV_N1' => array( 432.000, 648.000), // = ( 152 x 229 ) mm = ( 6.00 x 9.00 ) in
2314 'CATENV_N1_3/4' => array( 468.000, 684.000), // = ( 165 x 241 ) mm = ( 6.50 x 9.50 ) in
2315 'CATENV_N2' => array( 468.000, 720.000), // = ( 165 x 254 ) mm = ( 6.50 x 10.00 ) in
2316 'CATENV_N3' => array( 504.000, 720.000), // = ( 178 x 254 ) mm = ( 7.00 x 10.00 ) in
2317 'CATENV_N6' => array( 540.000, 756.000), // = ( 191 x 267 ) mm = ( 7.50 x 10.50 ) in
2318 'CATENV_N7' => array( 576.000, 792.000), // = ( 203 x 279 ) mm = ( 8.00 x 11.00 ) in
2319 'CATENV_N8' => array( 594.000, 810.000), // = ( 210 x 286 ) mm = ( 8.25 x 11.25 ) in
2320 'CATENV_N9_1/2' => array( 612.000, 756.000), // = ( 216 x 267 ) mm = ( 8.50 x 10.50 ) in
2321 'CATENV_N9_3/4' => array( 630.000, 810.000), // = ( 222 x 286 ) mm = ( 8.75 x 11.25 ) in
2322 'CATENV_N10_1/2' => array( 648.000, 864.000), // = ( 229 x 305 ) mm = ( 9.00 x 12.00 ) in
2323 'CATENV_N12_1/2' => array( 684.000, 900.000), // = ( 241 x 318 ) mm = ( 9.50 x 12.50 ) in
2324 'CATENV_N13_1/2' => array( 720.000, 936.000), // = ( 254 x 330 ) mm = ( 10.00 x 13.00 ) in
2325 'CATENV_N14_1/4' => array( 810.000, 882.000), // = ( 286 x 311 ) mm = ( 11.25 x 12.25 ) in
2326 'CATENV_N14_1/2' => array( 828.000, 1044.000), // = ( 292 x 368 ) mm = ( 11.50 x 14.50 ) in
2327 // Japanese (JIS P 0138-61) Standard B-Series
2328 'JIS_B0' => array( 2919.685, 4127.244), // = ( 1030 x 1456 ) mm = ( 40.55 x 57.32 ) in
2329 'JIS_B1' => array( 2063.622, 2919.685), // = ( 728 x 1030 ) mm = ( 28.66 x 40.55 ) in
2330 'JIS_B2' => array( 1459.843, 2063.622), // = ( 515 x 728 ) mm = ( 20.28 x 28.66 ) in
2331 'JIS_B3' => array( 1031.811, 1459.843), // = ( 364 x 515 ) mm = ( 14.33 x 20.28 ) in
2332 'JIS_B4' => array( 728.504, 1031.811), // = ( 257 x 364 ) mm = ( 10.12 x 14.33 ) in
2333 'JIS_B5' => array( 515.906, 728.504), // = ( 182 x 257 ) mm = ( 7.17 x 10.12 ) in
2334 'JIS_B6' => array( 362.835, 515.906), // = ( 128 x 182 ) mm = ( 5.04 x 7.17 ) in
2335 'JIS_B7' => array( 257.953, 362.835), // = ( 91 x 128 ) mm = ( 3.58 x 5.04 ) in
2336 'JIS_B8' => array( 181.417, 257.953), // = ( 64 x 91 ) mm = ( 2.52 x 3.58 ) in
2337 'JIS_B9' => array( 127.559, 181.417), // = ( 45 x 64 ) mm = ( 1.77 x 2.52 ) in
2338 'JIS_B10' => array( 90.709, 127.559), // = ( 32 x 45 ) mm = ( 1.26 x 1.77 ) in
2339 'JIS_B11' => array( 62.362, 90.709), // = ( 22 x 32 ) mm = ( 0.87 x 1.26 ) in
2340 'JIS_B12' => array( 45.354, 62.362), // = ( 16 x 22 ) mm = ( 0.63 x 0.87 ) in
2341 // PA Series
2342 'PA0' => array( 2381.102, 3174.803), // = ( 840 x 1120 ) mm = ( 33.07 x 44.09 ) in
2343 'PA1' => array( 1587.402, 2381.102), // = ( 560 x 840 ) mm = ( 22.05 x 33.07 ) in
2344 'PA2' => array( 1190.551, 1587.402), // = ( 420 x 560 ) mm = ( 16.54 x 22.05 ) in
2345 'PA3' => array( 793.701, 1190.551), // = ( 280 x 420 ) mm = ( 11.02 x 16.54 ) in
2346 'PA4' => array( 595.276, 793.701), // = ( 210 x 280 ) mm = ( 8.27 x 11.02 ) in
2347 'PA5' => array( 396.850, 595.276), // = ( 140 x 210 ) mm = ( 5.51 x 8.27 ) in
2348 'PA6' => array( 297.638, 396.850), // = ( 105 x 140 ) mm = ( 4.13 x 5.51 ) in
2349 'PA7' => array( 198.425, 297.638), // = ( 70 x 105 ) mm = ( 2.76 x 4.13 ) in
2350 'PA8' => array( 147.402, 198.425), // = ( 52 x 70 ) mm = ( 2.05 x 2.76 ) in
2351 'PA9' => array( 99.213, 147.402), // = ( 35 x 52 ) mm = ( 1.38 x 2.05 ) in
2352 'PA10' => array( 73.701, 99.213), // = ( 26 x 35 ) mm = ( 1.02 x 1.38 ) in
2353 // Standard Photographic Print Sizes
2354 'PASSPORT_PHOTO' => array( 99.213, 127.559), // = ( 35 x 45 ) mm = ( 1.38 x 1.77 ) in
2355 'E' => array( 233.858, 340.157), // = ( 82 x 120 ) mm = ( 3.25 x 4.72 ) in
2356 'L' => array( 252.283, 360.000), // = ( 89 x 127 ) mm = ( 3.50 x 5.00 ) in
2357 '3R' => array( 252.283, 360.000), // = ( 89 x 127 ) mm = ( 3.50 x 5.00 ) in
2358 'KG' => array( 289.134, 430.866), // = ( 102 x 152 ) mm = ( 4.02 x 5.98 ) in
2359 '4R' => array( 289.134, 430.866), // = ( 102 x 152 ) mm = ( 4.02 x 5.98 ) in
2360 '4D' => array( 340.157, 430.866), // = ( 120 x 152 ) mm = ( 4.72 x 5.98 ) in
2361 '2L' => array( 360.000, 504.567), // = ( 127 x 178 ) mm = ( 5.00 x 7.01 ) in
2362 '5R' => array( 360.000, 504.567), // = ( 127 x 178 ) mm = ( 5.00 x 7.01 ) in
2363 '8P' => array( 430.866, 575.433), // = ( 152 x 203 ) mm = ( 5.98 x 7.99 ) in
2364 '6R' => array( 430.866, 575.433), // = ( 152 x 203 ) mm = ( 5.98 x 7.99 ) in
2365 '6P' => array( 575.433, 720.000), // = ( 203 x 254 ) mm = ( 7.99 x 10.00 ) in
2366 '8R' => array( 575.433, 720.000), // = ( 203 x 254 ) mm = ( 7.99 x 10.00 ) in
2367 '6PW' => array( 575.433, 864.567), // = ( 203 x 305 ) mm = ( 7.99 x 12.01 ) in
2368 'S8R' => array( 575.433, 864.567), // = ( 203 x 305 ) mm = ( 7.99 x 12.01 ) in
2369 '4P' => array( 720.000, 864.567), // = ( 254 x 305 ) mm = ( 10.00 x 12.01 ) in
2370 '10R' => array( 720.000, 864.567), // = ( 254 x 305 ) mm = ( 10.00 x 12.01 ) in
2371 '4PW' => array( 720.000, 1080.000), // = ( 254 x 381 ) mm = ( 10.00 x 15.00 ) in
2372 'S10R' => array( 720.000, 1080.000), // = ( 254 x 381 ) mm = ( 10.00 x 15.00 ) in
2373 '11R' => array( 790.866, 1009.134), // = ( 279 x 356 ) mm = ( 10.98 x 14.02 ) in
2374 'S11R' => array( 790.866, 1224.567), // = ( 279 x 432 ) mm = ( 10.98 x 17.01 ) in
2375 '12R' => array( 864.567, 1080.000), // = ( 305 x 381 ) mm = ( 12.01 x 15.00 ) in
2376 'S12R' => array( 864.567, 1292.598), // = ( 305 x 456 ) mm = ( 12.01 x 17.95 ) in
2377 // Common Newspaper Sizes
2378 'NEWSPAPER_BROADSHEET' => array( 2125.984, 1700.787), // = ( 750 x 600 ) mm = ( 29.53 x 23.62 ) in
2379 'NEWSPAPER_BERLINER' => array( 1332.283, 892.913), // = ( 470 x 315 ) mm = ( 18.50 x 12.40 ) in
2380 'NEWSPAPER_TABLOID' => array( 1218.898, 793.701), // = ( 430 x 280 ) mm = ( 16.93 x 11.02 ) in
2381 'NEWSPAPER_COMPACT' => array( 1218.898, 793.701), // = ( 430 x 280 ) mm = ( 16.93 x 11.02 ) in
2382 // Business Cards
2383 'CREDIT_CARD' => array( 153.014, 242.646), // = ( 54 x 86 ) mm = ( 2.13 x 3.37 ) in
2384 'BUSINESS_CARD' => array( 153.014, 242.646), // = ( 54 x 86 ) mm = ( 2.13 x 3.37 ) in
2385 'BUSINESS_CARD_ISO7810' => array( 153.014, 242.646), // = ( 54 x 86 ) mm = ( 2.13 x 3.37 ) in
2386 'BUSINESS_CARD_ISO216' => array( 147.402, 209.764), // = ( 52 x 74 ) mm = ( 2.05 x 2.91 ) in
2387 'BUSINESS_CARD_IT' => array( 155.906, 240.945), // = ( 55 x 85 ) mm = ( 2.17 x 3.35 ) in
2388 'BUSINESS_CARD_UK' => array( 155.906, 240.945), // = ( 55 x 85 ) mm = ( 2.17 x 3.35 ) in
2389 'BUSINESS_CARD_FR' => array( 155.906, 240.945), // = ( 55 x 85 ) mm = ( 2.17 x 3.35 ) in
2390 'BUSINESS_CARD_DE' => array( 155.906, 240.945), // = ( 55 x 85 ) mm = ( 2.17 x 3.35 ) in
2391 'BUSINESS_CARD_ES' => array( 155.906, 240.945), // = ( 55 x 85 ) mm = ( 2.17 x 3.35 ) in
2392 'BUSINESS_CARD_CA' => array( 144.567, 252.283), // = ( 51 x 89 ) mm = ( 2.01 x 3.50 ) in
2393 'BUSINESS_CARD_US' => array( 144.567, 252.283), // = ( 51 x 89 ) mm = ( 2.01 x 3.50 ) in
2394 'BUSINESS_CARD_JP' => array( 155.906, 257.953), // = ( 55 x 91 ) mm = ( 2.17 x 3.58 ) in
2395 'BUSINESS_CARD_HK' => array( 153.071, 255.118), // = ( 54 x 90 ) mm = ( 2.13 x 3.54 ) in
2396 'BUSINESS_CARD_AU' => array( 155.906, 255.118), // = ( 55 x 90 ) mm = ( 2.17 x 3.54 ) in
2397 'BUSINESS_CARD_DK' => array( 155.906, 255.118), // = ( 55 x 90 ) mm = ( 2.17 x 3.54 ) in
2398 'BUSINESS_CARD_SE' => array( 155.906, 255.118), // = ( 55 x 90 ) mm = ( 2.17 x 3.54 ) in
2399 'BUSINESS_CARD_RU' => array( 141.732, 255.118), // = ( 50 x 90 ) mm = ( 1.97 x 3.54 ) in
2400 'BUSINESS_CARD_CZ' => array( 141.732, 255.118), // = ( 50 x 90 ) mm = ( 1.97 x 3.54 ) in
2401 'BUSINESS_CARD_FI' => array( 141.732, 255.118), // = ( 50 x 90 ) mm = ( 1.97 x 3.54 ) in
2402 'BUSINESS_CARD_HU' => array( 141.732, 255.118), // = ( 50 x 90 ) mm = ( 1.97 x 3.54 ) in
2403 'BUSINESS_CARD_IL' => array( 141.732, 255.118), // = ( 50 x 90 ) mm = ( 1.97 x 3.54 ) in
2404 // Billboards
2405 '4SHEET' => array( 2880.000, 4320.000), // = ( 1016 x 1524 ) mm = ( 40.00 x 60.00 ) in
2406 '6SHEET' => array( 3401.575, 5102.362), // = ( 1200 x 1800 ) mm = ( 47.24 x 70.87 ) in
2407 '12SHEET' => array( 8640.000, 4320.000), // = ( 3048 x 1524 ) mm = (120.00 x 60.00 ) in
2408 '16SHEET' => array( 5760.000, 8640.000), // = ( 2032 x 3048 ) mm = ( 80.00 x 120.00) in
2409 '32SHEET' => array(11520.000, 8640.000), // = ( 4064 x 3048 ) mm = (160.00 x 120.00) in
2410 '48SHEET' => array(17280.000, 8640.000), // = ( 6096 x 3048 ) mm = (240.00 x 120.00) in
2411 '64SHEET' => array(23040.000, 8640.000), // = ( 8128 x 3048 ) mm = (320.00 x 120.00) in
2412 '96SHEET' => array(34560.000, 8640.000), // = (12192 x 3048 ) mm = (480.00 x 120.00) in
2413 // -- Old European Sizes
2414 // - Old Imperial English Sizes
2415 'EN_EMPEROR' => array( 3456.000, 5184.000), // = ( 1219 x 1829 ) mm = ( 48.00 x 72.00 ) in
2416 'EN_ANTIQUARIAN' => array( 2232.000, 3816.000), // = ( 787 x 1346 ) mm = ( 31.00 x 53.00 ) in
2417 'EN_GRAND_EAGLE' => array( 2070.000, 3024.000), // = ( 730 x 1067 ) mm = ( 28.75 x 42.00 ) in
2418 'EN_DOUBLE_ELEPHANT' => array( 1926.000, 2880.000), // = ( 679 x 1016 ) mm = ( 26.75 x 40.00 ) in
2419 'EN_ATLAS' => array( 1872.000, 2448.000), // = ( 660 x 864 ) mm = ( 26.00 x 34.00 ) in
2420 'EN_COLOMBIER' => array( 1692.000, 2484.000), // = ( 597 x 876 ) mm = ( 23.50 x 34.50 ) in
2421 'EN_ELEPHANT' => array( 1656.000, 2016.000), // = ( 584 x 711 ) mm = ( 23.00 x 28.00 ) in
2422 'EN_DOUBLE_DEMY' => array( 1620.000, 2556.000), // = ( 572 x 902 ) mm = ( 22.50 x 35.50 ) in
2423 'EN_IMPERIAL' => array( 1584.000, 2160.000), // = ( 559 x 762 ) mm = ( 22.00 x 30.00 ) in
2424 'EN_PRINCESS' => array( 1548.000, 2016.000), // = ( 546 x 711 ) mm = ( 21.50 x 28.00 ) in
2425 'EN_CARTRIDGE' => array( 1512.000, 1872.000), // = ( 533 x 660 ) mm = ( 21.00 x 26.00 ) in
2426 'EN_DOUBLE_LARGE_POST' => array( 1512.000, 2376.000), // = ( 533 x 838 ) mm = ( 21.00 x 33.00 ) in
2427 'EN_ROYAL' => array( 1440.000, 1800.000), // = ( 508 x 635 ) mm = ( 20.00 x 25.00 ) in
2428 'EN_SHEET' => array( 1404.000, 1692.000), // = ( 495 x 597 ) mm = ( 19.50 x 23.50 ) in
2429 'EN_HALF_POST' => array( 1404.000, 1692.000), // = ( 495 x 597 ) mm = ( 19.50 x 23.50 ) in
2430 'EN_SUPER_ROYAL' => array( 1368.000, 1944.000), // = ( 483 x 686 ) mm = ( 19.00 x 27.00 ) in
2431 'EN_DOUBLE_POST' => array( 1368.000, 2196.000), // = ( 483 x 775 ) mm = ( 19.00 x 30.50 ) in
2432 'EN_MEDIUM' => array( 1260.000, 1656.000), // = ( 445 x 584 ) mm = ( 17.50 x 23.00 ) in
2433 'EN_DEMY' => array( 1260.000, 1620.000), // = ( 445 x 572 ) mm = ( 17.50 x 22.50 ) in
2434 'EN_LARGE_POST' => array( 1188.000, 1512.000), // = ( 419 x 533 ) mm = ( 16.50 x 21.00 ) in
2435 'EN_COPY_DRAUGHT' => array( 1152.000, 1440.000), // = ( 406 x 508 ) mm = ( 16.00 x 20.00 ) in
2436 'EN_POST' => array( 1116.000, 1386.000), // = ( 394 x 489 ) mm = ( 15.50 x 19.25 ) in
2437 'EN_CROWN' => array( 1080.000, 1440.000), // = ( 381 x 508 ) mm = ( 15.00 x 20.00 ) in
2438 'EN_PINCHED_POST' => array( 1062.000, 1332.000), // = ( 375 x 470 ) mm = ( 14.75 x 18.50 ) in
2439 'EN_BRIEF' => array( 972.000, 1152.000), // = ( 343 x 406 ) mm = ( 13.50 x 16.00 ) in
2440 'EN_FOOLSCAP' => array( 972.000, 1224.000), // = ( 343 x 432 ) mm = ( 13.50 x 17.00 ) in
2441 'EN_SMALL_FOOLSCAP' => array( 954.000, 1188.000), // = ( 337 x 419 ) mm = ( 13.25 x 16.50 ) in
2442 'EN_POTT' => array( 900.000, 1080.000), // = ( 318 x 381 ) mm = ( 12.50 x 15.00 ) in
2443 // - Old Imperial Belgian Sizes
2444 'BE_GRAND_AIGLE' => array( 1984.252, 2948.031), // = ( 700 x 1040 ) mm = ( 27.56 x 40.94 ) in
2445 'BE_COLOMBIER' => array( 1757.480, 2409.449), // = ( 620 x 850 ) mm = ( 24.41 x 33.46 ) in
2446 'BE_DOUBLE_CARRE' => array( 1757.480, 2607.874), // = ( 620 x 920 ) mm = ( 24.41 x 36.22 ) in
2447 'BE_ELEPHANT' => array( 1746.142, 2182.677), // = ( 616 x 770 ) mm = ( 24.25 x 30.31 ) in
2448 'BE_PETIT_AIGLE' => array( 1700.787, 2381.102), // = ( 600 x 840 ) mm = ( 23.62 x 33.07 ) in
2449 'BE_GRAND_JESUS' => array( 1559.055, 2069.291), // = ( 550 x 730 ) mm = ( 21.65 x 28.74 ) in
2450 'BE_JESUS' => array( 1530.709, 2069.291), // = ( 540 x 730 ) mm = ( 21.26 x 28.74 ) in
2451 'BE_RAISIN' => array( 1417.323, 1842.520), // = ( 500 x 650 ) mm = ( 19.69 x 25.59 ) in
2452 'BE_GRAND_MEDIAN' => array( 1303.937, 1714.961), // = ( 460 x 605 ) mm = ( 18.11 x 23.82 ) in
2453 'BE_DOUBLE_POSTE' => array( 1233.071, 1601.575), // = ( 435 x 565 ) mm = ( 17.13 x 22.24 ) in
2454 'BE_COQUILLE' => array( 1218.898, 1587.402), // = ( 430 x 560 ) mm = ( 16.93 x 22.05 ) in
2455 'BE_PETIT_MEDIAN' => array( 1176.378, 1502.362), // = ( 415 x 530 ) mm = ( 16.34 x 20.87 ) in
2456 'BE_RUCHE' => array( 1020.472, 1303.937), // = ( 360 x 460 ) mm = ( 14.17 x 18.11 ) in
2457 'BE_PROPATRIA' => array( 977.953, 1218.898), // = ( 345 x 430 ) mm = ( 13.58 x 16.93 ) in
2458 'BE_LYS' => array( 898.583, 1125.354), // = ( 317 x 397 ) mm = ( 12.48 x 15.63 ) in
2459 'BE_POT' => array( 870.236, 1088.504), // = ( 307 x 384 ) mm = ( 12.09 x 15.12 ) in
2460 'BE_ROSETTE' => array( 765.354, 983.622), // = ( 270 x 347 ) mm = ( 10.63 x 13.66 ) in
2461 // - Old Imperial French Sizes
2462 'FR_UNIVERS' => array( 2834.646, 3685.039), // = ( 1000 x 1300 ) mm = ( 39.37 x 51.18 ) in
2463 'FR_DOUBLE_COLOMBIER' => array( 2551.181, 3571.654), // = ( 900 x 1260 ) mm = ( 35.43 x 49.61 ) in
2464 'FR_GRANDE_MONDE' => array( 2551.181, 3571.654), // = ( 900 x 1260 ) mm = ( 35.43 x 49.61 ) in
2465 'FR_DOUBLE_SOLEIL' => array( 2267.717, 3401.575), // = ( 800 x 1200 ) mm = ( 31.50 x 47.24 ) in
2466 'FR_DOUBLE_JESUS' => array( 2154.331, 3174.803), // = ( 760 x 1120 ) mm = ( 29.92 x 44.09 ) in
2467 'FR_GRAND_AIGLE' => array( 2125.984, 3004.724), // = ( 750 x 1060 ) mm = ( 29.53 x 41.73 ) in
2468 'FR_PETIT_AIGLE' => array( 1984.252, 2664.567), // = ( 700 x 940 ) mm = ( 27.56 x 37.01 ) in
2469 'FR_DOUBLE_RAISIN' => array( 1842.520, 2834.646), // = ( 650 x 1000 ) mm = ( 25.59 x 39.37 ) in
2470 'FR_JOURNAL' => array( 1842.520, 2664.567), // = ( 650 x 940 ) mm = ( 25.59 x 37.01 ) in
2471 'FR_COLOMBIER_AFFICHE' => array( 1785.827, 2551.181), // = ( 630 x 900 ) mm = ( 24.80 x 35.43 ) in
2472 'FR_DOUBLE_CAVALIER' => array( 1757.480, 2607.874), // = ( 620 x 920 ) mm = ( 24.41 x 36.22 ) in
2473 'FR_CLOCHE' => array( 1700.787, 2267.717), // = ( 600 x 800 ) mm = ( 23.62 x 31.50 ) in
2474 'FR_SOLEIL' => array( 1700.787, 2267.717), // = ( 600 x 800 ) mm = ( 23.62 x 31.50 ) in
2475 'FR_DOUBLE_CARRE' => array( 1587.402, 2551.181), // = ( 560 x 900 ) mm = ( 22.05 x 35.43 ) in
2476 'FR_DOUBLE_COQUILLE' => array( 1587.402, 2494.488), // = ( 560 x 880 ) mm = ( 22.05 x 34.65 ) in
2477 'FR_JESUS' => array( 1587.402, 2154.331), // = ( 560 x 760 ) mm = ( 22.05 x 29.92 ) in
2478 'FR_RAISIN' => array( 1417.323, 1842.520), // = ( 500 x 650 ) mm = ( 19.69 x 25.59 ) in
2479 'FR_CAVALIER' => array( 1303.937, 1757.480), // = ( 460 x 620 ) mm = ( 18.11 x 24.41 ) in
2480 'FR_DOUBLE_COURONNE' => array( 1303.937, 2040.945), // = ( 460 x 720 ) mm = ( 18.11 x 28.35 ) in
2481 'FR_CARRE' => array( 1275.591, 1587.402), // = ( 450 x 560 ) mm = ( 17.72 x 22.05 ) in
2482 'FR_COQUILLE' => array( 1247.244, 1587.402), // = ( 440 x 560 ) mm = ( 17.32 x 22.05 ) in
2483 'FR_DOUBLE_TELLIERE' => array( 1247.244, 1927.559), // = ( 440 x 680 ) mm = ( 17.32 x 26.77 ) in
2484 'FR_DOUBLE_CLOCHE' => array( 1133.858, 1700.787), // = ( 400 x 600 ) mm = ( 15.75 x 23.62 ) in
2485 'FR_DOUBLE_POT' => array( 1133.858, 1757.480), // = ( 400 x 620 ) mm = ( 15.75 x 24.41 ) in
2486 'FR_ECU' => array( 1133.858, 1474.016), // = ( 400 x 520 ) mm = ( 15.75 x 20.47 ) in
2487 'FR_COURONNE' => array( 1020.472, 1303.937), // = ( 360 x 460 ) mm = ( 14.17 x 18.11 ) in
2488 'FR_TELLIERE' => array( 963.780, 1247.244), // = ( 340 x 440 ) mm = ( 13.39 x 17.32 ) in
2489 'FR_POT' => array( 878.740, 1133.858), // = ( 310 x 400 ) mm = ( 12.20 x 15.75 ) in
2490 );
2491
2492
2493 /**
2494 * Get page dimensions from format name.
2495 * @param $format (mixed) The format name @see self::$page_format<ul>
2496 * @return array containing page width and height in points
2497 * @since 5.0.010 (2010-05-17)
2498 * @public static
2499 */
2500 public static function getPageSizeFromFormat($format) {
2501 if (isset(self::$page_formats[$format])) {
2502 return self::$page_formats[$format];
2503 }
2504 return self::$page_formats['A4'];
2505 }
2506
2507 /**
2508 * Set page boundaries.
2509 * @param $page (int) page number
2510 * @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>
2511 * @param $llx (float) lower-left x coordinate in user units.
2512 * @param $lly (float) lower-left y coordinate in user units.
2513 * @param $urx (float) upper-right x coordinate in user units.
2514 * @param $ury (float) upper-right y coordinate in user units.
2515 * @param $points (boolean) If true uses user units as unit of measure, otherwise uses PDF points.
2516 * @param $k (float) Scale factor (number of points in user unit).
2517 * @param $pagedim (array) Array of page dimensions.
2518 * @return pagedim array of page dimensions.
2519 * @since 5.0.010 (2010-05-17)
2520 * @public static
2521 */
2522 public static function setPageBoxes($page, $type, $llx, $lly, $urx, $ury, $points, $k, $pagedim=array()) {
2523 if (!isset($pagedim[$page])) {
2524 // initialize array
2525 $pagedim[$page] = array();
2526 }
2527 if (!in_array($type, self::$pageboxes)) {
2528 return;
2529 }
2530 if ($points) {
2531 $k = 1;
2532 }
2533 $pagedim[$page][$type]['llx'] = ($llx * $k);
2534 $pagedim[$page][$type]['lly'] = ($lly * $k);
2535 $pagedim[$page][$type]['urx'] = ($urx * $k);
2536 $pagedim[$page][$type]['ury'] = ($ury * $k);
2537 return $pagedim;
2538 }
2539
2540 /**
2541 * Swap X and Y coordinates of page boxes (change page boxes orientation).
2542 * @param $page (int) page number
2543 * @param $pagedim (array) Array of page dimensions.
2544 * @return pagedim array of page dimensions.
2545 * @since 5.0.010 (2010-05-17)
2546 * @public static
2547 */
2548 public static function swapPageBoxCoordinates($page, $pagedim) {
2549 foreach (self::$pageboxes as $type) {
2550 // swap X and Y coordinates
2551 if (isset($pagedim[$page][$type])) {
2552 $tmp = $pagedim[$page][$type]['llx'];
2553 $pagedim[$page][$type]['llx'] = $pagedim[$page][$type]['lly'];
2554 $pagedim[$page][$type]['lly'] = $tmp;
2555 $tmp = $pagedim[$page][$type]['urx'];
2556 $pagedim[$page][$type]['urx'] = $pagedim[$page][$type]['ury'];
2557 $pagedim[$page][$type]['ury'] = $tmp;
2558 }
2559 }
2560 return $pagedim;
2561 }
2562
2563 /**
2564 * Get the canonical page layout mode.
2565 * @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>
2566 * @return (string) Canonical page layout name.
2567 * @public static
2568 */
2569 public static function getPageLayoutMode($layout='SinglePage') {
2570 switch ($layout) {
2571 case 'default':
2572 case 'single':
2573 case 'SinglePage': {
2574 $layout_mode = 'SinglePage';
2575 break;
2576 }
2577 case 'continuous':
2578 case 'OneColumn': {
2579 $layout_mode = 'OneColumn';
2580 break;
2581 }
2582 case 'two':
2583 case 'TwoColumnLeft': {
2584 $layout_mode = 'TwoColumnLeft';
2585 break;
2586 }
2587 case 'TwoColumnRight': {
2588 $layout_mode = 'TwoColumnRight';
2589 break;
2590 }
2591 case 'TwoPageLeft': {
2592 $layout_mode = 'TwoPageLeft';
2593 break;
2594 }
2595 case 'TwoPageRight': {
2596 $layout_mode = 'TwoPageRight';
2597 break;
2598 }
2599 default: {
2600 $layout_mode = 'SinglePage';
2601 }
2602 }
2603 return $layout_mode;
2604 }
2605
2606 /**
2607 * Get the canonical page layout mode.
2608 * @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>
2609 * @return (string) Canonical page mode name.
2610 * @public static
2611 */
2612 public static function getPageMode($mode='UseNone') {
2613 switch ($mode) {
2614 case 'UseNone': {
2615 $page_mode = 'UseNone';
2616 break;
2617 }
2618 case 'UseOutlines': {
2619 $page_mode = 'UseOutlines';
2620 break;
2621 }
2622 case 'UseThumbs': {
2623 $page_mode = 'UseThumbs';
2624 break;
2625 }
2626 case 'FullScreen': {
2627 $page_mode = 'FullScreen';
2628 break;
2629 }
2630 case 'UseOC': {
2631 $page_mode = 'UseOC';
2632 break;
2633 }
2634 case '': {
2635 $page_mode = 'UseAttachments';
2636 break;
2637 }
2638 default: {
2639 $page_mode = 'UseNone';
2640 }
2641 }
2642 return $page_mode;
2643 }
2644
2645
2646} // END OF TCPDF_STATIC CLASS
2647
2648//============================================================+
2649// END OF FILE
2650//============================================================+
Note: See TracBrowser for help on using the repository browser.