PageRenderTime 78ms CodeModel.GetById 26ms RepoModel.GetById 0ms app.codeStats 1ms

/library/classes/class.pdf.php

https://bitbucket.org/DenizYldrm/openemr
PHP | 3088 lines | 2179 code | 170 blank | 739 comment | 394 complexity | 4d3201419558d62a7a758d609f573604 MD5 | raw file
Possible License(s): AGPL-1.0, GPL-2.0, MPL-2.0, LGPL-2.1 
    

  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 they companion class CezPdf can be used to extend this class and dramatically
    11. 

  11. * simplify the creation of documents.
    12. 

  12. *
    13. 

  13. * IMPORTANT NOTE
    14. 

  14. * there is no warranty, implied or otherwise with this software.
    15. 

  15. *
    16. 

  16. * LICENCE
    17. 

  17. * This code has been placed in the Public Domain for all to enjoy.
    18. 

  18. *
    19. 

  19. * @author		Wayne Munro <pdf@ros.co.nz>
    20. 

  20. * @version 	009
    21. 

  21. * @package	Cpdf
    22. 

  22. */
    23. 

  23. class Cpdf {
    24. 

  24. 

  25. /**
    26. 

  26. * the current number of pdf objects in the document
    27. 

  27. */
    28. 

  28. var $numObj=0;
    29. 

  29. /**
    30. 

  30. * this array contains all of the pdf objects, ready for final assembly
    31. 

  31. */
    32. 

  32. var $objects = array();
    33. 

  33. /**
    34. 

  34. * the objectId (number within the objects array) of the document catalog
    35. 

  35. */
    36. 

  36. var $catalogId;
    37. 

  37. /**
    38. 

  38. * array carrying information about the fonts that the system currently knows about
    39. 

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

  40. */
    41. 

  41. var $fonts=array();
    42. 

  42. /**
    43. 

  43. * a record of the current font
    44. 

  44. */
    45. 

  45. var $currentFont='';
    46. 

  46. /**
    47. 

  47. * the current base font
    48. 

  48. */
    49. 

  49. var $currentBaseFont='';
    50. 

  50. /**
    51. 

  51. * the number of the current font within the font array
    52. 

  52. */
    53. 

  53. var $currentFontNum=0;
    54. 

  54. /**
    55. 

  55. *
    56. 

  56. */
    57. 

  57. var $currentNode;
    58. 

  58. /**
    59. 

  59. * object number of the current page
    60. 

  60. */
    61. 

  61. var $currentPage;
    62. 

  62. /**
    63. 

  63. * object number of the currently active contents block
    64. 

  64. */
    65. 

  65. var $currentContents;
    66. 

  66. /**
    67. 

  67. * number of fonts within the system
    68. 

  68. */
    69. 

  69. var $numFonts=0;
    70. 

  70. /**
    71. 

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

  72. */
    73. 

  73. var $currentColour=array('r'=>-1,'g'=>-1,'b'=>-1);
    74. 

  74. /**
    75. 

  75. * current colour for stroke operations (lines etc.)
    76. 

  76. */
    77. 

  77. var $currentStrokeColour=array('r'=>-1,'g'=>-1,'b'=>-1);
    78. 

  78. /**
    79. 

  79. * current style that lines are drawn in
    80. 

  80. */
    81. 

  81. var $currentLineStyle='';
    82. 

  82. /**
    83. 

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

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

  85. */
    86. 

  86. var $stateStack = array();
    87. 

  87. /**
    88. 

  88. * number of elements within the state stack
    89. 

  89. */
    90. 

  90. var $nStateStack = 0;
    91. 

  91. /**
    92. 

  92. * number of page objects within the document
    93. 

  93. */
    94. 

  94. var $numPages=0;
    95. 

  95. /**
    96. 

  96. * object Id storage stack
    97. 

  97. */
    98. 

  98. var $stack=array();
    99. 

  99. /**
    100. 

  100. * number of elements within the object Id storage stack
    101. 

  101. */
    102. 

  102. var $nStack=0;
    103. 

  103. /**
    104. 

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

  105. * these have been added with the addObject function
    106. 

  106. */
    107. 

  107. var $looseObjects=array();
    108. 

  108. /**
    109. 

  109. * array contains infomation about how the loose objects are to be added to the document
    110. 

  110. */
    111. 

  111. var $addLooseObjects=array();
    112. 

  112. /**
    113. 

  113. * the objectId of the information object for the document
    114. 

  114. * this contains authorship, title etc.
    115. 

  115. */
    116. 

  116. var $infoObject=0;
    117. 

  117. /**
    118. 

  118. * number of images being tracked within the document
    119. 

  119. */
    120. 

  120. var $numImages=0;
    121. 

  121. /**
    122. 

  122. * an array containing options about the document
    123. 

  123. * it defaults to turning on the compression of the objects
    124. 

  124. */
    125. 

  125. var $options=array('compression'=>1);
    126. 

  126. /**
    127. 

  127. * the objectId of the first page of the document
    128. 

  128. */
    129. 

  129. var $firstPageId;
    130. 

  130. /**
    131. 

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

  132. * when the spacing is changed.
    133. 

  133. */
    134. 

  134. var $wordSpaceAdjust=0;
    135. 

  135. /**
    136. 

  136. * the object Id of the procset object
    137. 

  137. */
    138. 

  138. var $procsetObjectId;
    139. 

  139. /**
    140. 

  140. * store the information about the relationship between font families
    141. 

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

  142. * the value of this array is initialised in the constuctor function.
    143. 

  143. */
    144. 

  144. var $fontFamilies = array();
    145. 

  145. /**
    146. 

  146. * track if the current font is bolded or italicised
    147. 

  147. */
    148. 

  148. var $currentTextState = '';
    149. 

  149. /**
    150. 

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

  151. */
    152. 

  152. var $messages='';
    153. 

  153. /**
    154. 

  154. * the ancryption array for the document encryption is stored here
    155. 

  155. */
    156. 

  156. var $arc4='';
    157. 

  157. /**
    158. 

  158. * the object Id of the encryption information
    159. 

  159. */
    160. 

  160. var $arc4_objnum=0;
    161. 

  161. /**
    162. 

  162. * the file identifier, used to uniquely identify a pdf document
    163. 

  163. */
    164. 

  164. var $fileIdentifier='';
    165. 

  165. /**
    166. 

  166. * a flag to say if a document is to be encrypted or not
    167. 

  167. */
    168. 

  168. var $encrypted=0;
    169. 

  169. /**
    170. 

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

  171. */
    172. 

  172. var $encryptionKey='';
    173. 

  173. /**
    174. 

  174. * array which forms a stack to keep track of nested callback functions
    175. 

  175. */
    176. 

  176. var $callback = array();
    177. 

  177. /**
    178. 

  178. * the number of callback functions in the callback array
    179. 

  179. */
    180. 

  180. var $nCallback = 0;
    181. 

  181. /**
    182. 

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

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

  184. */
    185. 

  185. var $destinations = array();
    186. 

  186. /**
    187. 

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

  188. * variables within the class, so that the user can rollback at will (from each 'start' command)
    189. 

  189. * note that this includes the objects array, so these can be large.
    190. 

  190. */
    191. 

  191. var $checkpoint = '';
    192. 

  192. /**
    193. 

  193. * class constructor
    194. 

  194. * this will start a new document
    195. 

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

  196. */
    197. 

  197. function Cpdf ($pageSize=array(0,0,612,792)){
    198. 

  198.   $this->newDocument($pageSize);
    199. 

  199. 

  200.   // also initialize the font families that are known about already
    201. 

  201.   $this->setFontFamily('init');
    202. 

  202. //  $this->fileIdentifier = md5('xxxxxxxx'.time());
    203. 

  203. 

  204. }
    205. 

  205. 

  206. /**
    207. 

  207. * Document object methods (internal use only)
    208. 

  208. *
    209. 

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

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

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

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

  213. *           'new' - create the object with the id $id
    214. 

  214. *           'out' - produce the output for the pdf object
    215. 

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

  216. *
    217. 

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

  218. * within the pdf 'file'.
    219. 

  219. */
    220. 

  220. 

  221. /**
    222. 

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

  223. */
    224. 

  224. function o_destination($id,$action,$options=''){
    225. 

  225.   if ($action!='new'){
    226. 

  226.     $o =& $this->objects[$id];
    227. 

  227.   }
    228. 

  228.   switch($action){
    229. 

  229.     case 'new':
    230. 

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

  231.       $tmp = '';
    232. 

  232.       switch ($options['type']){
    233. 

  233.         case 'XYZ':
    234. 

  234.         case 'FitR':
    235. 

  235.           $tmp =  ' '.$options['p3'].$tmp;
    236. 

  236.         case 'FitH':
    237. 

  237.         case 'FitV':
    238. 

  238.         case 'FitBH':
    239. 

  239.         case 'FitBV':
    240. 

  240.           $tmp =  ' '.$options['p1'].' '.$options['p2'].$tmp;
    241. 

  241.         case 'Fit':
    242. 

  242.         case 'FitB':
    243. 

  243.           $tmp =  $options['type'].$tmp;
    244. 

  244.           $this->objects[$id]['info']['string']=$tmp;
    245. 

  245.           $this->objects[$id]['info']['page']=$options['page'];
    246. 

  246.       }
    247. 

  247.       break;
    248. 

  248.     case 'out':
    249. 

  249.       $tmp = $o['info'];
    250. 

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

  251.       return $res;
    252. 

  252.       break;
    253. 

  253.   }
    254. 

  254. }
    255. 

  255. 

  256. /**
    257. 

  257. * set the viewer preferences
    258. 

  258. */
    259. 

  259. function o_viewerPreferences($id,$action,$options=''){
    260. 

  260.   if ($action!='new'){
    261. 

  261.     $o =& $this->objects[$id];
    262. 

  262.   }
    263. 

  263.   switch ($action){
    264. 

  264.     case 'new':
    265. 

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

  266.       break;
    267. 

  267.     case 'add':
    268. 

  268.       foreach($options as $k=>$v){
    269. 

  269.         switch ($k){
    270. 

  270.           case 'HideToolbar':
    271. 

  271.           case 'HideMenubar':
    272. 

  272.           case 'HideWindowUI':
    273. 

  273.           case 'FitWindow':
    274. 

  274.           case 'CenterWindow':
    275. 

  275.           case 'NonFullScreenPageMode':
    276. 

  276.           case 'Direction':
    277. 

  277.             $o['info'][$k]=$v;
    278. 

  278.           break;
    279. 

  279.         }
    280. 

  280.       }
    281. 

  281.       break;
    282. 

  282.     case 'out':
    283. 

  283. 

  284.       $res="\n".$id." 0 obj\n".'<< ';
    285. 

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

  286.         $res.="\n/".$k.' '.$v;
    287. 

  287.       }
    288. 

  288.       $res.="\n>>\n";
    289. 

  289.       return $res;
    290. 

  290.       break;
    291. 

  291.   }
    292. 

  292. }
    293. 

  293. 

  294. /**
    295. 

  295. * define the document catalog, the overall controller for the document
    296. 

  296. */
    297. 

  297. function o_catalog($id,$action,$options=''){
    298. 

  298.   if ($action!='new'){
    299. 

  299.     $o =& $this->objects[$id];
    300. 

  300.   }
    301. 

  301.   switch ($action){
    302. 

  302.     case 'new':
    303. 

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

  304.       $this->catalogId=$id;
    305. 

  305.       break;
    306. 

  306.     case 'outlines':
    307. 

  307.     case 'pages':
    308. 

  308.     case 'openHere':
    309. 

  309.       $o['info'][$action]=$options;
    310. 

  310.       break;
    311. 

  311.     case 'viewerPreferences':
    312. 

  312.       if (!isset($o['info']['viewerPreferences'])){
    313. 

  313.         $this->numObj++;
    314. 

  314.         $this->o_viewerPreferences($this->numObj,'new');
    315. 

  315.         $o['info']['viewerPreferences']=$this->numObj;
    316. 

  316.       }
    317. 

  317.       $vp = $o['info']['viewerPreferences'];
    318. 

  318.       $this->o_viewerPreferences($vp,'add',$options);
    319. 

  319.       break;
    320. 

  320.     case 'out':
    321. 

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

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

  323.         switch($k){
    324. 

  324.           case 'outlines':
    325. 

  325.             $res.="\n".'/Outlines '.$v.' 0 R';
    326. 

  326.             break;
    327. 

  327.           case 'pages':
    328. 

  328.             $res.="\n".'/Pages '.$v.' 0 R';
    329. 

  329.             break;
    330. 

  330.           case 'viewerPreferences':
    331. 

  331.             $res.="\n".'/ViewerPreferences '.$o['info']['viewerPreferences'].' 0 R';
    332. 

  332.             break;
    333. 

  333.           case 'openHere':
    334. 

  334.             $res.="\n".'/OpenAction '.$o['info']['openHere'].' 0 R';
    335. 

  335.             break;
    336. 

  336.         }
    337. 

  337.       }
    338. 

  338.       $res.=" >>\nendobj";
    339. 

  339.       return $res;
    340. 

  340.       break;
    341. 

  341.   }
    342. 

  342. }
    343. 

  343. 

  344. /**
    345. 

  345. * object which is a parent to the pages in the document
    346. 

  346. */
    347. 

  347. function o_pages($id,$action,$options=''){
    348. 

  348.   if ($action!='new'){
    349. 

  349.     $o =& $this->objects[$id];
    350. 

  350.   }
    351. 

  351.   switch ($action){
    352. 

  352.     case 'new':
    353. 

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

  354.       $this->o_catalog($this->catalogId,'pages',$id);
    355. 

  355.       break;
    356. 

  356.     case 'page':
    357. 

  357.       if (!is_array($options)){
    358. 

  358.         // then it will just be the id of the new page
    359. 

  359.         $o['info']['pages'][]=$options;
    360. 

  360.       } else {
    361. 

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

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

  363.         if (isset($options['id']) && isset($options['rid']) && isset($options['pos'])){
    364. 

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

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

  366.             // then there is a match
    367. 

  367.             // make a space
    368. 

  368.             switch ($options['pos']){
    369. 

  369.               case 'before':
    370. 

  370.                 $k = $i;
    371. 

  371.                 break;
    372. 

  372.               case 'after':
    373. 

  373.                 $k=$i+1;
    374. 

  374.                 break;
    375. 

  375.               default:
    376. 

  376.                 $k=-1;
    377. 

  377.                 break;
    378. 

  378.             }
    379. 

  379.             if ($k>=0){
    380. 

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

  381.                 $o['info']['pages'][$j+1]=$o['info']['pages'][$j];
    382. 

  382.               }
    383. 

  383.               $o['info']['pages'][$k]=$options['id'];
    384. 

  384.             }
    385. 

  385.           }
    386. 

  386.         }
    387. 

  387.       }
    388. 

  388.       break;
    389. 

  389.     case 'procset':
    390. 

  390.       $o['info']['procset']=$options;
    391. 

  391.       break;
    392. 

  392.     case 'mediaBox':
    393. 

  393.       $o['info']['mediaBox']=$options; // which should be an array of 4 numbers
    394. 

  394.       break;
    395. 

  395.     case 'font':
    396. 

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

  397.       break;
    398. 

  398.     case 'xObject':
    399. 

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

  400.       break;
    401. 

  401.     case 'out':
    402. 

  402.       if (count($o['info']['pages'])){
    403. 

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

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

  405.           $res.=$v." 0 R\n";
    406. 

  406.         }
    407. 

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

  408.         if ((isset($o['info']['fonts']) && count($o['info']['fonts'])) || isset($o['info']['procset'])){
    409. 

  409.           $res.="\n/Resources <<";
    410. 

  410.           if (isset($o['info']['procset'])){
    411. 

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

  412.           }
    413. 

  413.           if (isset($o['info']['fonts']) && count($o['info']['fonts'])){
    414. 

  414.             $res.="\n/Font << ";
    415. 

  415.             foreach($o['info']['fonts'] as $finfo){
    416. 

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

  417.             }
    418. 

  418.             $res.=" >>";
    419. 

  419.           }
    420. 

  420.           if (isset($o['info']['xObjects']) && count($o['info']['xObjects'])){
    421. 

  421.             $res.="\n/XObject << ";
    422. 

  422.             foreach($o['info']['xObjects'] as $finfo){
    423. 

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

  424.             }
    425. 

  425.             $res.=" >>";
    426. 

  426.           }
    427. 

  427.           $res.="\n>>";
    428. 

  428.           if (isset($o['info']['mediaBox'])){
    429. 

  429.             $tmp=$o['info']['mediaBox'];
    430. 

  430.             $res.="\n/MediaBox [".sprintf('%.3f',$tmp[0]).' '.sprintf('%.3f',$tmp[1]).' '.sprintf('%.3f',$tmp[2]).' '.sprintf('%.3f',$tmp[3]).']';
    431. 

  431.           }
    432. 

  432.         }
    433. 

  433.         $res.="\n >>\nendobj";
    434. 

  434.       } else {
    435. 

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

  436.       }
    437. 

  437.       return $res;
    438. 

  438.     break;
    439. 

  439.   }
    440. 

  440. }
    441. 

  441. 

  442. /**
    443. 

  443. * define the outlines in the doc, empty for now
    444. 

  444. */
    445. 

  445. function o_outlines($id,$action,$options=''){
    446. 

  446.   if ($action!='new'){
    447. 

  447.     $o =& $this->objects[$id];
    448. 

  448.   }
    449. 

  449.   switch ($action){
    450. 

  450.     case 'new':
    451. 

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

  452.       $this->o_catalog($this->catalogId,'outlines',$id);
    453. 

  453.       break;
    454. 

  454.     case 'outline':
    455. 

  455.       $o['info']['outlines'][]=$options;
    456. 

  456.       break;
    457. 

  457.     case 'out':
    458. 

  458.       if (count($o['info']['outlines'])){
    459. 

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

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

  461.           $res.=$v." 0 R ";
    462. 

  462.         }
    463. 

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

  464.       } else {
    465. 

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

  466.       }
    467. 

  467.       return $res;
    468. 

  468.       break;
    469. 

  469.   }
    470. 

  470. }
    471. 

  471. 

  472. /**
    473. 

  473. * an object to hold the font description
    474. 

  474. */
    475. 

  475. function o_font($id,$action,$options=''){
    476. 

  476.   if ($action!='new'){
    477. 

  477.     $o =& $this->objects[$id];
    478. 

  478.   }
    479. 

  479.   switch ($action){
    480. 

  480.     case 'new':
    481. 

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

  482.       $fontNum=$this->numFonts;
    483. 

  483.       $this->objects[$id]['info']['fontNum']=$fontNum;
    484. 

  484.       // deal with the encoding and the differences
    485. 

  485.       if (isset($options['differences'])){
    486. 

  486.         // then we'll need an encoding dictionary
    487. 

  487.         $this->numObj++;
    488. 

  488.         $this->o_fontEncoding($this->numObj,'new',$options);
    489. 

  489.         $this->objects[$id]['info']['encodingDictionary']=$this->numObj;
    490. 

  490.       } else if (isset($options['encoding'])){
    491. 

  491.         // we can specify encoding here
    492. 

  492.         switch($options['encoding']){
    493. 

  493.           case 'WinAnsiEncoding':
    494. 

  494.           case 'MacRomanEncoding':
    495. 

  495.           case 'MacExpertEncoding':
    496. 

  496.             $this->objects[$id]['info']['encoding']=$options['encoding'];
    497. 

  497.             break;
    498. 

  498.           case 'none':
    499. 

  499.             break;
    500. 

  500.           default:
    501. 

  501.             $this->objects[$id]['info']['encoding']='WinAnsiEncoding';
    502. 

  502.             break;
    503. 

  503.         }
    504. 

  504.       } else {
    505. 

  505.         $this->objects[$id]['info']['encoding']='WinAnsiEncoding';
    506. 

  506.       }
    507. 

  507.       // also tell the pages node about the new font
    508. 

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

  509.       break;
    510. 

  510.     case 'add':
    511. 

  511.       foreach ($options as $k=>$v){
    512. 

  512.         switch ($k){
    513. 

  513.           case 'BaseFont':
    514. 

  514.             $o['info']['name'] = $v;
    515. 

  515.             break;
    516. 

  516.           case 'FirstChar':
    517. 

  517.           case 'LastChar':
    518. 

  518.           case 'Widths':
    519. 

  519.           case 'FontDescriptor':
    520. 

  520.           case 'SubType':
    521. 

  521.           $this->addMessage('o_font '.$k." : ".$v);
    522. 

  522.             $o['info'][$k] = $v;
    523. 

  523.             break;
    524. 

  524.         }
    525. 

  525.      }
    526. 

  526.       break;
    527. 

  527.     case 'out':
    528. 

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

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

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

  531.       if (isset($o['info']['encodingDictionary'])){
    532. 

  532.         // then place a reference to the dictionary
    533. 

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

  534.       } else if (isset($o['info']['encoding'])){
    535. 

  535.         // use the specified encoding
    536. 

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

  537.       }
    538. 

  538.       if (isset($o['info']['FirstChar'])){
    539. 

  539.         $res.="/FirstChar ".$o['info']['FirstChar']."\n";
    540. 

  540.       }
    541. 

  541.       if (isset($o['info']['LastChar'])){
    542. 

  542.         $res.="/LastChar ".$o['info']['LastChar']."\n";
    543. 

  543.       }
    544. 

  544.       if (isset($o['info']['Widths'])){
    545. 

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

  546.       }
    547. 

  547.       if (isset($o['info']['FontDescriptor'])){
    548. 

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

  549.       }
    550. 

  550.       $res.=">>\nendobj";
    551. 

  551.       return $res;
    552. 

  552.       break;
    553. 

  553.   }
    554. 

  554. }
    555. 

  555. 

  556. /**
    557. 

  557. * a font descriptor, needed for including additional fonts
    558. 

  558. */
    559. 

  559. function o_fontDescriptor($id,$action,$options=''){
    560. 

  560.   if ($action!='new'){
    561. 

  561.     $o =& $this->objects[$id];
    562. 

  562.   }
    563. 

  563.   switch ($action){
    564. 

  564.     case 'new':
    565. 

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

  566.       break;
    567. 

  567.     case 'out':
    568. 

  568.       $res="\n".$id." 0 obj\n<< /Type /FontDescriptor\n";
    569. 

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

  570.         switch ($label){
    571. 

  571.           case 'Ascent':
    572. 

  572.           case 'CapHeight':
    573. 

  573.           case 'Descent':
    574. 

  574.           case 'Flags':
    575. 

  575.           case 'ItalicAngle':
    576. 

  576.           case 'StemV':
    577. 

  577.           case 'AvgWidth':
    578. 

  578.           case 'Leading':
    579. 

  579.           case 'MaxWidth':
    580. 

  580.           case 'MissingWidth':
    581. 

  581.           case 'StemH':
    582. 

  582.           case 'XHeight':
    583. 

  583.           case 'CharSet':
    584. 

  584.             if (strlen($value)){
    585. 

  585.               $res.='/'.$label.' '.$value."\n";
    586. 

  586.             }
    587. 

  587.             break;
    588. 

  588.           case 'FontFile':
    589. 

  589.           case 'FontFile2':
    590. 

  590.           case 'FontFile3':
    591. 

  591.             $res.='/'.$label.' '.$value." 0 R\n";
    592. 

  592.             break;
    593. 

  593.           case 'FontBBox':
    594. 

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

  595.             break;
    596. 

  596.           case 'FontName':
    597. 

  597.             $res.='/'.$label.' /'.$value."\n";
    598. 

  598.             break;
    599. 

  599.         }
    600. 

  600.       }
    601. 

  601.       $res.=">>\nendobj";
    602. 

  602.       return $res;
    603. 

  603.       break;
    604. 

  604.   }
    605. 

  605. }
    606. 

  606. 

  607. /**
    608. 

  608. * the font encoding
    609. 

  609. */
    610. 

  610. function o_fontEncoding($id,$action,$options=''){
    611. 

  611.   if ($action!='new'){
    612. 

  612.     $o =& $this->objects[$id];
    613. 

  613.   }
    614. 

  614.   switch ($action){
    615. 

  615.     case 'new':
    616. 

  616.       // the options array should contain 'differences' and maybe 'encoding'
    617. 

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

  618.       break;
    619. 

  619.     case 'out':
    620. 

  620.       $res="\n".$id." 0 obj\n<< /Type /Encoding\n";
    621. 

  621.       if (!isset($o['info']['encoding'])){
    622. 

  622.         $o['info']['encoding']='WinAnsiEncoding';
    623. 

  623.       }
    624. 

  624.       if ($o['info']['encoding']!='none'){
    625. 

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

  626.       }
    627. 

  627.       $res.="/Differences \n[";
    628. 

  628.       $onum=-100;
    629. 

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

  630.         if ($num!=$onum+1){
    631. 

  631.           // we cannot make use of consecutive numbering
    632. 

  632.           $res.= "\n".$num." /".$label;
    633. 

  633.         } else {
    634. 

  634.           $res.= " /".$label;
    635. 

  635.         }
    636. 

  636.         $onum=$num;
    637. 

  637.       }
    638. 

  638.       $res.="\n]\n>>\nendobj";
    639. 

  639.       return $res;
    640. 

  640.       break;
    641. 

  641.   }
    642. 

  642. }
    643. 

  643. 

  644. /**
    645. 

  645. * the document procset, solves some problems with printing to old PS printers
    646. 

  646. */
    647. 

  647. function o_procset($id,$action,$options=''){
    648. 

  648.   if ($action!='new'){
    649. 

  649.     $o =& $this->objects[$id];
    650. 

  650.   }
    651. 

  651.   switch ($action){
    652. 

  652.     case 'new':
    653. 

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

  654.       $this->o_pages($this->currentNode,'procset',$id);
    655. 

  655.       $this->procsetObjectId=$id;
    656. 

  656.       break;
    657. 

  657.     case 'add':
    658. 

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

  659.       // obselete, the items are required for printing to some postscript printers
    660. 

  660.       switch ($options) {
    661. 

  661.         case 'ImageB':
    662. 

  662.         case 'ImageC':
    663. 

  663.         case 'ImageI':
    664. 

  664.           $o['info'][$options]=1;
    665. 

  665.           break;
    666. 

  666.       }
    667. 

  667.       break;
    668. 

  668.     case 'out':
    669. 

  669.       $res="\n".$id." 0 obj\n[";
    670. 

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

  671.         $res.='/'.$label.' ';
    672. 

  672.       }
    673. 

  673.       $res.="]\nendobj";
    674. 

  674.       return $res;
    675. 

  675.       break;
    676. 

  676.   }
    677. 

  677. }
    678. 

  678. 

  679. /**
    680. 

  680. * define the document information
    681. 

  681. */
    682. 

  682. function o_info($id,$action,$options=''){
    683. 

  683.   if ($action!='new'){
    684. 

  684.     $o =& $this->objects[$id];
    685. 

  685.   }
    686. 

  686.   switch ($action){
    687. 

  687.     case 'new':
    688. 

  688.       $this->infoObject=$id;
    689. 

  689.       $date='D:'.date('Ymd');
    690. 

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

  691.       break;
    692. 

  692.     case 'Title':
    693. 

  693.     case 'Author':
    694. 

  694.     case 'Subject':
    695. 

  695.     case 'Keywords':
    696. 

  696.     case 'Creator':
    697. 

  697.     case 'Producer':
    698. 

  698.     case 'CreationDate':
    699. 

  699.     case 'ModDate':
    700. 

  700.     case 'Trapped':
    701. 

  701.       $o['info'][$action]=$options;
    702. 

  702.       break;
    703. 

  703.     case 'out':
    704. 

  704.       if ($this->encrypted){
    705. 

  705.         $this->encryptInit($id);
    706. 

  706.       }
    707. 

  707.       $res="\n".$id." 0 obj\n<<\n";
    708. 

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

  709.         $res.='/'.$k.' (';
    710. 

  710.         if ($this->encrypted){
    711. 

  711.           $res.=$this->filterText($this->ARC4($v));
    712. 

  712.         } else {
    713. 

  713.           $res.=$this->filterText($v);
    714. 

  714.         }
    715. 

  715.         $res.=")\n";
    716. 

  716.       }
    717. 

  717.       $res.=">>\nendobj";
    718. 

  718.       return $res;
    719. 

  719.       break;
    720. 

  720.   }
    721. 

  721. }
    722. 

  722. 

  723. /**
    724. 

  724. * an action object, used to link to URLS initially
    725. 

  725. */
    726. 

  726. function o_action($id,$action,$options=''){
    727. 

  727.   if ($action!='new'){
    728. 

  728.     $o =& $this->objects[$id];
    729. 

  729.   }
    730. 

  730.   switch ($action){
    731. 

  731.     case 'new':
    732. 

  732.       if (is_array($options)){
    733. 

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

  734.       } else {
    735. 

  735.         // then assume a URI action
    736. 

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

  737.       }
    738. 

  738.       break;
    739. 

  739.     case 'out':
    740. 

  740.       if ($this->encrypted){
    741. 

  741.         $this->encryptInit($id);
    742. 

  742.       }
    743. 

  743.       $res="\n".$id." 0 obj\n<< /Type /Action";
    744. 

  744.       switch($o['type']){
    745. 

  745.         case 'ilink':
    746. 

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

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

  748.           break;
    749. 

  749.         case 'URI':
    750. 

  750.           $res.="\n/S /URI\n/URI (";
    751. 

  751.           if ($this->encrypted){
    752. 

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

  753.           } else {
    754. 

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

  755.           }
    756. 

  756.           $res.=")";
    757. 

  757.           break;
    758. 

  758.       }
    759. 

  759.       $res.="\n>>\nendobj";
    760. 

  760.       return $res;
    761. 

  761.       break;
    762. 

  762.   }
    763. 

  763. }
    764. 

  764. 

  765. /**
    766. 

  766. * an annotation object, this will add an annotation to the current page.
    767. 

  767. * initially will support just link annotations
    768. 

  768. */
    769. 

  769. function o_annotation($id,$action,$options=''){
    770. 

  770.   if ($action!='new'){
    771. 

  771.     $o =& $this->objects[$id];
    772. 

  772.   }
    773. 

  773.   switch ($action){
    774. 

  774.     case 'new':
    775. 

  775.       // add the annotation to the current page
    776. 

  776.       $pageId = $this->currentPage;
    777. 

  777.       $this->o_page($pageId,'annot',$id);
    778. 

  778.       // and add the action object which is going to be required
    779. 

  779.       switch($options['type']){
    780. 

  780.         case 'link':
    781. 

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

  782.           $this->numObj++;
    783. 

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

  784.           $this->objects[$id]['info']['actionId']=$this->numObj;
    785. 

  785.           break;
    786. 

  786.         case 'ilink':
    787. 

  787.           // this is to a named internal link
    788. 

  788.           $label = $options['label'];
    789. 

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

  790.           $this->numObj++;
    791. 

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

  792.           $this->objects[$id]['info']['actionId']=$this->numObj;
    793. 

  793.           break;
    794. 

  794.       }
    795. 

  795.       break;
    796. 

  796.     case 'out':
    797. 

  797.       $res="\n".$id." 0 obj\n<< /Type /Annot";
    798. 

  798.       switch($o['info']['type']){
    799. 

  799.         case 'link':
    800. 

  800.         case 'ilink':
    801. 

  801.           $res.= "\n/Subtype /Link";
    802. 

  802.           break;
    803. 

  803.       }
    804. 

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

  805.       $res.="\n/Border [0 0 0]";
    806. 

  806.       $res.="\n/H /I";
    807. 

  807.       $res.="\n/Rect [ ";
    808. 

  808.       foreach($o['info']['rect'] as $v){
    809. 

  809.         $res.= sprintf("%.4f ",$v);
    810. 

  810.       }
    811. 

  811.       $res.="]";
    812. 

  812.       $res.="\n>>\nendobj";
    813. 

  813.       return $res;
    814. 

  814.       break;
    815. 

  815.   }
    816. 

  816. }
    817. 

  817. 

  818. /**
    819. 

  819. * a page object, it also creates a contents object to hold its contents
    820. 

  820. */
    821. 

  821. function o_page($id,$action,$options=''){
    822. 

  822.   if ($action!='new'){
    823. 

  823.     $o =& $this->objects[$id];
    824. 

  824.   }
    825. 

  825.   switch ($action){
    826. 

  826.     case 'new':
    827. 

  827.       $this->numPages++;
    828. 

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

  829.       if (is_array($options)){
    830. 

  830.         // then this must be a page insertion, array shoudl contain 'rid','pos'=[before|after]
    831. 

  831.         $options['id']=$id;
    832. 

  832.         $this->o_pages($this->currentNode,'page',$options);
    833. 

  833.       } else {
    834. 

  834.         $this->o_pages($this->currentNode,'page',$id);
    835. 

  835.       }
    836. 

  836.       $this->currentPage=$id;
    837. 

  837.       //make a contents object to go with this page
    838. 

  838.       $this->numObj++;
    839. 

  839.       $this->o_contents($this->numObj,'new',$id);
    840. 

  840.       $this->currentContents=$this->numObj;
    841. 

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

  842.       $this->objects[$id]['info']['contents'][]=$this->numObj;
    843. 

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

  844.       foreach($this->addLooseObjects as $oId=>$target){
    845. 

  845.         if ($target=='all' || $match==$target){
    846. 

  846.           $this->objects[$id]['info']['contents'][]=$oId;
    847. 

  847.         }
    848. 

  848.       }
    849. 

  849.       break;
    850. 

  850.     case 'content':
    851. 

  851.       $o['info']['contents'][]=$options;
    852. 

  852.       break;
    853. 

  853.     case 'annot':
    854. 

  854.       // add an annotation to this page
    855. 

  855.       if (!isset($o['info']['annot'])){
    856. 

  856.         $o['info']['annot']=array();
    857. 

  857.       }
    858. 

  858.       // $options should contain the id of the annotation dictionary
    859. 

  859.       $o['info']['annot'][]=$options;
    860. 

  860.       break;
    861. 

  861.     case 'out':
    862. 

  862.       $res="\n".$id." 0 obj\n<< /Type /Page";
    863. 

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

  864.       if (isset($o['info']['annot'])){
    865. 

  865.         $res.="\n/Annots [";
    866. 

  866.         foreach($o['info']['annot'] as $aId){
    867. 

  867.           $res.=" ".$aId." 0 R";
    868. 

  868.         }
    869. 

  869.         $res.=" ]";
    870. 

  870.       }
    871. 

  871.       $count = count($o['info']['contents']);
    872. 

  872.       if ($count==1){
    873. 

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

  874.       } else if ($count>1){
    875. 

  875.         $res.="\n/Contents [\n";
    876. 

  876.         foreach ($o['info']['contents'] as $cId){
    877. 

  877.           $res.=$cId." 0 R\n";
    878. 

  878.         }
    879. 

  879.         $res.="]";
    880. 

  880.       }
    881. 

  881.       $res.="\n>>\nendobj";
    882. 

  882.       return $res;
    883. 

  883.       break;
    884. 

  884.   }
    885. 

  885. }
    886. 

  886. 

  887. /**
    888. 

  888. * the contents objects hold all of the content which appears on pages
    889. 

  889. */
    890. 

  890. function o_contents($id,$action,$options=''){
    891. 

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

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

  893.   }
    894. 

  894.   switch ($action){
    895. 

  895.     case 'new':
    896. 

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

  897.       if (strlen($options) && intval($options)){
    898. 

  898.         // then this contents is the primary for a page
    899. 

  899.         $this->objects[$id]['onPage']=$options;
    900. 

  900.       } else if ($options=='raw'){
    901. 

  901.         // then this page contains some other type of system object
    902. 

  902.         $this->objects[$id]['raw']=1;
    903. 

  903.       }
    904. 

  904.       break;
    905. 

  905.     case 'add':
    906. 

  906.       // add more options to the decleration
    907. 

  907.       foreach ($options as $k=>$v){
    908. 

  908.         $o['info'][$k]=$v;
    909. 

  909.       }
    910. 

  910.     case 'out':
    911. 

  911.       $tmp=$o['c'];
    912. 

  912.       $res= "\n".$id." 0 obj\n";
    913. 

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

  914.         $res.=$tmp;
    915. 

  915.       } else {
    916. 

  916.         $res.= "<<";
    917. 

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

  918.           // then implement ZLIB based compression on this content stream
    919. 

  919.           $res.=" /Filter /FlateDecode";
    920. 

  920.           $tmp = gzcompress($tmp);
    921. 

  921.         }
    922. 

  922.         if ($this->encrypted){
    923. 

  923.           $this->encryptInit($id);
    924. 

  924.           $tmp = $this->ARC4($tmp);
    925. 

  925.         }
    926. 

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

  927.           $res .= "\n/".$k.' '.$v;
    928. 

  928.         }
    929. 

  929.         $res.="\n/Length ".strlen($tmp)." >>\nstream\n".$tmp."\nendstream";
    930. 

  930.       }
    931. 

  931.       $res.="\nendobj\n";
    932. 

  932.       return $res;
    933. 

  933.       break;
    934. 

  934.   }
    935. 

  935. }
    936. 

  936. 

  937. /**
    938. 

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

  939. */
    940. 

  940. function o_image($id,$action,$options=''){
    941. 

  941.   if ($action!='new'){
    942. 

  942.     $o =& $this->objects[$id];
    943. 

  943.   }
    944. 

  944.   switch($action){
    945. 

  945.     case 'new':
    946. 

  946.       // make the new object
    947. 

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

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

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

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

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

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

  953.         if (!isset($options['channels'])){
    954. 

  954.           $options['channels']=3;
    955. 

  955.         }
    956. 

  956.         switch($options['channels']){
    957. 

  957.           case 1:
    958. 

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

  959.             break;
    960. 

  960.           default:
    961. 

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

  962.             break;
    963. 

  963.         }
    964. 

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

  965.         $this->objects[$id]['info']['BitsPerComponent']=8;
    966. 

  966.       } else if ($options['type']=='png'){
    967. 

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

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

  969.         if (strlen($options['pdata'])){
    970. 

  970.           $tmp = ' [ /Indexed /DeviceRGB '.(strlen($options['pdata'])/3-1).' ';
    971. 

  971.           $this->numObj++;
    972. 

  972.           $this->o_contents($this->numObj,'new');
    973. 

  973.           $this->objects[$this->numObj]['c']=$options['pdata'];
    974. 

  974.           $tmp.=$this->numObj.' 0 R';
    975. 

  975.           $tmp .=' ]';
    976. 

  976.           $this->objects[$id]['info']['ColorSpace'] = $tmp;
    977. 

  977.           if (isset($options['transparency'])){
    978. 

  978.             switch($options['transparency']['type']){
    979. 

  979.               case 'indexed':
    980. 

  980.                 $tmp=' [ '.$options['transparency']['data'].' '.$options['transparency']['data'].'] ';
    981. 

  981.                 $this->objects[$id]['info']['Mask'] = $tmp;
    982. 

  982.                 break;
    983. 

  983.             }
    984. 

  984.           }
    985. 

  985.         } else {
    986. 

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

  987.         }
    988. 

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

  989.       }
    990. 

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

  991.       // the label passed in with it.
    992. 

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

  993.       // also make sure that we have the right procset object for it.
    994. 

  994.       $this->o_procset($this->procsetObjectId,'add','ImageC');
    995. 

  995.       break;
    996. 

  996.     case 'out':
    997. 

  997.       $tmp=$o['data'];
    998. 

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

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

  1000.         $res.="\n/".$k.' '.$v;
    1001. 

  1001.       }
    1002. 

  1002.       if ($this->encrypted){
    1003. 

  1003.         $this->encryptInit($id);
    1004. 

  1004.         $tmp = $this->ARC4($tmp);
    1005. 

  1005.       }
    1006. 

  1006.       $res.="\n/Length ".strlen($tmp)." >>\nstream\n".$tmp."\nendstream\nendobj\n";
    1007. 

  1007.       return $res;
    1008. 

  1008.       break;
    1009. 

  1009.   }
    1010. 

  1010. }
    1011. 

  1011. 

  1012. /**
    1013. 

  1013. * encryption object.
    1014. 

  1014. */
    1015. 

  1015. function o_encryption($id,$action,$options=''){
    1016. 

  1016.   if ($action!='new'){
    1017. 

  1017.     $o =& $this->objects[$id];
    1018. 

  1018.   }
    1019. 

  1019.   switch($action){
    1020. 

  1020.     case 'new':
    1021. 

  1021.       // make the new object
    1022. 

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

  1023.       $this->arc4_objnum=$id;
    1024. 

  1024.       // figure out the additional paramaters required
    1025. 

  1025.       $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);
    1026. 

  1026.       $len = strlen($options['owner']);
    1027. 

  1027.       if ($len>32){
    1028. 

  1028.         $owner = substr($options['owner'],0,32);
    1029. 

  1029.       } else if ($len<32){
    1030. 

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

  1031.       } else {
    1032. 

  1032.         $owner = $options['owner'];
    1033. 

  1033.       }
    1034. 

  1034.       $len = strlen($options['user']);
    1035. 

  1035.       if ($len>32){
    1036. 

  1036.         $user = substr($options['user'],0,32);
    1037. 

  1037.       } else if ($len<32){
    1038. 

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

  1039.       } else {
    1040. 

  1040.         $user = $options['user'];
    1041. 

  1041.       }
    1042. 

  1042.       $tmp = $this->md5_16($owner);
    1043. 

  1043.       $okey = substr($tmp,0,5);
    1044. 

  1044.       $this->ARC4_init($okey);
    1045. 

  1045.       $ovalue=$this->ARC4($user);
    1046. 

  1046.       $this->objects[$id]['info']['O']=$ovalue;
    1047. 

  1047.       // now make the u value, phew.
    1048. 

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

  1049.       $ukey = substr($tmp,0,5);
    1050. 

  1050. 

  1051.       $this->ARC4_init($ukey);
    1052. 

  1052.       $this->encryptionKey = $ukey;
    1053. 

  1053.       $this->encrypted=1;
    1054. 

  1054.       $uvalue=$this->ARC4($pad);
    1055. 

  1055. 

  1056.       $this->objects[$id]['info']['U']=$uvalue;
    1057. 

  1057.       $this->encryptionKey=$ukey;
    1058. 

  1058. 

  1059.       // initialize the arc4 array
    1060. 

  1060.       break;
    1061. 

  1061.     case 'out':
    1062. 

  1062.       $res= "\n".$id." 0 obj\n<<";
    1063. 

  1063.       $res.="\n/Filter /Standard";
    1064. 

  1064.       $res.="\n/V 1";
    1065. 

  1065.       $res.="\n/R 2";
    1066. 

  1066.       $res.="\n/O (".$this->filterText($o['info']['O']).')';
    1067. 

  1067.       $res.="\n/U (".$this->filterText($o['info']['U']).')';
    1068. 

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

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

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

  1071.       $res.="\n>>\nendobj\n";
    1072. 

  1072. 

  1073.       return $res;
    1074. 

  1074.       break;
    1075. 

  1075.   }
    1076. 

  1076. }
    1077. 

  1077. 

  1078. /**
    1079. 

  1079. * ARC4 functions
    1080. 

  1080. * A series of function to implement ARC4 encoding in PHP
    1081. 

  1081. */
    1082. 

  1082. 

  1083. /**
    1084. 

  1084. * calculate the 16 byte version of the 128 bit md5 digest of the string
    1085. 

  1085. */
    1086. 

  1086. function md5_16($string){
    1087. 

  1087.   $tmp = md5($string);
    1088. 

  1088.   $out='';
    1089. 

  1089.   for ($i=0;$i<=30;$i=$i+2){
    1090. 

  1090.     $out.=chr(hexdec(substr($tmp,$i,2)));
    1091. 

  1091.   }
    1092. 

  1092.   return $out;
    1093. 

  1093. }
    1094. 

  1094. 

  1095. /**
    1096. 

  1096. * initialize the encryption for processing a particular object
    1097. 

  1097. */
    1098. 

  1098. function encryptInit($id){
    1099. 

  1099.   $tmp = $this->encryptionKey;
    1100. 

  1100.   $hex = dechex($id);
    1101. 

  1101.   if (strlen($hex)<6){
    1102. 

  1102.     $hex = substr('000000',0,6-strlen($hex)).$hex;
    1103. 

  1103.   }
    1104. 

  1104.   $tmp.= chr(hexdec(substr($hex,4,2))).chr(hexdec(substr($hex,2,2))).chr(hexdec(substr($hex,0,2))).chr(0).chr(0);
    1105. 

  1105.   $key = $this->md5_16($tmp);
    1106. 

  1106.   $this->ARC4_init(substr($key,0,10));
    1107. 

  1107. }
    1108. 

  1108. 

  1109. /**
    1110. 

  1110. * initialize the ARC4 encryption
    1111. 

  1111. */
    1112. 

  1112. function ARC4_init($key=''){
    1113. 

  1113.   $this->arc4 = '';
    1114. 

  1114.   // setup the control array
    1115. 

  1115.   if (strlen($key)==0){
    1116. 

  1116.     return;
    1117. 

  1117.   }
    1118. 

  1118.   $k = '';
    1119. 

  1119.   while(strlen($k)<256){
    1120. 

  1120.     $k.=$key;
    1121. 

  1121.   }
    1122. 

  1122.   $k=substr($k,0,256);
    1123. 

  1123.   for ($i=0;$i<256;$i++){
    1124. 

  1124.     $this->arc4 .= chr($i);
    1125. 

  1125.   }
    1126. 

  1126.   $j=0;
    1127. 

  1127.   for ($i=0;$i<256;$i++){
    1128. 

  1128.     $t = $this->arc4[$i];
    1129. 

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

  1130.     $this->arc4[$i]=$this->arc4[$j];
    1131. 

  1131.     $this->arc4[$j]=$t;
    1132. 

  1132.   }
    1133. 

  1133. }
    1134. 

  1134. 

  1135. /**
    1136. 

  1136. * ARC4 encrypt a text string
    1137. 

  1137. */
    1138. 

  1138. function ARC4($text){
    1139. 

  1139.   $len=strlen($text);
    1140. 

  1140.   $a=0;
    1141. 

  1141.   $b=0;
    1142. 

  1142.   $c = $this->arc4;
    1143. 

  1143.   $out='';
    1144. 

  1144.   for ($i=0;$i<$len;$i++){
    1145. 

  1145.     $a = ($a+1)%256;
    1146. 

  1146.     $t= $c[$a];
    1147. 

  1147.     $b = ($b+ord($t))%256;
    1148. 

  1148.     $c[$a]=$c[$b];
    1149. 

  1149.     $c[$b]=$t;
    1150. 

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

  1151.     $out.=chr(ord($text[$i]) ^ $k);
    1152. 

  1152.   }
    1153. 

  1153. 

  1154.   return $out;
    1155. 

  1155. }
    1156. 

  1156. 

  1157. /**
    1158. 

  1158. * functions which can be called to adjust or add to the document
    1159. 

  1159. */
    1160. 

  1160. 

  1161. /**
    1162. 

  1162. * add a link in the document to an external URL
    1163. 

  1163. */
    1164. 

  1164. function addLink($url,$x0,$y0,$x1,$y1){
    1165. 

  1165.   $this->numObj++;
    1166. 

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

  1167.   $this->o_annotation($this->numObj,'new',$info);
    1168. 

  1168. }
    1169. 

  1169. 

  1170. /**
    1171. 

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

  1172. */
    1173. 

  1173. function addInternalLink($label,$x0,$y0,$x1,$y1){
    1174. 

  1174.   $this->numObj++;
    1175. 

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

  1176.   $this->o_annotation($this->numObj,'new',$info);
    1177. 

  1177. }
    1178. 

  1178. 

  1179. /**
    1180. 

  1180. * set the encryption of the document
    1181. 

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

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

  1183. */
    1184. 

  1184. function setEncryption($userPass='',$ownerPass='',$pc=array()){
    1185. 

  1185.   $p=bindec(11000000);
    1186. 

  1186. 

  1187.   $options = array(
    1188. 

  1188.      'print'=>4
    1189. 

  1189.     ,'modify'=>8
    1190. 

  1190.     ,'copy'=>16
    1191. 

  1191.     ,'add'=>32
    1192. 

  1192.   );
    1193. 

  1193.   foreach($pc as $k=>$v){
    1194. 

  1194.     if ($v && isset($options[$k])){
    1195. 

  1195.       $p+=$options[$k];
    1196. 

  1196.     } else if (isset($options[$v])){
    1197. 

  1197.       $p+=$options[$v];
    1198. 

  1198.     }
    1199. 

  1199.   }
    1200. 

  1200.   // implement encryption on the document
    1201. 

  1201.   if ($this->arc4_objnum == 0){
    1202. 

  1202.     // then the block does not exist already, add it.
    1203. 

  1203.     $this->numObj++;
    1204. 

  1204.     if (strlen($ownerPass)==0){
    1205. 

  1205.       $ownerPass=$userPass;
    1206. 

  1206.     }
    1207. 

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

  1208.   }
    1209. 

  1209. }
    1210. 

  1210. 

  1211. /**
    1212. 

  1212. * should be used for internal checks, not implemented as yet
    1213. 

  1213. */
    1214. 

  1214. function checkAllHere(){
    1215. 

  1215. }
    1216. 

  1216. 

  1217. /**
    1218. 

  1218. * return the pdf stream as a string returned from the function
    1219. 

  1219. */
    1220. 

  1220. function output($debug=0){
    1221. 

  1221. 

  1222.   if ($debug){
    1223. 

  1223.     // turn compression off
    1224. 

  1224.     $this->options['compression']=0;
    1225. 

  1225.   }
    1226. 

  1226. 

  1227.   if ($this->arc4_objnum){
    1228. 

  1228.     $this->ARC4_init($this->encryptionKey);
    1229. 

  1229.   }
    1230. 

  1230. 

  1231.   $this->checkAllHere();
    1232. 

  1232. 

  1233.   $xref=array();
    1234. 

  1234.   $content="%PDF-1.3\n%��\n";
    1235. 

  1235. //  $content="%PDF-1.3\n";
    1236. 

  1236.   $pos=strlen($content);
    1237. 

  1237.   foreach($this->objects as $k=>$v){
    1238. 

  1238.     $tmp='o_'.$v['t'];
    1239. 

  1239.     $cont=$this->$tmp($k,'out');
    1240. 

  1240.     $content.=$cont;
    1241. 

  1241.     $xref[]=$pos;
    1242. 

  1242.     $pos+=strlen($cont);
    1243. 

  1243.   }
    1244. 

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

  1245.   foreach($xref as $p){
    1246. 

  1246.     $content.=substr('0000000000',0,10-strlen($p)).$p." 00000 n \n";
    1247. 

  1247.   }
    1248. 

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

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

  1250.   if ($this->arc4_objnum > 0){
    1251. 

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

  1252.   }
    1253. 

  1253.   if (strlen($this->fileIdentifier)){
    1254. 

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

  1255.   }
    1256. 

  1256.   $content .= "  >>\nstartxref\n".$pos."\n%%EOF\n";
    1257. 

  1257.   return $content;
    1258. 

  1258. }
    1259. 

  1259. 

  1260. /**
    1261. 

  1261. * intialize a new document
    1262. 

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

  1263. * this function is called automatically by the constructor function
    1264. 

  1264. *
    1265. 

  1265. * @access private
    1266. 

  1266. */
    1267. 

  1267. function newDocument($pageSize=array(0,0,612,792)){
    1268. 

  1268.   $this->numObj=0;
    1269. 

  1269.   $this->objects = array();
    1270. 

  1270. 

  1271.   $this->numObj++;
    1272. 

  1272.   $this->o_catalog($this->numObj,'new');
    1273. 

  1273. 

  1274.   $this->numObj++;
    1275. 

  1275.   $this->o_outlines($this->numObj,'new');
    1276. 

  1276. 

  1277.   $this->numObj++;
    1278. 

  1278.   $this->o_pages($this->numObj,'new');
    1279. 

  1279. 

  1280.   $this->o_pages($this->numObj,'mediaBox',$pageSize);
    1281. 

  1281.   $this->currentNode = 3;
    1282. 

  1282. 

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

  1284.   $this->o_procset($this->numObj,'new');
    1285. 

  1285. 

  1286.   $this->numObj++;
    1287. 

  1287.   $this->o_info($this->numObj,'new');
    1288. 

  1288. 

  1289.   $this->numObj++;
    1290. 

  1290.   $this->o_page($this->numObj,'new');
    1291. 

  1291. 

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

  1293.   // startup
    1294. 

  1294.   $this->firstPageId = $this->currentContents;
    1295. 

  1295. }
    1296. 

  1296. 

  1297. /**
    1298. 

  1298. * open the font file and return a php structure containing it.
    1299. 

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

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

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

  1302. * files.
    1303. 

  1303. *
    1304. 

  1304. * @access private
    1305. 

  1305. */
    1306. 

  1306. function openFont($font){
    1307. 

  1307.   // assume that $font contains both the path and perhaps the extension to the file, split them
    1308. 

  1308.   $pos=strrpos($font,'/');
    1309. 

  1309.   if ($pos===false){
    1310. 

  1310.     $dir = './';
    1311. 

  1311.     $name = $font;
    1312. 

  1312.   } else {
    1313. 

  1313.     $dir=substr($font,0,$pos+1);
    1314. 

  1314.     $name=substr($font,$pos+1);
    1315. 

  1315.   }
    1316. 

  1316. 

  1317.   if (substr($name,-4)=='.afm'){
    1318. 

  1318.     $name=substr($name,0,strlen($name)-4);
    1319. 

  1319.   }
    1320. 

  1320.   $this->addMessage('openFont: '.$font.' - '.$name);
    1321. 

  1321.   if (file_exists($dir.'php_'.$name.'.afm')){
    1322. 

  1322.     $this->addMessage('openFont: php file exists '.$dir.'php_'.$name.'.afm');
    1323. 

  1323.     $tmp = file($dir.'php_'.$name.'.afm');
    1324. 

  1324.     $this->fonts[$font]=unserialize($tmp[0]);
    1325. 

  1325.     if (!isset($this->fonts[$font]['_version_']) || $this->fonts[$font]['_version_']<1){
    1326. 

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

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

  1328.       unset($this->fonts[$font]);
    1329. 

  1329.     }
    1330. 

  1330.   }
    1331. 

  1331.   if (!isset($this->fonts[$font]) && file_exists($dir.$name.'.afm')){
    1332. 

  1332.     // then rebuild the php_<font>.afm file from the <font>.afm file
    1333. 

  1333.     $this->addMessage('openFont: build php file from '.$dir.$name.'.afm');
    1334. 

  1334.     $data = array();
    1335. 

  1335.     $file = file($dir.$name.'.afm');
    1336. 

  1336.     foreach ($file as $rowA){
    1337. 

  1337.       $row=trim($rowA);
    1338. 

  1338.       $pos=strpos($row,' ');
    1339. 

  1339.       if ($pos){
    1340. 

  1340.         // then there must be some keyword
    1341. 

  1341.         $key = substr($row,0,$pos);
    1342. 

  1342.         switch ($key){
    1343. 

  1343.           case 'FontName':
    1344. 

  1344.           case 'FullName':
    1345. 

  1345.           case 'FamilyName':
    1346. 

  1346.           case 'Weight':
    1347. 

  1347.           case 'ItalicAngle':
    1348. 

  1348.           case 'IsFixedPitch':
    1349. 

  1349.           case 'CharacterSet':
    1350. 

  1350.           case 'UnderlinePosition':
    1351. 

  1351.           case 'UnderlineThickness':
    1352. 

  1352.           case 'Version':
    1353. 

  1353.           case 'EncodingScheme':
    1354. 

  1354.           case 'CapHeight':
    1355. 

  1355.           case 'XHeight':
    1356. 

  1356.           case 'Ascender':
    1357. 

  1357.           case 'Descender':
    1358. 

  1358.           case 'StdHW':
    1359. 

  1359.           case 'StdVW':
    1360. 

  1360.           case 'StartCharMetrics':
    1361. 

  1361.             $data[$key]=trim(substr($row,$pos));
    1362. 

  1362.             break;
    1363. 

  1363.           case 'FontBBox':
    1364. 

  1364.             $data[$key]=explode(' ',trim(substr($row,$pos)));
    1365. 

  1365.             break;
    1366. 

  1366.           case 'C':
    1367. 

  1367.             //C 39 ; WX 222 ; N quoteright ; B 53 463 157 718 ;
    1368. 

  1368.             $bits=explode(';',trim($row));
    1369. 

  1369.             $dtmp=array();
    1370. 

  1370.             foreach($bits as $bit){
    1371. 

  1371.               $bits2 = explode(' ',trim($bit));
    1372. 

  1372.               if (strlen($bits2[0])){
    1373. 

  1373.                 if (count($bits2)>2){
    1374. 

  1374.                   $dtmp[$bits2[0]]=array();
    1375. 

  1375.                   for ($i=1;$i<count($bits2);$i++){
    1376. 

  1376.                     $dtmp[$bits2[0]][]=$bits2[$i];
    1377. 

  1377.                   }
    1378. 

  1378.                 } else if (count($bits2)==2){
    1379. 

  1379.                   $dtmp[$bits2[0]]=$bits2[1];
    1380. 

  1380.                 }
    1381. 

  1381.               }
    1382. 

  1382.             }
    1383. 

  1383.             if ($dtmp['C']>=0){
    1384. 

  1384.               $data['C'][$dtmp['C']]=$dtmp;
    1385. 

  1385.               $data['C'][$dtmp['N']]=$dtmp;
    1386. 

  1386.             } else {
    1387. 

  1387.               $data['C'][$dtmp['N']]=$dtmp;
    1388. 

  1388.             }
    1389. 

  1389.             break;
    1390. 

  1390.           case 'KPX':
    1391. 

  1391.             //KPX Adieresis yacute -40
    1392. 

  1392.             $bits=explode(' ',trim($row));
    1393. 

  1393.             $data['KPX'][$bits[1]][$bits[2]]=$bits[3];
    1394. 

  1394.             break;
    1395. 

  1395.         }
    1396. 

  1396.       }
    1397. 

  1397.     }
    1398. 

  1398.     $data['_version_']=1;
    1399. 

  1399.     $this->fonts[$font]=$data;
    1400. 

  1400.     touch($dir.'php_'.$name.'.afm'); // php bug
    1401. 

  1401.     $fp = fopen($dir.'php_'.$name.'.afm','w');
    1402. 

  1402.     fwrite($fp,serialize($data));
    1403. 

  1403.     fclose($fp);
    1404. 

  1404.   } else if (!isset($this->fonts[$font])){
    1405. 

  1405.     $this->addMessage('openFont: no font file found');
    1406. 

  1406. //    echo 'Font not Found '.$font;
    1407. 

  1407.   }
    1408. 

  1408. }
    1409. 

  1409. 

  1410. /**
    1411. 

  1411. * if the font is not loaded then load it and make the required object
    1412. 

  1412. * else just make it the current font
    1413. 

  1413. * the encoding array can contain 'encoding'=> 'none','WinAnsiEncoding','MacRomanEncoding' or 'MacExpertEncoding'
    1414. 

  1414. * note that encoding='none' will need to be used for symbolic fonts
    1415. 

  1415. * and 'differences' => an array of mappings between numbers 0->255 and character names.
    1416. 

  1416. *
    1417. 

  1417. */
    1418. 

  1418. function selectFont($fontName,$encoding='',$set=1){
    1419. 

  1419.   if (!isset($this->fonts[$fontName])){
    1420. 

  1420.     // load the file
    1421. 

  1421.     $this->openFont($fontName);
    1422. 

  1422.     if (isset($this->fonts[$fontName])){
    1423. 

  1423.       $this->numObj++;
    1424. 

  1424.       $this->numFonts++;
    1425. 

  1425.       $pos=strrpos($fontName,'/');
    1426. 

  1426. //      $dir=substr($fontName,0,$pos+1);
    1427. 

  1427.       $name=substr($fontName,$pos+1);
    1428. 

  1428.       if (substr($name,-4)=='.afm'){
    1429. 

  1429.         $name=substr($name,0,strlen($name)-4);
    1430. 

  1430.       }
    1431. 

  1431.       $options=array('name'=>$name);
    1432. 

  1432.       if (is_array($encoding)){
    1433. 

  1433.         // then encoding and differences might be set
    1434. 

  1434.         if (isset($encoding['encoding'])){
    1435. 

  1435.           $options['encoding']=$encoding['encoding'];
    1436. 

  1436.         }
    1437. 

  1437.         if (isset($encoding['differences'])){
    1438. 

  1438.           $options['differences']=$encoding['differences'];
    1439. 

  1439.         }
    1440. 

  1440.       } else if (strlen($encoding)){
    1441. 

  1441.         // then perhaps only the encoding has been set
    1442. 

  1442.         $options['encoding']=$encoding;
    1443. 

  1443.       }
    1444. 

  1444.       $fontObj = $this->numObj;
    1445. 

  1445.       $this->o_font($this->numObj,'new',$options);
    1446. 

  1446.       $this->fonts[$fontName]['fontNum']=$this->numFonts;
    1447. 

  1447.       // if this is a '.afm' font, and there is a '.pfa' file to go with it ( as there
    1448. 

  1448.       // should be for all non-basic fonts), then load it into an object and put the
    1449. 

  1449.       // references into the font object
    1450. 

  1450.       $basefile = substr($fontName,0,strlen($fontName)-4);
    1451. 

  1451.       if (file_exists($basefile.'.pfb')){
    1452. 

  1452.         $fbtype = 'pfb';
    1453. 

  1453.       } else if (file_exists($basefile.'.ttf')){
    1454. 

  1454.         $fbtype = 'ttf';
    1455. 

  1455.       } else {
    1456. 

  1456.         $fbtype='';
    1457. 

  1457.       }
    1458. 

  1458.       $fbfile = $basefile.'.'.$fbtype;
    1459. 

  1459. 

  1460. //      $pfbfile = substr($fontName,0,strlen($fontName)-4).'.pfb';
    1461. 

  1461. //      $ttffile = substr($fontName,0,strlen($fontName)-4).'.ttf';
    1462. 

  1462.       $this->addMessage('selectFont: checking for - '.$fbfile);
    1463. 

  1463.       if (substr($fontName,-4)=='.afm' && strlen($fbtype) ){
    1464. 

  1464.         $adobeFontName = $this->fonts[$fontName]['FontName'];
    1465. 

  1465. //        $fontObj = $this->numObj;
    1466. 

  1466.         $this->addMessage('selectFont: adding font file - '.$fbfile.' - '.$adobeFontName);
    1467. 

  1467.         // find the array of fond widths, and put that into an object.
    1468. 

  1468.         $firstChar = -1;
    1469. 

  1469.         $lastChar = 0;
    1470. 

  1470.         $widths = array();
    1471. 

  1471.         foreach ($this->fonts[$fontName]['C'] as $num=>$d){
    1472. 

  1472.           if (intval($num)>0 || $num=='0'){
    1473. 

  1473.             if ($lastChar>0 && $num>$lastChar+1){
    1474. 

  1474.               for($i=$lastChar+1;$i<$num;$i++){
    1475. 

  1475.                 $widths[] = 0;
    1476. 

  1476.               }
    1477. 

  1477.             }
    1478. 

  1478.             $widths[] = $d['WX'];
    1479. 

  1479.             if ($firstChar==-1){
    1480. 

  1480.               $firstChar = $num;
    1481. 

  1481.             }
    1482. 

  1482.             $lastChar = $num;
    1483. 

  1483.           }
    1484. 

  1484.         }
    1485. 

  1485.         // also need to adjust the widths for the differences array
    1486. 

  1486.         if (isset($options['differences'])){
    1487. 

  1487.           foreach($options['differences'] as $charNum=>$charName){
    1488. 

  1488.             if ($charNum>$lastChar){
    1489. 

  1489.               for($i=$lastChar+1;$i<=$charNum;$i++){
    1490. 

  1490.                 $widths[]=0;
    1491. 

  1491.               }
    1492. 

  1492.               $lastChar=$charNum;
    1493. 

  1493.             }
    1494. 

  1494.             if (isset($this->fonts[$fontName]['C'][$charName])){
    1495. 

  1495.               $widths[$charNum-$firstChar]=$this->fonts[$fontName]['C'][$charName]['WX'];
    1496. 

  1496.             }
    1497. 

  1497.           }
    1498. 

  1498.         }
    1499. 

  1499.         $this->addMessage('selectFont: FirstChar='.$firstChar);
    1500. 

  1500.         $this->addMessage('selectFont: LastChar='.$lastChar);
    1501. 

  1501.         $this->numObj++;
    1502. 

  1502.         $this->o_contents($this->numObj,'new','raw');
    1503. 

  1503.         $this->objects[$this->numObj]['c'].='[';
    1504. 

  1504.         foreach($widths as $width){
    1505. 

  1505.           $this->objects[$this->numObj]['c'].=' '.$width;
    1506. 

  1506.         }
    1507. 

  1507.         $this->objects[$this->numObj]['c'].=' ]';
    1508. 

  1508.         $widthid = $this->numObj;
    1509. 

  1509. 

  1510.         // load the pfb file, and put that into an object too.
    1511. 

  1511.         // note that pdf supports only binary format type 1 font files, though there is a
    1512. 

  1512.         // simple utility to convert them from pfa to pfb.
    1513. 

  1513.         $fp = fopen($fbfile,'rb');
    1514. 

  1514.         $tmp = get_magic_quotes_runtime();
    1515. 

  1515.         set_magic_quotes_runtime(0);
    1516. 

  1516.         $data = fread($fp,filesize($fbfile));
    1517. 

  1517.         set_magic_quotes_runtime($tmp);
    1518. 

  1518.         fclose($fp);
    1519. 

  1519. 

  1520.         // create the font descriptor
    1521. 

  1521.         $this->numObj++;
    1522. 

  1522.         $fontDescriptorId = $this->numObj;
    1523. 

  1523.         $this->numObj++;
    1524. 

  1524.         $pfbid = $this->numObj;
    1525. 

  1525.         // determine flags (more than a little flakey, hopefully will not matter much)
    1526. 

  1526.         $flags=0;
    1527. 

  1527.         if ($this->fonts[$fontName]['ItalicAngle']!=0){ $flags+=pow(2,6); }
    1528. 

  1528.         if ($this->fonts[$fontName]['IsFixedPitch']=='true'){ $flags+=1; }
    1529. 

  1529.         $flags+=pow(2,5); // assume non-sybolic
    1530. 

  1530. 

  1531.         $list = array('Ascent'=>'Ascender','CapHeight'=>'CapHeight','Descent'=>'Descender','FontBBox'=>'FontBBox','ItalicAngle'=>'ItalicAngle');
    1532. 

  1532.         $fdopt = array(
    1533. 

  1533.          'Flags'=>$flags
    1534. 

  1534.          ,'FontName'=>$adobeFontName
    1535. 

  1535.          ,'StemV'=>100  // don't know what the value for this should be!
    1536. 

  1536.         );
    1537. 

  1537.         foreach($list as $k=>$v){
    1538. 

  1538.           if (isset($this->fonts[$fontName][$v])){
    1539. 

  1539.             $fdopt[$k]=$this->fonts[$fontName][$v];
    1540. 

  1540.           }
    1541. 

  1541.         }
    1542. 

  1542. 

  1543.         if ($fbtype=='pfb'){
    1544. 

  1544.           $fdopt['FontFile']=$pfbid;
    1545. 

  1545.         } else if ($fbtype=='ttf'){
    1546. 

  1546.           $fdopt['FontFile2']=$pfbid;
    1547. 

  1547.         }
    1548. 

  1548.         $this->o_fontDescriptor($fontDescriptorId,'new',$fdopt);
    1549. 

  1549. 

  1550.         // embed the font program
    1551. 

  1551.         $this->o_contents($this->numObj,'new');
    1552. 

  1552.         $this->objects[$pfbid]['c'].=$data;
    1553. 

  1553.         // determine the cruicial lengths within this file
    1554. 

  1554.         if ($fbtype=='pfb'){
    1555. 

  1555.           $l1 = strpos($data,'eexec')+6;
    1556. 

  1556.           $l2 = strpos($data,'00000000')-$l1;
    1557. 

  1557.           $l3 = strlen($data)-$l2-$l1;
    1558. 

  1558.           $this->o_contents($this->numObj,'add',array('Length1'=>$l1,'Length2'=>$l2,'Length3'=>$l3));
    1559. 

  1559.         } else if ($fbtype=='ttf'){
    1560. 

  1560.           $l1 = strlen($data);
    1561. 

  1561.           $this->o_contents($this->numObj,'add',array('Length1'=>$l1));
    1562. 

  1562.         }
    1563. 

  1563. 

  1564. 

  1565.         // tell the font object about all this new stuff
    1566. 

  1566.         $tmp = array('BaseFont'=>$adobeFontName,'Widths'=>$widthid
    1567. 

  1567.                                       ,'FirstChar'=>$firstChar,'LastChar'=>$lastChar
    1568. 

  1568.                                       ,'FontDescriptor'=>$fontDescriptorId);
    1569. 

  1569.         if ($fbtype=='ttf'){
    1570. 

  1570.           $tmp['SubType']='TrueType';
    1571. 

  1571.         }
    1572. 

  1572.         $this->addMessage('adding extra info to font.('.$fontObj.')');
    1573. 

  1573.         foreach($tmp as $fk=>$fv){
    1574. 

  1574.           $this->addMessage($fk." : ".$fv);
    1575. 

  1575.         }
    1576. 

  1576.         $this->o_font($fontObj,'add',$tmp);
    1577. 

  1577. 

  1578.       } else {
    1579. 

  1579.         $this->addMessage('selectFont: pfb or ttf file not found, ok if this is one of the 14 standard fonts');
    1580. 

  1580.       }
    1581. 

  1581. 

  1582. 

  1583.       // also set the differences here, note that this means that these will take effect only the
    1584. 

  1584.       //first time that a font is selected, else they are ignored
    1585. 

  1585.       if (isset($options['differences'])){
    1586. 

  1586.         $this->fonts[$fontName]['differences']=$options['differences'];
    1587. 

  1587.       }
    1588. 

  1588.     }
    1589. 

  1589.   }
    1590. 

  1590.   if ($set && isset($this->fonts[$fontName])){
    1591. 

  1591.     // so if for some reason the font was not set in the last one then it will not be selected
    1592. 

  1592.     $this->currentBaseFont=$fontName;
    1593. 

  1593.     // the next line means that if a new font is selected, then the current text state will be
    1594. 

  1594.     // applied to it as well.
    1595. 

  1595.     $this->setCurrentFont();
    1596. 

  1596.   }
    1597. 

  1597.   return $this->currentFontNum;
    1598. 

  1598. }
    1599. 

  1599. 

  1600. /**
    1601. 

  1601. * sets up the current font, based on the font families, and the current text state
    1602. 

  1602. * note that this system is quite flexible, a <b><i> font can be completely different to a
    1603. 

  1603. * <i><b> font, and even <b><b> will have to be defined within the family to have meaning
    1604. 

  1604. * This function is to be called whenever the currentTextState is changed, it will update
    1605. 

  1605. * the currentFont setting to whatever the appropriatte family one is.
    1606. 

  1606. * If the user calls selectFont themselves then that will reset the currentBaseFont, and the currentFont
    1607. 

  1607. * This function will change the currentFont to whatever it should be, but will not change the
    1608. 

  1608. * currentBaseFont.
    1609. 

  1609. *
    1610. 

  1610. * @access private
    1611. 

  1611. */
    1612. 

  1612. function setCurrentFont(){
    1613. 

  1613.   if (strlen($this->currentBaseFont)==0){
    1614. 

  1614.     // then assume an initial font
    1615. 

  1615.     $this->selectFont('./fonts/Helvetica.afm');
    1616. 

  1616.   }
    1617. 

  1617.   $cf = substr($this->currentBaseFont,strrpos($this->currentBaseFont,'/')+1);
    1618. 

  1618.   if (strlen($this->currentTextState)
    1619. 

  1619.     && isset($this->fontFamilies[$cf])
    1620. 

  1620.       && isset($this->fontFamilies[$cf][$this->currentTextState])){
    1621. 

  1621.     // then we are in some state or another
    1622. 

  1622.     // and this font has a family, and the current setting exists within it
    1623. 

  1623.     // select the font, then return it
    1624. 

  1624.     $nf = substr($this->currentBaseFont,0,strrpos($this->currentBaseFont,'/')+1).$this->fontFamilies[$cf][$this->currentTextState];
    1625. 

  1625.     $this->selectFont($nf,'',0);
    1626. 

  1626.     $this->currentFont = $nf;
    1627. 

  1627.     $this->currentFontNum = $this->fonts[$nf]['fontNum'];
    1628. 

  1628.   } else {
    1629. 

  1629.     // the this font must not have the right family member for the current state
    1630. 

  1630.     // simply assume the base font
    1631. 

  1631.     $this->currentFont = $this->currentBaseFont;
    1632. 

  1632.     $this->currentFontNum = $this->fonts[$this->currentFont]['fontNum'];
    1633. 

  1633.   }
    1634. 

  1634. }
    1635. 

  1635. 

  1636. /**
    1637. 

  1637. * function for the user to find out what the ID is of the first page that was created during
    1638. 

  1638. * startup - useful if they wish to add something to it later.
    1639. 

  1639. */
    1640. 

  1640. function getFirstPageId(){
    1641. 

  1641.   return $this->firstPageId;
    1642. 

  1642. }
    1643. 

  1643. 

  1644. /**
    1645. 

  1645. * add content to the currently active object
    1646. 

  1646. *
    1647. 

  1647. * @access private
    1648. 

  1648. */
    1649. 

  1649. function addContent($content){
    1650. 

  1650.   $this->objects[$this->currentContents]['c'].=$content;
    1651. 

  1651. }
    1652. 

  1652. 

  1653. /**
    1654. 

  1654. * sets the colour for fill operations
    1655. 

  1655. */
    1656. 

  1656. function setColor($r,$g,$b,$force=0){
    1657. 

  1657.   if ($r>=0 && ($force || $r!=$this->currentColour['r'] || $g!=$this->currentColour['g'] || $b!=$this->currentColour['b'])){
    1658. 

  1658.     $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$r).' '.sprintf('%.3f',$g).' '.sprintf('%.3f',$b).' rg';
    1659. 

  1659.     $this->currentColour=array('r'=>$r,'g'=>$g,'b'=>$b);
    1660. 

  1660.   }
    1661. 

  1661. }
    1662. 

  1662. 

  1663. /**
    1664. 

  1664. * sets the colour for stroke operations
    1665. 

  1665. */
    1666. 

  1666. function setStrokeColor($r,$g,$b,$force=0){
    1667. 

  1667.   if ($r>=0 && ($force || $r!=$this->currentStrokeColour['r'] || $g!=$this->currentStrokeColour['g'] || $b!=$this->currentStrokeColour['b'])){
    1668. 

  1668.     $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$r).' '.sprintf('%.3f',$g).' '.sprintf('%.3f',$b).' RG';
    1669. 

  1669.     $this->currentStrokeColour=array('r'=>$r,'g'=>$g,'b'=>$b);
    1670. 

  1670.   }
    1671. 

  1671. }
    1672. 

  1672. 

  1673. /**
    1674. 

  1674. * draw a line from one set of coordinates to another
    1675. 

  1675. */
    1676. 

  1676. function line($x1,$y1,$x2,$y2){
    1677. 

  1677.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$x1).' '.sprintf('%.3f',$y1).' m '.sprintf('%.3f',$x2).' '.sprintf('%.3f',$y2).' l S';
    1678. 

  1678. }
    1679. 

  1679. 

  1680. /**
    1681. 

  1681. * draw a bezier curve based on 4 control points
    1682. 

  1682. */
    1683. 

  1683. function curve($x0,$y0,$x1,$y1,$x2,$y2,$x3,$y3){
    1684. 

  1684.   // in the current line style, draw a bezier curve from (x0,y0) to (x3,y3) using the other two points
    1685. 

  1685.   // as the control points for the curve.
    1686. 

  1686.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$x0).' '.sprintf('%.3f',$y0).' m '.sprintf('%.3f',$x1).' '.sprintf('%.3f',$y1);
    1687. 

  1687.   $this->objects[$this->currentContents]['c'].= ' '.sprintf('%.3f',$x2).' '.sprintf('%.3f',$y2).' '.sprintf('%.3f',$x3).' '.sprintf('%.3f',$y3).' c S';
    1688. 

  1688. }
    1689. 

  1689. 

  1690. /**
    1691. 

  1691. * draw a part of an ellipse
    1692. 

  1692. */
    1693. 

  1693. function partEllipse($x0,$y0,$astart,$afinish,$r1,$r2=0,$angle=0,$nSeg=8){
    1694. 

  1694.   $this->ellipse($x0,$y0,$r1,$r2,$angle,$nSeg,$astart,$afinish,0);
    1695. 

  1695. }
    1696. 

  1696. 

  1697. /**
    1698. 

  1698. * draw a filled ellipse
    1699. 

  1699. */
    1700. 

  1700. function filledEllipse($x0,$y0,$r1,$r2=0,$angle=0,$nSeg=8,$astart=0,$afinish=360){
    1701. 

  1701.   return $this->ellipse($x0,$y0,$r1,$r2=0,$angle,$nSeg,$astart,$afinish,1,1);
    1702. 

  1702. }
    1703. 

  1703. 

  1704. /**
    1705. 

  1705. * draw an ellipse
    1706. 

  1706. * note that the part and filled ellipse are just special cases of this function
    1707. 

  1707. *
    1708. 

  1708. * draws an ellipse in the current line style
    1709. 

  1709. * centered at $x0,$y0, radii $r1,$r2
    1710. 

  1710. * if $r2 is not set, then a circle is drawn
    1711. 

  1711. * nSeg is not allowed to be less than 2, as this will simply draw a line (and will even draw a
    1712. 

  1712. * pretty crappy shape at 2, as we are approximating with bezier curves.
    1713. 

  1713. */
    1714. 

  1714. function ellipse($x0,$y0,$r1,$r2=0,$angle=0,$nSeg=8,$astart=0,$afinish=360,$close=1,$fill=0){
    1715. 

  1715.   if ($r1==0){
    1716. 

  1716.     return;
    1717. 

  1717.   }
    1718. 

  1718.   if ($r2==0){
    1719. 

  1719.     $r2=$r1;
    1720. 

  1720.   }
    1721. 

  1721.   if ($nSeg<2){
    1722. 

  1722.     $nSeg=2;
    1723. 

  1723.   }
    1724. 

  1724. 

  1725.   $astart = deg2rad((float)$astart);
    1726. 

  1726.   $afinish = deg2rad((float)$afinish);
    1727. 

  1727.   $totalAngle =$afinish-$astart;
    1728. 

  1728. 

  1729.   $dt = $totalAngle/$nSeg;
    1730. 

  1730.   $dtm = $dt/3;
    1731. 

  1731. 

  1732.   if ($angle != 0){
    1733. 

  1733.     $a = -1*deg2rad((float)$angle);
    1734. 

  1734.     $tmp = "\n q ";
    1735. 

  1735.     $tmp .= sprintf('%.3f',cos($a)).' '.sprintf('%.3f',(-1.0*sin($a))).' '.sprintf('%.3f',sin($a)).' '.sprintf('%.3f',cos($a)).' ';
    1736. 

  1736.     $tmp .= sprintf('%.3f',$x0).' '.sprintf('%.3f',$y0).' cm';
    1737. 

  1737.     $this->objects[$this->currentContents]['c'].= $tmp;
    1738. 

  1738.     $x0=0;
    1739. 

  1739.     $y0=0;
    1740. 

  1740.   }
    1741. 

  1741. 

  1742.   $t1 = $astart;
    1743. 

  1743.   $a0 = $x0+$r1*cos($t1);
    1744. 

  1744.   $b0 = $y0+$r2*sin($t1);
    1745. 

  1745.   $c0 = -$r1*sin($t1);
    1746. 

  1746.   $d0 = $r2*cos($t1);
    1747. 

  1747. 

  1748.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$a0).' '.sprintf('%.3f',$b0).' m ';
    1749. 

  1749.   for ($i=1;$i<=$nSeg;$i++){
    1750. 

  1750.     // draw this bit of the total curve
    1751. 

  1751.     $t1 = $i*$dt+$astart;
    1752. 

  1752.     $a1 = $x0+$r1*cos($t1);
    1753. 

  1753.     $b1 = $y0+$r2*sin($t1);
    1754. 

  1754.     $c1 = -$r1*sin($t1);
    1755. 

  1755.     $d1 = $r2*cos($t1);
    1756. 

  1756.     $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',($a0+$c0*$dtm)).' '.sprintf('%.3f',($b0+$d0*$dtm));
    1757. 

  1757.     $this->objects[$this->currentContents]['c'].= ' '.sprintf('%.3f',($a1-$c1*$dtm)).' '.sprintf('%.3f',($b1-$d1*$dtm)).' '.sprintf('%.3f',$a1).' '.sprintf('%.3f',$b1).' c';
    1758. 

  1758.     $a0=$a1;
    1759. 

  1759.     $b0=$b1;
    1760. 

  1760.     $c0=$c1;
    1761. 

  1761.     $d0=$d1;
    1762. 

  1762.   }
    1763. 

  1763.   if ($fill){
    1764. 

  1764.     $this->objects[$this->currentContents]['c'].=' f';
    1765. 

  1765.   } else {
    1766. 

  1766.     if ($close){
    1767. 

  1767.       $this->objects[$this->currentContents]['c'].=' s'; // small 's' signifies closing the path as well
    1768. 

  1768.     } else {
    1769. 

  1769.       $this->objects[$this->currentContents]['c'].=' S';
    1770. 

  1770.     }
    1771. 

  1771.   }
    1772. 

  1772.   if ($angle !=0){
    1773. 

  1773.     $this->objects[$this->currentContents]['c'].=' Q';
    1774. 

  1774.   }
    1775. 

  1775. }
    1776. 

  1776. 

  1777. /**
    1778. 

  1778. * this sets the line drawing style.
    1779. 

  1779. * width, is the thickness of the line in user units
    1780. 

  1780. * cap is the type of cap to put on the line, values can be 'butt','round','square'
    1781. 

  1781. *    where the diffference between 'square' and 'butt' is that 'square' projects a flat end past the
    1782. 

  1782. *    end of the line.
    1783. 

  1783. * join can be 'miter', 'round', 'bevel'
    1784. 

  1784. * dash is an array which sets the dash pattern, is a series of length values, which are the lengths of the
    1785. 

  1785. *   on and off dashes.
    1786. 

  1786. *   (2) represents 2 on, 2 off, 2 on , 2 off ...
    1787. 

  1787. *   (2,1) is 2 on, 1 off, 2 on, 1 off.. etc
    1788. 

  1788. * phase is a modifier on the dash pattern which is used to shift the point at which the pattern starts.
    1789. 

  1789. */
    1790. 

  1790. function setLineStyle($width=1,$cap='',$join='',$dash='',$phase=0){
    1791. 

  1791. 

  1792.   // this is quite inefficient in that it sets all the parameters whenever 1 is changed, but will fix another day
    1793. 

  1793.   $string = '';
    1794. 

  1794.   if ($width>0){
    1795. 

  1795.     $string.= $width.' w';
    1796. 

  1796.   }
    1797. 

  1797.   $ca = array('butt'=>0,'round'=>1,'square'=>2);
    1798. 

  1798.   if (isset($ca[$cap])){
    1799. 

  1799.     $string.= ' '.$ca[$cap].' J';
    1800. 

  1800.   }
    1801. 

  1801.   $ja = array('miter'=>0,'round'=>1,'bevel'=>2);
    1802. 

  1802.   if (isset($ja[$join])){
    1803. 

  1803.     $string.= ' '.$ja[$join].' j';
    1804. 

  1804.   }
    1805. 

  1805.   if (is_array($dash)){
    1806. 

  1806.     $string.= ' [';
    1807. 

  1807.     foreach ($dash as $len){
    1808. 

  1808.       $string.=' '.$len;
    1809. 

  1809.     }
    1810. 

  1810.     $string.= ' ] '.$phase.' d';
    1811. 

  1811.   }
    1812. 

  1812.   $this->currentLineStyle = $string;
    1813. 

  1813.   $this->objects[$this->currentContents]['c'].="\n".$string;
    1814. 

  1814. }
    1815. 

  1815. 

  1816. /**
    1817. 

  1817. * draw a polygon, the syntax for this is similar to the GD polygon command
    1818. 

  1818. */
    1819. 

  1819. function polygon($p,$np,$f=0){
    1820. 

  1820.   $this->objects[$this->currentContents]['c'].="\n";
    1821. 

  1821.   $this->objects[$this->currentContents]['c'].=sprintf('%.3f',$p[0]).' '.sprintf('%.3f',$p[1]).' m ';
    1822. 

  1822.   for ($i=2;$i<$np*2;$i=$i+2){
    1823. 

  1823.     $this->objects[$this->currentContents]['c'].= sprintf('%.3f',$p[$i]).' '.sprintf('%.3f',$p[$i+1]).' l ';
    1824. 

  1824.   }
    1825. 

  1825.   if ($f==1){
    1826. 

  1826.     $this->objects[$this->currentContents]['c'].=' f';
    1827. 

  1827.   } else {
    1828. 

  1828.     $this->objects[$this->currentContents]['c'].=' S';
    1829. 

  1829.   }
    1830. 

  1830. }
    1831. 

  1831. 

  1832. /**
    1833. 

  1833. * a filled rectangle, note that it is the width and height of the rectangle which are the secondary paramaters, not
    1834. 

  1834. * the coordinates of the upper-right corner
    1835. 

  1835. */
    1836. 

  1836. function filledRectangle($x1,$y1,$width,$height){
    1837. 

  1837.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$x1).' '.sprintf('%.3f',$y1).' '.sprintf('%.3f',$width).' '.sprintf('%.3f',$height).' re f';
    1838. 

  1838. }
    1839. 

  1839. 

  1840. /**
    1841. 

  1841. * draw a rectangle, note that it is the width and height of the rectangle which are the secondary paramaters, not
    1842. 

  1842. * the coordinates of the upper-right corner
    1843. 

  1843. */
    1844. 

  1844. function rectangle($x1,$y1,$width,$height){
    1845. 

  1845.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$x1).' '.sprintf('%.3f',$y1).' '.sprintf('%.3f',$width).' '.sprintf('%.3f',$height).' re S';
    1846. 

  1846. }
    1847. 

  1847. 

  1848. /**
    1849. 

  1849. * add a new page to the document
    1850. 

  1850. * this also makes the new page the current active object
    1851. 

  1851. */
    1852. 

  1852. function newPage($insert=0,$id=0,$pos='after'){
    1853. 

  1853. 

  1854.   // if there is a state saved, then go up the stack closing them
    1855. 

  1855.   // then on the new page, re-open them with the right setings
    1856. 

  1856. 

  1857.   if ($this->nStateStack){
    1858. 

  1858.     for ($i=$this->nStateStack;$i>=1;$i--){
    1859. 

  1859.       $this->restoreState($i);
    1860. 

  1860.     }
    1861. 

  1861.   }
    1862. 

  1862. 

  1863.   $this->numObj++;
    1864. 

  1864.   if ($insert){
    1865. 

  1865.     // the id from the ezPdf class is the od of the contents of the page, not the page object itself
    1866. 

  1866.     // query that object to find the parent
    1867. 

  1867.     $rid = $this->objects[$id]['onPage'];
    1868. 

  1868.     $opt= array('rid'=>$rid,'pos'=>$pos);
    1869. 

  1869.     $this->o_page($this->numObj,'new',$opt);
    1870. 

  1870.   } else {
    1871. 

  1871.     $this->o_page($this->numObj,'new');
    1872. 

  1872.   }
    1873. 

  1873.   // if there is a stack saved, then put that onto the page
    1874. 

  1874.   if ($this->nStateStack){
    1875. 

  1875.     for ($i=1;$i<=$this->nStateStack;$i++){
    1876. 

  1876.       $this->saveState($i);
    1877. 

  1877.     }
    1878. 

  1878.   }
    1879. 

  1879.   // and if there has been a stroke or fill colour set, then transfer them
    1880. 

  1880.   if ($this->currentColour['r']>=0){
    1881. 

  1881.     $this->setColor($this->currentColour['r'],$this->currentColour['g'],$this->currentColour['b'],1);
    1882. 

  1882.   }
    1883. 

  1883.   if ($this->currentStrokeColour['r']>=0){
    1884. 

  1884.     $this->setStrokeColor($this->currentStrokeColour['r'],$this->currentStrokeColour['g'],$this->currentStrokeColour['b'],1);
    1885. 

  1885.   }
    1886. 

  1886. 

  1887.   // if there is a line style set, then put this in too
    1888. 

  1888.   if (strlen($this->currentLineStyle)){
    1889. 

  1889.     $this->objects[$this->currentContents]['c'].="\n".$this->currentLineStyle;
    1890. 

  1890.   }
    1891. 

  1891. 

  1892.   // the call to the o_page object set currentContents to the present page, so this can be returned as the page id
    1893. 

  1893.   return $this->currentContents;
    1894. 

  1894. }
    1895. 

  1895. 

  1896. /**
    1897. 

  1897. * output the pdf code, streaming it to the browser
    1898. 

  1898. * the relevant headers are set so that hopefully the browser will recognise it
    1899. 

  1899. */
    1900. 

  1900. function stream($options=''){
    1901. 

  1901.   // setting the options allows the adjustment of the headers
    1902. 

  1902.   // values at the moment are:
    1903. 

  1903.   // 'Content-Disposition'=>'filename'  - sets the filename, though not too sure how well this will
    1904. 

  1904.   //        work as in my trial the browser seems to use the filename of the php file with .pdf on the end
    1905. 

  1905.   // 'Accept-Ranges'=>1 or 0 - if this is not set to 1, then this header is not included, off by default
    1906. 

  1906.   //    this header seems to have caused some problems despite tha fact that it is supposed to solve
    1907. 

  1907.   //    them, so I am leaving it off by default.
    1908. 

  1908.   // 'compress'=> 1 or 0 - apply content stream compression, this is on (1) by default
    1909. 

  1909.   if (!is_array($options)){
    1910. 

  1910.     $options=array();
    1911. 

  1911.   }
    1912. 

  1912.   if ( isset($options['compress']) && $options['compress']==0){
    1913. 

  1913.     $tmp = $this->output(1);
    1914. 

  1914.   } else {
    1915. 

  1915.     $tmp = $this->output();
    1916. 

  1916.   }
    1917. 

  1917. 

  1918.   // Rod's mods below are based on this tip:
    1919. 

  1919.   // http://sourceforge.net/forum/forum.php?thread_id=1420028&forum_id=147987
    1920. 

  1920.   header('Cache-Control:'); // added by Rod
    1921. 

  1921.   header('Pragma:');        // added by Rod
    1922. 

  1922.   header("Content-type: application/pdf");
    1923. 

  1923.   header("Content-Length: ".strlen(ltrim($tmp)));
    1924. 

  1924.   $fileName = (isset($options['Content-Disposition'])?$options['Content-Disposition']:'file.pdf');
    1925. 

  1925.   // header("Content-Disposition: inline; filename=".$fileName);
    1926. 

  1926.   // This supports a new "inline" keyword in the options array.  If true, the
    1927. 

  1927.   // Content-Disposition header is set to indicate an inline document:
    1928. 

  1928.   header("Content-Disposition: " .
    1929. 

  1929.     (empty($options['inline']) ? "attachment" : "inline") .
    1930. 

  1930.     "; filename=" . $fileName);
    1931. 

  1931.   // End of Rod's mods.
    1932. 

  1932. 

  1933.   if (isset($options['Accept-Ranges']) && $options['Accept-Ranges']==1){
    1934. 

  1934.     header("Accept-Ranges: ".strlen(ltrim($tmp)));
    1935. 

  1935.   }
    1936. 

  1936.   echo ltrim($tmp);
    1937. 

  1937. }
    1938. 

  1938. 

  1939. /**
    1940. 

  1940. * return the height in units of the current font in the given size
    1941. 

  1941. */
    1942. 

  1942. function getFontHeight($size){
    1943. 

  1943.   if (!$this->numFonts){
    1944. 

  1944.     $this->selectFont('./fonts/Helvetica');
    1945. 

  1945.   }
    1946. 

  1946.   // for the current font, and the given size, what is the height of the font in user units
    1947. 

  1947.   $h = $this->fonts[$this->currentFont]['FontBBox'][3]-$this->fonts[$this->currentFont]['FontBBox'][1];
    1948. 

  1948.   return $size*$h/1000;
    1949. 

  1949. }
    1950. 

  1950. 

  1951. /**
    1952. 

  1952. * return the font decender, this will normally return a negative number
    1953. 

  1953. * if you add this number to the baseline, you get the level of the bottom of the font
    1954. 

  1954. * it is in the pdf user units
    1955. 

  1955. */
    1956. 

  1956. function getFontDecender($size){
    1957. 

  1957.   // note that this will most likely return a negative value
    1958. 

  1958.   if (!$this->numFonts){
    1959. 

  1959.     $this->selectFont('./fonts/Helvetica');
    1960. 

  1960.   }
    1961. 

  1961.   $h = $this->fonts[$this->currentFont]['FontBBox'][1];
    1962. 

  1962.   return $size*$h/1000;
    1963. 

  1963. }
    1964. 

  1964. 

  1965. /**
    1966. 

  1966. * filter the text, this is applied to all text just before being inserted into the pdf document
    1967. 

  1967. * it escapes the various things that need to be escaped, and so on
    1968. 

  1968. *
    1969. 

  1969. * @access private
    1970. 

  1970. */
    1971. 

  1971. function filterText($text){
    1972. 

  1972.   $text = str_replace('\\','\\\\',$text);
    1973. 

  1973.   $text = str_replace('(','\(',$text);
    1974. 

  1974.   $text = str_replace(')','\)',$text);
    1975. 

  1975.   $text = str_replace('&lt;','<',$text);
    1976. 

  1976.   $text = str_replace('&gt;','>',$text);
    1977. 

  1977.   $text = str_replace('&#039;','\'',$text);
    1978. 

  1978.   $text = str_replace('&quot;','"',$text);
    1979. 

  1979.   $text = str_replace('&amp;','&',$text);
    1980. 

  1980. 

  1981.   return $text;
    1982. 

  1982. }
    1983. 

  1983. 

  1984. /**
    1985. 

  1985. * given a start position and information about how text is to be laid out, calculate where
    1986. 

  1986. * on the page the text will end
    1987. 

  1987. *
    1988. 

  1988. * @access private
    1989. 

  1989. */
    1990. 

  1990. function PRVTgetTextPosition($x,$y,$angle,$size,$wa,$text){
    1991. 

  1991.   // given this information return an array containing x and y for the end position as elements 0 and 1
    1992. 

  1992.   $w = $this->getTextWidth($size,$text);
    1993. 

  1993.   // need to adjust for the number of spaces in this text
    1994. 

  1994.   $words = explode(' ',$text);
    1995. 

  1995.   $nspaces=count($words)-1;
    1996. 

  1996.   $w += $wa*$nspaces;
    1997. 

  1997.   $a = deg2rad((float)$angle);
    1998. 

  1998.   return array(cos($a)*$w+$x,-sin($a)*$w+$y);
    1999. 

  1999. }
    2000. 

  2000. 

  2001. /**
    2002. 

  2002. * wrapper function for PRVTcheckTextDirective1
    2003. 

  2003. *
    2004. 

  2004. * @access private
    2005. 

  2005. */
    2006. 

  2006. function PRVTcheckTextDirective(&$text,$i,&$f){
    2007. 

  2007.   $x=0;
    2008. 

  2008.   $y=0;
    2009. 

  2009.   return $this->PRVTcheckTextDirective1($text,$i,$f,0,$x,$y);
    2010. 

  2010. }
    2011. 

  2011. 

  2012. /**
    2013. 

  2013. * checks if the text stream contains a control directive
    2014. 

  2014. * if so then makes some changes and returns the number of characters involved in the directive
    2015. 

  2015. * this has been re-worked to include everything neccesary to fins the current writing point, so that
    2016. 

  2016. * the location can be sent to the callback function if required
    2017. 

  2017. * if the directive does not require a font change, then $f should be set to 0
    2018. 

  2018. *
    2019. 

  2019. * @access private
    2020. 

  2020. */
    2021. 

  2021. function PRVTcheckTextDirective1(&$text,$i,&$f,$final,&$x,&$y,$size=0,$angle=0,$wordSpaceAdjust=0){
    2022. 

  2022.   $directive = 0;
    2023. 

  2023.   $j=$i;
    2024. 

  2024.   if ($text[$j]=='<'){
    2025. 

  2025.     $j++;
    2026. 

  2026.     switch($text[$j]){
    2027. 

  2027.       case '/':
    2028. 

  2028.         $j++;
    2029. 

  2029.         if (strlen($text) <= $j){
    2030. 

  2030.           return $directive;
    2031. 

  2031.         }
    2032. 

  2032.         switch($text[$j]){
    2033. 

  2033.           case 'b':
    2034. 

  2034.           case 'i':
    2035. 

  2035.             $j++;
    2036. 

  2036.             if ($text[$j]=='>'){
    2037. 

  2037.               $p = strrpos($this->currentTextState,$text[$j-1]);
    2038. 

  2038.               if ($p !== false){
    2039. 

  2039.                 // then there is one to remove
    2040. 

  2040.                 $this->currentTextState = substr($this->currentTextState,0,$p).substr($this->currentTextState,$p+1);
    2041. 

  2041.               }
    2042. 

  2042.               $directive=$j-$i+1;
    2043. 

  2043.             }
    2044. 

  2044.             break;
    2045. 

  2045.           case 'c':
    2046. 

  2046.             // this this might be a callback function
    2047. 

  2047.             $j++;
    2048. 

  2048.             $k = strpos($text,'>',$j);
    2049. 

  2049.             if ($k!==false && $text[$j]==':'){
    2050. 

  2050.               // then this will be treated as a callback directive
    2051. 

  2051.               $directive = $k-$i+1;
    2052. 

  2052.               $f=0;
    2053. 

  2053.               // split the remainder on colons to get the function name and the paramater
    2054. 

  2054.               $tmp = substr($text,$j+1,$k-$j-1);
    2055. 

  2055.               $b1 = strpos($tmp,':');
    2056. 

  2056.               if ($b1!==false){
    2057. 

  2057.                 $func = substr($tmp,0,$b1);
    2058. 

  2058.                 $parm = substr($tmp,$b1+1);
    2059. 

  2059.               } else {
    2060. 

  2060.                 $func=$tmp;
    2061. 

  2061.                 $parm='';
    2062. 

  2062.               }
    2063. 

  2063.               if (!isset($func) || !strlen(trim($func))){
    2064. 

  2064.                 $directive=0;
    2065. 

  2065.               } else {
    2066. 

  2066.                 // only call the function if this is the final call
    2067. 

  2067.                 if ($final){
    2068. 

  2068.                   // need to assess the text position, calculate the text width to this point
    2069. 

  2069.                   // can use getTextWidth to find the text width I think
    2070. 

  2070.                   $tmp = $this->PRVTgetTextPosition($x,$y,$angle,$size,$wordSpaceAdjust,substr($text,0,$i));
    2071. 

  2071.                   $info = array('x'=>$tmp[0],'y'=>$tmp[1],'angle'=>$angle,'status'=>'end','p'=>$parm,'nCallback'=>$this->nCallback);
    2072. 

  2072.                   $x=$tmp[0];
    2073. 

  2073.                   $y=$tmp[1];
    2074. 

  2074.                   $ret = $this->$func($info);
    2075. 

  2075.                   if (is_array($ret)){
    2076. 

  2076.                     // then the return from the callback function could set the position, to start with, later will do font colour, and font
    2077. 

  2077.                     foreach($ret as $rk=>$rv){
    2078. 

  2078.                       switch($rk){
    2079. 

  2079.                         case 'x':
    2080. 

  2080.                         case 'y':
    2081. 

  2081.                           $$rk=$rv;
    2082. 

  2082.                           break;
    2083. 

  2083.                       }
    2084. 

  2084.                     }
    2085. 

  2085.                   }
    2086. 

  2086.                   // also remove from to the stack
    2087. 

  2087.                   // for simplicity, just take from the end, fix this another day
    2088. 

  2088.                   $this->nCallback--;
    2089. 

  2089.                   if ($this->nCallback<0){
    2090. 

  2090.                     $this->nCallBack=0;
    2091. 

  2091.                   }
    2092. 

  2092.                 }
    2093. 

  2093.               }
    2094. 

  2094.             }
    2095. 

  2095.             break;
    2096. 

  2096.         }
    2097. 

  2097.         break;
    2098. 

  2098.       case 'b':
    2099. 

  2099.       case 'i':
    2100. 

  2100.         $j++;
    2101. 

  2101.         if ($text[$j]=='>'){
    2102. 

  2102.           $this->currentTextState.=$text[$j-1];
    2103. 

  2103.           $directive=$j-$i+1;
    2104. 

  2104.         }
    2105. 

  2105.         break;
    2106. 

  2106.       case 'C':
    2107. 

  2107.         $noClose=1;
    2108. 

  2108.       case 'c':
    2109. 

  2109.         // this this might be a callback function
    2110. 

  2110.         $j++;
    2111. 

  2111.         $k = strpos($text,'>',$j);
    2112. 

  2112.         if ($k!==false && $text[$j]==':'){
    2113. 

  2113.           // then this will be treated as a callback directive
    2114. 

  2114.           $directive = $k-$i+1;
    2115. 

  2115.           $f=0;
    2116. 

  2116.           // split the remainder on colons to get the function name and the paramater
    2117. 

  2117. //          $bits = explode(':',substr($text,$j+1,$k-$j-1));
    2118. 

  2118.           $tmp = substr($text,$j+1,$k-$j-1);
    2119. 

  2119.           $b1 = strpos($tmp,':');
    2120. 

  2120.           if ($b1!==false){
    2121. 

  2121.             $func = substr($tmp,0,$b1);
    2122. 

  2122.             $parm = substr($tmp,$b1+1);
    2123. 

  2123.           } else {
    2124. 

  2124.             $func=$tmp;
    2125. 

  2125.             $parm='';
    2126. 

  2126.           }
    2127. 

  2127.           if (!isset($func) || !strlen(trim($func))){
    2128. 

  2128.             $directive=0;
    2129. 

  2129.           } else {
    2130. 

  2130.             // only call the function if this is the final call, ie, the one actually doing printing, not measurement
    2131. 

  2131.             if ($final){
    2132. 

  2132.               // need to assess the text position, calculate the text width to this point
    2133. 

  2133.               // can use getTextWidth to find the text width I think
    2134. 

  2134.               // also add the text height and decender
    2135. 

  2135.               $tmp = $this->PRVTgetTextPosition($x,$y,$angle,$size,$wordSpaceAdjust,substr($text,0,$i));
    2136. 

  2136.               $info = array('x'=>$tmp[0],'y'=>$tmp[1],'angle'=>$angle,'status'=>'start','p'=>$parm,'f'=>$func,'height'=>$this->getFontHeight($size),'decender'=>$this->getFontDecender($size));
    2137. 

  2137.               $x=$tmp[0];
    2138. 

  2138.               $y=$tmp[1];
    2139. 

  2139.               if (!isset($noClose) || !$noClose){
    2140. 

  2140.                 // only add to the stack if this is a small 'c', therefore is a start-stop pair
    2141. 

  2141.                 $this->nCallback++;
    2142. 

  2142.                 $info['nCallback']=$this->nCallback;
    2143. 

  2143.                 $this->callback[$this->nCallback]=$info;
    2144. 

  2144.               }
    2145. 

  2145.               $ret = $this->$func($info);
    2146. 

  2146.               if (is_array($ret)){
    2147. 

  2147.                 // then the return from the callback function could set the position, to start with, later will do font colour, and font
    2148. 

  2148.                 foreach($ret as $rk=>$rv){
    2149. 

  2149.                   switch($rk){
    2150. 

  2150.                     case 'x':
    2151. 

  2151.                     case 'y':
    2152. 

  2152.                       $$rk=$rv;
    2153. 

  2153.                       break;
    2154. 

  2154.                   }
    2155. 

  2155.                 }
    2156. 

  2156.               }
    2157. 

  2157.             }
    2158. 

  2158.           }
    2159. 

  2159.         }
    2160. 

  2160.         break;
    2161. 

  2161.     }
    2162. 

  2162.   }
    2163. 

  2163.   return $directive;
    2164. 

  2164. }
    2165. 

  2165. 

  2166. /**
    2167. 

  2167. * add text to the document, at a specified location, size and angle on the page
    2168. 

  2168. */
    2169. 

  2169. function addText($x,$y,$size,$text,$angle=0,$wordSpaceAdjust=0){
    2170. 

  2170.   if (!$this->numFonts){$this->selectFont('./fonts/Helvetica');}
    2171. 

  2171. 

  2172.   // if there are any open callbacks, then they should be called, to show the start of the line
    2173. 

  2173.   if ($this->nCallback>0){
    2174. 

  2174.     for ($i=$this->nCallback;$i>0;$i--){
    2175. 

  2175.       // call each function
    2176. 

  2176.       $info = array('x'=>$x,'y'=>$y,'angle'=>$angle,'status'=>'sol','p'=>$this->callback[$i]['p'],'nCallback'=>$this->callback[$i]['nCallback'],'height'=>$this->callback[$i]['height'],'decender'=>$this->callback[$i]['decender']);
    2177. 

  2177.       $func = $this->callback[$i]['f'];
    2178. 

  2178.       $this->$func($info);
    2179. 

  2179.     }
    2180. 

  2180.   }
    2181. 

  2181.   if ($angle==0){
    2182. 

  2182.     $this->objects[$this->currentContents]['c'].="\n".'BT '.sprintf('%.3f',$x).' '.sprintf('%.3f',$y).' Td';
    2183. 

  2183.   } else {
    2184. 

  2184.     $a = deg2rad((float)$angle);
    2185. 

  2185.     $tmp = "\n".'BT ';
    2186. 

  2186.     $tmp .= sprintf('%.3f',cos($a)).' '.sprintf('%.3f',(-1.0*sin($a))).' '.sprintf('%.3f',sin($a)).' '.sprintf('%.3f',cos($a)).' ';
    2187. 

  2187.     $tmp .= sprintf('%.3f',$x).' '.sprintf('%.3f',$y).' Tm';
    2188. 

  2188.     $this->objects[$this->currentContents]['c'] .= $tmp;
    2189. 

  2189.   }
    2190. 

  2190.   if ($wordSpaceAdjust!=0 || $wordSpaceAdjust != $this->wordSpaceAdjust){
    2191. 

  2191.     $this->wordSpaceAdjust=$wordSpaceAdjust;
    2192. 

  2192.     $this->objects[$this->currentContents]['c'].=' '.sprintf('%.3f',$wordSpaceAdjust).' Tw';
    2193. 

  2193.   }
    2194. 

  2194.   $len=strlen($text);
    2195. 

  2195.   $start=0;
    2196. 

  2196.   for ($i=0;$i<$len;$i++){
    2197. 

  2197.     $f=1;
    2198. 

  2198.     $directive = $this->PRVTcheckTextDirective($text,$i,$f);
    2199. 

  2199.     if ($directive){
    2200. 

  2200.       // then we should write what we need to
    2201. 

  2201.       if ($i>$start){
    2202. 

  2202.         $part = substr($text,$start,$i-$start);
    2203. 

  2203.         $this->objects[$this->currentContents]['c'].=' /F'.$this->currentFontNum.' '.sprintf('%.1f',$size).' Tf ';
    2204. 

  2204.         $this->objects[$this->currentContents]['c'].=' ('.$this->filterText($part).') Tj';
    2205. 

  2205.       }
    2206. 

  2206.       if ($f){
    2207. 

  2207.         // then there was nothing drastic done here, restore the contents
    2208. 

  2208.         $this->setCurrentFont();
    2209. 

  2209.       } else {
    2210. 

  2210.         $this->objects[$this->currentContents]['c'] .= ' ET';
    2211. 

  2211.         $f=1;
    2212. 

  2212.         $xp=$x;
    2213. 

  2213.         $yp=$y;
    2214. 

  2214.         $directive = $this->PRVTcheckTextDirective1($text,$i,$f,1,$xp,$yp,$size,$angle,$wordSpaceAdjust);
    2215. 

  2215. 

  2216.         // restart the text object
    2217. 

  2217.           if ($angle==0){
    2218. 

  2218.             $this->objects[$this->currentContents]['c'].="\n".'BT '.sprintf('%.3f',$xp).' '.sprintf('%.3f',$yp).' Td';
    2219. 

  2219.           } else {
    2220. 

  2220.             $a = deg2rad((float)$angle);
    2221. 

  2221.             $tmp = "\n".'BT ';
    2222. 

  2222.             $tmp .= sprintf('%.3f',cos($a)).' '.sprintf('%.3f',(-1.0*sin($a))).' '.sprintf('%.3f',sin($a)).' '.sprintf('%.3f',cos($a)).' ';
    2223. 

  2223.             $tmp .= sprintf('%.3f',$xp).' '.sprintf('%.3f',$yp).' Tm';
    2224. 

  2224.             $this->objects[$this->currentContents]['c'] .= $tmp;
    2225. 

  2225.           }
    2226. 

  2226.           if ($wordSpaceAdjust!=0 || $wordSpaceAdjust != $this->wordSpaceAdjust){
    2227. 

  2227.             $this->wordSpaceAdjust=$wordSpaceAdjust;
    2228. 

  2228.             $this->objects[$this->currentContents]['c'].=' '.sprintf('%.3f',$wordSpaceAdjust).' Tw';
    2229. 

  2229.           }
    2230. 

  2230.       }
    2231. 

  2231.       // and move the writing point to the next piece of text
    2232. 

  2232.       $i=$i+$directive-1;
    2233. 

  2233.       $start=$i+1;
    2234. 

  2234.     }
    2235. 

  2235. 

  2236.   }
    2237. 

  2237.   if ($start<$len){
    2238. 

  2238.     $part = substr($text,$start);
    2239. 

  2239.     $this->objects[$this->currentContents]['c'].=' /F'.$this->currentFontNum.' '.sprintf('%.1f',$size).' Tf ';
    2240. 

  2240.     $this->objects[$this->currentContents]['c'].=' ('.$this->filterText($part).') Tj';
    2241. 

  2241.   }
    2242. 

  2242.   $this->objects[$this->currentContents]['c'].=' ET';
    2243. 

  2243. 

  2244.   // if there are any open callbacks, then they should be called, to show the end of the line
    2245. 

  2245.   if ($this->nCallback>0){
    2246. 

  2246.     for ($i=$this->nCallback;$i>0;$i--){
    2247. 

  2247.       // call each function
    2248. 

  2248.       $tmp = $this->PRVTgetTextPosition($x,$y,$angle,$size,$wordSpaceAdjust,$text);
    2249. 

  2249.       $info = array('x'=>$tmp[0],'y'=>$tmp[1],'angle'=>$angle,'status'=>'eol','p'=>$this->callback[$i]['p'],'nCallback'=>$this->callback[$i]['nCallback'],'height'=>$this->callback[$i]['height'],'decender'=>$this->callback[$i]['decender']);
    2250. 

  2250.       $func = $this->callback[$i]['f'];
    2251. 

  2251.       $this->$func($info);
    2252. 

  2252.     }
    2253. 

  2253.   }
    2254. 

  2254. 

  2255. }
    2256. 

  2256. 

  2257. /**
    2258. 

  2258. * calculate how wide a given text string will be on a page, at a given size.
    2259. 

  2259. * this can be called externally, but is alse used by the other class functions
    2260. 

  2260. */
    2261. 

  2261. function getTextWidth($size,$text){
    2262. 

  2262.   // this function should not change any of the settings, though it will need to
    2263. 

  2263.   // track any directives which change during calculation, so copy them at the start
    2264. 

  2264.   // and put them back at the end.
    2265. 

  2265.   $store_currentTextState = $this->currentTextState;
    2266. 

  2266. 

  2267.   if (!$this->numFonts){
    2268. 

  2268.     $this->selectFont('./fonts/Helvetica');
    2269. 

  2269.   }
    2270. 

  2270. 

  2271.   // converts a number or a float to a string so it can get the width
    2272. 

  2272.   $text = "$text";
    2273. 

  2273. 

  2274.   // hmm, this is where it all starts to get tricky - use the font information to
    2275. 

  2275.   // calculate the width of each character, add them up and convert to user units
    2276. 

  2276.   $w=0;
    2277. 

  2277.   $len=strlen($text);
    2278. 

  2278.   $cf = $this->currentFont;
    2279. 

  2279.   for ($i=0;$i<$len;$i++){
    2280. 

  2280.     $f=1;
    2281. 

  2281.     $directive = $this->PRVTcheckTextDirective($text,$i,$f);
    2282. 

  2282.     if ($directive){
    2283. 

  2283.       if ($f){
    2284. 

  2284.         $this->setCurrentFont();
    2285. 

  2285.         $cf = $this->currentFont;
    2286. 

  2286.       }
    2287. 

  2287.       $i=$i+$directive-1;
    2288. 

  2288.     } else {
    2289. 

  2289.       $char=ord($text[$i]);
    2290. 

  2290.       if (isset($this->fonts[$cf]['differences'][$char])){
    2291. 

  2291.         // then this character is being replaced by another
    2292. 

  2292.         $name = $this->fonts[$cf]['differences'][$char];
    2293. 

  2293.         if (isset($this->fonts[$cf]['C'][$name]['WX'])){
    2294. 

  2294.           $w+=$this->fonts[$cf]['C'][$name]['WX'];
    2295. 

  2295.         }
    2296. 

  2296.       } else if (isset($this->fonts[$cf]['C'][$char]['WX'])){
    2297. 

  2297.         $w+=$this->fonts[$cf]['C'][$char]['WX'];
    2298. 

  2298.       }
    2299. 

  2299.     }
    2300. 

  2300.   }
    2301. 

  2301. 

  2302.   $this->currentTextState = $store_currentTextState;
    2303. 

  2303.   $this->setCurrentFont();
    2304. 

  2304. 

  2305.   return $w*$size/1000;
    2306. 

  2306. }
    2307. 

  2307. 

  2308. /**
    2309. 

  2309. * do a part of the calculation for sorting out the justification of the text
    2310. 

  2310. *
    2311. 

  2311. * @access private
    2312. 

  2312. */
    2313. 

  2313. function PRVTadjustWrapText($text,$actual,$width,&$x,&$adjust,$justification){
    2314. 

  2314.   switch ($justification){
    2315. 

  2315.     case 'left':
    2316. 

  2316.       return;
    2317. 

  2317.       break;
    2318. 

  2318.     case 'right':
    2319. 

  2319.       $x+=$width-$actual;
    2320. 

  2320.       break;
    2321. 

  2321.     case 'center':
    2322. 

  2322.     case 'centre':
    2323. 

  2323.       $x+=($width-$actual)/2;
    2324. 

  2324.       break;
    2325. 

  2325.     case 'full':
    2326. 

  2326.       // count the number of words
    2327. 

  2327.       $words = explode(' ',$text);
    2328. 

  2328.       $nspaces=count($words)-1;
    2329. 

  2329.       if ($nspaces>0){
    2330. 

  2330.         $adjust = ($width-$actual)/$nspaces;
    2331. 

  2331.       } else {
    2332. 

  2332.         $adjust=0;
    2333. 

  2333.       }
    2334. 

  2334.       break;
    2335. 

  2335.   }
    2336. 

  2336. }
    2337. 

  2337. 

  2338. /**
    2339. 

  2339. * add text to the page, but ensure that it fits within a certain width
    2340. 

  2340. * if it does not fit then put in as much as possible, splitting at word boundaries
    2341. 

  2341. * and return the remainder.
    2342. 

  2342. * justification and angle can also be specified for the text
    2343. 

  2343. */
    2344. 

  2344. function addTextWrap($x,$y,$width,$size,$text,$justification='left',$angle=0,$test=0){
    2345. 

  2345.   // this will display the text, and if it goes beyond the width $width, will backtrack to the
    2346. 

  2346.   // previous space or hyphen, and return the remainder of the text.
    2347. 

  2347. 

  2348.   // $justification can be set to 'left','right','center','centre','full'
    2349. 

  2349. 

  2350.   // need to store the initial text state, as this will change during the width calculation
    2351. 

  2351.   // but will need to be re-set before printing, so that the chars work out right
    2352. 

  2352.   $store_currentTextState = $this->currentTextState;
    2353. 

  2353. 

  2354.   if (!$this->numFonts){$this->selectFont('./fonts/Helvetica');}
    2355. 

  2355.   if ($width<=0){
    2356. 

  2356.     // error, pretend it printed ok, otherwise risking a loop
    2357. 

  2357.     return '';
    2358. 

  2358.   }
    2359. 

  2359.   $w=0;
    2360. 

  2360.   $break=0;
    2361. 

  2361.   $breakWidth=0;
    2362. 

  2362.   $len=strlen($text);
    2363. 

  2363.   $cf = $this->currentFont;
    2364. 

  2364.   $tw = $width/$size*1000;
    2365. 

  2365.   for ($i=0;$i<$len;$i++){
    2366. 

  2366.     $f=1;
    2367. 

  2367.     $directive = $this->PRVTcheckTextDirective($text,$i,$f);
    2368. 

  2368.     if ($directive){
    2369. 

  2369.       if ($f){
    2370. 

  2370.         $this->setCurrentFont();
    2371. 

  2371.         $cf = $this->currentFont;
    2372. 

  2372.       }
    2373. 

  2373.       $i=$i+$directive-1;
    2374. 

  2374.     } else {
    2375. 

  2375.       $cOrd = ord($text[$i]);
    2376. 

  2376.       if (isset($this->fonts[$cf]['differences'][$cOrd])){
    2377. 

  2377.         // then this character is being replaced by another
    2378. 

  2378.         $cOrd2 = $this->fonts[$cf]['differences'][$cOrd];
    2379. 

  2379.       } else {
    2380. 

  2380.         $cOrd2 = $cOrd;
    2381. 

  2381.       }
    2382. 

  2382. 

  2383.       if (isset($this->fonts[$cf]['C'][$cOrd2]['WX'])){
    2384. 

  2384.         $w+=$this->fonts[$cf]['C'][$cOrd2]['WX'];
    2385. 

  2385.       }
    2386. 

  2386.       if ($w>$tw){
    2387. 

  2387.         // then we need to truncate this line
    2388. 

  2388.         if ($break>0){
    2389. 

  2389.           // then we have somewhere that we can split :)
    2390. 

  2390.           if ($text[$break]==' '){
    2391. 

  2391.             $tmp = substr($text,0,$break);
    2392. 

  2392.           } else {
    2393. 

  2393.             $tmp = substr($text,0,$break+1);
    2394. 

  2394.           }
    2395. 

  2395.           $adjust=0;
    2396. 

  2396.           $this->PRVTadjustWrapText($tmp,$breakWidth,$width,$x,$adjust,$justification);
    2397. 

  2397. 

  2398.           // reset the text state
    2399. 

  2399.           $this->currentTextState = $store_currentTextState;
    2400. 

  2400.           $this->setCurrentFont();
    2401. 

  2401.           if (!$test){
    2402. 

  2402.             $this->addText($x,$y,$size,$tmp,$angle,$adjust);
    2403. 

  2403.           }
    2404. 

  2404.           return substr($text,$break+1);
    2405. 

  2405.         } else {
    2406. 

  2406.           // just split before the current character
    2407. 

  2407.           $tmp = substr($text,0,$i);
    2408. 

  2408.           $adjust=0;
    2409. 

  2409.           $ctmp=ord($text[$i]);
    2410. 

  2410.           if (isset($this->fonts[$cf]['differences'][$ctmp])){
    2411. 

  2411.             $ctmp=$this->fonts[$cf]['differences'][$ctmp];
    2412. 

  2412.           }
    2413. 

  2413.           $tmpw=($w-$this->fonts[$cf]['C'][$ctmp]['WX'])*$size/1000;
    2414. 

  2414.           $this->PRVTadjustWrapText($tmp,$tmpw,$width,$x,$adjust,$justification);
    2415. 

  2415.           // reset the text state
    2416. 

  2416.           $this->currentTextState = $store_currentTextState;
    2417. 

  2417.           $this->setCurrentFont();
    2418. 

  2418.           if (!$test){
    2419. 

  2419.             $this->addText($x,$y,$size,$tmp,$angle,$adjust);
    2420. 

  2420.           }
    2421. 

  2421.           return substr($text,$i);
    2422. 

  2422.         }
    2423. 

  2423.       }
    2424. 

  2424.       if ($text[$i]=='-'){
    2425. 

  2425.         $break=$i;
    2426. 

  2426.         $breakWidth = $w*$size/1000;
    2427. 

  2427.       }
    2428. 

  2428.       if ($text[$i]==' '){
    2429. 

  2429.         $break=$i;
    2430. 

  2430.         $ctmp=ord($text[$i]);
    2431. 

  2431.         if (isset($this->fonts[$cf]['differences'][$ctmp])){
    2432. 

  2432.           $ctmp=$this->fonts[$cf]['differences'][$ctmp];
    2433. 

  2433.         }
    2434. 

  2434.         $breakWidth = ($w-$this->fonts[$cf]['C'][$ctmp]['WX'])*$size/1000;
    2435. 

  2435.       }
    2436. 

  2436.     }
    2437. 

  2437.   }
    2438. 

  2438.   // then there was no need to break this line
    2439. 

  2439.   if ($justification=='full'){
    2440. 

  2440.     $justification='left';
    2441. 

  2441.   }
    2442. 

  2442.   $adjust=0;
    2443. 

  2443.   $tmpw=$w*$size/1000;
    2444. 

  2444.   $this->PRVTadjustWrapText($text,$tmpw,$width,$x,$adjust,$justification);
    2445. 

  2445.   // reset the text state
    2446. 

  2446.   $this->currentTextState = $store_currentTextState;
    2447. 

  2447.   $this->setCurrentFont();
    2448. 

  2448.   if (!$test){
    2449. 

  2449.     $this->addText($x,$y,$size,$text,$angle,$adjust,$angle);
    2450. 

  2450.   }
    2451. 

  2451.   return '';
    2452. 

  2452. }
    2453. 

  2453. 

  2454. /**
    2455. 

  2455. * this will be called at a new page to return the state to what it was on the
    2456. 

  2456. * end of the previous page, before the stack was closed down
    2457. 

  2457. * This is to get around not being able to have open 'q' across pages
    2458. 

  2458. *
    2459. 

  2459. */
    2460. 

  2460. function saveState($pageEnd=0){
    2461. 

  2461.   if ($pageEnd){
    2462. 

  2462.     // this will be called at a new page to return the state to what it was on the
    2463. 

  2463.     // end of the previous page, before the stack was closed down
    2464. 

  2464.     // This is to get around not being able to have open 'q' across pages
    2465. 

  2465.     $opt = $this->stateStack[$pageEnd]; // ok to use this as stack starts numbering at 1
    2466. 

  2466.     $this->setColor($opt['col']['r'],$opt['col']['g'],$opt['col']['b'],1);
    2467. 

  2467.     $this->setStrokeColor($opt['str']['r'],$opt['str']['g'],$opt['str']['b'],1);
    2468. 

  2468.     $this->objects[$this->currentContents]['c'].="\n".$opt['lin'];
    2469. 

  2469. //    $this->currentLineStyle = $opt['lin'];
    2470. 

  2470.   } else {
    2471. 

  2471.     $this->nStateStack++;
    2472. 

  2472.     $this->stateStack[$this->nStateStack]=array(
    2473. 

  2473.       'col'=>$this->currentColour
    2474. 

  2474.      ,'str'=>$this->currentStrokeColour
    2475. 

  2475.      ,'lin'=>$this->currentLineStyle
    2476. 

  2476.     );
    2477. 

  2477.   }
    2478. 

  2478.   $this->objects[$this->currentContents]['c'].="\nq";
    2479. 

  2479. }
    2480. 

  2480. 

  2481. /**
    2482. 

  2482. * restore a previously saved state
    2483. 

  2483. */
    2484. 

  2484. function restoreState($pageEnd=0){
    2485. 

  2485.   if (!$pageEnd){
    2486. 

  2486.     $n = $this->nStateStack;
    2487. 

  2487.     $this->currentColour = $this->stateStack[$n]['col'];
    2488. 

  2488.     $this->currentStrokeColour = $this->stateStack[$n]['str'];
    2489. 

  2489.     $this->objects[$this->currentContents]['c'].="\n".$this->stateStack[$n]['lin'];
    2490. 

  2490.     $this->currentLineStyle = $this->stateStack[$n]['lin'];
    2491. 

  2491.     unset($this->stateStack[$n]);
    2492. 

  2492.     $this->nStateStack--;
    2493. 

  2493.   }
    2494. 

  2494.   $this->objects[$this->currentContents]['c'].="\nQ";
    2495. 

  2495. }
    2496. 

  2496. 

  2497. /**
    2498. 

  2498. * make a loose object, the output will go into this object, until it is closed, then will revert to
    2499. 

  2499. * the current one.
    2500. 

  2500. * this object will not appear until it is included within a page.
    2501. 

  2501. * the function will return the object number
    2502. 

  2502. */
    2503. 

  2503. function openObject(){
    2504. 

  2504.   $this->nStack++;
    2505. 

  2505.   $this->stack[$this->nStack]=array('c'=>$this->currentContents,'p'=>$this->currentPage);
    2506. 

  2506.   // add a new object of the content type, to hold the data flow
    2507. 

  2507.   $this->numObj++;
    2508. 

  2508.   $this->o_contents($this->numObj,'new');
    2509. 

  2509.   $this->currentContents=$this->numObj;
    2510. 

  2510.   $this->looseObjects[$this->numObj]=1;
    2511. 

  2511. 

  2512.   return $this->numObj;
    2513. 

  2513. }
    2514. 

  2514. 

  2515. /**
    2516. 

  2516. * open an existing object for editing
    2517. 

  2517. */
    2518. 

  2518. function reopenObject($id){
    2519. 

  2519.    $this->nStack++;
    2520. 

  2520.    $this->stack[$this->nStack]=array('c'=>$this->currentContents,'p'=>$this->currentPage);
    2521. 

  2521.    $this->currentContents=$id;
    2522. 

  2522.    // also if this object is the primary contents for a page, then set the current page to its parent
    2523. 

  2523.    if (isset($this->objects[$id]['onPage'])){
    2524. 

  2524.      $this->currentPage = $this->objects[$id]['onPage'];
    2525. 

  2525.    }
    2526. 

  2526. }
    2527. 

  2527. 

  2528. /**
    2529. 

  2529. * close an object
    2530. 

  2530. */
    2531. 

  2531. function closeObject(){
    2532. 

  2532.   // close the object, as long as there was one open in the first place, which will be indicated by
    2533. 

  2533.   // an objectId on the stack.
    2534. 

  2534.   if ($this->nStack>0){
    2535. 

  2535.     $this->currentContents=$this->stack[$this->nStack]['c'];
    2536. 

  2536.     $this->currentPage=$this->stack[$this->nStack]['p'];
    2537. 

  2537.     $this->nStack--;
    2538. 

  2538.     // easier to probably not worry about removing the old entries, they will be overwritten
    2539. 

  2539.     // if there are new ones.
    2540. 

  2540.   }
    2541. 

  2541. }
    2542. 

  2542. 

  2543. /**
    2544. 

  2544. * stop an object from appearing on pages from this point on
    2545. 

  2545. */
    2546. 

  2546. function stopObject($id){
    2547. 

  2547.   // if an object has been appearing on pages up to now, then stop it, this page will
    2548. 

  2548.   // be the last one that could contian it.
    2549. 

  2549.   if (isset($this->addLooseObjects[$id])){
    2550. 

  2550.     $this->addLooseObjects[$id]='';
    2551. 

  2551.   }
    2552. 

  2552. }
    2553. 

  2553. 

  2554. /**
    2555. 

  2555. * after an object has been created, it wil only show if it has been added, using this function.
    2556. 

  2556. */
    2557. 

  2557. function addObject($id,$options='add'){
    2558. 

  2558.   // add the specified object to the page
    2559. 

  2559.   if (isset($this->looseObjects[$id]) && $this->currentContents!=$id){
    2560. 

  2560.     // then it is a valid object, and it is not being added to itself
    2561. 

  2561.     switch($options){
    2562. 

  2562.       case 'all':
    2563. 

  2563.         // then this object is to be added to this page (done in the next block) and
    2564. 

  2564.         // all future new pages.
    2565. 

  2565.         $this->addLooseObjects[$id]='all';
    2566. 

  2566.       case 'add':
    2567. 

  2567.         if (isset($this->objects[$this->currentContents]['onPage'])){
    2568. 

  2568.           // then the destination contents is the primary for the page
    2569. 

  2569.           // (though this object is actually added to that page)
    2570. 

  2570.           $this->o_page($this->objects[$this->currentContents]['onPage'],'content',$id);
    2571. 

  2571.         }
    2572. 

  2572.         break;
    2573. 

  2573.       case 'even':
    2574. 

  2574.         $this->addLooseObjects[$id]='even';
    2575. 

  2575.         $pageObjectId=$this->objects[$this->currentContents]['onPage'];
    2576. 

  2576.         if ($this->objects[$pageObjectId]['info']['pageNum']%2==0){
    2577. 

  2577.           $this->addObject($id); // hacky huh :)
    2578. 

  2578.         }
    2579. 

  2579.         break;
    2580. 

  2580.       case 'odd':
    2581. 

  2581.         $this->addLooseObjects[$id]='odd';
    2582. 

  2582.         $pageObjectId=$this->objects[$this->currentContents]['onPage'];
    2583. 

  2583.         if ($this->objects[$pageObjectId]['info']['pageNum']%2==1){
    2584. 

  2584.           $this->addObject($id); // hacky huh :)
    2585. 

  2585.         }
    2586. 

  2586.         break;
    2587. 

  2587.       case 'next':
    2588. 

  2588.         $this->addLooseObjects[$id]='all';
    2589. 

  2589.         break;
    2590. 

  2590.       case 'nexteven':
    2591. 

  2591.         $this->addLooseObjects[$id]='even';
    2592. 

  2592.         break;
    2593. 

  2593.       case 'nextodd':
    2594. 

  2594.         $this->addLooseObjects[$id]='odd';
    2595. 

  2595.         break;
    2596. 

  2596.     }
    2597. 

  2597.   }
    2598. 

  2598. }
    2599. 

  2599. 

  2600. /**
    2601. 

  2601. * add content to the documents info object
    2602. 

  2602. */
    2603. 

  2603. function addInfo($label,$value=0){
    2604. 

  2604.   // this will only work if the label is one of the valid ones.
    2605. 

  2605.   // modify this so that arrays can be passed as well.
    2606. 

  2606.   // if $label is an array then assume that it is key=>value pairs
    2607. 

  2607.   // else assume that they are both scalar, anything else will probably error
    2608. 

  2608.   if (is_array($label)){
    2609. 

  2609.     foreach ($label as $l=>$v){
    2610. 

  2610.       $this->o_info($this->infoObject,$l,$v);
    2611. 

  2611.     }
    2612. 

  2612.   } else {
    2613. 

  2613.     $this->o_info($this->infoObject,$label,$value);
    2614. 

  2614.   }
    2615. 

  2615. }
    2616. 

  2616. 

  2617. /**
    2618. 

  2618. * set the viewer preferences of the document, it is up to the browser to obey these.
    2619. 

  2619. */
    2620. 

  2620. function setPreferences($label,$value=0){
    2621. 

  2621.   // this will only work if the label is one of the valid ones.
    2622. 

  2622.   if (is_array($label)){
    2623. 

  2623.     foreach ($label as $l=>$v){
    2624. 

  2624.       $this->o_catalog($this->catalogId,'viewerPreferences',array($l=>$v));
    2625. 

  2625.     }
    2626. 

  2626.   } else {
    2627. 

  2627.     $this->o_catalog($this->catalogId,'viewerPreferences',array($label=>$value));
    2628. 

  2628.   }
    2629. 

  2629. }
    2630. 

  2630. 

  2631. /**
    2632. 

  2632. * extract an integer from a position in a byte stream
    2633. 

  2633. *
    2634. 

  2634. * @access private
    2635. 

  2635. */
    2636. 

  2636. function PRVT_getBytes(&$data,$pos,$num){
    2637. 

  2637.   // return the integer represented by $num bytes from $pos within $data
    2638. 

  2638.   $ret=0;
    2639. 

  2639.   for ($i=0;$i<$num;$i++){
    2640. 

  2640.     $ret=$ret*256;
    2641. 

  2641.     $ret+=ord($data[$pos+$i]);
    2642. 

  2642.   }
    2643. 

  2643.   return $ret;
    2644. 

  2644. }
    2645. 

  2645. 

  2646. /**
    2647. 

  2647. * add a PNG image into the document, from a file
    2648. 

  2648. * this should work with remote files
    2649. 

  2649. */
    2650. 

  2650. function addPngFromFile($file,$x,$y,$w=0,$h=0){
    2651. 

  2651.   // read in a png file, interpret it, then add to the system
    2652. 

  2652.   $error=0;
    2653. 

  2653.   $tmp = get_magic_quotes_runtime();
    2654. 

  2654.   set_magic_quotes_runtime(0);
    2655. 

  2655.   $fp = @fopen($file,'rb');
    2656. 

  2656.   if ($fp){
    2657. 

  2657.     $data='';
    2658. 

  2658.     while(!feof($fp)){
    2659. 

  2659.       $data .= fread($fp,1024);
    2660. 

  2660.     }
    2661. 

  2661.     fclose($fp);
    2662. 

  2662.   } else {
    2663. 

  2663.     $error = 1;
    2664. 

  2664.     $errormsg = 'trouble opening file: '.$file;
    2665. 

  2665.   }
    2666. 

  2666.   set_magic_quotes_runtime($tmp);
    2667. 

  2667. 

  2668.   if (!$error){
    2669. 

  2669.     $header = chr(137).chr(80).chr(78).chr(71).chr(13).chr(10).chr(26).chr(10);
    2670. 

  2670.     if (substr($data,0,8)!=$header){
    2671. 

  2671.       $error=1;
    2672. 

  2672.       $errormsg = 'this file does not have a valid header';
    2673. 

  2673.     }
    2674. 

  2674.   }
    2675. 

  2675. 

  2676.   if (!$error){
    2677. 

  2677.     // set pointer
    2678. 

  2678.     $p = 8;
    2679. 

  2679.     $len = strlen($data);
    2680. 

  2680.     // cycle through the file, identifying chunks
    2681. 

  2681.     $haveHeader=0;
    2682. 

  2682.     $info=array();
    2683. 

  2683.     $idata='';
    2684. 

  2684.     $pdata='';
    2685. 

  2685.     while ($p<$len){
    2686. 

  2686.       $chunkLen = $this->PRVT_getBytes($data,$p,4);
    2687. 

  2687.       $chunkType = substr($data,$p+4,4);
    2688. 

  2688. //      echo $chunkType.' - '.$chunkLen.'<br>';
    2689. 

  2689. 

  2690.       switch($chunkType){
    2691. 

  2691.         case 'IHDR':
    2692. 

  2692.           // this is where all the file information comes from
    2693. 

  2693.           $info['width']=$this->PRVT_getBytes($data,$p+8,4);
    2694. 

  2694.           $info['height']=$this->PRVT_getBytes($data,$p+12,4);
    2695. 

  2695.           $info['bitDepth']=ord($data[$p+16]);
    2696. 

  2696.           $info['colorType']=ord($data[$p+17]);
    2697. 

  2697.           $info['compressionMethod']=ord($data[$p+18]);
    2698. 

  2698.           $info['filterMethod']=ord($data[$p+19]);
    2699. 

  2699.           $info['interlaceMethod']=ord($data[$p+20]);
    2700. 

  2700. //print_r($info);
    2701. 

  2701.           $haveHeader=1;
    2702. 

  2702.           if ($info['compressionMethod']!=0){
    2703. 

  2703.             $error=1;
    2704. 

  2704.             $errormsg = 'unsupported compression method';
    2705. 

  2705.           }
    2706. 

  2706.           if ($info['filterMethod']!=0){
    2707. 

  2707.             $error=1;
    2708. 

  2708.             $errormsg = 'unsupported filter method';
    2709. 

  2709.           }
    2710. 

  2710.           break;
    2711. 

  2711.         case 'PLTE':
    2712. 

  2712.           $pdata.=substr($data,$p+8,$chunkLen);
    2713. 

  2713.           break;
    2714. 

  2714.         case 'IDAT':
    2715. 

  2715.           $idata.=substr($data,$p+8,$chunkLen);
    2716. 

  2716.           break;
    2717. 

  2717.         case 'tRNS':
    2718. 

  2718.           //this chunk can only occur once and it must occur after the PLTE chunk and before IDAT chunk
    2719. 

  2719.           //print "tRNS found, color type = ".$info['colorType']."<BR>";
    2720. 

  2720.           $transparency = array();
    2721. 

  2721.           if ($info['colorType'] == 3) { // indexed color, rbg
    2722. 

  2722.           /* corresponding to entries in the plte chunk
    2723. 

  2723.           Alpha for palette index 0: 1 byte
    2724. 

  2724.           Alpha for palette index 1: 1 byte
    2725. 

  2725.           ...etc...
    2726. 

  2726.           */
    2727. 

  2727.             // there will be one entry for each palette entry. up until the last non-opaque entry.
    2728. 

  2728.             // set up an array, stretching over all palette entries which will be o (opaque) or 1 (transparent)
    2729. 

  2729.             $transparency['type']='indexed';
    2730. 

  2730.             $numPalette = strlen($pdata)/3;
    2731. 

  2731.             $trans=0;
    2732. 

  2732.             for ($i=$chunkLen;$i>=0;$i--){
    2733. 

  2733.               if (ord($data[$p+8+$i])==0){
    2734. 

  2734.                 $trans=$i;
    2735. 

  2735.               }
    2736. 

  2736.             }
    2737. 

  2737.             $transparency['data'] = $trans;
    2738. 

  2738. 

  2739.           } elseif($info['colorType'] == 0) { // grayscale
    2740. 

  2740.           /* corresponding to entries in the plte chunk
    2741. 

  2741.           Gray: 2 bytes, range 0 .. (2^bitdepth)-1
    2742. 

  2742.           */
    2743. 

  2743. //            $transparency['grayscale']=$this->PRVT_getBytes($data,$p+8,2); // g = grayscale
    2744. 

  2744.             $transparency['type']='indexed';
    2745. 

  2745.             $transparency['data'] = ord($data[$p+8+1]);
    2746. 

  2746. 

  2747.           } elseif($info['colorType'] == 2) { // truecolor
    2748. 

  2748.           /* corresponding to entries in the plte chunk
    2749. 

  2749.           Red: 2 bytes, range 0 .. (2^bitdepth)-1
    2750. 

  2750.           Green: 2 bytes, range 0 .. (2^bitdepth)-1
    2751. 

  2751.           Blue: 2 bytes, range 0 .. (2^bitdepth)-1
    2752. 

  2752.           */
    2753. 

  2753.             $transparency['r']=$this->PRVT_getBytes($data,$p+8,2); // r from truecolor
    2754. 

  2754.             $transparency['g']=$this->PRVT_getBytes($data,$p+10,2); // g from truecolor
    2755. 

  2755.             $transparency['b']=$this->PRVT_getBytes($data,$p+12,2); // b from truecolor
    2756. 

  2756. 

  2757.           } else {
    2758. 

  2758.           //unsupported transparency type
    2759. 

  2759.           }
    2760. 

  2760.           // KS End new code
    2761. 

  2761.           break;
    2762. 

  2762.         default:
    2763. 

  2763.           break;
    2764. 

  2764.       }
    2765. 

  2765. 

  2766.       $p += $chunkLen+12;
    2767. 

  2767.     }
    2768. 

  2768. 

  2769.     if(!$haveHeader){
    2770. 

  2770.       $error = 1;
    2771. 

  2771.       $errormsg = 'information header is missing';
    2772. 

  2772.     }
    2773. 

  2773.     if (isset($info['interlaceMethod']) && $info['interlaceMethod']){
    2774. 

  2774.       $error = 1;
    2775. 

  2775.       $errormsg = 'There appears to be no support for interlaced images in pdf.';
    2776. 

  2776.     }
    2777. 

  2777.   }
    2778. 

  2778. 

  2779.   if (!$error && $info['bitDepth'] > 8){
    2780. 

  2780.     $error = 1;
    2781. 

  2781.     $errormsg = 'only bit depth of 8 or less is supported';
    2782. 

  2782.   }
    2783. 

  2783. 

  2784.   if (!$error){
    2785. 

  2785.     if ($info['colorType']!=2 && $info['colorType']!=0 && $info['colorType']!=3){
    2786. 

  2786.       $error = 1;
    2787. 

  2787.       $errormsg = 'transparancey alpha channel not supported, transparency only supported for palette images.';
    2788. 

  2788.     } else {
    2789. 

  2789.       switch ($info['colorType']){
    2790. 

  2790.         case 3:
    2791. 

  2791.           $color = 'DeviceRGB';
    2792. 

  2792.           $ncolor=1;
    2793. 

  2793.           break;
    2794. 

  2794.         case 2:
    2795. 

  2795.           $color = 'DeviceRGB';
    2796. 

  2796.           $ncolor=3;
    2797. 

  2797.           break;
    2798. 

  2798.         case 0:
    2799. 

  2799.           $color = 'DeviceGray';
    2800. 

  2800.           $ncolor=1;
    2801. 

  2801.           break;
    2802. 

  2802.       }
    2803. 

  2803.     }
    2804. 

  2804.   }
    2805. 

  2805.   if ($error){
    2806. 

  2806.     $this->addMessage('PNG error - ('.$file.') '.$errormsg);
    2807. 

  2807.     return;
    2808. 

  2808.   }
    2809. 

  2809.   if ($w==0){
    2810. 

  2810.     $w=$h/$info['height']*$info['width'];
    2811. 

  2811.   }
    2812. 

  2812.   if ($h==0){
    2813. 

  2813.     $h=$w*$info['height']/$info['width'];
    2814. 

  2814.   }
    2815. 

  2815. //print_r($info);
    2816. 

  2816.   // so this image is ok... add it in.
    2817. 

  2817.   $this->numImages++;
    2818. 

  2818.   $im=$this->numImages;
    2819. 

  2819.   $label='I'.$im;
    2820. 

  2820.   $this->numObj++;
    2821. 

  2821. //  $this->o_image($this->numObj,'new',array('label'=>$label,'data'=>$idata,'iw'=>$w,'ih'=>$h,'type'=>'png','ic'=>$info['width']));
    2822. 

  2822.   $options = array('label'=>$label,'data'=>$idata,'bitsPerComponent'=>$info['bitDepth'],'pdata'=>$pdata
    2823. 

  2823.                                       ,'iw'=>$info['width'],'ih'=>$info['height'],'type'=>'png','color'=>$color,'ncolor'=>$ncolor);
    2824. 

  2824.   if (isset($transparency)){
    2825. 

  2825.     $options['transparency']=$transparency;
    2826. 

  2826.   }
    2827. 

  2827.   $this->o_image($this->numObj,'new',$options);
    2828. 

  2828. 

  2829.   $this->objects[$this->currentContents]['c'].="\nq";
    2830. 

  2830.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$w)." 0 0 ".sprintf('%.3f',$h)." ".sprintf('%.3f',$x)." ".sprintf('%.3f',$y)." cm";
    2831. 

  2831.   $this->objects[$this->currentContents]['c'].="\n/".$label.' Do';
    2832. 

  2832.   $this->objects[$this->currentContents]['c'].="\nQ";
    2833. 

  2833. }
    2834. 

  2834. 

  2835. /**
    2836. 

  2836. * add a JPEG image into the document, from a file
    2837. 

  2837. */
    2838. 

  2838. function addJpegFromFile($img,$x,$y,$w=0,$h=0){
    2839. 

  2839.   // attempt to add a jpeg image straight from a file, using no GD commands
    2840. 

  2840.   // note that this function is unable to operate on a remote file.
    2841. 

  2841. 

  2842.   if (!file_exists($img)){
    2843. 

  2843.     return;
    2844. 

  2844.   }
    2845. 

  2845. 

  2846.   $tmp=getimagesize($img);
    2847. 

  2847.   $imageWidth=$tmp[0];
    2848. 

  2848.   $imageHeight=$tmp[1];
    2849. 

  2849. 

  2850.   if (isset($tmp['channels'])){
    2851. 

  2851.     $channels = $tmp['channels'];
    2852. 

  2852.   } else {
    2853. 

  2853.     $channels = 3;
    2854. 

  2854.   }
    2855. 

  2855. 

  2856.   if ($w<=0 && $h<=0){
    2857. 

  2857.     $w=$imageWidth;
    2858. 

  2858.   }
    2859. 

  2859.   if ($w==0){
    2860. 

  2860.     $w=$h/$imageHeight*$imageWidth;
    2861. 

  2861.   }
    2862. 

  2862.   if ($h==0){
    2863. 

  2863.     $h=$w*$imageHeight/$imageWidth;
    2864. 

  2864.   }
    2865. 

  2865. 

  2866.   $fp=fopen($img,'rb');
    2867. 

  2867. 

  2868.   $tmp = get_magic_quotes_runtime();
    2869. 

  2869.   set_magic_quotes_runtime(0);
    2870. 

  2870.   $data = fread($fp,filesize($img));
    2871. 

  2871.   set_magic_quotes_runtime($tmp);
    2872. 

  2872. 

  2873.   fclose($fp);
    2874. 

  2874. 

  2875.   $this->addJpegImage_common($data,$x,$y,$w,$h,$imageWidth,$imageHeight,$channels);
    2876. 

  2876. }
    2877. 

  2877. 

  2878. /**
    2879. 

  2879. * add an image into the document, from a GD object
    2880. 

  2880. * this function is not all that reliable, and I would probably encourage people to use
    2881. 

  2881. * the file based functions
    2882. 

  2882. */
    2883. 

  2883. function addImage(&$img,$x,$y,$w=0,$h=0,$quality=75){
    2884. 

  2884.   // add a new image into the current location, as an external object
    2885. 

  2885.   // add the image at $x,$y, and with width and height as defined by $w & $h
    2886. 

  2886. 

  2887.   // note that this will only work with full colour images and makes them jpg images for display
    2888. 

  2888.   // later versions could present lossless image formats if there is interest.
    2889. 

  2889. 

  2890.   // there seems to be some problem here in that images that have quality set above 75 do not appear
    2891. 

  2891.   // not too sure why this is, but in the meantime I have restricted this to 75.
    2892. 

  2892.   if ($quality>75){
    2893. 

  2893.     $quality=75;
    2894. 

  2894.   }
    2895. 

  2895. 

  2896.   // if the width or height are set to zero, then set the other one based on keeping the image
    2897. 

  2897.   // height/width ratio the same, if they are both zero, then give up :)
    2898. 

  2898.   $imageWidth=imagesx($img);
    2899. 

  2899.   $imageHeight=imagesy($img);
    2900. 

  2900. 

  2901.   if ($w<=0 && $h<=0){
    2902. 

  2902.     return;
    2903. 

  2903.   }
    2904. 

  2904.   if ($w==0){
    2905. 

  2905.     $w=$h/$imageHeight*$imageWidth;
    2906. 

  2906.   }
    2907. 

  2907.   if ($h==0){
    2908. 

  2908.     $h=$w*$imageHeight/$imageWidth;
    2909. 

  2909.   }
    2910. 

  2910. 

  2911.   // gotta get the data out of the img..
    2912. 

  2912. 

  2913.   // so I write to a temp file, and then read it back.. soo ugly, my apologies.
    2914. 

  2914.   $tmpDir='/tmp';
    2915. 

  2915.   $tmpName=tempnam($tmpDir,'img');
    2916. 

  2916.   imagejpeg($img,$tmpName,$quality);
    2917. 

  2917.   $fp=fopen($tmpName,'rb');
    2918. 

  2918. 

  2919.   $tmp = get_magic_quotes_runtime();
    2920. 

  2920.   set_magic_quotes_runtime(0);
    2921. 

  2921.   $fp = @fopen($tmpName,'rb');
    2922. 

  2922.   if ($fp){
    2923. 

  2923.     $data='';
    2924. 

  2924.     while(!feof($fp)){
    2925. 

  2925.       $data .= fread($fp,1024);
    2926. 

  2926.     }
    2927. 

  2927.     fclose($fp);
    2928. 

  2928.   } else {
    2929. 

  2929.     $error = 1;
    2930. 

  2930.     $errormsg = 'trouble opening file';
    2931. 

  2931.   }
    2932. 

  2932. //  $data = fread($fp,filesize($tmpName));
    2933. 

  2933.   set_magic_quotes_runtime($tmp);
    2934. 

  2934. //  fclose($fp);
    2935. 

  2935.   unlink($tmpName);
    2936. 

  2936.   $this->addJpegImage_common($data,$x,$y,$w,$h,$imageWidth,$imageHeight);
    2937. 

  2937. }
    2938. 

  2938. 

  2939. /**
    2940. 

  2940. * common code used by the two JPEG adding functions
    2941. 

  2941. *
    2942. 

  2942. * @access private
    2943. 

  2943. */
    2944. 

  2944. function addJpegImage_common(&$data,$x,$y,$w=0,$h=0,$imageWidth,$imageHeight,$channels=3){
    2945. 

  2945.   // note that this function is not to be called externally
    2946. 

  2946.   // it is just the common code between the GD and the file options
    2947. 

  2947.   $this->numImages++;
    2948. 

  2948.   $im=$this->numImages;
    2949. 

  2949.   $label='I'.$im;
    2950. 

  2950.   $this->numObj++;
    2951. 

  2951.   $this->o_image($this->numObj,'new',array('label'=>$label,'data'=>$data,'iw'=>$imageWidth,'ih'=>$imageHeight,'channels'=>$channels));
    2952. 

  2952. 

  2953.   $this->objects[$this->currentContents]['c'].="\nq";
    2954. 

  2954.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$w)." 0 0 ".sprintf('%.3f',$h)." ".sprintf('%.3f',$x)." ".sprintf('%.3f',$y)." cm";
    2955. 

  2955.   $this->objects[$this->currentContents]['c'].="\n/".$label.' Do';
    2956. 

  2956.   $this->objects[$this->currentContents]['c'].="\nQ";
    2957. 

  2957. }
    2958. 

  2958. 

  2959. /**
    2960. 

  2960. * specify where the document should open when it first starts
    2961. 

  2961. */
    2962. 

  2962. function openHere($style,$a=0,$b=0,$c=0){
    2963. 

  2963.   // this function will open the document at a specified page, in a specified style
    2964. 

  2964.   // the values for style, and the required paramters are:
    2965. 

  2965.   // 'XYZ'  left, top, zoom
    2966. 

  2966.   // 'Fit'
    2967. 

  2967.   // 'FitH' top
    2968. 

  2968.   // 'FitV' left
    2969. 

  2969.   // 'FitR' left,bottom,right
    2970. 

  2970.   // 'FitB'
    2971. 

  2971.   // 'FitBH' top
    2972. 

  2972.   // 'FitBV' left
    2973. 

  2973.   $this->numObj++;
    2974. 

  2974.   $this->o_destination($this->numObj,'new',array('page'=>$this->currentPage,'type'=>$style,'p1'=>$a,'p2'=>$b,'p3'=>$c));
    2975. 

  2975.   $id = $this->catalogId;
    2976. 

  2976.   $this->o_catalog($id,'openHere',$this->numObj);
    2977. 

  2977. }
    2978. 

  2978. 

  2979. /**
    2980. 

  2980. * create a labelled destination within the document
    2981. 

  2981. */
    2982. 

  2982. function addDestination($label,$style,$a=0,$b=0,$c=0){
    2983. 

  2983.   // associates the given label with the destination, it is done this way so that a destination can be specified after
    2984. 

  2984.   // it has been linked to
    2985. 

  2985.   // styles are the same as the 'openHere' function
    2986. 

  2986.   $this->numObj++;
    2987. 

  2987.   $this->o_destination($this->numObj,'new',array('page'=>$this->currentPage,'type'=>$style,'p1'=>$a,'p2'=>$b,'p3'=>$c));
    2988. 

  2988.   $id = $this->numObj;
    2989. 

  2989.   // store the label->idf relationship, note that this means that labels can be used only once
    2990. 

  2990.   $this->destinations["$label"]=$id;
    2991. 

  2991. }
    2992. 

  2992. 

  2993. /**
    2994. 

  2994. * define font families, this is used to initialize the font families for the default fonts
    2995. 

  2995. * and for the user to add new ones for their fonts. The default bahavious can be overridden should
    2996. 

  2996. * that be desired.
    2997. 

  2997. */
    2998. 

  2998. function setFontFamily($family,$options=''){
    2999. 

  2999.   if (!is_array($options)){
    3000. 

  3000.     if ($family=='init'){
    3001. 

  3001.       // set the known family groups
    3002. 

  3002.       // these font families will be used to enable bold and italic markers to be included
    3003. 

  3003.       // within text streams. html forms will be used... <b></b> <i></i>
    3004. 

  3004.       $this->fontFamilies['Helvetica.afm']=array(
    3005. 

  3005.          'b'=>'Helvetica-Bold.afm'
    3006. 

  3006.         ,'i'=>'Helvetica-Oblique.afm'
    3007. 

  3007.         ,'bi'=>'Helvetica-BoldOblique.afm'
    3008. 

  3008.         ,'ib'=>'Helvetica-BoldOblique.afm'
    3009. 

  3009.       );
    3010. 

  3010.       $this->fontFamilies['Courier.afm']=array(
    3011. 

  3011.          'b'=>'Courier-Bold.afm'
    3012. 

  3012.         ,'i'=>'Courier-Oblique.afm'
    3013. 

  3013.         ,'bi'=>'Courier-BoldOblique.afm'
    3014. 

  3014.         ,'ib'=>'Courier-BoldOblique.afm'
    3015. 

  3015.       );
    3016. 

  3016.       $this->fontFamilies['Times-Roman.afm']=array(
    3017. 

  3017.          'b'=>'Times-Bold.afm'
    3018. 

  3018.         ,'i'=>'Times-Italic.afm'
    3019. 

  3019.         ,'bi'=>'Times-BoldItalic.afm'
    3020. 

  3020.         ,'ib'=>'Times-BoldItalic.afm'
    3021. 

  3021.       );
    3022. 

  3022.     }
    3023. 

  3023.   } else {
    3024. 

  3024.     // the user is trying to set a font family
    3025. 

  3025.     // note that this can also be used to set the base ones to something else
    3026. 

  3026.     if (strlen($family)){
    3027. 

  3027.       $this->fontFamilies[$family] = $options;
    3028. 

  3028.     }
    3029. 

  3029.   }
    3030. 

  3030. }
    3031. 

  3031. 

  3032. /**
    3033. 

  3033. * used to add messages for use in debugging
    3034. 

  3034. */
    3035. 

  3035. function addMessage($message){
    3036. 

  3036.   $this->messages.=$message."\n";
    3037. 

  3037. }
    3038. 

  3038. 

  3039. /**
    3040. 

  3040. * a few functions which should allow the document to be treated transactionally.
    3041. 

  3041. */
    3042. 

  3042. function transaction($action){
    3043. 

  3043.   switch ($action){
    3044. 

  3044.     case 'start':
    3045. 

  3045.       // store all the data away into the checkpoint variable
    3046. 

  3046.       $data = get_object_vars($this);
    3047. 

  3047.       $this->checkpoint = $data;
    3048. 

  3048.       unset($data);
    3049. 

  3049.       break;
    3050. 

  3050.     case 'commit':
    3051. 

  3051.       if (is_array($this->checkpoint) && isset($this->checkpoint['checkpoint'])){
    3052. 

  3052.         $tmp = $this->checkpoint['checkpoint'];
    3053. 

  3053.         $this->checkpoint = $tmp;
    3054. 

  3054.         unset($tmp);
    3055. 

  3055.       } else {
    3056. 

  3056.         $this->checkpoint='';
    3057. 

  3057.       }
    3058. 

  3058.       break;
    3059. 

  3059.     case 'rewind':
    3060. 

  3060.       // do not destroy the current checkpoint, but move us back to the state then, so that we can try again
    3061. 

  3061.       if (is_array($this->checkpoint)){
    3062. 

  3062.         // can only abort if were inside a checkpoint
    3063. 

  3063.         $tmp = $this->checkpoint;
    3064. 

  3064.         foreach ($tmp as $k=>$v){
    3065. 

  3065.           if ($k != 'checkpoint'){
    3066. 

  3066.             $this->$k=$v;
    3067. 

  3067.           }
    3068. 

  3068.         }
    3069. 

  3069.         unset($tmp);
    3070. 

  3070.       }
    3071. 

  3071.       break;
    3072. 

  3072.     case 'abort':
    3073. 

  3073.       if (is_array($this->checkpoint)){
    3074. 

  3074.         // can only abort if were inside a checkpoint
    3075. 

  3075.         $tmp = $this->checkpoint;
    3076. 

  3076.         foreach ($tmp as $k=>$v){
    3077. 

  3077.           $this->$k=$v;
    3078. 

  3078.         }
    3079. 

  3079.         unset($tmp);
    3080. 

  3080.       }
    3081. 

  3081.       break;
    3082. 

  3082.   }
    3083. 

  3083. 

  3084. }
    3085. 

  3085. 

  3086. } // end of class
    3087. 

  3087. 

  3088. ?>
    3089. 

  3089.