PageRenderTime 39ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 0ms

/include/PHPExcel/Writer/PDF/lib/class.pdf.php

https://bitbucket.org/ite/on-track-code-base
PHP | 4969 lines | 3043 code | 784 blank | 1142 comment | 596 complexity | ab5c62b1af242d660d87ef6bf6972eee MD5 | raw file
    

  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.  * @version $Id: class.pdf.php 469 2012-02-05 22:25:30Z fabien.menager $
    16. 

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

  17.  * @package Cpdf
    18. 

  18.  */
    19. 

  19. class Cpdf {
    20. 

  20.   
    21. 

  21.   /**
    22. 

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

  23.    */
    24. 

  24.   public  $numObj = 0;
    25. 

  25. 

  26.   /**
    27. 

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

  28.    */
    29. 

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

  30. 

  31.   /**
    32. 

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

  33.    */
    34. 

  34.   public  $catalogId;
    35. 

  35. 

  36.   /**
    37. 

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

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

  39.    */
    40. 

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

  41.   
    42. 

  42.   /**
    43. 

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

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

  45.    */
    46. 

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

  47.   
    48. 

  48.   /**
    49. 

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

  50.    */
    51. 

  51.   public  $currentFont = '';
    52. 

  52. 

  53.   /**
    54. 

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

  55.    */
    56. 

  56.   public  $currentBaseFont = '';
    57. 

  57. 

  58.   /**
    59. 

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

  60.    */
    61. 

  61.   public  $currentFontNum = 0;
    62. 

  62. 

  63.   /**
    64. 

  64.    * @var integer
    65. 

  65.    */
    66. 

  66.   public  $currentNode;
    67. 

  67. 

  68.   /**
    69. 

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

  70.    */
    71. 

  71.   public  $currentPage;
    72. 

  72. 

  73.   /**
    74. 

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

  75.    */
    76. 

  76.   public  $currentContents;
    77. 

  77. 

  78.   /**
    79. 

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

  80.    */
    81. 

  81.   public  $numFonts = 0;
    82. 

  82. 

  83.   /**
    84. 

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

  85.    */
    86. 

  86.   private  $numStates =  0;
    87. 

  87. 

  88.   /**
    89. 

  89.    * @var array Current colour for fill operations, defaults to inactive value, 
    90. 

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

  91.    */
    92. 

  92.   public  $currentColour = null;
    93. 

  93. 

  94.   /**
    95. 

  95.    * @var array Current colour for stroke operations (lines etc.)
    96. 

  96.    */
    97. 

  97.   public  $currentStrokeColour = null;
    98. 

  98. 

  99.   /**
    100. 

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

  101.    */
    102. 

  102.   public  $currentLineStyle = '';
    103. 

  103. 

  104.   /**
    105. 

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

  106.    */
    107. 

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

  108.   
    109. 

  109.   /**
    110. 

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

  111.    */
    112. 

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

  113.   
    114. 

  114.   /**
    115. 

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

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

  117.    */
    118. 

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

  119. 

  120.   /**
    121. 

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

  122.    */
    123. 

  123.   public  $nStateStack =  0;
    124. 

  124. 

  125.   /**
    126. 

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

  127.    */
    128. 

  128.   public  $numPages = 0;
    129. 

  129. 

  130.   /**
    131. 

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

  132.    */
    133. 

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

  134. 

  135.   /**
    136. 

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

  137.    */
    138. 

  138.   public  $nStack = 0;
    139. 

  139. 

  140.   /**
    141. 

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

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

  143.    */
    144. 

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

  145. 

  146.   /**
    147. 

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

  148.    */
    149. 

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

  150. 

  151.   /**
    152. 

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

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

  154.    */
    155. 

  155.   public  $infoObject = 0;
    156. 

  156. 

  157.   /**
    158. 

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

  159.    */
    160. 

  160.   public  $numImages = 0;
    161. 

  161. 

  162.   /**
    163. 

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

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

  165.    */
    166. 

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

  167. 

  168.   /**
    169. 

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

  170.    */
    171. 

  171.   public  $firstPageId;
    172. 

  172. 

  173.   /**
    174. 

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

  175.    * when the spacing is changed.
    176. 

  176.    */
    177. 

  177.   public  $wordSpaceAdjust = 0;
    178. 

  178. 

  179.   /**
    180. 

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

  181.    * when the spacing is changed.
    182. 

  182.    */
    183. 

  183.   public  $charSpaceAdjust = 0;
    184. 

  184.   
    185. 

  185.   /**
    186. 

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

  187.    */
    188. 

  188.   public  $procsetObjectId;
    189. 

  189. 

  190.   /**
    191. 

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

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

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

  194.    */
    195. 

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

  196.  
    197. 

  197.   /**
    198. 

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

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

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

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

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

  203.    */
    204. 

  204.   public  $fontcache = '';
    205. 

  205.   
    206. 

  206.   /**
    207. 

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

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

  209.    */
    210. 

  210.   public  $fontcacheVersion = 5;
    211. 

  211. 

  212.   /**
    213. 

  213.    * @var string Temporary folder.
    214. 

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

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

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

  217.    */
    218. 

  218.   public  $tmp = '';
    219. 

  219. 

  220.   /**
    221. 

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

  222.    */
    223. 

  223.   public  $currentTextState =  '';
    224. 

  224. 

  225.   /**
    226. 

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

  227.    */
    228. 

  228.   public  $messages = '';
    229. 

  229. 

  230.   /**
    231. 

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

  232.    */
    233. 

  233.   public  $arc4 = '';
    234. 

  234. 

  235.   /**
    236. 

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

  237.    */
    238. 

  238.   public  $arc4_objnum = 0;
    239. 

  239. 

  240.   /**
    241. 

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

  242.    */
    243. 

  243.   public  $fileIdentifier = '';
    244. 

  244. 

  245.   /**
    246. 

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

  247.    */
    248. 

  248.   public  $encrypted = false;
    249. 

  249. 

  250.   /**
    251. 

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

  252.    */
    253. 

  253.   public  $encryptionKey = '';
    254. 

  254. 

  255.   /**
    256. 

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

  257.    */
    258. 

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

  259. 

  260.   /**
    261. 

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

  262.    */
    263. 

  263.   public  $nCallback =  0;
    264. 

  264. 

  265.   /**
    266. 

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

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

  268.    */
    269. 

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

  270. 

  271.   /**
    272. 

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

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

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

  275.    */
    276. 

  276.   public  $checkpoint =  '';
    277. 

  277. 

  278.   /**
    279. 

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

  280.    * Allows to merge identical images
    281. 

  281.    */
    282. 

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

  283. 

  284.   /**
    285. 

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

  286.    */
    287. 

  287.   public  $isUnicode = false;
    288. 

  288. 

  289.   /**
    290. 

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

  291.    */
    292. 

  292.   public  $javascript = '';
    293. 

  293. 

  294.   /**
    295. 

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

  296.    */
    297. 

  297.   protected $compressionReady = false;
    298. 

  298. 

  299.   /**
    300. 

  300.    * @var array Current page size
    301. 

  301.    */
    302. 

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

  303.   
    304. 

  304.   /**
    305. 

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

  306.    */
    307. 

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

  308.   
    309. 

  309.   /**
    310. 

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

  311.    */
    312. 

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

  313.   
    314. 

  314.   /**
    315. 

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

  316.    */
    317. 

  317.   static protected $coreFonts = array(
    318. 

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

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

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

  321.     'symbol', 'zapfdingbats'
    322. 

  322.   );
    323. 

  323.   
    324. 

  324.   /**
    325. 

  325.    * class constructor
    326. 

  326.    * this will start a new document
    327. 

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

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

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

  330.    * @var 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. 

  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. 

  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. 

  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.       } else {
    523. 

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

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

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

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

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

  528. 

  529.             // then there is a match
    530. 

  530.             // make a space
    531. 

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

  532.             case  'before':
    533. 

  533.               $k =  $i;
    534. 

  534.               break;
    535. 

  535. 

  536.             case  'after':
    537. 

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

  538.               break;
    539. 

  539. 

  540.             default:
    541. 

  541.               $k = -1;
    542. 

  542.               break;
    543. 

  543.             }
    544. 

  544. 

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

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

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

  548.               }
    549. 

  549. 

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

  551.             }
    552. 

  552.           }
    553. 

  553.         }
    554. 

  554.       }
    555. 

  555.       break;
    556. 

  556. 

  557.     case  'procset':
    558. 

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

  559.       break;
    560. 

  560. 

  561.     case  'mediaBox':
    562. 

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

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

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

  565.       break;
    566. 

  566. 

  567.     case  'font':
    568. 

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

  569.       break;
    570. 

  570. 

  571.     case  'extGState':
    572. 

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

  573.       break;
    574. 

  574. 

  575.     case  'xObject':
    576. 

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

  577.       break;
    578. 

  578. 

  579.     case  'out':
    580. 

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

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

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

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

  584.         }
    585. 

  585. 

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

  587. 

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

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

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

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

  592. 

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

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

  595.           }
    596. 

  596. 

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

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

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

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

  601.             }
    602. 

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

  603.           }
    604. 

  604. 

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

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

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

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

  609.             }
    610. 

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

  611.           }
    612. 

  612. 

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

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

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

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

  617.             }
    618. 

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

  619.           }
    620. 

  620. 

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

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

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

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

  625.           }
    626. 

  626.         }
    627. 

  627. 

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

  629.       } else {
    630. 

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

  631.       }
    632. 

  632. 

  633.       return  $res;
    634. 

  634.     }
    635. 

  635.   }
    636. 

  636. 

  637.   /**
    638. 

  638.    * define the outlines in the doc, empty for now
    639. 

  639.    */
    640. 

  640.   protected function  o_outlines($id, $action, $options = '') {
    641. 

  641.     if  ($action !== 'new') {
    642. 

  642.       $o = & $this->objects[$id];
    643. 

  643.     }
    644. 

  644. 

  645.     switch  ($action) {
    646. 

  646.     case  'new':
    647. 

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

  648.       $this->o_catalog($this->catalogId, 'outlines', $id);
    649. 

  649.       break;
    650. 

  650. 

  651.     case  'outline':
    652. 

  652.       $o['info']['outlines'][] = $options;
    653. 

  653.       break;
    654. 

  654. 

  655.     case  'out':
    656. 

  656.       if  (count($o['info']['outlines'])) {
    657. 

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

  658.         foreach($o['info']['outlines'] as  $v) {
    659. 

  659.           $res.= "$v 0 R ";
    660. 

  660.         }
    661. 

  661. 

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

  663.       } else {
    664. 

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

  665.       }
    666. 

  666. 

  667.       return  $res;
    668. 

  668.     }
    669. 

  669.   }
    670. 

  670. 

  671.   /**
    672. 

  672.    * an object to hold the font description
    673. 

  673.    */
    674. 

  674.   protected function  o_font($id, $action, $options = '') {
    675. 

  675.     if  ($action !== 'new') {
    676. 

  676.       $o = & $this->objects[$id];
    677. 

  677.     }
    678. 

  678. 

  679.     switch  ($action) {
    680. 

  680.     case  'new':
    681. 

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

  682.       $fontNum =  $this->numFonts;
    683. 

  683.       $this->objects[$id]['info']['fontNum'] =  $fontNum;
    684. 

  684. 

  685.       // deal with the encoding and the differences
    686. 

  686.       if  (isset($options['differences'])) {
    687. 

  687.         // then we'll need an encoding dictionary
    688. 

  688.         $this->numObj++;
    689. 

  689.         $this->o_fontEncoding($this->numObj, 'new', $options);
    690. 

  690.         $this->objects[$id]['info']['encodingDictionary'] =  $this->numObj;
    691. 

  691.       } else  if  (isset($options['encoding'])) {
    692. 

  692.         // we can specify encoding here
    693. 

  693.         switch ($options['encoding']) {
    694. 

  694.         case  'WinAnsiEncoding':
    695. 

  695.         case  'MacRomanEncoding':
    696. 

  696.         case  'MacExpertEncoding':
    697. 

  697.           $this->objects[$id]['info']['encoding'] =  $options['encoding'];
    698. 

  698.           break;
    699. 

  699. 

  700.         case  'none':
    701. 

  701.           break;
    702. 

  702. 

  703.         default:
    704. 

  704.           $this->objects[$id]['info']['encoding'] =  'WinAnsiEncoding';
    705. 

  705.           break;
    706. 

  706.         }
    707. 

  707.       } else {
    708. 

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

  709.       }
    710. 

  710. 

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

  712.         // For Unicode fonts, we need to incorporate font data into
    713. 

  713.         // sub-sections that are linked from the primary font section.
    714. 

  714.         // Look at o_fontGIDtoCID and o_fontDescendentCID functions
    715. 

  715.         // for more informaiton.
    716. 

  716.         //
    717. 

  717.         // All of this code is adapted from the excellent changes made to
    718. 

  718.         // transform FPDF to TCPDF (http://tcpdf.sourceforge.net/)
    719. 

  719. 

  720.         $toUnicodeId = ++$this->numObj;
    721. 

  721.         $this->o_contents($toUnicodeId, 'new', 'raw');
    722. 

  722.         $this->objects[$id]['info']['toUnicode'] = $toUnicodeId;
    723. 

  723.         
    724. 

  724.         $stream =  <<<EOT
    725. 

  725. /CIDInit /ProcSet findresource begin
    726. 

  726. 12 dict begin
    727. 

  727. begincmap
    728. 

  728. /CIDSystemInfo
    729. 

  729. <</Registry (Adobe)
    730. 

  730. /Ordering (UCS)
    731. 

  731. /Supplement 0
    732. 

  732. >> def
    733. 

  733. /CMapName /Adobe-Identity-UCS def
    734. 

  734. /CMapType 2 def
    735. 

  735. 1 begincodespacerange
    736. 

  736. <0000> <FFFF>
    737. 

  737. endcodespacerange
    738. 

  738. 1 beginbfrange
    739. 

  739. <0000> <FFFF> <0000>
    740. 

  740. endbfrange
    741. 

  741. endcmap
    742. 

  742. CMapName currentdict /CMap defineresource pop
    743. 

  743. end
    744. 

  744. end
    745. 

  745. EOT;
    746. 

  746. 

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

  748.         $res .=  "stream\n" . $stream . "endstream";
    749. 

  749. 

  750.         $this->objects[$toUnicodeId]['c'] = $res;
    751. 

  751. 

  752.         $cidFontId = ++$this->numObj;
    753. 

  753.         $this->o_fontDescendentCID($cidFontId, 'new', $options);
    754. 

  754.         $this->objects[$id]['info']['cidFont'] = $cidFontId;
    755. 

  755.       }
    756. 

  756.       
    757. 

  757.       // also tell the pages node about the new font
    758. 

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

  759.       break;
    760. 

  760. 

  761.     case  'add':
    762. 

  762.       foreach ($options as  $k => $v) {
    763. 

  763.         switch  ($k) {
    764. 

  764.         case  'BaseFont':
    765. 

  765.           $o['info']['name'] =  $v;
    766. 

  766.           break;
    767. 

  767.         case  'FirstChar':
    768. 

  768.         case  'LastChar':
    769. 

  769.         case  'Widths':
    770. 

  770.         case  'FontDescriptor':
    771. 

  771.         case  'SubType':
    772. 

  772.           $this->addMessage('o_font '.$k." : ".$v);
    773. 

  773.           $o['info'][$k] =  $v;
    774. 

  774.           break;
    775. 

  775.         }
    776. 

  776.       }
    777. 

  777. 

  778.       // pass values down to descendent font
    779. 

  779.       if (isset($o['info']['cidFont'])) {
    780. 

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

  781.       }
    782. 

  782.       break;
    783. 

  783. 

  784.     case  'out':
    785. 

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

  786.         // For Unicode fonts, we need to incorporate font data into
    787. 

  787.         // sub-sections that are linked from the primary font section.
    788. 

  788.         // Look at o_fontGIDtoCID and o_fontDescendentCID functions
    789. 

  789.         // for more informaiton.
    790. 

  790.         //
    791. 

  791.         // All of this code is adapted from the excellent changes made to
    792. 

  792.         // transform FPDF to TCPDF (http://tcpdf.sourceforge.net/)
    793. 

  793. 

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

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

  796. 

  797.         // The horizontal identity mapping for 2-byte CIDs; may be used
    798. 

  798.         // with CIDFonts using any Registry, Ordering, and Supplement values.
    799. 

  799.         $res.=  "/Encoding /Identity-H\n";
    800. 

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

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

  802.         $res.=  ">>\n";
    803. 

  803.         $res.=  "endobj";
    804. 

  804.       } else {
    805. 

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

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

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

  808.   
    809. 

  809.         if  (isset($o['info']['encodingDictionary'])) {
    810. 

  810.           // then place a reference to the dictionary
    811. 

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

  812.         } else  if  (isset($o['info']['encoding'])) {
    813. 

  813.           // use the specified encoding
    814. 

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

  815.         }
    816. 

  816.   
    817. 

  817.         if  (isset($o['info']['FirstChar'])) {
    818. 

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

  819.         }
    820. 

  820.   
    821. 

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

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

  823.         }
    824. 

  824.   
    825. 

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

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

  827.         }
    828. 

  828.   
    829. 

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

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

  831.         }
    832. 

  832. 

  833.         $res.=  ">>\n";
    834. 

  834.         $res.=  "endobj";
    835. 

  835.       }
    836. 

  836. 

  837.       return  $res;
    838. 

  838.     }
    839. 

  839.   }
    840. 

  840. 

  841.   /**
    842. 

  842.    * a font descriptor, needed for including additional fonts
    843. 

  843.    */
    844. 

  844.   protected function  o_fontDescriptor($id, $action, $options = '') {
    845. 

  845.     if  ($action !== 'new') {
    846. 

  846.       $o = & $this->objects[$id];
    847. 

  847.     }
    848. 

  848. 

  849.     switch  ($action) {
    850. 

  850.     case  'new':
    851. 

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

  852.       break;
    853. 

  853. 

  854.     case  'out':
    855. 

  855.       $res = "\n$id 0 obj\n<< /Type /FontDescriptor\n";
    856. 

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

  857.         switch  ($label) {
    858. 

  858.         case  'Ascent':
    859. 

  859.         case  'CapHeight':
    860. 

  860.         case  'Descent':
    861. 

  861.         case  'Flags':
    862. 

  862.         case  'ItalicAngle':
    863. 

  863.         case  'StemV':
    864. 

  864.         case  'AvgWidth':
    865. 

  865.         case  'Leading':
    866. 

  866.         case  'MaxWidth':
    867. 

  867.         case  'MissingWidth':
    868. 

  868.         case  'StemH':
    869. 

  869.         case  'XHeight':
    870. 

  870.         case  'CharSet':
    871. 

  871.           if  (mb_strlen($value, '8bit')) {
    872. 

  872.             $res.= "/$label $value\n";
    873. 

  873.           }
    874. 

  874. 

  875.           break;
    876. 

  876.         case  'FontFile':
    877. 

  877.         case  'FontFile2':
    878. 

  878.         case  'FontFile3':
    879. 

  879.           $res.= "/$label $value 0 R\n";
    880. 

  880.           break;
    881. 

  881. 

  882.         case  'FontBBox':
    883. 

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

  884.           break;
    885. 

  885. 

  886.         case  'FontName':
    887. 

  887.           $res.= "/$label /$value\n";
    888. 

  888.           break;
    889. 

  889.         }
    890. 

  890.       }
    891. 

  891. 

  892.       $res.= ">>\nendobj";
    893. 

  893. 

  894.       return  $res;
    895. 

  895.     }
    896. 

  896.   }
    897. 

  897. 

  898.   /**
    899. 

  899.    * the font encoding
    900. 

  900.    */
    901. 

  901.   protected function  o_fontEncoding($id, $action, $options = '') {
    902. 

  902.     if  ($action !== 'new') {
    903. 

  903.       $o = & $this->objects[$id];
    904. 

  904.     }
    905. 

  905. 

  906.     switch  ($action) {
    907. 

  907.     case  'new':
    908. 

  908.       // the options array should contain 'differences' and maybe 'encoding'
    909. 

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

  910.       break;
    911. 

  911. 

  912.     case  'out':
    913. 

  913.       $res = "\n$id 0 obj\n<< /Type /Encoding\n";
    914. 

  914.       if  (!isset($o['info']['encoding'])) {
    915. 

  915.         $o['info']['encoding'] = 'WinAnsiEncoding';
    916. 

  916.       }
    917. 

  917. 

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

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

  920.       }
    921. 

  921. 

  922.       $res.= "/Differences \n[";
    923. 

  923. 

  924.       $onum = -100;
    925. 

  925. 

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

  927.         if  ($num != $onum+1) {
    928. 

  928.           // we cannot make use of consecutive numbering
    929. 

  929.           $res.=  "\n$num /$label";
    930. 

  930.         } else {
    931. 

  931.           $res.=  " /$label";
    932. 

  932.         }
    933. 

  933. 

  934.         $onum = $num;
    935. 

  935.       }
    936. 

  936. 

  937.       $res.= "\n]\n>>\nendobj";
    938. 

  938.       return  $res;
    939. 

  939.     }
    940. 

  940.   }
    941. 

  941. 

  942.   /**
    943. 

  943.    * a descendent cid font,  needed for unicode fonts
    944. 

  944.    */
    945. 

  945.   protected function  o_fontDescendentCID($id, $action, $options = '') {
    946. 

  946.     if  ($action !== 'new') {
    947. 

  947.       $o = & $this->objects[$id];
    948. 

  948.     }
    949. 

  949. 

  950.     switch  ($action) {
    951. 

  951.     case  'new':
    952. 

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

  953. 

  954.       // we need a CID system info section
    955. 

  955.       $cidSystemInfoId = ++$this->numObj;
    956. 

  956.       $this->o_contents($cidSystemInfoId, 'new', 'raw');
    957. 

  957.       $this->objects[$id]['info']['cidSystemInfo'] = $cidSystemInfoId;
    958. 

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

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

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

  961.       $res.=  ">>";
    962. 

  962.       $this->objects[$cidSystemInfoId]['c'] = $res;
    963. 

  963. 

  964.       // and a CID to GID map
    965. 

  965.       $cidToGidMapId = ++$this->numObj;
    966. 

  966.       $this->o_fontGIDtoCIDMap($cidToGidMapId, 'new', $options);
    967. 

  967.       $this->objects[$id]['info']['cidToGidMap'] = $cidToGidMapId;
    968. 

  968.       break;
    969. 

  969. 

  970.     case  'add':
    971. 

  971.       foreach ($options as  $k => $v) {
    972. 

  972.         switch  ($k) {
    973. 

  973.         case  'BaseFont':
    974. 

  974.           $o['info']['name'] =  $v;
    975. 

  975.           break;
    976. 

  976. 

  977.         case  'FirstChar':
    978. 

  978.         case  'LastChar':
    979. 

  979.         case  'MissingWidth':
    980. 

  980.         case  'FontDescriptor':
    981. 

  981.         case  'SubType':
    982. 

  982.           $this->addMessage("o_fontDescendentCID $k : $v");
    983. 

  983.           $o['info'][$k] =  $v;
    984. 

  984.           break;
    985. 

  985.         }
    986. 

  986.       }
    987. 

  987. 

  988.       // pass values down to cid to gid map
    989. 

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

  990.       break;
    991. 

  991. 

  992.     case  'out':
    993. 

  993.       $res =  "\n$id 0 obj\n";
    994. 

  994.       $res.=  "<</Type /Font\n";
    995. 

  995.       $res.=  "/Subtype /CIDFontType2\n";
    996. 

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

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

  998. //      if  (isset($o['info']['FirstChar'])) {
    999. 

  999. //        $res.=  "/FirstChar ".$o['info']['FirstChar']."\n";
    1000. 

  1000. //      }
    1001. 

  1001. 

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

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

  1004. //      }
    1005. 

  1005.       if  (isset($o['info']['FontDescriptor'])) {
    1006. 

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

  1007.       }
    1008. 

  1008. 

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

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

  1011.       }
    1012. 

  1012. 

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

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

  1015.         $w = '';
    1016. 

  1016.         foreach ($cid_widths as $cid => $width) {
    1017. 

  1017.           $w .= "$cid [$width] ";
    1018. 

  1018.         }
    1019. 

  1019.         $res.=  "/W [$w]\n";
    1020. 

  1020.       }
    1021. 

  1021. 

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

  1023.       $res.=  ">>\n";
    1024. 

  1024.       $res.=  "endobj";
    1025. 

  1025. 

  1026.       return  $res;
    1027. 

  1027.     }
    1028. 

  1028.   }
    1029. 

  1029.   
    1030. 

  1030.   /**
    1031. 

  1031.    * a font glyph to character map,  needed for unicode fonts
    1032. 

  1032.    */
    1033. 

  1033.   protected function  o_fontGIDtoCIDMap($id, $action, $options = '') {
    1034. 

  1034.     if  ($action !== 'new') {
    1035. 

  1035.       $o = & $this->objects[$id];
    1036. 

  1036.     }
    1037. 

  1037. 

  1038.     switch  ($action) {
    1039. 

  1039.     case  'new':
    1040. 

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

  1041.       break;
    1042. 

  1042. 

  1043.     case  'out':
    1044. 

  1044.       $res = "\n$id 0 obj\n";
    1045. 

  1045.       $fontFileName = $o['info']['fontFileName'];
    1046. 

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

  1047.       
    1048. 

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

  1049.                     $this->fonts[$fontFileName]['CIDtoGID_Compressed'];
    1050. 

  1050. 

  1051.       if  (!$compressed && isset($o['raw'])) {
    1052. 

  1052.         $res.= $tmp;
    1053. 

  1053.       } else {
    1054. 

  1054.         $res.=  "<<";
    1055. 

  1055. 

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

  1057.           // then implement ZLIB based compression on this content stream
    1058. 

  1058.           $compressed = true;
    1059. 

  1059.           $tmp =  gzcompress($tmp,  6);
    1060. 

  1060.         }
    1061. 

  1061.         if ($compressed) {
    1062. 

  1062.           $res.= "\n/Filter /FlateDecode";
    1063. 

  1063.         }
    1064. 

  1064. 

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

  1066.       }
    1067. 

  1067. 

  1068.       $res.= "\nendobj";
    1069. 

  1069.       return  $res;
    1070. 

  1070.     }
    1071. 

  1071.   }
    1072. 

  1072.   
    1073. 

  1073.   /**
    1074. 

  1074.    * the document procset, solves some problems with printing to old PS printers
    1075. 

  1075.    */
    1076. 

  1076.   protected function  o_procset($id, $action, $options = '') {
    1077. 

  1077.     if  ($action !== 'new') {
    1078. 

  1078.       $o = & $this->objects[$id];
    1079. 

  1079.     }
    1080. 

  1080. 

  1081.     switch  ($action) {
    1082. 

  1082.     case  'new':
    1083. 

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

  1084.       $this->o_pages($this->currentNode, 'procset', $id);
    1085. 

  1085.       $this->procsetObjectId = $id;
    1086. 

  1086.       break;
    1087. 

  1087. 

  1088.     case  'add':
    1089. 

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

  1090.       // obselete, the items are required for printing to some postscript printers
    1091. 

  1091.       switch  ($options) {
    1092. 

  1092.       case  'ImageB':
    1093. 

  1093.       case  'ImageC':
    1094. 

  1094.       case  'ImageI':
    1095. 

  1095.         $o['info'][$options] = 1;
    1096. 

  1096.         break;
    1097. 

  1097.       }
    1098. 

  1098.       break;
    1099. 

  1099. 

  1100.     case  'out':
    1101. 

  1101.       $res = "\n$id 0 obj\n[";
    1102. 

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

  1103.         $res.= "/$label ";
    1104. 

  1104.       }
    1105. 

  1105.       $res.= "]\nendobj";
    1106. 

  1106.       return  $res;
    1107. 

  1107.     }
    1108. 

  1108.   }
    1109. 

  1109. 

  1110.   /**
    1111. 

  1111.    * define the document information
    1112. 

  1112.    */
    1113. 

  1113.   protected function  o_info($id, $action, $options = '') {
    1114. 

  1114.     if  ($action !== 'new') {
    1115. 

  1115.       $o = & $this->objects[$id];
    1116. 

  1116.     }
    1117. 

  1117. 

  1118.     switch  ($action) {
    1119. 

  1119.     case  'new':
    1120. 

  1120.       $this->infoObject = $id;
    1121. 

  1121.       $date = 'D:'.@date('Ymd');
    1122. 

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

  1123.       break;
    1124. 

  1124.     case  'Title':
    1125. 

  1125.     case  'Author':
    1126. 

  1126.     case  'Subject':
    1127. 

  1127.     case  'Keywords':
    1128. 

  1128.     case  'Creator':
    1129. 

  1129.     case  'Producer':
    1130. 

  1130.     case  'CreationDate':
    1131. 

  1131.     case  'ModDate':
    1132. 

  1132.     case  'Trapped':
    1133. 

  1133.       $o['info'][$action] = $options;
    1134. 

  1134.       break;
    1135. 

  1135. 

  1136.     case  'out':
    1137. 

  1137.       if  ($this->encrypted) {
    1138. 

  1138.         $this->encryptInit($id);
    1139. 

  1139.       }
    1140. 

  1140. 

  1141.       $res = "\n$id 0 obj\n<<\n";
    1142. 

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

  1143.         $res.= "/$k (";
    1144. 

  1144.         // dates must be outputted as-is, without Unicode transformations
    1145. 

  1145.         $raw = ($k === 'CreationDate' || $k === 'ModDate');
    1146. 

  1146.         $c = $v;
    1147. 

  1147. 

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

  1149.           $c = $this->ARC4($c);
    1150. 

  1150.         }
    1151. 

  1151. 

  1152.         $res.= ($raw) ? $c : $this->filterText($c);
    1153. 

  1153.         $res.= ")\n";
    1154. 

  1154.       }
    1155. 

  1155. 

  1156.       $res.= ">>\nendobj";
    1157. 

  1157.       return  $res;
    1158. 

  1158.     }
    1159. 

  1159.   }
    1160. 

  1160. 

  1161.   /**
    1162. 

  1162.    * an action object, used to link to URLS initially
    1163. 

  1163.    */
    1164. 

  1164.   protected function  o_action($id, $action, $options = '') {
    1165. 

  1165.     if  ($action !== 'new') {
    1166. 

  1166.       $o = & $this->objects[$id];
    1167. 

  1167.     }
    1168. 

  1168. 

  1169.     switch  ($action) {
    1170. 

  1170.     case  'new':
    1171. 

  1171.       if  (is_array($options)) {
    1172. 

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

  1173.       } else {
    1174. 

  1174.         // then assume a URI action
    1175. 

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

  1176.       }
    1177. 

  1177.       break;
    1178. 

  1178. 

  1179.     case  'out':
    1180. 

  1180.       if  ($this->encrypted) {
    1181. 

  1181.         $this->encryptInit($id);
    1182. 

  1182.       }
    1183. 

  1183. 

  1184.       $res = "\n$id 0 obj\n<< /Type /Action";
    1185. 

  1185.       switch ($o['type']) {
    1186. 

  1186.       case  'ilink':
    1187. 

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

  1188.         
    1189. 

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

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

  1191.         break;
    1192. 

  1192. 

  1193.       case  'URI':
    1194. 

  1194.         $res.= "\n/S /URI\n/URI (";
    1195. 

  1195.         if  ($this->encrypted) {
    1196. 

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

  1197.         } else {
    1198. 

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

  1199.         }
    1200. 

  1200. 

  1201.         $res.= ")";
    1202. 

  1202.         break;
    1203. 

  1203.       }
    1204. 

  1204. 

  1205.       $res.= "\n>>\nendobj";
    1206. 

  1206.       return  $res;
    1207. 

  1207.     }
    1208. 

  1208.   }
    1209. 

  1209. 

  1210.   /**
    1211. 

  1211.    * an annotation object, this will add an annotation to the current page.
    1212. 

  1212.    * initially will support just link annotations
    1213. 

  1213.    */
    1214. 

  1214.   protected function  o_annotation($id, $action, $options = '') {
    1215. 

  1215.     if  ($action !== 'new') {
    1216. 

  1216.       $o = & $this->objects[$id];
    1217. 

  1217.     }
    1218. 

  1218. 

  1219.     switch  ($action) {
    1220. 

  1220.     case  'new':
    1221. 

  1221.       // add the annotation to the current page
    1222. 

  1222.       $pageId =  $this->currentPage;
    1223. 

  1223.       $this->o_page($pageId, 'annot', $id);
    1224. 

  1224. 

  1225.       // and add the action object which is going to be required
    1226. 

  1226.       switch ($options['type']) {
    1227. 

  1227.       case  'link':
    1228. 

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

  1229.         $this->numObj++;
    1230. 

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

  1231.         $this->objects[$id]['info']['actionId'] = $this->numObj;
    1232. 

  1232.         break;
    1233. 

  1233. 

  1234.       case  'ilink':
    1235. 

  1235.         // this is to a named internal link
    1236. 

  1236.         $label =  $options['label'];
    1237. 

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

  1238.         $this->numObj++;
    1239. 

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

  1240.         $this->objects[$id]['info']['actionId'] = $this->numObj;
    1241. 

  1241.         break;
    1242. 

  1242.       }
    1243. 

  1243.       break;
    1244. 

  1244. 

  1245.     case  'out':
    1246. 

  1246.       $res = "\n$id 0 obj\n<< /Type /Annot";
    1247. 

  1247.       switch ($o['info']['type']) {
    1248. 

  1248.       case  'link':
    1249. 

  1249.       case  'ilink':
    1250. 

  1250.         $res.=  "\n/Subtype /Link";
    1251. 

  1251.         break;
    1252. 

  1252.       }
    1253. 

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

  1254.       $res.= "\n/Border [0 0 0]";
    1255. 

  1255.       $res.= "\n/H /I";
    1256. 

  1256.       $res.= "\n/Rect [ ";
    1257. 

  1257. 

  1258.       foreach($o['info']['rect'] as  $v) {
    1259. 

  1259.         $res.=  sprintf("%.4F ", $v);
    1260. 

  1260.       }
    1261. 

  1261. 

  1262.       $res.= "]";
    1263. 

  1263.       $res.= "\n>>\nendobj";
    1264. 

  1264.       return  $res;
    1265. 

  1265.     }
    1266. 

  1266.   }
    1267. 

  1267. 

  1268.   /**
    1269. 

  1269.    * a page object, it also creates a contents object to hold its contents
    1270. 

  1270.    */
    1271. 

  1271.   protected function  o_page($id, $action, $options = '') {
    1272. 

  1272.     if  ($action !== 'new') {
    1273. 

  1273.       $o = & $this->objects[$id];
    1274. 

  1274.     }
    1275. 

  1275. 

  1276.     switch  ($action) {
    1277. 

  1277.     case  'new':
    1278. 

  1278.       $this->numPages++;
    1279. 

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

  1280. 

  1281.       if  (is_array($options)) {
    1282. 

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

  1283.         $options['id'] = $id;
    1284. 

  1284.         $this->o_pages($this->currentNode, 'page', $options);
    1285. 

  1285.       } else {
    1286. 

  1286.         $this->o_pages($this->currentNode, 'page', $id);
    1287. 

  1287.       }
    1288. 

  1288. 

  1289.       $this->currentPage = $id;
    1290. 

  1290.       //make a contents object to go with this page
    1291. 

  1291.       $this->numObj++;
    1292. 

  1292.       $this->o_contents($this->numObj, 'new', $id);
    1293. 

  1293.       $this->currentContents = $this->numObj;
    1294. 

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

  1295.       $this->objects[$id]['info']['contents'][] = $this->numObj;
    1296. 

  1296. 

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

  1298.       foreach($this->addLooseObjects as  $oId=>$target) {
    1299. 

  1299.         if  ($target === 'all' || $match === $target) {
    1300. 

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

  1301.         }
    1302. 

  1302.       }
    1303. 

  1303.       break;
    1304. 

  1304. 

  1305.     case  'content':
    1306. 

  1306.       $o['info']['contents'][] = $options;
    1307. 

  1307.       break;
    1308. 

  1308. 

  1309.     case  'annot':
    1310. 

  1310.       // add an annotation to this page
    1311. 

  1311.       if  (!isset($o['info']['annot'])) {
    1312. 

  1312.         $o['info']['annot'] = array();
    1313. 

  1313.       }
    1314. 

  1314. 

  1315.       // $options should contain the id of the annotation dictionary
    1316. 

  1316.       $o['info']['annot'][] = $options;
    1317. 

  1317.       break;
    1318. 

  1318. 

  1319.     case  'out':
    1320. 

  1320.       $res = "\n$id 0 obj\n<< /Type /Page";
    1321. 

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

  1322. 

  1323.       if  (isset($o['info']['annot'])) {
    1324. 

  1324.         $res.= "\n/Annots [";
    1325. 

  1325.         foreach($o['info']['annot'] as  $aId) {
    1326. 

  1326.           $res.= " $aId 0 R";
    1327. 

  1327.         }
    1328. 

  1328.         $res.= " ]";
    1329. 

  1329.       }
    1330. 

  1330. 

  1331.       $count =  count($o['info']['contents']);
    1332. 

  1332.       if  ($count == 1) {
    1333. 

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

  1334.       } else  if  ($count>1) {
    1335. 

  1335.         $res.= "\n/Contents [\n";
    1336. 

  1336. 

  1337.         // reverse the page contents so added objects are below normal content
    1338. 

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

  1339.         // Back to normal now that I've got transparency working --Benj
    1340. 

  1340.         foreach ($o['info']['contents'] as  $cId) {
    1341. 

  1341.           $res.= "$cId 0 R\n";
    1342. 

  1342.         }
    1343. 

  1343.         $res.= "]";
    1344. 

  1344.       }
    1345. 

  1345. 

  1346.       $res.= "\n>>\nendobj";
    1347. 

  1347.       return  $res;
    1348. 

  1348.     }
    1349. 

  1349.   }
    1350. 

  1350. 

  1351.   /**
    1352. 

  1352.    * the contents objects hold all of the content which appears on pages
    1353. 

  1353.    */
    1354. 

  1354.   protected function  o_contents($id, $action, $options = '') {
    1355. 

  1355.     if  ($action !== 'new') {
    1356. 

  1356.       $o = & $this->objects[$id];
    1357. 

  1357.     }
    1358. 

  1358. 

  1359.     switch  ($action) {
    1360. 

  1360.     case  'new':
    1361. 

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

  1362.       if  (mb_strlen($options, '8bit') &&  intval($options)) {
    1363. 

  1363.         // then this contents is the primary for a page
    1364. 

  1364.         $this->objects[$id]['onPage'] = $options;
    1365. 

  1365.       } else  if  ($options === 'raw') {
    1366. 

  1366.         // then this page contains some other type of system object
    1367. 

  1367.         $this->objects[$id]['raw'] = 1;
    1368. 

  1368.       }
    1369. 

  1369.       break;
    1370. 

  1370. 

  1371.     case  'add':
    1372. 

  1372.       // add more options to the decleration
    1373. 

  1373.       foreach ($options as  $k=>$v) {
    1374. 

  1374.         $o['info'][$k] = $v;
    1375. 

  1375.       }
    1376. 

  1376. 

  1377.     case  'out':
    1378. 

  1378.       $tmp = $o['c'];
    1379. 

  1379.       $res =  "\n$id 0 obj\n";
    1380. 

  1380. 

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

  1382.         $res.= $tmp;
    1383. 

  1383.       } else {
    1384. 

  1384.         $res.=  "<<";
    1385. 

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

  1386.           // then implement ZLIB based compression on this content stream
    1387. 

  1387.           $res.= " /Filter /FlateDecode";
    1388. 

  1388.           $tmp =  gzcompress($tmp,  6);
    1389. 

  1389.         }
    1390. 

  1390. 

  1391.         if  ($this->encrypted) {
    1392. 

  1392.           $this->encryptInit($id);
    1393. 

  1393.           $tmp =  $this->ARC4($tmp);
    1394. 

  1394.         }
    1395. 

  1395. 

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

  1397.           $res.=  "\n/$k $v";
    1398. 

  1398.         }
    1399. 

  1399. 

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

  1401.       }
    1402. 

  1402. 

  1403.       $res.= "\nendobj";
    1404. 

  1404.       return  $res;
    1405. 

  1405.     }
    1406. 

  1406.   }
    1407. 

  1407. 

  1408.   protected function  o_embedjs($id, $action, $code = '') {
    1409. 

  1409.     if  ($action !== 'new') {
    1410. 

  1410.       $o = & $this->objects[$id];
    1411. 

  1411.     }
    1412. 

  1412. 

  1413.     switch  ($action) {
    1414. 

  1414.     case  'new':
    1415. 

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

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

  1417.       ));
    1418. 

  1418.       break;
    1419. 

  1419. 

  1420.     case  'out':
    1421. 

  1421.       $res = "\n$id 0 obj\n<< ";
    1422. 

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

  1423.         $res.=  "\n/$k $v";
    1424. 

  1424.       }
    1425. 

  1425.       $res.= "\n>>\nendobj";
    1426. 

  1426.       return  $res;
    1427. 

  1427.     }
    1428. 

  1428.   }
    1429. 

  1429.   
    1430. 

  1430.   protected function  o_javascript($id, $action, $code = '') {
    1431. 

  1431.     if  ($action !== 'new') {
    1432. 

  1432.       $o = & $this->objects[$id];
    1433. 

  1433.     }
    1434. 

  1434. 

  1435.     switch  ($action) {
    1436. 

  1436.     case  'new':
    1437. 

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

  1438.         'S' => '/JavaScript',
    1439. 

  1439.         'JS' => '('.$this->filterText($code).')',
    1440. 

  1440.       ));
    1441. 

  1441.       break;
    1442. 

  1442. 

  1443.     case  'out':
    1444. 

  1444.       $res = "\n$id 0 obj\n<< ";
    1445. 

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

  1446.         $res.=  "\n/$k $v";
    1447. 

  1447.       }
    1448. 

  1448.       $res.= "\n>>\nendobj";
    1449. 

  1449.       return  $res;
    1450. 

  1450.     }
    1451. 

  1451.   }
    1452. 

  1452. 

  1453.   /**
    1454. 

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

  1455.    */
    1456. 

  1456.   protected function  o_image($id, $action, $options = '') {
    1457. 

  1457.     if  ($action !== 'new') {
    1458. 

  1458.       $o = & $this->objects[$id];
    1459. 

  1459.     }
    1460. 

  1460. 

  1461.     switch ($action) {
    1462. 

  1462.     case  'new':
    1463. 

  1463.       // make the new object
    1464. 

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

  1465.       
    1466. 

  1466.       $info =& $this->objects[$id]['info'];
    1467. 

  1467.       
    1468. 

  1468.       $info['Type'] = '/XObject';
    1469. 

  1469.       $info['Subtype'] = '/Image';
    1470. 

  1470.       $info['Width'] = $options['iw'];
    1471. 

  1471.       $info['Height'] = $options['ih'];
    1472. 

  1472.       
    1473. 

  1473.       if (isset($options['masked']) && $options['masked']) {
    1474. 

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

  1475.       }
    1476. 

  1476.       
    1477. 

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

  1478.         if  (!isset($options['channels'])) {
    1479. 

  1479.           $options['channels'] = 3;
    1480. 

  1480.         }
    1481. 

  1481. 

  1482.         switch ($options['channels']) {
    1483. 

  1483.           case  1: $info['ColorSpace'] = '/DeviceGray'; break;
    1484. 

  1484.           case  4: $info['ColorSpace'] = '/DeviceCMYK'; break;
    1485. 

  1485.           default: $info['ColorSpace'] = '/DeviceRGB'; break;
    1486. 

  1486.         }
    1487. 

  1487.         
    1488. 

  1488.         if ($info['ColorSpace'] === '/DeviceCMYK') {
    1489. 

  1489.           $info['Decode'] = '[1 0 1 0 1 0 1 0]';
    1490. 

  1490.         }
    1491. 

  1491. 

  1492.         $info['Filter'] = '/DCTDecode';
    1493. 

  1493.         $info['BitsPerComponent'] = 8;
    1494. 

  1494.       } 
    1495. 

  1495.       
    1496. 

  1496.       else if  ($options['type'] === 'png') {
    1497. 

  1497.         $info['Filter'] = '/FlateDecode';
    1498. 

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

  1499.       
    1500. 

  1500.         if ($options['isMask']) {
    1501. 

  1501.           $info['ColorSpace'] = '/DeviceGray';
    1502. 

  1502.         }
    1503. 

  1503.         else {
    1504. 

  1504.           if  (mb_strlen($options['pdata'], '8bit')) {
    1505. 

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

  1506.             $this->numObj++;
    1507. 

  1507.             $this->o_contents($this->numObj, 'new');
    1508. 

  1508.             $this->objects[$this->numObj]['c'] = $options['pdata'];
    1509. 

  1509.             $tmp.= $this->numObj.' 0 R';
    1510. 

  1510.             $tmp.= ' ]';
    1511. 

  1511.             $info['ColorSpace'] =  $tmp;
    1512. 

  1512.             
    1513. 

  1513.             if  (isset($options['transparency'])) {
    1514. 

  1514.               $transparency = $options['transparency'];
    1515. 

  1515.               switch ($transparency['type']) {
    1516. 

  1516.               case  'indexed':
    1517. 

  1517.                 $tmp = ' [ '.$transparency['data'].' '.$transparency['data'].'] ';
    1518. 

  1518.                 $info['Mask'] =  $tmp;
    1519. 

  1519.                 break;
    1520. 

  1520.   
    1521. 

  1521.               case 'color-key':
    1522. 

  1522.                 $tmp = ' [ '.
    1523. 

  1523.                   $transparency['r'] . ' ' . $transparency['r'] .
    1524. 

  1524.                   $transparency['g'] . ' ' . $transparency['g'] .
    1525. 

  1525.                   $transparency['b'] . ' ' . $transparency['b'] .
    1526. 

  1526.                   ' ] ';
    1527. 

  1527.                 $info['Mask'] = $tmp;
    1528. 

  1528.                 break;
    1529. 

  1529.               }
    1530. 

  1530.             }
    1531. 

  1531.           } else {
    1532. 

  1532.             if  (isset($options['transparency'])) {
    1533. 

  1533.               $transparency = $options['transparency'];
    1534. 

  1534.               
    1535. 

  1535.               switch ($transparency['type']) {
    1536. 

  1536.               case  'indexed':
    1537. 

  1537.                 $tmp = ' [ '.$transparency['data'].' '.$transparency['data'].'] ';
    1538. 

  1538.                 $info['Mask'] =  $tmp;
    1539. 

  1539.                 break;
    1540. 

  1540.   
    1541. 

  1541.               case 'color-key':
    1542. 

  1542.                 $tmp = ' [ '.
    1543. 

  1543.                   $transparency['r'] . ' ' . $transparency['r'] . ' ' .
    1544. 

  1544.                   $transparency['g'] . ' ' . $transparency['g'] . ' ' .
    1545. 

  1545.                   $transparency['b'] . ' ' . $transparency['b'] .
    1546. 

  1546.                   ' ] ';
    1547. 

  1547.                 $info['Mask'] = $tmp;
    1548. 

  1548.                 break;
    1549. 

  1549.               }
    1550. 

  1550.             }
    1551. 

  1551.             $info['ColorSpace'] = '/'.$options['color'];
    1552. 

  1552.           }
    1553. 

  1553.         }
    1554. 

  1554.         
    1555. 

  1555.         $info['BitsPerComponent'] = $options['bitsPerComponent'];
    1556. 

  1556.       }
    1557. 

  1557. 

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

  1559.       // the label passed in with it.
    1560. 

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

  1561. 

  1562.       // also make sure that we have the right procset object for it.
    1563. 

  1563.       $this->o_procset($this->procsetObjectId, 'add', 'ImageC');
    1564. 

  1564.       break;
    1565. 

  1565. 

  1566.     case  'out':
    1567. 

  1567.       $tmp = &$o['data'];
    1568. 

  1568.       $res =  "\n$id 0 obj\n<<";
    1569. 

  1569. 

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

  1571.         $res.= "\n/$k $v";
    1572. 

  1572.       }
    1573. 

  1573. 

  1574.       if  ($this->encrypted) {
    1575. 

  1575.         $this->encryptInit($id);
    1576. 

  1576.         $tmp =  $this->ARC4($tmp);
    1577. 

  1577.       }
    1578. 

  1578. 

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

  1580. 

  1581.       return  $res;
    1582. 

  1582.     }
    1583. 

  1583.   }
    1584. 

  1584. 

  1585.   /**
    1586. 

  1586.    * graphics state object
    1587. 

  1587.    */
    1588. 

  1588.   protected function  o_extGState($id,  $action,  $options = "") {
    1589. 

  1589.     static  $valid_params =  array("LW",  "LC",  "LC",  "LJ",  "ML",
    1590. 

  1590.                                    "D",  "RI",  "OP",  "op",  "OPM",
    1591. 

  1591.                                    "Font",  "BG",  "BG2",  "UCR",
    1592. 

  1592.                                    "TR",  "TR2",  "HT",  "FL",
    1593. 

  1593.                                    "SM",  "SA",  "BM",  "SMask",
    1594. 

  1594.                                    "CA",  "ca",  "AIS",  "TK");
    1595. 

  1595. 

  1596.     if  ($action !==  "new") {
    1597. 

  1597.       $o = & $this->objects[$id];
    1598. 

  1598.     }
    1599. 

  1599. 

  1600.     switch  ($action) {
    1601. 

  1601.     case  "new":
    1602. 

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

  1603. 

  1604.       // Tell the pages about the new resource
    1605. 

  1605.       $this->numStates++;
    1606. 

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

  1607.       break;
    1608. 

  1608. 

  1609.     case  "out":
    1610. 

  1610.       $res = "\n$id 0 obj\n<< /Type /ExtGState\n";
    1611. 

  1611. 

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

  1613.         if  ( !in_array($k, $valid_params))
    1614. 

  1614.           continue;
    1615. 

  1615.         $res.=  "/$k $v\n";
    1616. 

  1616.       }
    1617. 

  1617. 

  1618.       $res.= ">>\nendobj";
    1619. 

  1619.       return  $res;
    1620. 

  1620.     }
    1621. 

  1621.   }
    1622. 

  1622. 

  1623.   /**
    1624. 

  1624.    * encryption object.
    1625. 

  1625.    */
    1626. 

  1626.   protected function  o_encryption($id, $action, $options = '') {
    1627. 

  1627.     if  ($action !== 'new') {
    1628. 

  1628.       $o = & $this->objects[$id];
    1629. 

  1629.     }
    1630. 

  1630. 

  1631.     switch ($action) {
    1632. 

  1632.     case  'new':
    1633. 

  1633.       // make the new object
    1634. 

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

  1635.       $this->arc4_objnum = $id;
    1636. 

  1636. 

  1637.       // figure out the additional paramaters required
    1638. 

  1638.       $pad =  chr(0x28) .chr(0xBF) .chr(0x4E) .chr(0x5E) .chr(0x4E) .chr(0x75) .chr(0x8A) .chr(0x41)
    1639. 

  1639.              .chr(0x64) .chr(0x00) .chr(0x4E) .chr(0x56) .chr(0xFF) .chr(0xFA) .chr(0x01) .chr(0x08)
    1640. 

  1640.              .chr(0x2E) .chr(0x2E) .chr(0x00) .chr(0xB6) .chr(0xD0) .chr(0x68) .chr(0x3E) .chr(0x80)
    1641. 

  1641.              .chr(0x2F) .chr(0x0C) .chr(0xA9) .chr(0xFE) .chr(0x64) .chr(0x53) .chr(0x69) .chr(0x7A);
    1642. 

  1642.              
    1643. 

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

  1644. 

  1645.       if  ($len>32) {
    1646. 

  1646.         $owner =  substr($options['owner'], 0, 32);
    1647. 

  1647.       } else  if  ($len<32) {
    1648. 

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

  1649.       } else {
    1650. 

  1650.         $owner =  $options['owner'];
    1651. 

  1651.       }
    1652. 

  1652. 

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

  1654.       if  ($len>32) {
    1655. 

  1655.         $user =  substr($options['user'], 0, 32);
    1656. 

  1656.       } else  if  ($len<32) {
    1657. 

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

  1658.       } else {
    1659. 

  1659.         $user =  $options['user'];
    1660. 

  1660.       }
    1661. 

  1661. 

  1662.       $tmp =  $this->md5_16($owner);
    1663. 

  1663.       $okey =  substr($tmp, 0, 5);
    1664. 

  1664.       $this->ARC4_init($okey);
    1665. 

  1665.       $ovalue = $this->ARC4($user);
    1666. 

  1666.       $this->objects[$id]['info']['O'] = $ovalue;
    1667. 

  1667. 

  1668.       // now make the u value, phew.
    1669. 

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

  1670. 

  1671.       $ukey =  substr($tmp, 0, 5);
    1672. 

  1672.       $this->ARC4_init($ukey);
    1673. 

  1673.       $this->encryptionKey =  $ukey;
    1674. 

  1674.       $this->encrypted = true;
    1675. 

  1675.       $uvalue = $this->ARC4($pad);
    1676. 

  1676.       $this->objects[$id]['info']['U'] = $uvalue;
    1677. 

  1677.       $this->encryptionKey = $ukey;
    1678. 

  1678.       // initialize the arc4 array
    1679. 

  1679.       break;
    1680. 

  1680. 

  1681.     case  'out':
    1682. 

  1682.       $res =  "\n$id 0 obj\n<<";
    1683. 

  1683.       $res.= "\n/Filter /Standard";
    1684. 

  1684.       $res.= "\n/V 1";
    1685. 

  1685.       $res.= "\n/R 2";
    1686. 

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

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

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

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

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

  1691.       $res.= "\n>>\nendobj";
    1692. 

  1692.       return  $res;
    1693. 

  1693.     }
    1694. 

  1694.   }
    1695. 

  1695. 

  1696.   /**
    1697. 

  1697.    * ARC4 functions
    1698. 

  1698.    * A series of function to implement ARC4 encoding in PHP
    1699. 

  1699.    */
    1700. 

  1700. 

  1701.   /**
    1702. 

  1702.    * calculate the 16 byte version of the 128 bit md5 digest of the string
    1703. 

  1703.    */
    1704. 

  1704.   function md5_16($string) {
    1705. 

  1705.     $tmp =  md5($string);
    1706. 

  1706.     $out = '';
    1707. 

  1707.     for  ($i = 0;$i <= 30;$i = $i+2) {
    1708. 

  1708.       $out.= chr(hexdec(substr($tmp, $i, 2)));
    1709. 

  1709.     }
    1710. 

  1710.     return  $out;
    1711. 

  1711.   }
    1712. 

  1712. 

  1713.   /**
    1714. 

  1714.    * initialize the encryption for processing a particular object
    1715. 

  1715.    */
    1716. 

  1716.   function encryptInit($id) {
    1717. 

  1717.     $tmp =  $this->encryptionKey;
    1718. 

  1718.     $hex =  dechex($id);
    1719. 

  1719.     if  (mb_strlen($hex, '8bit') <6) {
    1720. 

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

  1721.     }
    1722. 

  1722.     $tmp.=  chr(hexdec(substr($hex, 4, 2))) .chr(hexdec(substr($hex, 2, 2))) .chr(hexdec(substr($hex, 0, 2))) .chr(0) .chr(0);
    1723. 

  1723.     $key =  $this->md5_16($tmp);
    1724. 

  1724.     $this->ARC4_init(substr($key, 0, 10));
    1725. 

  1725.   }
    1726. 

  1726. 

  1727.   /**
    1728. 

  1728.    * initialize the ARC4 encryption
    1729. 

  1729.    */
    1730. 

  1730.   function ARC4_init($key = '') {
    1731. 

  1731.     $this->arc4 =  '';
    1732. 

  1732. 

  1733.     // setup the control array
    1734. 

  1734.     if  (mb_strlen($key, '8bit') == 0) {
    1735. 

  1735.       return;
    1736. 

  1736.     }
    1737. 

  1737. 

  1738.     $k =  '';
    1739. 

  1739.     while (mb_strlen($k, '8bit') <256) {
    1740. 

  1740.       $k.= $key;
    1741. 

  1741.     }
    1742. 

  1742. 

  1743.     $k = substr($k, 0, 256);
    1744. 

  1744.     for  ($i = 0;$i<256;$i++) {
    1745. 

  1745.       $this->arc4.=  chr($i);
    1746. 

  1746.     }
    1747. 

  1747. 

  1748.     $j = 0;
    1749. 

  1749. 

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

  1751.       $t =  $this->arc4[$i];
    1752. 

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

  1753.       $this->arc4[$i] = $this->arc4[$j];
    1754. 

  1754.       $this->arc4[$j] = $t;
    1755. 

  1755.     }
    1756. 

  1756.   }
    1757. 

  1757. 

  1758.   /**
    1759. 

  1759.    * ARC4 encrypt a text string
    1760. 

  1760.    */
    1761. 

  1761.   function ARC4($text) {
    1762. 

  1762.     $len = mb_strlen($text, '8bit');
    1763. 

  1763.     $a = 0;
    1764. 

  1764.     $b = 0;
    1765. 

  1765.     $c =  $this->arc4;
    1766. 

  1766.     $out = '';
    1767. 

  1767.     for  ($i = 0;$i<$len;$i++) {
    1768. 

  1768.       $a =  ($a+1) %256;
    1769. 

  1769.       $t =  $c[$a];
    1770. 

  1770.       $b =  ($b+ord($t)) %256;
    1771. 

  1771.       $c[$a] = $c[$b];
    1772. 

  1772.       $c[$b] = $t;
    1773. 

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

  1774.       $out.= chr(ord($text[$i])  ^ $k);
    1775. 

  1775.     }
    1776. 

  1776.     return  $out;
    1777. 

  1777.   }
    1778. 

  1778. 

  1779.   /**
    1780. 

  1780.    * functions which can be called to adjust or add to the document
    1781. 

  1781.    */
    1782. 

  1782. 

  1783.   /**
    1784. 

  1784.    * add a link in the document to an external URL
    1785. 

  1785.    */
    1786. 

  1786.   function addLink($url, $x0, $y0, $x1, $y1) {
    1787. 

  1787.     $this->numObj++;
    1788. 

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

  1789.     $this->o_annotation($this->numObj, 'new', $info);
    1790. 

  1790.   }
    1791. 

  1791. 

  1792.   /**
    1793. 

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

  1794.    */
    1795. 

  1795.   function addInternalLink($label, $x0, $y0, $x1, $y1) {
    1796. 

  1796.     $this->numObj++;
    1797. 

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

  1798.     $this->o_annotation($this->numObj, 'new', $info);
    1799. 

  1799.   }
    1800. 

  1800. 

  1801.   /**
    1802. 

  1802.    * set the encryption of the document
    1803. 

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

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

  1805.    */
    1806. 

  1806.   function setEncryption($userPass = '', $ownerPass = '', $pc = array()) {
    1807. 

  1807.     $p = bindec("11000000");
    1808. 

  1808. 

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

  1810. 

  1811.     foreach($pc as  $k=>$v) {
    1812. 

  1812.       if  ($v &&  isset($options[$k])) {
    1813. 

  1813.         $p+= $options[$k];
    1814. 

  1814.       } else  if  (isset($options[$v])) {
    1815. 

  1815.         $p+= $options[$v];
    1816. 

  1816.       }
    1817. 

  1817.     }
    1818. 

  1818. 

  1819.     // implement encryption on the document
    1820. 

  1820.     if  ($this->arc4_objnum ==  0) {
    1821. 

  1821.       // then the block does not exist already, add it.
    1822. 

  1822.       $this->numObj++;
    1823. 

  1823.       if  (mb_strlen($ownerPass) == 0) {
    1824. 

  1824.         $ownerPass = $userPass;
    1825. 

  1825.       }
    1826. 

  1826. 

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

  1828.     }
    1829. 

  1829.   }
    1830. 

  1830. 

  1831.   /**
    1832. 

  1832.    * should be used for internal checks, not implemented as yet
    1833. 

  1833.    */
    1834. 

  1834.   function checkAllHere() {
    1835. 

  1835.   }
    1836. 

  1836. 

  1837.   /**
    1838. 

  1838.    * return the pdf stream as a string returned from the function
    1839. 

  1839.    */
    1840. 

  1840.   function output($debug = false) {
    1841. 

  1841.     if  ($debug) {
    1842. 

  1842.       // turn compression off
    1843. 

  1843.       $this->options['compression'] = false;
    1844. 

  1844.     }
    1845. 

  1845.     
    1846. 

  1846.     if ($this->javascript) {
    1847. 

  1847.       $this->numObj++;
    1848. 

  1848.       
    1849. 

  1849.       $js_id = $this->numObj;
    1850. 

  1850.       $this->o_embedjs($js_id, 'new');
    1851. 

  1851.       $this->o_javascript(++$this->numObj, 'new', $this->javascript);
    1852. 

  1852.       
    1853. 

  1853.       $id =  $this->catalogId;
    1854. 

  1854.       
    1855. 

  1855.       $this->o_catalog($id, 'javascript', $js_id);
    1856. 

  1856.     }
    1857. 

  1857. 

  1858.     if  ($this->arc4_objnum) {
    1859. 

  1859.       $this->ARC4_init($this->encryptionKey);
    1860. 

  1860.     }
    1861. 

  1861. 

  1862.     $this->checkAllHere();
    1863. 

  1863. 

  1864. 

  1865.     $xref = array();
    1866. 

  1866.     $content = '%PDF-1.3';
    1867. 

  1867.     $pos = mb_strlen($content, '8bit');
    1868. 

  1868. 

  1869.     foreach($this->objects as  $k=>$v) {
    1870. 

  1870.       $tmp = 'o_'.$v['t'];
    1871. 

  1871.       $cont = $this->$tmp($k, 'out');
    1872. 

  1872.       $content.= $cont;
    1873. 

  1873.       $xref[] = $pos;
    1874. 

  1874.       $pos+= mb_strlen($cont, '8bit');
    1875. 

  1875.     }
    1876. 

  1876. 

  1877.     $content.= "\nxref\n0 ".(count($xref) +1) ."\n0000000000 65535 f \n";
    1878. 

  1878. 

  1879.     foreach($xref as  $p) {
    1880. 

  1880.       $content.= str_pad($p,  10,  "0",  STR_PAD_LEFT)  . " 00000 n \n";
    1881. 

  1881.     }
    1882. 

  1882. 

  1883.     $content.= "trailer\n<<\n/Size ".(count($xref) +1) ."\n/Root 1 0 R\n/Info $this->infoObject 0 R\n";
    1884. 

  1884. 

  1885.     // if encryption has been applied to this document then add the marker for this dictionary
    1886. 

  1886.     if  ($this->arc4_objnum > 0) {
    1887. 

  1887.       $content.=  "/Encrypt $this->arc4_objnum 0 R\n";
    1888. 

  1888.     }
    1889. 

  1889. 

  1890.     if  (mb_strlen($this->fileIdentifier, '8bit')) {
    1891. 

  1891.       $content.=  "/ID[<$this->fileIdentifier><$this->fileIdentifier>]\n";
    1892. 

  1892.     }
    1893. 

  1893. 

  1894.     $content.=  ">>\nstartxref\n$pos\n%%EOF\n";
    1895. 

  1895. 

  1896.     return  $content;
    1897. 

  1897.   }
    1898. 

  1898. 

  1899.   /**
    1900. 

  1900.    * intialize a new document
    1901. 

  1901.    * if this is called on an existing document results may be unpredictable, but the existing document would be lost at minimum
    1902. 

  1902.    * this function is called automatically by the constructor function
    1903. 

  1903.    *
    1904. 

  1904.    * @access private
    1905. 

  1905.    */
    1906. 

  1906.   function newDocument($pageSize = array(0, 0, 612, 792)) {
    1907. 

  1907.     $this->numObj = 0;
    1908. 

  1908.     $this->objects =  array();
    1909. 

  1909. 

  1910.     $this->numObj++;
    1911. 

  1911.     $this->o_catalog($this->numObj, 'new');
    1912. 

  1912. 

  1913.     $this->numObj++;
    1914. 

  1914.     $this->o_outlines($this->numObj, 'new');
    1915. 

  1915. 

  1916.     $this->numObj++;
    1917. 

  1917.     $this->o_pages($this->numObj, 'new');
    1918. 

  1918. 

  1919.     $this->o_pages($this->numObj, 'mediaBox', $pageSize);
    1920. 

  1920.     $this->currentNode =  3;
    1921. 

  1921. 

  1922.     $this->numObj++;
    1923. 

  1923.     $this->o_procset($this->numObj, 'new');
    1924. 

  1924. 

  1925.     $this->numObj++;
    1926. 

  1926.     $this->o_info($this->numObj, 'new');
    1927. 

  1927. 

  1928.     $this->numObj++;
    1929. 

  1929.     $this->o_page($this->numObj, 'new');
    1930. 

  1930. 

  1931.     // need to store the first page id as there is no way to get it to the user during
    1932. 

  1932.     // startup
    1933. 

  1933.     $this->firstPageId =  $this->currentContents;
    1934. 

  1934.   }
    1935. 

  1935. 

  1936.   /**
    1937. 

  1937.    * open the font file and return a php structure containing it.
    1938. 

  1938.    * first check if this one has been done before and saved in a form more suited to php
    1939. 

  1939.    * note that if a php serialized version does not exist it will try and make one, but will
    1940. 

  1940.    * require write access to the directory to do it... it is MUCH faster to have these serialized
    1941. 

  1941.    * files.
    1942. 

  1942.    *
    1943. 

  1943.    * @access private
    1944. 

  1944.    */
    1945. 

  1945.   function openFont($font) {
    1946. 

  1946.     // assume that $font contains the path and file but not the extension
    1947. 

  1947.     $pos = strrpos($font, '/');
    1948. 

  1948. 

  1949.     if  ($pos === false) {
    1950. 

  1950.       $dir =  './';
    1951. 

  1951.       $name =  $font;
    1952. 

  1952.     } else {
    1953. 

  1953.       $dir = substr($font, 0, $pos+1);
    1954. 

  1954.       $name = substr($font, $pos+1);
    1955. 

  1955.     }
    1956. 

  1956.     
    1957. 

  1957.     $fontcache = $this->fontcache;
    1958. 

  1958.     if ($fontcache == '') {
    1959. 

  1959.       $fontcache = $dir;
    1960. 

  1960.     }
    1961. 

  1961.     
    1962. 

  1962.     //$name       filename without folder and extension of font metrics
    1963. 

  1963.     //$dir      folder of font metrics
    1964. 

  1964.     //$fontcache  folder of runtime created php serialized version of font metrics.
    1965. 

  1965.     //            If this is not given, the same folder as the font metrics will be used.
    1966. 

  1966.     //            Storing and reusing serialized versions improves speed much
    1967. 

  1967.     
    1968. 

  1968.     $this->addMessage("openFont: $font - $name");
    1969. 

  1969. 

  1970.     if ( !$this->isUnicode || in_array(mb_strtolower(basename($name)), self::$coreFonts) ) {
    1971. 

  1971.       $metrics_name = "$name.afm";
    1972. 

  1972.     }
    1973. 

  1973.     else {
    1974. 

  1974.       $metrics_name = "$name.ufm";
    1975. 

  1975.     }
    1976. 

  1976.     
    1977. 

  1977.     $cache_name = "$metrics_name.php";
    1978. 

  1978.     $this->addMessage("metrics: $metrics_name, cache: $cache_name");
    1979. 

  1979.     
    1980. 

  1980.     if  (file_exists($fontcache . $cache_name)) {
    1981. 

  1981.       $this->addMessage("openFont: php file exists $fontcache$cache_name");
    1982. 

  1982.       $this->fonts[$font] = require($fontcache . $cache_name);
    1983. 

  1983. 

  1984.       if  (!isset($this->fonts[$font]['_version_']) ||  $this->fonts[$font]['_version_'] != $this->fontcacheVersion) {
    1985. 

  1985.         // if the font file is old, then clear it out and prepare for re-creation
    1986. 

  1986.         $this->addMessage('openFont: clear out, make way for new version.');
    1987. 

  1987.         $this->fonts[$font] = null;
    1988. 

  1988.         unset($this->fonts[$font]);
    1989. 

  1989.       }
    1990. 

  1990.     }
    1991. 

  1991.     else {
    1992. 

  1992.       $old_cache_name = "php_$metrics_name";
    1993. 

  1993.       if (file_exists($fontcache . $old_cache_name)) {
    1994. 

  1994.         $this->addMessage("openFont: php file doesn't exist $fontcache$cache_name, creating it from the old format");
    1995. 

  1995.         $old_cache = file_get_contents($fontcache . $old_cache_name);
    1996. 

  1996.         file_put_contents($fontcache . $cache_name, '<?php return ' . $old_cache . ';');
    1997. 

  1997.         return $this->openFont($font);
    1998. 

  1998.       }
    1999. 

  1999.     }
    2000. 

  2000. 

  2001.     if  (!isset($this->fonts[$font]) &&  file_exists($dir . $metrics_name)) {
    2002. 

  2002.       // then rebuild the php_<font>.afm file from the <font>.afm file
    2003. 

  2003.       $this->addMessage("openFont: build php file from $dir$metrics_name");
    2004. 

  2004.       $data =  array();
    2005. 

  2005.       
    2006. 

  2006.       // 20 => 'space'
    2007. 

  2007.       $data['codeToName'] = array(); 
    2008. 

  2008.       
    2009. 

  2009.       // Since we're not going to enable Unicode for the core fonts we need to use a font-based
    2010. 

  2010.       // setting for Unicode support rather than a global setting.
    2011. 

  2011.       $data['isUnicode'] = (strtolower(substr($metrics_name, -3)) !== 'afm');
    2012. 

  2012.       
    2013. 

  2013.       $cidtogid = '';
    2014. 

  2014.       if ($data['isUnicode']) {
    2015. 

  2015.         $cidtogid = str_pad('', 256*256*2, "\x00");
    2016. 

  2016.       }
    2017. 

  2017. 

  2018.       $file =  file($dir . $metrics_name);
    2019. 

  2019. 

  2020.       foreach ($file as  $rowA) {
    2021. 

  2021.         $row = trim($rowA);
    2022. 

  2022.         $pos = strpos($row, ' ');
    2023. 

  2023. 

  2024.         if  ($pos) {
    2025. 

  2025.           // then there must be some keyword
    2026. 

  2026.           $key =  substr($row, 0, $pos);
    2027. 

  2027.           switch  ($key) {
    2028. 

  2028.           case  'FontName':
    2029. 

  2029.           case  'FullName':
    2030. 

  2030.           case  'FamilyName':
    2031. 

  2031.           case  'PostScriptName':
    2032. 

  2032.           case  'Weight':
    2033. 

  2033.           case  'ItalicAngle':
    2034. 

  2034.           case  'IsFixedPitch':
    2035. 

  2035.           case  'CharacterSet':
    2036. 

  2036.           case  'UnderlinePosition':
    2037. 

  2037.           case  'UnderlineThickness':
    2038. 

  2038.           case  'Version':
    2039. 

  2039.           case  'EncodingScheme':
    2040. 

  2040.           case  'CapHeight':
    2041. 

  2041.           case  'XHeight':
    2042. 

  2042.           case  'Ascender':
    2043. 

  2043.           case  'Descender':
    2044. 

  2044.           case  'StdHW':
    2045. 

  2045.           case  'StdVW':
    2046. 

  2046.           case  'StartCharMetrics':
    2047. 

  2047.           case  'FontHeightOffset': // OAR - Added so we can offset the height calculation of a Windows font.  Otherwise it's too big.
    2048. 

  2048.             $data[$key] = trim(substr($row, $pos));
    2049. 

  2049.             break;
    2050. 

  2050. 

  2051.           case  'FontBBox':
    2052. 

  2052.             $data[$key] = explode(' ', trim(substr($row, $pos)));
    2053. 

  2053.             break;
    2054. 

  2054. 

  2055.           //C 39 ; WX 222 ; N quoteright ; B 53 463 157 718 ;
    2056. 

  2056.           case  'C': // Found in AFM files
    2057. 

  2057.             $bits = explode(';', trim($row));
    2058. 

  2058.             $dtmp = array();
    2059. 

  2059. 

  2060.             foreach($bits as  $bit) {
    2061. 

  2061.               $bits2 =  explode(' ', trim($bit));
    2062. 

  2062.               if  (mb_strlen($bits2[0], '8bit') == 0) continue;
    2063. 

  2063.               
    2064. 

  2064.               if  (count($bits2) >2) {
    2065. 

  2065.                 $dtmp[$bits2[0]] = array();
    2066. 

  2066.                 for  ($i = 1;$i<count($bits2);$i++) {
    2067. 

  2067.                   $dtmp[$bits2[0]][] = $bits2[$i];
    2068. 

  2068.                 }
    2069. 

  2069.               } else  if  (count($bits2) == 2) {
    2070. 

  2070.                 $dtmp[$bits2[0]] = $bits2[1];
    2071. 

  2071.               }
    2072. 

  2072.             }
    2073. 

  2073. 

  2074.             $c = (int)$dtmp['C'];
    2075. 

  2075.             $n = $dtmp['N'];
    2076. 

  2076.             $width = floatval($dtmp['WX']);
    2077. 

  2077.             
    2078. 

  2078.             if  ($c >= 0) {
    2079. 

  2079.               if ($c != hexdec($n)) {
    2080. 

  2080.                 $data['codeToName'][$c] = $n;
    2081. 

  2081.               }
    2082. 

  2082.               $data['C'][$c] = $width;
    2083. 

  2083.             } else {
    2084. 

  2084.               $data['C'][$n] = $width;
    2085. 

  2085.             }
    2086. 

  2086. 

  2087.             if  (!isset($data['MissingWidth']) && $c == -1 && $n === '.notdef') {
    2088. 

  2088.               $data['MissingWidth'] = $width;
    2089. 

  2089.             }
    2090. 

  2090.             
    2091. 

  2091.             break;
    2092. 

  2092. 

  2093.           // U 827 ; WX 0 ; N squaresubnosp ; G 675 ;
    2094. 

  2094.           case  'U': // Found in UFM files
    2095. 

  2095.             if (!$data['isUnicode']) break;
    2096. 

  2096.             
    2097. 

  2097.             $bits = explode(';', trim($row));
    2098. 

  2098.             $dtmp = array();
    2099. 

  2099. 

  2100.             foreach($bits as  $bit) {
    2101. 

  2101.               $bits2 =  explode(' ', trim($bit));
    2102. 

  2102.               if  (mb_strlen($bits2[0], '8bit') === 0) continue;
    2103. 

  2103.               
    2104. 

  2104.               if  (count($bits2) >2) {
    2105. 

  2105.                 $dtmp[$bits2[0]] = array();
    2106. 

  2106.                 for  ($i = 1;$i<count($bits2);$i++) {
    2107. 

  2107.                   $dtmp[$bits2[0]][] = $bits2[$i];
    2108. 

  2108.                 }
    2109. 

  2109.               } else  if  (count($bits2) == 2) {
    2110. 

  2110.                 $dtmp[$bits2[0]] = $bits2[1];
    2111. 

  2111.               }
    2112. 

  2112.             }
    2113. 

  2113. 

  2114.             $c = (int)$dtmp['U'];
    2115. 

  2115.             $n = $dtmp['N'];
    2116. 

  2116.             $glyph = $dtmp['G'];
    2117. 

  2117.             $width = floatval($dtmp['WX']);
    2118. 

  2118.             
    2119. 

  2119.             if  ($c >= 0) {
    2120. 

  2120.               // Set values in CID to GID map
    2121. 

  2121.               if ($c >= 0 && $c < 0xFFFF && $glyph) {
    2122. 

  2122.                 $cidtogid[$c*2] = chr($glyph >> 8);
    2123. 

  2123.                 $cidtogid[$c*2 + 1] = chr($glyph & 0xFF);
    2124. 

  2124.               }
    2125. 

  2125.             
    2126. 

  2126.               if ($c != hexdec($n)) {
    2127. 

  2127.                 $data['codeToName'][$c] = $n;
    2128. 

  2128.               }
    2129. 

  2129.               $data['C'][$c] = $width;
    2130. 

  2130.             } else {
    2131. 

  2131.               $data['C'][$n] = $width;
    2132. 

  2132.             }
    2133. 

  2133.             
    2134. 

  2134.             if  (!isset($data['MissingWidth']) && $c == -1 && $n === '.notdef') {
    2135. 

  2135.               $data['MissingWidth'] = $width;
    2136. 

  2136.             }
    2137. 

  2137.               
    2138. 

  2138.             break;
    2139. 

  2139. 

  2140.           case  'KPX':
    2141. 

  2141.             break; // don't include them as they are not used yet
    2142. 

  2142.             //KPX Adieresis yacute -40
    2143. 

  2143.             $bits = explode(' ', trim($row));
    2144. 

  2144.             $data['KPX'][$bits[1]][$bits[2]] = $bits[3];
    2145. 

  2145.             break;
    2146. 

  2146.           }
    2147. 

  2147.         }
    2148. 

  2148.       }
    2149. 

  2149. 

  2150.       //    echo $cidtogid; die("CIDtoGID Displayed!");
    2151. 

  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. 

  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.       //echo 'Font not Found '.$font;
    2171. 

  2171.     }
    2172. 

  2172. 

  2173.     //pre_r($this->messages);
    2174. 

  2174.   }
    2175. 

  2175. 

  2176.   /**
    2177. 

  2177.    * if the font is not loaded then load it and make the required object
    2178. 

  2178.    * else just make it the current font
    2179. 

  2179.    * the encoding array can contain 'encoding'=> 'none','WinAnsiEncoding','MacRomanEncoding' or 'MacExpertEncoding'
    2180. 

  2180.    * note that encoding='none' will need to be used for symbolic fonts
    2181. 

  2181.    * and 'differences' => an array of mappings between numbers 0->255 and character names.
    2182. 

  2182.    *
    2183. 

  2183.    */
    2184. 

  2184.   function selectFont($fontName, $encoding =  '', $set =  true) {
    2185. 

  2185.     $ext = substr($fontName, -4);
    2186. 

  2186.     if  ($ext === '.afm' || $ext === '.ufm') {
    2187. 

  2187.       $fontName = substr($fontName, 0, mb_strlen($fontName)-4);
    2188. 

  2188.     }
    2189. 

  2189. 

  2190.     if  (!isset($this->fonts[$fontName])) {
    2191. 

  2191.       $this->addMessage("selectFont: selecting - $fontName - $encoding, $set");
    2192. 

  2192. 

  2193.       // load the file
    2194. 

  2194.       $this->openFont($fontName);
    2195. 

  2195. 

  2196.       if  (isset($this->fonts[$fontName])) {
    2197. 

  2197.         $this->numObj++;
    2198. 

  2198.         $this->numFonts++;
    2199. 

  2199.     
    2200. 

  2200.         $font = &$this->fonts[$fontName];
    2201. 

  2201. 

  2202.         //$this->numFonts = md5($fontName);
    2203. 

  2203.         $pos =  strrpos($fontName, '/');
    2204. 

  2204.         //      $dir = substr($fontName,0,$pos+1);
    2205. 

  2205.         $name =  substr($fontName, $pos+1);
    2206. 

  2206.         $options =  array('name' => $name, 'fontFileName' => $fontName);
    2207. 

  2207. 

  2208.         if  (is_array($encoding)) {
    2209. 

  2209.           // then encoding and differences might be set
    2210. 

  2210.           if  (isset($encoding['encoding'])) {
    2211. 

  2211.             $options['encoding'] =  $encoding['encoding'];
    2212. 

  2212.           }
    2213. 

  2213. 

  2214.           if  (isset($encoding['differences'])) {
    2215. 

  2215.             $options['differences'] =  $encoding['differences'];
    2216. 

  2216.           }
    2217. 

  2217.         } else  if  (mb_strlen($encoding, '8bit')) {
    2218. 

  2218.           // then perhaps only the encoding has been set
    2219. 

  2219.           $options['encoding'] =  $encoding;
    2220. 

  2220.         }
    2221. 

  2221. 

  2222.         $fontObj =  $this->numObj;
    2223. 

  2223.         $this->o_font($this->numObj, 'new', $options);
    2224. 

  2224.         $font['fontNum'] =  $this->numFonts;
    2225. 

  2225. 

  2226.         // if this is a '.afm' font, and there is a '.pfa' file to go with it ( as there
    2227. 

  2227.         // should be for all non-basic fonts), then load it into an object and put the
    2228. 

  2228.         // references into the font object
    2229. 

  2229.         $basefile =  $fontName;
    2230. 

  2230.         
    2231. 

  2231.         $fbtype = '';
    2232. 

  2232.         if  (file_exists("$basefile.pfb")) {
    2233. 

  2233.           $fbtype =  'pfb';
    2234. 

  2234.         } 
    2235. 

  2235.         elseif  (file_exists("$basefile.ttf")) {
    2236. 

  2236.           $fbtype =  'ttf';
    2237. 

  2237.         }
    2238. 

  2238. 

  2239.         $fbfile =  "$basefile.$fbtype";
    2240. 

  2240. 

  2241.         //      $pfbfile = substr($fontName,0,strlen($fontName)-4).'.pfb';
    2242. 

  2242.         //      $ttffile = substr($fontName,0,strlen($fontName)-4).'.ttf';
    2243. 

  2243.         $this->addMessage('selectFont: checking for - '.$fbfile);
    2244. 

  2244. 

  2245.         // OAR - I don't understand this old check
    2246. 

  2246.         // if  (substr($fontName, -4) ===  '.afm' &&  strlen($fbtype)) {
    2247. 

  2247.         if  ($fbtype) {
    2248. 

  2248.           $adobeFontName =  isset($font['PostScriptName']) ? $font['PostScriptName'] : $font['FontName'];
    2249. 

  2249.           //        $fontObj = $this->numObj;
    2250. 

  2250.           $this->addMessage("selectFont: adding font file - $fbfile - $adobeFontName");
    2251. 

  2251. 

  2252.           // find the array of font widths, and put that into an object.
    2253. 

  2253.           $firstChar =  -1;
    2254. 

  2254.           $lastChar =  0;
    2255. 

  2255.           $widths =  array();
    2256. 

  2256.           $cid_widths = array();
    2257. 

  2257. 

  2258.           foreach ($font['C'] as  $num => $d) {
    2259. 

  2259.             if  (intval($num) >0 ||  $num ==  '0') {
    2260. 

  2260.               if (!$font['isUnicode']) {
    2261. 

  2261.                 // With Unicode, widths array isn't used
    2262. 

  2262.                 if  ($lastChar>0 &&  $num>$lastChar+1) {
    2263. 

  2263.                   for ($i =  $lastChar+1;$i<$num;$i++) {
    2264. 

  2264.                     $widths[] =  0;
    2265. 

  2265.                   }
    2266. 

  2266.                 }
    2267. 

  2267.               }
    2268. 

  2268. 

  2269.               $widths[] =  $d;
    2270. 

  2270. 

  2271.               if ($font['isUnicode']) {
    2272. 

  2272.                 $cid_widths[$num] =  $d;
    2273. 

  2273.               }
    2274. 

  2274. 

  2275.               if  ($firstChar ==  -1) {
    2276. 

  2276.                 $firstChar =  $num;
    2277. 

  2277.               }
    2278. 

  2278. 

  2279.               $lastChar =  $num;
    2280. 

  2280.             }
    2281. 

  2281.           }
    2282. 

  2282. 

  2283.           // also need to adjust the widths for the differences array
    2284. 

  2284.           if  (isset($options['differences'])) {
    2285. 

  2285.             foreach($options['differences'] as  $charNum => $charName) {
    2286. 

  2286.               if  ($charNum > $lastChar) {
    2287. 

  2287.                 if (!$font['isUnicode']) {
    2288. 

  2288.                   // With Unicode, widths array isn't used
    2289. 

  2289.                   for ($i =  $lastChar + 1; $i <=  $charNum; $i++) {
    2290. 

  2290.                     $widths[] =  0;
    2291. 

  2291.                   }
    2292. 

  2292.                 }
    2293. 

  2293. 

  2294.                 $lastChar =  $charNum;
    2295. 

  2295.               }
    2296. 

  2296. 

  2297.               if  (isset($font['C'][$charName])) {
    2298. 

  2298.                 $widths[$charNum-$firstChar] =  $font['C'][$charName];
    2299. 

  2299.                 if ($font['isUnicode']) {
    2300. 

  2300.                   $cid_widths[$charName] =  $font['C'][$charName];
    2301. 

  2301.                 }
    2302. 

  2302.               }
    2303. 

  2303.             }
    2304. 

  2304.           }
    2305. 

  2305. 

  2306.           if ($font['isUnicode']) {
    2307. 

  2307.             $font['CIDWidths'] = $cid_widths;
    2308. 

  2308.           }
    2309. 

  2309. 

  2310.           $this->addMessage('selectFont: FirstChar = '.$firstChar);
    2311. 

  2311.           $this->addMessage('selectFont: LastChar = '.$lastChar);
    2312. 

  2312. 

  2313.           $widthid = -1;
    2314. 

  2314. 

  2315.           if (!$font['isUnicode']) {
    2316. 

  2316.             // With Unicode, widths array isn't used
    2317. 

  2317. 

  2318.             $this->numObj++;
    2319. 

  2319.             $this->o_contents($this->numObj, 'new', 'raw');
    2320. 

  2320.             $this->objects[$this->numObj]['c'].=  '['.implode(' ', $widths).']';
    2321. 

  2321.             $widthid =  $this->numObj;
    2322. 

  2322.           }
    2323. 

  2323. 

  2324.           $missing_width = 500;
    2325. 

  2325.           $stemV = 70;
    2326. 

  2326. 

  2327.           if (isset($font['MissingWidth'])) {
    2328. 

  2328.             $missing_width =  $font['MissingWidth'];
    2329. 

  2329.           }
    2330. 

  2330.           if (isset($font['StdVW'])) {
    2331. 

  2331.             $stemV = $font['StdVW'];
    2332. 

  2332.           } elseif (isset($font['Weight']) && preg_match('!(bold|black)!i', $font['Weight'])) {
    2333. 

  2333.             $stemV = 120;
    2334. 

  2334.           }
    2335. 

  2335.           
    2336. 

  2336.           // load the pfb file, and put that into an object too.
    2337. 

  2337.           // note that pdf supports only binary format type 1 font files, though there is a
    2338. 

  2338.           // simple utility to convert them from pfa to pfb.
    2339. 

  2339.           if (!$this->isUnicode || $fbtype !== 'ttf' || empty($this->stringSubsets)) {
    2340. 

  2340.             $data = file_get_contents($fbfile);
    2341. 

  2341.           }
    2342. 

  2342.           else {
    2343. 

  2343.             require_once dirname(__FILE__)."/php-font-lib/classes/font.cls.php";
    2344. 

  2344.             
    2345. 

  2345.             $this->stringSubsets[$fontName][] = 32; // Force space if not in yet
    2346. 

  2346.             
    2347. 

  2347.             $subset = $this->stringSubsets[$fontName];
    2348. 

  2348.             sort($subset);
    2349. 

  2349.             
    2350. 

  2350.             // Load font
    2351. 

  2351.             $font_obj = Font::load($fbfile);
    2352. 

  2352.             $font_obj->parse();
    2353. 

  2353.             
    2354. 

  2354.             // Define subset
    2355. 

  2355.             $font_obj->setSubset($subset);
    2356. 

  2356.             $font_obj->reduce();
    2357. 

  2357.             
    2358. 

  2358.             // Write new font
    2359. 

  2359.             $tmp_name = "$fbfile.tmp.".sprintf("%u", crc32(implode($subset)));
    2360. 

  2360.             $font_obj->open($tmp_name, Font_Binary_Stream::modeWrite);
    2361. 

  2361.             $font_obj->encode(array("OS/2"));
    2362. 

  2362.             $font_obj->close();
    2363. 

  2363.             
    2364. 

  2364.             // Parse the new font to get cid2gid and widths
    2365. 

  2365.             $font_obj = Font::load($tmp_name);
    2366. 

  2366.             
    2367. 

  2367.             // Find Unicode char map table
    2368. 

  2368.             $subtable = null;
    2369. 

  2369.             foreach($font_obj->getData("cmap", "subtables") as $_subtable) {
    2370. 

  2370.               if ($_subtable["platformID"] == 0 || $_subtable["platformID"] == 3 && $_subtable["platformSpecificID"] == 1) {
    2371. 

  2371.                 $subtable = $_subtable;
    2372. 

  2372.                 break;
    2373. 

  2373.               }
    2374. 

  2374.             }
    2375. 

  2375.             
    2376. 

  2376.             if ($subtable) {
    2377. 

  2377.               $glyphIndexArray = $subtable["glyphIndexArray"];
    2378. 

  2378.               $hmtx = $font_obj->getData("hmtx");
    2379. 

  2379.               
    2380. 

  2380.               unset($glyphIndexArray[0xFFFF]);
    2381. 

  2381.               
    2382. 

  2382.               $cidtogid = str_pad('', max(array_keys($glyphIndexArray))*2+1, "\x00");
    2383. 

  2383.               $font['CIDWidths'] = array();
    2384. 

  2384.               
    2385. 

  2385.               foreach($glyphIndexArray as $cid => $gid) {
    2386. 

  2386.                 if ($cid >= 0 && $cid < 0xFFFF && $gid) {
    2387. 

  2387.                   $cidtogid[$cid*2] = chr($gid >> 8);
    2388. 

  2388.                   $cidtogid[$cid*2 + 1] = chr($gid & 0xFF);
    2389. 

  2389.                 }
    2390. 

  2390.                 
    2391. 

  2391.                 $width = $font_obj->normalizeFUnit(isset($hmtx[$gid]) ? $hmtx[$gid][0] : $hmtx[0][0]);
    2392. 

  2392.                 $font['CIDWidths'][$cid] = $width;
    2393. 

  2393.               }
    2394. 

  2394.               
    2395. 

  2395.               $font['CIDtoGID'] = base64_encode(gzcompress($cidtogid));
    2396. 

  2396.               $font['CIDtoGID_Compressed'] = true;
    2397. 

  2397.               
    2398. 

  2398.               $data = file_get_contents($tmp_name);
    2399. 

  2399.             }
    2400. 

  2400.             else {
    2401. 

  2401.               $data = file_get_contents($fbfile);
    2402. 

  2402.             }
    2403. 

  2403.             
    2404. 

  2404.             $font_obj->close();
    2405. 

  2405.             unlink($tmp_name);
    2406. 

  2406.           }
    2407. 

  2407. 

  2408.           // create the font descriptor
    2409. 

  2409.           $this->numObj++;
    2410. 

  2410.           $fontDescriptorId =  $this->numObj;
    2411. 

  2411. 

  2412.           $this->numObj++;
    2413. 

  2413.           $pfbid =  $this->numObj;
    2414. 

  2414. 

  2415.           // determine flags (more than a little flakey, hopefully will not matter much)
    2416. 

  2416.           $flags =  0;
    2417. 

  2417. 

  2418.           if  ($font['ItalicAngle'] !=  0) {
    2419. 

  2419.             $flags+=  pow(2, 6);
    2420. 

  2420.           }
    2421. 

  2421. 

  2422.           if  ($font['IsFixedPitch'] === 'true') {
    2423. 

  2423.             $flags+=  1;
    2424. 

  2424.           }
    2425. 

  2425. 

  2426.           $flags+=  pow(2, 5); // assume non-sybolic
    2427. 

  2427.           $list =  array(
    2428. 

  2428.             'Ascent' => 'Ascender',
    2429. 

  2429.             'CapHeight' => 'CapHeight',
    2430. 

  2430.             'MissingWidth' => 'MissingWidth',
    2431. 

  2431.             'Descent' => 'Descender',
    2432. 

  2432.             'FontBBox' => 'FontBBox',
    2433. 

  2433.             'ItalicAngle' => 'ItalicAngle'
    2434. 

  2434.           );
    2435. 

  2435.           $fdopt =  array(
    2436. 

  2436.             'Flags' => $flags,
    2437. 

  2437.             'FontName' => $adobeFontName,
    2438. 

  2438.             'StemV' => $stemV
    2439. 

  2439.           );
    2440. 

  2440. 

  2441.           foreach($list as  $k => $v) {
    2442. 

  2442.             if  (isset($font[$v])) {
    2443. 

  2443.               $fdopt[$k] =  $font[$v];
    2444. 

  2444.             }
    2445. 

  2445.           }
    2446. 

  2446. 

  2447.           if  ($fbtype === 'pfb') {
    2448. 

  2448.             $fdopt['FontFile'] =  $pfbid;
    2449. 

  2449.           } else  if  ($fbtype === 'ttf') {
    2450. 

  2450.             $fdopt['FontFile2'] =  $pfbid;
    2451. 

  2451.           }
    2452. 

  2452. 

  2453.           $this->o_fontDescriptor($fontDescriptorId, 'new', $fdopt);
    2454. 

  2454. 

  2455.           // embed the font program
    2456. 

  2456.           $this->o_contents($this->numObj, 'new');
    2457. 

  2457.           $this->objects[$pfbid]['c'].=  $data;
    2458. 

  2458. 

  2459.           // determine the cruicial lengths within this file
    2460. 

  2460.           if  ($fbtype === 'pfb') {
    2461. 

  2461.             $l1 =  strpos($data, 'eexec') +6;
    2462. 

  2462.             $l2 =  strpos($data, '00000000') -$l1;
    2463. 

  2463.             $l3 =  mb_strlen($data, '8bit') -$l2-$l1;
    2464. 

  2464.             $this->o_contents($this->numObj, 'add', array('Length1' => $l1, 'Length2' => $l2, 'Length3' => $l3));
    2465. 

  2465.           } else  if  ($fbtype == 'ttf') {
    2466. 

  2466.             $l1 =  mb_strlen($data, '8bit');
    2467. 

  2467.             $this->o_contents($this->numObj, 'add', array('Length1' => $l1));
    2468. 

  2468.           }
    2469. 

  2469. 

  2470.           // tell the font object about all this new stuff
    2471. 

  2471.           $tmp =  array(
    2472. 

  2472.             'BaseFont' => $adobeFontName,
    2473. 

  2473.             'MissingWidth' => $missing_width,
    2474. 

  2474.             'Widths' => $widthid,
    2475. 

  2475.             'FirstChar' => $firstChar,
    2476. 

  2476.             'LastChar' => $lastChar,
    2477. 

  2477.             'FontDescriptor' => $fontDescriptorId,
    2478. 

  2478.           );
    2479. 

  2479. 

  2480.           if  ($fbtype === 'ttf') {
    2481. 

  2481.             $tmp['SubType'] =  'TrueType';
    2482. 

  2482.           }
    2483. 

  2483. 

  2484.           $this->addMessage("adding extra info to font.($fontObj)");
    2485. 

  2485. 

  2486.           foreach($tmp as  $fk => $fv) {
    2487. 

  2487.             $this->addMessage("$fk : $fv");
    2488. 

  2488.           }
    2489. 

  2489. 

  2490.           $this->o_font($fontObj, 'add', $tmp);
    2491. 

  2491.         } else {
    2492. 

  2492.           $this->addMessage('selectFont: pfb or ttf file not found, ok if this is one of the 14 standard fonts');
    2493. 

  2493.         }
    2494. 

  2494. 

  2495.         // also set the differences here, note that this means that these will take effect only the
    2496. 

  2496.         //first time that a font is selected, else they are ignored
    2497. 

  2497.         if  (isset($options['differences'])) {
    2498. 

  2498.           $font['differences'] =  $options['differences'];
    2499. 

  2499.         }
    2500. 

  2500.       }
    2501. 

  2501.     }
    2502. 

  2502. 

  2503.     if  ($set &&  isset($this->fonts[$fontName])) {
    2504. 

  2504.       // so if for some reason the font was not set in the last one then it will not be selected
    2505. 

  2505.       $this->currentBaseFont =  $fontName;
    2506. 

  2506. 

  2507.       // the next lines mean that if a new font is selected, then the current text state will be
    2508. 

  2508.       // applied to it as well.
    2509. 

  2509.       $this->currentFont =  $this->currentBaseFont;
    2510. 

  2510.       $this->currentFontNum =  $this->fonts[$this->currentFont]['fontNum'];
    2511. 

  2511. 

  2512.       //$this->setCurrentFont();
    2513. 

  2513.     }
    2514. 

  2514. 

  2515.     return  $this->currentFontNum;
    2516. 

  2516.     //return $this->numObj;
    2517. 

  2517.   }
    2518. 

  2518. 

  2519.   /**
    2520. 

  2520.    * sets up the current font, based on the font families, and the current text state
    2521. 

  2521.    * note that this system is quite flexible, a bold-italic font can be completely different to a
    2522. 

  2522.    * italic-bold font, and even bold-bold will have to be defined within the family to have meaning
    2523. 

  2523.    * This function is to be called whenever the currentTextState is changed, it will update
    2524. 

  2524.    * the currentFont setting to whatever the appropriatte family one is.
    2525. 

  2525.    * If the user calls selectFont themselves then that will reset the currentBaseFont, and the currentFont
    2526. 

  2526.    * This function will change the currentFont to whatever it should be, but will not change the
    2527. 

  2527.    * currentBaseFont.
    2528. 

  2528.    *
    2529. 

  2529.    * @access private
    2530. 

  2530.    */
    2531. 

  2531.   function setCurrentFont() {
    2532. 

  2532.     //   if (strlen($this->currentBaseFont) == 0){
    2533. 

  2533.     //     // then assume an initial font
    2534. 

  2534.     //     $this->selectFont($this->defaultFont);
    2535. 

  2535.     //   }
    2536. 

  2536.     //   $cf = substr($this->currentBaseFont,strrpos($this->currentBaseFont,'/')+1);
    2537. 

  2537.     //   if (strlen($this->currentTextState)
    2538. 

  2538.     //     && isset($this->fontFamilies[$cf])
    2539. 

  2539.     //       && isset($this->fontFamilies[$cf][$this->currentTextState])){
    2540. 

  2540.     //     // then we are in some state or another
    2541. 

  2541.     //     // and this font has a family, and the current setting exists within it
    2542. 

  2542.     //     // select the font, then return it
    2543. 

  2543.     //     $nf = substr($this->currentBaseFont,0,strrpos($this->currentBaseFont,'/')+1).$this->fontFamilies[$cf][$this->currentTextState];
    2544. 

  2544.     //     $this->selectFont($nf,'',0);
    2545. 

  2545.     //     $this->currentFont = $nf;
    2546. 

  2546.     //     $this->currentFontNum = $this->fonts[$nf]['fontNum'];
    2547. 

  2547.     //   } else {
    2548. 

  2548.     //     // the this font must not have the right family member for the current state
    2549. 

  2549.     //     // simply assume the base font
    2550. 

  2550.     $this->currentFont =  $this->currentBaseFont;
    2551. 

  2551.     $this->currentFontNum =  $this->fonts[$this->currentFont]['fontNum'];
    2552. 

  2552.     //  }
    2553. 

  2553.   }
    2554. 

  2554. 

  2555.   /**
    2556. 

  2556.    * function for the user to find out what the ID is of the first page that was created during
    2557. 

  2557.    * startup - useful if they wish to add something to it later.
    2558. 

  2558.    */
    2559. 

  2559.   function getFirstPageId() {
    2560. 

  2560.     return  $this->firstPageId;
    2561. 

  2561.   }
    2562. 

  2562. 

  2563.   /**
    2564. 

  2564.    * add content to the currently active object
    2565. 

  2565.    *
    2566. 

  2566.    * @access private
    2567. 

  2567.    */
    2568. 

  2568.   function addContent($content) {
    2569. 

  2569.     $this->objects[$this->currentContents]['c'].=  $content;
    2570. 

  2570.   }
    2571. 

  2571. 

  2572.   /**
    2573. 

  2573.    * sets the colour for fill operations
    2574. 

  2574.    */
    2575. 

  2575.   function setColor($color, $force = false) {
    2576. 

  2576.     $new_color = array($color[0], $color[1], $color[2], isset($color[3]) ? $color[3] : null);
    2577. 

  2577.     
    2578. 

  2578.     if (!$force && $this->currentColour == $new_color) return;
    2579. 

  2579.     
    2580. 

  2580.     if (isset($new_color[3])) {
    2581. 

  2581.       $this->currentColour = $new_color;
    2582. 

  2582.       $this->objects[$this->currentContents]['c'] .= vsprintf("\n%.3F %.3F %.3F %.3F k", $this->currentColour);
    2583. 

  2583.     }
    2584. 

  2584. 

  2585.     elseif (isset($new_color[2])) {
    2586. 

  2586.       $this->currentColour = $new_color;
    2587. 

  2587.       $this->objects[$this->currentContents]['c'] .= vsprintf("\n%.3F %.3F %.3F rg", $this->currentColour);
    2588. 

  2588.     }
    2589. 

  2589.   }
    2590. 

  2590. 

  2591.   /**
    2592. 

  2592.    * sets the colour for stroke operations
    2593. 

  2593.    */
    2594. 

  2594.   function setStrokeColor($color, $force =  false) {
    2595. 

  2595.     $new_color = array($color[0], $color[1], $color[2], isset($color[3]) ? $color[3] : null);
    2596. 

  2596.     
    2597. 

  2597.     if (!$force && $this->currentStrokeColour == $new_color) return;
    2598. 

  2598.     
    2599. 

  2599.     if (isset($new_color[3])) {
    2600. 

  2600.       $this->currentStrokeColour = $new_color;
    2601. 

  2601.       $this->objects[$this->currentContents]['c'] .= vsprintf("\n%.3F %.3F %.3F %.3F K", $this->currentStrokeColour);
    2602. 

  2602.     }
    2603. 

  2603. 

  2604.     elseif (isset($new_color[2])) {
    2605. 

  2605.       $this->currentStrokeColour = $new_color;
    2606. 

  2606.       $this->objects[$this->currentContents]['c'] .= vsprintf("\n%.3F %.3F %.3F RG", $this->currentStrokeColour);
    2607. 

  2607.     }
    2608. 

  2608.   }
    2609. 

  2609. 

  2610.   /**
    2611. 

  2611.    * Set the graphics state for compositions
    2612. 

  2612.    */
    2613. 

  2613.   function setGraphicsState($parameters) {
    2614. 

  2614.     // Create a new graphics state object
    2615. 

  2615.     // FIXME: should actually keep track of states that have already been created...
    2616. 

  2616.     $this->numObj++;
    2617. 

  2617.     $this->o_extGState($this->numObj,  'new',  $parameters);
    2618. 

  2618.     $this->objects[ $this->currentContents ]['c'].=  "\n/GS$this->numStates gs";
    2619. 

  2619.   }
    2620. 

  2620. 

  2621.   /**
    2622. 

  2622.    * Set current blend mode & opacity for lines.
    2623. 

  2623.    *
    2624. 

  2624.    * Valid blend modes are:
    2625. 

  2625.    *
    2626. 

  2626.    * Normal, Multiply, Screen, Overlay, Darken, Lighten,
    2627. 

  2627.    * ColorDogde, ColorBurn, HardLight, SoftLight, Difference,
    2628. 

  2628.    * Exclusion
    2629. 

  2629.    *
    2630. 

  2630.    * @param string $mode the blend mode to use
    2631. 

  2631.    * @param float $opacity 0.0 fully transparent, 1.0 fully opaque
    2632. 

  2632.    */
    2633. 

  2633.   function setLineTransparency($mode, $opacity) {
    2634. 

  2634.     static $blend_modes = array("Normal", "Multiply", "Screen",
    2635. 

  2635.                                 "Overlay", "Darken", "Lighten",
    2636. 

  2636.                                 "ColorDogde", "ColorBurn", "HardLight",
    2637. 

  2637.                                 "SoftLight", "Difference", "Exclusion");
    2638. 

  2638. 

  2639.     if ( !in_array($mode, $blend_modes) )
    2640. 

  2640.       $mode = "Normal";
    2641. 

  2641.     
    2642. 

  2642.     // Only create a new graphics state if required
    2643. 

  2643.     if ( $mode === $this->currentLineTransparency["mode"]  &&
    2644. 

  2644.          $opacity == $this->currentLineTransparency["opacity"] )
    2645. 

  2645.       return;
    2646. 

  2646. 

  2647.     $this->currentLineTransparency["mode"] = $mode;
    2648. 

  2648.     $this->currentLineTransparency["opacity"] = $opacity;
    2649. 

  2649.     
    2650. 

  2650.     $options = array("BM" => "/$mode",
    2651. 

  2651.                      "CA" => (float)$opacity);
    2652. 

  2652. 

  2653.     $this->setGraphicsState($options);
    2654. 

  2654.   }
    2655. 

  2655.   
    2656. 

  2656.   /**
    2657. 

  2657.    * Set current blend mode & opacity for filled objects.
    2658. 

  2658.    *
    2659. 

  2659.    * Valid blend modes are:
    2660. 

  2660.    *
    2661. 

  2661.    * Normal, Multiply, Screen, Overlay, Darken, Lighten,
    2662. 

  2662.    * ColorDogde, ColorBurn, HardLight, SoftLight, Difference,
    2663. 

  2663.    * Exclusion
    2664. 

  2664.    *
    2665. 

  2665.    * @param string $mode the blend mode to use
    2666. 

  2666.    * @param float $opacity 0.0 fully transparent, 1.0 fully opaque
    2667. 

  2667.    */
    2668. 

  2668.   function setFillTransparency($mode, $opacity) {
    2669. 

  2669.     static $blend_modes = array("Normal", "Multiply", "Screen",
    2670. 

  2670.                                 "Overlay", "Darken", "Lighten",
    2671. 

  2671.                                 "ColorDogde", "ColorBurn", "HardLight",
    2672. 

  2672.                                 "SoftLight", "Difference", "Exclusion");
    2673. 

  2673. 

  2674.     if ( !in_array($mode, $blend_modes) )
    2675. 

  2675.       $mode = "Normal";
    2676. 

  2676. 

  2677.     if ( $mode === $this->currentFillTransparency["mode"]  &&
    2678. 

  2678.          $opacity == $this->currentFillTransparency["opacity"] )
    2679. 

  2679.       return;
    2680. 

  2680.       
    2681. 

  2681.     $this->currentFillTransparency["mode"] = $mode;
    2682. 

  2682.     $this->currentFillTransparency["opacity"] = $opacity;
    2683. 

  2683. 

  2684.     $options = array("BM" => "/$mode",
    2685. 

  2685.                      "ca" => (float)$opacity);
    2686. 

  2686.     
    2687. 

  2687.     $this->setGraphicsState($options);
    2688. 

  2688.   }
    2689. 

  2689. 

  2690.   /**
    2691. 

  2691.    * draw a line from one set of coordinates to another
    2692. 

  2692.    */
    2693. 

  2693.   function line($x1, $y1, $x2, $y2) {
    2694. 

  2694.     $this->objects[$this->currentContents]['c'] .= sprintf("\n%.3F %.3F m %.3F %.3F l S", $x1, $y1, $x2, $y2);
    2695. 

  2695.   }
    2696. 

  2696. 

  2697.   /**
    2698. 

  2698.    * draw a bezier curve based on 4 control points
    2699. 

  2699.    */
    2700. 

  2700.   function curve($x0, $y0, $x1, $y1, $x2, $y2, $x3, $y3) {
    2701. 

  2701.     // in the current line style, draw a bezier curve from (x0,y0) to (x3,y3) using the other two points
    2702. 

  2702.     // as the control points for the curve.
    2703. 

  2703.     $this->objects[$this->currentContents]['c'] .=
    2704. 

  2704.       sprintf("\n%.3F %.3F m %.3F %.3F %.3F %.3F %.3F %.3F c S", $x0, $y0, $x1, $y1, $x2, $y2, $x3, $y3);
    2705. 

  2705.   }
    2706. 

  2706. 

  2707.   /**
    2708. 

  2708.    * draw a part of an ellipse
    2709. 

  2709.    */
    2710. 

  2710.   function partEllipse($x0, $y0, $astart, $afinish, $r1, $r2 =  0, $angle =  0, $nSeg =  8) {
    2711. 

  2711.     $this->ellipse($x0, $y0, $r1, $r2, $angle, $nSeg, $astart, $afinish, false);
    2712. 

  2712.   }
    2713. 

  2713. 

  2714.   /**
    2715. 

  2715.    * draw a filled ellipse
    2716. 

  2716.    */
    2717. 

  2717.   function filledEllipse($x0, $y0, $r1, $r2 =  0, $angle =  0, $nSeg =  8, $astart =  0, $afinish =  360) {
    2718. 

  2718.     return  $this->ellipse($x0, $y0, $r1, $r2 =  0, $angle, $nSeg, $astart, $afinish, true, true);
    2719. 

  2719.   }
    2720. 

  2720. 

  2721.   /**
    2722. 

  2722.    * draw an ellipse
    2723. 

  2723.    * note that the part and filled ellipse are just special cases of this function
    2724. 

  2724.    *
    2725. 

  2725.    * draws an ellipse in the current line style
    2726. 

  2726.    * centered at $x0,$y0, radii $r1,$r2
    2727. 

  2727.    * if $r2 is not set, then a circle is drawn
    2728. 

  2728.    * nSeg is not allowed to be less than 2, as this will simply draw a line (and will even draw a
    2729. 

  2729.    * pretty crappy shape at 2, as we are approximating with bezier curves.
    2730. 

  2730.    */
    2731. 

  2731.   function ellipse($x0, $y0, $r1, $r2 =  0, $angle =  0, $nSeg =  8, $astart =  0, $afinish =  360, $close =  true, $fill =  false) {
    2732. 

  2732.     if  ($r1 ==  0) {
    2733. 

  2733.       return;
    2734. 

  2734.     }
    2735. 

  2735. 

  2736.     if  ($r2 ==  0) {
    2737. 

  2737.       $r2 =  $r1;
    2738. 

  2738.     }
    2739. 

  2739. 

  2740.     if  ($nSeg < 2) {
    2741. 

  2741.       $nSeg =  2;
    2742. 

  2742.     }
    2743. 

  2743. 

  2744.     $astart =  deg2rad((float)$astart);
    2745. 

  2745.     $afinish =  deg2rad((float)$afinish);
    2746. 

  2746.     $totalAngle = $afinish-$astart;
    2747. 

  2747. 

  2748.     $dt =  $totalAngle/$nSeg;
    2749. 

  2749.     $dtm =  $dt/3;
    2750. 

  2750. 

  2751.     if  ($angle !=  0) {
    2752. 

  2752.       $a =  -1*deg2rad((float)$angle);
    2753. 

  2753. 

  2754.       $this->objects[$this->currentContents]['c'] .=
    2755. 

  2755.         sprintf("\n q %.3F %.3F %.3F %.3F %.3F %.3F cm", cos($a), -sin($a), sin($a), cos($a), $x0, $y0);
    2756. 

  2756. 

  2757.       $x0 =  0;
    2758. 

  2758.       $y0 =  0;
    2759. 

  2759.     }
    2760. 

  2760. 

  2761.     $t1 =  $astart;
    2762. 

  2762.     $a0 =  $x0 + $r1*cos($t1);
    2763. 

  2763.     $b0 =  $y0 + $r2*sin($t1);
    2764. 

  2764.     $c0 =  -$r1 * sin($t1);
    2765. 

  2765.     $d0 =  $r2 * cos($t1);
    2766. 

  2766. 

  2767.     $this->objects[$this->currentContents]['c'] .= sprintf("\n%.3F %.3F m ", $a0, $b0);
    2768. 

  2768. 

  2769.     for  ($i = 1; $i <=  $nSeg; $i++) {
    2770. 

  2770.       // draw this bit of the total curve
    2771. 

  2771.       $t1 =  $i * $dt + $astart;
    2772. 

  2772.       $a1 =  $x0 + $r1 * cos($t1);
    2773. 

  2773.       $b1 =  $y0 + $r2 * sin($t1);
    2774. 

  2774.       $c1 = -$r1 * sin($t1);
    2775. 

  2775.       $d1 =  $r2 * cos($t1);
    2776. 

  2776. 

  2777.       $this->objects[$this->currentContents]['c'] .=
    2778. 

  2778.         sprintf("\n%.3F %.3F %.3F %.3F %.3F %.3F c", ($a0+$c0*$dtm), ($b0+$d0*$dtm), ($a1-$c1*$dtm), ($b1-$d1*$dtm), $a1, $b1);
    2779. 

  2779. 

  2780.       $a0 =  $a1;
    2781. 

  2781.       $b0 =  $b1;
    2782. 

  2782.       $c0 =  $c1;
    2783. 

  2783.       $d0 =  $d1;
    2784. 

  2784.     }
    2785. 

  2785. 

  2786.     if  ($fill) {
    2787. 

  2787.       $this->objects[$this->currentContents]['c'].=  ' f';
    2788. 

  2788.     } else if ($close) {
    2789. 

  2789.       $this->objects[$this->currentContents]['c'].=  ' s'; // small 's' signifies closing the path as well
    2790. 

  2790.     } else {
    2791. 

  2791.       $this->objects[$this->currentContents]['c'].=  ' S';
    2792. 

  2792.     }
    2793. 

  2793. 

  2794.     if  ($angle !=  0) {
    2795. 

  2795.       $this->objects[$this->currentContents]['c'].=  ' Q';
    2796. 

  2796.     }
    2797. 

  2797.   }
    2798. 

  2798. 

  2799.   /**
    2800. 

  2800.    * this sets the line drawing style.
    2801. 

  2801.    * width, is the thickness of the line in user units
    2802. 

  2802.    * cap is the type of cap to put on the line, values can be 'butt','round','square'
    2803. 

  2803.    *    where the diffference between 'square' and 'butt' is that 'square' projects a flat end past the
    2804. 

  2804.    *    end of the line.
    2805. 

  2805.    * join can be 'miter', 'round', 'bevel'
    2806. 

  2806.    * dash is an array which sets the dash pattern, is a series of length values, which are the lengths of the
    2807. 

  2807.    *   on and off dashes.
    2808. 

  2808.    *   (2) represents 2 on, 2 off, 2 on , 2 off ...
    2809. 

  2809.    *   (2,1) is 2 on, 1 off, 2 on, 1 off.. etc
    2810. 

  2810.    * phase is a modifier on the dash pattern which is used to shift the point at which the pattern starts.
    2811. 

  2811.    */
    2812. 

  2812.   function setLineStyle($width =  1, $cap =  '', $join =  '', $dash =  '', $phase =  0) {
    2813. 

  2813.     // this is quite inefficient in that it sets all the parameters whenever 1 is changed, but will fix another day
    2814. 

  2814.     $string =  '';
    2815. 

  2815. 

  2816.     if  ($width>0) {
    2817. 

  2817.       $string.=  "$width w";
    2818. 

  2818.     }
    2819. 

  2819. 

  2820.     $ca =  array('butt' => 0, 'round' => 1, 'square' => 2);
    2821. 

  2821. 

  2822.     if  (isset($ca[$cap])) {
    2823. 

  2823.       $string.=  " $ca[$cap] J";
    2824. 

  2824.     }
    2825. 

  2825. 

  2826.     $ja =  array('miter' => 0, 'round' => 1, 'bevel' => 2);
    2827. 

  2827. 

  2828.     if  (isset($ja[$join])) {
    2829. 

  2829.       $string.=  " $ja[$join] j";
    2830. 

  2830.     }
    2831. 

  2831. 

  2832.     if  (is_array($dash)) {
    2833. 

  2833.       $string.=  ' [ ' . implode(' ', $dash) . " ] $phase d";
    2834. 

  2834.     }
    2835. 

  2835. 

  2836.     $this->currentLineStyle =  $string;
    2837. 

  2837.     $this->objects[$this->currentContents]['c'].=  "\n$string";
    2838. 

  2838.   }
    2839. 

  2839. 

  2840.   /**
    2841. 

  2841.    * draw a polygon, the syntax for this is similar to the GD polygon command
    2842. 

  2842.    */
    2843. 

  2843.   function polygon($p, $np, $f = false) {
    2844. 

  2844.     $this->objects[$this->currentContents]['c'].=  sprintf("\n%.3F %.3F m ", $p[0], $p[1]);
    2845. 

  2845. 

  2846.     for  ($i =  2; $i < $np * 2; $i =  $i + 2) {
    2847. 

  2847.       $this->objects[$this->currentContents]['c'].=  sprintf("%.3F %.3F l ", $p[$i], $p[$i+1]);
    2848. 

  2848.     }
    2849. 

  2849. 

  2850.     if  ($f) {
    2851. 

  2851.       $this->objects[$this->currentContents]['c'].=  ' f';
    2852. 

  2852.     } else {
    2853. 

  2853.       $this->objects[$this->currentContents]['c'].=  ' S';
    2854. 

  2854.     }
    2855. 

  2855.   }
    2856. 

  2856. 

  2857.   /**
    2858. 

  2858.    * a filled rectangle, note that it is the width and height of the rectangle which are the secondary paramaters, not
    2859. 

  2859.    * the coordinates of the upper-right corner
    2860. 

  2860.    */
    2861. 

  2861.   function filledRectangle($x1, $y1, $width, $height) {
    2862. 

  2862.     $this->objects[$this->currentContents]['c'].=  sprintf("\n%.3F %.3F %.3F %.3F re f", $x1, $y1, $width, $height);
    2863. 

  2863.   }
    2864. 

  2864. 

  2865.   /**
    2866. 

  2866.    * draw a rectangle, note that it is the width and height of the rectangle which are the secondary paramaters, not
    2867. 

  2867.    * the coordinates of the upper-right corner
    2868. 

  2868.    */
    2869. 

  2869.   function rectangle($x1, $y1, $width, $height) {
    2870. 

  2870.     $this->objects[$this->currentContents]['c'].=  sprintf("\n%.3F %.3F %.3F %.3F re S", $x1, $y1, $width, $height);
    2871. 

  2871.   }
    2872. 

  2872. 

  2873.   /**
    2874. 

  2874.    * save the current graphic state
    2875. 

  2875.    */
    2876. 

  2876.   function save() {
    2877. 

  2877.     // we must reset the colour cache or it will keep bad colours after clipping
    2878. 

  2878.     $this->currentColour = null;
    2879. 

  2879.     $this->currentStrokeColour = null;
    2880. 

  2880.     $this->objects[$this->currentContents]['c'].=  "\nq";
    2881. 

  2881.   }
    2882. 

  2882.   
    2883. 

  2883.   /**
    2884. 

  2884.    * restore the last graphic state
    2885. 

  2885.    */
    2886. 

  2886.   function restore() {
    2887. 

  2887.     $this->objects[$this->currentContents]['c'].=  "\nQ";
    2888. 

  2888.   }
    2889. 

  2889.   
    2890. 

  2890.   /**
    2891. 

  2891.    * draw a clipping rectangle, all the elements added after this will be clipped
    2892. 

  2892.    */
    2893. 

  2893.   function clippingRectangle($x1, $y1, $width, $height) {
    2894. 

  2894.     $this->save();
    2895. 

  2895.     $this->objects[$this->currentContents]['c'].=  sprintf("\n%.3F %.3F %.3F %.3F re W n", $x1, $y1, $width, $height);
    2896. 

  2896.   }
    2897. 

  2897. 

  2898.   /**
    2899. 

  2899.    * ends the last clipping shape
    2900. 

  2900.    */
    2901. 

  2901.   function clippingEnd() {
    2902. 

  2902.     $this->restore();
    2903. 

  2903.   }
    2904. 

  2904. 

  2905.   /**
    2906. 

  2906.    * scale
    2907. 

  2907.    * @param float $s_x scaling factor for width as percent
    2908. 

  2908.    * @param float $s_y scaling factor for height as percent
    2909. 

  2909.    * @param float $x Origin abscisse
    2910. 

  2910.    * @param float $y Origin ordinate
    2911. 

  2911.    */
    2912. 

  2912.   function scale($s_x, $s_y, $x, $y) {
    2913. 

  2913.     $y = $this->currentPageSize["height"] - $y;
    2914. 

  2914. 

  2915.     $tm = array(
    2916. 

  2916.       $s_x,        0,
    2917. 

  2917.       0,           $s_y,
    2918. 

  2918.       $x*(1-$s_x), $y*(1-$s_y)
    2919. 

  2919.     );
    2920. 

  2920.     
    2921. 

  2921.     $this->transform($tm);
    2922. 

  2922.   }
    2923. 

  2923.   
    2924. 

  2924.   /**
    2925. 

  2925.    * translate
    2926. 

  2926.    * @param float $t_x movement to the right
    2927. 

  2927.    * @param float $t_y movement to the bottom
    2928. 

  2928.    */
    2929. 

  2929.   function translate($t_x, $t_y) {
    2930. 

  2930.     $tm = array(
    2931. 

  2931.       1,    0,
    2932. 

  2932.       0,    1,
    2933. 

  2933.       $t_x, -$t_y
    2934. 

  2934.     );
    2935. 

  2935.     
    2936. 

  2936.     $this->transform($tm);
    2937. 

  2937.   }
    2938. 

  2938. 

  2939.   /**
    2940. 

  2940.    * rotate
    2941. 

  2941.    * @param float $angle angle in degrees for counter-clockwise rotation
    2942. 

  2942.    * @param float $x Origin abscisse
    2943. 

  2943.    * @param float $y Origin ordinate
    2944. 

  2944.    */
    2945. 

  2945.   function rotate($angle, $x, $y) {
    2946. 

  2946.     $y = $this->currentPageSize["height"] - $y;
    2947. 

  2947.     
    2948. 

  2948.     $a = deg2rad($angle);
    2949. 

  2949.     $cos_a = cos($a);
    2950. 

  2950.     $sin_a = sin($a);
    2951. 

  2951.     
    2952. 

  2952.     $tm = array(
    2953. 

  2953.       $cos_a,                     -$sin_a,
    2954. 

  2954.       $sin_a,                     $cos_a,
    2955. 

  2955.       $x - $sin_a*$y - $cos_a*$x, $y - $cos_a*$y + $sin_a*$x, 
    2956. 

  2956.     );
    2957. 

  2957.     
    2958. 

  2958.     $this->transform($tm);
    2959. 

  2959.   }
    2960. 

  2960.   
    2961. 

  2961.   /**
    2962. 

  2962.    * skew
    2963. 

  2963.    * @param float $angle_x
    2964. 

  2964.    * @param float $angle_y
    2965. 

  2965.    * @param float $x Origin abscisse
    2966. 

  2966.    * @param float $y Origin ordinate
    2967. 

  2967.    */
    2968. 

  2968.   function skew($angle_x, $angle_y, $x, $y) {
    2969. 

  2969.     $y = $this->currentPageSize["height"] - $y;
    2970. 

  2970.     
    2971. 

  2971.     $tan_x = tan(deg2rad($angle_x));
    2972. 

  2972.     $tan_y = tan(deg2rad($angle_y));
    2973. 

  2973.     
    2974. 

  2974.     $tm = array(
    2975. 

  2975.       1,         -$tan_y,
    2976. 

  2976.       -$tan_x,   1,
    2977. 

  2977.       $tan_x*$y, $tan_y*$x, 
    2978. 

  2978.     );
    2979. 

  2979. 

  2980.     $this->transform($tm);
    2981. 

  2981.   }
    2982. 

  2982. 

  2983.   /**
    2984. 

  2984.    * apply graphic transformations
    2985. 

  2985.    * @param array $tm transformation matrix
    2986. 

  2986.    */
    2987. 

  2987.   function transform($tm) {
    2988. 

  2988.     $this->objects[$this->currentContents]['c'].=
    2989. 

  2989.       vsprintf("\n %.3F %.3F %.3F %.3F %.3F %.3F cm", $tm);
    2990. 

  2990.   }
    2991. 

  2991. 

  2992.   /**
    2993. 

  2993.    * add a new page to the document
    2994. 

  2994.    * this also makes the new page the current active object
    2995. 

  2995.    */
    2996. 

  2996.   function newPage($insert =  0, $id =  0, $pos =  'after') {
    2997. 

  2997.     // if there is a state saved, then go up the stack closing them
    2998. 

  2998.     // then on the new page, re-open them with the right setings
    2999. 

  2999. 

  3000.     if  ($this->nStateStack) {
    3001. 

  3001.       for  ($i =  $this->nStateStack;$i >=  1;$i--) {
    3002. 

  3002.         $this->restoreState($i);
    3003. 

  3003.       }
    3004. 

  3004.     }
    3005. 

  3005. 

  3006.     $this->numObj++;
    3007. 

  3007. 

  3008.     if  ($insert) {
    3009. 

  3009.       // the id from the ezPdf class is the id of the contents of the page, not the page object itself
    3010. 

  3010.       // query that object to find the parent
    3011. 

  3011.       $rid =  $this->objects[$id]['onPage'];
    3012. 

  3012.       $opt =  array('rid' => $rid, 'pos' => $pos);
    3013. 

  3013.       $this->o_page($this->numObj, 'new', $opt);
    3014. 

  3014.     } else {
    3015. 

  3015.       $this->o_page($this->numObj, 'new');
    3016. 

  3016.     }
    3017. 

  3017. 

  3018.     // if there is a stack saved, then put that onto the page
    3019. 

  3019.     if  ($this->nStateStack) {
    3020. 

  3020.       for  ($i =  1;$i <=  $this->nStateStack;$i++) {
    3021. 

  3021.         $this->saveState($i);
    3022. 

  3022.       }
    3023. 

  3023.     }
    3024. 

  3024. 

  3025.     // and if there has been a stroke or fill colour set, then transfer them
    3026. 

  3026.     if  (isset($this->currentColour)) {
    3027. 

  3027.       $this->setColor($this->currentColour, true);
    3028. 

  3028.     }
    3029. 

  3029. 

  3030.     if  (isset($this->currentStrokeColour)) {
    3031. 

  3031.       $this->setStrokeColor($this->currentStrokeColour, true);
    3032. 

  3032.     }
    3033. 

  3033. 

  3034.     // if there is a line style set, then put this in too
    3035. 

  3035.     if  (mb_strlen($this->currentLineStyle, '8bit')) {
    3036. 

  3036.       $this->objects[$this->currentContents]['c'].=  "\n$this->currentLineStyle";
    3037. 

  3037.     }
    3038. 

  3038. 

  3039.     // the call to the o_page object set currentContents to the present page, so this can be returned as the page id
    3040. 

  3040.     return  $this->currentContents;
    3041. 

  3041.   }
    3042. 

  3042. 

  3043.   /**
    3044. 

  3044.    * output the pdf code, streaming it to the browser
    3045. 

  3045.    * the relevant headers are set so that hopefully the browser will recognise it
    3046. 

  3046.    */
    3047. 

  3047.   function stream($options =  '') {
    3048. 

  3048.     // setting the options allows the adjustment of the headers
    3049. 

  3049.     // values at the moment are:
    3050. 

  3050.     // 'Content-Disposition' => 'filename'  - sets the filename, though not too sure how well this will
    3051. 

  3051.     //        work as in my trial the browser seems to use the filename of the php file with .pdf on the end
    3052. 

  3052.     // 'Accept-Ranges' => 1 or 0 - if this is not set to 1, then this header is not included, off by default
    3053. 

  3053.     //    this header seems to have caused some problems despite tha fact that it is supposed to solve
    3054. 

  3054.     //    them, so I am leaving it off by default.
    3055. 

  3055.     // 'compress' = > 1 or 0 - apply content stream compression, this is on (1) by default
    3056. 

  3056.     // 'Attachment' => 1 or 0 - if 1, force the browser to open a download dialog
    3057. 

  3057.     if  (!is_array($options)) {
    3058. 

  3058.       $options =  array();
    3059. 

  3059.     }
    3060. 

  3060. 

  3061.     if  ( headers_sent())
    3062. 

  3062.       die("Unable to stream pdf: headers already sent");
    3063. 

  3063. 

  3064.     $debug = empty($options['compression']);
    3065. 

  3065.     $tmp =  ltrim($this->output($debug));
    3066. 

  3066. 

  3067.     header("Cache-Control: private");
    3068. 

  3068.     header("Content-type: application/pdf");
    3069. 

  3069. 

  3070.     //FIXME: I don't know that this is sufficient for determining content length (i.e. what about transport compression?)
    3071. 

  3071.     header("Content-Length: " . mb_strlen($tmp, '8bit'));
    3072. 

  3072.     $fileName =  (isset($options['Content-Disposition']) ?  $options['Content-Disposition'] :  'file.pdf');
    3073. 

  3073. 

  3074.     if  ( !isset($options["Attachment"]))
    3075. 

  3075.       $options["Attachment"] =  true;
    3076. 

  3076. 

  3077.     $attachment =  $options["Attachment"] ?  "attachment" :  "inline";
    3078. 

  3078. 

  3079.     header("Content-Disposition: $attachment; filename=\"$fileName\"");
    3080. 

  3080. 

  3081.     if  (isset($options['Accept-Ranges']) &&  $options['Accept-Ranges'] ==  1) {
    3082. 

  3082.       //FIXME: Is this the correct value ... spec says 1#range-unit
    3083. 

  3083.       header("Accept-Ranges: " . mb_strlen($tmp, '8bit'));
    3084. 

  3084.     }
    3085. 

  3085. 

  3086.     echo  $tmp;
    3087. 

  3087.     flush();
    3088. 

  3088.   }
    3089. 

  3089. 

  3090.   /**
    3091. 

  3091.    * return the height in units of the current font in the given size
    3092. 

  3092.    */
    3093. 

  3093.   function getFontHeight($size) {
    3094. 

  3094.     if  (!$this->numFonts) {
    3095. 

  3095.       $this->selectFont($this->defaultFont);
    3096. 

  3096.     }
    3097. 

  3097.     
    3098. 

  3098.     $font = $this->fonts[$this->currentFont];
    3099. 

  3099.     
    3100. 

  3100.     // for the current font, and the given size, what is the height of the font in user units
    3101. 

  3101.     if ( isset($font['Ascender']) && isset($font['Descender']) ) {
    3102. 

  3102.       $h =  $font['Ascender']-$font['Descender'];
    3103. 

  3103.     }
    3104. 

  3104.     else {
    3105. 

  3105.       $h =  $font['FontBBox'][3]-$font['FontBBox'][1];
    3106. 

  3106.     }
    3107. 

  3107. 

  3108.     // have to adjust by a font offset for Windows fonts.  unfortunately it looks like
    3109. 

  3109.     // the bounding box calculations are wrong and I don't know why.
    3110. 

  3110.     if (isset($font['FontHeightOffset'])) {
    3111. 

  3111.       // For CourierNew from Windows this needs to be -646 to match the
    3112. 

  3112.       // Adobe native Courier font.
    3113. 

  3113.       //
    3114. 

  3114.       // For FreeMono from GNU this needs to be -337 to match the
    3115. 

  3115.       // Courier font.
    3116. 

  3116.       //
    3117. 

  3117.       // Both have been added manually to the .afm and .ufm files.
    3118. 

  3118.       $h += (int)$font['FontHeightOffset'];
    3119. 

  3119.     }
    3120. 

  3120. 

  3121.     return  $size*$h/1000;
    3122. 

  3122.   }
    3123. 

  3123.   
    3124. 

  3124.   function getFontXHeight($size) {
    3125. 

  3125.     if  (!$this->numFonts) {
    3126. 

  3126.       $this->selectFont($this->defaultFont);
    3127. 

  3127.     }
    3128. 

  3128.     
    3129. 

  3129.     $font = $this->fonts[$this->currentFont];
    3130. 

  3130.     
    3131. 

  3131.     // for the current font, and the given size, what is the height of the font in user units
    3132. 

  3132.     if ( isset($font['XHeight']) ) {
    3133. 

  3133.       $xh =  $font['Ascender']-$font['Descender'];
    3134. 

  3134.     }
    3135. 

  3135.     else {
    3136. 

  3136.       $xh =  $this->getFontHeight($size) / 2;
    3137. 

  3137.     }
    3138. 

  3138. 

  3139.     return  $size*$xh/1000;
    3140. 

  3140.   }
    3141. 

  3141. 

  3142.   /**
    3143. 

  3143.    * return the font descender, this will normally return a negative number
    3144. 

  3144.    * if you add this number to the baseline, you get the level of the bottom of the font
    3145. 

  3145.    * it is in the pdf user units
    3146. 

  3146.    */
    3147. 

  3147.   function getFontDescender($size) {
    3148. 

  3148.     // note that this will most likely return a negative value
    3149. 

  3149.     if  (!$this->numFonts) {
    3150. 

  3150.       $this->selectFont($this->defaultFont);
    3151. 

  3151.     }
    3152. 

  3152. 

  3153.     //$h = $this->fonts[$this->currentFont]['FontBBox'][1];
    3154. 

  3154.     $h = $this->fonts[$this->currentFont]['Descender'];
    3155. 

  3155. 

  3156.     return  $size*$h/1000;
    3157. 

  3157.   }
    3158. 

  3158. 

  3159.   /**
    3160. 

  3160.    * filter the text, this is applied to all text just before being inserted into the pdf document
    3161. 

  3161.    * it escapes the various things that need to be escaped, and so on
    3162. 

  3162.    *
    3163. 

  3163.    * @access private
    3164. 

  3164.    */
    3165. 

  3165.   function filterText($text, $bom = true, $convert_encoding = true) {
    3166. 

  3166.     if (!$this->numFonts) {
    3167. 

  3167.       $this->selectFont($this->defaultFont);
    3168. 

  3168.     }
    3169. 

  3169.     
    3170. 

  3170.     if ($convert_encoding) {
    3171. 

  3171.       $cf = $this->currentFont;
    3172. 

  3172.       if (isset($this->fonts[$cf]) && $this->fonts[$cf]['isUnicode']) {
    3173. 

  3173.         //$text = html_entity_decode($text, ENT_QUOTES, 'UTF-8');
    3174. 

  3174.         $text =  $this->utf8toUtf16BE($text, $bom);
    3175. 

  3175.       } else {
    3176. 

  3176.         //$text = html_entity_decode($text, ENT_QUOTES);
    3177. 

  3177.         $text = mb_convert_encoding($text, self::$targetEncoding, 'UTF-8');
    3178. 

  3178.       }
    3179. 

  3179.     }
    3180. 

  3180. 

  3181.     // the chr(13) substitution fixes a bug seen in TCPDF (bug #1421290)
    3182. 

  3182.     return strtr($text, array(')' => '\\)', '(' => '\\(', '\\' => '\\\\', chr(13) => '\r'));
    3183. 

  3183.   }
    3184. 

  3184. 

  3185.   /**
    3186. 

  3186.    * return array containing codepoints (UTF-8 character values) for the
    3187. 

  3187.    * string passed in.
    3188. 

  3188.    *
    3189. 

  3189.    * based on the excellent TCPDF code by Nicola Asuni and the
    3190. 

  3190.    * RFC for UTF-8 at http://www.faqs.org/rfcs/rfc3629.html
    3191. 

  3191.    *
    3192. 

  3192.    * @access private
    3193. 

  3193.    * @author Orion Richardson
    3194. 

  3194.    * @since January 5, 2008
    3195. 

  3195.    * @param string $text UTF-8 string to process
    3196. 

  3196.    * @return array UTF-8 codepoints array for the string
    3197. 

  3197.    */
    3198. 

  3198.   function utf8toCodePointsArray(&$text) {
    3199. 

  3199.     $length = mb_strlen($text, '8bit'); // http://www.php.net/manual/en/function.mb-strlen.php#77040
    3200. 

  3200.     $unicode = array(); // array containing unicode values
    3201. 

  3201.     $bytes = array(); // array containing single character byte sequences
    3202. 

  3202.     $numbytes = 1; // number of octetc needed to represent the UTF-8 character
    3203. 

  3203.     
    3204. 

  3204.     for ($i = 0; $i < $length; $i++) {
    3205. 

  3205.       $c = ord($text[$i]); // get one string character at time
    3206. 

  3206.       if (count($bytes) === 0) { // get starting octect
    3207. 

  3207.         if ($c <= 0x7F) {
    3208. 

  3208.           $unicode[] = $c; // use the character "as is" because is ASCII
    3209. 

  3209.           $numbytes = 1;
    3210. 

  3210.         } elseif (($c >> 0x05) === 0x06) { // 2 bytes character (0x06 = 110 BIN)
    3211. 

  3211.           $bytes[] = ($c - 0xC0) << 0x06;
    3212. 

  3212.           $numbytes = 2;
    3213. 

  3213.         } elseif (($c >> 0x04) === 0x0E) { // 3 bytes character (0x0E = 1110 BIN)
    3214. 

  3214.           $bytes[] = ($c - 0xE0) << 0x0C;
    3215. 

  3215.           $numbytes = 3;
    3216. 

  3216.         } elseif (($c >> 0x03) === 0x1E) { // 4 bytes character (0x1E = 11110 BIN)
    3217. 

  3217.           $bytes[] = ($c - 0xF0) << 0x12;
    3218. 

  3218.           $numbytes = 4;
    3219. 

  3219.         } else {
    3220. 

  3220.           // use replacement character for other invalid sequences
    3221. 

  3221.           $unicode[] = 0xFFFD;
    3222. 

  3222.           $bytes = array();
    3223. 

  3223.           $numbytes = 1;
    3224. 

  3224.         }
    3225. 

  3225.       } elseif (($c >> 0x06) === 0x02) { // bytes 2, 3 and 4 must start with 0x02 = 10 BIN
    3226. 

  3226.         $bytes[] = $c - 0x80;
    3227. 

  3227.         if (count($bytes) === $numbytes) {
    3228. 

  3228.           // compose UTF-8 bytes to a single unicode value
    3229. 

  3229.           $c = $bytes[0];
    3230. 

  3230.           for ($j = 1; $j < $numbytes; $j++) {
    3231. 

  3231.             $c += ($bytes[$j] << (($numbytes - $j - 1) * 0x06));
    3232. 

  3232.           }
    3233. 

  3233.           if ((($c >= 0xD800) AND ($c <= 0xDFFF)) OR ($c >= 0x10FFFF)) {
    3234. 

  3234.             // The definition of UTF-8 prohibits encoding character numbers between
    3235. 

  3235.             // U+D800 and U+DFFF, which are reserved for use with the UTF-16
    3236. 

  3236.             // encoding form (as surrogate pairs) and do not directly represent
    3237. 

  3237.             // characters.
    3238. 

  3238.             $unicode[] = 0xFFFD; // use replacement character
    3239. 

  3239.           } else {
    3240. 

  3240.             $unicode[] = $c; // add char to array
    3241. 

  3241.           }
    3242. 

  3242.           // reset data for next char
    3243. 

  3243.           $bytes = array();
    3244. 

  3244.           $numbytes = 1;
    3245. 

  3245.         }
    3246. 

  3246.       } else {
    3247. 

  3247.         // use replacement character for other invalid sequences
    3248. 

  3248.         $unicode[] = 0xFFFD;
    3249. 

  3249.         $bytes = array();
    3250. 

  3250.         $numbytes = 1;
    3251. 

  3251.       }
    3252. 

  3252.     }
    3253. 

  3253.     return $unicode;
    3254. 

  3254.   }
    3255. 

  3255. 

  3256.   /**
    3257. 

  3257.    * convert UTF-8 to UTF-16 with an additional byte order marker
    3258. 

  3258.    * at the front if required.
    3259. 

  3259.    *
    3260. 

  3260.    * based on the excellent TCPDF code by Nicola Asuni and the
    3261. 

  3261.    * RFC for UTF-8 at http://www.faqs.org/rfcs/rfc3629.html
    3262. 

  3262.    *
    3263. 

  3263.    * @access private
    3264. 

  3264.    * @author Orion Richardson
    3265. 

  3265.    * @since January 5, 2008
    3266. 

  3266.    * @param string $text UTF-8 string to process
    3267. 

  3267.    * @param boolean $bom whether to add the byte order marker
    3268. 

  3268.    * @return string UTF-16 result string
    3269. 

  3269.    */
    3270. 

  3270.   function utf8toUtf16BE(&$text, $bom = true) {
    3271. 

  3271.     $cf =  $this->currentFont;
    3272. 

  3272.     if (!$this->fonts[$cf]['isUnicode']) return $text;
    3273. 

  3273.     $out = $bom ? "\xFE\xFF" : '';
    3274. 

  3274.     
    3275. 

  3275.     $unicode = $this->utf8toCodePointsArray($text);
    3276. 

  3276.     foreach ($unicode as $c) {
    3277. 

  3277.       if ($c === 0xFFFD) {
    3278. 

  3278.         $out .= "\xFF\xFD"; // replacement character
    3279. 

  3279.       } elseif ($c < 0x10000) {
    3280. 

  3280.         $out .= chr($c >> 0x08) . chr($c & 0xFF);
    3281. 

  3281.        } else {
    3282. 

  3282.         $c -= 0x10000;
    3283. 

  3283.         $w1 = 0xD800 | ($c >> 0x10);
    3284. 

  3284.         $w2 = 0xDC00 | ($c & 0x3FF);
    3285. 

  3285.         $out .= chr($w1 >> 0x08) . chr($w1 & 0xFF) . chr($w2 >> 0x08) . chr($w2 & 0xFF);
    3286. 

  3286.       }
    3287. 

  3287.     }
    3288. 

  3288.     return $out;
    3289. 

  3289.   }
    3290. 

  3290. 

  3291.   /**
    3292. 

  3292.    * given a start position and information about how text is to be laid out, calculate where
    3293. 

  3293.    * on the page the text will end
    3294. 

  3294.    *
    3295. 

  3295.    * @access private
    3296. 

  3296.    */
    3297. 

  3297.   function PRVTgetTextPosition($x, $y, $angle, $size, $wa, $text) {
    3298. 

  3298.     // given this information return an array containing x and y for the end position as elements 0 and 1
    3299. 

  3299.     $w =  $this->getTextWidth($size, $text);
    3300. 

  3300. 

  3301.     // need to adjust for the number of spaces in this text
    3302. 

  3302.     $words =  explode(' ', $text);
    3303. 

  3303.     $nspaces =  count($words) -1;
    3304. 

  3304.     $w+=  $wa*$nspaces;
    3305. 

  3305.     $a =  deg2rad((float)$angle);
    3306. 

  3306. 

  3307.     return  array(cos($a) *$w+$x, -sin($a) *$w+$y);
    3308. 

  3308.   }
    3309. 

  3309. 

  3310.   /**
    3311. 

  3311.    * wrapper function for PRVTcheckTextDirective1
    3312. 

  3312.    *
    3313. 

  3313.    * @access private
    3314. 

  3314.    */
    3315. 

  3315.   function PRVTcheckTextDirective(&$text, $i, &$f) {
    3316. 

  3316.     return  0;
    3317. 

  3317.     $x =  0;
    3318. 

  3318.     $y =  0;
    3319. 

  3319.     return  $this->PRVTcheckTextDirective1($text, $i, $f, 0, $x, $y);
    3320. 

  3320.   }
    3321. 

  3321. 

  3322.   /**
    3323. 

  3323.    * checks if the text stream contains a control directive
    3324. 

  3324.    * if so then makes some changes and returns the number of characters involved in the directive
    3325. 

  3325.    * this has been re-worked to include everything neccesary to find the current writing point, so that
    3326. 

  3326.    * the location can be sent to the callback function if required
    3327. 

  3327.    * if the directive does not require a font change, then $f should be set to 0
    3328. 

  3328.    *
    3329. 

  3329.    * @access private
    3330. 

  3330.    */
    3331. 

  3331.   function PRVTcheckTextDirective1(&$text, $i, &$f, $final, &$x, &$y, $size =  0, $angle =  0, $wordSpaceAdjust =  0) {
    3332. 

  3332.     return  0;
    3333. 

  3333.     $directive =  0;
    3334. 

  3334.     $j =  $i;
    3335. 

  3335.     if  ($text[$j] === '<') {
    3336. 

  3336.       $j++;
    3337. 

  3337.       switch ($text[$j]) {
    3338. 

  3338.       case  '/':
    3339. 

  3339.         $j++;
    3340. 

  3340.         if  (mb_strlen($text) <=  $j) {
    3341. 

  3341.           return  $directive;
    3342. 

  3342.         }
    3343. 

  3343. 

  3344.         switch ($text[$j]) {
    3345. 

  3345.         case  'b':
    3346. 

  3346.         case  'i':
    3347. 

  3347.           $j++;
    3348. 

  3348.           if  ($text[$j] === '>') {
    3349. 

  3349.             $p =  mb_strrpos($this->currentTextState, $text[$j-1]);
    3350. 

  3350. 

  3351.             if  ($p !==  false) {
    3352. 

  3352.               // then there is one to remove
    3353. 

  3353.               $this->currentTextState =  mb_substr($this->currentTextState, 0, $p) .substr($this->currentTextState, $p+1);
    3354. 

  3354.             }
    3355. 

  3355. 

  3356.             $directive =  $j-$i+1;
    3357. 

  3357.           }
    3358. 

  3358.           break;
    3359. 

  3359. 

  3360.         case  'c':
    3361. 

  3361.           // this this might be a callback function
    3362. 

  3362.           $j++;
    3363. 

  3363.           $k =  mb_strpos($text, '>', $j);
    3364. 

  3364. 

  3365.           if  ($k !==  false &&  $text[$j] === ':') {
    3366. 

  3366.             // then this will be treated as a callback directive
    3367. 

  3367.             $directive =  $k-$i+1;
    3368. 

  3368.             $f =  0;
    3369. 

  3369.             // split the remainder on colons to get the function name and the paramater
    3370. 

  3370.             $tmp =  mb_substr($text, $j+1, $k-$j-1);
    3371. 

  3371.             $b1 =  mb_strpos($tmp, ':');
    3372. 

  3372. 

  3373.             if  ($b1 !==  false) {
    3374. 

  3374.               $func =  mb_substr($tmp, 0, $b1);
    3375. 

  3375.               $parm =  mb_substr($tmp, $b1+1);
    3376. 

  3376.             } else {
    3377. 

  3377.               $func =  $tmp;
    3378. 

  3378.               $parm =  '';
    3379. 

  3379.             }
    3380. 

  3380. 

  3381.             if  (!isset($func) ||  !mb_strlen(trim($func), '8bit')) {
    3382. 

  3382.               $directive =  0;
    3383. 

  3383.             } else {
    3384. 

  3384.               // only call the function if this is the final call
    3385. 

  3385.               if  ($final) {
    3386. 

  3386.                 // need to assess the text position, calculate the text width to this point
    3387. 

  3387.                 // can use getTextWidth to find the text width I think
    3388. 

  3388.                 $tmp =  $this->PRVTgetTextPosition($x, $y, $angle, $size, $wordSpaceAdjust, mb_substr($text, 0, $i));
    3389. 

  3389. 

  3390.                 $info =  array('x' => $tmp[0], 'y' => $tmp[1], 'angle' => $angle, 'status' => 'end', 'p' => $parm, 'nCallback' => $this->nCallback);
    3391. 

  3391.                 $x =  $tmp[0];
    3392. 

  3392.                 $y =  $tmp[1];
    3393. 

  3393.                 $ret =  $this->$func($info);
    3394. 

  3394. 

  3395.                 if  (is_array($ret)) {
    3396. 

  3396.                   // then the return from the callback function could set the position, to start with, later will do font colour, and font
    3397. 

  3397.                   foreach($ret as  $rk => $rv) {
    3398. 

  3398.                     switch ($rk) {
    3399. 

  3399.                     case  'x':
    3400. 

  3400.                     case  'y':
    3401. 

  3401.                       $$rk =  $rv;
    3402. 

  3402.                       break;
    3403. 

  3403.                     }
    3404. 

  3404.                   }
    3405. 

  3405.                 }
    3406. 

  3406. 

  3407.                 // also remove from to the stack
    3408. 

  3408.                 // for simplicity, just take from the end, fix this another day
    3409. 

  3409.                 $this->nCallback--;
    3410. 

  3410.                 if  ($this->nCallback<0) {
    3411. 

  3411.                   $this->nCallBack =  0;
    3412. 

  3412.                 }
    3413. 

  3413.               }
    3414. 

  3414.             }
    3415. 

  3415.           }
    3416. 

  3416.           break;
    3417. 

  3417.         }
    3418. 

  3418.         break;
    3419. 

  3419. 

  3420.       case  'b':
    3421. 

  3421.       case  'i':
    3422. 

  3422.         $j++;
    3423. 

  3423.         if  ($text[$j] === '>') {
    3424. 

  3424.           $this->currentTextState.=  $text[$j-1];
    3425. 

  3425.           $directive =  $j-$i+1;
    3426. 

  3426.         }
    3427. 

  3427.         break;
    3428. 

  3428. 

  3429.       case  'C':
    3430. 

  3430.         $noClose =  1;
    3431. 

  3431.       case  'c':
    3432. 

  3432.         // this this might be a callback function
    3433. 

  3433.         $j++;
    3434. 

  3434.         $k =  mb_strpos($text, '>', $j);
    3435. 

  3435. 

  3436.         if  ($k !==  false &&  $text[$j] ===  ':') {
    3437. 

  3437.           // then this will be treated as a callback directive
    3438. 

  3438.           $directive =  $k-$i+1;
    3439. 

  3439. 

  3440.           $f =  0;
    3441. 

  3441. 

  3442.           // split the remainder on colons to get the function name and the paramater
    3443. 

  3443.           //          $bits = explode(':',substr($text,$j+1,$k-$j-1));
    3444. 

  3444.           $tmp =  mb_substr($text, $j+1, $k-$j-1);
    3445. 

  3445.           $b1 =  mb_strpos($tmp, ':');
    3446. 

  3446. 

  3447.           if  ($b1 !==  false) {
    3448. 

  3448.             $func =  mb_substr($tmp, 0, $b1);
    3449. 

  3449.             $parm =  mb_substr($tmp, $b1+1);
    3450. 

  3450.           } else {
    3451. 

  3451.             $func =  $tmp;
    3452. 

  3452.             $parm =  '';
    3453. 

  3453.           }
    3454. 

  3454. 

  3455.           if  (!isset($func) ||  !mb_strlen(trim($func), '8bit')) {
    3456. 

  3456.             $directive =  0;
    3457. 

  3457.           } else {
    3458. 

  3458.             // only call the function if this is the final call, ie, the one actually doing printing, not measurement
    3459. 

  3459.             if  ($final) {
    3460. 

  3460.               // need to assess the text position, calculate the text width to this point
    3461. 

  3461.               // can use getTextWidth to find the text width I think
    3462. 

  3462.               // also add the text height and descender
    3463. 

  3463.               $tmp =  $this->PRVTgetTextPosition($x, $y, $angle, $size, $wordSpaceAdjust, mb_substr($text, 0, $i));
    3464. 

  3464. 

  3465.               $info =  array(
    3466. 

  3466.                 'x' => $tmp[0],
    3467. 

  3467.                 'y' => $tmp[1],
    3468. 

  3468.                 'angle' => $angle,
    3469. 

  3469.                 'status' => 'start',
    3470. 

  3470.                 'p' => $parm,
    3471. 

  3471.                 'f' => $func,
    3472. 

  3472.                 'height' => $this->getFontHeight($size),
    3473. 

  3473.                 'descender' => $this->getFontDescender($size)
    3474. 

  3474.               );
    3475. 

  3475.               $x =  $tmp[0];
    3476. 

  3476.               $y =  $tmp[1];
    3477. 

  3477. 

  3478.               if  (!isset($noClose) ||  !$noClose) {
    3479. 

  3479.                 // only add to the stack if this is a small 'c', therefore is a start-stop pair
    3480. 

  3480.                 $this->nCallback++;
    3481. 

  3481.                 $info['nCallback'] =  $this->nCallback;
    3482. 

  3482.                 $this->callback[$this->nCallback] =  $info;
    3483. 

  3483.               }
    3484. 

  3484. 

  3485.               $ret =  $this->$func($info);
    3486. 

  3486.               if  (is_array($ret)) {
    3487. 

  3487.                 // then the return from the callback function could set the position, to start with, later will do font colour, and font
    3488. 

  3488.                 foreach($ret as  $rk => $rv) {
    3489. 

  3489.                   switch ($rk) {
    3490. 

  3490.                   case  'x':
    3491. 

  3491.                   case  'y':
    3492. 

  3492.                     $$rk =  $rv;
    3493. 

  3493.                     break;
    3494. 

  3494.                   }
    3495. 

  3495.                 }
    3496. 

  3496.               }
    3497. 

  3497.             }
    3498. 

  3498.           }
    3499. 

  3499.         }
    3500. 

  3500.         break;
    3501. 

  3501.       }
    3502. 

  3502.     }
    3503. 

  3503. 

  3504.     return  $directive;
    3505. 

  3505.   }
    3506. 

  3506.   
    3507. 

  3507.   /**
    3508. 

  3508.    * Callback method used by smallCaps
    3509. 

  3509.    * 
    3510. 

  3510.    * @param array $matches
    3511. 

  3511.    * @return string
    3512. 

  3512.    */
    3513. 

  3513.   function toUpper($matches) {
    3514. 

  3514.     return mb_strtoupper($matches[0]);
    3515. 

  3515.   }
    3516. 

  3516.   
    3517. 

  3517.   function concatMatches($matches) {
    3518. 

  3518.     $str = "";
    3519. 

  3519.     foreach($matches as $match){
    3520. 

  3520.       $str .= $match[0];
    3521. 

  3521.     }
    3522. 

  3522.     return $str;
    3523. 

  3523.   }
    3524. 

  3524. 

  3525.   /**
    3526. 

  3526.    * add text to the document, at a specified location, size and angle on the page
    3527. 

  3527.    */
    3528. 

  3528.   function registerText($font, $text) {
    3529. 

  3529.     if ( !$this->isUnicode || in_array(mb_strtolower(basename($font)), self::$coreFonts) ) {
    3530. 

  3530.       return;
    3531. 

  3531.     }
    3532. 

  3532.     
    3533. 

  3533.     if ( !isset($this->stringSubsets[$font]) ) {
    3534. 

  3534.       $this->stringSubsets[$font] = array();
    3535. 

  3535.     }
    3536. 

  3536.     
    3537. 

  3537.     $this->stringSubsets[$font] = array_unique(array_merge($this->stringSubsets[$font], $this->utf8toCodePointsArray($text)));
    3538. 

  3538.   }
    3539. 

  3539. 

  3540.   /**
    3541. 

  3541.    * add text to the document, at a specified location, size and angle on the page
    3542. 

  3542.    */
    3543. 

  3543.   function addText($x, $y, $size, $text, $angle =  0, $wordSpaceAdjust =  0, $charSpaceAdjust =  0, $smallCaps = false) {
    3544. 

  3544.     if  (!$this->numFonts) {
    3545. 

  3545.       $this->selectFont($this->defaultFont);
    3546. 

  3546.     }
    3547. 

  3547. 

  3548.     $text = str_replace(array("\r", "\n"), "", $text);
    3549. 

  3549.     
    3550. 

  3550.     if ( $smallCaps ) {
    3551. 

  3551.       preg_match_all("/(\P{Ll}+)/u", $text, $matches, PREG_SET_ORDER);
    3552. 

  3552.       $lower = $this->concatMatches($matches);
    3553. 

  3553.       d($lower);
    3554. 

  3554.       
    3555. 

  3555.       preg_match_all("/(\p{Ll}+)/u", $text, $matches, PREG_SET_ORDER);
    3556. 

  3556.       $other = $this->concatMatches($matches);
    3557. 

  3557.       d($other);
    3558. 

  3558.       
    3559. 

  3559.       //$text = preg_replace_callback("/\p{Ll}/u", array($this, "toUpper"), $text);
    3560. 

  3560.     }
    3561. 

  3561. 

  3562.     // if there are any open callbacks, then they should be called, to show the start of the line
    3563. 

  3563.     if  ($this->nCallback>0) {
    3564. 

  3564.       for  ($i =  $this->nCallback;$i>0;$i--) {
    3565. 

  3565.         // call each function
    3566. 

  3566.         $info =  array('x' => $x,
    3567. 

  3567.                        'y' => $y,
    3568. 

  3568.                        'angle' => $angle,
    3569. 

  3569.                        'status' => 'sol',
    3570. 

  3570.                        'p'         => $this->callback[$i]['p'],
    3571. 

  3571.                        'nCallback' => $this->callback[$i]['nCallback'],
    3572. 

  3572.                        'height'    => $this->callback[$i]['height'],
    3573. 

  3573.                        'descender' => $this->callback[$i]['descender']);
    3574. 

  3574. 

  3575.         $func =  $this->callback[$i]['f'];
    3576. 

  3576.         $this->$func($info);
    3577. 

  3577.       }
    3578. 

  3578.     }
    3579. 

  3579. 

  3580.     if  ($angle ==  0) {
    3581. 

  3581.       $this->objects[$this->currentContents]['c'].=  sprintf("\nBT %.3F %.3F Td", $x, $y);
    3582. 

  3582.     } else {
    3583. 

  3583.       $a =  deg2rad((float)$angle);
    3584. 

  3584.       $this->objects[$this->currentContents]['c'].=
    3585. 

  3585.         sprintf("\nBT %.3F %.3F %.3F %.3F %.3F %.3F Tm", cos($a), -sin($a), sin($a), cos($a), $x, $y);
    3586. 

  3586.     }
    3587. 

  3587. 

  3588.     if  ($wordSpaceAdjust !=  0 ||  $wordSpaceAdjust !=  $this->wordSpaceAdjust) {
    3589. 

  3589.       $this->wordSpaceAdjust =  $wordSpaceAdjust;
    3590. 

  3590.       $this->objects[$this->currentContents]['c'].=  sprintf(" %.3F Tw", $wordSpaceAdjust);
    3591. 

  3591.     }
    3592. 

  3592. 

  3593.     if  ($charSpaceAdjust !=  0 ||  $charSpaceAdjust !=  $this->charSpaceAdjust) {
    3594. 

  3594.       $this->charSpaceAdjust =  $charSpaceAdjust;
    3595. 

  3595.       $this->objects[$this->currentContents]['c'].=  sprintf(" %.3F Tc", $charSpaceAdjust);
    3596. 

  3596.     }
    3597. 

  3597. 

  3598.     $len =  mb_strlen($text);
    3599. 

  3599.     $start =  0;
    3600. 

  3600. 

  3601.     /*
    3602. 

  3602.      for ($i = 0;$i<$len;$i++){
    3603. 

  3603.      $f = 1;
    3604. 

  3604.      $directive = 0; //$this->PRVTcheckTextDirective($text,$i,$f);
    3605. 

  3605.      if ($directive){
    3606. 

  3606.      // then we should write what we need to
    3607. 

  3607.      if ($i>$start){
    3608. 

  3608.      $part = mb_substr($text,$start,$i-$start);
    3609. 

  3609.      $this->objects[$this->currentContents]['c'] .= ' /F'.$this->currentFontNum.' '.sprintf('%.1F',$size).' Tf ';
    3610. 

  3610.      $this->objects[$this->currentContents]['c'] .= ' ('.$this->filterText($part, false).') Tj';
    3611. 

  3611.      }
    3612. 

  3612.      if ($f){
    3613. 

  3613.      // then there was nothing drastic done here, restore the contents
    3614. 

  3614.      $this->setCurrentFont();
    3615. 

  3615.      } else {
    3616. 

  3616.      $this->objects[$this->currentContents]['c'] .= ' ET';
    3617. 

  3617.      $f = 1;
    3618. 

  3618.      $xp = $x;
    3619. 

  3619.      $yp = $y;
    3620. 

  3620.      $directive = 0; //$this->PRVTcheckTextDirective1($text,$i,$f,1,$xp,$yp,$size,$angle,$wordSpaceAdjust);
    3621. 

    3622. 

  3622.      // restart the text object
    3623. 

  3623.      if ($angle == 0){
    3624. 

  3624.      $this->objects[$this->currentContents]['c'] .= "\n".'BT '.sprintf('%.3F',$xp).' '.sprintf('%.3F',$yp).' Td';
    3625. 

  3625.      } else {
    3626. 

  3626.      $a = deg2rad((float)$angle);
    3627. 

  3627.      $tmp = "\n".'BT ';
    3628. 

  3628.      $tmp .= sprintf('%.3F',cos($a)).' '.sprintf('%.3F',(-1.0*sin($a))).' '.sprintf('%.3F',sin($a)).' '.sprintf('%.3F',cos($a)).' ';
    3629. 

  3629.      $tmp .= sprintf('%.3F',$xp).' '.sprintf('%.3F',$yp).' Tm';
    3630. 

  3630.      $this->objects[$this->currentContents]['c'] .= $tmp;
    3631. 

  3631.      }
    3632. 

  3632.      if ($wordSpaceAdjust != 0 || $wordSpaceAdjust != $this->wordSpaceAdjust){
    3633. 

  3633.      $this->wordSpaceAdjust = $wordSpaceAdjust;
    3634. 

  3634.      $this->objects[$this->currentContents]['c'] .= ' '.sprintf('%.3F',$wordSpaceAdjust).' Tw';
    3635. 

  3635.      }
    3636. 

  3636.      }
    3637. 

  3637.      // and move the writing point to the next piece of text
    3638. 

  3638.      $i = $i+$directive-1;
    3639. 

  3639.      $start = $i+1;
    3640. 

  3640.      }
    3641. 

    3642. 

  3642.      }
    3643. 

  3643.     */
    3644. 

  3644.     if  ($start < $len) {
    3645. 

  3645.       $part =  $text; // OAR - Don't need this anymore, given that $start always equals zero.  substr($text, $start);
    3646. 

  3646.       $place_text = $this->filterText($part, false);
    3647. 

  3647.       // modify unicode text so that extra word spacing is manually implemented (bug #)
    3648. 

  3648.       $cf = $this->currentFont;
    3649. 

  3649.       if ($this->fonts[$cf]['isUnicode'] && $wordSpaceAdjust != 0) {
    3650. 

  3650.         $space_scale = 1000 / $size;
    3651. 

  3651.         //$place_text = str_replace(' ', ') ( ) '.($this->getTextWidth($size, chr(32), $wordSpaceAdjust)*-75).' (', $place_text);
    3652. 

  3652.         $place_text = str_replace(' ', ' ) '.(-round($space_scale*$wordSpaceAdjust)).' (', $place_text);
    3653. 

  3653.       }
    3654. 

  3654.       $this->objects[$this->currentContents]['c'].=  " /F$this->currentFontNum ".sprintf('%.1F Tf ', $size);
    3655. 

  3655.       $this->objects[$this->currentContents]['c'].=  " [($place_text)] TJ";
    3656. 

  3656.     }
    3657. 

  3657. 

  3658.     $this->objects[$this->currentContents]['c'].=  ' ET';
    3659. 

  3659. 

  3660.     // if there are any open callbacks, then they should be called, to show the end of the line
    3661. 

  3661.     if  ($this->nCallback>0) {
    3662. 

  3662.       for  ($i =  $this->nCallback;$i>0;$i--) {
    3663. 

  3663.         // call each function
    3664. 

  3664.         $tmp =  $this->PRVTgetTextPosition($x, $y, $angle, $size, $wordSpaceAdjust, $text);
    3665. 

  3665.         $info =  array(
    3666. 

  3666.           'x' => $tmp[0],
    3667. 

  3667.           'y' => $tmp[1],
    3668. 

  3668.           'angle' => $angle,
    3669. 

  3669.           'status' => 'eol',
    3670. 

  3670.           'p'         => $this->callback[$i]['p'],
    3671. 

  3671.           'nCallback' => $this->callback[$i]['nCallback'],
    3672. 

  3672.           'height'    => $this->callback[$i]['height'],
    3673. 

  3673.           'descender' => $this->callback[$i]['descender']
    3674. 

  3674.         );
    3675. 

  3675.         $func =  $this->callback[$i]['f'];
    3676. 

  3676.         $this->$func($info);
    3677. 

  3677.       }
    3678. 

  3678.     }
    3679. 

  3679.   }
    3680. 

  3680. 

  3681.   /**
    3682. 

  3682.    * calculate how wide a given text string will be on a page, at a given size.
    3683. 

  3683.    * this can be called externally, but is alse used by the other class functions
    3684. 

  3684.    */
    3685. 

  3685.   function getTextWidth($size, $text, $word_spacing =  0, $char_spacing =  0) {
    3686. 

  3686.     static $ord_cache = array();
    3687. 

  3687.     
    3688. 

  3688.     // this function should not change any of the settings, though it will need to
    3689. 

  3689.     // track any directives which change during calculation, so copy them at the start
    3690. 

  3690.     // and put them back at the end.
    3691. 

  3691.     $store_currentTextState =  $this->currentTextState;
    3692. 

  3692. 

  3693.     if (!$this->numFonts) {
    3694. 

  3694.       $this->selectFont($this->defaultFont);
    3695. 

  3695.     }
    3696. 

  3696. 

  3697.     $text = str_replace(array("\r", "\n"), "", $text);
    3698. 

  3698. 

  3699.     // converts a number or a float to a string so it can get the width
    3700. 

  3700.     $text = "$text";
    3701. 

  3701. 

  3702.     // hmm, this is where it all starts to get tricky - use the font information to
    3703. 

  3703.     // calculate the width of each character, add them up and convert to user units
    3704. 

  3704.     $w = 0;
    3705. 

  3705.     $cf = $this->currentFont;
    3706. 

  3706.     $current_font = $this->fonts[$cf];
    3707. 

  3707.     $space_scale = 1000 / $size;
    3708. 

  3708.     $n_spaces = 0;
    3709. 

  3709.     
    3710. 

  3710.     if ( $current_font['isUnicode']) {
    3711. 

  3711.       // for Unicode, use the code points array to calculate width rather
    3712. 

  3712.       // than just the string itself
    3713. 

  3713.       $unicode = $this->utf8toCodePointsArray($text);
    3714. 

  3714. 

  3715.       foreach ($unicode as $char) {
    3716. 

  3716.         // check if we have to replace character
    3717. 

  3717.         if ( isset($current_font['differences'][$char])) {
    3718. 

  3718.           $char = $current_font['differences'][$char];
    3719. 

  3719.         }
    3720. 

  3720.         
    3721. 

  3721.         if ( isset($current_font['C'][$char]) ) {
    3722. 

  3722.           $char_width = $current_font['C'][$char];
    3723. 

  3723.           
    3724. 

  3724.           // add the character width
    3725. 

  3725.           $w += $char_width;
    3726. 

  3726.           
    3727. 

  3727.           // add additional padding for space
    3728. 

  3728.           if ( isset($current_font['codeToName'][$char]) && $current_font['codeToName'][$char] === 'space' ) {  // Space
    3729. 

  3729.             $w += $word_spacing * $space_scale;
    3730. 

  3730.             $n_spaces++;
    3731. 

  3731.           }
    3732. 

  3732.         }
    3733. 

  3733.       }
    3734. 

  3734.       
    3735. 

  3735.       // add additionnal char spacing
    3736. 

  3736.       if ( $char_spacing != 0 ) {
    3737. 

  3737.         $w += $char_spacing * $space_scale * (count($unicode) + $n_spaces);
    3738. 

  3738.       }
    3739. 

  3739. 

  3740.     } else {
    3741. 

  3741.       // If CPDF is in Unicode mode but the current font does not support Unicode we need to convert the character set to Windows-1252
    3742. 

  3742.       if ( $this->isUnicode ) { 
    3743. 

  3743.         $text = mb_convert_encoding($text, 'Windows-1252', 'UTF-8');
    3744. 

  3744.       }
    3745. 

  3745.       
    3746. 

  3746.       $len = mb_strlen($text, 'Windows-1252');
    3747. 

  3747. 

  3748.       for ($i = 0; $i < $len; $i++) {
    3749. 

  3749.         $c = $text[$i];
    3750. 

  3750.         $char = isset($ord_cache[$c]) ? $ord_cache[$c] : ($ord_cache[$c] = ord($c));
    3751. 

  3751.         
    3752. 

  3752.         // check if we have to replace character
    3753. 

  3753.         if ( isset($current_font['differences'][$char])) {
    3754. 

  3754.           $char = $current_font['differences'][$char];
    3755. 

  3755.         }
    3756. 

  3756.         
    3757. 

  3757.         if ( isset($current_font['C'][$char]) ) {
    3758. 

  3758.           $char_width = $current_font['C'][$char];
    3759. 

  3759.           
    3760. 

  3760.           // add the character width
    3761. 

  3761.           $w += $char_width;
    3762. 

  3762.           
    3763. 

  3763.           // add additional padding for space
    3764. 

  3764.           if ( isset($current_font['codeToName'][$char]) && $current_font['codeToName'][$char] === 'space' ) {  // Space
    3765. 

  3765.             $w += $word_spacing * $space_scale;
    3766. 

  3766.             $n_spaces++;
    3767. 

  3767.           }
    3768. 

  3768.         }
    3769. 

  3769.       }
    3770. 

  3770.       
    3771. 

  3771.       // add additionnal char spacing
    3772. 

  3772.       if ( $char_spacing != 0 )  {
    3773. 

  3773.         $w += $char_spacing * $space_scale * ($len + $n_spaces);
    3774. 

  3774.       }
    3775. 

  3775.     }
    3776. 

  3776. 

  3777.     $this->currentTextState = $store_currentTextState;
    3778. 

  3778.     $this->setCurrentFont();
    3779. 

  3779. 

  3780.     return  $w*$size/1000;
    3781. 

  3781.   }
    3782. 

  3782. 

  3783.   /**
    3784. 

  3784.    * do a part of the calculation for sorting out the justification of the text
    3785. 

  3785.    *
    3786. 

  3786.    * @access private
    3787. 

  3787.    */
    3788. 

  3788.   function PRVTadjustWrapText($text, $actual, $width, &$x, &$adjust, $justification) {
    3789. 

  3789.     switch  ($justification) {
    3790. 

  3790.     case  'left':
    3791. 

  3791.       return;
    3792. 

  3792. 

  3793.     case  'right':
    3794. 

  3794.       $x+=  $width-$actual;
    3795. 

  3795.       break;
    3796. 

  3796. 

  3797.     case  'center':
    3798. 

  3798.     case  'centre':
    3799. 

  3799.       $x+=  ($width-$actual) /2;
    3800. 

  3800.       break;
    3801. 

  3801. 

  3802.     case  'full':
    3803. 

  3803.       // count the number of words
    3804. 

  3804.       $words =  explode(' ', $text);
    3805. 

  3805.       $nspaces =  count($words) -1;
    3806. 

  3806. 

  3807.       if  ($nspaces>0) {
    3808. 

  3808.         $adjust =  ($width-$actual) /$nspaces;
    3809. 

  3809.       } else {
    3810. 

  3810.         $adjust =  0;
    3811. 

  3811.       }
    3812. 

  3812.       break;
    3813. 

  3813.     }
    3814. 

  3814.   }
    3815. 

  3815. 

  3816.   /**
    3817. 

  3817.    * add text to the page, but ensure that it fits within a certain width
    3818. 

  3818.    * if it does not fit then put in as much as possible, splitting at word boundaries
    3819. 

  3819.    * and return the remainder.
    3820. 

  3820.    * justification and angle can also be specified for the text
    3821. 

  3821.    */
    3822. 

  3822.   function addTextWrap($x, $y, $width, $size, $text, $justification =  'left', $angle =  0, $test =  0) {
    3823. 

  3823.     // TODO - need to support Unicode
    3824. 

  3824.     $cf =  $this->currentFont;
    3825. 

  3825.     if ($this->fonts[$cf]['isUnicode']) {
    3826. 

  3826.         die("addTextWrap does not support Unicode yet!");
    3827. 

  3827.     }
    3828. 

  3828. 

  3829.     // this will display the text, and if it goes beyond the width $width, will backtrack to the
    3830. 

  3830.     // previous space or hyphen, and return the remainder of the text.
    3831. 

  3831. 

  3832.     // $justification can be set to 'left','right','center','centre','full'
    3833. 

  3833. 

  3834.     // need to store the initial text state, as this will change during the width calculation
    3835. 

  3835.     // but will need to be re-set before printing, so that the chars work out right
    3836. 

  3836.     $store_currentTextState =  $this->currentTextState;
    3837. 

  3837. 

  3838.     if  (!$this->numFonts) {
    3839. 

  3839.       $this->selectFont($this->defaultFont);
    3840. 

  3840.     }
    3841. 

  3841. 

  3842.     if  ($width <=  0) {
    3843. 

  3843.       // error, pretend it printed ok, otherwise risking a loop
    3844. 

  3844.       return  '';
    3845. 

  3845.     }
    3846. 

  3846. 

  3847.     $w =  0;
    3848. 

  3848.     $break =  0;
    3849. 

  3849.     $breakWidth =  0;
    3850. 

  3850.     $len =  mb_strlen($text);
    3851. 

  3851.     $cf =  $this->currentFont;
    3852. 

  3852.     $tw =  $width/$size*1000;
    3853. 

  3853. 

  3854.     for  ($i =  0;$i<$len;$i++) {
    3855. 

  3855.       $f =  1;
    3856. 

  3856.       $directive =  0;
    3857. 

  3857.       //$this->PRVTcheckTextDirective($text,$i,$f);
    3858. 

  3858.       if  ($directive) {
    3859. 

  3859.         if  ($f) {
    3860. 

  3860.           $this->setCurrentFont();
    3861. 

  3861.           $cf =  $this->currentFont;
    3862. 

  3862.         }
    3863. 

  3863. 

  3864.         $i =  $i+$directive-1;
    3865. 

  3865.       } else {
    3866. 

  3866.         $cOrd =  ord($text[$i]);
    3867. 

  3867. 

  3868.         if  (isset($this->fonts[$cf]['differences'][$cOrd])) {
    3869. 

  3869.           // then this character is being replaced by another
    3870. 

  3870.           $cOrd2 =  $this->fonts[$cf]['differences'][$cOrd];
    3871. 

  3871.         } else {
    3872. 

  3872.           $cOrd2 =  $cOrd;
    3873. 

  3873.         }
    3874. 

  3874. 

  3875.         if  (isset($this->fonts[$cf]['C'][$cOrd2])) {
    3876. 

  3876.           $w+=  $this->fonts[$cf]['C'][$cOrd2];
    3877. 

  3877.         }
    3878. 

  3878. 

  3879.         if  ($w>$tw) {
    3880. 

  3880.           // then we need to truncate this line
    3881. 

  3881.           if  ($break>0) {
    3882. 

  3882.             // then we have somewhere that we can split :)
    3883. 

  3883.             if  ($text[$break] ===  ' ') {
    3884. 

  3884.               $tmp =  mb_substr($text, 0, $break);
    3885. 

  3885.             } else {
    3886. 

  3886.               $tmp =  mb_substr($text, 0, $break+1);
    3887. 

  3887.             }
    3888. 

  3888. 

  3889.             $adjust =  0;
    3890. 

  3890.             $this->PRVTadjustWrapText($tmp, $breakWidth, $width, $x, $adjust, $justification);
    3891. 

  3891. 

  3892.             // reset the text state
    3893. 

  3893.             $this->currentTextState =  $store_currentTextState;
    3894. 

  3894.             $this->setCurrentFont();
    3895. 

  3895. 

  3896.             if  (!$test) {
    3897. 

  3897.               $this->addText($x, $y, $size, $tmp, $angle, $adjust);
    3898. 

  3898.             }
    3899. 

  3899. 

  3900.             return  mb_substr($text, $break+1);
    3901. 

  3901.           } else {
    3902. 

  3902.             // just split before the current character
    3903. 

  3903.             $tmp =  mb_substr($text, 0, $i);
    3904. 

  3904.             $adjust =  0;
    3905. 

  3905.             $ctmp =  ord($text[$i]);
    3906. 

  3906. 

  3907.             if  (isset($this->fonts[$cf]['differences'][$ctmp])) {
    3908. 

  3908.               $ctmp =  $this->fonts[$cf]['differences'][$ctmp];
    3909. 

  3909.             }
    3910. 

  3910. 

  3911.             $tmpw =  ($w-$this->fonts[$cf]['C'][$ctmp]) *$size/1000;
    3912. 

  3912.             $this->PRVTadjustWrapText($tmp, $tmpw, $width, $x, $adjust, $justification);
    3913. 

  3913. 

  3914.             // reset the text state
    3915. 

  3915.             $this->currentTextState =  $store_currentTextState;
    3916. 

  3916.             $this->setCurrentFont();
    3917. 

  3917. 

  3918.             if  (!$test) {
    3919. 

  3919.               $this->addText($x, $y, $size, $tmp, $angle, $adjust);
    3920. 

  3920.             }
    3921. 

  3921. 

  3922.             return  mb_substr($text, $i);
    3923. 

  3923.           }
    3924. 

  3924.         }
    3925. 

  3925. 

  3926.         if  ($text[$i] ===  '-') {
    3927. 

  3927.           $break =  $i;
    3928. 

  3928.           $breakWidth =  $w*$size/1000;
    3929. 

  3929.         }
    3930. 

  3930. 

  3931.         if  ($text[$i] ===  ' ') {
    3932. 

  3932.           $break =  $i;
    3933. 

  3933.           $ctmp =  ord($text[$i]);
    3934. 

  3934. 

  3935.           if  (isset($this->fonts[$cf]['differences'][$ctmp])) {
    3936. 

  3936.             $ctmp =  $this->fonts[$cf]['differences'][$ctmp];
    3937. 

  3937.           }
    3938. 

  3938. 

  3939.           $breakWidth =  ($w-$this->fonts[$cf]['C'][$ctmp]) *$size/1000;
    3940. 

  3940.         }
    3941. 

  3941.       }
    3942. 

  3942.     }
    3943. 

  3943. 

  3944.     // then there was no need to break this line
    3945. 

  3945.     if  ($justification ===  'full') {
    3946. 

  3946.       $justification =  'left';
    3947. 

  3947.     }
    3948. 

  3948. 

  3949.     $adjust =  0;
    3950. 

  3950.     $tmpw =  $w*$size/1000;
    3951. 

  3951. 

  3952.     $this->PRVTadjustWrapText($text, $tmpw, $width, $x, $adjust, $justification);
    3953. 

  3953. 

  3954.     // reset the text state
    3955. 

  3955.     $this->currentTextState =  $store_currentTextState;
    3956. 

  3956.     $this->setCurrentFont();
    3957. 

  3957. 

  3958.     if  (!$test) {
    3959. 

  3959.       $this->addText($x, $y, $size, $text, $angle, $adjust);
    3960. 

  3960.     }
    3961. 

  3961. 

  3962.     return  '';
    3963. 

  3963.   }
    3964. 

  3964. 

  3965.   /**
    3966. 

  3966.    * this will be called at a new page to return the state to what it was on the
    3967. 

  3967.    * end of the previous page, before the stack was closed down
    3968. 

  3968.    * This is to get around not being able to have open 'q' across pages
    3969. 

  3969.    *
    3970. 

  3970.    */
    3971. 

  3971.   function saveState($pageEnd =  0) {
    3972. 

  3972.     if  ($pageEnd) {
    3973. 

  3973.       // this will be called at a new page to return the state to what it was on the
    3974. 

  3974.       // end of the previous page, before the stack was closed down
    3975. 

  3975.       // This is to get around not being able to have open 'q' across pages
    3976. 

  3976.       $opt =  $this->stateStack[$pageEnd];
    3977. 

  3977.       // ok to use this as stack starts numbering at 1
    3978. 

  3978.       $this->setColor($opt['col'], true);
    3979. 

  3979.       $this->setStrokeColor($opt['str'], true);
    3980. 

  3980.       $this->objects[$this->currentContents]['c'].=  "\n".$opt['lin'];
    3981. 

  3981.       //    $this->currentLineStyle = $opt['lin'];
    3982. 

  3982.     } else {
    3983. 

  3983.       $this->nStateStack++;
    3984. 

  3984.       $this->stateStack[$this->nStateStack] =  array(
    3985. 

  3985.         'col' => $this->currentColour,
    3986. 

  3986.         'str' => $this->currentStrokeColour,
    3987. 

  3987.         'lin' => $this->currentLineStyle
    3988. 

  3988.       );
    3989. 

  3989.     }
    3990. 

  3990. 

  3991.     $this->save();
    3992. 

  3992.   }
    3993. 

  3993. 

  3994.   /**
    3995. 

  3995.    * restore a previously saved state
    3996. 

  3996.    */
    3997. 

  3997.   function restoreState($pageEnd =  0) {
    3998. 

  3998.     if  (!$pageEnd) {
    3999. 

  3999.       $n =  $this->nStateStack;
    4000. 

  4000.       $this->currentColour =       $this->stateStack[$n]['col'];
    4001. 

  4001.       $this->currentStrokeColour = $this->stateStack[$n]['str'];
    4002. 

  4002.       $this->objects[$this->currentContents]['c'].=  "\n".$this->stateStack[$n]['lin'];
    4003. 

  4003.       $this->currentLineStyle =    $this->stateStack[$n]['lin'];
    4004. 

  4004.       $this->stateStack[$n] = null;
    4005. 

  4005.       unset($this->stateStack[$n]);
    4006. 

  4006.       $this->nStateStack--;
    4007. 

  4007.     }
    4008. 

  4008.     
    4009. 

  4009.     $this->restore();
    4010. 

  4010.   }
    4011. 

  4011. 

  4012.   /**
    4013. 

  4013.    * make a loose object, the output will go into this object, until it is closed, then will revert to
    4014. 

  4014.    * the current one.
    4015. 

  4015.    * this object will not appear until it is included within a page.
    4016. 

  4016.    * the function will return the object number
    4017. 

  4017.    */
    4018. 

  4018.   function openObject() {
    4019. 

  4019.     $this->nStack++;
    4020. 

  4020.     $this->stack[$this->nStack] =  array('c' => $this->currentContents, 'p' => $this->currentPage);
    4021. 

  4021.     // add a new object of the content type, to hold the data flow
    4022. 

  4022.     $this->numObj++;
    4023. 

  4023.     $this->o_contents($this->numObj, 'new');
    4024. 

  4024.     $this->currentContents =  $this->numObj;
    4025. 

  4025.     $this->looseObjects[$this->numObj] =  1;
    4026. 

  4026. 

  4027.     return  $this->numObj;
    4028. 

  4028.   }
    4029. 

  4029. 

  4030.   /**
    4031. 

  4031.    * open an existing object for editing
    4032. 

  4032.    */
    4033. 

  4033.   function reopenObject($id) {
    4034. 

  4034.     $this->nStack++;
    4035. 

  4035.     $this->stack[$this->nStack] =  array('c' => $this->currentContents, 'p' => $this->currentPage);
    4036. 

  4036.     $this->currentContents =  $id;
    4037. 

  4037. 

  4038.     // also if this object is the primary contents for a page, then set the current page to its parent
    4039. 

  4039.     if  (isset($this->objects[$id]['onPage'])) {
    4040. 

  4040.       $this->currentPage =  $this->objects[$id]['onPage'];
    4041. 

  4041.     }
    4042. 

  4042.   }
    4043. 

  4043. 

  4044.   /**
    4045. 

  4045.    * close an object
    4046. 

  4046.    */
    4047. 

  4047.   function closeObject() {
    4048. 

  4048.     // close the object, as long as there was one open in the first place, which will be indicated by
    4049. 

  4049.     // an objectId on the stack.
    4050. 

  4050.     if  ($this->nStack>0) {
    4051. 

  4051.       $this->currentContents =  $this->stack[$this->nStack]['c'];
    4052. 

  4052.       $this->currentPage =  $this->stack[$this->nStack]['p'];
    4053. 

  4053.       $this->nStack--;
    4054. 

  4054.       // easier to probably not worry about removing the old entries, they will be overwritten
    4055. 

  4055.       // if there are new ones.
    4056. 

  4056.     }
    4057. 

  4057.   }
    4058. 

  4058. 

  4059.   /**
    4060. 

  4060.    * stop an object from appearing on pages from this point on
    4061. 

  4061.    */
    4062. 

  4062.   function stopObject($id) {
    4063. 

  4063.     // if an object has been appearing on pages up to now, then stop it, this page will
    4064. 

  4064.     // be the last one that could contian it.
    4065. 

  4065.     if  (isset($this->addLooseObjects[$id])) {
    4066. 

  4066.       $this->addLooseObjects[$id] =  '';
    4067. 

  4067.     }
    4068. 

  4068.   }
    4069. 

  4069. 

  4070.   /**
    4071. 

  4071.    * after an object has been created, it wil only show if it has been added, using this function.
    4072. 

  4072.    */
    4073. 

  4073.   function addObject($id, $options =  'add') {
    4074. 

  4074.     // add the specified object to the page
    4075. 

  4075.     if  (isset($this->looseObjects[$id]) &&  $this->currentContents !=  $id) {
    4076. 

  4076.       // then it is a valid object, and it is not being added to itself
    4077. 

  4077.       switch ($options) {
    4078. 

  4078.       case  'all':
    4079. 

  4079.         // then this object is to be added to this page (done in the next block) and
    4080. 

  4080.         // all future new pages.
    4081. 

  4081.         $this->addLooseObjects[$id] =  'all';
    4082. 

  4082. 

  4083.       case  'add':
    4084. 

  4084.         if  (isset($this->objects[$this->currentContents]['onPage'])) {
    4085. 

  4085.           // then the destination contents is the primary for the page
    4086. 

  4086.           // (though this object is actually added to that page)
    4087. 

  4087.           $this->o_page($this->objects[$this->currentContents]['onPage'], 'content', $id);
    4088. 

  4088.         }
    4089. 

  4089.         break;
    4090. 

  4090. 

  4091.       case  'even':
    4092. 

  4092.         $this->addLooseObjects[$id] =  'even';
    4093. 

  4093.         $pageObjectId =  $this->objects[$this->currentContents]['onPage'];
    4094. 

  4094.         if  ($this->objects[$pageObjectId]['info']['pageNum']%2 ==  0) {
    4095. 

  4095.           $this->addObject($id);
    4096. 

  4096.           // hacky huh :)
    4097. 

  4097.         }
    4098. 

  4098.         break;
    4099. 

  4099. 

  4100.       case  'odd':
    4101. 

  4101.         $this->addLooseObjects[$id] =  'odd';
    4102. 

  4102.         $pageObjectId =  $this->objects[$this->currentContents]['onPage'];
    4103. 

  4103.         if  ($this->objects[$pageObjectId]['info']['pageNum']%2 ==  1) {
    4104. 

  4104.           $this->addObject($id);
    4105. 

  4105.           // hacky huh :)
    4106. 

  4106.         }
    4107. 

  4107.         break;
    4108. 

  4108. 

  4109.       case  'next':
    4110. 

  4110.         $this->addLooseObjects[$id] =  'all';
    4111. 

  4111.         break;
    4112. 

  4112. 

  4113.       case  'nexteven':
    4114. 

  4114.         $this->addLooseObjects[$id] =  'even';
    4115. 

  4115.         break;
    4116. 

  4116. 

  4117.       case  'nextodd':
    4118. 

  4118.         $this->addLooseObjects[$id] =  'odd';
    4119. 

  4119.         break;
    4120. 

  4120.       }
    4121. 

  4121.     }
    4122. 

  4122.   }
    4123. 

  4123. 

  4124.   /**
    4125. 

  4125.    * return a storable representation of a specific object
    4126. 

  4126.    */
    4127. 

  4127.   function serializeObject($id) {
    4128. 

  4128.     if  ( array_key_exists($id,  $this->objects))
    4129. 

  4129.       return  var_export($this->objects[$id],  true);
    4130. 

  4130.   }
    4131. 

  4131. 

  4132.   /**
    4133. 

  4133.    * restore an object from its stored representation.  returns its new object id.
    4134. 

  4134.    */
    4135. 

  4135.   function restoreSerializedObject($obj) {
    4136. 

  4136.     $obj_id =  $this->openObject();
    4137. 

  4137.     eval('$this->objects[$obj_id] = ' . $obj . ';');
    4138. 

  4138.     $this->closeObject();
    4139. 

  4139.     return  $obj_id;
    4140. 

  4140.   }
    4141. 

  4141. 

  4142.   /**
    4143. 

  4143.    * add content to the documents info object
    4144. 

  4144.    */
    4145. 

  4145.   function addInfo($label, $value =  0) {
    4146. 

  4146.     // this will only work if the label is one of the valid ones.
    4147. 

  4147.     // modify this so that arrays can be passed as well.
    4148. 

  4148.     // if $label is an array then assume that it is key => value pairs
    4149. 

  4149.     // else assume that they are both scalar, anything else will probably error
    4150. 

  4150.     if  (is_array($label)) {
    4151. 

  4151.       foreach ($label as  $l => $v) {
    4152. 

  4152.         $this->o_info($this->infoObject, $l, $v);
    4153. 

  4153.       }
    4154. 

  4154.     } else {
    4155. 

  4155.       $this->o_info($this->infoObject, $label, $value);
    4156. 

  4156.     }
    4157. 

  4157.   }
    4158. 

  4158. 

  4159.   /**
    4160. 

  4160.    * set the viewer preferences of the document, it is up to the browser to obey these.
    4161. 

  4161.    */
    4162. 

  4162.   function setPreferences($label, $value =  0) {
    4163. 

  4163.     // this will only work if the label is one of the valid ones.
    4164. 

  4164.     if  (is_array($label)) {
    4165. 

  4165.       foreach ($label as  $l => $v) {
    4166. 

  4166.         $this->o_catalog($this->catalogId, 'viewerPreferences', array($l => $v));
    4167. 

  4167.       }
    4168. 

  4168.     } else {
    4169. 

  4169.       $this->o_catalog($this->catalogId, 'viewerPreferences', array($label => $value));
    4170. 

  4170.     }
    4171. 

  4171.   }
    4172. 

  4172. 

  4173.   /**
    4174. 

  4174.    * extract an integer from a position in a byte stream
    4175. 

  4175.    *
    4176. 

  4176.    * @access private
    4177. 

  4177.    */
    4178. 

  4178.   function PRVT_getBytes(&$data, $pos, $num) {
    4179. 

  4179.     // return the integer represented by $num bytes from $pos within $data
    4180. 

  4180.     $ret =  0;
    4181. 

  4181.     for  ($i =  0;$i<$num;$i++) {
    4182. 

  4182.       $ret =  $ret*256;
    4183. 

  4183.       $ret+=  ord($data[$pos+$i]);
    4184. 

  4184.     }
    4185. 

  4185. 

  4186.     return  $ret;
    4187. 

  4187.   }
    4188. 

  4188. 

  4189.   /**
    4190. 

  4190.    * Check if image already added to pdf image directory.
    4191. 

  4191.    * If yes, need not to create again (pass empty data)
    4192. 

  4192.    */
    4193. 

  4193.   function image_iscached($imgname) {
    4194. 

  4194.     return isset($this->imagelist[$imgname]);
    4195. 

  4195.   }
    4196. 

  4196. 

  4197.   /**
    4198. 

  4198.    * add a PNG image into the document, from a GD object
    4199. 

  4199.    * this should work with remote files
    4200. 

  4200.    * 
    4201. 

  4201.    * @param string $file The PNG file
    4202. 

  4202.    * @param float $x X position
    4203. 

  4203.    * @param float $y Y position
    4204. 

  4204.    * @param float $w Width
    4205. 

  4205.    * @param float $h Height
    4206. 

  4206.    * @param resource $img A GD resource
    4207. 

  4207.    * @param bool $is_mask true if the image is a mask
    4208. 

  4208.    * @param bool $mask true if the image is masked
    4209. 

  4209.    */
    4210. 

  4210.   function addImagePng($file, $x, $y, $w =  0, $h =  0, &$img, $is_mask = false, $mask = null) {
    4211. 

  4211.     //if already cached, need not to read again
    4212. 

  4212.     if ( isset($this->imagelist[$file]) ) {
    4213. 

  4213.       $data = null;
    4214. 

  4214.     }
    4215. 

  4215.     else {
    4216. 

  4216.       // Example for transparency handling on new image. Retain for current image
    4217. 

  4217.       // $tIndex = imagecolortransparent($img);
    4218. 

  4218.       // if ($tIndex > 0) {
    4219. 

  4219.       //   $tColor    = imagecolorsforindex($img, $tIndex);
    4220. 

  4220.       //   $new_tIndex    = imagecolorallocate($new_img, $tColor['red'], $tColor['green'], $tColor['blue']);
    4221. 

  4221.       //   imagefill($new_img, 0, 0, $new_tIndex);
    4222. 

  4222.       //   imagecolortransparent($new_img, $new_tIndex);
    4223. 

  4223.       // }
    4224. 

  4224.       // blending mode (literal/blending) on drawing into current image. not relevant when not saved or not drawn
    4225. 

  4225.       //imagealphablending($img, true);
    4226. 

  4226.       
    4227. 

  4227.       //default, but explicitely set to ensure pdf compatibility
    4228. 

  4228.       imagesavealpha($img, false/*!$is_mask && !$mask*/);
    4229. 

  4229.       
    4230. 

  4230.       $error =  0;
    4231. 

  4231.       //DEBUG_IMG_TEMP
    4232. 

  4232.       //debugpng
    4233. 

  4233.       if (DEBUGPNG) print '[addImagePng '.$file.']';
    4234. 

  4234. 

  4235.       ob_start();
    4236. 

  4236.       @imagepng($img);
    4237. 

  4237.       $data = ob_get_clean();
    4238. 

  4238.       
    4239. 

  4239.       if ($data == '') {
    4240. 

  4240.         $error = 1;
    4241. 

  4241.         $errormsg = 'trouble writing file from GD';
    4242. 

  4242.         //DEBUG_IMG_TEMP
    4243. 

  4243.         //debugpng
    4244. 

  4244.         if (DEBUGPNG) print 'trouble writing file from GD';
    4245. 

  4245.       }
    4246. 

  4246. 

  4247.       if  ($error) {
    4248. 

  4248.         $this->addMessage('PNG error - ('.$file.') '.$errormsg);
    4249. 

  4249.         return;
    4250. 

  4250.       }
    4251. 

  4251.     }  //End isset($this->imagelist[$file]) (png Duplicate removal)
    4252. 

  4252.   
    4253. 

  4253.     $this->addPngFromBuf($file, $x, $y, $w, $h, $data, $is_mask, $mask);
    4254. 

  4254.   }
    4255. 

  4255.   
    4256. 

  4256.   protected function addImagePngAlpha($file, $x, $y, $w, $h, $byte) {
    4257. 

  4257.     // generate images
    4258. 

  4258.     $img = imagecreatefrompng($file);
    4259. 

  4259.     
    4260. 

  4260.     if ($img === false) {
    4261. 

  4261.       return;
    4262. 

  4262.     }
    4263. 

  4263.     
    4264. 

  4264.     // FIXME The pixel transformation doesn't work well with 8bit PNGs
    4265. 

  4265.     $eight_bit = ($byte & 4) !== 4;
    4266. 

  4266.     
    4267. 

  4267.     $wpx = imagesx($img);
    4268. 

  4268.     $hpx = imagesy($img);
    4269. 

  4269.       
    4270. 

  4270.     imagesavealpha($img, false);
    4271. 

  4271.     
    4272. 

  4272.     // create temp alpha file
    4273. 

  4273.     $tempfile_alpha = tempnam($this->tmp, "cpdf_img_");
    4274. 

  4274.     @unlink($tempfile_alpha);
    4275. 

  4275.     $tempfile_alpha = "$tempfile_alpha.png";
    4276. 

  4276.     
    4277. 

  4277.     // create temp plain file
    4278. 

  4278.     $tempfile_plain = tempnam($this->tmp, "cpdf_img_");
    4279. 

  4279.     @unlink($tempfile_plain);
    4280. 

  4280.     $tempfile_plain = "$tempfile_plain.png";
    4281. 

  4281.       
    4282. 

  4282.     $imgalpha = imagecreate($wpx, $hpx);
    4283. 

  4283.     imagesavealpha($imgalpha, false);
    4284. 

  4284.     
    4285. 

  4285.     // generate gray scale palette (0 -> 255)
    4286. 

  4286.     for ($c = 0; $c < 256; ++$c) {
    4287. 

  4287.       imagecolorallocate($imgalpha, $c, $c, $c);
    4288. 

  4288.     }
    4289. 

  4289.     
    4290. 

  4290.     // Use PECL gmagick + Graphics Magic to process transparent PNG images
    4291. 

  4291.     if (extension_loaded("gmagick")) {
    4292. 

  4292.       $gmagick = new Gmagick($file);
    4293. 

  4293.       $gmagick->setimageformat('png');
    4294. 

  4294.       
    4295. 

  4295.       // Get opacity channel (negative of alpha channel)
    4296. 

  4296.       $alpha_channel_neg = clone $gmagick;
    4297. 

  4297.       $alpha_channel_neg->separateimagechannel(Gmagick::CHANNEL_OPACITY);
    4298. 

  4298.       
    4299. 

  4299.       // Negate opacity channel
    4300. 

  4300.       $alpha_channel = new Gmagick();
    4301. 

  4301.       $alpha_channel->newimage($wpx, $hpx, "#FFFFFF", "png");
    4302. 

  4302.       $alpha_channel->compositeimage($alpha_channel_neg, Gmagick::COMPOSITE_DIFFERENCE, 0, 0);
    4303. 

  4303.       $alpha_channel->separateimagechannel(Gmagick::CHANNEL_RED);
    4304. 

  4304.       $alpha_channel->writeimage($tempfile_alpha);
    4305. 

  4305.       
    4306. 

  4306.       // Cast to 8bit+palette
    4307. 

  4307.       $imgalpha_ = imagecreatefrompng($tempfile_alpha);
    4308. 

  4308.       imagecopy($imgalpha, $imgalpha_, 0, 0, 0, 0, $wpx, $hpx);
    4309. 

  4309.       imagedestroy($imgalpha_);
    4310. 

  4310.       imagepng($imgalpha, $tempfile_alpha);
    4311. 

  4311.       
    4312. 

  4312.       // Make opaque image
    4313. 

  4313.       $color_channels = new Gmagick();
    4314. 

  4314.       $color_channels->newimage($wpx, $hpx, "#FFFFFF", "png");
    4315. 

  4315.       $color_channels->compositeimage($gmagick, Gmagick::COMPOSITE_COPYRED, 0, 0);
    4316. 

  4316.       $color_channels->compositeimage($gmagick, Gmagick::COMPOSITE_COPYGREEN, 0, 0);
    4317. 

  4317.       $color_channels->compositeimage($gmagick, Gmagick::COMPOSITE_COPYBLUE, 0, 0);
    4318. 

  4318.       $color_channels->writeimage($tempfile_plain);
    4319. 

  4319.       
    4320. 

  4320.       $imgplain = imagecreatefrompng($tempfile_plain);
    4321. 

  4321.     }
    4322. 

  4322.     
    4323. 

  4323.     // Use PECL imagick + ImageMagic to process transparent PNG images
    4324. 

  4324.     elseif (extension_loaded("imagick")) {
    4325. 

  4325.       $imagick = new Imagick($file);
    4326. 

  4326.       $imagick->setFormat('png');
    4327. 

  4327.       
    4328. 

  4328.       // Get opacity channel (negative of alpha channel)
    4329. 

  4329.       $alpha_channel = clone $imagick;
    4330. 

  4330.       $alpha_channel->separateImageChannel(Imagick::CHANNEL_ALPHA);
    4331. 

  4331.       $alpha_channel->negateImage(true);
    4332. 

  4332.       $alpha_channel->writeImage($tempfile_alpha);
    4333. 

  4333.       
    4334. 

  4334.       // Cast to 8bit+palette
    4335. 

  4335.       $imgalpha_ = imagecreatefrompng($tempfile_alpha);
    4336. 

  4336.       imagecopy($imgalpha, $imgalpha_, 0, 0, 0, 0, $wpx, $hpx);
    4337. 

  4337.       imagedestroy($imgalpha_);
    4338. 

  4338.       imagepng($imgalpha, $tempfile_alpha);
    4339. 

  4339.       
    4340. 

  4340.       // Make opaque image
    4341. 

  4341.       $color_channels = new Imagick();
    4342. 

  4342.       $color_channels->newImage($wpx, $hpx, "#FFFFFF", "png");
    4343. 

  4343.       $color_channels->compositeImage($imagick, Imagick::COMPOSITE_COPYRED, 0, 0);
    4344. 

  4344.       $color_channels->compositeImage($imagick, Imagick::COMPOSITE_COPYGREEN, 0, 0);
    4345. 

  4345.       $color_channels->compositeImage($imagick, Imagick::COMPOSITE_COPYBLUE, 0, 0);
    4346. 

  4346.       $color_channels->writeImage($tempfile_plain);
    4347. 

  4347.       
    4348. 

  4348.       $imgplain = imagecreatefrompng($tempfile_plain);
    4349. 

  4349.     }
    4350. 

  4350.     else {
    4351. 

  4351.       // allocated colors cache
    4352. 

  4352.       $allocated_colors = array();
    4353. 

  4353.       
    4354. 

  4354.       // extract alpha channel
    4355. 

  4355.       for ($xpx = 0; $xpx < $wpx; ++$xpx) {
    4356. 

  4356.         for ($ypx = 0; $ypx < $hpx; ++$ypx) {
    4357. 

  4357.           $color = imagecolorat($img, $xpx, $ypx);
    4358. 

  4358.           $col = imagecolorsforindex($img, $color);
    4359. 

  4359.           $alpha = $col['alpha'];
    4360. 

  4360.           
    4361. 

  4361.           if ($eight_bit) {
    4362. 

  4362.             // with gamma correction
    4363. 

  4363.             $gammacorr = 2.2;
    4364. 

  4364.             $pixel = pow((((127 - $alpha) * 255 / 127) / 255), $gammacorr) * 255;
    4365. 

  4365.           }
    4366. 

  4366.           
    4367. 

  4367.           else {
    4368. 

  4368.             // without gamma correction
    4369. 

  4369.             $pixel = (127 - $alpha) * 2;
    4370. 

  4370.             
    4371. 

  4371.             $key = $col['red'].$col['green'].$col['blue'];
    4372. 

  4372.             
    4373. 

  4373.             if (!isset($allocated_colors[$key])) {
    4374. 

  4374.               $pixel_img = imagecolorallocate($img, $col['red'], $col['green'], $col['blue']);
    4375. 

  4375.               $allocated_colors[$key] = $pixel_img;
    4376. 

  4376.             }
    4377. 

  4377.             else {
    4378. 

  4378.               $pixel_img = $allocated_colors[$key]; 
    4379. 

  4379.             }
    4380. 

  4380.             
    4381. 

  4381.             imagesetpixel($img, $xpx, $ypx, $pixel_img);
    4382. 

  4382.           }
    4383. 

  4383.           
    4384. 

  4384.           imagesetpixel($imgalpha, $xpx, $ypx, $pixel);
    4385. 

  4385.         }
    4386. 

  4386.       }
    4387. 

  4387.       
    4388. 

  4388.       // extract image without alpha channel
    4389. 

  4389.       $imgplain = imagecreatetruecolor($wpx, $hpx);
    4390. 

  4390.       imagecopy($imgplain, $img, 0, 0, 0, 0, $wpx, $hpx);
    4391. 

  4391.       imagedestroy($img);
    4392. 

  4392.         
    4393. 

  4393.       imagepng($imgalpha, $tempfile_alpha);
    4394. 

  4394.       imagepng($imgplain, $tempfile_plain);
    4395. 

  4395.     }
    4396. 

  4396.     
    4397. 

  4397.     // embed mask image
    4398. 

  4398.     $this->addImagePng($tempfile_alpha, $x, $y, $w, $h, $imgalpha, true);
    4399. 

  4399.     imagedestroy($imgalpha);
    4400. 

  4400.     
    4401. 

  4401.     // embed image, masked with previously embedded mask
    4402. 

  4402.     $this->addImagePng($tempfile_plain, $x, $y, $w, $h, $imgplain, false, true);
    4403. 

  4403.     imagedestroy($imgplain);
    4404. 

  4404.     
    4405. 

  4405.     // remove temp files
    4406. 

  4406.     unlink($tempfile_alpha);
    4407. 

  4407.     unlink($tempfile_plain);
    4408. 

  4408.   }
    4409. 

  4409. 

  4410.   /**
    4411. 

  4411.    * add a PNG image into the document, from a file
    4412. 

  4412.    * this should work with remote files
    4413. 

  4413.    */
    4414. 

  4414.   function addPngFromFile($file, $x, $y, $w =  0, $h =  0) {
    4415. 

  4415.     //if already cached, need not to read again
    4416. 

  4416.     if ( isset($this->imagelist[$file]) ) {
    4417. 

  4417.       $img = null;
    4418. 

  4418.     } 
    4419. 

  4419.     
    4420. 

  4420.     else {
    4421. 

  4421.       $info = file_get_contents ($file, false, null, 24, 5);
    4422. 

  4422.       $meta = unpack("CbitDepth/CcolorType/CcompressionMethod/CfilterMethod/CinterlaceMethod", $info);
    4423. 

  4423.       $bit_depth = $meta["bitDepth"];
    4424. 

  4424.       $color_type = $meta["colorType"];
    4425. 

  4425.       
    4426. 

  4426.       // http://www.w3.org/TR/PNG/#11IHDR
    4427. 

  4427.       // 3 => indexed
    4428. 

  4428.       // 4 => greyscale with alpha
    4429. 

  4429.       // 6 => fullcolor with alpha
    4430. 

  4430.       $is_alpha = in_array($color_type, array(4, 6)) || ($color_type == 3 && $bit_depth != 4);
    4431. 

  4431. 

  4432.       if ($is_alpha) { // exclude grayscale alpha
    4433. 

  4433.         return $this->addImagePngAlpha($file, $x, $y, $w, $h, $color_type);
    4434. 

  4434.       }
    4435. 

  4435. 

  4436.       //png files typically contain an alpha channel.
    4437. 

  4437.       //pdf file format or class.pdf does not support alpha blending.
    4438. 

  4438.       //on alpha blended images, more transparent areas have a color near black.
    4439. 

  4439.       //This appears in the result on not storing the alpha channel.
    4440. 

  4440.       //Correct would be the box background image or its parent when transparent.
    4441. 

  4441.       //But this would make the image dependent on the background.
    4442. 

  4442.       //Therefore create an image with white background and copy in
    4443. 

  4443.       //A more natural background than black is white.
    4444. 

  4444.       //Therefore create an empty image with white background and merge the
    4445. 

  4445.       //image in with alpha blending.
    4446. 

  4446.       $imgtmp = @imagecreatefrompng($file);
    4447. 

  4447.       if (!$imgtmp) {
    4448. 

  4448.         return;
    4449. 

  4449.       }
    4450. 

  4450.       $sx = imagesx($imgtmp);
    4451. 

  4451.       $sy = imagesy($imgtmp);
    4452. 

  4452.       $img = imagecreatetruecolor($sx,$sy);
    4453. 

  4453.       imagealphablending($img, true);
    4454. 

  4454.       
    4455. 

  4455.       // @todo is it still needed ??
    4456. 

  4456.       $ti = imagecolortransparent($imgtmp);
    4457. 

  4457.       if ($ti >= 0) {
    4458. 

  4458.         $tc = imagecolorsforindex($imgtmp,$ti);
    4459. 

  4459.         $ti = imagecolorallocate($img,$tc['red'],$tc['green'],$tc['blue']);
    4460. 

  4460.         imagefill($img,0,0,$ti);
    4461. 

  4461.         imagecolortransparent($img, $ti);
    4462. 

  4462.       } else {
    4463. 

  4463.         imagefill($img,1,1,imagecolorallocate($img,255,255,255));
    4464. 

  4464.       }
    4465. 

  4465.       
    4466. 

  4466.       imagecopy($img,$imgtmp,0,0,0,0,$sx,$sy);
    4467. 

  4467.       imagedestroy($imgtmp);
    4468. 

  4468.     }
    4469. 

  4469.     $this->addImagePng($file, $x, $y, $w, $h, $img);
    4470. 

  4470.     
    4471. 

  4471.     if ( $img ) {
    4472. 

  4472.       imagedestroy($img);
    4473. 

  4473.     }
    4474. 

  4474.   }
    4475. 

  4475. 

  4476.   /**
    4477. 

  4477.    * add a PNG image into the document, from a memory buffer of the file
    4478. 

  4478.    */
    4479. 

  4479.   function addPngFromBuf($file, $x, $y, $w =  0, $h =  0, &$data, $is_mask = false, $mask = null) {
    4480. 

  4480.     if ( isset($this->imagelist[$file]) ) {
    4481. 

  4481.       $data = null;
    4482. 

  4482.       $info['width'] = $this->imagelist[$file]['w'];
    4483. 

  4483.       $info['height'] = $this->imagelist[$file]['h'];
    4484. 

  4484.       $label = $this->imagelist[$file]['label'];
    4485. 

  4485.     }
    4486. 

  4486.     
    4487. 

  4487.     else {
    4488. 

  4488.       if ($data == null) {
    4489. 

  4489.         $this->addMessage('addPngFromBuf error - ('.$imgname.') data not present!');
    4490. 

  4490.         return;
    4491. 

  4491.       }
    4492. 

  4492.       
    4493. 

  4493.       $error =  0;
    4494. 

  4494.   
    4495. 

  4495.       if  (!$error) {
    4496. 

  4496.         $header =  chr(137) .chr(80) .chr(78) .chr(71) .chr(13) .chr(10) .chr(26) .chr(10);
    4497. 

  4497.         
    4498. 

  4498.         if  (mb_substr($data, 0, 8, '8bit') !=  $header) {
    4499. 

  4499.           $error =  1;
    4500. 

  4500.           
    4501. 

  4501.           if (DEBUGPNG) print '[addPngFromFile this file does not have a valid header '.$file.']';
    4502. 

  4502.   
    4503. 

  4503.           $errormsg =  'this file does not have a valid header';
    4504. 

  4504.         }
    4505. 

  4505.       }
    4506. 

  4506.   
    4507. 

  4507.       if  (!$error) {
    4508. 

  4508.         // set pointer
    4509. 

  4509.         $p =  8;
    4510. 

  4510.         $len =  mb_strlen($data, '8bit');
    4511. 

  4511.   
    4512. 

  4512.         // cycle through the file, identifying chunks
    4513. 

  4513.         $haveHeader =  0;
    4514. 

  4514.         $info =  array();
    4515. 

  4515.         $idata =  '';
    4516. 

  4516.         $pdata =  '';
    4517. 

  4517.   
    4518. 

  4518.         while  ($p < $len) {
    4519. 

  4519.           $chunkLen =  $this->PRVT_getBytes($data, $p, 4);
    4520. 

  4520.           $chunkType =  mb_substr($data, $p+4, 4, '8bit');
    4521. 

  4521.           
    4522. 

  4522.           switch ($chunkType) {
    4523. 

  4523.           case  'IHDR':
    4524. 

  4524.             // this is where all the file information comes from
    4525. 

  4525.             $info['width'] =  $this->PRVT_getBytes($data, $p+8, 4);
    4526. 

  4526.             $info['height'] =  $this->PRVT_getBytes($data, $p+12, 4);
    4527. 

  4527.             $info['bitDepth'] =  ord($data[$p+16]);
    4528. 

  4528.             $info['colorType'] =  ord($data[$p+17]);
    4529. 

  4529.             $info['compressionMethod'] =  ord($data[$p+18]);
    4530. 

  4530.             $info['filterMethod'] =  ord($data[$p+19]);
    4531. 

  4531.             $info['interlaceMethod'] =  ord($data[$p+20]);
    4532. 

  4532.   
    4533. 

  4533.             //print_r($info);
    4534. 

  4534.             $haveHeader =  1;
    4535. 

  4535.             if  ($info['compressionMethod'] !=  0) {
    4536. 

  4536.               $error =  1;
    4537. 

  4537.   
    4538. 

  4538.               //debugpng
    4539. 

  4539.               if (DEBUGPNG) print '[addPngFromFile unsupported compression method '.$file.']';
    4540. 

  4540.   
    4541. 

  4541.               $errormsg =  'unsupported compression method';
    4542. 

  4542.             }
    4543. 

  4543.   
    4544. 

  4544.             if  ($info['filterMethod'] !=  0) {
    4545. 

  4545.               $error =  1;
    4546. 

  4546.   
    4547. 

  4547.               //debugpng
    4548. 

  4548.               if (DEBUGPNG) print '[addPngFromFile unsupported filter method '.$file.']';
    4549. 

  4549.   
    4550. 

  4550.               $errormsg =  'unsupported filter method';
    4551. 

  4551.             }
    4552. 

  4552.             break;
    4553. 

  4553.   
    4554. 

  4554.           case  'PLTE':
    4555. 

  4555.             $pdata.=  mb_substr($data, $p+8, $chunkLen, '8bit');
    4556. 

  4556.             break;
    4557. 

  4557.   
    4558. 

  4558.           case  'IDAT':
    4559. 

  4559.             $idata.=  mb_substr($data, $p+8, $chunkLen, '8bit');
    4560. 

  4560.             break;
    4561. 

  4561.   
    4562. 

  4562.           case  'tRNS':
    4563. 

  4563.             //this chunk can only occur once and it must occur after the PLTE chunk and before IDAT chunk
    4564. 

  4564.             //print "tRNS found, color type = ".$info['colorType']."\n";
    4565. 

  4565.             $transparency =  array();
    4566. 

  4566.             
    4567. 

  4567.             switch ($info['colorType']) {
    4568. 

  4568.               // indexed color, rbg
    4569. 

  4569.               case 3:
    4570. 

  4570.                 /* corresponding to entries in the plte chunk
    4571. 

  4571.                  Alpha for palette index 0: 1 byte
    4572. 

  4572.                  Alpha for palette index 1: 1 byte
    4573. 

  4573.                  ...etc...
    4574. 

  4574.                 */
    4575. 

  4575.                 // there will be one entry for each palette entry. up until the last non-opaque entry.
    4576. 

  4576.                 // set up an array, stretching over all palette entries which will be o (opaque) or 1 (transparent)
    4577. 

  4577.                 $transparency['type'] =  'indexed';
    4578. 

  4578.                 
    4579. 

  4579.                 $numPalette =  mb_strlen($pdata, '8bit')/3;
    4580. 

  4580.                 $trans =  0;
    4581. 

  4581.     
    4582. 

  4582.                 for  ($i =  $chunkLen;$i >=  0;$i--) {
    4583. 

  4583.                   if  (ord($data[$p+8+$i]) ==  0) {
    4584. 

  4584.                     $trans =  $i;
    4585. 

  4585.                   }
    4586. 

  4586.                 }
    4587. 

  4587.     
    4588. 

  4588.                 $transparency['data'] =  $trans;
    4589. 

  4589.               break;
    4590. 

  4590.               
    4591. 

  4591.               // grayscale
    4592. 

  4592.               case 0:
    4593. 

  4593.                 /* corresponding to entries in the plte chunk
    4594. 

  4594.                  Gray: 2 bytes, range 0 .. (2^bitdepth)-1
    4595. 

  4595.                 */
    4596. 

  4596.                 //            $transparency['grayscale'] = $this->PRVT_getBytes($data,$p+8,2); // g = grayscale
    4597. 

  4597.                 $transparency['type'] =  'indexed';
    4598. 

  4598.                 $transparency['data'] =  ord($data[$p+8+1]);
    4599. 

  4599.               break;
    4600. 

  4600.               
    4601. 

  4601.               // truecolor
    4602. 

  4602.               case 2:      
    4603. 

  4603.                 /* corresponding to entries in the plte chunk
    4604. 

  4604.                  Red: 2 bytes, range 0 .. (2^bitdepth)-1
    4605. 

  4605.                  Green: 2 bytes, range 0 .. (2^bitdepth)-1
    4606. 

  4606.                  Blue: 2 bytes, range 0 .. (2^bitdepth)-1
    4607. 

  4607.                 */
    4608. 

  4608.                 $transparency['r'] =  $this->PRVT_getBytes($data, $p+8, 2);
    4609. 

  4609.                 // r from truecolor
    4610. 

  4610.                 $transparency['g'] =  $this->PRVT_getBytes($data, $p+10, 2);
    4611. 

  4611.                 // g from truecolor
    4612. 

  4612.                 $transparency['b'] =  $this->PRVT_getBytes($data, $p+12, 2);
    4613. 

  4613.                 // b from truecolor
    4614. 

  4614.     
    4615. 

  4615.                 $transparency['type'] = 'color-key';
    4616. 

  4616.               break;
    4617. 

  4617.               
    4618. 

  4618.               //unsupported transparency type
    4619. 

  4619.               default:
    4620. 

  4620.                 if (DEBUGPNG) print '[addPngFromFile unsupported transparency type '.$file.']';
    4621. 

  4621.                 break;
    4622. 

  4622.             }
    4623. 

  4623.   
    4624. 

  4624.             // KS End new code
    4625. 

  4625.             break;
    4626. 

  4626.   
    4627. 

  4627.           default:
    4628. 

  4628.             break;
    4629. 

  4629.           }
    4630. 

  4630.   
    4631. 

  4631.           $p +=  $chunkLen+12;
    4632. 

  4632.         }
    4633. 

  4633.   
    4634. 

  4634.         if (!$haveHeader) {
    4635. 

  4635.           $error =  1;
    4636. 

  4636.   
    4637. 

  4637.           //debugpng
    4638. 

  4638.           if (DEBUGPNG) print '[addPngFromFile information header is missing '.$file.']';
    4639. 

  4639.   
    4640. 

  4640.           $errormsg =  'information header is missing';
    4641. 

  4641.         }
    4642. 

  4642.   
    4643. 

  4643.         if  (isset($info['interlaceMethod']) &&  $info['interlaceMethod']) {
    4644. 

  4644.           $error =  1;
    4645. 

  4645.   
    4646. 

  4646.           //debugpng
    4647. 

  4647.           if (DEBUGPNG) print '[addPngFromFile no support for interlaced images in pdf '.$file.']';
    4648. 

  4648.   
    4649. 

  4649.           $errormsg =  'There appears to be no support for interlaced images in pdf.';
    4650. 

  4650.         }
    4651. 

  4651.       }
    4652. 

  4652.   
    4653. 

  4653.       if  (!$error &&  $info['bitDepth'] > 8) {
    4654. 

  4654.         $error =  1;
    4655. 

  4655.   
    4656. 

  4656.         //debugpng
    4657. 

  4657.         if (DEBUGPNG) print '[addPngFromFile bit depth of 8 or less is supported '.$file.']';
    4658. 

  4658.   
    4659. 

  4659.         $errormsg =  'only bit depth of 8 or less is supported';
    4660. 

  4660.       }
    4661. 

  4661.       
    4662. 

  4662.       if  (!$error) {
    4663. 

  4663.         switch  ($info['colorType']) {
    4664. 

  4664.         case  3:
    4665. 

  4665.           $color =  'DeviceRGB';
    4666. 

  4666.           $ncolor =  1;
    4667. 

  4667.           break;
    4668. 

  4668.   
    4669. 

  4669.         case  2:
    4670. 

  4670.           $color =  'DeviceRGB';
    4671. 

  4671.           $ncolor =  3;
    4672. 

  4672.           break;
    4673. 

  4673.   
    4674. 

  4674.         case  0:
    4675. 

  4675.           $color =  'DeviceGray';
    4676. 

  4676.           $ncolor =  1;
    4677. 

  4677.           break;
    4678. 

  4678.         
    4679. 

  4679.         default: 
    4680. 

  4680.           $error =  1;
    4681. 

  4681.   
    4682. 

  4682.           //debugpng
    4683. 

  4683.           if (DEBUGPNG) print '[addPngFromFile alpha channel not supported: '.$info['colorType'].' '.$file.']';
    4684. 

  4684.   
    4685. 

  4685.           $errormsg =  'transparancey alpha channel not supported, transparency only supported for palette images.';
    4686. 

  4686.         }
    4687. 

  4687.       }
    4688. 

  4688.   
    4689. 

  4689.       if  ($error) {
    4690. 

  4690.         $this->addMessage('PNG error - ('.$file.') '.$errormsg);
    4691. 

  4691.         return;
    4692. 

  4692.       }
    4693. 

  4693. 

  4694.       //print_r($info);
    4695. 

  4695.       // so this image is ok... add it in.
    4696. 

  4696.       $this->numImages++;
    4697. 

  4697.       $im =  $this->numImages;
    4698. 

  4698.       $label =  "I$im";
    4699. 

  4699.       $this->numObj++;
    4700. 

  4700. 

  4701.       //  $this->o_image($this->numObj,'new',array('label' => $label,'data' => $idata,'iw' => $w,'ih' => $h,'type' => 'png','ic' => $info['width']));
    4702. 

  4702.       $options =  array(
    4703. 

  4703.         'label' => $label,
    4704. 

  4704.         'data' => $idata,
    4705. 

  4705.         'bitsPerComponent' => $info['bitDepth'],
    4706. 

  4706.         'pdata' => $pdata,
    4707. 

  4707.         'iw' => $info['width'],
    4708. 

  4708.         'ih' => $info['height'],
    4709. 

  4709.         'type' => 'png',
    4710. 

  4710.         'color' => $color,
    4711. 

  4711.         'ncolor' => $ncolor,
    4712. 

  4712.         'masked' => $mask,
    4713. 

  4713.         'isMask' => $is_mask,
    4714. 

  4714.       );
    4715. 

  4715. 

  4716.       if  (isset($transparency)) {
    4717. 

  4717.         $options['transparency'] =  $transparency;
    4718. 

  4718.       }
    4719. 

  4719. 

  4720.       $this->o_image($this->numObj, 'new', $options);
    4721. 

  4721.       $this->imagelist[$file] = array('label' =>$label, 'w' => $info['width'], 'h' => $info['height']);
    4722. 

  4722.     }
    4723. 

  4723.     
    4724. 

  4724.     if ($is_mask) {
    4725. 

  4725.       return;
    4726. 

  4726.     }
    4727. 

  4727. 

  4728.     if  ($w <=  0 && $h <=  0) {
    4729. 

  4729.       $w =  $info['width'];
    4730. 

  4730.       $h =  $info['height'];
    4731. 

  4731.     }
    4732. 

  4732. 

  4733.     if  ($w <=  0) {
    4734. 

  4734.       $w =  $h/$info['height']*$info['width'];
    4735. 

  4735.     }
    4736. 

  4736. 

  4737.     if  ($h <=  0) {
    4738. 

  4738.       $h =  $w*$info['height']/$info['width'];
    4739. 

  4739.     }
    4740. 

  4740. 

  4741.     $this->objects[$this->currentContents]['c'].=  sprintf("\nq\n%.3F 0 0 %.3F %.3F %.3F cm /%s Do\nQ", $w, $h, $x, $y, $label);
    4742. 

  4742.   }
    4743. 

  4743. 

  4744.   /**
    4745. 

  4745.    * add a JPEG image into the document, from a file
    4746. 

  4746.    */
    4747. 

  4747.   function addJpegFromFile($img, $x, $y, $w =  0, $h =  0) {
    4748. 

  4748.     // attempt to add a jpeg image straight from a file, using no GD commands
    4749. 

  4749.     // note that this function is unable to operate on a remote file.
    4750. 

  4750. 

  4751.     if  (!file_exists($img)) {
    4752. 

  4752.       return;
    4753. 

  4753.     }
    4754. 

  4754. 

  4755.     if ( $this->image_iscached($img) ) {
    4756. 

  4756.       $data = null;
    4757. 

  4757.       $imageWidth  = $this->imagelist[$img]['w'];
    4758. 

  4758.       $imageHeight = $this->imagelist[$img]['h'];
    4759. 

  4759.       $channels    = $this->imagelist[$img]['c'];
    4760. 

  4760.     } 
    4761. 

  4761.     else {
    4762. 

  4762.       $tmp = getimagesize($img);
    4763. 

  4763.       $imageWidth  = $tmp[0];
    4764. 

  4764.       $imageHeight = $tmp[1];
    4765. 

  4765. 

  4766.       if ( isset($tmp['channels']) ) {
    4767. 

  4767.         $channels =  $tmp['channels'];
    4768. 

  4768.       } else {
    4769. 

  4769.         $channels =  3;
    4770. 

  4770.       }
    4771. 

  4771. 

  4772.       $data =  file_get_contents($img);
    4773. 

  4773.     }
    4774. 

  4774. 

  4775.     if  ($w <=  0 &&  $h <=  0) {
    4776. 

  4776.       $w =  $imageWidth;
    4777. 

  4777.     }
    4778. 

  4778. 

  4779.     if  ($w ==  0) {
    4780. 

  4780.       $w =  $h/$imageHeight*$imageWidth;
    4781. 

  4781.     }
    4782. 

  4782. 

  4783.     if  ($h ==  0) {
    4784. 

  4784.       $h =  $w*$imageHeight/$imageWidth;
    4785. 

  4785.     }
    4786. 

  4786. 

  4787.     $this->addJpegImage_common($data, $x, $y, $w, $h, $imageWidth, $imageHeight, $channels, $img);
    4788. 

  4788.   }
    4789. 

  4789. 

  4790.   /**
    4791. 

  4791.    * common code used by the two JPEG adding functions
    4792. 

  4792.    *
    4793. 

  4793.    * @access private
    4794. 

  4794.    */
    4795. 

  4795.   function addJpegImage_common(&$data, $x, $y, $w =  0, $h =  0, $imageWidth, $imageHeight, $channels =  3, $imgname) {
    4796. 

  4796.     if ( $this->image_iscached($imgname) ) {
    4797. 

  4797.       $label = $this->imagelist[$imgname]['label'];
    4798. 

  4798.       //debugpng
    4799. 

  4799.       //if (DEBUGPNG) print '[addJpegImage_common Duplicate '.$imgname.']';
    4800. 

  4800. 

  4801.     } else {
    4802. 

  4802.       if ($data == null) {
    4803. 

  4803.         $this->addMessage('addJpegImage_common error - ('.$imgname.') data not present!');
    4804. 

  4804.         return;
    4805. 

  4805.       }
    4806. 

  4806. 

  4807.       // note that this function is not to be called externally
    4808. 

  4808.       // it is just the common code between the GD and the file options
    4809. 

  4809.       $this->numImages++;
    4810. 

  4810.       $im =  $this->numImages;
    4811. 

  4811.       $label =  "I$im";
    4812. 

  4812.       $this->numObj++;
    4813. 

  4813.       
    4814. 

  4814.       $this->o_image($this->numObj, 'new', array(
    4815. 

  4815.         'label' => $label, 
    4816. 

  4816.         'data' => &$data, 
    4817. 

  4817.         'iw' => $imageWidth, 
    4818. 

  4818.         'ih' => $imageHeight, 
    4819. 

  4819.         'channels' => $channels
    4820. 

  4820.       ));
    4821. 

  4821.       
    4822. 

  4822.       $this->imagelist[$imgname] = array('label' =>$label, 'w' => $imageWidth, 'h' => $imageHeight, 'c'=> $channels );
    4823. 

  4823.     }
    4824. 

  4824. 

  4825.     $this->objects[$this->currentContents]['c'].=  sprintf("\nq\n%.3F 0 0 %.3F %.3F %.3F cm /%s Do\nQ ", $w, $h, $x, $y, $label);
    4826. 

  4826.   }
    4827. 

  4827. 

  4828.   /**
    4829. 

  4829.    * specify where the document should open when it first starts
    4830. 

  4830.    */
    4831. 

  4831.   function openHere($style, $a =  0, $b =  0, $c =  0) {
    4832. 

  4832.     // this function will open the document at a specified page, in a specified style
    4833. 

  4833.     // the values for style, and the required paramters are:
    4834. 

  4834.     // 'XYZ'  left, top, zoom
    4835. 

  4835.     // 'Fit'
    4836. 

  4836.     // 'FitH' top
    4837. 

  4837.     // 'FitV' left
    4838. 

  4838.     // 'FitR' left,bottom,right
    4839. 

  4839.     // 'FitB'
    4840. 

  4840.     // 'FitBH' top
    4841. 

  4841.     // 'FitBV' left
    4842. 

  4842.     $this->numObj++;
    4843. 

  4843.     $this->o_destination($this->numObj, 'new', array('page' => $this->currentPage, 'type' => $style, 'p1' => $a, 'p2' => $b, 'p3' => $c));
    4844. 

  4844.     $id =  $this->catalogId;
    4845. 

  4845.     $this->o_catalog($id, 'openHere', $this->numObj);
    4846. 

  4846.   }
    4847. 

  4847.   
    4848. 

  4848.   /**
    4849. 

  4849.    * Add JavaScript code to the PDF document
    4850. 

  4850.    * 
    4851. 

  4851.    * @param string $code
    4852. 

  4852.    * @return void
    4853. 

  4853.    */
    4854. 

  4854.   function addJavascript($code) {
    4855. 

  4855.     $this->javascript .= $code;
    4856. 

  4856.   }
    4857. 

  4857. 

  4858.   /**
    4859. 

  4859.    * create a labelled destination within the document
    4860. 

  4860.    */
    4861. 

  4861.   function addDestination($label, $style, $a =  0, $b =  0, $c =  0) {
    4862. 

  4862.     // associates the given label with the destination, it is done this way so that a destination can be specified after
    4863. 

  4863.     // it has been linked to
    4864. 

  4864.     // styles are the same as the 'openHere' function
    4865. 

  4865.     $this->numObj++;
    4866. 

  4866.     $this->o_destination($this->numObj, 'new', array('page' => $this->currentPage, 'type' => $style, 'p1' => $a, 'p2' => $b, 'p3' => $c));
    4867. 

  4867.     $id =  $this->numObj;
    4868. 

  4868. 

  4869.     // store the label->idf relationship, note that this means that labels can be used only once
    4870. 

  4870.     $this->destinations["$label"] =  $id;
    4871. 

  4871.   }
    4872. 

  4872. 

  4873.   /**
    4874. 

  4874.    * define font families, this is used to initialize the font families for the default fonts
    4875. 

  4875.    * and for the user to add new ones for their fonts. The default bahavious can be overridden should
    4876. 

  4876.    * that be desired.
    4877. 

  4877.    */
    4878. 

  4878.   function setFontFamily($family, $options =  '') {
    4879. 

  4879.     if  (!is_array($options)) {
    4880. 

  4880.       if  ($family ===  'init') {
    4881. 

  4881.         // set the known family groups
    4882. 

  4882.         // these font families will be used to enable bold and italic markers to be included
    4883. 

  4883.         // within text streams. html forms will be used... <b></b> <i></i>
    4884. 

  4884.         $this->fontFamilies['Helvetica.afm'] =
    4885. 

  4885.           array('b' => 'Helvetica-Bold.afm',
    4886. 

  4886.                 'i' => 'Helvetica-Oblique.afm',
    4887. 

  4887.                 'bi' => 'Helvetica-BoldOblique.afm',
    4888. 

  4888.                 'ib' => 'Helvetica-BoldOblique.afm');
    4889. 

  4889. 

  4890.         $this->fontFamilies['Courier.afm'] =
    4891. 

  4891.           array('b' => 'Courier-Bold.afm',
    4892. 

  4892.                 'i' => 'Courier-Oblique.afm',
    4893. 

  4893.                 'bi' => 'Courier-BoldOblique.afm',
    4894. 

  4894.                 'ib' => 'Courier-BoldOblique.afm');
    4895. 

  4895. 

  4896.         $this->fontFamilies['Times-Roman.afm'] =
    4897. 

  4897.           array('b' => 'Times-Bold.afm',
    4898. 

  4898.                 'i' => 'Times-Italic.afm',
    4899. 

  4899.                 'bi' => 'Times-BoldItalic.afm',
    4900. 

  4900.                 'ib' => 'Times-BoldItalic.afm');
    4901. 

  4901.       }
    4902. 

  4902.     } else {
    4903. 

  4903. 

  4904.       // the user is trying to set a font family
    4905. 

  4905.       // note that this can also be used to set the base ones to something else
    4906. 

  4906.       if  (mb_strlen($family)) {
    4907. 

  4907.         $this->fontFamilies[$family] =  $options;
    4908. 

  4908.       }
    4909. 

  4909.     }
    4910. 

  4910.   }
    4911. 

  4911. 

  4912.   /**
    4913. 

  4913.    * used to add messages for use in debugging
    4914. 

  4914.    */
    4915. 

  4915.   function addMessage($message) {
    4916. 

  4916.     $this->messages.=  $message."\n";
    4917. 

  4917.   }
    4918. 

  4918. 

  4919.   /**
    4920. 

  4920.    * a few functions which should allow the document to be treated transactionally.
    4921. 

  4921.    */
    4922. 

  4922.   function transaction($action) {
    4923. 

  4923.     switch  ($action) {
    4924. 

  4924.     case 'start':
    4925. 

  4925.       // store all the data away into the checkpoint variable
    4926. 

  4926.       $data =  get_object_vars($this);
    4927. 

  4927.       $this->checkpoint =  $data;
    4928. 

  4928.       unset($data);
    4929. 

  4929.       break;
    4930. 

  4930. 

  4931.     case 'commit':
    4932. 

  4932.       if  (is_array($this->checkpoint) &&  isset($this->checkpoint['checkpoint'])) {
    4933. 

  4933.         $tmp =  $this->checkpoint['checkpoint'];
    4934. 

  4934.         $this->checkpoint =  $tmp;
    4935. 

  4935.         unset($tmp);
    4936. 

  4936.       } else {
    4937. 

  4937.         $this->checkpoint =  '';
    4938. 

  4938.       }
    4939. 

  4939.       break;
    4940. 

  4940. 

  4941.     case 'rewind':
    4942. 

  4942.       // do not destroy the current checkpoint, but move us back to the state then, so that we can try again
    4943. 

  4943.       if  (is_array($this->checkpoint)) {
    4944. 

  4944.         // can only abort if were inside a checkpoint
    4945. 

  4945.         $tmp =  $this->checkpoint;
    4946. 

  4946. 

  4947.         foreach ($tmp as  $k => $v) {
    4948. 

  4948.           if  ($k !==  'checkpoint') {
    4949. 

  4949.             $this->$k =  $v;
    4950. 

  4950.           }
    4951. 

  4951.         }
    4952. 

  4952.         unset($tmp);
    4953. 

  4953.       }
    4954. 

  4954.       break;
    4955. 

  4955. 

  4956.     case 'abort':
    4957. 

  4957.       if  (is_array($this->checkpoint)) {
    4958. 

  4958.         // can only abort if were inside a checkpoint
    4959. 

  4959.         $tmp =  $this->checkpoint;
    4960. 

  4960.         foreach ($tmp as  $k => $v) {
    4961. 

  4961.           $this->$k =  $v;
    4962. 

  4962.         }
    4963. 

  4963.         unset($tmp);
    4964. 

  4964.       }
    4965. 

  4965.       break;
    4966. 

  4966.     }
    4967. 

  4967.   }
    4968. 

  4968. }
    4969. 

  4969. 

  4970.