PageRenderTime 93ms CodeModel.GetById 23ms RepoModel.GetById 0ms app.codeStats 1ms

/lib/class.pdf.php

https://github.com/dwagner2301/dompdf
PHP | 4607 lines | 2833 code | 736 blank | 1038 comment | 554 complexity | ed7e198371529c7aa5db09e0d9b921e0 MD5 | raw file
Possible License(s): LGPL-2.1 
    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * A PHP class to provide the basic functionality to create a pdf document without
    4. 

  4.  * any requirement for additional modules.
    5. 

  5.  *
    6. 

  6.  * Extended by Orion Richardson to support Unicode / UTF-8 characters using
    7. 

  7.  * TCPDF and others as a guide.
    8. 

  8.  *
    9. 

  9.  * @author  Wayne Munro <pdf@ros.co.nz>
    10. 

  10.  * @author  Orion Richardson <orionr@yahoo.com>
    11. 

  11.  * @author  Helmut Tischer <htischer@weihenstephan.org>
    12. 

  12.  * @author  Ryan H. Masten <ryan.masten@gmail.com>
    13. 

  13.  * @author  Brian Sweeney <eclecticgeek@gmail.com>
    14. 

  14.  * @author  Fabien MĂŠnager <fabien.menager@gmail.com>
    15. 

  15.  * @license Public Domain http://creativecommons.org/licenses/publicdomain/
    16. 

  16.  * @package Cpdf
    17. 

  17.  */
    18. 

  18. class Cpdf {
    19. 

  19. 

  20.   /**
    21. 

  21.    * @var integer The current number of pdf objects in the document
    22. 

  22.    */
    23. 

  23.   public $numObj = 0;
    24. 

  24. 

  25.   /**
    26. 

  26.    * @var array This array contains all of the pdf objects, ready for final assembly
    27. 

  27.    */
    28. 

  28.   public $objects = array();
    29. 

  29. 

  30.   /**
    31. 

  31.    * @var integer The objectId (number within the objects array) of the document catalog
    32. 

  32.    */
    33. 

  33.   public $catalogId;
    34. 

  34. 

  35.   /**
    36. 

  36.    * @var array Array carrying information about the fonts that the system currently knows about
    37. 

  37.    * Used to ensure that a font is not loaded twice, among other things
    38. 

  38.    */
    39. 

  39.   public $fonts = array();
    40. 

  40. 

  41.   /**
    42. 

  42.    * @var string The default font metrics file to use if no other font has been loaded.
    43. 

  43.    * The path to the directory containing the font metrics should be included
    44. 

  44.    */
    45. 

  45.   public $defaultFont = './fonts/Helvetica.afm';
    46. 

  46. 

  47.   /**
    48. 

  48.    * @string A record of the current font
    49. 

  49.    */
    50. 

  50.   public $currentFont = '';
    51. 

  51. 

  52.   /**
    53. 

  53.    * @var string The current base font
    54. 

  54.    */
    55. 

  55.   public $currentBaseFont = '';
    56. 

  56. 

  57.   /**
    58. 

  58.    * @var integer The number of the current font within the font array
    59. 

  59.    */
    60. 

  60.   public $currentFontNum = 0;
    61. 

  61. 

  62.   /**
    63. 

  63.    * @var integer
    64. 

  64.    */
    65. 

  65.   public $currentNode;
    66. 

  66. 

  67.   /**
    68. 

  68.    * @var integer Object number of the current page
    69. 

  69.    */
    70. 

  70.   public $currentPage;
    71. 

  71. 

  72.   /**
    73. 

  73.    * @var integer Object number of the currently active contents block
    74. 

  74.    */
    75. 

  75.   public $currentContents;
    76. 

  76. 

  77.   /**
    78. 

  78.    * @var integer Number of fonts within the system
    79. 

  79.    */
    80. 

  80.   public $numFonts = 0;
    81. 

  81. 

  82.   /**
    83. 

  83.    * @var integer Number of graphic state resources used
    84. 

  84.    */
    85. 

  85.   private $numStates = 0;
    86. 

  86. 

  87.   /**
    88. 

  88.    * @var array Current color for fill operations, defaults to inactive value, 
    89. 

  89.    * all three components should be between 0 and 1 inclusive when active
    90. 

  90.    */
    91. 

  91.   public $currentColor = null;
    92. 

  92. 

  93.   /**
    94. 

  94.    * @var array Current color for stroke operations (lines etc.)
    95. 

  95.    */
    96. 

  96.   public $currentStrokeColor = null;
    97. 

  97. 

  98.   /**
    99. 

  99.    * @var string Current style that lines are drawn in
    100. 

  100.    */
    101. 

  101.   public $currentLineStyle = '';
    102. 

  102. 

  103.   /**
    104. 

  104.    * @var array Current line transparency (partial graphics state)
    105. 

  105.    */
    106. 

  106.   public $currentLineTransparency = array("mode" => "Normal", "opacity" => 1.0);
    107. 

  107. 

  108.   /**
    109. 

  109.    * array Current fill transparency (partial graphics state)
    110. 

  110.    */
    111. 

  111.   public $currentFillTransparency = array("mode" => "Normal", "opacity" => 1.0);
    112. 

  112. 

  113.   /**
    114. 

  114.    * @var array An array which is used to save the state of the document, mainly the colors and styles
    115. 

  115.    * it is used to temporarily change to another state, the change back to what it was before
    116. 

  116.    */
    117. 

  117.   public $stateStack = array();
    118. 

  118. 

  119.   /**
    120. 

  120.    * @var integer Number of elements within the state stack
    121. 

  121.    */
    122. 

  122.   public $nStateStack = 0;
    123. 

  123. 

  124.   /**
    125. 

  125.    * @var integer Number of page objects within the document
    126. 

  126.    */
    127. 

  127.   public $numPages = 0;
    128. 

  128. 

  129.   /**
    130. 

  130.    * @var array Object Id storage stack
    131. 

  131.    */
    132. 

  132.   public $stack = array();
    133. 

  133. 

  134.   /**
    135. 

  135.    * @var integer Number of elements within the object Id storage stack
    136. 

  136.    */
    137. 

  137.   public $nStack = 0;
    138. 

  138. 

  139.   /**
    140. 

  140.    * an array which contains information about the objects which are not firmly attached to pages
    141. 

  141.    * these have been added with the addObject function
    142. 

  142.    */
    143. 

  143.   public $looseObjects = array();
    144. 

  144. 

  145.   /**
    146. 

  146.    * array contains infomation about how the loose objects are to be added to the document
    147. 

  147.    */
    148. 

  148.   public $addLooseObjects = array();
    149. 

  149. 

  150.   /**
    151. 

  151.    * @var integer The objectId of the information object for the document
    152. 

  152.    * this contains authorship, title etc.
    153. 

  153.    */
    154. 

  154.   public $infoObject = 0;
    155. 

  155. 

  156.   /**
    157. 

  157.    * @var integer Number of images being tracked within the document
    158. 

  158.    */
    159. 

  159.   public $numImages = 0;
    160. 

  160. 

  161.   /**
    162. 

  162.    * @var array An array containing options about the document
    163. 

  163.    * it defaults to turning on the compression of the objects
    164. 

  164.    */
    165. 

  165.   public $options = array('compression' => true);
    166. 

  166. 

  167.   /**
    168. 

  168.    * @var integer The objectId of the first page of the document
    169. 

  169.    */
    170. 

  170.   public $firstPageId;
    171. 

  171. 

  172.   /**
    173. 

  173.    * @var float Used to track the last used value of the inter-word spacing, this is so that it is known
    174. 

  174.    * when the spacing is changed.
    175. 

  175.    */
    176. 

  176.   public $wordSpaceAdjust = 0;
    177. 

  177. 

  178.   /**
    179. 

  179.    * @var float Used to track the last used value of the inter-letter spacing, this is so that it is known
    180. 

  180.    * when the spacing is changed.
    181. 

  181.    */
    182. 

  182.   public $charSpaceAdjust = 0;
    183. 

  183. 

  184.   /**
    185. 

  185.    * @var integer The object Id of the procset object
    186. 

  186.    */
    187. 

  187.   public $procsetObjectId;
    188. 

  188. 

  189.   /**
    190. 

  190.    * @var array Store the information about the relationship between font families
    191. 

  191.    * this used so that the code knows which font is the bold version of another font, etc.
    192. 

  192.    * the value of this array is initialised in the constuctor function.
    193. 

  193.    */
    194. 

  194.   public $fontFamilies = array();
    195. 

  195. 

  196.   /**
    197. 

  197.    * @var string Folder for php serialized formats of font metrics files.
    198. 

  198.    * If empty string, use same folder as original metrics files.
    199. 

  199.    * This can be passed in from class creator.
    200. 

  200.    * If this folder does not exist or is not writable, Cpdf will be **much** slower.
    201. 

  201.    * Because of potential trouble with php safe mode, folder cannot be created at runtime.
    202. 

  202.    */
    203. 

  203.   public $fontcache = '';
    204. 

  204. 

  205.   /**
    206. 

  206.    * @var integer The version of the font metrics cache file.
    207. 

  207.    * This value must be manually incremented whenever the internal font data structure is modified.
    208. 

  208.    */
    209. 

  209.   public $fontcacheVersion = 6;
    210. 

  210. 

  211.   /**
    212. 

  212.    * @var string Temporary folder.
    213. 

  213.    * If empty string, will attempty system tmp folder.
    214. 

  214.    * This can be passed in from class creator.
    215. 

  215.    * Only used for conversion of gd images to jpeg images.
    216. 

  216.    */
    217. 

  217.   public $tmp = '';
    218. 

  218. 

  219.   /**
    220. 

  220.    * @var string Track if the current font is bolded or italicised
    221. 

  221.    */
    222. 

  222.   public $currentTextState = '';
    223. 

  223. 

  224.   /**
    225. 

  225.    * @var string Messages are stored here during processing, these can be selected afterwards to give some useful debug information
    226. 

  226.    */
    227. 

  227.   public $messages = '';
    228. 

  228. 

  229.   /**
    230. 

  230.    * @var string The ancryption array for the document encryption is stored here
    231. 

  231.    */
    232. 

  232.   public $arc4 = '';
    233. 

  233. 

  234.   /**
    235. 

  235.    * @var integer The object Id of the encryption information
    236. 

  236.    */
    237. 

  237.   public $arc4_objnum = 0;
    238. 

  238. 

  239.   /**
    240. 

  240.    * @var string The file identifier, used to uniquely identify a pdf document
    241. 

  241.    */
    242. 

  242.   public $fileIdentifier = '';
    243. 

  243. 

  244.   /**
    245. 

  245.    * @var boolean A flag to say if a document is to be encrypted or not
    246. 

  246.    */
    247. 

  247.   public $encrypted = false;
    248. 

  248. 

  249.   /**
    250. 

  250.    * @var string The encryption key for the encryption of all the document content (structure is not encrypted)
    251. 

  251.    */
    252. 

  252.   public $encryptionKey = '';
    253. 

  253. 

  254.   /**
    255. 

  255.    * @var array Array which forms a stack to keep track of nested callback functions
    256. 

  256.    */
    257. 

  257.   public $callback = array();
    258. 

  258. 

  259.   /**
    260. 

  260.    * @var integer The number of callback functions in the callback array
    261. 

  261.    */
    262. 

  262.   public $nCallback = 0;
    263. 

  263. 

  264.   /**
    265. 

  265.    * @var array Store label->id pairs for named destinations, these will be used to replace internal links
    266. 

  266.    * done this way so that destinations can be defined after the location that links to them
    267. 

  267.    */
    268. 

  268.   public $destinations = array();
    269. 

  269. 

  270.   /**
    271. 

  271.    * @var array Store the stack for the transaction commands, each item in here is a record of the values of all the
    272. 

  272.    * publiciables within the class, so that the user can rollback at will (from each 'start' command)
    273. 

  273.    * note that this includes the objects array, so these can be large.
    274. 

  274.    */
    275. 

  275.   public $checkpoint = '';
    276. 

  276. 

  277.   /**
    278. 

  278.    * @var array Table of Image origin filenames and image labels which were already added with o_image().
    279. 

  279.    * Allows to merge identical images
    280. 

  280.    */
    281. 

  281.   public $imagelist = array();
    282. 

  282. 

  283.   /**
    284. 

  284.    * @var boolean Whether the text passed in should be treated as Unicode or just local character set.
    285. 

  285.    */
    286. 

  286.   public $isUnicode = false;
    287. 

  287. 

  288.   /**
    289. 

  289.    * @var string the JavaScript code of the document
    290. 

  290.    */
    291. 

  291.   public $javascript = '';
    292. 

  292. 

  293.   /**
    294. 

  294.    * @var boolean whether the compression is possible
    295. 

  295.    */
    296. 

  296.   protected $compressionReady = false;
    297. 

  297. 

  298.   /**
    299. 

  299.    * @var array Current page size
    300. 

  300.    */
    301. 

  301.   protected $currentPageSize = array("width" => 0, "height" => 0);
    302. 

  302. 

  303.   /**
    304. 

  304.    * @var array All the chars that will be required in the font subsets
    305. 

  305.    */
    306. 

  306.   protected $stringSubsets = array();
    307. 

  307. 

  308.   /**
    309. 

  309.    * @var string The target internal encoding
    310. 

  310.    */
    311. 

  311.   static protected $targetEncoding = 'iso-8859-1';
    312. 

  312. 

  313.   /**
    314. 

  314.    * @var array The list of the core fonts
    315. 

  315.    */
    316. 

  316.   static protected $coreFonts = array(
    317. 

  317.     'courier', 'courier-bold', 'courier-oblique', 'courier-boldoblique',
    318. 

  318.     'helvetica', 'helvetica-bold', 'helvetica-oblique', 'helvetica-boldoblique',
    319. 

  319.     'times-roman', 'times-bold', 'times-italic', 'times-bolditalic',
    320. 

  320.     'symbol', 'zapfdingbats'
    321. 

  321.   );
    322. 

  322. 

  323.   /**
    324. 

  324.    * Class constructor
    325. 

  325.    * This will start a new document
    326. 

  326.    *
    327. 

  327.    * @param array   $pageSize  Array of 4 numbers, defining the bottom left and upper right corner of the page. first two are normally zero.
    328. 

  328.    * @param boolean $isUnicode Whether text will be treated as Unicode or not.
    329. 

  329.    * @param string  $fontcache The font cache folder
    330. 

  330.    * @param string  $tmp       The temporary folder
    331. 

  331.    */
    332. 

  332.   function __construct($pageSize = array(0, 0, 612, 792), $isUnicode = false, $fontcache = '', $tmp = '') {
    333. 

  333.     $this->isUnicode = $isUnicode;
    334. 

  334.     $this->fontcache = $fontcache;
    335. 

  335.     $this->tmp = $tmp;
    336. 

  336.     $this->newDocument($pageSize);
    337. 

  337. 

  338.     $this->compressionReady = function_exists('gzcompress');
    339. 

  339.     
    340. 

  340.     if ( in_array('Windows-1252', mb_list_encodings()) ) {
    341. 

  341.       self::$targetEncoding = 'Windows-1252';
    342. 

  342.     }
    343. 

  343. 

  344.     // also initialize the font families that are known about already
    345. 

  345.     $this->setFontFamily('init');
    346. 

  346.     //  $this->fileIdentifier = md5('xxxxxxxx'.time());
    347. 

  347.   }
    348. 

  348. 

  349.   /**
    350. 

  350.    * Document object methods (internal use only)
    351. 

  351.    *
    352. 

  352.    * There is about one object method for each type of object in the pdf document
    353. 

  353.    * Each function has the same call list ($id,$action,$options).
    354. 

  354.    * $id = the object ID of the object, or what it is to be if it is being created
    355. 

  355.    * $action = a string specifying the action to be performed, though ALL must support:
    356. 

  356.    *           'new' - create the object with the id $id
    357. 

  357.    *           'out' - produce the output for the pdf object
    358. 

  358.    * $options = optional, a string or array containing the various parameters for the object
    359. 

  359.    *
    360. 

  360.    * These, in conjunction with the output function are the ONLY way for output to be produced
    361. 

  361.    * within the pdf 'file'.
    362. 

  362.    */
    363. 

  363. 

  364.   /**
    365. 

  365.    * Destination object, used to specify the location for the user to jump to, presently on opening
    366. 

  366.    */
    367. 

  367.   protected function o_destination($id, $action, $options = '') {
    368. 

  368.     if ($action !== 'new') {
    369. 

  369.       $o = &$this->objects[$id];
    370. 

  370.     }
    371. 

  371. 

  372.     switch ($action) {
    373. 

  373.     case 'new':
    374. 

  374.       $this->objects[$id] = array('t' => 'destination', 'info' => array());
    375. 

  375.       $tmp = '';
    376. 

  376.       switch ($options['type']) {
    377. 

  377.         case 'XYZ':
    378. 

  378.         case 'FitR':
    379. 

  379.           $tmp = ' '.$options['p3'].$tmp;
    380. 

  380.         case 'FitH':
    381. 

  381.         case 'FitV':
    382. 

  382.         case 'FitBH':
    383. 

  383.         case 'FitBV':
    384. 

  384.           $tmp = ' '.$options['p1'].' '.$options['p2'].$tmp;
    385. 

  385.         case 'Fit':
    386. 

  386.         case 'FitB':
    387. 

  387.           $tmp = $options['type'].$tmp;
    388. 

  388.           $this->objects[$id]['info']['string'] = $tmp;
    389. 

  389.           $this->objects[$id]['info']['page'] = $options['page'];
    390. 

  390.       }
    391. 

  391.       break;
    392. 

  392. 

  393.     case 'out':
    394. 

  394.       $tmp = $o['info'];
    395. 

  395.       $res = "\n$id 0 obj\n".'['.$tmp['page'].' 0 R /'.$tmp['string']."]\nendobj";
    396. 

  396.       return $res;
    397. 

  397.     }
    398. 

  398.   }
    399. 

  399. 

  400.   /**
    401. 

  401.    * set the viewer preferences
    402. 

  402.    */
    403. 

  403.   protected function o_viewerPreferences($id, $action, $options = '') {
    404. 

  404.     if ($action !== 'new') {
    405. 

  405.       $o = & $this->objects[$id];
    406. 

  406.     }
    407. 

  407. 

  408.     switch ($action) {
    409. 

  409.     case 'new':
    410. 

  410.       $this->objects[$id] = array('t' => 'viewerPreferences', 'info' => array());
    411. 

  411.       break;
    412. 

  412. 

  413.     case 'add':
    414. 

  414.       foreach ($options as $k => $v) {
    415. 

  415.         switch ($k) {
    416. 

  416.           case 'HideToolbar':
    417. 

  417.           case 'HideMenubar':
    418. 

  418.           case 'HideWindowUI':
    419. 

  419.           case 'FitWindow':
    420. 

  420.           case 'CenterWindow':
    421. 

  421.           case 'NonFullScreenPageMode':
    422. 

  422.           case 'Direction':
    423. 

  423.             $o['info'][$k] = $v;
    424. 

  424.             break;
    425. 

  425.         }
    426. 

  426.       }
    427. 

  427.       break;
    428. 

  428. 

  429.     case 'out':
    430. 

  430.       $res = "\n$id 0 obj\n<< ";
    431. 

  431.       foreach ($o['info'] as $k => $v) {
    432. 

  432.         $res.= "\n/$k $v";
    433. 

  433.       }
    434. 

  434.       $res.= "\n>>\n";
    435. 

  435.       return $res;
    436. 

  436.     }
    437. 

  437.   }
    438. 

  438. 

  439.   /**
    440. 

  440.    * define the document catalog, the overall controller for the document
    441. 

  441.    */
    442. 

  442.   protected function o_catalog($id, $action, $options = '') {
    443. 

  443.     if ($action !== 'new') {
    444. 

  444.       $o = & $this->objects[$id];
    445. 

  445.     }
    446. 

  446. 

  447.     switch ($action) {
    448. 

  448.       case 'new':
    449. 

  449.         $this->objects[$id] = array('t' => 'catalog', 'info' => array());
    450. 

  450.         $this->catalogId = $id;
    451. 

  451.         break;
    452. 

  452. 

  453.       case 'outlines':
    454. 

  454.       case 'pages':
    455. 

  455.       case 'openHere':
    456. 

  456.       case 'javascript':
    457. 

  457.         $o['info'][$action] = $options;
    458. 

  458.         break;
    459. 

  459. 

  460.       case 'viewerPreferences':
    461. 

  461.         if (!isset($o['info']['viewerPreferences'])) {
    462. 

  462.           $this->numObj++;
    463. 

  463.           $this->o_viewerPreferences($this->numObj, 'new');
    464. 

  464.           $o['info']['viewerPreferences'] = $this->numObj;
    465. 

  465.         }
    466. 

  466. 

  467.         $vp = $o['info']['viewerPreferences'];
    468. 

  468.         $this->o_viewerPreferences($vp, 'add', $options);
    469. 

  469. 

  470.         break;
    471. 

  471. 

  472.       case 'out':
    473. 

  473.         $res = "\n$id 0 obj\n<< /Type /Catalog";
    474. 

  474. 

  475.         foreach ($o['info'] as $k => $v) {
    476. 

  476.           switch ($k) {
    477. 

  477.             case 'outlines':
    478. 

  478.               $res.= "\n/Outlines $v 0 R";
    479. 

  479.               break;
    480. 

  480. 

  481.             case 'pages':
    482. 

  482.               $res.= "\n/Pages $v 0 R";
    483. 

  483.               break;
    484. 

  484. 

  485.             case 'viewerPreferences':
    486. 

  486.               $res.= "\n/ViewerPreferences $v 0 R";
    487. 

  487.               break;
    488. 

  488. 

  489.             case 'openHere':
    490. 

  490.               $res.= "\n/OpenAction $v 0 R";
    491. 

  491.               break;
    492. 

  492. 

  493.             case 'javascript':
    494. 

  494.               $res.= "\n/Names <</JavaScript $v 0 R>>";
    495. 

  495.               break;
    496. 

  496.           }
    497. 

  497.         }
    498. 

  498. 

  499.         $res.= " >>\nendobj";
    500. 

  500.         return $res;
    501. 

  501.     }
    502. 

  502.   }
    503. 

  503. 

  504.   /**
    505. 

  505.    * object which is a parent to the pages in the document
    506. 

  506.    */
    507. 

  507.   protected function o_pages($id, $action, $options = '') {
    508. 

  508.     if ($action !== 'new') {
    509. 

  509.       $o = & $this->objects[$id];
    510. 

  510.     }
    511. 

  511. 

  512.     switch ($action) {
    513. 

  513.     case 'new':
    514. 

  514.       $this->objects[$id] = array('t' => 'pages', 'info' => array());
    515. 

  515.       $this->o_catalog($this->catalogId, 'pages', $id);
    516. 

  516.       break;
    517. 

  517. 

  518.     case 'page':
    519. 

  519.       if (!is_array($options)) {
    520. 

  520.         // then it will just be the id of the new page
    521. 

  521.         $o['info']['pages'][] = $options;
    522. 

  522.       }
    523. 

  523.       else {
    524. 

  524.         // then it should be an array having 'id','rid','pos', where rid=the page to which this one will be placed relative
    525. 

  525.         // and pos is either 'before' or 'after', saying where this page will fit.
    526. 

  526.         if (isset($options['id']) && isset($options['rid']) && isset($options['pos'])) {
    527. 

  527.           $i = array_search($options['rid'], $o['info']['pages']);
    528. 

  528.           if (isset($o['info']['pages'][$i]) && $o['info']['pages'][$i] == $options['rid']) {
    529. 

  529. 

  530.             // then there is a match
    531. 

  531.             // make a space
    532. 

  532.             switch ($options['pos']) {
    533. 

  533.               case 'before':
    534. 

  534.                 $k = $i;
    535. 

  535.                 break;
    536. 

  536. 

  537.               case 'after':
    538. 

  538.                 $k = $i+1;
    539. 

  539.                 break;
    540. 

  540. 

  541.               default:
    542. 

  542.                 $k = -1;
    543. 

  543.                 break;
    544. 

  544.             }
    545. 

  545. 

  546.             if ($k >= 0) {
    547. 

  547.               for ($j = count($o['info']['pages'])-1; $j >= $k; $j--) {
    548. 

  548.                 $o['info']['pages'][$j+1] = $o['info']['pages'][$j];
    549. 

  549.               }
    550. 

  550. 

  551.               $o['info']['pages'][$k] = $options['id'];
    552. 

  552.             }
    553. 

  553.           }
    554. 

  554.         }
    555. 

  555.       }
    556. 

  556.       break;
    557. 

  557. 

  558.     case 'procset':
    559. 

  559.       $o['info']['procset'] = $options;
    560. 

  560.       break;
    561. 

  561. 

  562.     case 'mediaBox':
    563. 

  563.       $o['info']['mediaBox'] = $options;
    564. 

  564.       // which should be an array of 4 numbers
    565. 

  565.       $this->currentPageSize = array('width' => $options[2], 'height' => $options[3]);
    566. 

  566.       break;
    567. 

  567. 

  568.     case 'font':
    569. 

  569.       $o['info']['fonts'][] = array('objNum' => $options['objNum'], 'fontNum' => $options['fontNum']);
    570. 

  570.       break;
    571. 

  571. 

  572.     case 'extGState':
    573. 

  573.       $o['info']['extGStates'][] = array('objNum' => $options['objNum'],  'stateNum' => $options['stateNum']);
    574. 

  574.       break;
    575. 

  575. 

  576.     case 'xObject':
    577. 

  577.       $o['info']['xObjects'][] = array('objNum' => $options['objNum'], 'label' => $options['label']);
    578. 

  578.       break;
    579. 

  579. 

  580.     case 'out':
    581. 

  581.       if (count($o['info']['pages'])) {
    582. 

  582.         $res = "\n$id 0 obj\n<< /Type /Pages\n/Kids [";
    583. 

  583.         foreach ($o['info']['pages'] as $v) {
    584. 

  584.           $res.= "$v 0 R\n";
    585. 

  585.         }
    586. 

  586. 

  587.         $res.= "]\n/Count ".count($this->objects[$id]['info']['pages']);
    588. 

  588. 

  589.         if ( (isset($o['info']['fonts']) && count($o['info']['fonts'])) ||
    590. 

  590.               isset($o['info']['procset']) ||
    591. 

  591.               (isset($o['info']['extGStates']) && count($o['info']['extGStates']))) {
    592. 

  592.           $res.= "\n/Resources <<";
    593. 

  593. 

  594.           if (isset($o['info']['procset'])) {
    595. 

  595.             $res.= "\n/ProcSet ".$o['info']['procset']." 0 R";
    596. 

  596.           }
    597. 

  597. 

  598.           if (isset($o['info']['fonts']) && count($o['info']['fonts'])) {
    599. 

  599.             $res.= "\n/Font << ";
    600. 

  600.             foreach ($o['info']['fonts'] as $finfo) {
    601. 

  601.               $res.= "\n/F".$finfo['fontNum']." ".$finfo['objNum']." 0 R";
    602. 

  602.             }
    603. 

  603.             $res.= "\n>>";
    604. 

  604.           }
    605. 

  605. 

  606.           if (isset($o['info']['xObjects']) && count($o['info']['xObjects'])) {
    607. 

  607.             $res.= "\n/XObject << ";
    608. 

  608.             foreach ($o['info']['xObjects'] as $finfo) {
    609. 

  609.               $res.= "\n/".$finfo['label']." ".$finfo['objNum']." 0 R";
    610. 

  610.             }
    611. 

  611.             $res.= "\n>>";
    612. 

  612.           }
    613. 

  613. 

  614.           if ( isset($o['info']['extGStates']) && count($o['info']['extGStates'])) {
    615. 

  615.             $res.= "\n/ExtGState << ";
    616. 

  616.             foreach ($o['info']['extGStates'] as $gstate) {
    617. 

  617.               $res.= "\n/GS" . $gstate['stateNum'] . " " . $gstate['objNum'] . " 0 R";
    618. 

  618.             }
    619. 

  619.             $res.= "\n>>";
    620. 

  620.           }
    621. 

  621. 

  622.           $res.= "\n>>";
    623. 

  623.           if (isset($o['info']['mediaBox'])) {
    624. 

  624.             $tmp = $o['info']['mediaBox'];
    625. 

  625.             $res.= "\n/MediaBox [".sprintf('%.3F %.3F %.3F %.3F', $tmp[0], $tmp[1], $tmp[2], $tmp[3]) .']';
    626. 

  626.           }
    627. 

  627.         }
    628. 

  628. 

  629.         $res.= "\n >>\nendobj";
    630. 

  630.       }
    631. 

  631.       else {
    632. 

  632.         $res = "\n$id 0 obj\n<< /Type /Pages\n/Count 0\n>>\nendobj";
    633. 

  633.       }
    634. 

  634. 

  635.       return $res;
    636. 

  636.     }
    637. 

  637.   }
    638. 

  638. 

  639.   /**
    640. 

  640.    * define the outlines in the doc, empty for now
    641. 

  641.    */
    642. 

  642.   protected function o_outlines($id, $action, $options = '') {
    643. 

  643.     if ($action !== 'new') {
    644. 

  644.       $o = &$this->objects[$id];
    645. 

  645.     }
    646. 

  646. 

  647.     switch ($action) {
    648. 

  648.       case 'new':
    649. 

  649.         $this->objects[$id] = array('t' => 'outlines', 'info' => array('outlines' => array()));
    650. 

  650.         $this->o_catalog($this->catalogId, 'outlines', $id);
    651. 

  651.         break;
    652. 

  652. 

  653.       case 'outline':
    654. 

  654.         $o['info']['outlines'][] = $options;
    655. 

  655.         break;
    656. 

  656. 

  657.       case 'out':
    658. 

  658.         if (count($o['info']['outlines'])) {
    659. 

  659.           $res = "\n$id 0 obj\n<< /Type /Outlines /Kids [";
    660. 

  660.           foreach ($o['info']['outlines'] as $v) {
    661. 

  661.             $res.= "$v 0 R ";
    662. 

  662.           }
    663. 

  663. 

  664.           $res.= "] /Count ".count($o['info']['outlines']) ." >>\nendobj";
    665. 

  665.         } else {
    666. 

  666.           $res = "\n$id 0 obj\n<< /Type /Outlines /Count 0 >>\nendobj";
    667. 

  667.         }
    668. 

  668. 

  669.         return $res;
    670. 

  670.     }
    671. 

  671.   }
    672. 

  672. 

  673.   /**
    674. 

  674.    * an object to hold the font description
    675. 

  675.    */
    676. 

  676.   protected function o_font($id, $action, $options = '') {
    677. 

  677.     if ($action !== 'new') {
    678. 

  678.       $o = &$this->objects[$id];
    679. 

  679.     }
    680. 

  680. 

  681.     switch ($action) {
    682. 

  682.     case 'new':
    683. 

  683.       $this->objects[$id] = array('t' => 'font', 'info' => array('name' => $options['name'], 'fontFileName' => $options['fontFileName'], 'SubType' => 'Type1'));
    684. 

  684.       $fontNum = $this->numFonts;
    685. 

  685.       $this->objects[$id]['info']['fontNum'] = $fontNum;
    686. 

  686. 

  687.       // deal with the encoding and the differences
    688. 

  688.       if (isset($options['differences'])) {
    689. 

  689.         // then we'll need an encoding dictionary
    690. 

  690.         $this->numObj++;
    691. 

  691.         $this->o_fontEncoding($this->numObj, 'new', $options);
    692. 

  692.         $this->objects[$id]['info']['encodingDictionary'] = $this->numObj;
    693. 

  693.       }
    694. 

  694.       else if (isset($options['encoding'])) {
    695. 

  695.         // we can specify encoding here
    696. 

  696.         switch ($options['encoding']) {
    697. 

  697.           case 'WinAnsiEncoding':
    698. 

  698.           case 'MacRomanEncoding':
    699. 

  699.           case 'MacExpertEncoding':
    700. 

  700.             $this->objects[$id]['info']['encoding'] = $options['encoding'];
    701. 

  701.             break;
    702. 

  702. 

  703.           case 'none':
    704. 

  704.             break;
    705. 

  705. 

  706.           default:
    707. 

  707.             $this->objects[$id]['info']['encoding'] = 'WinAnsiEncoding';
    708. 

  708.             break;
    709. 

  709.         }
    710. 

  710.       }
    711. 

  711.       else {
    712. 

  712.         $this->objects[$id]['info']['encoding'] = 'WinAnsiEncoding';
    713. 

  713.       }
    714. 

  714. 

  715.       if ($this->fonts[$options['fontFileName']]['isUnicode']) {
    716. 

  716.         // For Unicode fonts, we need to incorporate font data into
    717. 

  717.         // sub-sections that are linked from the primary font section.
    718. 

  718.         // Look at o_fontGIDtoCID and o_fontDescendentCID functions
    719. 

  719.         // for more informaiton.
    720. 

  720.         //
    721. 

  721.         // All of this code is adapted from the excellent changes made to
    722. 

  722.         // transform FPDF to TCPDF (http://tcpdf.sourceforge.net/)
    723. 

  723. 

  724.         $toUnicodeId = ++$this->numObj;
    725. 

  725.         $this->o_contents($toUnicodeId, 'new', 'raw');
    726. 

  726.         $this->objects[$id]['info']['toUnicode'] = $toUnicodeId;
    727. 

  727. 

  728.         $stream = <<<EOT
    729. 

  729. /CIDInit /ProcSet findresource begin
    730. 

  730. 12 dict begin
    731. 

  731. begincmap
    732. 

  732. /CIDSystemInfo
    733. 

  733. <</Registry (Adobe)
    734. 

  734. /Ordering (UCS)
    735. 

  735. /Supplement 0
    736. 

  736. >> def
    737. 

  737. /CMapName /Adobe-Identity-UCS def
    738. 

  738. /CMapType 2 def
    739. 

  739. 1 begincodespacerange
    740. 

  740. <0000> <FFFF>
    741. 

  741. endcodespacerange
    742. 

  742. 1 beginbfrange
    743. 

  743. <0000> <FFFF> <0000>
    744. 

  744. endbfrange
    745. 

  745. endcmap
    746. 

  746. CMapName currentdict /CMap defineresource pop
    747. 

  747. end
    748. 

  748. end
    749. 

  749. EOT;
    750. 

  750. 

  751.         $res = "<</Length " . mb_strlen($stream, '8bit') . " >>\n";
    752. 

  752.         $res .= "stream\n" . $stream . "endstream";
    753. 

  753. 

  754.         $this->objects[$toUnicodeId]['c'] = $res;
    755. 

  755. 

  756.         $cidFontId = ++$this->numObj;
    757. 

  757.         $this->o_fontDescendentCID($cidFontId, 'new', $options);
    758. 

  758.         $this->objects[$id]['info']['cidFont'] = $cidFontId;
    759. 

  759.       }
    760. 

  760. 

  761.       // also tell the pages node about the new font
    762. 

  762.       $this->o_pages($this->currentNode, 'font', array('fontNum' => $fontNum, 'objNum' => $id));
    763. 

  763.       break;
    764. 

  764. 

  765.     case 'add':
    766. 

  766.       foreach ($options as $k => $v) {
    767. 

  767.         switch ($k) {
    768. 

  768.           case 'BaseFont':
    769. 

  769.             $o['info']['name'] = $v;
    770. 

  770.             break;
    771. 

  771.           case 'FirstChar':
    772. 

  772.           case 'LastChar':
    773. 

  773.           case 'Widths':
    774. 

  774.           case 'FontDescriptor':
    775. 

  775.           case 'SubType':
    776. 

  776.             $this->addMessage('o_font '.$k." : ".$v);
    777. 

  777.             $o['info'][$k] = $v;
    778. 

  778.             break;
    779. 

  779.         }
    780. 

  780.       }
    781. 

  781. 

  782.       // pass values down to descendent font
    783. 

  783.       if (isset($o['info']['cidFont'])) {
    784. 

  784.         $this->o_fontDescendentCID($o['info']['cidFont'], 'add', $options);
    785. 

  785.       }
    786. 

  786.       break;
    787. 

  787. 

  788.     case 'out':
    789. 

  789.       if ($this->fonts[$this->objects[$id]['info']['fontFileName']]['isUnicode']) {
    790. 

  790.         // For Unicode fonts, we need to incorporate font data into
    791. 

  791.         // sub-sections that are linked from the primary font section.
    792. 

  792.         // Look at o_fontGIDtoCID and o_fontDescendentCID functions
    793. 

  793.         // for more informaiton.
    794. 

  794.         //
    795. 

  795.         // All of this code is adapted from the excellent changes made to
    796. 

  796.         // transform FPDF to TCPDF (http://tcpdf.sourceforge.net/)
    797. 

  797. 

  798.         $res = "\n$id 0 obj\n<</Type /Font\n/Subtype /Type0\n";
    799. 

  799.         $res.= "/BaseFont /".$o['info']['name']."\n";
    800. 

  800. 

  801.         // The horizontal identity mapping for 2-byte CIDs; may be used
    802. 

  802.         // with CIDFonts using any Registry, Ordering, and Supplement values.
    803. 

  803.         $res.= "/Encoding /Identity-H\n";
    804. 

  804.         $res.= "/DescendantFonts [".$o['info']['cidFont']." 0 R]\n";
    805. 

  805.         $res.= "/ToUnicode ".$o['info']['toUnicode']." 0 R\n";
    806. 

  806.         $res.= ">>\n";
    807. 

  807.         $res.= "endobj";
    808. 

  808.       } else {
    809. 

  809.         $res = "\n$id 0 obj\n<< /Type /Font\n/Subtype /".$o['info']['SubType']."\n";
    810. 

  810.         $res.= "/Name /F".$o['info']['fontNum']."\n";
    811. 

  811.         $res.= "/BaseFont /".$o['info']['name']."\n";
    812. 

  812. 

  813.         if (isset($o['info']['encodingDictionary'])) {
    814. 

  814.           // then place a reference to the dictionary
    815. 

  815.           $res.= "/Encoding ".$o['info']['encodingDictionary']." 0 R\n";
    816. 

  816.         } else if (isset($o['info']['encoding'])) {
    817. 

  817.           // use the specified encoding
    818. 

  818.           $res.= "/Encoding /".$o['info']['encoding']."\n";
    819. 

  819.         }
    820. 

  820. 

  821.         if (isset($o['info']['FirstChar'])) {
    822. 

  822.           $res.= "/FirstChar ".$o['info']['FirstChar']."\n";
    823. 

  823.         }
    824. 

  824. 

  825.         if (isset($o['info']['LastChar'])) {
    826. 

  826.           $res.= "/LastChar ".$o['info']['LastChar']."\n";
    827. 

  827.         }
    828. 

  828. 

  829.         if (isset($o['info']['Widths'])) {
    830. 

  830.           $res.= "/Widths ".$o['info']['Widths']." 0 R\n";
    831. 

  831.         }
    832. 

  832. 

  833.         if (isset($o['info']['FontDescriptor'])) {
    834. 

  834.           $res.= "/FontDescriptor ".$o['info']['FontDescriptor']." 0 R\n";
    835. 

  835.         }
    836. 

  836. 

  837.         $res.= ">>\n";
    838. 

  838.         $res.= "endobj";
    839. 

  839.       }
    840. 

  840. 

  841.       return $res;
    842. 

  842.     }
    843. 

  843.   }
    844. 

  844. 

  845.   /**
    846. 

  846.    * a font descriptor, needed for including additional fonts
    847. 

  847.    */
    848. 

  848.   protected function o_fontDescriptor($id, $action, $options = '') {
    849. 

  849.     if ($action !== 'new') {
    850. 

  850.       $o = & $this->objects[$id];
    851. 

  851.     }
    852. 

  852. 

  853.     switch ($action) {
    854. 

  854.       case 'new':
    855. 

  855.         $this->objects[$id] = array('t' => 'fontDescriptor', 'info' => $options);
    856. 

  856.         break;
    857. 

  857. 

  858.       case 'out':
    859. 

  859.         $res = "\n$id 0 obj\n<< /Type /FontDescriptor\n";
    860. 

  860.         foreach ($o['info'] as $label => $value) {
    861. 

  861.           switch ($label) {
    862. 

  862.           case 'Ascent':
    863. 

  863.           case 'CapHeight':
    864. 

  864.           case 'Descent':
    865. 

  865.           case 'Flags':
    866. 

  866.           case 'ItalicAngle':
    867. 

  867.           case 'StemV':
    868. 

  868.           case 'AvgWidth':
    869. 

  869.           case 'Leading':
    870. 

  870.           case 'MaxWidth':
    871. 

  871.           case 'MissingWidth':
    872. 

  872.           case 'StemH':
    873. 

  873.           case 'XHeight':
    874. 

  874.           case 'CharSet':
    875. 

  875.             if (mb_strlen($value, '8bit')) {
    876. 

  876.               $res.= "/$label $value\n";
    877. 

  877.             }
    878. 

  878. 

  879.             break;
    880. 

  880.           case 'FontFile':
    881. 

  881.           case 'FontFile2':
    882. 

  882.           case 'FontFile3':
    883. 

  883.             $res.= "/$label $value 0 R\n";
    884. 

  884.             break;
    885. 

  885. 

  886.           case 'FontBBox':
    887. 

  887.             $res.= "/$label [$value[0] $value[1] $value[2] $value[3]]\n";
    888. 

  888.             break;
    889. 

  889. 

  890.           case 'FontName':
    891. 

  891.             $res.= "/$label /$value\n";
    892. 

  892.             break;
    893. 

  893.           }
    894. 

  894.         }
    895. 

  895. 

  896.         $res.= ">>\nendobj";
    897. 

  897. 

  898.         return $res;
    899. 

  899.     }
    900. 

  900.   }
    901. 

  901. 

  902.   /**
    903. 

  903.    * the font encoding
    904. 

  904.    */
    905. 

  905.   protected function o_fontEncoding($id, $action, $options = '') {
    906. 

  906.     if ($action !== 'new') {
    907. 

  907.       $o = & $this->objects[$id];
    908. 

  908.     }
    909. 

  909. 

  910.     switch ($action) {
    911. 

  911.     case 'new':
    912. 

  912.       // the options array should contain 'differences' and maybe 'encoding'
    913. 

  913.       $this->objects[$id] = array('t' => 'fontEncoding', 'info' => $options);
    914. 

  914.       break;
    915. 

  915. 

  916.     case 'out':
    917. 

  917.       $res = "\n$id 0 obj\n<< /Type /Encoding\n";
    918. 

  918.       if (!isset($o['info']['encoding'])) {
    919. 

  919.         $o['info']['encoding'] = 'WinAnsiEncoding';
    920. 

  920.       }
    921. 

  921. 

  922.       if ($o['info']['encoding'] !== 'none') {
    923. 

  923.         $res.= "/BaseEncoding /".$o['info']['encoding']."\n";
    924. 

  924.       }
    925. 

  925. 

  926.       $res.= "/Differences \n[";
    927. 

  927. 

  928.       $onum = -100;
    929. 

  929. 

  930.       foreach ($o['info']['differences'] as $num => $label) {
    931. 

  931.         if ($num != $onum+1) {
    932. 

  932.           // we cannot make use of consecutive numbering
    933. 

  933.           $res.= "\n$num /$label";
    934. 

  934.         } else {
    935. 

  935.           $res.= " /$label";
    936. 

  936.         }
    937. 

  937. 

  938.         $onum = $num;
    939. 

  939.       }
    940. 

  940. 

  941.       $res.= "\n]\n>>\nendobj";
    942. 

  942.       return $res;
    943. 

  943.     }
    944. 

  944.   }
    945. 

  945. 

  946.   /**
    947. 

  947.    * a descendent cid font, needed for unicode fonts
    948. 

  948.    */
    949. 

  949.   protected function o_fontDescendentCID($id, $action, $options = '') {
    950. 

  950.     if ($action !== 'new') {
    951. 

  951.       $o = & $this->objects[$id];
    952. 

  952.     }
    953. 

  953. 

  954.     switch ($action) {
    955. 

  955.     case 'new':
    956. 

  956.       $this->objects[$id] = array('t' => 'fontDescendentCID', 'info' => $options);
    957. 

  957. 

  958.       // we need a CID system info section
    959. 

  959.       $cidSystemInfoId = ++$this->numObj;
    960. 

  960.       $this->o_contents($cidSystemInfoId, 'new', 'raw');
    961. 

  961.       $this->objects[$id]['info']['cidSystemInfo'] = $cidSystemInfoId;
    962. 

  962.       $res = "<</Registry (Adobe)\n"; // A string identifying an issuer of character collections
    963. 

  963.       $res.= "/Ordering (UCS)\n"; // A string that uniquely names a character collection issued by a specific registry
    964. 

  964.       $res.= "/Supplement 0\n"; // The supplement number of the character collection.
    965. 

  965.       $res.= ">>";
    966. 

  966.       $this->objects[$cidSystemInfoId]['c'] = $res;
    967. 

  967. 

  968.       // and a CID to GID map
    969. 

  969.       $cidToGidMapId = ++$this->numObj;
    970. 

  970.       $this->o_fontGIDtoCIDMap($cidToGidMapId, 'new', $options);
    971. 

  971.       $this->objects[$id]['info']['cidToGidMap'] = $cidToGidMapId;
    972. 

  972.       break;
    973. 

  973. 

  974.     case 'add':
    975. 

  975.       foreach ($options as $k => $v) {
    976. 

  976.         switch ($k) {
    977. 

  977.         case 'BaseFont':
    978. 

  978.           $o['info']['name'] = $v;
    979. 

  979.           break;
    980. 

  980. 

  981.         case 'FirstChar':
    982. 

  982.         case 'LastChar':
    983. 

  983.         case 'MissingWidth':
    984. 

  984.         case 'FontDescriptor':
    985. 

  985.         case 'SubType':
    986. 

  986.           $this->addMessage("o_fontDescendentCID $k : $v");
    987. 

  987.           $o['info'][$k] = $v;
    988. 

  988.           break;
    989. 

  989.         }
    990. 

  990.       }
    991. 

  991. 

  992.       // pass values down to cid to gid map
    993. 

  993.       $this->o_fontGIDtoCIDMap($o['info']['cidToGidMap'], 'add', $options);
    994. 

  994.       break;
    995. 

  995. 

  996.     case 'out':
    997. 

  997.       $res = "\n$id 0 obj\n";
    998. 

  998.       $res.= "<</Type /Font\n";
    999. 

  999.       $res.= "/Subtype /CIDFontType2\n";
    1000. 

  1000.       $res.= "/BaseFont /".$o['info']['name']."\n";
    1001. 

  1001.       $res.= "/CIDSystemInfo ".$o['info']['cidSystemInfo']." 0 R\n";
    1002. 

  1002. //      if (isset($o['info']['FirstChar'])) {
    1003. 

  1003. //        $res.= "/FirstChar ".$o['info']['FirstChar']."\n";
    1004. 

  1004. //      }
    1005. 

  1005. 

  1006. //      if (isset($o['info']['LastChar'])) {
    1007. 

  1007. //        $res.= "/LastChar ".$o['info']['LastChar']."\n";
    1008. 

  1008. //      }
    1009. 

  1009.       if (isset($o['info']['FontDescriptor'])) {
    1010. 

  1010.         $res.= "/FontDescriptor ".$o['info']['FontDescriptor']." 0 R\n";
    1011. 

  1011.       }
    1012. 

  1012. 

  1013.       if (isset($o['info']['MissingWidth'])) {
    1014. 

  1014.         $res.= "/DW ".$o['info']['MissingWidth']."\n";
    1015. 

  1015.       }
    1016. 

  1016. 

  1017.       if (isset($o['info']['fontFileName']) && isset($this->fonts[$o['info']['fontFileName']]['CIDWidths'])) {
    1018. 

  1018.         $cid_widths = &$this->fonts[$o['info']['fontFileName']]['CIDWidths'];
    1019. 

  1019.         $w = '';
    1020. 

  1020.         foreach ($cid_widths as $cid => $width) {
    1021. 

  1021.           $w .= "$cid [$width] ";
    1022. 

  1022.         }
    1023. 

  1023.         $res.= "/W [$w]\n";
    1024. 

  1024.       }
    1025. 

  1025. 

  1026.       $res.= "/CIDToGIDMap ".$o['info']['cidToGidMap']." 0 R\n";
    1027. 

  1027.       $res.= ">>\n";
    1028. 

  1028.       $res.= "endobj";
    1029. 

  1029. 

  1030.       return $res;
    1031. 

  1031.     }
    1032. 

  1032.   }
    1033. 

  1033. 

  1034.   /**
    1035. 

  1035.    * a font glyph to character map, needed for unicode fonts
    1036. 

  1036.    */
    1037. 

  1037.   protected function o_fontGIDtoCIDMap($id, $action, $options = '') {
    1038. 

  1038.     if ($action !== 'new') {
    1039. 

  1039.       $o = & $this->objects[$id];
    1040. 

  1040.     }
    1041. 

  1041. 

  1042.     switch ($action) {
    1043. 

  1043.     case 'new':
    1044. 

  1044.       $this->objects[$id] = array('t' => 'fontGIDtoCIDMap', 'info' => $options);
    1045. 

  1045.       break;
    1046. 

  1046. 

  1047.     case 'out':
    1048. 

  1048.       $res = "\n$id 0 obj\n";
    1049. 

  1049.       $fontFileName = $o['info']['fontFileName'];
    1050. 

  1050.       $tmp = $this->fonts[$fontFileName]['CIDtoGID'] = base64_decode($this->fonts[$fontFileName]['CIDtoGID']);
    1051. 

  1051. 

  1052.       $compressed = isset($this->fonts[$fontFileName]['CIDtoGID_Compressed']) &&
    1053. 

  1053.                     $this->fonts[$fontFileName]['CIDtoGID_Compressed'];
    1054. 

  1054. 

  1055.       if (!$compressed && isset($o['raw'])) {
    1056. 

  1056.         $res.= $tmp;
    1057. 

  1057.       } else {
    1058. 

  1058.         $res.= "<<";
    1059. 

  1059. 

  1060.         if (!$compressed && $this->compressionReady && $this->options['compression']) {
    1061. 

  1061.           // then implement ZLIB based compression on this content stream
    1062. 

  1062.           $compressed = true;
    1063. 

  1063.           $tmp = gzcompress($tmp, 6);
    1064. 

  1064.         }
    1065. 

  1065.         if ($compressed) {
    1066. 

  1066.           $res.= "\n/Filter /FlateDecode";
    1067. 

  1067.         }
    1068. 

  1068. 

  1069.         $res.= "\n/Length ".mb_strlen($tmp, '8bit') .">>\nstream\n$tmp\nendstream";
    1070. 

  1070.       }
    1071. 

  1071. 

  1072.       $res.= "\nendobj";
    1073. 

  1073.       return $res;
    1074. 

  1074.     }
    1075. 

  1075.   }
    1076. 

  1076. 

  1077.   /**
    1078. 

  1078.    * the document procset, solves some problems with printing to old PS printers
    1079. 

  1079.    */
    1080. 

  1080.   protected function o_procset($id, $action, $options = '') {
    1081. 

  1081.     if ($action !== 'new') {
    1082. 

  1082.       $o = & $this->objects[$id];
    1083. 

  1083.     }
    1084. 

  1084. 

  1085.     switch ($action) {
    1086. 

  1086.       case 'new':
    1087. 

  1087.         $this->objects[$id] = array('t' => 'procset', 'info' => array('PDF' => 1, 'Text' => 1));
    1088. 

  1088.         $this->o_pages($this->currentNode, 'procset', $id);
    1089. 

  1089.         $this->procsetObjectId = $id;
    1090. 

  1090.         break;
    1091. 

  1091. 

  1092.       case 'add':
    1093. 

  1093.         // this is to add new items to the procset list, despite the fact that this is considered
    1094. 

  1094.         // obselete, the items are required for printing to some postscript printers
    1095. 

  1095.         switch ($options) {
    1096. 

  1096.         case 'ImageB':
    1097. 

  1097.         case 'ImageC':
    1098. 

  1098.         case 'ImageI':
    1099. 

  1099.           $o['info'][$options] = 1;
    1100. 

  1100.           break;
    1101. 

  1101.         }
    1102. 

  1102.         break;
    1103. 

  1103. 

  1104.       case 'out':
    1105. 

  1105.         $res = "\n$id 0 obj\n[";
    1106. 

  1106.         foreach ($o['info'] as $label => $val) {
    1107. 

  1107.           $res.= "/$label ";
    1108. 

  1108.         }
    1109. 

  1109.         $res.= "]\nendobj";
    1110. 

  1110.         return $res;
    1111. 

  1111.     }
    1112. 

  1112.   }
    1113. 

  1113. 

  1114.   /**
    1115. 

  1115.    * define the document information
    1116. 

  1116.    */
    1117. 

  1117.   protected function o_info($id, $action, $options = '') {
    1118. 

  1118.     if ($action !== 'new') {
    1119. 

  1119.       $o = & $this->objects[$id];
    1120. 

  1120.     }
    1121. 

  1121. 

  1122.     switch ($action) {
    1123. 

  1123.       case 'new':
    1124. 

  1124.         $this->infoObject = $id;
    1125. 

  1125.         $date = 'D:'.@date('Ymd');
    1126. 

  1126.         $this->objects[$id] = array('t' => 'info', 'info' => array('Creator' => 'R and OS php pdf writer, http://www.ros.co.nz', 'CreationDate' => $date));
    1127. 

  1127.         break;
    1128. 

  1128.       case 'Title':
    1129. 

  1129.       case 'Author':
    1130. 

  1130.       case 'Subject':
    1131. 

  1131.       case 'Keywords':
    1132. 

  1132.       case 'Creator':
    1133. 

  1133.       case 'Producer':
    1134. 

  1134.       case 'CreationDate':
    1135. 

  1135.       case 'ModDate':
    1136. 

  1136.       case 'Trapped':
    1137. 

  1137.         $o['info'][$action] = $options;
    1138. 

  1138.         break;
    1139. 

  1139. 

  1140.       case 'out':
    1141. 

  1141.         if ($this->encrypted) {
    1142. 

  1142.           $this->encryptInit($id);
    1143. 

  1143.         }
    1144. 

  1144. 

  1145.         $res = "\n$id 0 obj\n<<\n";
    1146. 

  1146.         foreach ($o['info'] as $k => $v) {
    1147. 

  1147.           $res.= "/$k (";
    1148. 

  1148. 

  1149.           if ($this->encrypted) {
    1150. 

  1150.             $v = $this->ARC4($v);
    1151. 

  1151.           }
    1152. 

  1152. 

  1153.           // dates must be outputted as-is, without Unicode transformations
    1154. 

  1154.           elseif (!in_array($k, array('CreationDate', 'ModDate'))){
    1155. 

  1155.             $v = $this->filterText($v);
    1156. 

  1156.           }
    1157. 

  1157. 

  1158.           $res.= $v;
    1159. 

  1159.           $res.= ")\n";
    1160. 

  1160.         }
    1161. 

  1161. 

  1162.         $res.= ">>\nendobj";
    1163. 

  1163.         return $res;
    1164. 

  1164.     }
    1165. 

  1165.   }
    1166. 

  1166. 

  1167.   /**
    1168. 

  1168.    * an action object, used to link to URLS initially
    1169. 

  1169.    */
    1170. 

  1170.   protected function o_action($id, $action, $options = '') {
    1171. 

  1171.     if ($action !== 'new') {
    1172. 

  1172.       $o = & $this->objects[$id];
    1173. 

  1173.     }
    1174. 

  1174. 

  1175.     switch ($action) {
    1176. 

  1176.       case 'new':
    1177. 

  1177.         if (is_array($options)) {
    1178. 

  1178.           $this->objects[$id] = array('t' => 'action', 'info' => $options, 'type' => $options['type']);
    1179. 

  1179.         } else {
    1180. 

  1180.           // then assume a URI action
    1181. 

  1181.           $this->objects[$id] = array('t' => 'action', 'info' => $options, 'type' => 'URI');
    1182. 

  1182.         }
    1183. 

  1183.         break;
    1184. 

  1184. 

  1185.       case 'out':
    1186. 

  1186.         if ($this->encrypted) {
    1187. 

  1187.           $this->encryptInit($id);
    1188. 

  1188.         }
    1189. 

  1189. 

  1190.         $res = "\n$id 0 obj\n<< /Type /Action";
    1191. 

  1191.         switch ($o['type']) {
    1192. 

  1192.           case 'ilink':
    1193. 

  1193.             if (!isset($this->destinations[(string)$o['info']['label']])) break;
    1194. 

  1194. 

  1195.             // there will be an 'label' setting, this is the name of the destination
    1196. 

  1196.             $res.= "\n/S /GoTo\n/D ".$this->destinations[(string)$o['info']['label']]." 0 R";
    1197. 

  1197.             break;
    1198. 

  1198. 

  1199.           case 'URI':
    1200. 

  1200.             $res.= "\n/S /URI\n/URI (";
    1201. 

  1201.             if ($this->encrypted) {
    1202. 

  1202.               $res.= $this->filterText($this->ARC4($o['info']), true, false);
    1203. 

  1203.             } else {
    1204. 

  1204.               $res.= $this->filterText($o['info'], true, false);
    1205. 

  1205.             }
    1206. 

  1206. 

  1207.             $res.= ")";
    1208. 

  1208.             break;
    1209. 

  1209.         }
    1210. 

  1210. 

  1211.         $res.= "\n>>\nendobj";
    1212. 

  1212.         return $res;
    1213. 

  1213.     }
    1214. 

  1214.   }
    1215. 

  1215. 

  1216.   /**
    1217. 

  1217.    * an annotation object, this will add an annotation to the current page.
    1218. 

  1218.    * initially will support just link annotations
    1219. 

  1219.    */
    1220. 

  1220.   protected function o_annotation($id, $action, $options = '') {
    1221. 

  1221.     if ($action !== 'new') {
    1222. 

  1222.       $o = & $this->objects[$id];
    1223. 

  1223.     }
    1224. 

  1224. 

  1225.     switch ($action) {
    1226. 

  1226.       case 'new':
    1227. 

  1227.         // add the annotation to the current page
    1228. 

  1228.         $pageId = $this->currentPage;
    1229. 

  1229.         $this->o_page($pageId, 'annot', $id);
    1230. 

  1230. 

  1231.         // and add the action object which is going to be required
    1232. 

  1232.         switch ($options['type']) {
    1233. 

  1233.           case 'link':
    1234. 

  1234.             $this->objects[$id] = array('t' => 'annotation', 'info' => $options);
    1235. 

  1235.             $this->numObj++;
    1236. 

  1236.             $this->o_action($this->numObj, 'new', $options['url']);
    1237. 

  1237.             $this->objects[$id]['info']['actionId'] = $this->numObj;
    1238. 

  1238.             break;
    1239. 

  1239. 

  1240.           case 'ilink':
    1241. 

  1241.             // this is to a named internal link
    1242. 

  1242.             $label = $options['label'];
    1243. 

  1243.             $this->objects[$id] = array('t' => 'annotation', 'info' => $options);
    1244. 

  1244.             $this->numObj++;
    1245. 

  1245.             $this->o_action($this->numObj, 'new', array('type' => 'ilink', 'label' => $label));
    1246. 

  1246.             $this->objects[$id]['info']['actionId'] = $this->numObj;
    1247. 

  1247.             break;
    1248. 

  1248.         }
    1249. 

  1249.         break;
    1250. 

  1250. 

  1251.       case 'out':
    1252. 

  1252.         $res = "\n$id 0 obj\n<< /Type /Annot";
    1253. 

  1253.         switch ($o['info']['type']) {
    1254. 

  1254.           case 'link':
    1255. 

  1255.           case 'ilink':
    1256. 

  1256.             $res.= "\n/Subtype /Link";
    1257. 

  1257.             break;
    1258. 

  1258.         }
    1259. 

  1259.         $res.= "\n/A ".$o['info']['actionId']." 0 R";
    1260. 

  1260.         $res.= "\n/Border [0 0 0]";
    1261. 

  1261.         $res.= "\n/H /I";
    1262. 

  1262.         $res.= "\n/Rect [ ";
    1263. 

  1263. 

  1264.         foreach ($o['info']['rect'] as $v) {
    1265. 

  1265.           $res.= sprintf("%.4F ", $v);
    1266. 

  1266.         }
    1267. 

  1267. 

  1268.         $res.= "]";
    1269. 

  1269.         $res.= "\n>>\nendobj";
    1270. 

  1270.         return $res;
    1271. 

  1271.     }
    1272. 

  1272.   }
    1273. 

  1273. 

  1274.   /**
    1275. 

  1275.    * a page object, it also creates a contents object to hold its contents
    1276. 

  1276.    */
    1277. 

  1277.   protected function o_page($id, $action, $options = '') {
    1278. 

  1278.     if ($action !== 'new') {
    1279. 

  1279.       $o = & $this->objects[$id];
    1280. 

  1280.     }
    1281. 

  1281. 

  1282.     switch ($action) {
    1283. 

  1283.     case 'new':
    1284. 

  1284.       $this->numPages++;
    1285. 

  1285.       $this->objects[$id] = array('t' => 'page', 'info' => array('parent' => $this->currentNode, 'pageNum' => $this->numPages));
    1286. 

  1286. 

  1287.       if (is_array($options)) {
    1288. 

  1288.         // then this must be a page insertion, array should contain 'rid','pos'=[before|after]
    1289. 

  1289.         $options['id'] = $id;
    1290. 

  1290.         $this->o_pages($this->currentNode, 'page', $options);
    1291. 

  1291.       } else {
    1292. 

  1292.         $this->o_pages($this->currentNode, 'page', $id);
    1293. 

  1293.       }
    1294. 

  1294. 

  1295.       $this->currentPage = $id;
    1296. 

  1296.       //make a contents object to go with this page
    1297. 

  1297.       $this->numObj++;
    1298. 

  1298.       $this->o_contents($this->numObj, 'new', $id);
    1299. 

  1299.       $this->currentContents = $this->numObj;
    1300. 

  1300.       $this->objects[$id]['info']['contents'] = array();
    1301. 

  1301.       $this->objects[$id]['info']['contents'][] = $this->numObj;
    1302. 

  1302. 

  1303.       $match = ($this->numPages%2 ? 'odd' : 'even');
    1304. 

  1304.       foreach ($this->addLooseObjects as $oId => $target) {
    1305. 

  1305.         if ($target === 'all' || $match === $target) {
    1306. 

  1306.           $this->objects[$id]['info']['contents'][] = $oId;
    1307. 

  1307.         }
    1308. 

  1308.       }
    1309. 

  1309.       break;
    1310. 

  1310. 

  1311.     case 'content':
    1312. 

  1312.       $o['info']['contents'][] = $options;
    1313. 

  1313.       break;
    1314. 

  1314. 

  1315.     case 'annot':
    1316. 

  1316.       // add an annotation to this page
    1317. 

  1317.       if (!isset($o['info']['annot'])) {
    1318. 

  1318.         $o['info']['annot'] = array();
    1319. 

  1319.       }
    1320. 

  1320. 

  1321.       // $options should contain the id of the annotation dictionary
    1322. 

  1322.       $o['info']['annot'][] = $options;
    1323. 

  1323.       break;
    1324. 

  1324. 

  1325.     case 'out':
    1326. 

  1326.       $res = "\n$id 0 obj\n<< /Type /Page";
    1327. 

  1327.       $res.= "\n/Parent ".$o['info']['parent']." 0 R";
    1328. 

  1328. 

  1329.       if (isset($o['info']['annot'])) {
    1330. 

  1330.         $res.= "\n/Annots [";
    1331. 

  1331.         foreach ($o['info']['annot'] as $aId) {
    1332. 

  1332.           $res.= " $aId 0 R";
    1333. 

  1333.         }
    1334. 

  1334.         $res.= " ]";
    1335. 

  1335.       }
    1336. 

  1336. 

  1337.       $count = count($o['info']['contents']);
    1338. 

  1338.       if ($count == 1) {
    1339. 

  1339.         $res.= "\n/Contents ".$o['info']['contents'][0]." 0 R";
    1340. 

  1340.       } else if ($count > 1) {
    1341. 

  1341.         $res.= "\n/Contents [\n";
    1342. 

  1342. 

  1343.         // reverse the page contents so added objects are below normal content
    1344. 

  1344.         //foreach (array_reverse($o['info']['contents']) as $cId) {
    1345. 

  1345.         // Back to normal now that I've got transparency working --Benj
    1346. 

  1346.         foreach ($o['info']['contents'] as $cId) {
    1347. 

  1347.           $res.= "$cId 0 R\n";
    1348. 

  1348.         }
    1349. 

  1349.         $res.= "]";
    1350. 

  1350.       }
    1351. 

  1351. 

  1352.       $res.= "\n>>\nendobj";
    1353. 

  1353.       return $res;
    1354. 

  1354.     }
    1355. 

  1355.   }
    1356. 

  1356. 

  1357.   /**
    1358. 

  1358.    * the contents objects hold all of the content which appears on pages
    1359. 

  1359.    */
    1360. 

  1360.   protected function o_contents($id, $action, $options = '') {
    1361. 

  1361.     if ($action !== 'new') {
    1362. 

  1362.       $o = & $this->objects[$id];
    1363. 

  1363.     }
    1364. 

  1364. 

  1365.     switch ($action) {
    1366. 

  1366.     case 'new':
    1367. 

  1367.       $this->objects[$id] = array('t' => 'contents', 'c' => '', 'info' => array());
    1368. 

  1368.       if (mb_strlen($options, '8bit') && intval($options)) {
    1369. 

  1369.         // then this contents is the primary for a page
    1370. 

  1370.         $this->objects[$id]['onPage'] = $options;
    1371. 

  1371.       } else if ($options === 'raw') {
    1372. 

  1372.         // then this page contains some other type of system object
    1373. 

  1373.         $this->objects[$id]['raw'] = 1;
    1374. 

  1374.       }
    1375. 

  1375.       break;
    1376. 

  1376. 

  1377.     case 'add':
    1378. 

  1378.       // add more options to the decleration
    1379. 

  1379.       foreach ($options as $k => $v) {
    1380. 

  1380.         $o['info'][$k] = $v;
    1381. 

  1381.       }
    1382. 

  1382. 

  1383.     case 'out':
    1384. 

  1384.       $tmp = $o['c'];
    1385. 

  1385.       $res = "\n$id 0 obj\n";
    1386. 

  1386. 

  1387.       if (isset($this->objects[$id]['raw'])) {
    1388. 

  1388.         $res.= $tmp;
    1389. 

  1389.       } else {
    1390. 

  1390.         $res.= "<<";
    1391. 

  1391.         if ($this->compressionReady && $this->options['compression']) {
    1392. 

  1392.           // then implement ZLIB based compression on this content stream
    1393. 

  1393.           $res.= " /Filter /FlateDecode";
    1394. 

  1394.           $tmp = gzcompress($tmp, 6);
    1395. 

  1395.         }
    1396. 

  1396. 

  1397.         if ($this->encrypted) {
    1398. 

  1398.           $this->encryptInit($id);
    1399. 

  1399.           $tmp = $this->ARC4($tmp);
    1400. 

  1400.         }
    1401. 

  1401. 

  1402.         foreach ($o['info'] as $k => $v) {
    1403. 

  1403.           $res.= "\n/$k $v";
    1404. 

  1404.         }
    1405. 

  1405. 

  1406.         $res.= "\n/Length ".mb_strlen($tmp, '8bit') ." >>\nstream\n$tmp\nendstream";
    1407. 

  1407.       }
    1408. 

  1408. 

  1409.       $res.= "\nendobj";
    1410. 

  1410.       return $res;
    1411. 

  1411.     }
    1412. 

  1412.   }
    1413. 

  1413. 

  1414.   protected function o_embedjs($id, $action) {
    1415. 

  1415.     if ($action !== 'new') {
    1416. 

  1416.       $o = & $this->objects[$id];
    1417. 

  1417.     }
    1418. 

  1418. 

  1419.     switch ($action) {
    1420. 

  1420.     case 'new':
    1421. 

  1421.       $this->objects[$id] = array('t' => 'embedjs', 'info' => array(
    1422. 

  1422.         'Names' => '[(EmbeddedJS) '.($id+1).' 0 R]'
    1423. 

  1423.       ));
    1424. 

  1424.       break;
    1425. 

  1425. 

  1426.     case 'out':
    1427. 

  1427.       $res = "\n$id 0 obj\n<< ";
    1428. 

  1428.       foreach ($o['info'] as $k => $v) {
    1429. 

  1429.         $res.= "\n/$k $v";
    1430. 

  1430.       }
    1431. 

  1431.       $res.= "\n>>\nendobj";
    1432. 

  1432.       return $res;
    1433. 

  1433.     }
    1434. 

  1434.   }
    1435. 

  1435. 

  1436.   protected function o_javascript($id, $action, $code = '') {
    1437. 

  1437.     if ($action !== 'new') {
    1438. 

  1438.       $o = & $this->objects[$id];
    1439. 

  1439.     }
    1440. 

  1440. 

  1441.     switch ($action) {
    1442. 

  1442.     case 'new':
    1443. 

  1443.       $this->objects[$id] = array('t' => 'javascript', 'info' => array(
    1444. 

  1444.         'S' => '/JavaScript',
    1445. 

  1445.         'JS' => '('.$this->filterText($code).')',
    1446. 

  1446.       ));
    1447. 

  1447.       break;
    1448. 

  1448. 

  1449.     case 'out':
    1450. 

  1450.       $res = "\n$id 0 obj\n<< ";
    1451. 

  1451.       foreach ($o['info'] as $k => $v) {
    1452. 

  1452.         $res.= "\n/$k $v";
    1453. 

  1453.       }
    1454. 

  1454.       $res.= "\n>>\nendobj";
    1455. 

  1455.       return $res;
    1456. 

  1456.     }
    1457. 

  1457.   }
    1458. 

  1458. 

  1459.   /**
    1460. 

  1460.    * an image object, will be an XObject in the document, includes description and data
    1461. 

  1461.    */
    1462. 

  1462.   protected function o_image($id, $action, $options = '') {
    1463. 

  1463.     if ($action !== 'new') {
    1464. 

  1464.       $o = & $this->objects[$id];
    1465. 

  1465.     }
    1466. 

  1466. 

  1467.     switch ($action) {
    1468. 

  1468.     case 'new':
    1469. 

  1469.       // make the new object
    1470. 

  1470.       $this->objects[$id] = array('t' => 'image', 'data' => &$options['data'], 'info' => array());
    1471. 

  1471. 

  1472.       $info =& $this->objects[$id]['info'];
    1473. 

  1473. 

  1474.       $info['Type'] = '/XObject';
    1475. 

  1475.       $info['Subtype'] = '/Image';
    1476. 

  1476.       $info['Width'] = $options['iw'];
    1477. 

  1477.       $info['Height'] = $options['ih'];
    1478. 

  1478. 

  1479.       if (isset($options['masked']) && $options['masked']) {
    1480. 

  1480.         $info['SMask'] = ($this->numObj-1).' 0 R';
    1481. 

  1481.       }
    1482. 

  1482. 

  1483.       if (!isset($options['type']) || $options['type'] === 'jpg') {
    1484. 

  1484.         if (!isset($options['channels'])) {
    1485. 

  1485.           $options['channels'] = 3;
    1486. 

  1486.         }
    1487. 

  1487. 

  1488.         switch ($options['channels']) {
    1489. 

  1489.           case  1: $info['ColorSpace'] = '/DeviceGray'; break;
    1490. 

  1490.           case  4: $info['ColorSpace'] = '/DeviceCMYK'; break;
    1491. 

  1491.           default: $info['ColorSpace'] = '/DeviceRGB'; break;
    1492. 

  1492.         }
    1493. 

  1493. 

  1494.         if ($info['ColorSpace'] === '/DeviceCMYK') {
    1495. 

  1495.           $info['Decode'] = '[1 0 1 0 1 0 1 0]';
    1496. 

  1496.         }
    1497. 

  1497. 

  1498.         $info['Filter'] = '/DCTDecode';
    1499. 

  1499.         $info['BitsPerComponent'] = 8;
    1500. 

  1500.       } 
    1501. 

  1501. 

  1502.       else if ($options['type'] === 'png') {
    1503. 

  1503.         $info['Filter'] = '/FlateDecode';
    1504. 

  1504.         $info['DecodeParms'] = '<< /Predictor 15 /Colors '.$options['ncolor'].' /Columns '.$options['iw'].' /BitsPerComponent '.$options['bitsPerComponent'].'>>';
    1505. 

  1505. 

  1506.         if ($options['isMask']) {
    1507. 

  1507.           $info['ColorSpace'] = '/DeviceGray';
    1508. 

  1508.         }
    1509. 

  1509.         else {
    1510. 

  1510.           if (mb_strlen($options['pdata'], '8bit')) {
    1511. 

  1511.             $tmp = ' [ /Indexed /DeviceRGB '.(mb_strlen($options['pdata'], '8bit') /3-1) .' ';
    1512. 

  1512.             $this->numObj++;
    1513. 

  1513.             $this->o_contents($this->numObj, 'new');
    1514. 

  1514.             $this->objects[$this->numObj]['c'] = $options['pdata'];
    1515. 

  1515.             $tmp.= $this->numObj.' 0 R';
    1516. 

  1516.             $tmp.= ' ]';
    1517. 

  1517.             $info['ColorSpace'] = $tmp;
    1518. 

  1518. 

  1519.             if (isset($options['transparency'])) {
    1520. 

  1520.               $transparency = $options['transparency'];
    1521. 

  1521.               switch ($transparency['type']) {
    1522. 

  1522.               case 'indexed':
    1523. 

  1523.                 $tmp = ' [ '.$transparency['data'].' '.$transparency['data'].'] ';
    1524. 

  1524.                 $info['Mask'] = $tmp;
    1525. 

  1525.                 break;
    1526. 

  1526. 

  1527.               case 'color-key':
    1528. 

  1528.                 $tmp = ' [ '.
    1529. 

  1529.                   $transparency['r'] . ' ' . $transparency['r'] .
    1530. 

  1530.                   $transparency['g'] . ' ' . $transparency['g'] .
    1531. 

  1531.                   $transparency['b'] . ' ' . $transparency['b'] .
    1532. 

  1532.                   ' ] ';
    1533. 

  1533.                 $info['Mask'] = $tmp;
    1534. 

  1534.                 break;
    1535. 

  1535.               }
    1536. 

  1536.             }
    1537. 

  1537.           } else {
    1538. 

  1538.             if (isset($options['transparency'])) {
    1539. 

  1539.               $transparency = $options['transparency'];
    1540. 

  1540. 

  1541.               switch ($transparency['type']) {
    1542. 

  1542.               case 'indexed':
    1543. 

  1543.                 $tmp = ' [ '.$transparency['data'].' '.$transparency['data'].'] ';
    1544. 

  1544.                 $info['Mask'] = $tmp;
    1545. 

  1545.                 break;
    1546. 

  1546. 

  1547.               case 'color-key':
    1548. 

  1548.                 $tmp = ' [ '.
    1549. 

  1549.                   $transparency['r'] . ' ' . $transparency['r'] . ' ' .
    1550. 

  1550.                   $transparency['g'] . ' ' . $transparency['g'] . ' ' .
    1551. 

  1551.                   $transparency['b'] . ' ' . $transparency['b'] .
    1552. 

  1552.                   ' ] ';
    1553. 

  1553.                 $info['Mask'] = $tmp;
    1554. 

  1554.                 break;
    1555. 

  1555.               }
    1556. 

  1556.             }
    1557. 

  1557.             $info['ColorSpace'] = '/'.$options['color'];
    1558. 

  1558.           }
    1559. 

  1559.         }
    1560. 

  1560. 

  1561.         $info['BitsPerComponent'] = $options['bitsPerComponent'];
    1562. 

  1562.       }
    1563. 

  1563. 

  1564.       // assign it a place in the named resource dictionary as an external object, according to
    1565. 

  1565.       // the label passed in with it.
    1566. 

  1566.       $this->o_pages($this->currentNode, 'xObject', array('label' => $options['label'], 'objNum' => $id));
    1567. 

  1567. 

  1568.       // also make sure that we have the right procset object for it.
    1569. 

  1569.       $this->o_procset($this->procsetObjectId, 'add', 'ImageC');
    1570. 

  1570.       break;
    1571. 

  1571. 

  1572.     case 'out':
    1573. 

  1573.       $tmp = &$o['data'];
    1574. 

  1574.       $res = "\n$id 0 obj\n<<";
    1575. 

  1575. 

  1576.       foreach ($o['info'] as $k => $v) {
    1577. 

  1577.         $res.= "\n/$k $v";
    1578. 

  1578.       }
    1579. 

  1579. 

  1580.       if ($this->encrypted) {
    1581. 

  1581.         $this->encryptInit($id);
    1582. 

  1582.         $tmp = $this->ARC4($tmp);
    1583. 

  1583.       }
    1584. 

  1584. 

  1585.       $res.= "\n/Length ".mb_strlen($tmp, '8bit') .">>\nstream\n$tmp\nendstream\nendobj";
    1586. 

  1586. 

  1587.       return $res;
    1588. 

  1588.     }
    1589. 

  1589.   }
    1590. 

  1590. 

  1591.   /**
    1592. 

  1592.    * graphics state object
    1593. 

  1593.    */
    1594. 

  1594.   protected function o_extGState($id, $action, $options = "") {
    1595. 

  1595.     static $valid_params = array("LW",  "LC",  "LC",  "LJ",  "ML",
    1596. 

  1596.                                    "D",  "RI",  "OP",  "op",  "OPM",
    1597. 

  1597.                                    "Font",  "BG",  "BG2",  "UCR",
    1598. 

  1598.                                    "TR",  "TR2",  "HT",  "FL",
    1599. 

  1599.                                    "SM",  "SA",  "BM",  "SMask",
    1600. 

  1600.                                    "CA",  "ca",  "AIS",  "TK");
    1601. 

  1601. 

  1602.     if ($action !== "new") {
    1603. 

  1603.       $o = & $this->objects[$id];
    1604. 

  1604.     }
    1605. 

  1605. 

  1606.     switch ($action) {
    1607. 

  1607.     case "new":
    1608. 

  1608.       $this->objects[$id] = array('t' => 'extGState', 'info' => $options);
    1609. 

  1609. 

  1610.       // Tell the pages about the new resource
    1611. 

  1611.       $this->numStates++;
    1612. 

  1612.       $this->o_pages($this->currentNode, 'extGState', array("objNum" => $id, "stateNum" => $this->numStates));
    1613. 

  1613.       break;
    1614. 

  1614. 

  1615.     case "out":
    1616. 

  1616.       $res = "\n$id 0 obj\n<< /Type /ExtGState\n";
    1617. 

  1617. 

  1618.       foreach ($o["info"] as $k => $v) {
    1619. 

  1619.         if ( !in_array($k, $valid_params))
    1620. 

  1620.           continue;
    1621. 

  1621.         $res.= "/$k $v\n";
    1622. 

  1622.       }
    1623. 

  1623. 

  1624.       $res.= ">>\nendobj";
    1625. 

  1625.       return $res;
    1626. 

  1626.     }
    1627. 

  1627.   }
    1628. 

  1628. 

  1629.   /**
    1630. 

  1630.    * encryption object.
    1631. 

  1631.    */
    1632. 

  1632.   protected function o_encryption($id, $action, $options = '') {
    1633. 

  1633.     if ($action !== 'new') {
    1634. 

  1634.       $o = & $this->objects[$id];
    1635. 

  1635.     }
    1636. 

  1636. 

  1637.     switch ($action) {
    1638. 

  1638.     case 'new':
    1639. 

  1639.       // make the new object
    1640. 

  1640.       $this->objects[$id] = array('t' => 'encryption', 'info' => $options);
    1641. 

  1641.       $this->arc4_objnum = $id;
    1642. 

  1642. 

  1643.       // figure out the additional paramaters required
    1644. 

  1644.       $pad = chr(0x28) .chr(0xBF) .chr(0x4E) .chr(0x5E) .chr(0x4E) .chr(0x75) .chr(0x8A) .chr(0x41)
    1645. 

  1645.              .chr(0x64) .chr(0x00) .chr(0x4E) .chr(0x56) .chr(0xFF) .chr(0xFA) .chr(0x01) .chr(0x08)
    1646. 

  1646.              .chr(0x2E) .chr(0x2E) .chr(0x00) .chr(0xB6) .chr(0xD0) .chr(0x68) .chr(0x3E) .chr(0x80)
    1647. 

  1647.              .chr(0x2F) .chr(0x0C) .chr(0xA9) .chr(0xFE) .chr(0x64) .chr(0x53) .chr(0x69) .chr(0x7A);
    1648. 

  1648. 

  1649.       $len = mb_strlen($options['owner'], '8bit');
    1650. 

  1650. 

  1651.       if ($len > 32) {
    1652. 

  1652.         $owner = substr($options['owner'], 0, 32);
    1653. 

  1653.       } else if ($len < 32) {
    1654. 

  1654.         $owner = $options['owner'].substr($pad, 0, 32-$len);
    1655. 

  1655.       } else {
    1656. 

  1656.         $owner = $options['owner'];
    1657. 

  1657.       }
    1658. 

  1658. 

  1659.       $len = mb_strlen($options['user'], '8bit');
    1660. 

  1660.       if ($len > 32) {
    1661. 

  1661.         $user = substr($options['user'], 0, 32);
    1662. 

  1662.       } else if ($len < 32) {
    1663. 

  1663.         $user = $options['user'].substr($pad, 0, 32-$len);
    1664. 

  1664.       } else {
    1665. 

  1665.         $user = $options['user'];
    1666. 

  1666.       }
    1667. 

  1667. 

  1668.       $tmp = $this->md5_16($owner);
    1669. 

  1669.       $okey = substr($tmp, 0, 5);
    1670. 

  1670.       $this->ARC4_init($okey);
    1671. 

  1671.       $ovalue = $this->ARC4($user);
    1672. 

  1672.       $this->objects[$id]['info']['O'] = $ovalue;
    1673. 

  1673. 

  1674.       // now make the u value, phew.
    1675. 

  1675.       $tmp = $this->md5_16($user.$ovalue.chr($options['p']) .chr(255) .chr(255) .chr(255) .$this->fileIdentifier);
    1676. 

  1676. 

  1677.       $ukey = substr($tmp, 0, 5);
    1678. 

  1678.       $this->ARC4_init($ukey);
    1679. 

  1679.       $this->encryptionKey = $ukey;
    1680. 

  1680.       $this->encrypted = true;
    1681. 

  1681.       $uvalue = $this->ARC4($pad);
    1682. 

  1682.       $this->objects[$id]['info']['U'] = $uvalue;
    1683. 

  1683.       $this->encryptionKey = $ukey;
    1684. 

  1684.       // initialize the arc4 array
    1685. 

  1685.       break;
    1686. 

  1686. 

  1687.     case 'out':
    1688. 

  1688.       $res = "\n$id 0 obj\n<<";
    1689. 

  1689.       $res.= "\n/Filter /Standard";
    1690. 

  1690.       $res.= "\n/V 1";
    1691. 

  1691.       $res.= "\n/R 2";
    1692. 

  1692.       $res.= "\n/O (".$this->filterText($o['info']['O'], true, false) .')';
    1693. 

  1693.       $res.= "\n/U (".$this->filterText($o['info']['U'], true, false) .')';
    1694. 

  1694.       // and the p-value needs to be converted to account for the twos-complement approach
    1695. 

  1695.       $o['info']['p'] = (($o['info']['p']^255) +1) *-1;
    1696. 

  1696.       $res.= "\n/P ".($o['info']['p']);
    1697. 

  1697.       $res.= "\n>>\nendobj";
    1698. 

  1698.       return $res;
    1699. 

  1699.     }
    1700. 

  1700.   }
    1701. 

  1701. 

  1702.   /**
    1703. 

  1703.    * ARC4 functions
    1704. 

  1704.    * A series of function to implement ARC4 encoding in PHP
    1705. 

  1705.    */
    1706. 

  1706. 

  1707.   /**
    1708. 

  1708.    * calculate the 16 byte version of the 128 bit md5 digest of the string
    1709. 

  1709.    */
    1710. 

  1710.   function md5_16($string) {
    1711. 

  1711.     $tmp = md5($string);
    1712. 

  1712.     $out = '';
    1713. 

  1713.     for ($i = 0; $i <= 30; $i = $i+2) {
    1714. 

  1714.       $out.= chr(hexdec(substr($tmp, $i, 2)));
    1715. 

  1715.     }
    1716. 

  1716.     return $out;
    1717. 

  1717.   }
    1718. 

  1718. 

  1719.   /**
    1720. 

  1720.    * initialize the encryption for processing a particular object
    1721. 

  1721.    */
    1722. 

  1722.   function encryptInit($id) {
    1723. 

  1723.     $tmp = $this->encryptionKey;
    1724. 

  1724.     $hex = dechex($id);
    1725. 

  1725.     if (mb_strlen($hex, '8bit') < 6) {
    1726. 

  1726.       $hex = substr('000000', 0, 6-mb_strlen($hex, '8bit')) .$hex;
    1727. 

  1727.     }
    1728. 

  1728.     $tmp.= chr(hexdec(substr($hex, 4, 2))) .chr(hexdec(substr($hex, 2, 2))) .chr(hexdec(substr($hex, 0, 2))) .chr(0) .chr(0);
    1729. 

  1729.     $key = $this->md5_16($tmp);
    1730. 

  1730.     $this->ARC4_init(substr($key, 0, 10));
    1731. 

  1731.   }
    1732. 

  1732. 

  1733.   /**
    1734. 

  1734.    * initialize the ARC4 encryption
    1735. 

  1735.    */
    1736. 

  1736.   function ARC4_init($key = '') {
    1737. 

  1737.     $this->arc4 = '';
    1738. 

  1738. 

  1739.     // setup the control array
    1740. 

  1740.     if (mb_strlen($key, '8bit') == 0) {
    1741. 

  1741.       return;
    1742. 

  1742.     }
    1743. 

  1743. 

  1744.     $k = '';
    1745. 

  1745.     while (mb_strlen($k, '8bit') < 256) {
    1746. 

  1746.       $k.= $key;
    1747. 

  1747.     }
    1748. 

  1748. 

  1749.     $k = substr($k, 0, 256);
    1750. 

  1750.     for ($i = 0; $i < 256; $i++) {
    1751. 

  1751.       $this->arc4.= chr($i);
    1752. 

  1752.     }
    1753. 

  1753. 

  1754.     $j = 0;
    1755. 

  1755. 

  1756.     for ($i = 0; $i < 256; $i++) {
    1757. 

  1757.       $t = $this->arc4[$i];
    1758. 

  1758.       $j = ($j + ord($t) + ord($k[$i])) %256;
    1759. 

  1759.       $this->arc4[$i] = $this->arc4[$j];
    1760. 

  1760.       $this->arc4[$j] = $t;
    1761. 

  1761.     }
    1762. 

  1762.   }
    1763. 

  1763. 

  1764.   /**
    1765. 

  1765.    * ARC4 encrypt a text string
    1766. 

  1766.    */
    1767. 

  1767.   function ARC4($text) {
    1768. 

  1768.     $len = mb_strlen($text, '8bit');
    1769. 

  1769.     $a = 0;
    1770. 

  1770.     $b = 0;
    1771. 

  1771.     $c = $this->arc4;
    1772. 

  1772.     $out = '';
    1773. 

  1773.     for ($i = 0; $i < $len; $i++) {
    1774. 

  1774.       $a = ($a+1) %256;
    1775. 

  1775.       $t = $c[$a];
    1776. 

  1776.       $b = ($b+ord($t)) %256;
    1777. 

  1777.       $c[$a] = $c[$b];
    1778. 

  1778.       $c[$b] = $t;
    1779. 

  1779.       $k = ord($c[(ord($c[$a]) + ord($c[$b])) %256]);
    1780. 

  1780.       $out.= chr(ord($text[$i]) ^ $k);
    1781. 

  1781.     }
    1782. 

  1782.     return $out;
    1783. 

  1783.   }
    1784. 

  1784. 

  1785.   /**
    1786. 

  1786.    * functions which can be called to adjust or add to the document
    1787. 

  1787.    */
    1788. 

  1788. 

  1789.   /**
    1790. 

  1790.    * add a link in the document to an external URL
    1791. 

  1791.    */
    1792. 

  1792.   function addLink($url, $x0, $y0, $x1, $y1) {
    1793. 

  1793.     $this->numObj++;
    1794. 

  1794.     $info = array('type' => 'link', 'url' => $url, 'rect' => array($x0, $y0, $x1, $y1));
    1795. 

  1795.     $this->o_annotation($this->numObj, 'new', $info);
    1796. 

  1796.   }
    1797. 

  1797. 

  1798.   /**
    1799. 

  1799.    * add a link in the document to an internal destination (ie. within the document)
    1800. 

  1800.    */
    1801. 

  1801.   function addInternalLink($label, $x0, $y0, $x1, $y1) {
    1802. 

  1802.     $this->numObj++;
    1803. 

  1803.     $info = array('type' => 'ilink', 'label' => $label, 'rect' => array($x0, $y0, $x1, $y1));
    1804. 

  1804.     $this->o_annotation($this->numObj, 'new', $info);
    1805. 

  1805.   }
    1806. 

  1806. 

  1807.   /**
    1808. 

  1808.    * set the encryption of the document
    1809. 

  1809.    * can be used to turn it on and/or set the passwords which it will have.
    1810. 

  1810.    * also the functions that the user will have are set here, such as print, modify, add
    1811. 

  1811.    */
    1812. 

  1812.   function setEncryption($userPass = '', $ownerPass = '', $pc = array()) {
    1813. 

  1813.     $p = bindec("11000000");
    1814. 

  1814. 

  1815.     $options = array('print' => 4, 'modify' => 8, 'copy' => 16, 'add' => 32);
    1816. 

  1816. 

  1817.     foreach ($pc as $k => $v) {
    1818. 

  1818.       if ($v && isset($options[$k])) {
    1819. 

  1819.         $p+= $options[$k];
    1820. 

  1820.       } else if (isset($options[$v])) {
    1821. 

  1821.         $p+= $options[$v];
    1822. 

  1822.       }
    1823. 

  1823.     }
    1824. 

  1824. 

  1825.     // implement encryption on the document
    1826. 

  1826.     if ($this->arc4_objnum == 0) {
    1827. 

  1827.       // then the block does not exist already, add it.
    1828. 

  1828.       $this->numObj++;
    1829. 

  1829.       if (mb_strlen($ownerPass) == 0) {
    1830. 

  1830.         $ownerPass = $userPass;
    1831. 

  1831.       }
    1832. 

  1832. 

  1833.       $this->o_encryption($this->numObj, 'new', array('user' => $userPass, 'owner' => $ownerPass, 'p' => $p));
    1834. 

  1834.     }
    1835. 

  1835.   }
    1836. 

  1836. 

  1837.   /**
    1838. 

  1838.    * should be used for internal checks, not implemented as yet
    1839. 

  1839.    */
    1840. 

  1840.   function checkAllHere() {
    1841. 

  1841.   }
    1842. 

  1842. 

  1843.   /**
    1844. 

  1844.    * return the pdf stream as a string returned from the function
    1845. 

  1845.    */
    1846. 

  1846.   function output($debug = false) {
    1847. 

  1847.     if ($debug) {
    1848. 

  1848.       // turn compression off
    1849. 

  1849.       $this->options['compression'] = false;
    1850. 

  1850.     }
    1851. 

  1851. 

  1852.     if ($this->javascript) {
    1853. 

  1853.       $this->numObj++;
    1854. 

  1854. 

  1855.       $js_id = $this->numObj;
    1856. 

  1856.       $this->o_embedjs($js_id, 'new');
    1857. 

  1857.       $this->o_javascript(++$this->numObj, 'new', $this->javascript);
    1858. 

  1858. 

  1859.       $id = $this->catalogId;
    1860. 

  1860. 

  1861.       $this->o_catalog($id, 'javascript', $js_id);
    1862. 

  1862.     }
    1863. 

  1863. 

  1864.     if ($this->arc4_objnum) {
    1865. 

  1865.       $this->ARC4_init($this->encryptionKey);
    1866. 

  1866.     }
    1867. 

  1867. 

  1868.     $this->checkAllHere();
    1869. 

  1869. 

  1870.     $xref = array();
    1871. 

  1871.     $content = '%PDF-1.3';
    1872. 

  1872.     $pos = mb_strlen($content, '8bit');
    1873. 

  1873. 

  1874.     foreach ($this->objects as $k => $v) {
    1875. 

  1875.       $tmp = 'o_'.$v['t'];
    1876. 

  1876.       $cont = $this->$tmp($k, 'out');
    1877. 

  1877.       $content.= $cont;
    1878. 

  1878.       $xref[] = $pos;
    1879. 

  1879.       $pos+= mb_strlen($cont, '8bit');
    1880. 

  1880.     }
    1881. 

  1881. 

  1882.     $content.= "\nxref\n0 ".(count($xref) +1) ."\n0000000000 65535 f \n";
    1883. 

  1883. 

  1884.     foreach ($xref as $p) {
    1885. 

  1885.       $content.= str_pad($p, 10, "0", STR_PAD_LEFT) . " 00000 n \n";
    1886. 

  1886.     }
    1887. 

  1887. 

  1888.     $content.= "trailer\n<<\n/Size ".(count($xref) +1) ."\n/Root 1 0 R\n/Info $this->infoObject 0 R\n";
    1889. 

  1889. 

  1890.     // if encryption has been applied to this document then add the marker for this dictionary
    1891. 

  1891.     if ($this->arc4_objnum > 0) {
    1892. 

  1892.       $content.= "/Encrypt $this->arc4_objnum 0 R\n";
    1893. 

  1893.     }
    1894. 

  1894. 

  1895.     if (mb_strlen($this->fileIdentifier, '8bit')) {
    1896. 

  1896.       $content.= "/ID[<$this->fileIdentifier><$this->fileIdentifier>]\n";
    1897. 

  1897.     }
    1898. 

  1898. 

  1899.     $content.= ">>\nstartxref\n$pos\n%%EOF\n";
    1900. 

  1900. 

  1901.     return $content;
    1902. 

  1902.   }
    1903. 

  1903. 

  1904.   /**
    1905. 

  1905.    * intialize a new document
    1906. 

  1906.    * if this is called on an existing document results may be unpredictable, but the existing document would be lost at minimum
    1907. 

  1907.    * this function is called automatically by the constructor function
    1908. 

  1908.    */
    1909. 

  1909.   private function newDocument($pageSize = array(0, 0, 612, 792)) {
    1910. 

  1910.     $this->numObj = 0;
    1911. 

  1911.     $this->objects = array();
    1912. 

  1912. 

  1913.     $this->numObj++;
    1914. 

  1914.     $this->o_catalog($this->numObj, 'new');
    1915. 

  1915. 

  1916.     $this->numObj++;
    1917. 

  1917.     $this->o_outlines($this->numObj, 'new');
    1918. 

  1918. 

  1919.     $this->numObj++;
    1920. 

  1920.     $this->o_pages($this->numObj, 'new');
    1921. 

  1921. 

  1922.     $this->o_pages($this->numObj, 'mediaBox', $pageSize);
    1923. 

  1923.     $this->currentNode = 3;
    1924. 

  1924. 

  1925.     $this->numObj++;
    1926. 

  1926.     $this->o_procset($this->numObj, 'new');
    1927. 

  1927. 

  1928.     $this->numObj++;
    1929. 

  1929.     $this->o_info($this->numObj, 'new');
    1930. 

  1930. 

  1931.     $this->numObj++;
    1932. 

  1932.     $this->o_page($this->numObj, 'new');
    1933. 

  1933. 

  1934.     // need to store the first page id as there is no way to get it to the user during
    1935. 

  1935.     // startup
    1936. 

  1936.     $this->firstPageId = $this->currentContents;
    1937. 

  1937.   }
    1938. 

  1938. 

  1939.   /**
    1940. 

  1940.    * open the font file and return a php structure containing it.
    1941. 

  1941.    * first check if this one has been done before and saved in a form more suited to php
    1942. 

  1942.    * note that if a php serialized version does not exist it will try and make one, but will
    1943. 

  1943.    * require write access to the directory to do it... it is MUCH faster to have these serialized
    1944. 

  1944.    * files.
    1945. 

  1945.    */
    1946. 

  1946.   private function openFont($font) {
    1947. 

  1947.     // assume that $font contains the path and file but not the extension
    1948. 

  1948.     $pos = strrpos($font, '/');
    1949. 

  1949. 

  1950.     if ($pos === false) {
    1951. 

  1951.       $dir = './';
    1952. 

  1952.       $name = $font;
    1953. 

  1953.     } else {
    1954. 

  1954.       $dir = substr($font, 0, $pos+1);
    1955. 

  1955.       $name = substr($font, $pos+1);
    1956. 

  1956.     }
    1957. 

  1957. 

  1958.     $fontcache = $this->fontcache;
    1959. 

  1959.     if ($fontcache == '') {
    1960. 

  1960.       $fontcache = $dir;
    1961. 

  1961.     }
    1962. 

  1962. 

  1963.     //$name       filename without folder and extension of font metrics
    1964. 

  1964.     //$dir      folder of font metrics
    1965. 

  1965.     //$fontcache  folder of runtime created php serialized version of font metrics.
    1966. 

  1966.     //            If this is not given, the same folder as the font metrics will be used.
    1967. 

  1967.     //            Storing and reusing serialized versions improves speed much
    1968. 

  1968. 

  1969.     $this->addMessage("openFont: $font - $name");
    1970. 

  1970. 

  1971.     if ( !$this->isUnicode || in_array(mb_strtolower(basename($name)), self::$coreFonts) ) {
    1972. 

  1972.       $metrics_name = "$name.afm";
    1973. 

  1973.     }
    1974. 

  1974.     else {
    1975. 

  1975.       $metrics_name = "$name.ufm";
    1976. 

  1976.     }
    1977. 

  1977. 

  1978.     $cache_name = "$metrics_name.php";
    1979. 

  1979.     $this->addMessage("metrics: $metrics_name, cache: $cache_name");
    1980. 

  1980. 

  1981.     if (file_exists($fontcache . $cache_name)) {
    1982. 

  1982.       $this->addMessage("openFont: php file exists $fontcache$cache_name");
    1983. 

  1983.       $this->fonts[$font] = require($fontcache . $cache_name);
    1984. 

  1984. 

  1985.       if (!isset($this->fonts[$font]['_version_']) || $this->fonts[$font]['_version_'] != $this->fontcacheVersion) {
    1986. 

  1986.         // if the font file is old, then clear it out and prepare for re-creation
    1987. 

  1987.         $this->addMessage('openFont: clear out, make way for new version.');
    1988. 

  1988.         $this->fonts[$font] = null;
    1989. 

  1989.         unset($this->fonts[$font]);
    1990. 

  1990.       }
    1991. 

  1991.     }
    1992. 

  1992.     else {
    1993. 

  1993.       $old_cache_name = "php_$metrics_name";
    1994. 

  1994.       if (file_exists($fontcache . $old_cache_name)) {
    1995. 

  1995.         $this->addMessage("openFont: php file doesn't exist $fontcache$cache_name, creating it from the old format");
    1996. 

  1996.         $old_cache = file_get_contents($fontcache . $old_cache_name);
    1997. 

  1997.         file_put_contents($fontcache . $cache_name, '<?php return ' . $old_cache . ';');
    1998. 

  1998.         return $this->openFont($font);
    1999. 

  1999.       }
    2000. 

  2000.     }
    2001. 

  2001. 

  2002.     if (!isset($this->fonts[$font]) && file_exists($dir . $metrics_name)) {
    2003. 

  2003.       // then rebuild the php_<font>.afm file from the <font>.afm file
    2004. 

  2004.       $this->addMessage("openFont: build php file from $dir$metrics_name");
    2005. 

  2005.       $data = array();
    2006. 

  2006. 

  2007.       // 20 => 'space'
    2008. 

  2008.       $data['codeToName'] = array(); 
    2009. 

  2009. 

  2010.       // Since we're not going to enable Unicode for the core fonts we need to use a font-based
    2011. 

  2011.       // setting for Unicode support rather than a global setting.
    2012. 

  2012.       $data['isUnicode'] = (strtolower(substr($metrics_name, -3)) !== 'afm');
    2013. 

  2013. 

  2014.       $cidtogid = '';
    2015. 

  2015.       if ($data['isUnicode']) {
    2016. 

  2016.         $cidtogid = str_pad('', 256*256*2, "\x00");
    2017. 

  2017.       }
    2018. 

  2018. 

  2019.       $file = file($dir . $metrics_name);
    2020. 

  2020. 

  2021.       foreach ($file as $rowA) {
    2022. 

  2022.         $row = trim($rowA);
    2023. 

  2023.         $pos = strpos($row, ' ');
    2024. 

  2024. 

  2025.         if ($pos) {
    2026. 

  2026.           // then there must be some keyword
    2027. 

  2027.           $key = substr($row, 0, $pos);
    2028. 

  2028.           switch ($key) {
    2029. 

  2029.           case 'FontName':
    2030. 

  2030.           case 'FullName':
    2031. 

  2031.           case 'FamilyName':
    2032. 

  2032.           case 'PostScriptName':
    2033. 

  2033.           case 'Weight':
    2034. 

  2034.           case 'ItalicAngle':
    2035. 

  2035.           case 'IsFixedPitch':
    2036. 

  2036.           case 'CharacterSet':
    2037. 

  2037.           case 'UnderlinePosition':
    2038. 

  2038.           case 'UnderlineThickness':
    2039. 

  2039.           case 'Version':
    2040. 

  2040.           case 'EncodingScheme':
    2041. 

  2041.           case 'CapHeight':
    2042. 

  2042.           case 'XHeight':
    2043. 

  2043.           case 'Ascender':
    2044. 

  2044.           case 'Descender':
    2045. 

  2045.           case 'StdHW':
    2046. 

  2046.           case 'StdVW':
    2047. 

  2047.           case 'StartCharMetrics':
    2048. 

  2048.           case 'FontHeightOffset': // OAR - Added so we can offset the height calculation of a Windows font.  Otherwise it's too big.
    2049. 

  2049.             $data[$key] = trim(substr($row, $pos));
    2050. 

  2050.             break;
    2051. 

  2051. 

  2052.           case 'FontBBox':
    2053. 

  2053.             $data[$key] = explode(' ', trim(substr($row, $pos)));
    2054. 

  2054.             break;
    2055. 

  2055. 

  2056.           //C 39 ; WX 222 ; N quoteright ; B 53 463 157 718 ;
    2057. 

  2057.           case 'C': // Found in AFM files
    2058. 

  2058.             $bits = explode(';', trim($row));
    2059. 

  2059.             $dtmp = array();
    2060. 

  2060. 

  2061.             foreach ($bits as $bit) {
    2062. 

  2062.               $bits2 = explode(' ', trim($bit));
    2063. 

  2063.               if (mb_strlen($bits2[0], '8bit') == 0) continue;
    2064. 

  2064. 

  2065.               if (count($bits2) > 2) {
    2066. 

  2066.                 $dtmp[$bits2[0]] = array();
    2067. 

  2067.                 for ($i = 1; $i < count($bits2); $i++) {
    2068. 

  2068.                   $dtmp[$bits2[0]][] = $bits2[$i];
    2069. 

  2069.                 }
    2070. 

  2070.               } else if (count($bits2) == 2) {
    2071. 

  2071.                 $dtmp[$bits2[0]] = $bits2[1];
    2072. 

  2072.               }
    2073. 

  2073.             }
    2074. 

  2074. 

  2075.             $c = (int)$dtmp['C'];
    2076. 

  2076.             $n = $dtmp['N'];
    2077. 

  2077.             $width = floatval($dtmp['WX']);
    2078. 

  2078. 

  2079.             if ($c >= 0) {
    2080. 

  2080.               if ($c != hexdec($n)) {
    2081. 

  2081.                 $data['codeToName'][$c] = $n;
    2082. 

  2082.               }
    2083. 

  2083.               $data['C'][$c] = $width;
    2084. 

  2084.             } else {
    2085. 

  2085.               $data['C'][$n] = $width;
    2086. 

  2086.             }
    2087. 

  2087. 

  2088.             if (!isset($data['MissingWidth']) && $c == -1 && $n === '.notdef') {
    2089. 

  2089.               $data['MissingWidth'] = $width;
    2090. 

  2090.             }
    2091. 

  2091. 

  2092.             break;
    2093. 

  2093. 

  2094.           // U 827 ; WX 0 ; N squaresubnosp ; G 675 ;
    2095. 

  2095.           case 'U': // Found in UFM files
    2096. 

  2096.             if (!$data['isUnicode']) break;
    2097. 

  2097. 

  2098.             $bits = explode(';', trim($row));
    2099. 

  2099.             $dtmp = array();
    2100. 

  2100. 

  2101.             foreach ($bits as $bit) {
    2102. 

  2102.               $bits2 = explode(' ', trim($bit));
    2103. 

  2103.               if (mb_strlen($bits2[0], '8bit') === 0) continue;
    2104. 

  2104. 

  2105.               if (count($bits2) > 2) {
    2106. 

  2106.                 $dtmp[$bits2[0]] = array();
    2107. 

  2107.                 for ($i = 1; $i < count($bits2); $i++) {
    2108. 

  2108.                   $dtmp[$bits2[0]][] = $bits2[$i];
    2109. 

  2109.                 }
    2110. 

  2110.               } else if (count($bits2) == 2) {
    2111. 

  2111.                 $dtmp[$bits2[0]] = $bits2[1];
    2112. 

  2112.               }
    2113. 

  2113.             }
    2114. 

  2114. 

  2115.             $c = (int)$dtmp['U'];
    2116. 

  2116.             $n = $dtmp['N'];
    2117. 

  2117.             $glyph = $dtmp['G'];
    2118. 

  2118.             $width = floatval($dtmp['WX']);
    2119. 

  2119. 

  2120.             if ($c >= 0) {
    2121. 

  2121.               // Set values in CID to GID map
    2122. 

  2122.               if ($c >= 0 && $c < 0xFFFF && $glyph) {
    2123. 

  2123.                 $cidtogid[$c*2] = chr($glyph >> 8);
    2124. 

  2124.                 $cidtogid[$c*2 + 1] = chr($glyph & 0xFF);
    2125. 

  2125.               }
    2126. 

  2126. 

  2127.               if ($c != hexdec($n)) {
    2128. 

  2128.                 $data['codeToName'][$c] = $n;
    2129. 

  2129.               }
    2130. 

  2130.               $data['C'][$c] = $width;
    2131. 

  2131.             } else {
    2132. 

  2132.               $data['C'][$n] = $width;
    2133. 

  2133.             }
    2134. 

  2134. 

  2135.             if (!isset($data['MissingWidth']) && $c == -1 && $n === '.notdef') {
    2136. 

  2136.               $data['MissingWidth'] = $width;
    2137. 

  2137.             }
    2138. 

  2138. 

  2139.             break;
    2140. 

  2140. 

  2141.           case 'KPX':
    2142. 

  2142.             break; // don't include them as they are not used yet
    2143. 

  2143.             //KPX Adieresis yacute -40
    2144. 

  2144.             $bits = explode(' ', trim($row));
    2145. 

  2145.             $data['KPX'][$bits[1]][$bits[2]] = $bits[3];
    2146. 

  2146.             break;
    2147. 

  2147.           }
    2148. 

  2148.         }
    2149. 

  2149.       }
    2150. 

  2150. 

  2151.       if ($this->compressionReady && $this->options['compression']) {
    2152. 

  2152.         // then implement ZLIB based compression on CIDtoGID string
    2153. 

  2153.         $data['CIDtoGID_Compressed'] = true;
    2154. 

  2154.         $cidtogid = gzcompress($cidtogid, 6);
    2155. 

  2155.       }
    2156. 

  2156.       $data['CIDtoGID'] = base64_encode($cidtogid);
    2157. 

  2157.       $data['_version_'] = $this->fontcacheVersion;
    2158. 

  2158.       $this->fonts[$font] = $data;
    2159. 

  2159. 

  2160.       //Because of potential trouble with php safe mode, expect that the folder already exists.
    2161. 

  2161.       //If not existing, this will hit performance because of missing cached results.
    2162. 

  2162.       if ( is_dir(substr($fontcache, 0, -1)) && is_writable(substr($fontcache, 0, -1)) ) {
    2163. 

  2163.         file_put_contents($fontcache . $cache_name, '<?php return ' . var_export($data, true) . ';');
    2164. 

  2164.       }
    2165. 

  2165.       $data = null;
    2166. 

  2166.     }
    2167. 

  2167. 

  2168.     if (!isset($this->fonts[$font])) {
    2169. 

  2169.       $this->addMessage("openFont: no font file found for $font. Do you need to run load_font.php?");
    2170. 

  2170.     }
    2171. 

  2171. 

  2172.     //pre_r($this->messages);
    2173. 

  2173.   }
    2174. 

  2174. 

  2175.   /**
    2176. 

  2176.    * if the font is not loaded then load it and make the required object
    2177. 

  2177.    * else just make it the current font
    2178. 

  2178.    * the encoding array can contain 'encoding'=> 'none','WinAnsiEncoding','MacRomanEncoding' or 'MacExpertEncoding'
    2179. 

  2179.    * note that encoding='none' will need to be used for symbolic fonts
    2180. 

  2180.    * and 'differences' => an array of mappings between numbers 0->255 and character names.
    2181. 

  2181.    *
    2182. 

  2182.    */
    2183. 

  2183.   function selectFont($fontName, $encoding = '', $set = true) {
    2184. 

  2184.     $ext = substr($fontName, -4);
    2185. 

  2185.     if ($ext === '.afm' || $ext === '.ufm') {
    2186. 

  2186.       $fontName = substr($fontName, 0, mb_strlen($fontName)-4);
    2187. 

  2187.     }
    2188. 

  2188. 

  2189.     if (!isset($this->fonts[$fontName])) {
    2190. 

  2190.       $this->addMessage("selectFont: selecting - $fontName - $encoding, $set");
    2191. 

  2191. 

  2192.       // load the file
    2193. 

  2193.       $this->openFont($fontName);
    2194. 

  2194. 

  2195.       if (isset($this->fonts[$fontName])) {
    2196. 

  2196.         $this->numObj++;
    2197. 

  2197.         $this->numFonts++;
    2198. 

  2198. 

  2199.         $font = &$this->fonts[$fontName];
    2200. 

  2200. 

  2201.         //$this->numFonts = md5($fontName);
    2202. 

  2202.         $pos = strrpos($fontName, '/');
    2203. 

  2203.         //      $dir = substr($fontName,0,$pos+1);
    2204. 

  2204.         $name = substr($fontName, $pos+1);
    2205. 

  2205.         $options = array('name' => $name, 'fontFileName' => $fontName);
    2206. 

  2206. 

  2207.         if (is_array($encoding)) {
    2208. 

  2208.           // then encoding and differences might be set
    2209. 

  2209.           if (isset($encoding['encoding'])) {
    2210. 

  2210.             $options['encoding'] = $encoding['encoding'];
    2211. 

  2211.           }
    2212. 

  2212. 

  2213.           if (isset($encoding['differences'])) {
    2214. 

  2214.             $options['differences'] = $encoding['differences'];
    2215. 

  2215.           }
    2216. 

  2216.         } else if (mb_strlen($encoding, '8bit')) {
    2217. 

  2217.           // then perhaps only the encoding has been set
    2218. 

  2218.           $options['encoding'] = $encoding;
    2219. 

  2219.         }
    2220. 

  2220. 

  2221.         $fontObj = $this->numObj;
    2222. 

  2222.         $this->o_font($this->numObj, 'new', $options);
    2223. 

  2223.         $font['fontNum'] = $this->numFonts;
    2224. 

  2224. 

  2225.         // if this is a '.afm' font, and there is a '.pfa' file to go with it ( as there
    2226. 

  2226.         // should be for all non-basic fonts), then load it into an object and put the
    2227. 

  2227.         // references into the font object
    2228. 

  2228.         $basefile = $fontName;
    2229. 

  2229. 

  2230.         $fbtype = '';
    2231. 

  2231.         if (file_exists("$basefile.pfb")) {
    2232. 

  2232.           $fbtype = 'pfb';
    2233. 

  2233.         } 
    2234. 

  2234.         else if (file_exists("$basefile.ttf")) {
    2235. 

  2235.           $fbtype = 'ttf';
    2236. 

  2236.         }
    2237. 

  2237. 

  2238.         $fbfile = "$basefile.$fbtype";
    2239. 

  2239. 

  2240.         //      $pfbfile = substr($fontName,0,strlen($fontName)-4).'.pfb';
    2241. 

  2241.         //      $ttffile = substr($fontName,0,strlen($fontName)-4).'.ttf';
    2242. 

  2242.         $this->addMessage('selectFont: checking for - '.$fbfile);
    2243. 

  2243. 

  2244.         // OAR - I don't understand this old check
    2245. 

  2245.         // if (substr($fontName, -4) ===  '.afm' &&  strlen($fbtype)) {
    2246. 

  2246.         if ($fbtype) {
    2247. 

  2247.           $adobeFontName = isset($font['PostScriptName']) ? $font['PostScriptName'] : $font['FontName'];
    2248. 

  2248.           //        $fontObj = $this->numObj;
    2249. 

  2249.           $this->addMessage("selectFont: adding font file - $fbfile - $adobeFontName");
    2250. 

  2250. 

  2251.           // find the array of font widths, and put that into an object.
    2252. 

  2252.           $firstChar = -1;
    2253. 

  2253.           $lastChar = 0;
    2254. 

  2254.           $widths = array();
    2255. 

  2255.           $cid_widths = array();
    2256. 

  2256. 

  2257.           foreach ($font['C'] as $num => $d) {
    2258. 

  2258.             if (intval($num) > 0 || $num == '0') {
    2259. 

  2259.               if (!$font['isUnicode']) {
    2260. 

  2260.                 // With Unicode, widths array isn't used
    2261. 

  2261.                 if ($lastChar>0 && $num>$lastChar+1) {
    2262. 

  2262.                   for ($i = $lastChar+1; $i<$num; $i++) {
    2263. 

  2263.                     $widths[] = 0;
    2264. 

  2264.                   }
    2265. 

  2265.                 }
    2266. 

  2266.               }
    2267. 

  2267. 

  2268.               $widths[] = $d;
    2269. 

  2269. 

  2270.               if ($font['isUnicode']) {
    2271. 

  2271.                 $cid_widths[$num] = $d;
    2272. 

  2272.               }
    2273. 

  2273. 

  2274.               if ($firstChar == -1) {
    2275. 

  2275.                 $firstChar = $num;
    2276. 

  2276.               }
    2277. 

  2277. 

  2278.               $lastChar = $num;
    2279. 

  2279.             }
    2280. 

  2280.           }
    2281. 

  2281. 

  2282.           // also need to adjust the widths for the differences array
    2283. 

  2283.           if (isset($options['differences'])) {
    2284. 

  2284.             foreach ($options['differences'] as $charNum => $charName) {
    2285. 

  2285.               if ($charNum > $lastChar) {
    2286. 

  2286.                 if (!$font['isUnicode']) {
    2287. 

  2287.                   // With Unicode, widths array isn't used
    2288. 

  2288.                   for ($i = $lastChar + 1; $i <= $charNum; $i++) {
    2289. 

  2289.                     $widths[] = 0;
    2290. 

  2290.                   }
    2291. 

  2291.                 }
    2292. 

  2292. 

  2293.                 $lastChar = $charNum;
    2294. 

  2294.               }
    2295. 

  2295. 

  2296.               if (isset($font['C'][$charName])) {
    2297. 

  2297.                 $widths[$charNum-$firstChar] = $font['C'][$charName];
    2298. 

  2298.                 if ($font['isUnicode']) {
    2299. 

  2299.                   $cid_widths[$charName] = $font['C'][$charName];
    2300. 

  2300.                 }
    2301. 

  2301.               }
    2302. 

  2302.             }
    2303. 

  2303.           }
    2304. 

  2304. 

  2305.           if ($font['isUnicode']) {
    2306. 

  2306.             $font['CIDWidths'] = $cid_widths;
    2307. 

  2307.           }
    2308. 

  2308. 

  2309.           $this->addMessage('selectFont: FirstChar = '.$firstChar);
    2310. 

  2310.           $this->addMessage('selectFont: LastChar = '.$lastChar);
    2311. 

  2311. 

  2312.           $widthid = -1;
    2313. 

  2313. 

  2314.           if (!$font['isUnicode']) {
    2315. 

  2315.             // With Unicode, widths array isn't used
    2316. 

  2316. 

  2317.             $this->numObj++;
    2318. 

  2318.             $this->o_contents($this->numObj, 'new', 'raw');
    2319. 

  2319.             $this->objects[$this->numObj]['c'].= '['.implode(' ', $widths).']';
    2320. 

  2320.             $widthid = $this->numObj;
    2321. 

  2321.           }
    2322. 

  2322. 

  2323.           $missing_width = 500;
    2324. 

  2324.           $stemV = 70;
    2325. 

  2325. 

  2326.           if (isset($font['MissingWidth'])) {
    2327. 

  2327.             $missing_width = $font['MissingWidth'];
    2328. 

  2328.           }
    2329. 

  2329.           if (isset($font['StdVW'])) {
    2330. 

  2330.             $stemV = $font['StdVW'];
    2331. 

  2331.           } else if (isset($font['Weight']) && preg_match('!(bold|black)!i', $font['Weight'])) {
    2332. 

  2332.             $stemV = 120;
    2333. 

  2333.           }
    2334. 

  2334. 

  2335.           // load the pfb file, and put that into an object too.
    2336. 

  2336.           // note that pdf supports only binary format type 1 font files, though there is a
    2337. 

  2337.           // simple utility to convert them from pfa to pfb.
    2338. 

  2338.           if (!$this->isUnicode || $fbtype !== 'ttf' || empty($this->stringSubsets)) {
    2339. 

  2339.             $data = file_get_contents($fbfile);
    2340. 

  2340.           }
    2341. 

  2341.           else {
    2342. 

  2342.             $this->stringSubsets[$fontName][] = 32; // Force space if not in yet
    2343. 

  2343. 

  2344.             $subset = $this->stringSubsets[$fontName];
    2345. 

  2345.             sort($subset);
    2346. 

  2346. 

  2347.             // Load font
    2348. 

  2348.             $font_obj = Font::load($fbfile);
    2349. 

  2349.             $font_obj->parse();
    2350. 

  2350. 

  2351.             // Define subset
    2352. 

  2352.             $font_obj->setSubset($subset);
    2353. 

  2353.             $font_obj->reduce();
    2354. 

  2354. 

  2355.             // Write new font
    2356. 

  2356.             $tmp_name = "$fbfile.tmp.".uniqid();
    2357. 

  2357.             $font_obj->open($tmp_name, Font_Binary_Stream::modeWrite);
    2358. 

  2358.             $font_obj->encode(array("OS/2"));
    2359. 

  2359.             $font_obj->close();
    2360. 

  2360. 

  2361.             // Parse the new font to get cid2gid and widths
    2362. 

  2362.             $font_obj = Font::load($tmp_name);
    2363. 

  2363. 

  2364.             // Find Unicode char map table
    2365. 

  2365.             $subtable = null;
    2366. 

  2366.             foreach ($font_obj->getData("cmap", "subtables") as $_subtable) {
    2367. 

  2367.               if ($_subtable["platformID"] == 0 || $_subtable["platformID"] == 3 && $_subtable["platformSpecificID"] == 1) {
    2368. 

  2368.                 $subtable = $_subtable;
    2369. 

  2369.                 break;
    2370. 

  2370.               }
    2371. 

  2371.             }
    2372. 

  2372. 

  2373.             if ($subtable) {
    2374. 

  2374.               $glyphIndexArray = $subtable["glyphIndexArray"];
    2375. 

  2375.               $hmtx = $font_obj->getData("hmtx");
    2376. 

  2376. 

  2377.               unset($glyphIndexArray[0xFFFF]);
    2378. 

  2378. 

  2379.               $cidtogid = str_pad('', max(array_keys($glyphIndexArray))*2+1, "\x00");
    2380. 

  2380.               $font['CIDWidths'] = array();
    2381. 

  2381.               foreach ($glyphIndexArray as $cid => $gid) {
    2382. 

  2382.                 if ($cid >= 0 && $cid < 0xFFFF && $gid) {
    2383. 

  2383.                   $cidtogid[$cid*2] = chr($gid >> 8);
    2384. 

  2384.                   $cidtogid[$cid*2 + 1] = chr($gid & 0xFF);
    2385. 

  2385.                 }
    2386. 

  2386. 

  2387.                 $width = $font_obj->normalizeFUnit(isset($hmtx[$gid]) ? $hmtx[$gid][0] : $hmtx[0][0]);
    2388. 

  2388.                 $font['CIDWidths'][$cid] = $width;
    2389. 

  2389.               }
    2390. 

  2390. 

  2391.               $font['CIDtoGID'] = base64_encode(gzcompress($cidtogid));
    2392. 

  2392.               $font['CIDtoGID_Compressed'] = true;
    2393. 

  2393. 

  2394.               $data = file_get_contents($tmp_name);
    2395. 

  2395.             }
    2396. 

  2396.             else {
    2397. 

  2397.               $data = file_get_contents($fbfile);
    2398. 

  2398.             }
    2399. 

  2399. 

  2400.             $font_obj->close();
    2401. 

  2401.             unlink($tmp_name);
    2402. 

  2402.           }
    2403. 

  2403. 

  2404.           // create the font descriptor
    2405. 

  2405.           $this->numObj++;
    2406. 

  2406.           $fontDescriptorId = $this->numObj;
    2407. 

  2407. 

  2408.           $this->numObj++;
    2409. 

  2409.           $pfbid = $this->numObj;
    2410. 

  2410. 

  2411.           // determine flags (more than a little flakey, hopefully will not matter much)
    2412. 

  2412.           $flags = 0;
    2413. 

  2413. 

  2414.           if ($font['ItalicAngle'] != 0) {
    2415. 

  2415.             $flags+= pow(2, 6);
    2416. 

  2416.           }
    2417. 

  2417. 

  2418.           if ($font['IsFixedPitch'] === 'true') {
    2419. 

  2419.             $flags+= 1;
    2420. 

  2420.           }
    2421. 

  2421. 

  2422.           $flags+= pow(2, 5); // assume non-sybolic
    2423. 

  2423.           $list = array(
    2424. 

  2424.             'Ascent' => 'Ascender',
    2425. 

  2425.             'CapHeight' => 'CapHeight',
    2426. 

  2426.             'MissingWidth' => 'MissingWidth',
    2427. 

  2427.             'Descent' => 'Descender',
    2428. 

  2428.             'FontBBox' => 'FontBBox',
    2429. 

  2429.             'ItalicAngle' => 'ItalicAngle'
    2430. 

  2430.           );
    2431. 

  2431.           $fdopt = array(
    2432. 

  2432.             'Flags' => $flags,
    2433. 

  2433.             'FontName' => $adobeFontName,
    2434. 

  2434.             'StemV' => $stemV
    2435. 

  2435.           );
    2436. 

  2436. 

  2437.           foreach ($list as $k => $v) {
    2438. 

  2438.             if (isset($font[$v])) {
    2439. 

  2439.               $fdopt[$k] = $font[$v];
    2440. 

  2440.             }
    2441. 

  2441.           }
    2442. 

  2442. 

  2443.           if ($fbtype === 'pfb') {
    2444. 

  2444.             $fdopt['FontFile'] = $pfbid;
    2445. 

  2445.           } else if ($fbtype === 'ttf') {
    2446. 

  2446.             $fdopt['FontFile2'] = $pfbid;
    2447. 

  2447.           }
    2448. 

  2448. 

  2449.           $this->o_fontDescriptor($fontDescriptorId, 'new', $fdopt);
    2450. 

  2450. 

  2451.           // embed the font program
    2452. 

  2452.           $this->o_contents($this->numObj, 'new');
    2453. 

  2453.           $this->objects[$pfbid]['c'].= $data;
    2454. 

  2454. 

  2455.           // determine the cruicial lengths within this file
    2456. 

  2456.           if ($fbtype === 'pfb') {
    2457. 

  2457.             $l1 = strpos($data, 'eexec') +6;
    2458. 

  2458.             $l2 = strpos($data, '00000000') -$l1;
    2459. 

  2459.             $l3 = mb_strlen($data, '8bit') -$l2-$l1;
    2460. 

  2460.             $this->o_contents($this->numObj, 'add', array('Length1' => $l1, 'Length2' => $l2, 'Length3' => $l3));
    2461. 

  2461.           } else if ($fbtype == 'ttf') {
    2462. 

  2462.             $l1 = mb_strlen($data, '8bit');
    2463. 

  2463.             $this->o_contents($this->numObj, 'add', array('Length1' => $l1));
    2464. 

  2464.           }
    2465. 

  2465. 

  2466.           // tell the font object about all this new stuff
    2467. 

  2467.           $tmp = array(
    2468. 

  2468.             'BaseFont' => $adobeFontName,
    2469. 

  2469.             'MissingWidth' => $missing_width,
    2470. 

  2470.             'Widths' => $widthid,
    2471. 

  2471.             'FirstChar' => $firstChar,
    2472. 

  2472.             'LastChar' => $lastChar,
    2473. 

  2473.             'FontDescriptor' => $fontDescriptorId
    2474. 

  2474.           );
    2475. 

  2475. 

  2476.           if ($fbtype === 'ttf') {
    2477. 

  2477.             $tmp['SubType'] = 'TrueType';
    2478. 

  2478.           }
    2479. 

  2479. 

  2480.           $this->addMessage("adding extra info to font.($fontObj)");
    2481. 

  2481. 

  2482.           foreach ($tmp as $fk => $fv) {
    2483. 

  2483.             $this->addMessage("$fk : $fv");
    2484. 

  2484.           }
    2485. 

  2485. 

  2486.           $this->o_font($fontObj, 'add', $tmp);
    2487. 

  2487.         } else {
    2488. 

  2488.           $this->addMessage('selectFont: pfb or ttf file not found, ok if this is one of the 14 standard fonts');
    2489. 

  2489.         }
    2490. 

  2490. 

  2491.         // also set the differences here, note that this means that these will take effect only the
    2492. 

  2492.         //first time that a font is selected, else they are ignored
    2493. 

  2493.         if (isset($options['differences'])) {
    2494. 

  2494.           $font['differences'] = $options['differences'];
    2495. 

  2495.         }
    2496. 

  2496.       }
    2497. 

  2497.     }
    2498. 

  2498. 

  2499.     if ($set && isset($this->fonts[$fontName])) {
    2500. 

  2500.       // so if for some reason the font was not set in the last one then it will not be selected
    2501. 

  2501.       $this->currentBaseFont = $fontName;
    2502. 

  2502. 

  2503.       // the next lines mean that if a new font is selected, then the current text state will be
    2504. 

  2504.       // applied to it as well.
    2505. 

  2505.       $this->currentFont = $this->currentBaseFont;
    2506. 

  2506.       $this->currentFontNum = $this->fonts[$this->currentFont]['fontNum'];
    2507. 

  2507. 

  2508.       //$this->setCurrentFont();
    2509. 

  2509.     }
    2510. 

  2510. 

  2511.     return $this->currentFontNum;
    2512. 

  2512.     //return $this->numObj;
    2513. 

  2513.   }
    2514. 

  2514. 

  2515.   /**
    2516. 

  2516.    * sets up the current font, based on the font families, and the current text state
    2517. 

  2517.    * note that this system is quite flexible, a bold-italic font can be completely different to a
    2518. 

  2518.    * italic-bold font, and even bold-bold will have to be defined within the family to have meaning
    2519. 

  2519.    * This function is to be called whenever the currentTextState is changed, it will update
    2520. 

  2520.    * the currentFont setting to whatever the appropriatte family one is.
    2521. 

  2521.    * If the user calls selectFont themselves then that will reset the currentBaseFont, and the currentFont
    2522. 

  2522.    * This function will change the currentFont to whatever it should be, but will not change the
    2523. 

  2523.    * currentBaseFont.
    2524. 

  2524.    */
    2525. 

  2525.   private function setCurrentFont() {
    2526. 

  2526.     //   if (strlen($this->currentBaseFont) == 0){
    2527. 

  2527.     //     // then assume an initial font
    2528. 

  2528.     //     $this->selectFont($this->defaultFont);
    2529. 

  2529.     //   }
    2530. 

  2530.     //   $cf = substr($this->currentBaseFont,strrpos($this->currentBaseFont,'/')+1);
    2531. 

  2531.     //   if (strlen($this->currentTextState)
    2532. 

  2532.     //     && isset($this->fontFamilies[$cf])
    2533. 

  2533.     //       && isset($this->fontFamilies[$cf][$this->currentTextState])){
    2534. 

  2534.     //     // then we are in some state or another
    2535. 

  2535.     //     // and this font has a family, and the current setting exists within it
    2536. 

  2536.     //     // select the font, then return it
    2537. 

  2537.     //     $nf = substr($this->currentBaseFont,0,strrpos($this->currentBaseFont,'/')+1).$this->fontFamilies[$cf][$this->currentTextState];
    2538. 

  2538.     //     $this->selectFont($nf,'',0);
    2539. 

  2539.     //     $this->currentFont = $nf;
    2540. 

  2540.     //     $this->currentFontNum = $this->fonts[$nf]['fontNum'];
    2541. 

  2541.     //   } else {
    2542. 

  2542.     //     // the this font must not have the right family member for the current state
    2543. 

  2543.     //     // simply assume the base font
    2544. 

  2544.     $this->currentFont = $this->currentBaseFont;
    2545. 

  2545.     $this->currentFontNum = $this->fonts[$this->currentFont]['fontNum'];
    2546. 

  2546.     //  }
    2547. 

  2547.   }
    2548. 

  2548. 

  2549.   /**
    2550. 

  2550.    * function for the user to find out what the ID is of the first page that was created during
    2551. 

  2551.    * startup - useful if they wish to add something to it later.
    2552. 

  2552.    */
    2553. 

  2553.   function getFirstPageId() {
    2554. 

  2554.     return $this->firstPageId;
    2555. 

  2555.   }
    2556. 

  2556. 

  2557.   /**
    2558. 

  2558.    * add content to the currently active object
    2559. 

  2559.    */
    2560. 

  2560.   private function addContent($content) {
    2561. 

  2561.     $this->objects[$this->currentContents]['c'] .=  $content;
    2562. 

  2562.   }
    2563. 

  2563. 

  2564.   /**
    2565. 

  2565.    * sets the color for fill operations
    2566. 

  2566.    */
    2567. 

  2567.   function setColor($color, $force = false) {
    2568. 

  2568.     $new_color = array($color[0], $color[1], $color[2], isset($color[3]) ? $color[3] : null);
    2569. 

  2569. 

  2570.     if (!$force && $this->currentColor == $new_color) {
    2571. 

  2571.       return;
    2572. 

  2572.     }
    2573. 

  2573. 

  2574.     if (isset($new_color[3])) {
    2575. 

  2575.       $this->currentColor = $new_color;
    2576. 

  2576.       $this->addContent(vsprintf("\n%.3F %.3F %.3F %.3F k", $this->currentColor));
    2577. 

  2577.     }
    2578. 

  2578. 

  2579.     else if (isset($new_color[2])) {
    2580. 

  2580.       $this->currentColor = $new_color;
    2581. 

  2581.       $this->addContent(vsprintf("\n%.3F %.3F %.3F rg", $this->currentColor));
    2582. 

  2582.     }
    2583. 

  2583.   }
    2584. 

  2584. 

  2585.   /**
    2586. 

  2586.    * sets the color for stroke operations
    2587. 

  2587.    */
    2588. 

  2588.   function setStrokeColor($color, $force = false) {
    2589. 

  2589.     $new_color = array($color[0], $color[1], $color[2], isset($color[3]) ? $color[3] : null);
    2590. 

  2590. 

  2591.     if (!$force && $this->currentStrokeColor == $new_color) return;
    2592. 

  2592. 

  2593.     if (isset($new_color[3])) {
    2594. 

  2594.       $this->currentStrokeColor = $new_color;
    2595. 

  2595.       $this->addContent(vsprintf("\n%.3F %.3F %.3F %.3F K", $this->currentStrokeColor));
    2596. 

  2596.     }
    2597. 

  2597. 

  2598.     else if (isset($new_color[2])) {
    2599. 

  2599.       $this->currentStrokeColor = $new_color;
    2600. 

  2600.       $this->addContent(vsprintf("\n%.3F %.3F %.3F RG", $this->currentStrokeColor));
    2601. 

  2601.     }
    2602. 

  2602.   }
    2603. 

  2603. 

  2604.   /**
    2605. 

  2605.    * Set the graphics state for compositions
    2606. 

  2606.    */
    2607. 

  2607.   function setGraphicsState($parameters) {
    2608. 

  2608.     // Create a new graphics state object
    2609. 

  2609.     // FIXME: should actually keep track of states that have already been created...
    2610. 

  2610.     $this->numObj++;
    2611. 

  2611.     $this->o_extGState($this->numObj, 'new', $parameters);
    2612. 

  2612.     $this->addContent("\n/GS$this->numStates gs");
    2613. 

  2613.   }
    2614. 

  2614. 

  2615.   /**
    2616. 

  2616.    * Set current blend mode & opacity for lines.
    2617. 

  2617.    *
    2618. 

  2618.    * Valid blend modes are:
    2619. 

  2619.    *
    2620. 

  2620.    * Normal, Multiply, Screen, Overlay, Darken, Lighten,
    2621. 

  2621.    * ColorDogde, ColorBurn, HardLight, SoftLight, Difference,
    2622. 

  2622.    * Exclusion
    2623. 

  2623.    *
    2624. 

  2624.    * @param string $mode the blend mode to use
    2625. 

  2625.    * @param float $opacity 0.0 fully transparent, 1.0 fully opaque
    2626. 

  2626.    */
    2627. 

  2627.   function setLineTransparency($mode, $opacity) {
    2628. 

  2628.     static $blend_modes = array("Normal", "Multiply", "Screen",
    2629. 

  2629.                                 "Overlay", "Darken", "Lighten",
    2630. 

  2630.                                 "ColorDogde", "ColorBurn", "HardLight",
    2631. 

  2631.                                 "SoftLight", "Difference", "Exclusion");
    2632. 

  2632. 

  2633.     if ( !in_array($mode, $blend_modes) )
    2634. 

  2634.       $mode = "Normal";
    2635. 

  2635. 

  2636.     // Only create a new graphics state if required
    2637. 

  2637.     if ( $mode === $this->currentLineTransparency["mode"] &&
    2638. 

  2638.          $opacity == $this->currentLineTransparency["opacity"] )
    2639. 

  2639.       return;
    2640. 

  2640. 

  2641.     $this->currentLineTransparency["mode"] = $mode;
    2642. 

  2642.     $this->currentLineTransparency["opacity"] = $opacity;
    2643. 

  2643. 

  2644.     $options = array("BM" => "/$mode",
    2645. 

  2645.                      "CA" => (float)$opacity);
    2646. 

  2646. 

  2647.     $this->setGraphicsState($options);
    2648. 

  2648.   }
    2649. 

  2649. 

  2650.   /**
    2651. 

  2651.    * Set current blend mode & opacity for filled objects.
    2652. 

  2652.    *
    2653. 

  2653.    * Valid blend modes are:
    2654. 

  2654.    *
    2655. 

  2655.    * Normal, Multiply, Screen, Overlay, Darken, Lighten,
    2656. 

  2656.    * ColorDogde, ColorBurn, HardLight, SoftLight, Difference,
    2657. 

  2657.    * Exclusion
    2658. 

  2658.    *
    2659. 

  2659.    * @param string $mode the blend mode to use
    2660. 

  2660.    * @param float $opacity 0.0 fully transparent, 1.0 fully opaque
    2661. 

  2661.    */
    2662. 

  2662.   function setFillTransparency($mode, $opacity) {
    2663. 

  2663.     static $blend_modes = array("Normal", "Multiply", "Screen",
    2664. 

  2664.                                 "Overlay", "Darken", "Lighten",
    2665. 

  2665.                                 "ColorDogde", "ColorBurn", "HardLight",
    2666. 

  2666.                                 "SoftLight", "Difference", "Exclusion");
    2667. 

  2667. 

  2668.     if ( !in_array($mode, $blend_modes) ) {
    2669. 

  2669.       $mode = "Normal";
    2670. 

  2670.     }
    2671. 

  2671. 

  2672.     if ( $mode === $this->currentFillTransparency["mode"] &&
    2673. 

  2673.          $opacity == $this->currentFillTransparency["opacity"] ) {
    2674. 

  2674.       return;
    2675. 

  2675.     }
    2676. 

  2676. 

  2677.     $this->currentFillTransparency["mode"] = $mode;
    2678. 

  2678.     $this->currentFillTransparency["opacity"] = $opacity;
    2679. 

  2679. 

  2680.     $options = array(
    2681. 

  2681.       "BM" => "/$mode",
    2682. 

  2682.       "ca" => (float)$opacity,
    2683. 

  2683.     );
    2684. 

  2684. 

  2685.     $this->setGraphicsState($options);
    2686. 

  2686.   }
    2687. 

  2687. 

  2688.   /**
    2689. 

  2689.    * draw a line from one set of coordinates to another
    2690. 

  2690.    */
    2691. 

  2691.   function line($x1, $y1, $x2, $y2, $stroke = true) {
    2692. 

  2692.     $this->addContent(sprintf("\n%.3F %.3F m %.3F %.3F l", $x1, $y1, $x2, $y2));
    2693. 

  2693. 

  2694.     if ($stroke) {
    2695. 

  2695.       $this->addContent(' S');
    2696. 

  2696.     }
    2697. 

  2697.   }
    2698. 

  2698. 

  2699.   /**
    2700. 

  2700.    * draw a bezier curve based on 4 control points
    2701. 

  2701.    */
    2702. 

  2702.   function curve($x0, $y0, $x1, $y1, $x2, $y2, $x3, $y3) {
    2703. 

  2703.     // in the current line style, draw a bezier curve from (x0,y0) to (x3,y3) using the other two points
    2704. 

  2704.     // as the control points for the curve.
    2705. 

  2705.     $this->addContent(sprintf("\n%.3F %.3F m %.3F %.3F %.3F %.3F %.3F %.3F c S", $x0, $y0, $x1, $y1, $x2, $y2, $x3, $y3));
    2706. 

  2706.   }
    2707. 

  2707. 

  2708.   /**
    2709. 

  2709.    * draw a part of an ellipse
    2710. 

  2710.    */
    2711. 

  2711.   function partEllipse($x0, $y0, $astart, $afinish, $r1, $r2 = 0, $angle = 0, $nSeg = 8) {
    2712. 

  2712.     $this->ellipse($x0, $y0, $r1, $r2, $angle, $nSeg, $astart, $afinish, false);
    2713. 

  2713.   }
    2714. 

  2714. 

  2715.   /**
    2716. 

  2716.    * draw a filled ellipse
    2717. 

  2717.    */
    2718. 

  2718.   function filledEllipse($x0, $y0, $r1, $r2 = 0, $angle = 0, $nSeg = 8, $astart = 0, $afinish = 360) {
    2719. 

  2719.     return $this->ellipse($x0, $y0, $r1, $r2, $angle, $nSeg, $astart, $afinish, true, true);
    2720. 

  2720.   }
    2721. 

  2721. 

  2722.   /**
    2723. 

  2723.    * draw an ellipse
    2724. 

  2724.    * note that the part and filled ellipse are just special cases of this function
    2725. 

  2725.    *
    2726. 

  2726.    * draws an ellipse in the current line style
    2727. 

  2727.    * centered at $x0,$y0, radii $r1,$r2
    2728. 

  2728.    * if $r2 is not set, then a circle is drawn
    2729. 

  2729.    * from $astart to $afinish, measured in degrees, running anti-clockwise from the right hand side of the ellipse.
    2730. 

  2730.    * nSeg is not allowed to be less than 2, as this will simply draw a line (and will even draw a
    2731. 

  2731.    * pretty crappy shape at 2, as we are approximating with bezier curves.
    2732. 

  2732.    */
    2733. 

  2733.   function ellipse($x0, $y0, $r1, $r2 = 0, $angle = 0, $nSeg = 8, $astart = 0, $afinish = 360, $close = true, $fill = false, $stroke = true, $incomplete = false) {
    2734. 

  2734.     if ($r1 == 0) {
    2735. 

  2735.       return;
    2736. 

  2736.     }
    2737. 

  2737. 

  2738.     if ($r2 == 0) {
    2739. 

  2739.       $r2 = $r1;
    2740. 

  2740.     }
    2741. 

  2741. 

  2742.     if ($nSeg < 2) {
    2743. 

  2743.       $nSeg = 2;
    2744. 

  2744.     }
    2745. 

  2745. 

  2746.     $astart = deg2rad((float)$astart);
    2747. 

  2747.     $afinish = deg2rad((float)$afinish);
    2748. 

  2748.     $totalAngle = $afinish-$astart;
    2749. 

  2749. 

  2750.     $dt = $totalAngle/$nSeg;
    2751. 

  2751.     $dtm = $dt/3;
    2752. 

  2752. 

  2753.     if ($angle != 0) {
    2754. 

  2754.       $a = -1*deg2rad((float)$angle);
    2755. 

  2755. 

  2756.       $this->addContent(sprintf("\n q %.3F %.3F %.3F %.3F %.3F %.3F cm", cos($a), -sin($a), sin($a), cos($a), $x0, $y0));
    2757. 

  2757. 

  2758.       $x0 = 0;
    2759. 

  2759.       $y0 = 0;
    2760. 

  2760.     }
    2761. 

  2761. 

  2762.     $t1 = $astart;
    2763. 

  2763.     $a0 = $x0 + $r1*cos($t1);
    2764. 

  2764.     $b0 = $y0 + $r2*sin($t1);
    2765. 

  2765.     $c0 = -$r1 * sin($t1);
    2766. 

  2766.     $d0 = $r2 * cos($t1);
    2767. 

  2767. 

  2768.     if (!$incomplete) {
    2769. 

  2769.       $this->addContent(sprintf("\n%.3F %.3F m ", $a0, $b0));
    2770. 

  2770.     }
    2771. 

  2771. 

  2772.     for ($i = 1; $i <= $nSeg; $i++) {
    2773. 

  2773.       // draw this bit of the total curve
    2774. 

  2774.       $t1 = $i * $dt + $astart;
    2775. 

  2775.       $a1 = $x0 + $r1 * cos($t1);
    2776. 

  2776.       $b1 = $y0 + $r2 * sin($t1);
    2777. 

  2777.       $c1 = -$r1 * sin($t1);
    2778. 

  2778.       $d1 = $r2 * cos($t1);
    2779. 

  2779. 

  2780.       $this->addContent(sprintf("\n%.3F %.3F %.3F %.3F %.3F %.3F c", ($a0+$c0*$dtm), ($b0+$d0*$dtm), ($a1-$c1*$dtm), ($b1-$d1*$dtm), $a1, $b1));
    2781. 

  2781. 

  2782.       $a0 = $a1;
    2783. 

  2783.       $b0 = $b1;
    2784. 

  2784.       $c0 = $c1;
    2785. 

  2785.       $d0 = $d1;
    2786. 

  2786.     }
    2787. 

  2787. 

  2788.     if (!$incomplete) {
    2789. 

  2789.       if ($fill) {
    2790. 

  2790.         $this->addContent(' f');
    2791. 

  2791.       }
    2792. 

  2792.       else if ($close) {
    2793. 

  2793.         $this->addContent(' s'); // small 's' signifies closing the path as well
    2794. 

  2794.       }
    2795. 

  2795.       else if ($stroke) {
    2796. 

  2796.         $this->addContent(' S');
    2797. 

  2797.       }
    2798. 

  2798.     }
    2799. 

  2799. 

  2800.     if ($angle != 0) {
    2801. 

  2801.       $this->addContent(' Q');
    2802. 

  2802.     }
    2803. 

  2803.   }
    2804. 

  2804. 

  2805.   /**
    2806. 

  2806.    * this sets the line drawing style.
    2807. 

  2807.    * width, is the thickness of the line in user units
    2808. 

  2808.    * cap is the type of cap to put on the line, values can be 'butt','round','square'
    2809. 

  2809.    *    where the diffference between 'square' and 'butt' is that 'square' projects a flat end past the
    2810. 

  2810.    *    end of the line.
    2811. 

  2811.    * join can be 'miter', 'round', 'bevel'
    2812. 

  2812.    * dash is an array which sets the dash pattern, is a series of length values, which are the lengths of the
    2813. 

  2813.    *   on and off dashes.
    2814. 

  2814.    *   (2) represents 2 on, 2 off, 2 on , 2 off ...
    2815. 

  2815.    *   (2,1) is 2 on, 1 off, 2 on, 1 off.. etc
    2816. 

  2816.    * phase is a modifier on the dash pattern which is used to shift the point at which the pattern starts.
    2817. 

  2817.    */
    2818. 

  2818.   function setLineStyle($width = 1, $cap = '', $join = '', $dash = '', $phase = 0) {
    2819. 

  2819.     // this is quite inefficient in that it sets all the parameters whenever 1 is changed, but will fix another day
    2820. 

  2820.     $string = '';
    2821. 

  2821. 

  2822.     if ($width > 0) {
    2823. 

  2823.       $string.= "$width w";
    2824. 

  2824.     }
    2825. 

  2825. 

  2826.     $ca = array('butt' => 0, 'round' => 1, 'square' => 2);
    2827. 

  2827. 

  2828.     if (isset($ca[$cap])) {
    2829. 

  2829.       $string.= " $ca[$cap] J";
    2830. 

  2830.     }
    2831. 

  2831. 

  2832.     $ja = array('miter' => 0, 'round' => 1, 'bevel' => 2);
    2833. 

  2833. 

  2834.     if (isset($ja[$join])) {
    2835. 

  2835.       $string.= " $ja[$join] j";
    2836. 

  2836.     }
    2837. 

  2837. 

  2838.     if (is_array($dash)) {
    2839. 

  2839.       $string.= ' [ ' . implode(' ', $dash) . " ] $phase d";
    2840. 

  2840.     }
    2841. 

  2841. 

  2842.     $this->currentLineStyle = $string;
    2843. 

  2843.     $this->addContent("\n$string");
    2844. 

  2844.   }
    2845. 

  2845. 

  2846.   /**
    2847. 

  2847.    * draw a polygon, the syntax for this is similar to the GD polygon command
    2848. 

  2848.    */
    2849. 

  2849.   function polygon($p, $np, $f = false) {
    2850. 

  2850.     $this->addContent(sprintf("\n%.3F %.3F m ", $p[0], $p[1]));
    2851. 

  2851. 

  2852.     for ($i = 2; $i < $np * 2; $i = $i + 2) {
    2853. 

  2853.       $this->addContent(sprintf("%.3F %.3F l ", $p[$i], $p[$i+1]));
    2854. 

  2854.     }
    2855. 

  2855. 

  2856.     if ($f) {
    2857. 

  2857.       $this->addContent(' f');
    2858. 

  2858.     } else {
    2859. 

  2859.       $this->addContent(' S');
    2860. 

  2860.     }
    2861. 

  2861.   }
    2862. 

  2862. 

  2863.   /**
    2864. 

  2864.    * a filled rectangle, note that it is the width and height of the rectangle which are the secondary paramaters, not
    2865. 

  2865.    * the coordinates of the upper-right corner
    2866. 

  2866.    */
    2867. 

  2867.   function filledRectangle($x1, $y1, $width, $height) {
    2868. 

  2868.     $this->addContent(sprintf("\n%.3F %.3F %.3F %.3F re f", $x1, $y1, $width, $height));
    2869. 

  2869.   }
    2870. 

  2870. 

  2871.   /**
    2872. 

  2872.    * draw a rectangle, note that it is the width and height of the rectangle which are the secondary paramaters, not
    2873. 

  2873.    * the coordinates of the upper-right corner
    2874. 

  2874.    */
    2875. 

  2875.   function rectangle($x1, $y1, $width, $height) {
    2876. 

  2876.     $this->addContent(sprintf("\n%.3F %.3F %.3F %.3F re S", $x1, $y1, $width, $height));
    2877. 

  2877.   }
    2878. 

  2878. 

  2879.   /**
    2880. 

  2880.    * save the current graphic state
    2881. 

  2881.    */
    2882. 

  2882.   function save() {
    2883. 

  2883.     // we must reset the color cache or it will keep bad colors after clipping
    2884. 

  2884.     $this->currentColor = null;
    2885. 

  2885.     $this->currentStrokeColor = null;
    2886. 

  2886.     $this->addContent("\nq");
    2887. 

  2887.   }
    2888. 

  2888. 

  2889.   /**
    2890. 

  2890.    * restore the last graphic state
    2891. 

  2891.    */
    2892. 

  2892.   function restore() {
    2893. 

  2893.     // we must reset the color cache or it will keep bad colors after clipping
    2894. 

  2894.     $this->currentColor = null;
    2895. 

  2895.     $this->currentStrokeColor = null;
    2896. 

  2896.     $this->addContent("\nQ");
    2897. 

  2897.   }
    2898. 

  2898. 

  2899.   /**
    2900. 

  2900.    * draw a clipping rectangle, all the elements added after this will be clipped
    2901. 

  2901.    */
    2902. 

  2902.   function clippingRectangle($x1, $y1, $width, $height) {
    2903. 

  2903.     $this->save();
    2904. 

  2904.     $this->addContent(sprintf("\n%.3F %.3F %.3F %.3F re W n", $x1, $y1, $width, $height));
    2905. 

  2905.   }
    2906. 

  2906. 

  2907.   /**
    2908. 

  2908.    * draw a clipping rounded rectangle, all the elements added after this will be clipped
    2909. 

  2909.    */
    2910. 

  2910.   function clippingRectangleRounded($x1, $y1, $w, $h, $rTL, $rTR, $rBR, $rBL) {
    2911. 

  2911.     $this->save();
    2912. 

  2912. 

  2913.     // start: top edge, left end
    2914. 

  2914.     $this->addContent(sprintf("\n%.3F %.3F m ", $x1, $y1 - $rTL + $h));
    2915. 

  2915. 

  2916.     // curve: bottom-left corner
    2917. 

  2917.     $this->ellipse($x1 + $rBL, $y1 + $rBL, $rBL, 0, 0, 8, 180, 270, false, false, false, true);
    2918. 

  2918. 

  2919.     // line: right edge, bottom end
    2920. 

  2920.     $this->addContent(sprintf("\n%.3F %.3F l ", $x1 + $w - $rBR, $y1));
    2921. 

  2921. 

  2922.     // curve: bottom-right corner
    2923. 

  2923.     $this->ellipse($x1 + $w - $rBR, $y1 + $rBR, $rBR, 0, 0, 8, 270, 360, false, false, false, true);
    2924. 

  2924. 

  2925.     // line: right edge, top end
    2926. 

  2926.     $this->addContent(sprintf("\n%.3F %.3F l ", $x1 + $w, $y1 + $h - $rTR));
    2927. 

  2927. 

  2928.     // curve: bottom-right corner
    2929. 

  2929.     $this->ellipse($x1 + $w - $rTR, $y1 + $h - $rTR, $rTR, 0, 0, 8, 0, 90, false, false, false, true);
    2930. 

  2930. 

  2931.     // line: bottom edge, right end
    2932. 

  2932.     $this->addContent(sprintf("\n%.3F %.3F l ", $x1 + $rTL, $y1 + $h));
    2933. 

  2933. 

  2934.     // curve: top-right corner
    2935. 

  2935.     $this->ellipse($x1 + $rTL, $y1 + $h - $rTL, $rTL, 0, 0, 8, 90, 180, false, false, false, true);
    2936. 

  2936. 

  2937.     // line: top edge, left end
    2938. 

  2938.     $this->addContent(sprintf("\n%.3F %.3F l ", $x1 + $rBL, $y1));
    2939. 

  2939. 

  2940.     // Close & clip
    2941. 

  2941.     $this->addContent(" W n");
    2942. 

  2942.   }
    2943. 

  2943. 

  2944.   /**
    2945. 

  2945.    * ends the last clipping shape
    2946. 

  2946.    */
    2947. 

  2947.   function clippingEnd() {
    2948. 

  2948.     $this->restore();
    2949. 

  2949.   }
    2950. 

  2950. 

  2951.   /**
    2952. 

  2952.    * scale
    2953. 

  2953.    * @param float $s_x scaling factor for width as percent
    2954. 

  2954.    * @param float $s_y scaling factor for height as percent
    2955. 

  2955.    * @param float $x Origin abscisse
    2956. 

  2956.    * @param float $y Origin ordinate
    2957. 

  2957.    */
    2958. 

  2958.   function scale($s_x, $s_y, $x, $y) {
    2959. 

  2959.     $y = $this->currentPageSize["height"] - $y;
    2960. 

  2960. 

  2961.     $tm = array(
    2962. 

  2962.       $s_x,        0,
    2963. 

  2963.       0,           $s_y,
    2964. 

  2964.       $x*(1-$s_x), $y*(1-$s_y)
    2965. 

  2965.     );
    2966. 

  2966. 

  2967.     $this->transform($tm);
    2968. 

  2968.   }
    2969. 

  2969. 

  2970.   /**
    2971. 

  2971.    * translate
    2972. 

  2972.    * @param float $t_x movement to the right
    2973. 

  2973.    * @param float $t_y movement to the bottom
    2974. 

  2974.    */
    2975. 

  2975.   function translate($t_x, $t_y) {
    2976. 

  2976.     $tm = array(
    2977. 

  2977.       1,    0,
    2978. 

  2978.       0,    1,
    2979. 

  2979.       $t_x, -$t_y
    2980. 

  2980.     );
    2981. 

  2981. 

  2982.     $this->transform($tm);
    2983. 

  2983.   }
    2984. 

  2984. 

  2985.   /**
    2986. 

  2986.    * rotate
    2987. 

  2987.    * @param float $angle angle in degrees for counter-clockwise rotation
    2988. 

  2988.    * @param float $x Origin abscisse
    2989. 

  2989.    * @param float $y Origin ordinate
    2990. 

  2990.    */
    2991. 

  2991.   function rotate($angle, $x, $y) {
    2992. 

  2992.     $y = $this->currentPageSize["height"] - $y;
    2993. 

  2993. 

  2994.     $a = deg2rad($angle);
    2995. 

  2995.     $cos_a = cos($a);
    2996. 

  2996.     $sin_a = sin($a);
    2997. 

  2997. 

  2998.     $tm = array(
    2999. 

  2999.       $cos_a,                     -$sin_a,
    3000. 

  3000.       $sin_a,                     $cos_a,
    3001. 

  3001.       $x - $sin_a*$y - $cos_a*$x, $y - $cos_a*$y + $sin_a*$x, 
    3002. 

  3002.     );
    3003. 

  3003. 

  3004.     $this->transform($tm);
    3005. 

  3005.   }
    3006. 

  3006. 

  3007.   /**
    3008. 

  3008.    * skew
    3009. 

  3009.    * @param float $angle_x
    3010. 

  3010.    * @param float $angle_y
    3011. 

  3011.    * @param float $x Origin abscisse
    3012. 

  3012.    * @param float $y Origin ordinate
    3013. 

  3013.    */
    3014. 

  3014.   function skew($angle_x, $angle_y, $x, $y) {
    3015. 

  3015.     $y = $this->currentPageSize["height"] - $y;
    3016. 

  3016. 

  3017.     $tan_x = tan(deg2rad($angle_x));
    3018. 

  3018.     $tan_y = tan(deg2rad($angle_y));
    3019. 

  3019. 

  3020.     $tm = array(
    3021. 

  3021.       1,         -$tan_y,
    3022. 

  3022.       -$tan_x,   1,
    3023. 

  3023.       $tan_x*$y, $tan_y*$x, 
    3024. 

  3024.     );
    3025. 

  3025. 

  3026.     $this->transform($tm);
    3027. 

  3027.   }
    3028. 

  3028. 

  3029.   /**
    3030. 

  3030.    * apply graphic transformations
    3031. 

  3031.    * @param array $tm transformation matrix
    3032. 

  3032.    */
    3033. 

  3033.   function transform($tm) {
    3034. 

  3034.     $this->addContent(vsprintf("\n %.3F %.3F %.3F %.3F %.3F %.3F cm", $tm));
    3035. 

  3035.   }
    3036. 

  3036. 

  3037.   /**
    3038. 

  3038.    * add a new page to the document
    3039. 

  3039.    * this also makes the new page the current active object
    3040. 

  3040.    */
    3041. 

  3041.   function newPage($insert = 0, $id = 0, $pos = 'after') {
    3042. 

  3042.     // if there is a state saved, then go up the stack closing them
    3043. 

  3043.     // then on the new page, re-open them with the right setings
    3044. 

  3044. 

  3045.     if ($this->nStateStack) {
    3046. 

  3046.       for ($i = $this->nStateStack; $i >= 1; $i--) {
    3047. 

  3047.         $this->restoreState($i);
    3048. 

  3048.       }
    3049. 

  3049.     }
    3050. 

  3050. 

  3051.     $this->numObj++;
    3052. 

  3052. 

  3053.     if ($insert) {
    3054. 

  3054.       // the id from the ezPdf class is the id of the contents of the page, not the page object itself
    3055. 

  3055.       // query that object to find the parent
    3056. 

  3056.       $rid = $this->objects[$id]['onPage'];
    3057. 

  3057.       $opt = array('rid' => $rid, 'pos' => $pos);
    3058. 

  3058.       $this->o_page($this->numObj, 'new', $opt);
    3059. 

  3059.     } else {
    3060. 

  3060.       $this->o_page($this->numObj, 'new');
    3061. 

  3061.     }
    3062. 

  3062. 

  3063.     // if there is a stack saved, then put that onto the page
    3064. 

  3064.     if ($this->nStateStack) {
    3065. 

  3065.       for ($i = 1; $i <= $this->nStateStack; $i++) {
    3066. 

  3066.         $this->saveState($i);
    3067. 

  3067.       }
    3068. 

  3068.     }
    3069. 

  3069. 

  3070.     // and if there has been a stroke or fill color set, then transfer them
    3071. 

  3071.     if (isset($this->currentColor)) {
    3072. 

  3072.       $this->setColor($this->currentColor, true);
    3073. 

  3073.     }
    3074. 

  3074. 

  3075.     if (isset($this->currentStrokeColor)) {
    3076. 

  3076.       $this->setStrokeColor($this->currentStrokeColor, true);
    3077. 

  3077.     }
    3078. 

  3078. 

  3079.     // if there is a line style set, then put this in too
    3080. 

  3080.     if (mb_strlen($this->currentLineStyle, '8bit')) {
    3081. 

  3081.       $this->addContent("\n$this->currentLineStyle");
    3082. 

  3082.     }
    3083. 

  3083. 

  3084.     // the call to the o_page object set currentContents to the present page, so this can be returned as the page id
    3085. 

  3085.     return $this->currentContents;
    3086. 

  3086.   }
    3087. 

  3087. 

  3088.   /**
    3089. 

  3089.    * output the pdf code, streaming it to the browser
    3090. 

  3090.    * the relevant headers are set so that hopefully the browser will recognise it
    3091. 

  3091.    */
    3092. 

  3092.   function stream($options = '') {
    3093. 

  3093.     // setting the options allows the adjustment of the headers
    3094. 

  3094.     // values at the moment are:
    3095. 

  3095.     // 'Content-Disposition' => 'filename'  - sets the filename, though not too sure how well this will
    3096. 

  3096.     //        work as in my trial the browser seems to use the filename of the php file with .pdf on the end
    3097. 

  3097.     // 'Accept-Ranges' => 1 or 0 - if this is not set to 1, then this header is not included, off by default
    3098. 

  3098.     //    this header seems to have caused some problems despite tha fact that it is supposed to solve
    3099. 

  3099.     //    them, so I am leaving it off by default.
    3100. 

  3100.     // 'compress' = > 1 or 0 - apply content stream compression, this is on (1) by default
    3101. 

  3101.     // 'Attachment' => 1 or 0 - if 1, force the browser to open a download dialog
    3102. 

  3102.     if (!is_array($options)) {
    3103. 

  3103.       $options = array();
    3104. 

  3104.     }
    3105. 

  3105. 

  3106.     if ( headers_sent()) {
    3107. 

  3107.       die("Unable to stream pdf: headers already sent");
    3108. 

  3108.     }
    3109. 

  3109. 

  3110.     $debug = empty($options['compression']);
    3111. 

  3111.     $tmp = ltrim($this->output($debug));
    3112. 

  3112. 

  3113.     header("Cache-Control: private");
    3114. 

  3114.     header("Content-type: application/pdf");
    3115. 

  3115. 

  3116.     //FIXME: I don't know that this is sufficient for determining content length (i.e. what about transport compression?)
    3117. 

  3117.     header("Content-Length: " . mb_strlen($tmp, '8bit'));
    3118. 

  3118.     $fileName = (isset($options['Content-Disposition']) ?  $options['Content-Disposition'] :  'file.pdf');
    3119. 

  3119. 

  3120.     if ( !isset($options["Attachment"]))
    3121. 

  3121.       $options["Attachment"] = true;
    3122. 

  3122. 

  3123.     $attachment = $options["Attachment"] ? "attachment" : "inline";
    3124. 

  3124. 

  3125.     header("Content-Disposition: $attachment; filename=\"$fileName\"");
    3126. 

  3126. 

  3127.     if (isset($options['Accept-Ranges']) && $options['Accept-Ranges'] == 1) {
    3128. 

  3128.       //FIXME: Is this the correct value ... spec says 1#range-unit
    3129. 

  3129.       header("Accept-Ranges: " . mb_strlen($tmp, '8bit'));
    3130. 

  3130.     }
    3131. 

  3131. 

  3132.     echo $tmp;
    3133. 

  3133.     flush();
    3134. 

  3134.   }
    3135. 

  3135. 

  3136.   /**
    3137. 

  3137.    * return the height in units of the current font in the given size
    3138. 

  3138.    */
    3139. 

  3139.   function getFontHeight($size) {
    3140. 

  3140.     if (!$this->numFonts) {
    3141. 

  3141.       $this->selectFont($this->defaultFont);
    3142. 

  3142.     }
    3143. 

  3143. 

  3144.     $font = $this->fonts[$this->currentFont];
    3145. 

  3145. 

  3146.     // for the current font, and the given size, what is the height of the font in user units
    3147. 

  3147.     if ( isset($font['Ascender']) && isset($font['Descender']) ) {
    3148. 

  3148.       $h = $font['Ascender']-$font['Descender'];
    3149. 

  3149.     }
    3150. 

  3150.     else {
    3151. 

  3151.       $h = $font['FontBBox'][3]-$font['FontBBox'][1];
    3152. 

  3152.     }
    3153. 

  3153. 

  3154.     // have to adjust by a font offset for Windows fonts.  unfortunately it looks like
    3155. 

  3155.     // the bounding box calculations are wrong and I don't know why.
    3156. 

  3156.     if (isset($font['FontHeightOffset'])) {
    3157. 

  3157.       // For CourierNew from Windows this needs to be -646 to match the
    3158. 

  3158.       // Adobe native Courier font.
    3159. 

  3159.       //
    3160. 

  3160.       // For FreeMono from GNU this needs to be -337 to match the
    3161. 

  3161.       // Courier font.
    3162. 

  3162.       //
    3163. 

  3163.       // Both have been added manually to the .afm and .ufm files.
    3164. 

  3164.       $h += (int)$font['FontHeightOffset'];
    3165. 

  3165.     }
    3166. 

  3166. 

  3167.     return $size*$h/1000;
    3168. 

  3168.   }
    3169. 

  3169. 

  3170.   function getFontXHeight($size) {
    3171. 

  3171.     if (!$this->numFonts) {
    3172. 

  3172.       $this->selectFont($this->defaultFont);
    3173. 

  3173.     }
    3174. 

  3174. 

  3175.     $font = $this->fonts[$this->currentFont];
    3176. 

  3176. 

  3177.     // for the current font, and the given size, what is the height of the font in user units
    3178. 

  3178.     if ( isset($font['XHeight']) ) {
    3179. 

  3179.       $xh = $font['Ascender']-$font['Descender'];
    3180. 

  3180.     }
    3181. 

  3181.     else {
    3182. 

  3182.       $xh = $this->getFontHeight($size) / 2;
    3183. 

  3183.     }
    3184. 

  3184. 

  3185.     return $size*$xh/1000;
    3186. 

  3186.   }
    3187. 

  3187. 

  3188.   /**
    3189. 

  3189.    * return the font descender, this will normally return a negative number
    3190. 

  3190.    * if you add this number to the baseline, you get the level of the bottom of the font
    3191. 

  3191.    * it is in the pdf user units
    3192. 

  3192.    */
    3193. 

  3193.   function getFontDescender($size) {
    3194. 

  3194.     // note that this will most likely return a negative value
    3195. 

  3195.     if (!$this->numFonts) {
    3196. 

  3196.       $this->selectFont($this->defaultFont);
    3197. 

  3197.     }
    3198. 

  3198. 

  3199.     //$h = $this->fonts[$this->currentFont]['FontBBox'][1];
    3200. 

  3200.     $h = $this->fonts[$this->currentFont]['Descender'];
    3201. 

  3201. 

  3202.     return $size*$h/1000;
    3203. 

  3203.   }
    3204. 

  3204. 

  3205.   /**
    3206. 

  3206.    * filter the text, this is applied to all text just before being inserted into the pdf document
    3207. 

  3207.    * it escapes the various things that need to be escaped, and so on
    3208. 

  3208.    *
    3209. 

  3209.    * @access private
    3210. 

  3210.    */
    3211. 

  3211.   function filterText($text, $bom = true, $convert_encoding = true) {
    3212. 

  3212.     if (!$this->numFonts) {
    3213. 

  3213.       $this->selectFont($this->defaultFont);
    3214. 

  3214.     }
    3215. 

  3215. 

  3216.     if ($convert_encoding) {
    3217. 

  3217.       $cf = $this->currentFont;
    3218. 

  3218.       if (isset($this->fonts[$cf]) && $this->fonts[$cf]['isUnicode']) {
    3219. 

  3219.         //$text = html_entity_decode($text, ENT_QUOTES, 'UTF-8');
    3220. 

  3220.         $text = $this->utf8toUtf16BE($text, $bom);
    3221. 

  3221.       } else {
    3222. 

  3222.         //$text = html_entity_decode($text, ENT_QUOTES);
    3223. 

  3223.         $text = mb_convert_encoding($text, self::$targetEncoding, 'UTF-8');
    3224. 

  3224.       }
    3225. 

  3225.     }
    3226. 

  3226. 

  3227.     // the chr(13) substitution fixes a bug seen in TCPDF (bug #1421290)
    3228. 

  3228.     return strtr($text, array(')' => '\\)', '(' => '\\(', '\\' => '\\\\', chr(13) => '\r'));
    3229. 

  3229.   }
    3230. 

  3230. 

  3231.   /**
    3232. 

  3232.    * return array containing codepoints (UTF-8 character values) for the
    3233. 

  3233.    * string passed in.
    3234. 

  3234.    *
    3235. 

  3235.    * based on the excellent TCPDF code by Nicola Asuni and the
    3236. 

  3236.    * RFC for UTF-8 at http://www.faqs.org/rfcs/rfc3629.html
    3237. 

  3237.    *
    3238. 

  3238.    * @access private
    3239. 

  3239.    * @author Orion Richardson
    3240. 

  3240.    * @since January 5, 2008
    3241. 

  3241.    * @param string $text UTF-8 string to process
    3242. 

  3242.    * @return array UTF-8 codepoints array for the string
    3243. 

  3243.    */
    3244. 

  3244.   function utf8toCodePointsArray(&$text) {
    3245. 

  3245.     $length = mb_strlen($text, '8bit'); // http://www.php.net/manual/en/function.mb-strlen.php#77040
    3246. 

  3246.     $unicode = array(); // array containing unicode values
    3247. 

  3247.     $bytes = array(); // array containing single character byte sequences
    3248. 

  3248.     $numbytes = 1; // number of octetc needed to represent the UTF-8 character
    3249. 

  3249. 

  3250.     for ($i = 0; $i < $length; $i++) {
    3251. 

  3251.       $c = ord($text[$i]); // get one string character at time
    3252. 

  3252.       if (count($bytes) === 0) { // get starting octect
    3253. 

  3253.         if ($c <= 0x7F) {
    3254. 

  3254.           $unicode[] = $c; // use the character "as is" because is ASCII
    3255. 

  3255.           $numbytes = 1;
    3256. 

  3256.         } elseif (($c >> 0x05) === 0x06) { // 2 bytes character (0x06 = 110 BIN)
    3257. 

  3257.           $bytes[] = ($c - 0xC0) << 0x06;
    3258. 

  3258.           $numbytes = 2;
    3259. 

  3259.         } elseif (($c >> 0x04) === 0x0E) { // 3 bytes character (0x0E = 1110 BIN)
    3260. 

  3260.           $bytes[] = ($c - 0xE0) << 0x0C;
    3261. 

  3261.           $numbytes = 3;
    3262. 

  3262.         } elseif (($c >> 0x03) === 0x1E) { // 4 bytes character (0x1E = 11110 BIN)
    3263. 

  3263.           $bytes[] = ($c - 0xF0) << 0x12;
    3264. 

  3264.           $numbytes = 4;
    3265. 

  3265.         } else {
    3266. 

  3266.           // use replacement character for other invalid sequences
    3267. 

  3267.           $unicode[] = 0xFFFD;
    3268. 

  3268.           $bytes = array();
    3269. 

  3269.           $numbytes = 1;
    3270. 

  3270.         }
    3271. 

  3271.       } elseif (($c >> 0x06) === 0x02) { // bytes 2, 3 and 4 must start with 0x02 = 10 BIN
    3272. 

  3272.         $bytes[] = $c - 0x80;
    3273. 

  3273.         if (count($bytes) === $numbytes) {
    3274. 

  3274.           // compose UTF-8 bytes to a single unicode value
    3275. 

  3275.           $c = $bytes[0];
    3276. 

  3276.           for ($j = 1; $j < $numbytes; $j++) {
    3277. 

  3277.             $c += ($bytes[$j] << (($numbytes - $j - 1) * 0x06));
    3278. 

  3278.           }
    3279. 

  3279.           if ((($c >= 0xD800) AND ($c <= 0xDFFF)) OR ($c >= 0x10FFFF)) {
    3280. 

  3280.             // The definition of UTF-8 prohibits encoding character numbers between
    3281. 

  3281.             // U+D800 and U+DFFF, which are reserved for use with the UTF-16
    3282. 

  3282.             // encoding form (as surrogate pairs) and do not directly represent
    3283. 

  3283.             // characters.
    3284. 

  3284.             $unicode[] = 0xFFFD; // use replacement character
    3285. 

  3285.           } else {
    3286. 

  3286.             $unicode[] = $c; // add char to array
    3287. 

  3287.           }
    3288. 

  3288.           // reset data for next char
    3289. 

  3289.           $bytes = array();
    3290. 

  3290.           $numbytes = 1;
    3291. 

  3291.         }
    3292. 

  3292.       } else {
    3293. 

  3293.         // use replacement character for other invalid sequences
    3294. 

  3294.         $unicode[] = 0xFFFD;
    3295. 

  3295.         $bytes = array();
    3296. 

  3296.         $numbytes = 1;
    3297. 

  3297.       }
    3298. 

  3298.     }
    3299. 

  3299.     return $unicode;
    3300. 

  3300.   }
    3301. 

  3301. 

  3302.   /**
    3303. 

  3303.    * convert UTF-8 to UTF-16 with an additional byte order marker
    3304. 

  3304.    * at the front if required.
    3305. 

  3305.    *
    3306. 

  3306.    * based on the excellent TCPDF code by Nicola Asuni and the
    3307. 

  3307.    * RFC for UTF-8 at http://www.faqs.org/rfcs/rfc3629.html
    3308. 

  3308.    *
    3309. 

  3309.    * @access private
    3310. 

  3310.    * @author Orion Richardson
    3311. 

  3311.    * @since January 5, 2008
    3312. 

  3312.    * @param string $text UTF-8 string to process
    3313. 

  3313.    * @param boolean $bom whether to add the byte order marker
    3314. 

  3314.    * @return string UTF-16 result string
    3315. 

  3315.    */
    3316. 

  3316.   function utf8toUtf16BE(&$text, $bom = true) {
    3317. 

  3317.     $cf = $this->currentFont;
    3318. 

  3318.     if (!$this->fonts[$cf]['isUnicode']) return $text;
    3319. 

  3319.     $out = $bom ? "\xFE\xFF" : '';
    3320. 

  3320. 

  3321.     $unicode = $this->utf8toCodePointsArray($text);
    3322. 

  3322.     foreach ($unicode as $c) {
    3323. 

  3323.       if ($c === 0xFFFD) {
    3324. 

  3324.         $out .= "\xFF\xFD"; // replacement character
    3325. 

  3325.       } elseif ($c < 0x10000) {
    3326. 

  3326.         $out .= chr($c >> 0x08) . chr($c & 0xFF);
    3327. 

  3327.        } else {
    3328. 

  3328.         $c -= 0x10000;
    3329. 

  3329.         $w1 = 0xD800 | ($c >> 0x10);
    3330. 

  3330.         $w2 = 0xDC00 | ($c & 0x3FF);
    3331. 

  3331.         $out .= chr($w1 >> 0x08) . chr($w1 & 0xFF) . chr($w2 >> 0x08) . chr($w2 & 0xFF);
    3332. 

  3332.       }
    3333. 

  3333.     }
    3334. 

  3334.     return $out;
    3335. 

  3335.   }
    3336. 

  3336. 

  3337.   /**
    3338. 

  3338.    * given a start position and information about how text is to be laid out, calculate where
    3339. 

  3339.    * on the page the text will end
    3340. 

  3340.    */
    3341. 

  3341.   private function getTextPosition($x, $y, $angle, $size, $wa, $text) {
    3342. 

  3342.     // given this information return an array containing x and y for the end position as elements 0 and 1
    3343. 

  3343.     $w = $this->getTextWidth($size, $text);
    3344. 

  3344. 

  3345.     // need to adjust for the number of spaces in this text
    3346. 

  3346.     $words = explode(' ', $text);
    3347. 

  3347.     $nspaces = count($words) -1;
    3348. 

  3348.     $w+= $wa*$nspaces;
    3349. 

  3349.     $a = deg2rad((float)$angle);
    3350. 

  3350. 

  3351.     return array(cos($a) *$w+$x, -sin($a) *$w+$y);
    3352. 

  3352.   }
    3353. 

  3353. 

  3354.   /**
    3355. 

  3355.    * Callback method used by smallCaps
    3356. 

  3356.    * 
    3357. 

  3357.    * @param array $matches
    3358. 

  3358.    * @return string
    3359. 

  3359.    */
    3360. 

  3360.   function toUpper($matches) {
    3361. 

  3361.     return mb_strtoupper($matches[0]);
    3362. 

  3362.   }
    3363. 

  3363. 

  3364.   function concatMatches($matches) {
    3365. 

  3365.     $str = "";
    3366. 

  3366.     foreach ($matches as $match){
    3367. 

  3367.       $str .= $match[0];
    3368. 

  3368.     }
    3369. 

  3369.     return $str;
    3370. 

  3370.   }
    3371. 

  3371. 

  3372.   /**
    3373. 

  3373.    * add text to the document, at a specified location, size and angle on the page
    3374. 

  3374.    */
    3375. 

  3375.   function registerText($font, $text) {
    3376. 

  3376.     if ( !$this->isUnicode || in_array(mb_strtolower(basename($font)), self::$coreFonts) ) {
    3377. 

  3377.       return;
    3378. 

  3378.     }
    3379. 

  3379. 

  3380.     if ( !isset($this->stringSubsets[$font]) ) {
    3381. 

  3381.       $this->stringSubsets[$font] = array();
    3382. 

  3382.     }
    3383. 

  3383. 

  3384.     $this->stringSubsets[$font] = array_unique(array_merge($this->stringSubsets[$font], $this->utf8toCodePointsArray($text)));
    3385. 

  3385.   }
    3386. 

  3386. 

  3387.   /**
    3388. 

  3388.    * add text to the document, at a specified location, size and angle on the page
    3389. 

  3389.    */
    3390. 

  3390.   function addText($x, $y, $size, $text, $angle = 0, $wordSpaceAdjust = 0, $charSpaceAdjust = 0, $smallCaps = false) {
    3391. 

  3391.     if (!$this->numFonts) {
    3392. 

  3392.       $this->selectFont($this->defaultFont);
    3393. 

  3393.     }
    3394. 

  3394. 

  3395.     $text = str_replace(array("\r", "\n"), "", $text);
    3396. 

  3396. 

  3397.     if ( $smallCaps ) {
    3398. 

  3398.       preg_match_all("/(\P{Ll}+)/u", $text, $matches, PREG_SET_ORDER);
    3399. 

  3399.       $lower = $this->concatMatches($matches);
    3400. 

  3400.       d($lower);
    3401. 

  3401. 

  3402.       preg_match_all("/(\p{Ll}+)/u", $text, $matches, PREG_SET_ORDER);
    3403. 

  3403.       $other = $this->concatMatches($matches);
    3404. 

  3404.       d($other);
    3405. 

  3405. 

  3406.       //$text = preg_replace_callback("/\p{Ll}/u", array($this, "toUpper"), $text);
    3407. 

  3407.     }
    3408. 

  3408. 

  3409.     // if there are any open callbacks, then they should be called, to show the start of the line
    3410. 

  3410.     if ($this->nCallback > 0) {
    3411. 

  3411.       for ($i = $this->nCallback; $i > 0; $i--) {
    3412. 

  3412.         // call each function
    3413. 

  3413.         $info = array(
    3414. 

  3414.           'x' => $x,
    3415. 

  3415.           'y' => $y,
    3416. 

  3416.           'angle' => $angle,
    3417. 

  3417.           'status' => 'sol',
    3418. 

  3418.           'p'         => $this->callback[$i]['p'],
    3419. 

  3419.           'nCallback' => $this->callback[$i]['nCallback'],
    3420. 

  3420.           'height'    => $this->callback[$i]['height'],
    3421. 

  3421.           'descender' => $this->callback[$i]['descender']
    3422. 

  3422.         );
    3423. 

  3423. 

  3424.         $func = $this->callback[$i]['f'];
    3425. 

  3425.         $this->$func($info);
    3426. 

  3426.       }
    3427. 

  3427.     }
    3428. 

  3428. 

  3429.     if ($angle == 0) {
    3430. 

  3430.       $this->addContent(sprintf("\nBT %.3F %.3F Td", $x, $y));
    3431. 

  3431.     } else {
    3432. 

  3432.       $a = deg2rad((float)$angle);
    3433. 

  3433.       $this->addContent(sprintf("\nBT %.3F %.3F %.3F %.3F %.3F %.3F Tm", cos($a), -sin($a), sin($a), cos($a), $x, $y));
    3434. 

  3434.     }
    3435. 

  3435. 

  3436.     if ($wordSpaceAdjust != 0 || $wordSpaceAdjust != $this->wordSpaceAdjust) {
    3437. 

  3437.       $this->wordSpaceAdjust = $wordSpaceAdjust;
    3438. 

  3438.       $this->addContent(sprintf(" %.3F Tw", $wordSpaceAdjust));
    3439. 

  3439.     }
    3440. 

  3440. 

  3441.     if ($charSpaceAdjust != 0 || $charSpaceAdjust != $this->charSpaceAdjust) {
    3442. 

  3442.       $this->charSpaceAdjust = $charSpaceAdjust;
    3443. 

  3443.       $this->addContent(sprintf(" %.3F Tc", $charSpaceAdjust));
    3444. 

  3444.     }
    3445. 

  3445. 

  3446.     $len = mb_strlen($text);
    3447. 

  3447.     $start = 0;
    3448. 

  3448. 

  3449.     if ($start < $len) {
    3450. 

  3450.       $part = $text; // OAR - Don't need this anymore, given that $start always equals zero.  substr($text, $start);
    3451. 

  3451.       $place_text = $this->filterText($part, false);
    3452. 

  3452.       // modify unicode text so that extra word spacing is manually implemented (bug #)
    3453. 

  3453.       $cf = $this->currentFont;
    3454. 

  3454.       if ($this->fonts[$cf]['isUnicode'] && $wordSpaceAdjust != 0) {
    3455. 

  3455.         $space_scale = 1000 / $size;
    3456. 

  3456.         //$place_text = str_replace(' ', ') ( ) '.($this->getTextWidth($size, chr(32), $wordSpaceAdjust)*-75).' (', $place_text);
    3457. 

  3457.         $place_text = str_replace(' ', ' ) '.(-round($space_scale*$wordSpaceAdjust)).' (', $place_text);
    3458. 

  3458.       }
    3459. 

  3459.       $this->addContent(" /F$this->currentFontNum ".sprintf('%.1F Tf ', $size));
    3460. 

  3460.       $this->addContent(" [($place_text)] TJ");
    3461. 

  3461.     }
    3462. 

  3462. 

  3463.     $this->addContent(' ET');
    3464. 

  3464. 

  3465.     // if there are any open callbacks, then they should be called, to show the end of the line
    3466. 

  3466.     if ($this->nCallback > 0) {
    3467. 

  3467.       for ($i = $this->nCallback; $i > 0; $i--) {
    3468. 

  3468.         // call each function
    3469. 

  3469.         $tmp = $this->getTextPosition($x, $y, $angle, $size, $wordSpaceAdjust, $text);
    3470. 

  3470.         $info = array(
    3471. 

  3471.           'x' => $tmp[0],
    3472. 

  3472.           'y' => $tmp[1],
    3473. 

  3473.           'angle' => $angle,
    3474. 

  3474.           'status' => 'eol',
    3475. 

  3475.           'p'         => $this->callback[$i]['p'],
    3476. 

  3476.           'nCallback' => $this->callback[$i]['nCallback'],
    3477. 

  3477.           'height'    => $this->callback[$i]['height'],
    3478. 

  3478.           'descender' => $this->callback[$i]['descender']
    3479. 

  3479.         );
    3480. 

  3480.         $func = $this->callback[$i]['f'];
    3481. 

  3481.         $this->$func($info);
    3482. 

  3482.       }
    3483. 

  3483.     }
    3484. 

  3484.   }
    3485. 

  3485. 

  3486.   /**
    3487. 

  3487.    * calculate how wide a given text string will be on a page, at a given size.
    3488. 

  3488.    * this can be called externally, but is alse used by the other class functions
    3489. 

  3489.    */
    3490. 

  3490.   function getTextWidth($size, $text, $word_spacing = 0, $char_spacing = 0) {
    3491. 

  3491.     static $ord_cache = array();
    3492. 

  3492. 

  3493.     // this function should not change any of the settings, though it will need to
    3494. 

  3494.     // track any directives which change during calculation, so copy them at the start
    3495. 

  3495.     // and put them back at the end.
    3496. 

  3496.     $store_currentTextState = $this->currentTextState;
    3497. 

  3497. 

  3498.     if (!$this->numFonts) {
    3499. 

  3499.       $this->selectFont($this->defaultFont);
    3500. 

  3500.     }
    3501. 

  3501. 

  3502.     $text = str_replace(array("\r", "\n"), "", $text);
    3503. 

  3503. 

  3504.     // converts a number or a float to a string so it can get the width
    3505. 

  3505.     $text = "$text";
    3506. 

  3506. 

  3507.     // hmm, this is where it all starts to get tricky - use the font information to
    3508. 

  3508.     // calculate the width of each character, add them up and convert to user units
    3509. 

  3509.     $w = 0;
    3510. 

  3510.     $cf = $this->currentFont;
    3511. 

  3511.     $current_font = $this->fonts[$cf];
    3512. 

  3512.     $space_scale = 1000 / $size;
    3513. 

  3513.     $n_spaces = 0;
    3514. 

  3514. 

  3515.     if ( $current_font['isUnicode']) {
    3516. 

  3516.       // for Unicode, use the code points array to calculate width rather
    3517. 

  3517.       // than just the string itself
    3518. 

  3518.       $unicode = $this->utf8toCodePointsArray($text);
    3519. 

  3519. 

  3520.       foreach ($unicode as $char) {
    3521. 

  3521.         // check if we have to replace character
    3522. 

  3522.         if ( isset($current_font['differences'][$char])) {
    3523. 

  3523.           $char = $current_font['differences'][$char];
    3524. 

  3524.         }
    3525. 

  3525. 

  3526.         if ( isset($current_font['C'][$char]) ) {
    3527. 

  3527.           $char_width = $current_font['C'][$char];
    3528. 

  3528. 

  3529.           // add the character width
    3530. 

  3530.           $w += $char_width;
    3531. 

  3531. 

  3532.           // add additional padding for space
    3533. 

  3533.           if ( isset($current_font['codeToName'][$char]) && $current_font['codeToName'][$char] === 'space' ) {  // Space
    3534. 

  3534.             $w += $word_spacing * $space_scale;
    3535. 

  3535.             $n_spaces++;
    3536. 

  3536.           }
    3537. 

  3537.         }
    3538. 

  3538.       }
    3539. 

  3539. 

  3540.       // add additionnal char spacing
    3541. 

  3541.       if ( $char_spacing != 0 ) {
    3542. 

  3542.         $w += $char_spacing * $space_scale * (count($unicode) + $n_spaces);
    3543. 

  3543.       }
    3544. 

  3544. 

  3545.     } else {
    3546. 

  3546.       // If CPDF is in Unicode mode but the current font does not support Unicode we need to convert the character set to Windows-1252
    3547. 

  3547.       if ( $this->isUnicode ) { 
    3548. 

  3548.         $text = mb_convert_encoding($text, 'Windows-1252', 'UTF-8');
    3549. 

  3549.       }
    3550. 

  3550. 

  3551.       $len = mb_strlen($text, 'Windows-1252');
    3552. 

  3552. 

  3553.       for ($i = 0; $i < $len; $i++) {
    3554. 

  3554.         $c = $text[$i];
    3555. 

  3555.         $char = isset($ord_cache[$c]) ? $ord_cache[$c] : ($ord_cache[$c] = ord($c));
    3556. 

  3556. 

  3557.         // check if we have to replace character
    3558. 

  3558.         if ( isset($current_font['differences'][$char])) {
    3559. 

  3559.           $char = $current_font['differences'][$char];
    3560. 

  3560.         }
    3561. 

  3561. 

  3562.         if ( isset($current_font['C'][$char]) ) {
    3563. 

  3563.           $char_width = $current_font['C'][$char];
    3564. 

  3564. 

  3565.           // add the character width
    3566. 

  3566.           $w += $char_width;
    3567. 

  3567. 

  3568.           // add additional padding for space
    3569. 

  3569.           if ( isset($current_font['codeToName'][$char]) && $current_font['codeToName'][$char] === 'space' ) {  // Space
    3570. 

  3570.             $w += $word_spacing * $space_scale;
    3571. 

  3571.             $n_spaces++;
    3572. 

  3572.           }
    3573. 

  3573.         }
    3574. 

  3574.       }
    3575. 

  3575. 

  3576.       // add additionnal char spacing
    3577. 

  3577.       if ( $char_spacing != 0 )  {
    3578. 

  3578.         $w += $char_spacing * $space_scale * ($len + $n_spaces);
    3579. 

  3579.       }
    3580. 

  3580.     }
    3581. 

  3581. 

  3582.     $this->currentTextState = $store_currentTextState;
    3583. 

  3583.     $this->setCurrentFont();
    3584. 

  3584. 

  3585.     return $w*$size/1000;
    3586. 

  3586.   }
    3587. 

  3587. 

  3588.   /**
    3589. 

  3589.    * this will be called at a new page to return the state to what it was on the
    3590. 

  3590.    * end of the previous page, before the stack was closed down
    3591. 

  3591.    * This is to get around not being able to have open 'q' across pages
    3592. 

  3592.    *
    3593. 

  3593.    */
    3594. 

  3594.   function saveState($pageEnd = 0) {
    3595. 

  3595.     if ($pageEnd) {
    3596. 

  3596.       // this will be called at a new page to return the state to what it was on the
    3597. 

  3597.       // end of the previous page, before the stack was closed down
    3598. 

  3598.       // This is to get around not being able to have open 'q' across pages
    3599. 

  3599.       $opt = $this->stateStack[$pageEnd];
    3600. 

  3600.       // ok to use this as stack starts numbering at 1
    3601. 

  3601.       $this->setColor($opt['col'], true);
    3602. 

  3602.       $this->setStrokeColor($opt['str'], true);
    3603. 

  3603.       $this->addContent("\n".$opt['lin']);
    3604. 

  3604.       //    $this->currentLineStyle = $opt['lin'];
    3605. 

  3605.     } else {
    3606. 

  3606.       $this->nStateStack++;
    3607. 

  3607.       $this->stateStack[$this->nStateStack] = array(
    3608. 

  3608.         'col' => $this->currentColor,
    3609. 

  3609.         'str' => $this->currentStrokeColor,
    3610. 

  3610.         'lin' => $this->currentLineStyle
    3611. 

  3611.       );
    3612. 

  3612.     }
    3613. 

  3613. 

  3614.     $this->save();
    3615. 

  3615.   }
    3616. 

  3616. 

  3617.   /**
    3618. 

  3618.    * restore a previously saved state
    3619. 

  3619.    */
    3620. 

  3620.   function restoreState($pageEnd = 0) {
    3621. 

  3621.     if (!$pageEnd) {
    3622. 

  3622.       $n = $this->nStateStack;
    3623. 

  3623.       $this->currentColor =       $this->stateStack[$n]['col'];
    3624. 

  3624.       $this->currentStrokeColor = $this->stateStack[$n]['str'];
    3625. 

  3625.       $this->addContent("\n".$this->stateStack[$n]['lin']);
    3626. 

  3626.       $this->currentLineStyle =    $this->stateStack[$n]['lin'];
    3627. 

  3627.       $this->stateStack[$n] = null;
    3628. 

  3628.       unset($this->stateStack[$n]);
    3629. 

  3629.       $this->nStateStack--;
    3630. 

  3630.     }
    3631. 

  3631. 

  3632.     $this->restore();
    3633. 

  3633.   }
    3634. 

  3634. 

  3635.   /**
    3636. 

  3636.    * make a loose object, the output will go into this object, until it is closed, then will revert to
    3637. 

  3637.    * the current one.
    3638. 

  3638.    * this object will not appear until it is included within a page.
    3639. 

  3639.    * the function will return the object number
    3640. 

  3640.    */
    3641. 

  3641.   function openObject() {
    3642. 

  3642.     $this->nStack++;
    3643. 

  3643.     $this->stack[$this->nStack] = array('c' => $this->currentContents, 'p' => $this->currentPage);
    3644. 

  3644.     // add a new object of the content type, to hold the data flow
    3645. 

  3645.     $this->numObj++;
    3646. 

  3646.     $this->o_contents($this->numObj, 'new');
    3647. 

  3647.     $this->currentContents = $this->numObj;
    3648. 

  3648.     $this->looseObjects[$this->numObj] = 1;
    3649. 

  3649. 

  3650.     return $this->numObj;
    3651. 

  3651.   }
    3652. 

  3652. 

  3653.   /**
    3654. 

  3654.    * open an existing object for editing
    3655. 

  3655.    */
    3656. 

  3656.   function reopenObject($id) {
    3657. 

  3657.     $this->nStack++;
    3658. 

  3658.     $this->stack[$this->nStack] = array('c' => $this->currentContents, 'p' => $this->currentPage);
    3659. 

  3659.     $this->currentContents = $id;
    3660. 

  3660. 

  3661.     // also if this object is the primary contents for a page, then set the current page to its parent
    3662. 

  3662.     if (isset($this->objects[$id]['onPage'])) {
    3663. 

  3663.       $this->currentPage = $this->objects[$id]['onPage'];
    3664. 

  3664.     }
    3665. 

  3665.   }
    3666. 

  3666. 

  3667.   /**
    3668. 

  3668.    * close an object
    3669. 

  3669.    */
    3670. 

  3670.   function closeObject() {
    3671. 

  3671.     // close the object, as long as there was one open in the first place, which will be indicated by
    3672. 

  3672.     // an objectId on the stack.
    3673. 

  3673.     if ($this->nStack > 0) {
    3674. 

  3674.       $this->currentContents = $this->stack[$this->nStack]['c'];
    3675. 

  3675.       $this->currentPage = $this->stack[$this->nStack]['p'];
    3676. 

  3676.       $this->nStack--;
    3677. 

  3677.       // easier to probably not worry about removing the old entries, they will be overwritten
    3678. 

  3678.       // if there are new ones.
    3679. 

  3679.     }
    3680. 

  3680.   }
    3681. 

  3681. 

  3682.   /**
    3683. 

  3683.    * stop an object from appearing on pages from this point on
    3684. 

  3684.    */
    3685. 

  3685.   function stopObject($id) {
    3686. 

  3686.     // if an object has been appearing on pages up to now, then stop it, this page will
    3687. 

  3687.     // be the last one that could contian it.
    3688. 

  3688.     if (isset($this->addLooseObjects[$id])) {
    3689. 

  3689.       $this->addLooseObjects[$id] = '';
    3690. 

  3690.     }
    3691. 

  3691.   }
    3692. 

  3692. 

  3693.   /**
    3694. 

  3694.    * after an object has been created, it wil only show if it has been added, using this function.
    3695. 

  3695.    */
    3696. 

  3696.   function addObject($id, $options = 'add') {
    3697. 

  3697.     // add the specified object to the page
    3698. 

  3698.     if (isset($this->looseObjects[$id]) && $this->currentContents != $id) {
    3699. 

  3699.       // then it is a valid object, and it is not being added to itself
    3700. 

  3700.       switch ($options) {
    3701. 

  3701.       case 'all':
    3702. 

  3702.         // then this object is to be added to this page (done in the next block) and
    3703. 

  3703.         // all future new pages.
    3704. 

  3704.         $this->addLooseObjects[$id] = 'all';
    3705. 

  3705. 

  3706.       case 'add':
    3707. 

  3707.         if (isset($this->objects[$this->currentContents]['onPage'])) {
    3708. 

  3708.           // then the destination contents is the primary for the page
    3709. 

  3709.           // (though this object is actually added to that page)
    3710. 

  3710.           $this->o_page($this->objects[$this->currentContents]['onPage'], 'content', $id);
    3711. 

  3711.         }
    3712. 

  3712.         break;
    3713. 

  3713. 

  3714.       case 'even':
    3715. 

  3715.         $this->addLooseObjects[$id] = 'even';
    3716. 

  3716.         $pageObjectId = $this->objects[$this->currentContents]['onPage'];
    3717. 

  3717.         if ($this->objects[$pageObjectId]['info']['pageNum']%2 == 0) {
    3718. 

  3718.           $this->addObject($id);
    3719. 

  3719.           // hacky huh :)
    3720. 

  3720.         }
    3721. 

  3721.         break;
    3722. 

  3722. 

  3723.       case 'odd':
    3724. 

  3724.         $this->addLooseObjects[$id] = 'odd';
    3725. 

  3725.         $pageObjectId = $this->objects[$this->currentContents]['onPage'];
    3726. 

  3726.         if ($this->objects[$pageObjectId]['info']['pageNum']%2 == 1) {
    3727. 

  3727.           $this->addObject($id);
    3728. 

  3728.           // hacky huh :)
    3729. 

  3729.         }
    3730. 

  3730.         break;
    3731. 

  3731. 

  3732.       case 'next':
    3733. 

  3733.         $this->addLooseObjects[$id] = 'all';
    3734. 

  3734.         break;
    3735. 

  3735. 

  3736.       case 'nexteven':
    3737. 

  3737.         $this->addLooseObjects[$id] = 'even';
    3738. 

  3738.         break;
    3739. 

  3739. 

  3740.       case 'nextodd':
    3741. 

  3741.         $this->addLooseObjects[$id] = 'odd';
    3742. 

  3742.         break;
    3743. 

  3743.       }
    3744. 

  3744.     }
    3745. 

  3745.   }
    3746. 

  3746. 

  3747.   /**
    3748. 

  3748.    * return a storable representation of a specific object
    3749. 

  3749.    */
    3750. 

  3750.   function serializeObject($id) {
    3751. 

  3751.     if ( array_key_exists($id, $this->objects)) {
    3752. 

  3752.       return serialize($this->objects[$id]);
    3753. 

  3753.     }
    3754. 

  3754.   }
    3755. 

  3755. 

  3756.   /**
    3757. 

  3757.    * restore an object from its stored representation.  returns its new object id.
    3758. 

  3758.    */
    3759. 

  3759.   function restoreSerializedObject($obj) {
    3760. 

  3760.     $obj_id = $this->openObject();
    3761. 

  3761.     $this->objects[$obj_id] = unserialize($obj);
    3762. 

  3762.     $this->closeObject();
    3763. 

  3763.     return $obj_id;
    3764. 

  3764.   }
    3765. 

  3765. 

  3766.   /**
    3767. 

  3767.    * add content to the documents info object
    3768. 

  3768.    */
    3769. 

  3769.   function addInfo($label, $value = 0) {
    3770. 

  3770.     // this will only work if the label is one of the valid ones.
    3771. 

  3771.     // modify this so that arrays can be passed as well.
    3772. 

  3772.     // if $label is an array then assume that it is key => value pairs
    3773. 

  3773.     // else assume that they are both scalar, anything else will probably error
    3774. 

  3774.     if (is_array($label)) {
    3775. 

  3775.       foreach ($label as $l => $v) {
    3776. 

  3776.         $this->o_info($this->infoObject, $l, $v);
    3777. 

  3777.       }
    3778. 

  3778.     } else {
    3779. 

  3779.       $this->o_info($this->infoObject, $label, $value);
    3780. 

  3780.     }
    3781. 

  3781.   }
    3782. 

  3782. 

  3783.   /**
    3784. 

  3784.    * set the viewer preferences of the document, it is up to the browser to obey these.
    3785. 

  3785.    */
    3786. 

  3786.   function setPreferences($label, $value = 0) {
    3787. 

  3787.     // this will only work if the label is one of the valid ones.
    3788. 

  3788.     if (is_array($label)) {
    3789. 

  3789.       foreach ($label as $l => $v) {
    3790. 

  3790.         $this->o_catalog($this->catalogId, 'viewerPreferences', array($l => $v));
    3791. 

  3791.       }
    3792. 

  3792.     } else {
    3793. 

  3793.       $this->o_catalog($this->catalogId, 'viewerPreferences', array($label => $value));
    3794. 

  3794.     }
    3795. 

  3795.   }
    3796. 

  3796. 

  3797.   /**
    3798. 

  3798.    * extract an integer from a position in a byte stream
    3799. 

  3799.    */
    3800. 

  3800.   private function getBytes(&$data, $pos, $num) {
    3801. 

  3801.     // return the integer represented by $num bytes from $pos within $data
    3802. 

  3802.     $ret = 0;
    3803. 

  3803.     for ($i = 0; $i < $num; $i++) {
    3804. 

  3804.       $ret *= 256;
    3805. 

  3805.       $ret += ord($data[$pos+$i]);
    3806. 

  3806.     }
    3807. 

  3807. 

  3808.     return $ret;
    3809. 

  3809.   }
    3810. 

  3810. 

  3811.   /**
    3812. 

  3812.    * Check if image already added to pdf image directory.
    3813. 

  3813.    * If yes, need not to create again (pass empty data)
    3814. 

  3814.    */
    3815. 

  3815.   function image_iscached($imgname) {
    3816. 

  3816.     return isset($this->imagelist[$imgname]);
    3817. 

  3817.   }
    3818. 

  3818. 

  3819.   /**
    3820. 

  3820.    * add a PNG image into the document, from a GD object
    3821. 

  3821.    * this should work with remote files
    3822. 

  3822.    *
    3823. 

  3823.    * @param string   $file    The PNG file
    3824. 

  3824.    * @param float    $x       X position
    3825. 

  3825.    * @param float    $y       Y position
    3826. 

  3826.    * @param float    $w       Width
    3827. 

  3827.    * @param float    $h       Height
    3828. 

  3828.    * @param resource $img     A GD resource
    3829. 

  3829.    * @param bool     $is_mask true if the image is a mask
    3830. 

  3830.    * @param bool     $mask    true if the image is masked
    3831. 

  3831.    */
    3832. 

  3832.   function addImagePng($file, $x, $y, $w = 0.0, $h = 0.0, &$img, $is_mask = false, $mask = null) {
    3833. 

  3833.     if (!function_exists("imagepng")) {
    3834. 

  3834.       throw new Exception("The PHP GD extension is required, but is not installed.");
    3835. 

  3835.     }
    3836. 

  3836. 

  3837.     //if already cached, need not to read again
    3838. 

  3838.     if ( isset($this->imagelist[$file]) ) {
    3839. 

  3839.       $data = null;
    3840. 

  3840.     }
    3841. 

  3841.     else {
    3842. 

  3842.       // Example for transparency handling on new image. Retain for current image
    3843. 

  3843.       // $tIndex = imagecolortransparent($img);
    3844. 

  3844.       // if ($tIndex > 0) {
    3845. 

  3845.       //   $tColor    = imagecolorsforindex($img, $tIndex);
    3846. 

  3846.       //   $new_tIndex    = imagecolorallocate($new_img, $tColor['red'], $tColor['green'], $tColor['blue']);
    3847. 

  3847.       //   imagefill($new_img, 0, 0, $new_tIndex);
    3848. 

  3848.       //   imagecolortransparent($new_img, $new_tIndex);
    3849. 

  3849.       // }
    3850. 

  3850.       // blending mode (literal/blending) on drawing into current image. not relevant when not saved or not drawn
    3851. 

  3851.       //imagealphablending($img, true);
    3852. 

  3852. 

  3853.       //default, but explicitely set to ensure pdf compatibility
    3854. 

  3854.       imagesavealpha($img, false/*!$is_mask && !$mask*/);
    3855. 

  3855. 

  3856.       $error = 0;
    3857. 

  3857.       //DEBUG_IMG_TEMP
    3858. 

  3858.       //debugpng
    3859. 

  3859.       if (DEBUGPNG) print '[addImagePng '.$file.']';
    3860. 

  3860. 

  3861.       ob_start();
    3862. 

  3862.       @imagepng($img);
    3863. 

  3863.       $data = ob_get_clean();
    3864. 

  3864. 

  3865.       if ($data == '') {
    3866. 

  3866.         $error = 1;
    3867. 

  3867.         $errormsg = 'trouble writing file from GD';
    3868. 

  3868.         //DEBUG_IMG_TEMP
    3869. 

  3869.         //debugpng
    3870. 

  3870.         if (DEBUGPNG) print 'trouble writing file from GD';
    3871. 

  3871.       }
    3872. 

  3872. 

  3873.       if ($error) {
    3874. 

  3874.         $this->addMessage('PNG error - ('.$file.') '.$errormsg);
    3875. 

  3875.         return;
    3876. 

  3876.       }
    3877. 

  3877.     }  //End isset($this->imagelist[$file]) (png Duplicate removal)
    3878. 

  3878. 

  3879.     $this->addPngFromBuf($file, $x, $y, $w, $h, $data, $is_mask, $mask);
    3880. 

  3880.   }
    3881. 

  3881. 

  3882.   protected function addImagePngAlpha($file, $x, $y, $w, $h, $byte) {
    3883. 

  3883.     // generate images
    3884. 

  3884.     $img = imagecreatefrompng($file);
    3885. 

  3885. 

  3886.     if ($img === false) {
    3887. 

  3887.       return;
    3888. 

  3888.     }
    3889. 

  3889. 

  3890.     // FIXME The pixel transformation doesn't work well with 8bit PNGs
    3891. 

  3891.     $eight_bit = ($byte & 4) !== 4;
    3892. 

  3892. 

  3893.     $wpx = imagesx($img);
    3894. 

  3894.     $hpx = imagesy($img);
    3895. 

  3895. 

  3896.     imagesavealpha($img, false);
    3897. 

  3897. 

  3898.     // create temp alpha file
    3899. 

  3899.     $tempfile_alpha = tempnam($this->tmp, "cpdf_img_");
    3900. 

  3900.     @unlink($tempfile_alpha);
    3901. 

  3901.     $tempfile_alpha = "$tempfile_alpha.png";
    3902. 

  3902. 

  3903.     // create temp plain file
    3904. 

  3904.     $tempfile_plain = tempnam($this->tmp, "cpdf_img_");
    3905. 

  3905.     @unlink($tempfile_plain);
    3906. 

  3906.     $tempfile_plain = "$tempfile_plain.png";
    3907. 

  3907. 

  3908.     $imgalpha = imagecreate($wpx, $hpx);
    3909. 

  3909.     imagesavealpha($imgalpha, false);
    3910. 

  3910. 

  3911.     // generate gray scale palette (0 -> 255)
    3912. 

  3912.     for ($c = 0; $c < 256; ++$c) {
    3913. 

  3913.       imagecolorallocate($imgalpha, $c, $c, $c);
    3914. 

  3914.     }
    3915. 

  3915. 

  3916.     // Use PECL gmagick + Graphics Magic to process transparent PNG images
    3917. 

  3917.     if (extension_loaded("gmagick")) {
    3918. 

  3918.       $gmagick = new Gmagick($file);
    3919. 

  3919.       $gmagick->setimageformat('png');
    3920. 

  3920. 

  3921.       // Get opacity channel (negative of alpha channel)
    3922. 

  3922.       $alpha_channel_neg = clone $gmagick;
    3923. 

  3923.       $alpha_channel_neg->separateimagechannel(Gmagick::CHANNEL_OPACITY);
    3924. 

  3924. 

  3925.       // Negate opacity channel
    3926. 

  3926.       $alpha_channel = new Gmagick();
    3927. 

  3927.       $alpha_channel->newimage($wpx, $hpx, "#FFFFFF", "png");
    3928. 

  3928.       $alpha_channel->compositeimage($alpha_channel_neg, Gmagick::COMPOSITE_DIFFERENCE, 0, 0);
    3929. 

  3929.       $alpha_channel->separateimagechannel(Gmagick::CHANNEL_RED);
    3930. 

  3930.       $alpha_channel->writeimage($tempfile_alpha);
    3931. 

  3931. 

  3932.       // Cast to 8bit+palette
    3933. 

  3933.       $imgalpha_ = imagecreatefrompng($tempfile_alpha);
    3934. 

  3934.       imagecopy($imgalpha, $imgalpha_, 0, 0, 0, 0, $wpx, $hpx);
    3935. 

  3935.       imagedestroy($imgalpha_);
    3936. 

  3936.       imagepng($imgalpha, $tempfile_alpha);
    3937. 

  3937. 

  3938.       // Make opaque image
    3939. 

  3939.       $color_channels = new Gmagick();
    3940. 

  3940.       $color_channels->newimage($wpx, $hpx, "#FFFFFF", "png");
    3941. 

  3941.       $color_channels->compositeimage($gmagick, Gmagick::COMPOSITE_COPYRED, 0, 0);
    3942. 

  3942.       $color_channels->compositeimage($gmagick, Gmagick::COMPOSITE_COPYGREEN, 0, 0);
    3943. 

  3943.       $color_channels->compositeimage($gmagick, Gmagick::COMPOSITE_COPYBLUE, 0, 0);
    3944. 

  3944.       $color_channels->writeimage($tempfile_plain);
    3945. 

  3945. 

  3946.       $imgplain = imagecreatefrompng($tempfile_plain);
    3947. 

  3947.     }
    3948. 

  3948. 

  3949.     // Use PECL imagick + ImageMagic to process transparent PNG images
    3950. 

  3950.     elseif (extension_loaded("imagick")) {
    3951. 

  3951.       // Native cloning was added to pecl-imagick in svn commit 263814
    3952. 

  3952.       // the first version containing it was 3.0.1RC1
    3953. 

  3953.       static $imagickClonable = null;
    3954. 

  3954.       if($imagickClonable === null) {
    3955. 

  3955.         $imagickClonable = version_compare(phpversion('imagick'), '3.0.1rc1') > 0;
    3956. 

  3956.       }
    3957. 

  3957. 

  3958.       $imagick = new Imagick($file);
    3959. 

  3959.       $imagick->setFormat('png');
    3960. 

  3960. 

  3961.       // Get opacity channel (negative of alpha channel)
    3962. 

  3962.       $alpha_channel = $imagickClonable ? clone $imagick : $imagick->clone();
    3963. 

  3963.       $alpha_channel->separateImageChannel(Imagick::CHANNEL_ALPHA);
    3964. 

  3964.       $alpha_channel->negateImage(true);
    3965. 

  3965.       $alpha_channel->writeImage($tempfile_alpha);
    3966. 

  3966. 

  3967.       // Cast to 8bit+palette
    3968. 

  3968.       $imgalpha_ = imagecreatefrompng($tempfile_alpha);
    3969. 

  3969.       imagecopy($imgalpha, $imgalpha_, 0, 0, 0, 0, $wpx, $hpx);
    3970. 

  3970.       imagedestroy($imgalpha_);
    3971. 

  3971.       imagepng($imgalpha, $tempfile_alpha);
    3972. 

  3972. 

  3973.       // Make opaque image
    3974. 

  3974.       $color_channels = new Imagick();
    3975. 

  3975.       $color_channels->newImage($wpx, $hpx, "#FFFFFF", "png");
    3976. 

  3976.       $color_channels->compositeImage($imagick, Imagick::COMPOSITE_COPYRED, 0, 0);
    3977. 

  3977.       $color_channels->compositeImage($imagick, Imagick::COMPOSITE_COPYGREEN, 0, 0);
    3978. 

  3978.       $color_channels->compositeImage($imagick, Imagick::COMPOSITE_COPYBLUE, 0, 0);
    3979. 

  3979.       $color_channels->writeImage($tempfile_plain);
    3980. 

  3980. 

  3981.       $imgplain = imagecreatefrompng($tempfile_plain);
    3982. 

  3982.     }
    3983. 

  3983.     else {
    3984. 

  3984.       // allocated colors cache
    3985. 

  3985.       $allocated_colors = array();
    3986. 

  3986. 

  3987.       // extract alpha channel
    3988. 

  3988.       for ($xpx = 0; $xpx < $wpx; ++$xpx) {
    3989. 

  3989.         for ($ypx = 0; $ypx < $hpx; ++$ypx) {
    3990. 

  3990.           $color = imagecolorat($img, $xpx, $ypx);
    3991. 

  3991.           $col = imagecolorsforindex($img, $color);
    3992. 

  3992.           $alpha = $col['alpha'];
    3993. 

  3993. 

  3994.           if ($eight_bit) {
    3995. 

  3995.             // with gamma correction
    3996. 

  3996.             $gammacorr = 2.2;
    3997. 

  3997.             $pixel = pow((((127 - $alpha) * 255 / 127) / 255), $gammacorr) * 255;
    3998. 

  3998.           }
    3999. 

  3999. 

  4000.           else {
    4001. 

  4001.             // without gamma correction
    4002. 

  4002.             $pixel = (127 - $alpha) * 2;
    4003. 

  4003. 

  4004.             $key = $col['red'].$col['green'].$col['blue'];
    4005. 

  4005. 

  4006.             if (!isset($allocated_colors[$key])) {
    4007. 

  4007.               $pixel_img = imagecolorallocate($img, $col['red'], $col['green'], $col['blue']);
    4008. 

  4008.               $allocated_colors[$key] = $pixel_img;
    4009. 

  4009.             }
    4010. 

  4010.             else {
    4011. 

  4011.               $pixel_img = $allocated_colors[$key]; 
    4012. 

  4012.             }
    4013. 

  4013. 

  4014.             imagesetpixel($img, $xpx, $ypx, $pixel_img);
    4015. 

  4015.           }
    4016. 

  4016. 

  4017.           imagesetpixel($imgalpha, $xpx, $ypx, $pixel);
    4018. 

  4018.         }
    4019. 

  4019.       }
    4020. 

  4020. 

  4021.       // extract image without alpha channel
    4022. 

  4022.       $imgplain = imagecreatetruecolor($wpx, $hpx);
    4023. 

  4023.       imagecopy($imgplain, $img, 0, 0, 0, 0, $wpx, $hpx);
    4024. 

  4024.       imagedestroy($img);
    4025. 

  4025. 

  4026.       imagepng($imgalpha, $tempfile_alpha);
    4027. 

  4027.       imagepng($imgplain, $tempfile_plain);
    4028. 

  4028.     }
    4029. 

  4029. 

  4030.     // embed mask image
    4031. 

  4031.     $this->addImagePng($tempfile_alpha, $x, $y, $w, $h, $imgalpha, true);
    4032. 

  4032.     imagedestroy($imgalpha);
    4033. 

  4033. 

  4034.     // embed image, masked with previously embedded mask
    4035. 

  4035.     $this->addImagePng($tempfile_plain, $x, $y, $w, $h, $imgplain, false, true);
    4036. 

  4036.     imagedestroy($imgplain);
    4037. 

  4037. 

  4038.     // remove temp files
    4039. 

  4039.     unlink($tempfile_alpha);
    4040. 

  4040.     unlink($tempfile_plain);
    4041. 

  4041.   }
    4042. 

  4042. 

  4043.   /**
    4044. 

  4044.    * add a PNG image into the document, from a file
    4045. 

  4045.    * this should work with remote files
    4046. 

  4046.    */
    4047. 

  4047.   function addPngFromFile($file, $x, $y, $w = 0, $h = 0) {
    4048. 

  4048.     if (!function_exists("imagecreatefrompng")) {
    4049. 

  4049.       throw new Exception("The PHP GD extension is required, but is not installed.");
    4050. 

  4050.     }
    4051. 

  4051. 

  4052.     //if already cached, need not to read again
    4053. 

  4053.     if ( isset($this->imagelist[$file]) ) {
    4054. 

  4054.       $img = null;
    4055. 

  4055.     } 
    4056. 

  4056. 

  4057.     else {
    4058. 

  4058.       $info = file_get_contents ($file, false, null, 24, 5);
    4059. 

  4059.       $meta = unpack("CbitDepth/CcolorType/CcompressionMethod/CfilterMethod/CinterlaceMethod", $info);
    4060. 

  4060.       $bit_depth = $meta["bitDepth"];
    4061. 

  4061.       $color_type = $meta["colorType"];
    4062. 

  4062. 

  4063.       // http://www.w3.org/TR/PNG/#11IHDR
    4064. 

  4064.       // 3 => indexed
    4065. 

  4065.       // 4 => greyscale with alpha
    4066. 

  4066.       // 6 => fullcolor with alpha
    4067. 

  4067.       $is_alpha = in_array($color_type, array(4, 6)) || ($color_type == 3 && $bit_depth != 4);
    4068. 

  4068. 

  4069.       if ($is_alpha) { // exclude grayscale alpha
    4070. 

  4070.         return $this->addImagePngAlpha($file, $x, $y, $w, $h, $color_type);
    4071. 

  4071.       }
    4072. 

  4072. 

  4073.       //png files typically contain an alpha channel.
    4074. 

  4074.       //pdf file format or class.pdf does not support alpha blending.
    4075. 

  4075.       //on alpha blended images, more transparent areas have a color near black.
    4076. 

  4076.       //This appears in the result on not storing the alpha channel.
    4077. 

  4077.       //Correct would be the box background image or its parent when transparent.
    4078. 

  4078.       //But this would make the image dependent on the background.
    4079. 

  4079.       //Therefore create an image with white background and copy in
    4080. 

  4080.       //A more natural background than black is white.
    4081. 

  4081.       //Therefore create an empty image with white background and merge the
    4082. 

  4082.       //image in with alpha blending.
    4083. 

  4083.       $imgtmp = @imagecreatefrompng($file);
    4084. 

  4084.       if (!$imgtmp) {
    4085. 

  4085.         return;
    4086. 

  4086.       }
    4087. 

  4087.       $sx = imagesx($imgtmp);
    4088. 

  4088.       $sy = imagesy($imgtmp);
    4089. 

  4089.       $img = imagecreatetruecolor($sx,$sy);
    4090. 

  4090.       imagealphablending($img, true);
    4091. 

  4091. 

  4092.       // @todo is it still needed ??
    4093. 

  4093.       $ti = imagecolortransparent($imgtmp);
    4094. 

  4094.       if ($ti >= 0) {
    4095. 

  4095.         $tc = imagecolorsforindex($imgtmp,$ti);
    4096. 

  4096.         $ti = imagecolorallocate($img,$tc['red'],$tc['green'],$tc['blue']);
    4097. 

  4097.         imagefill($img,0,0,$ti);
    4098. 

  4098.         imagecolortransparent($img, $ti);
    4099. 

  4099.       } else {
    4100. 

  4100.         imagefill($img,1,1,imagecolorallocate($img,255,255,255));
    4101. 

  4101.       }
    4102. 

  4102. 

  4103.       imagecopy($img,$imgtmp,0,0,0,0,$sx,$sy);
    4104. 

  4104.       imagedestroy($imgtmp);
    4105. 

  4105.     }
    4106. 

  4106.     $this->addImagePng($file, $x, $y, $w, $h, $img);
    4107. 

  4107. 

  4108.     if ( $img ) {
    4109. 

  4109.       imagedestroy($img);
    4110. 

  4110.     }
    4111. 

  4111.   }
    4112. 

  4112. 

  4113.   /**
    4114. 

  4114.    * add a PNG image into the document, from a memory buffer of the file
    4115. 

  4115.    */
    4116. 

  4116.   function addPngFromBuf($file, $x, $y, $w = 0.0, $h = 0.0, &$data, $is_mask = false, $mask = null) {
    4117. 

  4117.     if ( isset($this->imagelist[$file]) ) {
    4118. 

  4118.       $data = null;
    4119. 

  4119.       $info['width'] = $this->imagelist[$file]['w'];
    4120. 

  4120.       $info['height'] = $this->imagelist[$file]['h'];
    4121. 

  4121.       $label = $this->imagelist[$file]['label'];
    4122. 

  4122.     }
    4123. 

  4123. 

  4124.     else {
    4125. 

  4125.       if ($data == null) {
    4126. 

  4126.         $this->addMessage('addPngFromBuf error - data not present!');
    4127. 

  4127.         return;
    4128. 

  4128.       }
    4129. 

  4129. 

  4130.       $error = 0;
    4131. 

  4131. 

  4132.       if (!$error) {
    4133. 

  4133.         $header = chr(137) .chr(80) .chr(78) .chr(71) .chr(13) .chr(10) .chr(26) .chr(10);
    4134. 

  4134. 

  4135.         if (mb_substr($data, 0, 8, '8bit') != $header) {
    4136. 

  4136.           $error = 1;
    4137. 

  4137. 

  4138.           if (DEBUGPNG) print '[addPngFromFile this file does not have a valid header '.$file.']';
    4139. 

  4139. 

  4140.           $errormsg = 'this file does not have a valid header';
    4141. 

  4141.         }
    4142. 

  4142.       }
    4143. 

  4143. 

  4144.       if (!$error) {
    4145. 

  4145.         // set pointer
    4146. 

  4146.         $p = 8;
    4147. 

  4147.         $len = mb_strlen($data, '8bit');
    4148. 

  4148. 

  4149.         // cycle through the file, identifying chunks
    4150. 

  4150.         $haveHeader = 0;
    4151. 

  4151.         $info = array();
    4152. 

  4152.         $idata = '';
    4153. 

  4153.         $pdata = '';
    4154. 

  4154. 

  4155.         while ($p < $len) {
    4156. 

  4156.           $chunkLen = $this->getBytes($data, $p, 4);
    4157. 

  4157.           $chunkType = mb_substr($data, $p+4, 4, '8bit');
    4158. 

  4158. 

  4159.           switch ($chunkType) {
    4160. 

  4160.           case 'IHDR':
    4161. 

  4161.             // this is where all the file information comes from
    4162. 

  4162.             $info['width'] = $this->getBytes($data, $p+8, 4);
    4163. 

  4163.             $info['height'] = $this->getBytes($data, $p+12, 4);
    4164. 

  4164.             $info['bitDepth'] = ord($data[$p+16]);
    4165. 

  4165.             $info['colorType'] = ord($data[$p+17]);
    4166. 

  4166.             $info['compressionMethod'] = ord($data[$p+18]);
    4167. 

  4167.             $info['filterMethod'] = ord($data[$p+19]);
    4168. 

  4168.             $info['interlaceMethod'] = ord($data[$p+20]);
    4169. 

  4169. 

  4170.             //print_r($info);
    4171. 

  4171.             $haveHeader = 1;
    4172. 

  4172.             if ($info['compressionMethod'] != 0) {
    4173. 

  4173.               $error = 1;
    4174. 

  4174. 

  4175.               //debugpng
    4176. 

  4176.               if (DEBUGPNG) print '[addPngFromFile unsupported compression method '.$file.']';
    4177. 

  4177. 

  4178.               $errormsg = 'unsupported compression method';
    4179. 

  4179.             }
    4180. 

  4180. 

  4181.             if ($info['filterMethod'] != 0) {
    4182. 

  4182.               $error = 1;
    4183. 

  4183. 

  4184.               //debugpng
    4185. 

  4185.               if (DEBUGPNG) print '[addPngFromFile unsupported filter method '.$file.']';
    4186. 

  4186. 

  4187.               $errormsg = 'unsupported filter method';
    4188. 

  4188.             }
    4189. 

  4189.             break;
    4190. 

  4190. 

  4191.           case 'PLTE':
    4192. 

  4192.             $pdata.= mb_substr($data, $p+8, $chunkLen, '8bit');
    4193. 

  4193.             break;
    4194. 

  4194. 

  4195.           case 'IDAT':
    4196. 

  4196.             $idata.= mb_substr($data, $p+8, $chunkLen, '8bit');
    4197. 

  4197.             break;
    4198. 

  4198. 

  4199.           case 'tRNS':
    4200. 

  4200.             //this chunk can only occur once and it must occur after the PLTE chunk and before IDAT chunk
    4201. 

  4201.             //print "tRNS found, color type = ".$info['colorType']."\n";
    4202. 

  4202.             $transparency = array();
    4203. 

  4203. 

  4204.             switch ($info['colorType']) {
    4205. 

  4205.               // indexed color, rbg
    4206. 

  4206.               case 3:
    4207. 

  4207.                 /* corresponding to entries in the plte chunk
    4208. 

  4208.                  Alpha for palette index 0: 1 byte
    4209. 

  4209.                  Alpha for palette index 1: 1 byte
    4210. 

  4210.                  ...etc...
    4211. 

  4211.                 */
    4212. 

  4212.                 // there will be one entry for each palette entry. up until the last non-opaque entry.
    4213. 

  4213.                 // set up an array, stretching over all palette entries which will be o (opaque) or 1 (transparent)
    4214. 

  4214.                 $transparency['type'] = 'indexed';
    4215. 

  4215.                 $trans = 0;
    4216. 

  4216. 

  4217.                 for ($i = $chunkLen; $i >= 0; $i--) {
    4218. 

  4218.                   if (ord($data[$p+8+$i]) == 0) {
    4219. 

  4219.                     $trans = $i;
    4220. 

  4220.                   }
    4221. 

  4221.                 }
    4222. 

  4222. 

  4223.                 $transparency['data'] = $trans;
    4224. 

  4224.               break;
    4225. 

  4225. 

  4226.               // grayscale
    4227. 

  4227.               case 0:
    4228. 

  4228.                 /* corresponding to entries in the plte chunk
    4229. 

  4229.                  Gray: 2 bytes, range 0 .. (2^bitdepth)-1
    4230. 

  4230.                 */
    4231. 

  4231.                 //            $transparency['grayscale'] = $this->PRVT_getBytes($data,$p+8,2); // g = grayscale
    4232. 

  4232.                 $transparency['type'] = 'indexed';
    4233. 

  4233.                 $transparency['data'] = ord($data[$p+8+1]);
    4234. 

  4234.               break;
    4235. 

  4235. 

  4236.               // truecolor
    4237. 

  4237.               case 2:      
    4238. 

  4238.                 /* corresponding to entries in the plte chunk
    4239. 

  4239.                  Red: 2 bytes, range 0 .. (2^bitdepth)-1
    4240. 

  4240.                  Green: 2 bytes, range 0 .. (2^bitdepth)-1
    4241. 

  4241.                  Blue: 2 bytes, range 0 .. (2^bitdepth)-1
    4242. 

  4242.                 */
    4243. 

  4243.                 $transparency['r'] = $this->getBytes($data, $p+8, 2);
    4244. 

  4244.                 // r from truecolor
    4245. 

  4245.                 $transparency['g'] = $this->getBytes($data, $p+10, 2);
    4246. 

  4246.                 // g from truecolor
    4247. 

  4247.                 $transparency['b'] = $this->getBytes($data, $p+12, 2);
    4248. 

  4248.                 // b from truecolor
    4249. 

  4249. 

  4250.                 $transparency['type'] = 'color-key';
    4251. 

  4251.               break;
    4252. 

  4252. 

  4253.               //unsupported transparency type
    4254. 

  4254.               default:
    4255. 

  4255.                 if (DEBUGPNG) print '[addPngFromFile unsupported transparency type '.$file.']';
    4256. 

  4256.                 break;
    4257. 

  4257.             }
    4258. 

  4258. 

  4259.             // KS End new code
    4260. 

  4260.             break;
    4261. 

  4261. 

  4262.           default:
    4263. 

  4263.             break;
    4264. 

  4264.           }
    4265. 

  4265. 

  4266.           $p += $chunkLen+12;
    4267. 

  4267.         }
    4268. 

  4268. 

  4269.         if (!$haveHeader) {
    4270. 

  4270.           $error = 1;
    4271. 

  4271. 

  4272.           //debugpng
    4273. 

  4273.           if (DEBUGPNG) print '[addPngFromFile information header is missing '.$file.']';
    4274. 

  4274. 

  4275.           $errormsg = 'information header is missing';
    4276. 

  4276.         }
    4277. 

  4277. 

  4278.         if (isset($info['interlaceMethod']) && $info['interlaceMethod']) {
    4279. 

  4279.           $error = 1;
    4280. 

  4280. 

  4281.           //debugpng
    4282. 

  4282.           if (DEBUGPNG) print '[addPngFromFile no support for interlaced images in pdf '.$file.']';
    4283. 

  4283. 

  4284.           $errormsg = 'There appears to be no support for interlaced images in pdf.';
    4285. 

  4285.         }
    4286. 

  4286.       }
    4287. 

  4287. 

  4288.       if (!$error && $info['bitDepth'] > 8) {
    4289. 

  4289.         $error = 1;
    4290. 

  4290. 

  4291.         //debugpng
    4292. 

  4292.         if (DEBUGPNG) print '[addPngFromFile bit depth of 8 or less is supported '.$file.']';
    4293. 

  4293. 

  4294.         $errormsg = 'only bit depth of 8 or less is supported';
    4295. 

  4295.       }
    4296. 

  4296.   
    4297. 

  4297.       if (!$error) {
    4298. 

  4298.         switch ($info['colorType']) {
    4299. 

  4299.         case 3:
    4300. 

  4300.           $color = 'DeviceRGB';
    4301. 

  4301.           $ncolor = 1;
    4302. 

  4302.           break;
    4303. 

  4303. 

  4304.         case 2:
    4305. 

  4305.           $color = 'DeviceRGB';
    4306. 

  4306.           $ncolor = 3;
    4307. 

  4307.           break;
    4308. 

  4308. 

  4309.         case 0:
    4310. 

  4310.           $color = 'DeviceGray';
    4311. 

  4311.           $ncolor = 1;
    4312. 

  4312.           break;
    4313. 

  4313. 

  4314.         default: 
    4315. 

  4315.           $error = 1;
    4316. 

  4316. 

  4317.           //debugpng
    4318. 

  4318.           if (DEBUGPNG) print '[addPngFromFile alpha channel not supported: '.$info['colorType'].' '.$file.']';
    4319. 

  4319. 

  4320.           $errormsg = 'transparancey alpha channel not supported, transparency only supported for palette images.';
    4321. 

  4321.         }
    4322. 

  4322.       }
    4323. 

  4323. 

  4324.       if ($error) {
    4325. 

  4325.         $this->addMessage('PNG error - ('.$file.') '.$errormsg);
    4326. 

  4326.         return;
    4327. 

  4327.       }
    4328. 

  4328. 

  4329.       //print_r($info);
    4330. 

  4330.       // so this image is ok... add it in.
    4331. 

  4331.       $this->numImages++;
    4332. 

  4332.       $im = $this->numImages;
    4333. 

  4333.       $label = "I$im";
    4334. 

  4334.       $this->numObj++;
    4335. 

  4335. 

  4336.       //  $this->o_image($this->numObj,'new',array('label' => $label,'data' => $idata,'iw' => $w,'ih' => $h,'type' => 'png','ic' => $info['width']));
    4337. 

  4337.       $options = array(
    4338. 

  4338.         'label' => $label,
    4339. 

  4339.         'data' => $idata,
    4340. 

  4340.         'bitsPerComponent' => $info['bitDepth'],
    4341. 

  4341.         'pdata' => $pdata,
    4342. 

  4342.         'iw' => $info['width'],
    4343. 

  4343.         'ih' => $info['height'],
    4344. 

  4344.         'type' => 'png',
    4345. 

  4345.         'color' => $color,
    4346. 

  4346.         'ncolor' => $ncolor,
    4347. 

  4347.         'masked' => $mask,
    4348. 

  4348.         'isMask' => $is_mask
    4349. 

  4349.       );
    4350. 

  4350. 

  4351.       if (isset($transparency)) {
    4352. 

  4352.         $options['transparency'] = $transparency;
    4353. 

  4353.       }
    4354. 

  4354. 

  4355.       $this->o_image($this->numObj, 'new', $options);
    4356. 

  4356.       $this->imagelist[$file] = array('label' =>$label, 'w' => $info['width'], 'h' => $info['height']);
    4357. 

  4357.     }
    4358. 

  4358. 

  4359.     if ($is_mask) {
    4360. 

  4360.       return;
    4361. 

  4361.     }
    4362. 

  4362. 

  4363.     if ($w <= 0 && $h <= 0) {
    4364. 

  4364.       $w = $info['width'];
    4365. 

  4365.       $h = $info['height'];
    4366. 

  4366.     }
    4367. 

  4367. 

  4368.     if ($w <= 0) {
    4369. 

  4369.       $w = $h/$info['height']*$info['width'];
    4370. 

  4370.     }
    4371. 

  4371. 

  4372.     if ($h <= 0) {
    4373. 

  4373.       $h = $w*$info['height']/$info['width'];
    4374. 

  4374.     }
    4375. 

  4375. 

  4376.     $this->addContent(sprintf("\nq\n%.3F 0 0 %.3F %.3F %.3F cm /%s Do\nQ", $w, $h, $x, $y, $label));
    4377. 

  4377.   }
    4378. 

  4378. 

  4379.   /**
    4380. 

  4380.    * add a JPEG image into the document, from a file
    4381. 

  4381.    */
    4382. 

  4382.   function addJpegFromFile($img, $x, $y, $w = 0, $h = 0) {
    4383. 

  4383.     // attempt to add a jpeg image straight from a file, using no GD commands
    4384. 

  4384.     // note that this function is unable to operate on a remote file.
    4385. 

  4385. 

  4386.     if (!file_exists($img)) {
    4387. 

  4387.       return;
    4388. 

  4388.     }
    4389. 

  4389. 

  4390.     if ( $this->image_iscached($img) ) {
    4391. 

  4391.       $data = null;
    4392. 

  4392.       $imageWidth  = $this->imagelist[$img]['w'];
    4393. 

  4393.       $imageHeight = $this->imagelist[$img]['h'];
    4394. 

  4394.       $channels    = $this->imagelist[$img]['c'];
    4395. 

  4395.     } 
    4396. 

  4396.     else {
    4397. 

  4397.       $tmp = getimagesize($img);
    4398. 

  4398.       $imageWidth  = $tmp[0];
    4399. 

  4399.       $imageHeight = $tmp[1];
    4400. 

  4400. 

  4401.       if ( isset($tmp['channels']) ) {
    4402. 

  4402.         $channels = $tmp['channels'];
    4403. 

  4403.       } else {
    4404. 

  4404.         $channels = 3;
    4405. 

  4405.       }
    4406. 

  4406. 

  4407.       $data = file_get_contents($img);
    4408. 

  4408.     }
    4409. 

  4409. 

  4410.     if ($w <= 0 && $h <= 0) {
    4411. 

  4411.       $w = $imageWidth;
    4412. 

  4412.     }
    4413. 

  4413. 

  4414.     if ($w == 0) {
    4415. 

  4415.       $w = $h/$imageHeight*$imageWidth;
    4416. 

  4416.     }
    4417. 

  4417. 

  4418.     if ($h == 0) {
    4419. 

  4419.       $h = $w*$imageHeight/$imageWidth;
    4420. 

  4420.     }
    4421. 

  4421. 

  4422.     $this->addJpegImage_common($data, $x, $y, $w, $h, $imageWidth, $imageHeight, $channels, $img);
    4423. 

  4423.   }
    4424. 

  4424. 

  4425.   /**
    4426. 

  4426.    * common code used by the two JPEG adding functions
    4427. 

  4427.    */
    4428. 

  4428.   private function addJpegImage_common(&$data, $x, $y, $w = 0, $h = 0, $imageWidth, $imageHeight, $channels = 3, $imgname) {
    4429. 

  4429.     if ( $this->image_iscached($imgname) ) {
    4430. 

  4430.       $label = $this->imagelist[$imgname]['label'];
    4431. 

  4431.       //debugpng
    4432. 

  4432.       //if (DEBUGPNG) print '[addJpegImage_common Duplicate '.$imgname.']';
    4433. 

  4433. 

  4434.     } else {
    4435. 

  4435.       if ($data == null) {
    4436. 

  4436.         $this->addMessage('addJpegImage_common error - ('.$imgname.') data not present!');
    4437. 

  4437.         return;
    4438. 

  4438.       }
    4439. 

  4439. 

  4440.       // note that this function is not to be called externally
    4441. 

  4441.       // it is just the common code between the GD and the file options
    4442. 

  4442.       $this->numImages++;
    4443. 

  4443.       $im = $this->numImages;
    4444. 

  4444.       $label = "I$im";
    4445. 

  4445.       $this->numObj++;
    4446. 

  4446. 

  4447.       $this->o_image($this->numObj, 'new', array(
    4448. 

  4448.         'label' => $label, 
    4449. 

  4449.         'data' => &$data, 
    4450. 

  4450.         'iw' => $imageWidth, 
    4451. 

  4451.         'ih' => $imageHeight, 
    4452. 

  4452.         'channels' => $channels
    4453. 

  4453.       ));
    4454. 

  4454. 

  4455.       $this->imagelist[$imgname] = array('label' =>$label, 'w' => $imageWidth, 'h' => $imageHeight, 'c'=> $channels);
    4456. 

  4456.     }
    4457. 

  4457. 

  4458.     $this->addContent(sprintf("\nq\n%.3F 0 0 %.3F %.3F %.3F cm /%s Do\nQ ", $w, $h, $x, $y, $label));
    4459. 

  4459.   }
    4460. 

  4460. 

  4461.   /**
    4462. 

  4462.    * specify where the document should open when it first starts
    4463. 

  4463.    */
    4464. 

  4464.   function openHere($style, $a = 0, $b = 0, $c = 0) {
    4465. 

  4465.     // this function will open the document at a specified page, in a specified style
    4466. 

  4466.     // the values for style, and the required paramters are:
    4467. 

  4467.     // 'XYZ'  left, top, zoom
    4468. 

  4468.     // 'Fit'
    4469. 

  4469.     // 'FitH' top
    4470. 

  4470.     // 'FitV' left
    4471. 

  4471.     // 'FitR' left,bottom,right
    4472. 

  4472.     // 'FitB'
    4473. 

  4473.     // 'FitBH' top
    4474. 

  4474.     // 'FitBV' left
    4475. 

  4475.     $this->numObj++;
    4476. 

  4476.     $this->o_destination($this->numObj, 'new', array('page' => $this->currentPage, 'type' => $style, 'p1' => $a, 'p2' => $b, 'p3' => $c));
    4477. 

  4477.     $id = $this->catalogId;
    4478. 

  4478.     $this->o_catalog($id, 'openHere', $this->numObj);
    4479. 

  4479.   }
    4480. 

  4480. 

  4481.   /**
    4482. 

  4482.    * Add JavaScript code to the PDF document
    4483. 

  4483.    * 
    4484. 

  4484.    * @param string $code
    4485. 

  4485.    * @return void
    4486. 

  4486.    */
    4487. 

  4487.   function addJavascript($code) {
    4488. 

  4488.     $this->javascript .= $code;
    4489. 

  4489.   }
    4490. 

  4490. 

  4491.   /**
    4492. 

  4492.    * create a labelled destination within the document
    4493. 

  4493.    */
    4494. 

  4494.   function addDestination($label, $style, $a = 0, $b = 0, $c = 0) {
    4495. 

  4495.     // associates the given label with the destination, it is done this way so that a destination can be specified after
    4496. 

  4496.     // it has been linked to
    4497. 

  4497.     // styles are the same as the 'openHere' function
    4498. 

  4498.     $this->numObj++;
    4499. 

  4499.     $this->o_destination($this->numObj, 'new', array('page' => $this->currentPage, 'type' => $style, 'p1' => $a, 'p2' => $b, 'p3' => $c));
    4500. 

  4500.     $id = $this->numObj;
    4501. 

  4501. 

  4502.     // store the label->idf relationship, note that this means that labels can be used only once
    4503. 

  4503.     $this->destinations["$label"] = $id;
    4504. 

  4504.   }
    4505. 

  4505. 

  4506.   /**
    4507. 

  4507.    * define font families, this is used to initialize the font families for the default fonts
    4508. 

  4508.    * and for the user to add new ones for their fonts. The default bahavious can be overridden should
    4509. 

  4509.    * that be desired.
    4510. 

  4510.    */
    4511. 

  4511.   function setFontFamily($family, $options = '') {
    4512. 

  4512.     if (!is_array($options)) {
    4513. 

  4513.       if ($family === 'init') {
    4514. 

  4514.         // set the known family groups
    4515. 

  4515.         // these font families will be used to enable bold and italic markers to be included
    4516. 

  4516.         // within text streams. html forms will be used... <b></b> <i></i>
    4517. 

  4517.         $this->fontFamilies['Helvetica.afm'] =
    4518. 

  4518.           array(
    4519. 

  4519.             'b'  => 'Helvetica-Bold.afm',
    4520. 

  4520.             'i'  => 'Helvetica-Oblique.afm',
    4521. 

  4521.             'bi' => 'Helvetica-BoldOblique.afm',
    4522. 

  4522.             'ib' => 'Helvetica-BoldOblique.afm'
    4523. 

  4523.           );
    4524. 

  4524. 

  4525.         $this->fontFamilies['Courier.afm'] =
    4526. 

  4526.           array(
    4527. 

  4527.             'b'  => 'Courier-Bold.afm',
    4528. 

  4528.             'i'  => 'Courier-Oblique.afm',
    4529. 

  4529.             'bi' => 'Courier-BoldOblique.afm',
    4530. 

  4530.             'ib' => 'Courier-BoldOblique.afm'
    4531. 

  4531.           );
    4532. 

  4532. 

  4533.         $this->fontFamilies['Times-Roman.afm'] =
    4534. 

  4534.           array(
    4535. 

  4535.             'b'  => 'Times-Bold.afm',
    4536. 

  4536.             'i'  => 'Times-Italic.afm',
    4537. 

  4537.             'bi' => 'Times-BoldItalic.afm',
    4538. 

  4538.             'ib' => 'Times-BoldItalic.afm'
    4539. 

  4539.           );
    4540. 

  4540.       }
    4541. 

  4541.     } else {
    4542. 

  4542. 

  4543.       // the user is trying to set a font family
    4544. 

  4544.       // note that this can also be used to set the base ones to something else
    4545. 

  4545.       if (mb_strlen($family)) {
    4546. 

  4546.         $this->fontFamilies[$family] = $options;
    4547. 

  4547.       }
    4548. 

  4548.     }
    4549. 

  4549.   }
    4550. 

  4550. 

  4551.   /**
    4552. 

  4552.    * used to add messages for use in debugging
    4553. 

  4553.    */
    4554. 

  4554.   function addMessage($message) {
    4555. 

  4555.     $this->messages.=  $message."\n";
    4556. 

  4556.   }
    4557. 

  4557. 

  4558.   /**
    4559. 

  4559.    * a few functions which should allow the document to be treated transactionally.
    4560. 

  4560.    */
    4561. 

  4561.   function transaction($action) {
    4562. 

  4562.     switch ($action) {
    4563. 

  4563.     case 'start':
    4564. 

  4564.       // store all the data away into the checkpoint variable
    4565. 

  4565.       $data = get_object_vars($this);
    4566. 

  4566.       $this->checkpoint = $data;
    4567. 

  4567.       unset($data);
    4568. 

  4568.       break;
    4569. 

  4569. 

  4570.     case 'commit':
    4571. 

  4571.       if (is_array($this->checkpoint) && isset($this->checkpoint['checkpoint'])) {
    4572. 

  4572.         $tmp = $this->checkpoint['checkpoint'];
    4573. 

  4573.         $this->checkpoint = $tmp;
    4574. 

  4574.         unset($tmp);
    4575. 

  4575.       } else {
    4576. 

  4576.         $this->checkpoint = '';
    4577. 

  4577.       }
    4578. 

  4578.       break;
    4579. 

  4579. 

  4580.     case 'rewind':
    4581. 

  4581.       // do not destroy the current checkpoint, but move us back to the state then, so that we can try again
    4582. 

  4582.       if (is_array($this->checkpoint)) {
    4583. 

  4583.         // can only abort if were inside a checkpoint
    4584. 

  4584.         $tmp = $this->checkpoint;
    4585. 

  4585. 

  4586.         foreach ($tmp as $k => $v) {
    4587. 

  4587.           if ($k !== 'checkpoint') {
    4588. 

  4588.             $this->$k = $v;
    4589. 

  4589.           }
    4590. 

  4590.         }
    4591. 

  4591.         unset($tmp);
    4592. 

  4592.       }
    4593. 

  4593.       break;
    4594. 

  4594. 

  4595.     case 'abort':
    4596. 

  4596.       if (is_array($this->checkpoint)) {
    4597. 

  4597.         // can only abort if were inside a checkpoint
    4598. 

  4598.         $tmp = $this->checkpoint;
    4599. 

  4599.         foreach ($tmp as $k => $v) {
    4600. 

  4600.           $this->$k = $v;
    4601. 

  4601.         }
    4602. 

  4602.         unset($tmp);
    4603. 

  4603.       }
    4604. 

  4604.       break;
    4605. 

  4605.     }
    4606. 

  4606.   }
    4607. 

  4607. }
    4608. 

  4608.