PageRenderTime 71ms CodeModel.GetById 29ms RepoModel.GetById 1ms app.codeStats 0ms

/mainapp/plugins/dompdf/lib/class.pdf.php

https://bitbucket.org/fauzilhaqqi/freestay-module
PHP | 4517 lines | 2698 code | 742 blank | 1077 comment | 570 complexity | e57ed8ce5220b70700ec80c637e99b5d MD5 | raw file
Possible License(s): LGPL-2.1

Large files files are truncated, but you can click here to view the full file

    

  1. <?php
    2. 

  2.   /**
    3. 

  3.    * Cpdf
    4. 

  4.    *
    5. 

  5.    * http://www.ros.co.nz/pdf
    6. 

  6.    *
    7. 

  7.    * A PHP class to provide the basic functionality to create a pdf document without
    8. 

  8.    * any requirement for additional modules.
    9. 

  9.    *
    10. 

  10.    * Note that the companion class CezPdf can be used to extend this class and dramatically
    11. 

  11.    * simplify the creation of documents.
    12. 

  12.    *
    13. 

  13.    * Extended by Orion Richardson to support Unicode / UTF-8 characters using
    14. 

  14.    * TCPDF and others as a guide.
    15. 

  15.    *
    16. 

  16.    * IMPORTANT NOTE
    17. 

  17.    * there is no warranty, implied or otherwise with this software.
    18. 

  18.    *
    19. 

  19.    * LICENCE
    20. 

  20.    * This code has been placed in the Public Domain for all to enjoy.
    21. 

  21.    *
    22. 

  22.    * @author       Wayne Munro <pdf@ros.co.nz>
    23. 

  23.    * @contributor  Orion Richardson <orionr@yahoo.com>
    24. 

  24.    * @contributor  Helmut Tischer <htischer@weihenstephan.org>
    25. 

  25.    * @contributor  Ryan H. Masten <ryan.masten@gmail.com>
    26. 

  26.    * @version  009
    27. 

  27.    * @package  Cpdf
    28. 

  28.    *
    29. 

  29.    * Changes
    30. 

  30.    * @contributor Helmut Tischer <htischer@weihenstephan.org>
    31. 

  31.    * @version 0.5.1.htischer.20090507
    32. 

  32.    * - On multiple identical png and jpg images, put only one copy into the pdf file and refer to it.
    33. 

  33.    *   This reduces file size and rendering time.
    34. 

  34.    * - Allow font metrics cache to be a different folder as the font metrics. This allows a read only installation.
    35. 

  35.    * - Allow adding images directly from a gd object. This increases performance by avoiding temporary files.
    36. 

  36.    * - On png image files remove alpa channel to allow display of typical png files in pdf.
    37. 

  37.    * - On addImage avoid temporary file. Todo: Duplicate Image (currently not used)
    38. 

  38.    * - Add a check function, whether image is already cached, This avoids double creation by caller which saves
    39. 

  39.    *   CPU time and memory.
    40. 

  40.    * @contributor Helmut Tischer <htischer@weihenstephan.org>
    41. 

  41.    * @version dompdf_trunk_with_helmut_mods.20090524
    42. 

  42.    * - Allow temp and fontcache folders to be passed in by class creator
    43. 

  43.    * @version dompdf_trunk_with_helmut_mods.20090528
    44. 

  44.    * - typo 'decent' instead of 'descent' at various locations made getFontDescender worthless
    45. 

  45.    */
    46. 

  46. 

  47. /* $Id: class.pdf.php 217 2010-03-11 23:03:57Z ryan.masten $ */
    48. 

  48. 

  49. class  Cpdf {
    50. 

  50. 

  51. 

  52.   /**
    53. 

  53.    * the current number of pdf objects in the document
    54. 

  54.    */
    55. 

  55.   public  $numObj = 0;
    56. 

  56. 

  57.   /**
    58. 

  58.    * this array contains all of the pdf objects, ready for final assembly
    59. 

  59.    */
    60. 

  60.   public  $objects =  array();
    61. 

  61. 

  62.   /**
    63. 

  63.    * the objectId (number within the objects array) of the document catalog
    64. 

  64.    */
    65. 

  65.   public  $catalogId;
    66. 

  66. 

  67.   /**
    68. 

  68.    * array carrying information about the fonts that the system currently knows about
    69. 

  69.    * used to ensure that a font is not loaded twice, among other things
    70. 

  70.    */
    71. 

  71.   public  $fonts = array();
    72. 

  72.   
    73. 

  73.   /**
    74. 

  74.    * the default font metrics file to use if no other font has been loaded
    75. 

  75.    * the path to the directory containing the font metrics should be included
    76. 

  76.    */
    77. 

  77.   public  $defaultFont = './fonts/Helvetica.afm';
    78. 

  78.   
    79. 

  79.   /**
    80. 

  80.    * a record of the current font
    81. 

  81.    */
    82. 

  82.   public  $currentFont = '';
    83. 

  83. 

  84.   /**
    85. 

  85.    * the current base font
    86. 

  86.    */
    87. 

  87.   public  $currentBaseFont = '';
    88. 

  88. 

  89.   /**
    90. 

  90.    * the number of the current font within the font array
    91. 

  91.    */
    92. 

  92.   public  $currentFontNum = 0;
    93. 

  93. 

  94.   /**
    95. 

  95.    *
    96. 

  96.    */
    97. 

  97.   public  $currentNode;
    98. 

  98. 

  99.   /**
    100. 

  100.    * object number of the current page
    101. 

  101.    */
    102. 

  102.   public  $currentPage;
    103. 

  103. 

  104.   /**
    105. 

  105.    * object number of the currently active contents block
    106. 

  106.    */
    107. 

  107.   public  $currentContents;
    108. 

  108. 

  109.   /**
    110. 

  110.    * number of fonts within the system
    111. 

  111.    */
    112. 

  112.   public  $numFonts = 0;
    113. 

  113. 

  114.   /**
    115. 

  115.    * Number of graphic state resources used
    116. 

  116.    */
    117. 

  117.   private  $numStates =  0;
    118. 

  118. 

  119. 

  120.   /**
    121. 

  121.    * current colour for fill operations, defaults to inactive value, all three components should be between 0 and 1 inclusive when active
    122. 

  122.    */
    123. 

  123.   public  $currentColour = array('r'=>-1, 'g'=>-1, 'b'=>-1);
    124. 

  124. 

  125.   /**
    126. 

  126.    * current colour for stroke operations (lines etc.)
    127. 

  127.    */
    128. 

  128.   public  $currentStrokeColour = array('r'=>-1, 'g'=>-1, 'b'=>-1);
    129. 

  129. 

  130.   /**
    131. 

  131.    * current style that lines are drawn in
    132. 

  132.    */
    133. 

  133.   public  $currentLineStyle = '';
    134. 

  134. 

  135.   /**
    136. 

  136.    * current line transparency (partial graphics state)
    137. 

  137.    */
    138. 

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

  139.   
    140. 

  140.   /**
    141. 

  141.    * current fill transparency (partial graphics state)
    142. 

  142.    */
    143. 

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

  144.   
    145. 

  145.   /**
    146. 

  146.    * an array which is used to save the state of the document, mainly the colours and styles
    147. 

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

  148.    */
    149. 

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

  150. 

  151.   /**
    152. 

  152.    * number of elements within the state stack
    153. 

  153.    */
    154. 

  154.   public  $nStateStack =  0;
    155. 

  155. 

  156.   /**
    157. 

  157.    * number of page objects within the document
    158. 

  158.    */
    159. 

  159.   public  $numPages = 0;
    160. 

  160. 

  161.   /**
    162. 

  162.    * object Id storage stack
    163. 

  163.    */
    164. 

  164.   public  $stack = array();
    165. 

  165. 

  166.   /**
    167. 

  167.    * number of elements within the object Id storage stack
    168. 

  168.    */
    169. 

  169.   public  $nStack = 0;
    170. 

  170. 

  171.   /**
    172. 

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

  173.    * these have been added with the addObject function
    174. 

  174.    */
    175. 

  175.   public  $looseObjects = array();
    176. 

  176. 

  177.   /**
    178. 

  178.    * array contains infomation about how the loose objects are to be added to the document
    179. 

  179.    */
    180. 

  180.   public  $addLooseObjects = array();
    181. 

  181. 

  182.   /**
    183. 

  183.    * the objectId of the information object for the document
    184. 

  184.    * this contains authorship, title etc.
    185. 

  185.    */
    186. 

  186.   public  $infoObject = 0;
    187. 

  187. 

  188.   /**
    189. 

  189.    * number of images being tracked within the document
    190. 

  190.    */
    191. 

  191.   public  $numImages = 0;
    192. 

  192. 

  193.   /**
    194. 

  194.    * an array containing options about the document
    195. 

  195.    * it defaults to turning on the compression of the objects
    196. 

  196.    */
    197. 

  197.   public  $options = array('compression'=>1);
    198. 

  198. 

  199.   /**
    200. 

  200.    * the objectId of the first page of the document
    201. 

  201.    */
    202. 

  202.   public  $firstPageId;
    203. 

  203. 

  204.   /**
    205. 

  205.    * used to track the last used value of the inter-word spacing, this is so that it is known
    206. 

  206.    * when the spacing is changed.
    207. 

  207.    */
    208. 

  208.   public  $wordSpaceAdjust = 0;
    209. 

  209. 

  210.   /**
    211. 

  211.    * the object Id of the procset object
    212. 

  212.    */
    213. 

  213.   public  $procsetObjectId;
    214. 

  214. 

  215.   /**
    216. 

  216.    * store the information about the relationship between font families
    217. 

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

  218.    * the value of this array is initialised in the constuctor function.
    219. 

  219.    */
    220. 

  220.   public  $fontFamilies =  array();
    221. 

  221.  
    222. 

  222.   /**
    223. 

  223.    * folder for php serialized formats of font metrics files.
    224. 

  224.    * If empty string, use same folder as original metrics files.
    225. 

  225.    * This can be passed in from class creator.
    226. 

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

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

  228.    */
    229. 

  229.   public  $fontcache = '';
    230. 

  230.   
    231. 

  231.   /**
    232. 

  232.    * The version of the font metrics cache file.
    233. 

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

  234.    */
    235. 

  235.   public  $fontcacheVersion = 2;
    236. 

  236. 

  237.   /**
    238. 

  238.    * temporary folder.
    239. 

  239.    * If empty string, will attempty system tmp folder.
    240. 

  240.    * This can be passed in from class creator.
    241. 

  241.    * Only used for conversion of gd images to jpeg images.
    242. 

  242.    */
    243. 

  243.   public  $tmp = '';
    244. 

  244. 

  245.   /**
    246. 

  246.    * track if the current font is bolded or italicised
    247. 

  247.    */
    248. 

  248.   public  $currentTextState =  '';
    249. 

  249. 

  250.   /**
    251. 

  251.    * messages are stored here during processing, these can be selected afterwards to give some useful debug information
    252. 

  252.    */
    253. 

  253.   public  $messages = '';
    254. 

  254. 

  255.   /**
    256. 

  256.    * the ancryption array for the document encryption is stored here
    257. 

  257.    */
    258. 

  258.   public  $arc4 = '';
    259. 

  259. 

  260.   /**
    261. 

  261.    * the object Id of the encryption information
    262. 

  262.    */
    263. 

  263.   public  $arc4_objnum = 0;
    264. 

  264. 

  265.   /**
    266. 

  266.    * the file identifier, used to uniquely identify a pdf document
    267. 

  267.    */
    268. 

  268.   public  $fileIdentifier = '';
    269. 

  269. 

  270.   /**
    271. 

  271.    * a flag to say if a document is to be encrypted or not
    272. 

  272.    */
    273. 

  273.   public  $encrypted = 0;
    274. 

  274. 

  275.   /**
    276. 

  276.    * the ancryption key for the encryption of all the document content (structure is not encrypted)
    277. 

  277.    */
    278. 

  278.   public  $encryptionKey = '';
    279. 

  279. 

  280.   /**
    281. 

  281.    * array which forms a stack to keep track of nested callback functions
    282. 

  282.    */
    283. 

  283.   public  $callback =  array();
    284. 

  284. 

  285.   /**
    286. 

  286.    * the number of callback functions in the callback array
    287. 

  287.    */
    288. 

  288.   public  $nCallback =  0;
    289. 

  289. 

  290.   /**
    291. 

  291.    * store label->id pairs for named destinations, these will be used to replace internal links
    292. 

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

  293.    */
    294. 

  294.   public  $destinations =  array();
    295. 

  295. 

  296.   /**
    297. 

  297.    * store the stack for the transaction commands, each item in here is a record of the values of all the
    298. 

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

  299.    * note that this includes the objects array, so these can be large.
    300. 

  300.    */
    301. 

  301.   public  $checkpoint =  '';
    302. 

  302. 

  303.   /* Table of Image origin filenames and image labels which were already added with o_image().
    304. 

  304.    * Allows to merge identical images
    305. 

  305.    */
    306. 

  306.   public  $imagelist = array();
    307. 

  307. 

  308.   /**
    309. 

  309.    * whether the text passed in should be treated as Unicode or just local character set.
    310. 

  310.    */
    311. 

  311.   public  $isUnicode = false;
    312. 

  312.   
    313. 

  313.   public  $javascript = '';
    314. 

  314. 

  315.   /**
    316. 

  316.    * class constructor
    317. 

  317.    * this will start a new document
    318. 

  318.    * @var array array of 4 numbers, defining the bottom left and upper right corner of the page. first two are normally zero.
    319. 

  319.    * @var boolean whether text will be treated as Unicode or not.
    320. 

  320.    */
    321. 

  321.   function  Cpdf ($pageSize = array(0, 0, 612, 792), $isUnicode = false, $fontcache = '', $tmp = '') {
    322. 

  322.     $this->isUnicode = $isUnicode;
    323. 

  323.     $this->fontcache = $fontcache;
    324. 

  324.     $this->tmp = $tmp;
    325. 

  325.     $this->newDocument($pageSize);
    326. 

  326. 

  327.     // also initialize the font families that are known about already
    328. 

  328.     $this->setFontFamily('init');
    329. 

  329.     //  $this->fileIdentifier = md5('xxxxxxxx'.time());
    330. 

  330.   }
    331. 

  331. 

  332. 

  333.   /**
    334. 

  334.    * Document object methods (internal use only)
    335. 

  335.    *
    336. 

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

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

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

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

  340.    *           'new' - create the object with the id $id
    341. 

  341.    *           'out' - produce the output for the pdf object
    342. 

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

  343.    *
    344. 

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

  345.    * within the pdf 'file'.
    346. 

  346.    */
    347. 

  347. 

  348.   /**
    349. 

  349.    *destination object, used to specify the location for the user to jump to, presently on opening
    350. 

  350.    */
    351. 

  351.   protected function  o_destination($id, $action, $options = '') {
    352. 

  352.     if  ($action !== 'new') {
    353. 

  353.       $o = & $this->objects[$id];
    354. 

  354.     }
    355. 

  355. 

  356.     switch ($action) {
    357. 

  357.     case  'new':
    358. 

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

  359.       $tmp =  '';
    360. 

  360.       switch  ($options['type']) {
    361. 

  361.       case  'XYZ':
    362. 

  362.       case  'FitR':
    363. 

  363.         $tmp =   ' '.$options['p3'].$tmp;
    364. 

  364.       case  'FitH':
    365. 

  365.       case  'FitV':
    366. 

  366.       case  'FitBH':
    367. 

  367.       case  'FitBV':
    368. 

  368.         $tmp =   ' '.$options['p1'].' '.$options['p2'].$tmp;
    369. 

  369.       case  'Fit':
    370. 

  370.       case  'FitB':
    371. 

  371.         $tmp =   $options['type'].$tmp;
    372. 

  372.         $this->objects[$id]['info']['string'] = $tmp;
    373. 

  373.         $this->objects[$id]['info']['page'] = $options['page'];
    374. 

  374.       }
    375. 

  375.       break;
    376. 

  376. 

  377.     case  'out':
    378. 

  378.       $tmp =  $o['info'];
    379. 

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

  380.       return  $res;
    381. 

  381.     }
    382. 

  382.   }
    383. 

  383. 

  384. 

  385.   /**
    386. 

  386.    * set the viewer preferences
    387. 

  387.    */
    388. 

  388.   protected function  o_viewerPreferences($id, $action, $options = '') {
    389. 

  389.     if  ($action !== 'new') {
    390. 

  390.       $o = & $this->objects[$id];
    391. 

  391.     }
    392. 

  392. 

  393.     switch  ($action) {
    394. 

  394.     case  'new':
    395. 

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

  396.       break;
    397. 

  397. 

  398.     case  'add':
    399. 

  399.       foreach($options as  $k=>$v) {
    400. 

  400.         switch  ($k) {
    401. 

  401.         case  'HideToolbar':
    402. 

  402.         case  'HideMenubar':
    403. 

  403.         case  'HideWindowUI':
    404. 

  404.         case  'FitWindow':
    405. 

  405.         case  'CenterWindow':
    406. 

  406.         case  'NonFullScreenPageMode':
    407. 

  407.         case  'Direction':
    408. 

  408.           $o['info'][$k] = $v;
    409. 

  409.           break;
    410. 

  410.         }
    411. 

  411.       }
    412. 

  412.       break;
    413. 

  413. 

  414.     case  'out':
    415. 

  415.       $res = "\n".$id." 0 obj\n".'<< ';
    416. 

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

  417.         $res.= "\n/".$k.' '.$v;
    418. 

  418.       }
    419. 

  419.       $res.= "\n>>\n";
    420. 

  420.       return  $res;
    421. 

  421.     }
    422. 

  422.   }
    423. 

  423. 

  424. 

  425.   /**
    426. 

  426.    * define the document catalog, the overall controller for the document
    427. 

  427.    */
    428. 

  428.   protected function  o_catalog($id, $action, $options = '') {
    429. 

  429.     if  ($action !== 'new') {
    430. 

  430.       $o = & $this->objects[$id];
    431. 

  431.     }
    432. 

  432. 

  433.     switch  ($action) {
    434. 

  434.     case  'new':
    435. 

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

  436.       $this->catalogId = $id;
    437. 

  437.       break;
    438. 

  438. 

  439.     case  'outlines':
    440. 

  440.     case  'pages':
    441. 

  441.     case  'openHere':
    442. 

  442.     case  'javascript':
    443. 

  443.       $o['info'][$action] = $options;
    444. 

  444.       break;
    445. 

  445. 

  446.     case  'viewerPreferences':
    447. 

  447.       if  (!isset($o['info']['viewerPreferences'])) {
    448. 

  448.         $this->numObj++;
    449. 

  449.         $this->o_viewerPreferences($this->numObj, 'new');
    450. 

  450.         $o['info']['viewerPreferences'] = $this->numObj;
    451. 

  451.       }
    452. 

  452. 

  453.       $vp =  $o['info']['viewerPreferences'];
    454. 

  454.       $this->o_viewerPreferences($vp, 'add', $options);
    455. 

  455. 

  456.       break;
    457. 

  457. 

  458.     case  'out':
    459. 

  459.       $res = "\n".$id." 0 obj\n".'<< /Type /Catalog';
    460. 

  460. 

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

  462.         switch ($k) {
    463. 

  463.         case  'outlines':
    464. 

  464.           $res.= "\n".'/Outlines '.$v.' 0 R';
    465. 

  465.           break;
    466. 

  466.           
    467. 

  467.         case  'pages':
    468. 

  468.           $res.= "\n".'/Pages '.$v.' 0 R';
    469. 

  469.           break;
    470. 

  470. 

  471.         case  'viewerPreferences':
    472. 

  472.           $res.= "\n".'/ViewerPreferences '.$v.' 0 R';
    473. 

  473.           break;
    474. 

  474. 

  475.         case  'openHere':
    476. 

  476.           $res.= "\n".'/OpenAction '.$v.' 0 R';
    477. 

  477.           break;
    478. 

  478. 

  479.         case  'javascript':
    480. 

  480.           $res.= "\n".'/Names <</JavaScript '.$v.' 0 R>>';
    481. 

  481.           break;
    482. 

  482.         }
    483. 

  483.       }
    484. 

  484. 

  485.       $res.= " >>\nendobj";
    486. 

  486.       return  $res;
    487. 

  487.     }
    488. 

  488.   }
    489. 

  489. 

  490. 

  491.   /**
    492. 

  492.    * object which is a parent to the pages in the document
    493. 

  493.    */
    494. 

  494.   protected function  o_pages($id, $action, $options = '') {
    495. 

  495.     if  ($action !== 'new') {
    496. 

  496.       $o = & $this->objects[$id];
    497. 

  497.     }
    498. 

  498. 

  499.     switch  ($action) {
    500. 

  500.     case  'new':
    501. 

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

  502.       $this->o_catalog($this->catalogId, 'pages', $id);
    503. 

  503.       break;
    504. 

  504. 

  505.     case  'page':
    506. 

  506.       if  (!is_array($options)) {
    507. 

  507.         // then it will just be the id of the new page
    508. 

  508.         $o['info']['pages'][] = $options;
    509. 

  509.       } else {
    510. 

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

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

  512.         if  (isset($options['id']) &&  isset($options['rid']) &&  isset($options['pos'])) {
    513. 

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

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

  515. 

  516.             // then there is a match
    517. 

  517.             // make a space
    518. 

  518.             switch  ($options['pos']) {
    519. 

  519.             case  'before':
    520. 

  520.               $k =  $i;
    521. 

  521.               break;
    522. 

  522. 

  523.             case  'after':
    524. 

  524.               $k = $i+1;
    525. 

  525.               break;
    526. 

  526. 

  527.             default:
    528. 

  528.               $k = -1;
    529. 

  529.               break;
    530. 

  530.             }
    531. 

  531. 

  532.             if  ($k >= 0) {
    533. 

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

  534.                 $o['info']['pages'][$j+1] = $o['info']['pages'][$j];
    535. 

  535.               }
    536. 

  536. 

  537.               $o['info']['pages'][$k] = $options['id'];
    538. 

  538.             }
    539. 

  539.           }
    540. 

  540.         }
    541. 

  541.       }
    542. 

  542.       break;
    543. 

  543. 

  544.     case  'procset':
    545. 

  545.       $o['info']['procset'] = $options;
    546. 

  546.       break;
    547. 

  547. 

  548.     case  'mediaBox':
    549. 

  549.       $o['info']['mediaBox'] = $options;
    550. 

  550.       // which should be an array of 4 numbers
    551. 

  551.       break;
    552. 

  552. 

  553.     case  'font':
    554. 

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

  555.       break;
    556. 

  556. 

  557.     case  'extGState':
    558. 

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

  559.       break;
    560. 

  560. 

  561.     case  'xObject':
    562. 

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

  563.       break;
    564. 

  564. 

  565.     case  'out':
    566. 

  566.       if  (count($o['info']['pages'])) {
    567. 

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

  568.         foreach($o['info']['pages'] as  $k=>$v) {
    569. 

  569.           $res.= $v." 0 R\n";
    570. 

  570.         }
    571. 

  571. 

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

  573. 

  574.         if  ( (isset($o['info']['fonts']) &&  count($o['info']['fonts'])) ||
    575. 

  575.               isset($o['info']['procset']) ||
    576. 

  576.               (isset($o['info']['extGStates']) &&  count($o['info']['extGStates']))) {
    577. 

  577.           $res.= "\n/Resources <<";
    578. 

  578. 

  579.           if  (isset($o['info']['procset'])) {
    580. 

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

  581.           }
    582. 

  582. 

  583.           if  (isset($o['info']['fonts']) &&  count($o['info']['fonts'])) {
    584. 

  584.             $res.= "\n/Font << ";
    585. 

  585.             foreach($o['info']['fonts'] as  $finfo) {
    586. 

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

  587.             }
    588. 

  588.             $res.= "\n>>";
    589. 

  589.           }
    590. 

  590. 

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

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

  593.             foreach($o['info']['xObjects'] as  $finfo) {
    594. 

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

  595.             }
    596. 

  596.             $res.= "\n>>";
    597. 

  597.           }
    598. 

  598. 

  599.           if  ( isset($o['info']['extGStates']) &&  count($o['info']['extGStates'])) {
    600. 

  600.             $res.=  "\n/ExtGState << ";
    601. 

  601.             foreach ($o['info']['extGStates'] as  $gstate) {
    602. 

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

  603.             }
    604. 

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

  605.           }
    606. 

  606. 

  607.           $res.= "\n>>";
    608. 

  608.           if  (isset($o['info']['mediaBox'])) {
    609. 

  609.             $tmp = $o['info']['mediaBox'];
    610. 

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

  611.           }
    612. 

  612.         }
    613. 

  613. 

  614.         $res.= "\n >>\nendobj";
    615. 

  615.       } else {
    616. 

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

  617.       }
    618. 

  618. 

  619.       return  $res;
    620. 

  620.     }
    621. 

  621.   }
    622. 

  622. 

  623. 

  624.   /**
    625. 

  625.    * define the outlines in the doc, empty for now
    626. 

  626.    */
    627. 

  627.   protected function  o_outlines($id, $action, $options = '') {
    628. 

  628.     if  ($action !== 'new') {
    629. 

  629.       $o = & $this->objects[$id];
    630. 

  630.     }
    631. 

  631. 

  632.     switch  ($action) {
    633. 

  633.     case  'new':
    634. 

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

  635.       $this->o_catalog($this->catalogId, 'outlines', $id);
    636. 

  636.       break;
    637. 

  637. 

  638.     case  'outline':
    639. 

  639.       $o['info']['outlines'][] = $options;
    640. 

  640.       break;
    641. 

  641. 

  642.     case  'out':
    643. 

  643.       if  (count($o['info']['outlines'])) {
    644. 

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

  645.         foreach($o['info']['outlines'] as  $k=>$v) {
    646. 

  646.           $res.= $v." 0 R ";
    647. 

  647.         }
    648. 

  648. 

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

  650.       } else {
    651. 

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

  652.       }
    653. 

  653. 

  654.       return  $res;
    655. 

  655.     }
    656. 

  656.   }
    657. 

  657. 

  658. 

  659.   /**
    660. 

  660.    * an object to hold the font description
    661. 

  661.    */
    662. 

  662.   protected function  o_font($id, $action, $options = '') {
    663. 

  663.     if  ($action !== 'new') {
    664. 

  664.       $o = & $this->objects[$id];
    665. 

  665.     }
    666. 

  666. 

  667.     switch  ($action) {
    668. 

  668.     case  'new':
    669. 

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

  670.       $fontNum =  $this->numFonts;
    671. 

  671.       $this->objects[$id]['info']['fontNum'] =  $fontNum;
    672. 

  672. 

  673.       // deal with the encoding and the differences
    674. 

  674.       if  (isset($options['differences'])) {
    675. 

  675.         // then we'll need an encoding dictionary
    676. 

  676.         $this->numObj++;
    677. 

  677.         $this->o_fontEncoding($this->numObj, 'new', $options);
    678. 

  678.         $this->objects[$id]['info']['encodingDictionary'] =  $this->numObj;
    679. 

  679.       } else  if  (isset($options['encoding'])) {
    680. 

  680.         // we can specify encoding here
    681. 

  681.         switch ($options['encoding']) {
    682. 

  682.         case  'WinAnsiEncoding':
    683. 

  683.         case  'MacRomanEncoding':
    684. 

  684.         case  'MacExpertEncoding':
    685. 

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

  686.           break;
    687. 

  687. 

  688.         case  'none':
    689. 

  689.           break;
    690. 

  690. 

  691.         default:
    692. 

  692.           $this->objects[$id]['info']['encoding'] =  'WinAnsiEncoding';
    693. 

  693.           break;
    694. 

  694.         }
    695. 

  695.       } else {
    696. 

  696.         $this->objects[$id]['info']['encoding'] =  'WinAnsiEncoding';
    697. 

  697.       }
    698. 

  698. 

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

  700.         // For Unicode fonts, we need to incorporate font data into
    701. 

  701.         // sub-sections that are linked from the primary font section.
    702. 

  702.         // Look at o_fontGIDtoCID and o_fontDescendentCID functions
    703. 

  703.         // for more informaiton.
    704. 

  704.         //
    705. 

  705.         // All of this code is adapted from the excellent changes made to
    706. 

  706.         // transform FPDF to TCPDF (http://tcpdf.sourceforge.net/)
    707. 

  707. 

  708.         $toUnicodeId = ++$this->numObj;
    709. 

  709.         $this->o_contents($toUnicodeId, 'new', 'raw');
    710. 

  710.         $this->objects[$id]['info']['toUnicode'] = $toUnicodeId;
    711. 

  711.         
    712. 

  712.         $stream =  "/CIDInit /ProcSet findresource begin\n";
    713. 

  713.         $stream.=  "12 dict begin\n";
    714. 

  714.         $stream.=  "begincmap\n";
    715. 

  715.         $stream.=  "/CIDSystemInfo\n";
    716. 

  716.         $stream.=  "<</Registry (Adobe)\n";
    717. 

  717.         $stream.=  "/Ordering (UCS)\n";
    718. 

  718.         $stream.=  "/Supplement 0\n";
    719. 

  719.         $stream.=  ">> def\n";
    720. 

  720.         $stream.=  "/CMapName /Adobe-Identity-UCS def\n";
    721. 

  721.         $stream.=  "/CMapType 2 def\n";
    722. 

  722.         $stream.=  "1 begincodespacerange\n";
    723. 

  723.         $stream.=  "<0000> <FFFF>\n";
    724. 

  724.         $stream.=  "endcodespacerange\n";
    725. 

  725.         $stream.=  "1 beginbfrange\n";
    726. 

  726.         $stream.=  "<0000> <FFFF> <0000>\n";
    727. 

  727.         $stream.=  "endbfrange\n";
    728. 

  728.         $stream.=  "endcmap\n";
    729. 

  729.         $stream.=  "CMapName currentdict /CMap defineresource pop\n";
    730. 

  730.         $stream.=  "end\n";
    731. 

  731.         $stream.=  "end\n";
    732. 

  732. 

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

  734.         $res .=  "stream\n" . $stream . "endstream";
    735. 

  735. 

  736.         $this->objects[$toUnicodeId]['c'] = $res;
    737. 

  737. 

  738.         $cidFontId = ++$this->numObj;
    739. 

  739.         $this->o_fontDescendentCID($cidFontId, 'new', $options);
    740. 

  740.         $this->objects[$id]['info']['cidFont'] = $cidFontId;
    741. 

  741.       }
    742. 

  742.       
    743. 

  743.       // also tell the pages node about the new font
    744. 

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

  745.       break;
    746. 

  746. 

  747.     case  'add':
    748. 

  748.       foreach ($options as  $k => $v) {
    749. 

  749.         switch  ($k) {
    750. 

  750.         case  'BaseFont':
    751. 

  751.           $o['info']['name'] =  $v;
    752. 

  752.           break;
    753. 

  753.         case  'FirstChar':
    754. 

  754.         case  'LastChar':
    755. 

  755.         case  'Widths':
    756. 

  756.         case  'FontDescriptor':
    757. 

  757.         case  'SubType':
    758. 

  758.           $this->addMessage('o_font '.$k." : ".$v);
    759. 

  759.           $o['info'][$k] =  $v;
    760. 

  760.           break;
    761. 

  761.         }
    762. 

  762.       }
    763. 

  763. 

  764.       // pass values down to descendent font
    765. 

  765.       if (isset($o['info']['cidFont'])) {
    766. 

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

  767.       }
    768. 

  768.       break;
    769. 

  769. 

  770.     case  'out':
    771. 

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

  772.         // For Unicode fonts, we need to incorporate font data into
    773. 

  773.         // sub-sections that are linked from the primary font section.
    774. 

  774.         // Look at o_fontGIDtoCID and o_fontDescendentCID functions
    775. 

  775.         // for more informaiton.
    776. 

  776.         //
    777. 

  777.         // All of this code is adapted from the excellent changes made to
    778. 

  778.         // transform FPDF to TCPDF (http://tcpdf.sourceforge.net/)
    779. 

  779. 

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

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

  782. 

  783.         // The horizontal identity mapping for 2-byte CIDs; may be used
    784. 

  784.         // with CIDFonts using any Registry, Ordering, and Supplement values.
    785. 

  785.         $res.=  "/Encoding /Identity-H\n";
    786. 

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

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

  788.         $res.=  ">>\n";
    789. 

  789.         $res.=  "endobj";
    790. 

  790.       } else {
    791. 

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

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

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

  794. 

  795.       if  (isset($o['info']['encodingDictionary'])) {
    796. 

  796.         // then place a reference to the dictionary
    797. 

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

  798.       } else  if  (isset($o['info']['encoding'])) {
    799. 

  799.         // use the specified encoding
    800. 

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

  801.       }
    802. 

  802. 

  803.       if  (isset($o['info']['FirstChar'])) {
    804. 

  804.         $res.=  "/FirstChar ".$o['info']['FirstChar']."\n";
    805. 

  805.       }
    806. 

  806. 

  807.       if  (isset($o['info']['LastChar'])) {
    808. 

  808.         $res.=  "/LastChar ".$o['info']['LastChar']."\n";
    809. 

  809.       }
    810. 

  810. 

  811.       if  (isset($o['info']['Widths'])) {
    812. 

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

  813.       }
    814. 

  814. 

  815.       if  (isset($o['info']['FontDescriptor'])) {
    816. 

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

  817.       }
    818. 

  818. 

  819.         $res.=  ">>\n";
    820. 

  820.         $res.=  "endobj";
    821. 

  821.       }
    822. 

  822. 

  823.       return  $res;
    824. 

  824.     }
    825. 

  825.   }
    826. 

  826. 

  827. 

  828.   /**
    829. 

  829.    * a font descriptor, needed for including additional fonts
    830. 

  830.    */
    831. 

  831.   protected function  o_fontDescriptor($id, $action, $options = '') {
    832. 

  832.     if  ($action !== 'new') {
    833. 

  833.       $o = & $this->objects[$id];
    834. 

  834.     }
    835. 

  835. 

  836.     switch  ($action) {
    837. 

  837.     case  'new':
    838. 

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

  839.       break;
    840. 

  840. 

  841.     case  'out':
    842. 

  842.       $res = "\n".$id." 0 obj\n<< /Type /FontDescriptor\n";
    843. 

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

  844.         switch  ($label) {
    845. 

  845.         case  'Ascent':
    846. 

  846.         case  'CapHeight':
    847. 

  847.         case  'Descent':
    848. 

  848.         case  'Flags':
    849. 

  849.         case  'ItalicAngle':
    850. 

  850.         case  'StemV':
    851. 

  851.         case  'AvgWidth':
    852. 

  852.         case  'Leading':
    853. 

  853.         case  'MaxWidth':
    854. 

  854.         case  'MissingWidth':
    855. 

  855.         case  'StemH':
    856. 

  856.         case  'XHeight':
    857. 

  857.         case  'CharSet':
    858. 

  858.           if  (mb_strlen($value, '8bit')) {
    859. 

  859.             $res.= '/'.$label.' '.$value."\n";
    860. 

  860.           }
    861. 

  861. 

  862.           break;
    863. 

  863.         case  'FontFile':
    864. 

  864.         case  'FontFile2':
    865. 

  865.         case  'FontFile3':
    866. 

  866.           $res.= '/'.$label.' '.$value." 0 R\n";
    867. 

  867.           break;
    868. 

  868. 

  869.         case  'FontBBox':
    870. 

  870.           $res.= '/'.$label.' ['.$value[0].' '.$value[1].' '.$value[2].' '.$value[3]."]\n";
    871. 

  871.           break;
    872. 

  872. 

  873.         case  'FontName':
    874. 

  874.           $res.= '/'.$label.' /'.$value."\n";
    875. 

  875.           break;
    876. 

  876.         }
    877. 

  877.       }
    878. 

  878. 

  879.       $res.= ">>\nendobj";
    880. 

  880. 

  881.       return  $res;
    882. 

  882.     }
    883. 

  883.   }
    884. 

  884. 

  885. 

  886.   /**
    887. 

  887.    * the font encoding
    888. 

  888.    */
    889. 

  889.   protected function  o_fontEncoding($id, $action, $options = '') {
    890. 

  890.     if  ($action !== 'new') {
    891. 

  891.       $o = & $this->objects[$id];
    892. 

  892.     }
    893. 

  893. 

  894.     switch  ($action) {
    895. 

  895.     case  'new':
    896. 

  896.       // the options array should contain 'differences' and maybe 'encoding'
    897. 

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

  898.       break;
    899. 

  899. 

  900.     case  'out':
    901. 

  901.       $res = "\n".$id." 0 obj\n<< /Type /Encoding\n";
    902. 

  902.       if  (!isset($o['info']['encoding'])) {
    903. 

  903.         $o['info']['encoding'] = 'WinAnsiEncoding';
    904. 

  904.       }
    905. 

  905. 

  906.       if  ($o['info']['encoding'] !== 'none') {
    907. 

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

  908.       }
    909. 

  909. 

  910.       $res.= "/Differences \n[";
    911. 

  911. 

  912.       $onum = -100;
    913. 

  913. 

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

  915.         if  ($num != $onum+1) {
    916. 

  916.           // we cannot make use of consecutive numbering
    917. 

  917.           $res.=  "\n".$num." /".$label;
    918. 

  918.         } else {
    919. 

  919.           $res.=  " /".$label;
    920. 

  920.         }
    921. 

  921. 

  922.         $onum = $num;
    923. 

  923.       }
    924. 

  924. 

  925.       $res.= "\n]\n>>\nendobj";
    926. 

  926.       return  $res;
    927. 

  927.     }
    928. 

  928.   }
    929. 

  929. 

  930. 

  931.   /**
    932. 

  932.    * a descendent cid font,  needed for unicode fonts
    933. 

  933.    */
    934. 

  934.   protected function  o_fontDescendentCID($id, $action, $options = '') {
    935. 

  935.     if  ($action !== 'new') {
    936. 

  936.       $o = & $this->objects[$id];
    937. 

  937.     }
    938. 

  938. 

  939.     switch  ($action) {
    940. 

  940.     case  'new':
    941. 

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

  942. 

  943.       // we need a CID system info section
    944. 

  944.       $cidSystemInfoId = ++$this->numObj;
    945. 

  945.       $this->o_contents($cidSystemInfoId, 'new', 'raw');
    946. 

  946.       $this->objects[$id]['info']['cidSystemInfo'] = $cidSystemInfoId;
    947. 

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

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

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

  950.       $res.=  ">>";
    951. 

  951.       $this->objects[$cidSystemInfoId]['c'] = $res;
    952. 

  952. 

  953.       // and a CID to GID map
    954. 

  954.       $cidToGidMapId = ++$this->numObj;
    955. 

  955.       $this->o_fontGIDtoCIDMap($cidToGidMapId, 'new', $options);
    956. 

  956.       $this->objects[$id]['info']['cidToGidMap'] = $cidToGidMapId;
    957. 

  957.       break;
    958. 

  958. 

  959.     case  'add':
    960. 

  960.       foreach ($options as  $k => $v) {
    961. 

  961.         switch  ($k) {
    962. 

  962.         case  'BaseFont':
    963. 

  963.           $o['info']['name'] =  $v;
    964. 

  964.           break;
    965. 

  965. 

  966.         case  'FirstChar':
    967. 

  967.         case  'LastChar':
    968. 

  968.         case  'MissingWidth':
    969. 

  969.         case  'FontDescriptor':
    970. 

  970.         case  'SubType':
    971. 

  971.           $this->addMessage('o_fontDescendentCID '.$k." : ".$v);
    972. 

  972.           $o['info'][$k] =  $v;
    973. 

  973.           break;
    974. 

  974.         }
    975. 

  975.       }
    976. 

  976. 

  977.       // pass values down to cid to gid map
    978. 

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

  979.       break;
    980. 

  980. 

  981.     case  'out':
    982. 

  982.       $res =  "\n".$id." 0 obj\n";
    983. 

  983.       $res.=  "<</Type /Font\n";
    984. 

  984.       $res.=  "/Subtype /CIDFontType2\n";
    985. 

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

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

  987. //      if  (isset($o['info']['FirstChar'])) {
    988. 

  988. //        $res.=  "/FirstChar ".$o['info']['FirstChar']."\n";
    989. 

  989. //      }
    990. 

  990. 

  991. //      if  (isset($o['info']['LastChar'])) {
    992. 

  992. //        $res.=  "/LastChar ".$o['info']['LastChar']."\n";
    993. 

  993. //      }
    994. 

  994.       if  (isset($o['info']['FontDescriptor'])) {
    995. 

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

  996.       }
    997. 

  997. 

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

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

  1000.       }
    1001. 

  1001. 

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

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

  1004.         $w = '';
    1005. 

  1005.         foreach ($cid_widths as $cid => $width) {
    1006. 

  1006.           $w .= $cid.' ['.$width.'] ';
    1007. 

  1007.         }
    1008. 

  1008.         $res.=  "/W [".$w."]\n";
    1009. 

  1009.       }
    1010. 

  1010. 

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

  1012.       $res.=  ">>\n";
    1013. 

  1013.       $res.=  "endobj";
    1014. 

  1014. 

  1015.       return  $res;
    1016. 

  1016.     }
    1017. 

  1017.   }
    1018. 

  1018.   
    1019. 

  1019. 

  1020.   /**
    1021. 

  1021.    * a font glyph to character map,  needed for unicode fonts
    1022. 

  1022.    */
    1023. 

  1023.   protected function  o_fontGIDtoCIDMap($id, $action, $options = '') {
    1024. 

  1024.     if  ($action !== 'new') {
    1025. 

  1025.       $o = & $this->objects[$id];
    1026. 

  1026.     }
    1027. 

  1027. 

  1028.     switch  ($action) {
    1029. 

  1029.     case  'new':
    1030. 

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

  1031.       break;
    1032. 

  1032. 

  1033.     case  'out':
    1034. 

  1034.       $res = "\n".$id." 0 obj\n";
    1035. 

  1035.       $tmp = $this->fonts[$o['info']['fontFileName']]['CIDtoGID'] = base64_decode($this->fonts[$o['info']['fontFileName']]['CIDtoGID']);
    1036. 

  1036.       $compressed = isset($this->fonts[$o['info']['fontFileName']]['CIDtoGID_Compressed']) &&
    1037. 

  1037.                     $this->fonts[$o['info']['fontFileName']]['CIDtoGID_Compressed'];
    1038. 

  1038. 

  1039.       if  (!$compressed && isset($o['raw'])) {
    1040. 

  1040.         $res.= $tmp;
    1041. 

  1041.       } else {
    1042. 

  1042.         $res.=  "<<";
    1043. 

  1043. 

  1044.         if  (!$compressed && function_exists('gzcompress') &&  $this->options['compression']) {
    1045. 

  1045.           // then implement ZLIB based compression on this content stream
    1046. 

  1046.           $compressed = true;
    1047. 

  1047.           $tmp =  gzcompress($tmp,  6);
    1048. 

  1048.         }
    1049. 

  1049.         if ($compressed) {
    1050. 

  1050.           $res.= "\n/Filter /FlateDecode";
    1051. 

  1051.         }
    1052. 

  1052. 

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

  1054.       }
    1055. 

  1055. 

  1056.       $res.= "\nendobj";
    1057. 

  1057.       return  $res;
    1058. 

  1058.     }
    1059. 

  1059.   }
    1060. 

  1060.   
    1061. 

  1061. 

  1062.   /**
    1063. 

  1063.    * the document procset, solves some problems with printing to old PS printers
    1064. 

  1064.    */
    1065. 

  1065.   protected function  o_procset($id, $action, $options = '') {
    1066. 

  1066.     if  ($action !== 'new') {
    1067. 

  1067.       $o = & $this->objects[$id];
    1068. 

  1068.     }
    1069. 

  1069. 

  1070.     switch  ($action) {
    1071. 

  1071.     case  'new':
    1072. 

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

  1073.       $this->o_pages($this->currentNode, 'procset', $id);
    1074. 

  1074.       $this->procsetObjectId = $id;
    1075. 

  1075.       break;
    1076. 

  1076. 

  1077.     case  'add':
    1078. 

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

  1079.       // obselete, the items are required for printing to some postscript printers
    1080. 

  1080.       switch  ($options) {
    1081. 

  1081.       case  'ImageB':
    1082. 

  1082.       case  'ImageC':
    1083. 

  1083.       case  'ImageI':
    1084. 

  1084.         $o['info'][$options] = 1;
    1085. 

  1085.         break;
    1086. 

  1086.       }
    1087. 

  1087.       break;
    1088. 

  1088. 

  1089.     case  'out':
    1090. 

  1090.       $res = "\n".$id." 0 obj\n[";
    1091. 

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

  1092.         $res.= '/'.$label.' ';
    1093. 

  1093.       }
    1094. 

  1094.       $res.= "]\nendobj";
    1095. 

  1095.       return  $res;
    1096. 

  1096.     }
    1097. 

  1097.   }
    1098. 

  1098. 

  1099. 

  1100.   /**
    1101. 

  1101.    * define the document information
    1102. 

  1102.    */
    1103. 

  1103.   protected function  o_info($id, $action, $options = '') {
    1104. 

  1104.     if  ($action !== 'new') {
    1105. 

  1105.       $o = & $this->objects[$id];
    1106. 

  1106.     }
    1107. 

  1107. 

  1108.     switch  ($action) {
    1109. 

  1109.     case  'new':
    1110. 

  1110.       $this->infoObject = $id;
    1111. 

  1111.       $date = 'D:'.@date('Ymd');
    1112. 

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

  1113.       break;
    1114. 

  1114.     case  'Title':
    1115. 

  1115.     case  'Author':
    1116. 

  1116.     case  'Subject':
    1117. 

  1117.     case  'Keywords':
    1118. 

  1118.     case  'Creator':
    1119. 

  1119.     case  'Producer':
    1120. 

  1120.     case  'CreationDate':
    1121. 

  1121.     case  'ModDate':
    1122. 

  1122.     case  'Trapped':
    1123. 

  1123.       $o['info'][$action] = $options;
    1124. 

  1124.       break;
    1125. 

  1125. 

  1126.     case  'out':
    1127. 

  1127.       if  ($this->encrypted) {
    1128. 

  1128.         $this->encryptInit($id);
    1129. 

  1129.       }
    1130. 

  1130. 

  1131.       $res = "\n".$id." 0 obj\n<<\n";
    1132. 

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

  1133.         $res.= '/'.$k.' (';
    1134. 

  1134.         // dates must be outputted as-is, without Unicode transformations
    1135. 

  1135.         $raw = ($k === 'CreationDate' || $k === 'ModDate');
    1136. 

  1136.         $c = $v;
    1137. 

  1137. 

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

  1139.           $c = $this->ARC4($c);
    1140. 

  1140.         }
    1141. 

  1141. 

  1142.         $res.= ($raw) ? $c : $this->filterText($c);
    1143. 

  1143.         $res.= ")\n";
    1144. 

  1144.       }
    1145. 

  1145. 

  1146.       $res.= ">>\nendobj";
    1147. 

  1147.       return  $res;
    1148. 

  1148.     }
    1149. 

  1149.   }
    1150. 

  1150. 

  1151. 

  1152.   /**
    1153. 

  1153.    * an action object, used to link to URLS initially
    1154. 

  1154.    */
    1155. 

  1155.   protected function  o_action($id, $action, $options = '') {
    1156. 

  1156.     if  ($action !== 'new') {
    1157. 

  1157.       $o = & $this->objects[$id];
    1158. 

  1158.     }
    1159. 

  1159. 

  1160.     switch  ($action) {
    1161. 

  1161.     case  'new':
    1162. 

  1162.       if  (is_array($options)) {
    1163. 

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

  1164.       } else {
    1165. 

  1165.         // then assume a URI action
    1166. 

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

  1167.       }
    1168. 

  1168.       break;
    1169. 

  1169. 

  1170.     case  'out':
    1171. 

  1171.       if  ($this->encrypted) {
    1172. 

  1172.         $this->encryptInit($id);
    1173. 

  1173.       }
    1174. 

  1174. 

  1175.       $res = "\n".$id." 0 obj\n<< /Type /Action";
    1176. 

  1176.       switch ($o['type']) {
    1177. 

  1177.       case  'ilink':
    1178. 

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

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

  1180.         break;
    1181. 

  1181. 

  1182.       case  'URI':
    1183. 

  1183.         $res.= "\n/S /URI\n/URI (";
    1184. 

  1184.         if  ($this->encrypted) {
    1185. 

  1185.           $res.= $this->filterText($this->ARC4($o['info']));
    1186. 

  1186.         } else {
    1187. 

  1187.           $res.= $this->filterText($o['info']);
    1188. 

  1188.         }
    1189. 

  1189. 

  1190.         $res.= ")";
    1191. 

  1191.         break;
    1192. 

  1192.       }
    1193. 

  1193. 

  1194.       $res.= "\n>>\nendobj";
    1195. 

  1195.       return  $res;
    1196. 

  1196.     }
    1197. 

  1197.   }
    1198. 

  1198. 

  1199. 

  1200.   /**
    1201. 

  1201.    * an annotation object, this will add an annotation to the current page.
    1202. 

  1202.    * initially will support just link annotations
    1203. 

  1203.    */
    1204. 

  1204.   protected function  o_annotation($id, $action, $options = '') {
    1205. 

  1205.     if  ($action !== 'new') {
    1206. 

  1206.       $o = & $this->objects[$id];
    1207. 

  1207.     }
    1208. 

  1208. 

  1209.     switch  ($action) {
    1210. 

  1210.     case  'new':
    1211. 

  1211.       // add the annotation to the current page
    1212. 

  1212.       $pageId =  $this->currentPage;
    1213. 

  1213.       $this->o_page($pageId, 'annot', $id);
    1214. 

  1214. 

  1215.       // and add the action object which is going to be required
    1216. 

  1216.       switch ($options['type']) {
    1217. 

  1217.       case  'link':
    1218. 

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

  1219.         $this->numObj++;
    1220. 

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

  1221.         $this->objects[$id]['info']['actionId'] = $this->numObj;
    1222. 

  1222.         break;
    1223. 

  1223. 

  1224.       case  'ilink':
    1225. 

  1225.         // this is to a named internal link
    1226. 

  1226.         $label =  $options['label'];
    1227. 

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

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

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

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

  1231.         break;
    1232. 

  1232.       }
    1233. 

  1233.       break;
    1234. 

  1234. 

  1235.     case  'out':
    1236. 

  1236.       $res = "\n".$id." 0 obj\n<< /Type /Annot";
    1237. 

  1237.       switch ($o['info']['type']) {
    1238. 

  1238.       case  'link':
    1239. 

  1239.       case  'ilink':
    1240. 

  1240.         $res.=  "\n/Subtype /Link";
    1241. 

  1241.         break;
    1242. 

  1242.       }
    1243. 

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

  1244.       $res.= "\n/Border [0 0 0]";
    1245. 

  1245.       $res.= "\n/H /I";
    1246. 

  1246.       $res.= "\n/Rect [ ";
    1247. 

  1247. 

  1248.       foreach($o['info']['rect'] as  $v) {
    1249. 

  1249.         $res.=  sprintf("%.4F ", $v);
    1250. 

  1250.       }
    1251. 

  1251. 

  1252.       $res.= "]";
    1253. 

  1253.       $res.= "\n>>\nendobj";
    1254. 

  1254.       return  $res;
    1255. 

  1255.     }
    1256. 

  1256.   }
    1257. 

  1257. 

  1258. 

  1259.   /**
    1260. 

  1260.    * a page object, it also creates a contents object to hold its contents
    1261. 

  1261.    */
    1262. 

  1262.   protected function  o_page($id, $action, $options = '') {
    1263. 

  1263.     if  ($action !== 'new') {
    1264. 

  1264.       $o = & $this->objects[$id];
    1265. 

  1265.     }
    1266. 

  1266. 

  1267.     switch  ($action) {
    1268. 

  1268.     case  'new':
    1269. 

  1269.       $this->numPages++;
    1270. 

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

  1271. 

  1272.       if  (is_array($options)) {
    1273. 

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

  1274.         $options['id'] = $id;
    1275. 

  1275.         $this->o_pages($this->currentNode, 'page', $options);
    1276. 

  1276.       } else {
    1277. 

  1277.         $this->o_pages($this->currentNode, 'page', $id);
    1278. 

  1278.       }
    1279. 

  1279. 

  1280.       $this->currentPage = $id;
    1281. 

  1281.       //make a contents object to go with this page
    1282. 

  1282.       $this->numObj++;
    1283. 

  1283.       $this->o_contents($this->numObj, 'new', $id);
    1284. 

  1284.       $this->currentContents = $this->numObj;
    1285. 

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

  1286.       $this->objects[$id]['info']['contents'][] = $this->numObj;
    1287. 

  1287. 

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

  1289.       foreach($this->addLooseObjects as  $oId=>$target) {
    1290. 

  1290.         if  ($target === 'all' || $match === $target) {
    1291. 

  1291.           $this->objects[$id]['info']['contents'][] = $oId;
    1292. 

  1292.         }
    1293. 

  1293.       }
    1294. 

  1294.       break;
    1295. 

  1295. 

  1296.     case  'content':
    1297. 

  1297.       $o['info']['contents'][] = $options;
    1298. 

  1298.       break;
    1299. 

  1299. 

  1300.     case  'annot':
    1301. 

  1301.       // add an annotation to this page
    1302. 

  1302.       if  (!isset($o['info']['annot'])) {
    1303. 

  1303.         $o['info']['annot'] = array();
    1304. 

  1304.       }
    1305. 

  1305. 

  1306.       // $options should contain the id of the annotation dictionary
    1307. 

  1307.       $o['info']['annot'][] = $options;
    1308. 

  1308.       break;
    1309. 

  1309. 

  1310.     case  'out':
    1311. 

  1311.       $res = "\n".$id." 0 obj\n<< /Type /Page";
    1312. 

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

  1313. 

  1314.       if  (isset($o['info']['annot'])) {
    1315. 

  1315.         $res.= "\n/Annots [";
    1316. 

  1316.         foreach($o['info']['annot'] as  $aId) {
    1317. 

  1317.           $res.= " ".$aId." 0 R";
    1318. 

  1318.         }
    1319. 

  1319.         $res.= " ]";
    1320. 

  1320.       }
    1321. 

  1321. 

  1322.       $count =  count($o['info']['contents']);
    1323. 

  1323.       if  ($count == 1) {
    1324. 

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

  1325.       } else  if  ($count>1) {
    1326. 

  1326.         $res.= "\n/Contents [\n";
    1327. 

  1327. 

  1328.         // reverse the page contents so added objects are below normal content
    1329. 

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

  1330.         // Back to normal now that I've got transparency working --Benj
    1331. 

  1331.         foreach ($o['info']['contents'] as  $cId) {
    1332. 

  1332.           $res.= $cId." 0 R\n";
    1333. 

  1333.         }
    1334. 

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

  1335.       }
    1336. 

  1336. 

  1337.       $res.= "\n>>\nendobj";
    1338. 

  1338.       return  $res;
    1339. 

  1339.     }
    1340. 

  1340.   }
    1341. 

  1341. 

  1342. 

  1343.   /**
    1344. 

  1344.    * the contents objects hold all of the content which appears on pages
    1345. 

  1345.    */
    1346. 

  1346.   protected function  o_contents($id, $action, $options = '') {
    1347. 

  1347.     if  ($action !== 'new') {
    1348. 

  1348.       $o = & $this->objects[$id];
    1349. 

  1349.     }
    1350. 

  1350. 

  1351.     switch  ($action) {
    1352. 

  1352.     case  'new':
    1353. 

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

  1354.       if  (mb_strlen($options, '8bit') &&  intval($options)) {
    1355. 

  1355.         // then this contents is the primary for a page
    1356. 

  1356.         $this->objects[$id]['onPage'] = $options;
    1357. 

  1357.       } else  if  ($options === 'raw') {
    1358. 

  1358.         // then this page contains some other type of system object
    1359. 

  1359.         $this->objects[$id]['raw'] = 1;
    1360. 

  1360.       }
    1361. 

  1361.       break;
    1362. 

  1362. 

  1363.     case  'add':
    1364. 

  1364.       // add more options to the decleration
    1365. 

  1365.       foreach ($options as  $k=>$v) {
    1366. 

  1366.         $o['info'][$k] = $v;
    1367. 

  1367.       }
    1368. 

  1368. 

  1369.     case  'out':
    1370. 

  1370.       $tmp = $o['c'];
    1371. 

  1371.       $res =  "\n".$id." 0 obj\n";
    1372. 

  1372. 

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

  1374.         $res.= $tmp;
    1375. 

  1375.       } else {
    1376. 

  1376.         $res.=  "<<";
    1377. 

  1377.         if  (function_exists('gzcompress') &&  $this->options['compression']) {
    1378. 

  1378.           // then implement ZLIB based compression on this content stream
    1379. 

  1379.           $res.= " /Filter /FlateDecode";
    1380. 

  1380.           $tmp =  gzcompress($tmp,  6);
    1381. 

  1381.         }
    1382. 

  1382. 

  1383.         if  ($this->encrypted) {
    1384. 

  1384.           $this->encryptInit($id);
    1385. 

  1385.           $tmp =  $this->ARC4($tmp);
    1386. 

  1386.         }
    1387. 

  1387. 

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

  1389.           $res.=  "\n/".$k.' '.$v;
    1390. 

  1390.         }
    1391. 

  1391. 

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

  1393.       }
    1394. 

  1394. 

  1395.       $res.= "\nendobj";
    1396. 

  1396.       return  $res;
    1397. 

  1397.     }
    1398. 

  1398.   }
    1399. 

  1399. 

  1400.   protected function  o_embedjs($id, $action, $code = '') {
    1401. 

  1401.     if  ($action !== 'new') {
    1402. 

  1402.       $o = & $this->objects[$id];
    1403. 

  1403.     }
    1404. 

  1404. 

  1405.     switch  ($action) {
    1406. 

  1406.     case  'new':
    1407. 

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

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

  1409.       ));
    1410. 

  1410.       break;
    1411. 

  1411. 

  1412.     case  'out':
    1413. 

  1413.       $res .= "\n".$id." 0 obj\n".'<< ';
    1414. 

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

  1415.         $res.=  "\n/".$k.' '.$v;
    1416. 

  1416.       }
    1417. 

  1417.       $res.= "\n>>\nendobj";
    1418. 

  1418.       return  $res;
    1419. 

  1419.     }
    1420. 

  1420.   }
    1421. 

  1421.   
    1422. 

  1422.   protected function  o_javascript($id, $action, $code = '') {
    1423. 

  1423.     if  ($action !== 'new') {
    1424. 

  1424.       $o = & $this->objects[$id];
    1425. 

  1425.     }
    1426. 

  1426. 

  1427.     switch  ($action) {
    1428. 

  1428.     case  'new':
    1429. 

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

  1430.         'S' => '/JavaScript',
    1431. 

  1431.         'JS' => '('.$this->filterText($code).')',
    1432. 

  1432.       ));
    1433. 

  1433.       break;
    1434. 

  1434. 

  1435.     case  'out':
    1436. 

  1436.       $res = "\n".$id." 0 obj\n".'<< ';
    1437. 

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

  1438.         $res.=  "\n/".$k.' '.$v;
    1439. 

  1439.       }
    1440. 

  1440.       $res.= "\n>>\nendobj";
    1441. 

  1441.       return  $res;
    1442. 

  1442.     }
    1443. 

  1443.   }
    1444. 

  1444. 

  1445.   /**
    1446. 

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

  1447.    */
    1448. 

  1448.   protected function  o_image($id, $action, $options = '') {
    1449. 

  1449.     if  ($action !== 'new') {
    1450. 

  1450.       $o = & $this->objects[$id];
    1451. 

  1451.     }
    1452. 

  1452. 

  1453.     switch ($action) {
    1454. 

  1454.     case  'new':
    1455. 

  1455.       // make the new object
    1456. 

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

  1457.       $this->objects[$id]['info']['Type'] = '/XObject';
    1458. 

  1458.       $this->objects[$id]['info']['Subtype'] = '/Image';
    1459. 

  1459.       $this->objects[$id]['info']['Width'] = $options['iw'];
    1460. 

  1460.       $this->objects[$id]['info']['Height'] = $options['ih'];
    1461. 

  1461. 

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

  1463.         if  (!isset($options['channels'])) {
    1464. 

  1464.           $options['channels'] = 3;
    1465. 

  1465.         }
    1466. 

  1466. 

  1467.         switch ($options['channels']) {
    1468. 

  1468.         case  1:
    1469. 

  1469.           $this->objects[$id]['info']['ColorSpace'] = '/DeviceGray';
    1470. 

  1470.           break;
    1471. 

  1471. 

  1472.         default:
    1473. 

  1473.           $this->objects[$id]['info']['ColorSpace'] = '/DeviceRGB';
    1474. 

  1474.           break;
    1475. 

  1475.         }
    1476. 

  1476. 

  1477.         $this->objects[$id]['info']['Filter'] = '/DCTDecode';
    1478. 

  1478.         $this->objects[$id]['info']['BitsPerComponent'] = 8;
    1479. 

  1479.       } else  if  ($options['type'] === 'png') {
    1480. 

  1480.         $this->objects[$id]['info']['Filter'] = '/FlateDecode';
    1481. 

  1481.         $this->objects[$id]['info']['DecodeParms'] = '<< /Predictor 15 /Colors '.$options['ncolor'].' /Columns '.$options['iw'].' /BitsPerComponent '.$options['bitsPerComponent'].'>>';
    1482. 

  1482. 

  1483.         if  (mb_strlen($options['pdata'], '8bit')) {
    1484. 

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

  1485.           $this->numObj++;
    1486. 

  1486.           $this->o_contents($this->numObj, 'new');
    1487. 

  1487.           $this->objects[$this->numObj]['c'] = $options['pdata'];
    1488. 

  1488.           $tmp.= $this->numObj.' 0 R';
    1489. 

  1489.           $tmp.= ' ]';
    1490. 

  1490.           $this->objects[$id]['info']['ColorSpace'] =  $tmp;
    1491. 

  1491.           if  (isset($options['transparency'])) {
    1492. 

  1492.             switch ($options['transparency']['type']) {
    1493. 

  1493.             case  'indexed':
    1494. 

  1494.               $tmp = ' [ '.$options['transparency']['data'].' '.$options['transparency']['data'].'] ';
    1495. 

  1495.               $this->objects[$id]['info']['Mask'] =  $tmp;
    1496. 

  1496.               break;
    1497. 

  1497. 

  1498.             case 'color-key':
    1499. 

  1499.               $tmp = ' [ '.
    1500. 

  1500.                 $options['transparency']['r'] . ' ' . $options['transparency']['r'] .
    1501. 

  1501.                 $options['transparency']['g'] . ' ' . $options['transparency']['g'] .
    1502. 

  1502.                 $options['transparency']['b'] . ' ' . $options['transparency']['b'] .
    1503. 

  1503.                 ' ] ';
    1504. 

  1504.               $this->objects[$id]['info']['Mask'] = $tmp;
    1505. 

  1505.               pre_r($tmp);
    1506. 

  1506.               break;
    1507. 

  1507.               
    1508. 

  1508.             }
    1509. 

  1509.           }
    1510. 

  1510.         } else {
    1511. 

  1511.           if  (isset($options['transparency'])) {
    1512. 

  1512.             switch ($options['transparency']['type']) {
    1513. 

  1513.             case  'indexed':
    1514. 

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

  1515.               $this->objects[$id]['info']['Mask'] =  $tmp;
    1516. 

  1516.               break;
    1517. 

  1517. 

  1518.             case 'color-key':
    1519. 

  1519.               $tmp = ' [ '.
    1520. 

  1520.                 $options['transparency']['r'] . ' ' . $options['transparency']['r'] . ' ' .
    1521. 

  1521.                 $options['transparency']['g'] . ' ' . $options['transparency']['g'] . ' ' .
    1522. 

  1522.                 $options['transparency']['b'] . ' ' . $options['transparency']['b'] .
    1523. 

  1523.                 ' ] ';
    1524. 

  1524.               $this->objects[$id]['info']['Mask'] = $tmp;
    1525. 

  1525.               break;              
    1526. 

  1526.             }
    1527. 

  1527.           }
    1528. 

  1528.           $this->objects[$id]['info']['ColorSpace'] = '/'.$options['color'];
    1529. 

  1529.         }
    1530. 

  1530. 

  1531.         $this->objects[$id]['info']['BitsPerComponent'] = $options['bitsPerComponent'];
    1532. 

  1532.       }
    1533. 

  1533. 

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

  1535.       // the label passed in with it.
    1536. 

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

  1537. 

  1538.       // also make sure that we have the right procset object for it.
    1539. 

  1539.       $this->o_procset($this->procsetObjectId, 'add', 'ImageC');
    1540. 

  1540.       break;
    1541. 

  1541. 

  1542.     case  'out':
    1543. 

  1543.       $tmp = &$o['data'];
    1544. 

  1544.       $res =  "\n".$id." 0 obj\n<<";
    1545. 

  1545. 

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

  1547.         $res.= "\n/".$k.' '.$v;
    1548. 

  1548.       }
    1549. 

  1549. 

  1550.       if  ($this->encrypted) {
    1551. 

  1551.         $this->encryptInit($id);
    1552. 

  1552.         $tmp =  $this->ARC4($tmp);
    1553. 

  1553.       }
    1554. 

  1554. 

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

  1556. 

  1557.       return  $res;
    1558. 

  1558.     }
    1559. 

  1559.   }
    1560. 

  1560. 

  1561. 

  1562.   /**
    1563. 

  1563.    * graphics state object
    1564. 

  1564.    */
    1565. 

  1565.   protected function  o_extGState($id,  $action,  $options = "") {
    1566. 

  1566.     static  $valid_params =  array("LW",  "LC",  "LC",  "LJ",  "ML",
    1567. 

  1567.                                    "D",  "RI",  "OP",  "op",  "OPM",
    1568. 

  1568.                                    "Font",  "BG",  "BG2",  "UCR",
    1569. 

  1569.                                    "TR",  "TR2",  "HT",  "FL",
    1570. 

  1570.                                    "SM",  "SA",  "BM",  "SMask",
    1571. 

  1571.                                    "CA",  "ca",  "AIS",  "TK");
    1572. 

  1572. 

  1573.     if  ($action !==  "new") {
    1574. 

  1574.       $o = & $this->objects[$id];
    1575. 

  1575.     }
    1576. 

  1576. 

  1577.     switch  ($action) {
    1578. 

  1578.     case  "new":
    1579. 

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

  1580. 

  1581.       // Tell the pages about the new resource
    1582. 

  1582.       $this->numStates++;
    1583. 

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

  1584.       break;
    1585. 

  1585. 

  1586.     case  "out":
    1587. 

  1587.       $res =
    1588. 

  1588.         "\n" . $id . " 0 obj\n".
    1589. 

  1589.         "<< /Type /ExtGState\n";
    1590. 

  1590. 

  1591.       foreach ($o["info"] as  $parameter => $value) {
    1592. 

  1592.         if  ( !in_array($parameter,  $valid_params))
    1593. 

  1593.           continue;
    1594. 

  1594.         $res.=  "/$parameter $value\n";
    1595. 

  1595.       }
    1596. 

  1596. 

  1597.       $res.=
    1598. 

  1598.         ">>\n".
    1599. 

  1599.         "endobj";
    1600. 

  1600.       return  $res;
    1601. 

  1601.     }
    1602. 

  1602.   }
    1603. 

  1603. 

  1604. 

  1605.   /**
    1606. 

  1606.    * encryption object.
    1607. 

  1607.    */
    1608. 

  1608.   protected function  o_encryption($id, $action, $options = '') {
    1609. 

  1609.     if  ($action !== 'new') {
    1610. 

  1610.       $o = & $this->objects[$id];
    1611. 

  1611.     }
    1612. 

  1612. 

  1613.     switch ($action) {
    1614. 

  1614.     case  'new':
    1615. 

  1615.       // make the new object
    1616. 

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

  1617.       $this->arc4_objnum = $id;
    1618. 

  1618. 

  1619.       // figure out the additional paramaters required
    1620. 

  1620.       $pad =  chr(0x28) .chr(0xBF) .chr(0x4E) .chr(0x5E) .chr(0x4E) .chr(0x75) .chr(0x8A) .chr(0x41) .chr(0x64) .chr(0x00) .chr(0x4E) .chr(0x56) .chr(0xFF) .chr(0xFA) .chr(0x01) .chr(0x08) .chr(0x2E) .chr(0x2E) .chr(0x00) .chr(0xB6) .chr(0xD0) .chr(0x68) .chr(0x3E) .chr(0x80) .chr(0x2F) .chr(0x0C) .chr(0xA9) .chr(0xFE) .chr(0x64) .chr(0x53) .chr(0x69) .chr(0x7A);
    1621. 

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

  1622. 

  1623.       if  ($len>32) {
    1624. 

  1624.         $owner =  substr($options['owner'], 0, 32);
    1625. 

  1625.       } else  if  ($len<32) {
    1626. 

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

  1627.       } else {
    1628. 

  1628.         $owner =  $options['owner'];
    1629. 

  1629.       }
    1630. 

  1630. 

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

  1632.       if  ($len>32) {
    1633. 

  1633.         $user =  substr($options['user'], 0, 32);
    1634. 

  1634.       } else  if  ($len<32) {
    1635. 

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

  1636.       } else {
    1637. 

  1637.         $user =  $options['user'];
    1638. 

  1638.       }
    1639. 

  1639. 

  1640.       $tmp =  $this->md5_16($owner);
    1641. 

  1641.       $okey =  substr($tmp, 0, 5);
    1642. 

  1642.       $this->ARC4_init($okey);
    1643. 

  1643.       $ovalue = $this->ARC4($user);
    1644. 

  1644.       $this->objects[$id]['info']['O'] = $ovalue;
    1645. 

  1645. 

  1646.       // now make the u value, phew.
    1647. 

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

  1648. 

  1649.       $ukey =  substr($tmp, 0, 5);
    1650. 

  1650.       $this->ARC4_init($ukey);
    1651. 

  1651.       $this->encryptionKey =  $ukey;
    1652. 

  1652.       $this->encrypted = 1;
    1653. 

  1653.       $uvalue = $this->ARC4($pad);
    1654. 

  1654.       $this->objects[$id]['info']['U'] = $uvalue;
    1655. 

  1655.       $this->encryptionKey = $ukey;
    1656. 

  1656.       // initialize the arc4 array
    1657. 

  1657.       break;
    1658. 

  1658. 

  1659.     case  'out':
    1660. 

  1660.       $res =  "\n".$id." 0 obj\n<<";
    1661. 

  1661.       $res.= "\n/Filter /Standard";
    1662. 

  1662.       $res.= "\n/V 1";
    1663. 

  1663.       $res.= "\n/R 2";
    1664. 

  1664.       $res.= "\n/O (".$…
    1665.

Large files files are truncated, but you can click here to view the full file