PageRenderTime 90ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 1ms

/classes/phppdf/class.pdf.php

https://github.com/timschofield/2.8
PHP | 3101 lines | 2195 code | 169 blank | 737 comment | 395 complexity | 089bf8e23af093132e8c162926ff2b49 MD5 | raw file
Possible License(s): LGPL-2.1, BSD-3-Clause, GPL-2.0 
    

  1. <?php
    2. 

  2. /**
    3. 

  3. * Cpdf
    4. 

  4. *
    5. 

  5. * http://pdf-php.sourceforge.net/
    6. 

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

  7. *
    8. 

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

  9. * any requirement for additional modules.
    10. 

  10. *
    11. 

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

  12. * simplify the creation of documents.
    13. 

  13. *
    14. 

  14. * IMPORTANT NOTE
    15. 

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

  16. * 
    17. 

  17. * LICENCE
    18. 

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

  19. *
    20. 

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

  21. * @version 	010a
    22. 

  22. * @package	Cpdf
    23. 

  23. */
    24. 

  24. class Cpdf {
    25. 

  25. 

  26. /**
    27. 

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

  28. */
    29. 

  29. var $numObj=0;
    30. 

  30. /**
    31. 

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

  32. */
    33. 

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

  34. /**
    35. 

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

  36. */
    37. 

  37. var $catalogId;
    38. 

  38. /**
    39. 

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

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

  41. */
    42. 

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

  43. /**
    44. 

  44. * a record of the current font
    45. 

  45. */
    46. 

  46. var $currentFont='';
    47. 

  47. /**
    48. 

  48. * the current base font
    49. 

  49. */
    50. 

  50. var $currentBaseFont='';
    51. 

  51. /**
    52. 

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

  53. */
    54. 

  54. var $currentFontNum=0;
    55. 

  55. /**
    56. 

  56. * 
    57. 

  57. */
    58. 

  58. var $currentNode;
    59. 

  59. /**
    60. 

  60. * object number of the current page
    61. 

  61. */
    62. 

  62. var $currentPage;
    63. 

  63. /**
    64. 

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

  65. */
    66. 

  66. var $currentContents;
    67. 

  67. /**
    68. 

  68. * number of fonts within the system
    69. 

  69. */
    70. 

  70. var $numFonts=0;
    71. 

  71. /**
    72. 

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

  73. */
    74. 

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

  75. /**
    76. 

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

  77. */
    78. 

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

  79. /**
    80. 

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

  81. */
    82. 

  82. var $currentLineStyle='';
    83. 

  83. /**
    84. 

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

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

  86. */
    87. 

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

  88. /**
    89. 

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

  90. */
    91. 

  91. var $nStateStack = 0;
    92. 

  92. /**
    93. 

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

  94. */
    95. 

  95. var $numPages=0;
    96. 

  96. /**
    97. 

  97. * object Id storage stack
    98. 

  98. */
    99. 

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

  100. /**
    101. 

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

  102. */
    103. 

  103. var $nStack=0;
    104. 

  104. /**
    105. 

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

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

  107. */
    108. 

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

  109. /**
    110. 

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

  111. */
    112. 

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

  113. /**
    114. 

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

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

  116. */
    117. 

  117. var $infoObject=0;
    118. 

  118. /**
    119. 

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

  120. */
    121. 

  121. var $numImages=0;
    122. 

  122. /**
    123. 

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

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

  125. */
    126. 

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

  127. /**
    128. 

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

  129. */
    130. 

  130. var $firstPageId;
    131. 

  131. /**
    132. 

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

  133. * when the spacing is changed.
    134. 

  134. */
    135. 

  135. var $wordSpaceAdjust=0;
    136. 

  136. /**
    137. 

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

  138. */
    139. 

  139. var $procsetObjectId;
    140. 

  140. /**
    141. 

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

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

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

  144. */
    145. 

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

  146. /**
    147. 

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

  148. */
    149. 

  149. var $currentTextState = ''; 
    150. 

  150. /**
    151. 

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

  152. */
    153. 

  153. var $messages='';
    154. 

  154. /**
    155. 

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

  156. */
    157. 

  157. var $arc4='';
    158. 

  158. /**
    159. 

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

  160. */
    161. 

  161. var $arc4_objnum=0;
    162. 

  162. /**
    163. 

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

  164. */
    165. 

  165. var $fileIdentifier='';
    166. 

  166. /**
    167. 

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

  168. */
    169. 

  169. var $encrypted=0;
    170. 

  170. /**
    171. 

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

  172. */
    173. 

  173. var $encryptionKey='';
    174. 

  174. /**
    175. 

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

  176. */
    177. 

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

  178. /**
    179. 

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

  180. */
    181. 

  181. var $nCallback = 0;
    182. 

  182. /**
    183. 

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

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

  185. */
    186. 

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

  187. /**
    188. 

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

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

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

  191. */
    192. 

  192. var $checkpoint = '';
    193. 

  193. /**
    194. 

  194. * class constructor
    195. 

  195. * this will start a new document
    196. 

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

  197. */
    198. 

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

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

  200.   
    201. 

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

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

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

  204. 

  205. }
    206. 

  206. 

  207. /**
    208. 

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

  209. *
    210. 

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

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

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

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

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

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

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

  217. *
    218. 

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

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

  220. */
    221. 

  221. 

  222. /**
    223. 

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

  224. */
    225. 

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

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

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

  228.   }
    229. 

  229.   switch($action){
    230. 

  230.     case 'new':
    231. 

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

  232.       $tmp = '';
    233. 

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

  234.         case 'XYZ':
    235. 

  235.         case 'FitR':
    236. 

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

  237.         case 'FitH':
    238. 

  238.         case 'FitV':
    239. 

  239.         case 'FitBH':
    240. 

  240.         case 'FitBV':
    241. 

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

  242.         case 'Fit':
    243. 

  243.         case 'FitB':
    244. 

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

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

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

  247.       }
    248. 

  248.       break;
    249. 

  249.     case 'out':
    250. 

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

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

  252.       return $res;
    253. 

  253.       break;
    254. 

  254.   }
    255. 

  255. }
    256. 

  256. 

  257. /**
    258. 

  258. * set the viewer preferences
    259. 

  259. */
    260. 

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

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

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

  263.   }
    264. 

  264.   switch ($action){
    265. 

  265.     case 'new':
    266. 

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

  267.       break;
    268. 

  268.     case 'add':
    269. 

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

  270.         switch ($k){
    271. 

  271.           case 'HideToolbar':
    272. 

  272.           case 'HideMenubar':
    273. 

  273.           case 'HideWindowUI':
    274. 

  274.           case 'FitWindow':
    275. 

  275.           case 'CenterWindow':
    276. 

  276.           case 'NonFullScreenPageMode':
    277. 

  277.           case 'Direction':
    278. 

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

  279.           break;
    280. 

  280.         }
    281. 

  281.       }
    282. 

  282.       break;
    283. 

  283.     case 'out':
    284. 

  284. 

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

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

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

  288.       }
    289. 

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

  290.       return $res;
    291. 

  291.       break;
    292. 

  292.   }
    293. 

  293. }
    294. 

  294. 

  295. /**
    296. 

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

  297. */
    298. 

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

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

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

  301.   }
    302. 

  302.   switch ($action){
    303. 

  303.     case 'new':
    304. 

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

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

  306.       break;
    307. 

  307.     case 'outlines':
    308. 

  308.     case 'pages':
    309. 

  309.     case 'openHere':
    310. 

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

  311.       break;
    312. 

  312.     case 'viewerPreferences':
    313. 

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

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

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

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

  317.       }
    318. 

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

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

  320.       break;
    321. 

  321.     case 'out':
    322. 

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

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

  324.         switch($k){
    325. 

  325.           case 'outlines':
    326. 

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

  327.             break;
    328. 

  328.           case 'pages':
    329. 

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

  330.             break;
    331. 

  331.           case 'viewerPreferences':
    332. 

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

  333.             break;
    334. 

  334.           case 'openHere':
    335. 

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

  336.             break;
    337. 

  337.         }
    338. 

  338.       }
    339. 

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

  340.       return $res;
    341. 

  341.       break;
    342. 

  342.   }
    343. 

  343. }
    344. 

  344. 

  345. /**
    346. 

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

  347. */
    348. 

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

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

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

  351.   }
    352. 

  352.   switch ($action){
    353. 

  353.     case 'new':
    354. 

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

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

  356.       break;
    357. 

  357.     case 'page':
    358. 

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

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

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

  361.       } else {
    362. 

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

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

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

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

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

  367.             // then there is a match
    368. 

  368.             // make a space
    369. 

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

  370.               case 'before':
    371. 

  371.                 $k = $i;
    372. 

  372.                 break;
    373. 

  373.               case 'after':
    374. 

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

  375.                 break;
    376. 

  376.               default:
    377. 

  377.                 $k=-1;
    378. 

  378.                 break;
    379. 

  379.             }
    380. 

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

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

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

  383.               }
    384. 

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

  385.             }
    386. 

  386.           }
    387. 

  387.         } 
    388. 

  388.       }
    389. 

  389.       break;
    390. 

  390.     case 'procset':
    391. 

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

  392.       break;
    393. 

  393.     case 'mediaBox':
    394. 

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

  395.       break;
    396. 

  396.     case 'font':
    397. 

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

  398.       break;
    399. 

  399.     case 'xObject':
    400. 

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

  401.       break;
    402. 

  402.     case 'out':
    403. 

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

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

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

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

  407.         }
    408. 

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

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

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

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

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

  413.           }
    414. 

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

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

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

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

  418.             }
    419. 

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

  420.           }
    421. 

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

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

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

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

  425.             }
    426. 

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

  427.           }
    428. 

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

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

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

  431.             $res.="\n/MediaBox [".$tmp[0].' '.$tmp[1].' '.$tmp[2].' '.$tmp[3].']';
    432. 

  432.           }
    433. 

  433.         }
    434. 

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

  435.       } else {
    436. 

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

  437.       }
    438. 

  438.       return $res;
    439. 

  439.     break;
    440. 

  440.   }
    441. 

  441. }
    442. 

  442. 

  443. /**
    444. 

  444. * Beta Redirection function
    445. 

  445. */
    446. 

  446. function o_redirect($id,$action,$options=''){
    447. 

  447. 	switch($action){
    448. 

  448. 		case 'new':
    449. 

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

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

  451. 			break;
    452. 

  452. 		case 'out':
    453. 

  453. 			$o =& $this->objects[$id];
    454. 

  454. 			$tmp=$o['data'];
    455. 

  455. 			$res= "\n".$id." 0 obj\n<<";
    456. 

  456. 			$res.="/R".$o['data']." ".$o['data']." 0 R>>\nendobj\n";
    457. 

  457. 			return $res;
    458. 

  458. 			break;
    459. 

  459. 	}
    460. 

  460. }
    461. 

  461. 

  462. /**
    463. 

  463. * define the outlines in the doc, empty for now
    464. 

  464. */
    465. 

  465. function o_outlines($id,$action,$options=''){
    466. 

  466.   if ($action!='new'){
    467. 

  467.     $o =& $this->objects[$id];
    468. 

  468.   }
    469. 

  469.   switch ($action){
    470. 

  470.     case 'new':
    471. 

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

  472.       $this->o_catalog($this->catalogId,'outlines',$id);
    473. 

  473.       break;
    474. 

  474.     case 'outline':
    475. 

  475.       $o['info']['outlines'][]=$options;
    476. 

  476.       break;
    477. 

  477.     case 'out':
    478. 

  478.       if (count($o['info']['outlines'])){
    479. 

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

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

  481.           $res.=$v." 0 R ";
    482. 

  482.         }
    483. 

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

  484.       } else {
    485. 

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

  486.       }
    487. 

  487.       return $res;
    488. 

  488.       break;
    489. 

  489.   }
    490. 

  490. }
    491. 

  491. 

  492. /**
    493. 

  493. * an object to hold the font description
    494. 

  494. */
    495. 

  495. function o_font($id,$action,$options=''){
    496. 

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

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

  498.   }
    499. 

  499.   switch ($action){
    500. 

  500.     case 'new':
    501. 

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

  502.       $fontNum=$this->numFonts;
    503. 

  503.       $this->objects[$id]['info']['fontNum']=$fontNum;
    504. 

  504.       // deal with the encoding and the differences
    505. 

  505.       if (isset($options['differences'])){
    506. 

  506.         // then we'll need an encoding dictionary
    507. 

  507.         $this->numObj++;
    508. 

  508.         $this->o_fontEncoding($this->numObj,'new',$options);
    509. 

  509.         $this->objects[$id]['info']['encodingDictionary']=$this->numObj;
    510. 

  510.       } else if (isset($options['encoding'])){
    511. 

  511.         // we can specify encoding here
    512. 

  512.         switch($options['encoding']){
    513. 

  513.           case 'WinAnsiEncoding':
    514. 

  514.           case 'MacRomanEncoding':
    515. 

  515.           case 'MacExpertEncoding':
    516. 

  516.             $this->objects[$id]['info']['encoding']=$options['encoding'];
    517. 

  517.             break;
    518. 

  518.           case 'none':
    519. 

  519.             break;
    520. 

  520.           default:
    521. 

  521.             $this->objects[$id]['info']['encoding']='WinAnsiEncoding';
    522. 

  522.             break;
    523. 

  523.         }
    524. 

  524.       } else {
    525. 

  525.         $this->objects[$id]['info']['encoding']='WinAnsiEncoding';
    526. 

  526.       }
    527. 

  527.       // also tell the pages node about the new font
    528. 

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

  529.       break;
    530. 

  530.     case 'add':
    531. 

  531.       foreach ($options as $k=>$v){
    532. 

  532.         switch ($k){
    533. 

  533.           case 'BaseFont':
    534. 

  534.             $o['info']['name'] = $v;
    535. 

  535.             break;
    536. 

  536.           case 'FirstChar':
    537. 

  537.           case 'LastChar':
    538. 

  538.           case 'Widths':
    539. 

  539.           case 'FontDescriptor':
    540. 

  540.           case 'SubType':
    541. 

  541.           $this->addMessage('o_font '.$k." : ".$v);
    542. 

  542.             $o['info'][$k] = $v;
    543. 

  543.             break;
    544. 

  544.         }
    545. 

  545.      }
    546. 

  546.       break;
    547. 

  547.     case 'out':
    548. 

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

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

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

  551.       if (isset($o['info']['encodingDictionary'])){
    552. 

  552.         // then place a reference to the dictionary
    553. 

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

  554.       } else if (isset($o['info']['encoding'])){
    555. 

  555.         // use the specified encoding
    556. 

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

  557.       }
    558. 

  558.       if (isset($o['info']['FirstChar'])){
    559. 

  559.         $res.="/FirstChar ".$o['info']['FirstChar']."\n";
    560. 

  560.       }
    561. 

  561.       if (isset($o['info']['LastChar'])){
    562. 

  562.         $res.="/LastChar ".$o['info']['LastChar']."\n";
    563. 

  563.       }
    564. 

  564.       if (isset($o['info']['Widths'])){
    565. 

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

  566.       }
    567. 

  567.       if (isset($o['info']['FontDescriptor'])){
    568. 

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

  569.       }
    570. 

  570.       $res.=">>\nendobj";
    571. 

  571.       return $res;
    572. 

  572.       break;
    573. 

  573.   }
    574. 

  574. }
    575. 

  575. 

  576. /**
    577. 

  577. * a font descriptor, needed for including additional fonts
    578. 

  578. */
    579. 

  579. function o_fontDescriptor($id,$action,$options=''){
    580. 

  580.   if ($action!='new'){
    581. 

  581.     $o =& $this->objects[$id];
    582. 

  582.   }
    583. 

  583.   switch ($action){
    584. 

  584.     case 'new':
    585. 

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

  586.       break;
    587. 

  587.     case 'out':
    588. 

  588.       $res="\n".$id." 0 obj\n<< /Type /FontDescriptor\n";
    589. 

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

  590.         switch ($label){
    591. 

  591.           case 'Ascent':
    592. 

  592.           case 'CapHeight':
    593. 

  593.           case 'Descent':
    594. 

  594.           case 'Flags':
    595. 

  595.           case 'ItalicAngle':
    596. 

  596.           case 'StemV':
    597. 

  597.           case 'AvgWidth':
    598. 

  598.           case 'Leading':
    599. 

  599.           case 'MaxWidth':
    600. 

  600.           case 'MissingWidth':
    601. 

  601.           case 'StemH':
    602. 

  602.           case 'XHeight':
    603. 

  603.           case 'CharSet':
    604. 

  604.             if (strlen($value)){
    605. 

  605.               $res.='/'.$label.' '.$value."\n";
    606. 

  606.             }
    607. 

  607.             break;
    608. 

  608.           case 'FontFile':
    609. 

  609.           case 'FontFile2':
    610. 

  610.           case 'FontFile3':
    611. 

  611.             $res.='/'.$label.' '.$value." 0 R\n";
    612. 

  612.             break;
    613. 

  613.           case 'FontBBox':
    614. 

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

  615.             break;
    616. 

  616.           case 'FontName':
    617. 

  617.             $res.='/'.$label.' /'.$value."\n";
    618. 

  618.             break;
    619. 

  619.         }
    620. 

  620.       }
    621. 

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

  622.       return $res;
    623. 

  623.       break;
    624. 

  624.   }
    625. 

  625. }
    626. 

  626. 

  627. /**
    628. 

  628. * the font encoding
    629. 

  629. */
    630. 

  630. function o_fontEncoding($id,$action,$options=''){
    631. 

  631.   if ($action!='new'){
    632. 

  632.     $o =& $this->objects[$id];
    633. 

  633.   }
    634. 

  634.   switch ($action){
    635. 

  635.     case 'new':
    636. 

  636.       // the options array should contain 'differences' and maybe 'encoding'
    637. 

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

  638.       break;
    639. 

  639.     case 'out':
    640. 

  640.       $res="\n".$id." 0 obj\n<< /Type /Encoding\n";
    641. 

  641.       if (!isset($o['info']['encoding'])){
    642. 

  642.         $o['info']['encoding']='WinAnsiEncoding';
    643. 

  643.       }
    644. 

  644.       if ($o['info']['encoding']!='none'){
    645. 

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

  646.       }
    647. 

  647.       $res.="/Differences \n[";
    648. 

  648.       $onum=-100;
    649. 

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

  650.         if ($num!=$onum+1){
    651. 

  651.           // we cannot make use of consecutive numbering
    652. 

  652.           $res.= "\n".$num." /".$label;
    653. 

  653.         } else {
    654. 

  654.           $res.= " /".$label;
    655. 

  655.         }
    656. 

  656.         $onum=$num;
    657. 

  657.       }
    658. 

  658.       $res.="\n]\n>>\nendobj";
    659. 

  659.       return $res;
    660. 

  660.       break;
    661. 

  661.   }
    662. 

  662. }
    663. 

  663. 

  664. /**
    665. 

  665. * the document procset, solves some problems with printing to old PS printers
    666. 

  666. */
    667. 

  667. function o_procset($id,$action,$options=''){
    668. 

  668.   if ($action!='new'){
    669. 

  669.     $o =& $this->objects[$id];
    670. 

  670.   }
    671. 

  671.   switch ($action){
    672. 

  672.     case 'new':
    673. 

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

  674.       $this->o_pages($this->currentNode,'procset',$id);
    675. 

  675.       $this->procsetObjectId=$id;
    676. 

  676.       break;
    677. 

  677.     case 'add':
    678. 

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

  679.       // obselete, the items are required for printing to some postscript printers
    680. 

  680.       switch ($options) {
    681. 

  681.         case 'ImageB':
    682. 

  682.         case 'ImageC':
    683. 

  683.         case 'ImageI':
    684. 

  684.           $o['info'][$options]=1;
    685. 

  685.           break;
    686. 

  686.       }
    687. 

  687.       break;
    688. 

  688.     case 'out':
    689. 

  689.       $res="\n".$id." 0 obj\n[";
    690. 

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

  691.         $res.='/'.$label.' ';
    692. 

  692.       }
    693. 

  693.       $res.="]\nendobj";
    694. 

  694.       return $res;
    695. 

  695.       break;
    696. 

  696.   }
    697. 

  697. }
    698. 

  698. 

  699. /**
    700. 

  700. * define the document information
    701. 

  701. */
    702. 

  702. function o_info($id,$action,$options=''){
    703. 

  703.   if ($action!='new'){
    704. 

  704.     $o =& $this->objects[$id];
    705. 

  705.   }
    706. 

  706.   switch ($action){
    707. 

  707.     case 'new':
    708. 

  708.       $this->infoObject=$id;
    709. 

  709.       $date='D:'.date('Ymd');
    710. 

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

  711.       break;
    712. 

  712.     case 'Title':
    713. 

  713.     case 'Author':
    714. 

  714.     case 'Subject':
    715. 

  715.     case 'Keywords':
    716. 

  716.     case 'Creator':
    717. 

  717.     case 'Producer':
    718. 

  718.     case 'CreationDate':
    719. 

  719.     case 'ModDate':
    720. 

  720.     case 'Trapped':
    721. 

  721.       $o['info'][$action]=$options;
    722. 

  722.       break;
    723. 

  723.     case 'out':
    724. 

  724.       if ($this->encrypted){
    725. 

  725.         $this->encryptInit($id);
    726. 

  726.       }
    727. 

  727.       $res="\n".$id." 0 obj\n<<\n";
    728. 

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

  729.         $res.='/'.$k.' (';
    730. 

  730.         if ($this->encrypted){
    731. 

  731.           $res.=$this->filterText($this->ARC4($v));
    732. 

  732.         } else {
    733. 

  733.           $res.=$this->filterText($v);
    734. 

  734.         }
    735. 

  735.         $res.=")\n";
    736. 

  736.       }
    737. 

  737.       $res.=">>\nendobj";
    738. 

  738.       return $res;
    739. 

  739.       break;
    740. 

  740.   }
    741. 

  741. }
    742. 

  742. 

  743. /**
    744. 

  744. * an action object, used to link to URLS initially
    745. 

  745. */
    746. 

  746. function o_action($id,$action,$options=''){
    747. 

  747.   if ($action!='new'){
    748. 

  748.     $o =& $this->objects[$id];
    749. 

  749.   }
    750. 

  750.   switch ($action){
    751. 

  751.     case 'new':
    752. 

  752.       if (is_array($options)){
    753. 

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

  754.       } else {
    755. 

  755.         // then assume a URI action
    756. 

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

  757.       }
    758. 

  758.       break;
    759. 

  759.     case 'out':
    760. 

  760.       if ($this->encrypted){
    761. 

  761.         $this->encryptInit($id);
    762. 

  762.       }
    763. 

  763.       $res="\n".$id." 0 obj\n<< /Type /Action";
    764. 

  764.       switch($o['type']){
    765. 

  765.         case 'ilink':
    766. 

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

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

  768.           break;
    769. 

  769.         case 'URI':
    770. 

  770.           $res.="\n/S /URI\n/URI (";
    771. 

  771.           if ($this->encrypted){
    772. 

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

  773.           } else {
    774. 

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

  775.           }
    776. 

  776.           $res.=")";
    777. 

  777.           break;
    778. 

  778.       }
    779. 

  779.       $res.="\n>>\nendobj";
    780. 

  780.       return $res;
    781. 

  781.       break;
    782. 

  782.   }
    783. 

  783. }
    784. 

  784. 

  785. /**
    786. 

  786. * an annotation object, this will add an annotation to the current page.
    787. 

  787. * initially will support just link annotations 
    788. 

  788. */
    789. 

  789. function o_annotation($id,$action,$options=''){
    790. 

  790.   if ($action!='new'){
    791. 

  791.     $o =& $this->objects[$id];
    792. 

  792.   }
    793. 

  793.   switch ($action){
    794. 

  794.     case 'new':
    795. 

  795.       // add the annotation to the current page
    796. 

  796.       $pageId = $this->currentPage;
    797. 

  797.       $this->o_page($pageId,'annot',$id);
    798. 

  798.       // and add the action object which is going to be required
    799. 

  799.       switch($options['type']){
    800. 

  800.         case 'link':
    801. 

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

  802.           $this->numObj++;
    803. 

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

  804.           $this->objects[$id]['info']['actionId']=$this->numObj;
    805. 

  805.           break;
    806. 

  806.         case 'ilink':
    807. 

  807.           // this is to a named internal link
    808. 

  808.           $label = $options['label'];
    809. 

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

  810.           $this->numObj++;
    811. 

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

  812.           $this->objects[$id]['info']['actionId']=$this->numObj;
    813. 

  813.           break;
    814. 

  814.       }
    815. 

  815.       break;
    816. 

  816.     case 'out':
    817. 

  817.       $res="\n".$id." 0 obj\n<< /Type /Annot";
    818. 

  818.       switch($o['info']['type']){
    819. 

  819.         case 'link':
    820. 

  820.         case 'ilink':
    821. 

  821.           $res.= "\n/Subtype /Link";
    822. 

  822.           break;
    823. 

  823.       }
    824. 

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

  825.       $res.="\n/Border [0 0 0]";
    826. 

  826.       $res.="\n/H /I";
    827. 

  827.       $res.="\n/Rect [ ";
    828. 

  828.       foreach($o['info']['rect'] as $v){
    829. 

  829.         $res.= sprintf("%.4F ",$v);
    830. 

  830.       }
    831. 

  831.       $res.="]";
    832. 

  832.       $res.="\n>>\nendobj";
    833. 

  833.       return $res;
    834. 

  834.       break;
    835. 

  835.   }
    836. 

  836. }
    837. 

  837. 

  838. /**
    839. 

  839. * a page object, it also creates a contents object to hold its contents
    840. 

  840. */
    841. 

  841. function o_page($id,$action,$options=''){
    842. 

  842.   if ($action!='new'){
    843. 

  843.     $o =& $this->objects[$id];
    844. 

  844.   }
    845. 

  845.   switch ($action){
    846. 

  846.     case 'new':
    847. 

  847.       $this->numPages++;
    848. 

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

  849.       if (is_array($options)){
    850. 

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

  851.         $options['id']=$id;
    852. 

  852.         $this->o_pages($this->currentNode,'page',$options);
    853. 

  853.       } else {
    854. 

  854.         $this->o_pages($this->currentNode,'page',$id);
    855. 

  855.       }
    856. 

  856.       $this->currentPage=$id;
    857. 

  857.       //make a contents object to go with this page
    858. 

  858.       $this->numObj++;
    859. 

  859.       $this->o_contents($this->numObj,'new',$id);
    860. 

  860.       $this->currentContents=$this->numObj;
    861. 

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

  862.       $this->objects[$id]['info']['contents'][]=$this->numObj;
    863. 

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

  864.       foreach($this->addLooseObjects as $oId=>$target){
    865. 

  865.         if ($target=='all' || $match==$target){
    866. 

  866.           $this->objects[$id]['info']['contents'][]=$oId;
    867. 

  867.         }
    868. 

  868.       }
    869. 

  869.       break;
    870. 

  870.     case 'content':
    871. 

  871.       $o['info']['contents'][]=$options;
    872. 

  872.       break;
    873. 

  873.     case 'annot':
    874. 

  874.       // add an annotation to this page
    875. 

  875.       if (!isset($o['info']['annot'])){
    876. 

  876.         $o['info']['annot']=array();
    877. 

  877.       }
    878. 

  878.       // $options should contain the id of the annotation dictionary
    879. 

  879.       $o['info']['annot'][]=$options;
    880. 

  880.       break;
    881. 

  881.     case 'out':
    882. 

  882.       $res="\n".$id." 0 obj\n<< /Type /Page";
    883. 

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

  884.       if (isset($o['info']['annot'])){
    885. 

  885.         $res.="\n/Annots [";
    886. 

  886.         foreach($o['info']['annot'] as $aId){
    887. 

  887.           $res.=" ".$aId." 0 R";
    888. 

  888.         }
    889. 

  889.         $res.=" ]";
    890. 

  890.       }
    891. 

  891.       $count = count($o['info']['contents']);
    892. 

  892.       if ($count==1){
    893. 

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

  894.       } else if ($count>1){
    895. 

  895.         $res.="\n/Contents [\n";
    896. 

  896.         foreach ($o['info']['contents'] as $cId){
    897. 

  897.           $res.=$cId." 0 R\n";
    898. 

  898.         }
    899. 

  899.         $res.="]";
    900. 

  900.       }
    901. 

  901.       $res.="\n>>\nendobj";
    902. 

  902.       return $res;
    903. 

  903.       break;
    904. 

  904.   }
    905. 

  905. }
    906. 

  906. 

  907. /**
    908. 

  908. * the contents objects hold all of the content which appears on pages
    909. 

  909. */
    910. 

  910. function o_contents($id,$action,$options=''){
    911. 

  911.   if ($action!='new'){
    912. 

  912.     $o =& $this->objects[$id];
    913. 

  913.   }
    914. 

  914.   switch ($action){
    915. 

  915.     case 'new':
    916. 

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

  917.       if (strlen($options) && intval($options)){
    918. 

  918.         // then this contents is the primary for a page
    919. 

  919.         $this->objects[$id]['onPage']=$options;
    920. 

  920.       } else if ($options=='raw'){
    921. 

  921.         // then this page contains some other type of system object
    922. 

  922.         $this->objects[$id]['raw']=1;
    923. 

  923.       }
    924. 

  924.       break;
    925. 

  925.     case 'add':
    926. 

  926.       // add more options to the decleration
    927. 

  927.       foreach ($options as $k=>$v){
    928. 

  928.         $o['info'][$k]=$v;
    929. 

  929.       }
    930. 

  930.     case 'out':
    931. 

  931.       $tmp=$o['c'];
    932. 

  932.       $res= "\n".$id." 0 obj\n";
    933. 

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

  934.         $res.=$tmp;
    935. 

  935.       } else {
    936. 

  936.         $res.= "<<";
    937. 

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

  938.           // then implement ZLIB based compression on this content stream
    939. 

  939.           $res.=" /Filter /FlateDecode";
    940. 

  940.           $tmp = gzcompress($tmp);
    941. 

  941.         }
    942. 

  942.         if ($this->encrypted){
    943. 

  943.           $this->encryptInit($id);
    944. 

  944.           $tmp = $this->ARC4($tmp);
    945. 

  945.         }
    946. 

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

  947.           $res .= "\n/".$k.' '.$v;
    948. 

  948.         }
    949. 

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

  950.       }
    951. 

  951.       $res.="\nendobj\n";
    952. 

  952.       return $res;
    953. 

  953.       break;
    954. 

  954.   }
    955. 

  955. }
    956. 

  956. 

  957. /**
    958. 

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

  959. */
    960. 

  960. function o_image($id,$action,$options=''){
    961. 

  961.   if ($action!='new'){
    962. 

  962.     $o =& $this->objects[$id];
    963. 

  963.   }
    964. 

  964.   switch($action){
    965. 

  965.     case 'new':
    966. 

  966.       // make the new object
    967. 

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

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

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

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

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

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

  973.         if (!isset($options['channels'])){
    974. 

  974.           $options['channels']=3;
    975. 

  975.         }
    976. 

  976.         switch($options['channels']){
    977. 

  977.           case 1:
    978. 

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

  979.             break;
    980. 

  980.           default:
    981. 

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

  982.             break;
    983. 

  983.         }
    984. 

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

  985.         $this->objects[$id]['info']['BitsPerComponent']=8;
    986. 

  986.       } else if ($options['type']=='png'){
    987. 

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

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

  989.         if (strlen($options['pdata'])){
    990. 

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

  991.           $this->numObj++;
    992. 

  992.           $this->o_contents($this->numObj,'new');
    993. 

  993.           $this->objects[$this->numObj]['c']=$options['pdata'];
    994. 

  994.           $tmp.=$this->numObj.' 0 R';
    995. 

  995.           $tmp .=' ]';
    996. 

  996.           $this->objects[$id]['info']['ColorSpace'] = $tmp;
    997. 

  997.           if (isset($options['transparency'])){
    998. 

  998.             switch($options['transparency']['type']){
    999. 

  999.               case 'indexed':
    1000. 

  1000.                 $tmp=' [ '.$options['transparency']['data'].' '.$options['transparency']['data'].'] ';
    1001. 

  1001.                 $this->objects[$id]['info']['Mask'] = $tmp;
    1002. 

  1002.                 break;
    1003. 

  1003.             }
    1004. 

  1004.           }
    1005. 

  1005.         } else {
    1006. 

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

  1007.         }
    1008. 

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

  1009.       }
    1010. 

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

  1011.       // the label passed in with it.
    1012. 

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

  1013.       // also make sure that we have the right procset object for it.
    1014. 

  1014.       $this->o_procset($this->procsetObjectId,'add','ImageC');
    1015. 

  1015.       break;
    1016. 

  1016.     case 'out':
    1017. 

  1017.       $tmp=$o['data'];
    1018. 

  1018.       $res= "\n".$id." 0 obj\n<<";
    1019. 

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

  1020.         $res.="\n/".$k.' '.$v;
    1021. 

  1021.       }
    1022. 

  1022.       if ($this->encrypted){
    1023. 

  1023.         $this->encryptInit($id);
    1024. 

  1024.         $tmp = $this->ARC4($tmp);
    1025. 

  1025.       }
    1026. 

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

  1027.       return $res;
    1028. 

  1028.       break;
    1029. 

  1029.   }
    1030. 

  1030. }
    1031. 

  1031. 

  1032. /**
    1033. 

  1033. * encryption object.
    1034. 

  1034. */
    1035. 

  1035. function o_encryption($id,$action,$options=''){
    1036. 

  1036.   if ($action!='new'){
    1037. 

  1037.     $o =& $this->objects[$id];
    1038. 

  1038.   }
    1039. 

  1039.   switch($action){
    1040. 

  1040.     case 'new':
    1041. 

  1041.       // make the new object
    1042. 

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

  1043.       $this->arc4_objnum=$id;
    1044. 

  1044.       // figure out the additional paramaters required
    1045. 

  1045.       $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);
    1046. 

  1046.       $len = strlen($options['owner']);
    1047. 

  1047.       if ($len>32){
    1048. 

  1048.         $owner = substr($options['owner'],0,32);
    1049. 

  1049.       } else if ($len<32){
    1050. 

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

  1051.       } else {
    1052. 

  1052.         $owner = $options['owner'];
    1053. 

  1053.       }
    1054. 

  1054.       $len = strlen($options['user']);
    1055. 

  1055.       if ($len>32){
    1056. 

  1056.         $user = substr($options['user'],0,32);
    1057. 

  1057.       } else if ($len<32){
    1058. 

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

  1059.       } else {
    1060. 

  1060.         $user = $options['user'];
    1061. 

  1061.       }
    1062. 

  1062.       $tmp = $this->md5_16($owner);
    1063. 

  1063.       $okey = substr($tmp,0,5);
    1064. 

  1064.       $this->ARC4_init($okey);
    1065. 

  1065.       $ovalue=$this->ARC4($user);
    1066. 

  1066.       $this->objects[$id]['info']['O']=$ovalue;
    1067. 

  1067.       // now make the u value, phew.
    1068. 

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

  1069.       $ukey = substr($tmp,0,5);
    1070. 

  1070. 

  1071.       $this->ARC4_init($ukey);
    1072. 

  1072.       $this->encryptionKey = $ukey;
    1073. 

  1073.       $this->encrypted=1;
    1074. 

  1074.       $uvalue=$this->ARC4($pad);
    1075. 

  1075. 

  1076.       $this->objects[$id]['info']['U']=$uvalue;
    1077. 

  1077.       $this->encryptionKey=$ukey;
    1078. 

  1078.      
    1079. 

  1079.       // initialize the arc4 array
    1080. 

  1080.       break;
    1081. 

  1081.     case 'out':
    1082. 

  1082.       $res= "\n".$id." 0 obj\n<<";
    1083. 

  1083.       $res.="\n/Filter /Standard";
    1084. 

  1084.       $res.="\n/V 1";
    1085. 

  1085.       $res.="\n/R 2";
    1086. 

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

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

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

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

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

  1091.       $res.="\n>>\nendobj\n";
    1092. 

  1092.       
    1093. 

  1093.       return $res;
    1094. 

  1094.       break;
    1095. 

  1095.   }
    1096. 

  1096. }
    1097. 

  1097.       
    1098. 

  1098. /**
    1099. 

  1099. * ARC4 functions
    1100. 

  1100. * A series of function to implement ARC4 encoding in PHP
    1101. 

  1101. */
    1102. 

  1102. 

  1103. /**
    1104. 

  1104. * calculate the 16 byte version of the 128 bit md5 digest of the string
    1105. 

  1105. */
    1106. 

  1106. function md5_16($string){
    1107. 

  1107.   $tmp = md5($string);
    1108. 

  1108.   $out='';
    1109. 

  1109.   for ($i=0;$i<=30;$i=$i+2){
    1110. 

  1110.     $out.=chr(hexdec(substr($tmp,$i,2)));
    1111. 

  1111.   }
    1112. 

  1112.   return $out;
    1113. 

  1113. }
    1114. 

  1114. 

  1115. /**
    1116. 

  1116. * initialize the encryption for processing a particular object 
    1117. 

  1117. */
    1118. 

  1118. function encryptInit($id){
    1119. 

  1119.   $tmp = $this->encryptionKey;
    1120. 

  1120.   $hex = dechex($id);
    1121. 

  1121.   if (strlen($hex)<6){
    1122. 

  1122.     $hex = substr('000000',0,6-strlen($hex)).$hex;
    1123. 

  1123.   }
    1124. 

  1124.   $tmp.= chr(hexdec(substr($hex,4,2))).chr(hexdec(substr($hex,2,2))).chr(hexdec(substr($hex,0,2))).chr(0).chr(0);
    1125. 

  1125.   $key = $this->md5_16($tmp);
    1126. 

  1126.   $this->ARC4_init(substr($key,0,10));
    1127. 

  1127. }
    1128. 

  1128. 

  1129. /**
    1130. 

  1130. * initialize the ARC4 encryption
    1131. 

  1131. */
    1132. 

  1132. function ARC4_init($key=''){
    1133. 

  1133.   $this->arc4 = '';
    1134. 

  1134.   // setup the control array
    1135. 

  1135.   if (strlen($key)==0){
    1136. 

  1136.     return;
    1137. 

  1137.   }
    1138. 

  1138.   $k = '';
    1139. 

  1139.   while(strlen($k)<256){
    1140. 

  1140.     $k.=$key;
    1141. 

  1141.   }
    1142. 

  1142.   $k=substr($k,0,256);
    1143. 

  1143.   for ($i=0;$i<256;$i++){
    1144. 

  1144.     $this->arc4 .= chr($i);
    1145. 

  1145.   }
    1146. 

  1146.   $j=0;
    1147. 

  1147.   for ($i=0;$i<256;$i++){
    1148. 

  1148.     $t = $this->arc4[$i];
    1149. 

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

  1150.     $this->arc4[$i]=$this->arc4[$j];
    1151. 

  1151.     $this->arc4[$j]=$t;
    1152. 

  1152.   }    
    1153. 

  1153. }
    1154. 

  1154. 

  1155. /**
    1156. 

  1156. * ARC4 encrypt a text string
    1157. 

  1157. */
    1158. 

  1158. function ARC4($text){
    1159. 

  1159.   $len=strlen($text);
    1160. 

  1160.   $a=0;
    1161. 

  1161.   $b=0;
    1162. 

  1162.   $c = $this->arc4;
    1163. 

  1163.   $out='';
    1164. 

  1164.   for ($i=0;$i<$len;$i++){
    1165. 

  1165.     $a = ($a+1)%256;
    1166. 

  1166.     $t= $c[$a];
    1167. 

  1167.     $b = ($b+ord($t))%256;
    1168. 

  1168.     $c[$a]=$c[$b];
    1169. 

  1169.     $c[$b]=$t;
    1170. 

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

  1171.     $out.=chr(ord($text[$i]) ^ $k);
    1172. 

  1172.   }
    1173. 

  1173.   
    1174. 

  1174.   return $out;
    1175. 

  1175. }
    1176. 

  1176. 

  1177. /**
    1178. 

  1178. * functions which can be called to adjust or add to the document
    1179. 

  1179. */
    1180. 

  1180. 

  1181. /**
    1182. 

  1182. * add a link in the document to an external URL
    1183. 

  1183. */
    1184. 

  1184. function addLink($url,$x0,$y0,$x1,$y1){
    1185. 

  1185.   $this->numObj++;
    1186. 

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

  1187.   $this->o_annotation($this->numObj,'new',$info);
    1188. 

  1188. }
    1189. 

  1189. 

  1190. /**
    1191. 

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

  1192. */
    1193. 

  1193. function addInternalLink($label,$x0,$y0,$x1,$y1){
    1194. 

  1194.   $this->numObj++;
    1195. 

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

  1196.   $this->o_annotation($this->numObj,'new',$info);
    1197. 

  1197. }
    1198. 

  1198. 

  1199. /**
    1200. 

  1200. * set the encryption of the document
    1201. 

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

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

  1203. */
    1204. 

  1204. function setEncryption($userPass='',$ownerPass='',$pc=array()){
    1205. 

  1205.   $p=bindec(11000000);
    1206. 

  1206. 

  1207.   $options = array(
    1208. 

  1208.      'print'=>4
    1209. 

  1209.     ,'modify'=>8
    1210. 

  1210.     ,'copy'=>16
    1211. 

  1211.     ,'add'=>32
    1212. 

  1212.   );
    1213. 

  1213.   foreach($pc as $k=>$v){
    1214. 

  1214.     if ($v && isset($options[$k])){
    1215. 

  1215.       $p+=$options[$k];
    1216. 

  1216.     } else if (isset($options[$v])){
    1217. 

  1217.       $p+=$options[$v];
    1218. 

  1218.     }
    1219. 

  1219.   }
    1220. 

  1220.   // implement encryption on the document
    1221. 

  1221.   if ($this->arc4_objnum == 0){
    1222. 

  1222.     // then the block does not exist already, add it.
    1223. 

  1223.     $this->numObj++;
    1224. 

  1224.     if (strlen($ownerPass)==0){
    1225. 

  1225.       $ownerPass=$userPass;
    1226. 

  1226.     }
    1227. 

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

  1228.   }
    1229. 

  1229. }
    1230. 

  1230. 

  1231. /**
    1232. 

  1232. * should be used for internal checks, not implemented as yet
    1233. 

  1233. */
    1234. 

  1234. function checkAllHere(){
    1235. 

  1235. }
    1236. 

  1236. 

  1237. /**
    1238. 

  1238. * return the pdf stream as a string returned from the function
    1239. 

  1239. */
    1240. 

  1240. function output($debug=0){
    1241. 

  1241. 

  1242.   if ($debug){
    1243. 

  1243.     // turn compression off
    1244. 

  1244.     $this->options['compression']=0;
    1245. 

  1245.   }
    1246. 

  1246. 

  1247.   if ($this->arc4_objnum){
    1248. 

  1248.     $this->ARC4_init($this->encryptionKey);
    1249. 

  1249.   }
    1250. 

  1250. 

  1251.   $this->checkAllHere();
    1252. 

  1252. 

  1253.   $xref=array();
    1254. 

  1254. //  $content="%PDF-1.3\n%????\n";
    1255. 

  1255.   $content="%PDF-1.3\n";
    1256. 

  1256.   $pos=strlen($content);
    1257. 

  1257.   foreach($this->objects as $k=>$v){
    1258. 

  1258.     $tmp='o_'.$v['t'];
    1259. 

  1259.     $cont=$this->$tmp($k,'out');
    1260. 

  1260.     $content.=$cont;
    1261. 

  1261.     $xref[]=$pos;
    1262. 

  1262.     $pos+=strlen($cont);
    1263. 

  1263.   }
    1264. 

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

  1265.   foreach($xref as $p){
    1266. 

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

  1267.   }
    1268. 

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

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

  1270.   if ($this->arc4_objnum > 0){
    1271. 

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

  1272.   }
    1273. 

  1273.   if (strlen($this->fileIdentifier)){
    1274. 

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

  1275.   }
    1276. 

  1276.   $content .= "  >>\nstartxref\n".$pos."\n%%EOF\n";
    1277. 

  1277.   return $content;
    1278. 

  1278. }
    1279. 

  1279. 

  1280. /**
    1281. 

  1281. * intialize a new document
    1282. 

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

  1283. * this function is called automatically by the constructor function
    1284. 

  1284. *
    1285. 

  1285. * @access private
    1286. 

  1286. */
    1287. 

  1287. function newDocument($pageSize=array(0,0,612,792)){
    1288. 

  1288.   $this->numObj=0;
    1289. 

  1289.   $this->objects = array();
    1290. 

  1290. 

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

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

  1293. 

  1294.   $this->numObj++;
    1295. 

  1295.   $this->o_outlines($this->numObj,'new');
    1296. 

  1296. 

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

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

  1299. 

  1300.   $this->o_pages($this->numObj,'mediaBox',$pageSize);
    1301. 

  1301.   $this->currentNode = 3;
    1302. 

  1302. 

  1303.   $this->numObj++;
    1304. 

  1304.   $this->o_procset($this->numObj,'new');
    1305. 

  1305. 

  1306.   $this->numObj++;
    1307. 

  1307.   $this->o_info($this->numObj,'new');
    1308. 

  1308. 

  1309.   $this->numObj++;
    1310. 

  1310.   $this->o_page($this->numObj,'new');
    1311. 

  1311. 

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

  1313.   // startup
    1314. 

  1314.   $this->firstPageId = $this->currentContents;
    1315. 

  1315. }
    1316. 

  1316. 

  1317. /**
    1318. 

  1318. * open the font file and return a php structure containing it.
    1319. 

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

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

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

  1322. * files.
    1323. 

  1323. *
    1324. 

  1324. * @access private
    1325. 

  1325. */
    1326. 

  1326. function openFont($font){
    1327. 

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

  1328.   $pos=strrpos($font,'/');
    1329. 

  1329.   if ($pos===false){
    1330. 

  1330.     $dir = './';
    1331. 

  1331.     $name = $font;
    1332. 

  1332.   } else {
    1333. 

  1333.     $dir=substr($font,0,$pos+1);
    1334. 

  1334.     $name=substr($font,$pos+1);
    1335. 

  1335.   }
    1336. 

  1336. 

  1337.   if (substr($name,-4)=='.afm'){
    1338. 

  1338.     $name=substr($name,0,strlen($name)-4);
    1339. 

  1339.   }
    1340. 

  1340.   $this->addMessage('openFont: '.$font.' - '.$name);
    1341. 

  1341.   if (file_exists($dir.'php_'.$name.'.afm')){
    1342. 

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

  1343.     $tmp = file($dir.'php_'.$name.'.afm');
    1344. 

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

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

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

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

  1348.       unset($this->fonts[$font]);
    1349. 

  1349.     }
    1350. 

  1350.   }
    1351. 

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

  1352.     // then rebuild the php_<font>.afm file from the <font>.afm file
    1353. 

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

  1354.     $data = array();
    1355. 

  1355.     $file = file($dir.$name.'.afm');
    1356. 

  1356.     foreach ($file as $rowA){
    1357. 

  1357.       $row=trim($rowA);
    1358. 

  1358.       $pos=strpos($row,' ');
    1359. 

  1359.       if ($pos){
    1360. 

  1360.         // then there must be some keyword
    1361. 

  1361.         $key = substr($row,0,$pos);
    1362. 

  1362.         switch ($key){
    1363. 

  1363.           case 'FontName':
    1364. 

  1364.           case 'FullName':
    1365. 

  1365.           case 'FamilyName':
    1366. 

  1366.           case 'Weight':
    1367. 

  1367.           case 'ItalicAngle':
    1368. 

  1368.           case 'IsFixedPitch':
    1369. 

  1369.           case 'CharacterSet':
    1370. 

  1370.           case 'UnderlinePosition':
    1371. 

  1371.           case 'UnderlineThickness':
    1372. 

  1372.           case 'Version':
    1373. 

  1373.           case 'EncodingScheme':
    1374. 

  1374.           case 'CapHeight':
    1375. 

  1375.           case 'XHeight':
    1376. 

  1376.           case 'Ascender':
    1377. 

  1377.           case 'Descender':
    1378. 

  1378.           case 'StdHW':
    1379. 

  1379.           case 'StdVW':
    1380. 

  1380.           case 'StartCharMetrics':
    1381. 

  1381.             $data[$key]=trim(substr($row,$pos));
    1382. 

  1382.             break;
    1383. 

  1383.           case 'FontBBox':
    1384. 

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

  1385.             break;
    1386. 

  1386.           case 'C':
    1387. 

  1387.             //C 39 ; WX 222 ; N quoteright ; B 53 463 157 718 ;
    1388. 

  1388.             $bits=explode(';',trim($row));
    1389. 

  1389.             $dtmp=array();
    1390. 

  1390.             foreach($bits as $bit){
    1391. 

  1391.               $bits2 = explode(' ',trim($bit));
    1392. 

  1392.               if (strlen($bits2[0])){
    1393. 

  1393.                 if (count($bits2)>2){
    1394. 

  1394.                   $dtmp[$bits2[0]]=array();
    1395. 

  1395.                   for ($i=1;$i<count($bits2);$i++){
    1396. 

  1396.                     $dtmp[$bits2[0]][]=$bits2[$i];
    1397. 

  1397.                   }
    1398. 

  1398.                 } else if (count($bits2)==2){
    1399. 

  1399.                   $dtmp[$bits2[0]]=$bits2[1];
    1400. 

  1400.                 }
    1401. 

  1401.               }
    1402. 

  1402.             }
    1403. 

  1403.             if ($dtmp['C']>=0){
    1404. 

  1404.               $data['C'][$dtmp['C']]=$dtmp;
    1405. 

  1405.               $data['C'][$dtmp['N']]=$dtmp;
    1406. 

  1406.             } else {
    1407. 

  1407.               $data['C'][$dtmp['N']]=$dtmp;
    1408. 

  1408.             }
    1409. 

  1409.             break;
    1410. 

  1410.           case 'KPX':
    1411. 

  1411.             //KPX Adieresis yacute -40
    1412. 

  1412.             $bits=explode(' ',trim($row));
    1413. 

  1413.             $data['KPX'][$bits[1]][$bits[2]]=$bits[3];
    1414. 

  1414.             break;
    1415. 

  1415.         }
    1416. 

  1416.       }
    1417. 

  1417.     }
    1418. 

  1418.     $data['_version_']=1;
    1419. 

  1419.     $this->fonts[$font]=$data;
    1420. 

  1420.     $fp = fopen($dir.'php_'.$name.'.afm','w');
    1421. 

  1421.     fwrite($fp,serialize($data));
    1422. 

  1422.     fclose($fp);
    1423. 

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

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

  1425. //    echo 'Font not Found '.$font;
    1426. 

  1426.   }
    1427. 

  1427. }
    1428. 

  1428. 

  1429. /**
    1430. 

  1430. * if the font is not loaded then load it and make the required object
    1431. 

  1431. * else just make it the current font
    1432. 

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

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

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

  1435. *
    1436. 

  1436. */
    1437. 

  1437. function selectFont($fontName,$encoding='',$set=1){
    1438. 

  1438.   if (!isset($this->fonts[$fontName])){
    1439. 

  1439.     // load the file
    1440. 

  1440.     $this->openFont($fontName);
    1441. 

  1441.     if (isset($this->fonts[$fontName])){
    1442. 

  1442.       $this->numObj++;
    1443. 

  1443.       $this->numFonts++;
    1444. 

  1444.       $pos=strrpos($fontName,'/');
    1445. 

  1445. //      $dir=substr($fontName,0,$pos+1);
    1446. 

  1446.       $name=substr($fontName,$pos+1);
    1447. 

  1447.       if (substr($name,-4)=='.afm'){
    1448. 

  1448.         $name=substr($name,0,strlen($name)-4);
    1449. 

  1449.       }
    1450. 

  1450.       $options=array('name'=>$name);
    1451. 

  1451.       if (is_array($encoding)){
    1452. 

  1452.         // then encoding and differences might be set
    1453. 

  1453.         if (isset($encoding['encoding'])){
    1454. 

  1454.           $options['encoding']=$encoding['encoding'];
    1455. 

  1455.         }
    1456. 

  1456.         if (isset($encoding['differences'])){
    1457. 

  1457.           $options['differences']=$encoding['differences'];
    1458. 

  1458.         }
    1459. 

  1459.       } else if (strlen($encoding)){
    1460. 

  1460.         // then perhaps only the encoding has been set
    1461. 

  1461.         $options['encoding']=$encoding;
    1462. 

  1462.       }
    1463. 

  1463.       $fontObj = $this->numObj;
    1464. 

  1464.       $this->o_font($this->numObj,'new',$options);
    1465. 

  1465.       $this->fonts[$fontName]['fontNum']=$this->numFonts;
    1466. 

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

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

  1468.       // references into the font object
    1469. 

  1469.       $basefile = substr($fontName,0,strlen($fontName)-4);
    1470. 

  1470.       if (file_exists($basefile.'.pfb')){
    1471. 

  1471.         $fbtype = 'pfb';
    1472. 

  1472.       } else if (file_exists($basefile.'.ttf')){
    1473. 

  1473.         $fbtype = 'ttf';
    1474. 

  1474.       } else {
    1475. 

  1475.         $fbtype='';
    1476. 

  1476.       }
    1477. 

  1477.       $fbfile = $basefile.'.'.$fbtype;
    1478. 

  1478.       
    1479. 

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

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

  1481.       $this->addMessage('selectFont: checking for - '.$fbfile);
    1482. 

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

  1483.         $adobeFontName = $this->fonts[$fontName]['FontName'];
    1484. 

  1484. //        $fontObj = $this->numObj;
    1485. 

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

  1486.         // find the array of fond widths, and put that into an object.
    1487. 

  1487.         $firstChar = -1;
    1488. 

  1488.         $lastChar = 0;
    1489. 

  1489.         $widths = array();
    1490. 

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

  1491.           if (intval($num)>0 || $num=='0'){
    1492. 

  1492.             if ($lastChar>0 && $num>$lastChar+1){
    1493. 

  1493.               for($i=$lastChar+1;$i<$num;$i++){
    1494. 

  1494.                 $widths[] = 0;
    1495. 

  1495.               }
    1496. 

  1496.             }
    1497. 

  1497.             $widths[] = $d['WX'];
    1498. 

  1498.             if ($firstChar==-1){
    1499. 

  1499.               $firstChar = $num;
    1500. 

  1500.             }
    1501. 

  1501.             $lastChar = $num;
    1502. 

  1502.           }
    1503. 

  1503.         }
    1504. 

  1504.         // also need to adjust the widths for the differences array
    1505. 

  1505.         if (isset($options['differences'])){
    1506. 

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

  1507.             if ($charNum>$lastChar){
    1508. 

  1508.               for($i=$lastChar+1;$i<=$charNum;$i++){
    1509. 

  1509.                 $widths[]=0;
    1510. 

  1510.               }
    1511. 

  1511.               $lastChar=$charNum;
    1512. 

  1512.             }
    1513. 

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

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

  1515.             }
    1516. 

  1516.           }
    1517. 

  1517.         }
    1518. 

  1518.         $this->addMessage('selectFont: FirstChar='.$firstChar);
    1519. 

  1519.         $this->addMessage('selectFont: LastChar='.$lastChar);
    1520. 

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

  1521.         $this->o_contents($this->numObj,'new','raw');
    1522. 

  1522.         $this->objects[$this->numObj]['c'].='[';
    1523. 

  1523.         foreach($widths as $width){
    1524. 

  1524.           $this->objects[$this->numObj]['c'].=' '.$width;
    1525. 

  1525.         }
    1526. 

  1526.         $this->objects[$this->numObj]['c'].=' ]';
    1527. 

  1527.         $widthid = $this->numObj;
    1528. 

  1528. 

  1529.         // load the pfb file, and put that into an object too.
    1530. 

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

  1531.         // simple utility to convert them from pfa to pfb.
    1532. 

  1532.         $fp = fopen($fbfile,'rb');
    1533. 

  1533.         $tmp = get_magic_quotes_runtime();
    1534. 

  1534.         set_magic_quotes_runtime(0);
    1535. 

  1535.         $data = fread($fp,filesize($fbfile));
    1536. 

  1536.         set_magic_quotes_runtime($tmp);
    1537. 

  1537.         fclose($fp);
    1538. 

  1538. 

  1539.         // create the font descriptor
    1540. 

  1540.         $this->numObj++;
    1541. 

  1541.         $fontDescriptorId = $this->numObj;
    1542. 

  1542.         $this->numObj++;
    1543. 

  1543.         $pfbid = $this->numObj;
    1544. 

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

  1545.         $flags=0;
    1546. 

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

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

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

  1549. 

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

  1551.         $fdopt = array(
    1552. 

  1552.          'Flags'=>$flags
    1553. 

  1553.          ,'FontName'=>$adobeFontName
    1554. 

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

  1555.         );
    1556. 

  1556.         foreach($list as $k=>$v){
    1557. 

  1557.           if (isset($this->fonts[$fontName][$v])){
    1558. 

  1558.             $fdopt[$k]=$this->fonts[$fontName][$v];
    1559. 

  1559.           }
    1560. 

  1560.         }
    1561. 

  1561. 

  1562.         if ($fbtype=='pfb'){
    1563. 

  1563.           $fdopt['FontFile']=$pfbid;
    1564. 

  1564.         } else if ($fbtype=='ttf'){
    1565. 

  1565.           $fdopt['FontFile2']=$pfbid;
    1566. 

  1566.         }
    1567. 

  1567.         $this->o_fontDescriptor($fontDescriptorId,'new',$fdopt);        
    1568. 

  1568. 

  1569.         // embed the font program
    1570. 

  1570.         $this->o_contents($this->numObj,'new');
    1571. 

  1571.         $this->objects[$pfbid]['c'].=$data;
    1572. 

  1572.         // determine the cruicial lengths within this file
    1573. 

  1573.         if ($fbtype=='pfb'){
    1574. 

  1574.           $l1 = strpos($data,'eexec')+6;
    1575. 

  1575.           $l2 = strpos($data,'00000000')-$l1;
    1576. 

  1576.           $l3 = strlen($data)-$l2-$l1;
    1577. 

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

  1578.         } else if ($fbtype=='ttf'){
    1579. 

  1579.           $l1 = strlen($data);
    1580. 

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

  1581.         }
    1582. 

  1582. 

  1583. 

  1584.         // tell the font object about all this new stuff
    1585. 

  1585.         $tmp = array('BaseFont'=>$adobeFontName,'Widths'=>$widthid
    1586. 

  1586.                                       ,'FirstChar'=>$firstChar,'LastChar'=>$lastChar
    1587. 

  1587.                                       ,'FontDescriptor'=>$fontDescriptorId);
    1588. 

  1588.         if ($fbtype=='ttf'){
    1589. 

  1589.           $tmp['SubType']='TrueType';
    1590. 

  1590.         }
    1591. 

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

  1592.         foreach($tmp as $fk=>$fv){
    1593. 

  1593.           $this->addMessage($fk." : ".$fv);
    1594. 

  1594.         }
    1595. 

  1595.         $this->o_font($fontObj,'add',$tmp);
    1596. 

  1596. 

  1597.       } else {
    1598. 

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

  1599.       }
    1600. 

  1600. 

  1601. 

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

  1603.       //first time that a font is selected, else they are ignored
    1604. 

  1604.       if (isset($options['differences'])){
    1605. 

  1605.         $this->fonts[$fontName]['differences']=$options['differences'];
    1606. 

  1606.       }
    1607. 

  1607.     }
    1608. 

  1608.   }
    1609. 

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

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

  1611.     $this->currentBaseFont=$fontName;
    1612. 

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

  1613.     // applied to it as well.
    1614. 

  1614.     $this->setCurrentFont();
    1615. 

  1615.   }
    1616. 

  1616.   return $this->currentFontNum;
    1617. 

  1617. }
    1618. 

  1618. 

  1619. /**
    1620. 

  1620. * sets up the current font, based on the font families, and the current text state
    1621. 

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

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

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

  1624. * the currentFont setting to whatever the appropriatte family one is.
    1625. 

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

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

  1627. * currentBaseFont.
    1628. 

  1628. *
    1629. 

  1629. * @access private
    1630. 

  1630. */
    1631. 

  1631. function setCurrentFont(){
    1632. 

  1632.   if (strlen($this->currentBaseFont)==0){
    1633. 

  1633.     // then assume an initial font
    1634. 

  1634.     $this->selectFont('./fonts/Helvetica.afm');
    1635. 

  1635.   }
    1636. 

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

  1637.   if (strlen($this->currentTextState)
    1638. 

  1638.     && isset($this->fontFamilies[$cf]) 
    1639. 

  1639.       && isset($this->fontFamilies[$cf][$this->currentTextState])){
    1640. 

  1640.     // then we are in some state or another
    1641. 

  1641.     // and this font has a family, and the current setting exists within it
    1642. 

  1642.     // select the font, then return it
    1643. 

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

  1644.     $this->selectFont($nf,'',0);
    1645. 

  1645.     $this->currentFont = $nf;
    1646. 

  1646.     $this->currentFontNum = $this->fonts[$nf]['fontNum'];
    1647. 

  1647.   } else {
    1648. 

  1648.     // the this font must not have the right family member for the current state
    1649. 

  1649.     // simply assume the base font
    1650. 

  1650.     $this->currentFont = $this->currentBaseFont;
    1651. 

  1651.     $this->currentFontNum = $this->fonts[$this->currentFont]['fontNum'];    
    1652. 

  1652.   }
    1653. 

  1653. }
    1654. 

  1654. 

  1655. /**
    1656. 

  1656. * function for the user to find out what the ID is of the first page that was created during
    1657. 

  1657. * startup - useful if they wish to add something to it later.
    1658. 

  1658. */
    1659. 

  1659. function getFirstPageId(){
    1660. 

  1660.   return $this->firstPageId;
    1661. 

  1661. }
    1662. 

  1662. 

  1663. /**
    1664. 

  1664. * add content to the currently active object
    1665. 

  1665. *
    1666. 

  1666. * @access private
    1667. 

  1667. */
    1668. 

  1668. function addContent($content){
    1669. 

  1669.   $this->objects[$this->currentContents]['c'].=$content;
    1670. 

  1670. }
    1671. 

  1671. 

  1672. /**
    1673. 

  1673. * sets the colour for fill operations
    1674. 

  1674. */
    1675. 

  1675. function setColor($r,$g,$b,$force=0){
    1676. 

  1676.   if ($r>=0 && ($force || $r!=$this->currentColour['r'] || $g!=$this->currentColour['g'] || $b!=$this->currentColour['b'])){
    1677. 

  1677.     $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3F',$r).' '.sprintf('%.3F',$g).' '.sprintf('%.3F',$b).' rg';
    1678. 

  1678.     $this->currentColour=array('r'=>$r,'g'=>$g,'b'=>$b);
    1679. 

  1679.   }
    1680. 

  1680. }
    1681. 

  1681. 

  1682. /**
    1683. 

  1683. * sets the colour for stroke operations
    1684. 

  1684. */
    1685. 

  1685. function setStrokeColor($r,$g,$b,$force=0){
    1686. 

  1686.   if ($r>=0 && ($force || $r!=$this->currentStrokeColour['r'] || $g!=$this->currentStrokeColour['g'] || $b!=$this->currentStrokeColour['b'])){
    1687. 

  1687.     $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3F',$r).' '.sprintf('%.3F',$g).' '.sprintf('%.3F',$b).' RG';
    1688. 

  1688.     $this->currentStrokeColour=array('r'=>$r,'g'=>$g,'b'=>$b);
    1689. 

  1689.   }
    1690. 

  1690. }
    1691. 

  1691. 

  1692. /**
    1693. 

  1693. * draw a line from one set of coordinates to another
    1694. 

  1694. */
    1695. 

  1695. function line($x1,$y1,$x2,$y2){
    1696. 

  1696.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3F',$x1).' '.sprintf('%.3F',$y1).' m '.sprintf('%.3F',$x2).' '.sprintf('%.3F',$y2).' l S';
    1697. 

  1697. }
    1698. 

  1698. 

  1699. /**
    1700. 

  1700. * draw a bezier curve based on 4 control points
    1701. 

  1701. */
    1702. 

  1702. function curve($x0,$y0,$x1,$y1,$x2,$y2,$x3,$y3){
    1703. 

  1703.   // in the current line style, draw a bezier curve from (x0,y0) to (x3,y3) using the other two points
    1704. 

  1704.   // as the control points for the curve.
    1705. 

  1705.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3F',$x0).' '.sprintf('%.3F',$y0).' m '.sprintf('%.3F',$x1).' '.sprintf('%.3F',$y1);
    1706. 

  1706.   $this->objects[$this->currentContents]['c'].= ' '.sprintf('%.3F',$x2).' '.sprintf('%.3F',$y2).' '.sprintf('%.3F',$x3).' '.sprintf('%.3F',$y3).' c S';
    1707. 

  1707. }
    1708. 

  1708. 

  1709. /**
    1710. 

  1710. * draw a part of an ellipse
    1711. 

  1711. */
    1712. 

  1712. function partEllipse($x0,$y0,$astart,$afinish,$r1,$r2=0,$angle=0,$nSeg=8){
    1713. 

  1713.   $this->ellipse($x0,$y0,$r1,$r2,$angle,$nSeg,$astart,$afinish,0);
    1714. 

  1714. }
    1715. 

  1715. 

  1716. /**
    1717. 

  1717. * draw a filled ellipse
    1718. 

  1718. */
    1719. 

  1719. function filledEllipse($x0,$y0,$r1,$r2=0,$angle=0,$nSeg=8,$astart=0,$afinish=360){
    1720. 

  1720.   return $this->ellipse($x0,$y0,$r1,$r2=0,$angle,$nSeg,$astart,$afinish,1,1);
    1721. 

  1721. }
    1722. 

  1722. 

  1723. /**
    1724. 

  1724. * draw an ellipse
    1725. 

  1725. * note that the part and filled ellipse are just special cases of this function
    1726. 

  1726. *
    1727. 

  1727. * draws an ellipse in the current line style
    1728. 

  1728. * centered at $x0,$y0, radii $r1,$r2
    1729. 

  1729. * if $r2 is not set, then a circle is drawn
    1730. 

  1730. * nSeg is not allowed to be less than 2, as this will simply draw a line (and will even draw a 
    1731. 

  1731. * pretty crappy shape at 2, as we are approximating with bezier curves.
    1732. 

  1732. */
    1733. 

  1733. function ellipse($x0,$y0,$r1,$r2=0,$angle=0,$nSeg=8,$astart=0,$afinish=360,$close=1,$fill=0){
    1734. 

  1734.   if ($r1==0){
    1735. 

  1735.     return;
    1736. 

  1736.   }
    1737. 

  1737.   if ($r2==0){
    1738. 

  1738.     $r2=$r1;
    1739. 

  1739.   }
    1740. 

  1740.   if ($nSeg<2){
    1741. 

  1741.     $nSeg=2;
    1742. 

  1742.   }
    1743. 

  1743. 

  1744.   $astart = deg2rad((float)$astart);
    1745. 

  1745.   $afinish = deg2rad((float)$afinish);
    1746. 

  1746.   $totalAngle =$afinish-$astart;
    1747. 

  1747. 

  1748.   $dt = $totalAngle/$nSeg;
    1749. 

  1749.   $dtm = $dt/3;
    1750. 

  1750. 

  1751.   if ($angle != 0){
    1752. 

  1752.     $a = -1*deg2rad((float)$angle);
    1753. 

  1753.     $tmp = "\n q ";
    1754. 

  1754.     $tmp .= sprintf('%.3F',cos($a)).' '.sprintf('%.3F',(-1.0*sin($a))).' '.sprintf('%.3F',sin($a)).' '.sprintf('%.3F',cos($a)).' ';
    1755. 

  1755.     $tmp .= sprintf('%.3F',$x0).' '.sprintf('%.3F',$y0).' cm';
    1756. 

  1756.     $this->objects[$this->currentContents]['c'].= $tmp;
    1757. 

  1757.     $x0=0;
    1758. 

  1758.     $y0=0;
    1759. 

  1759.   }
    1760. 

  1760. 

  1761.   $t1 = $astart;
    1762. 

  1762.   $a0 = $x0+$r1*cos($t1);
    1763. 

  1763.   $b0 = $y0+$r2*sin($t1);
    1764. 

  1764.   $c0 = -$r1*sin($t1);
    1765. 

  1765.   $d0 = $r2*cos($t1);
    1766. 

  1766. 

  1767.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3F',$a0).' '.sprintf('%.3F',$b0).' m ';
    1768. 

  1768.   for ($i=1;$i<=$nSeg;$i++){
    1769. 

  1769.     // draw this bit of the total curve
    1770. 

  1770.     $t1 = $i*$dt+$astart;
    1771. 

  1771.     $a1 = $x0+$r1*cos($t1);
    1772. 

  1772.     $b1 = $y0+$r2*sin($t1);
    1773. 

  1773.     $c1 = -$r1*sin($t1);
    1774. 

  1774.     $d1 = $r2*cos($t1);
    1775. 

  1775.     $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3F',($a0+$c0*$dtm)).' '.sprintf('%.3F',($b0+$d0*$dtm));
    1776. 

  1776.     $this->objects[$this->currentContents]['c'].= ' '.sprintf('%.3F',($a1-$c1*$dtm)).' '.sprintf('%.3F',($b1-$d1*$dtm)).' '.sprintf('%.3F',$a1).' '.sprintf('%.3F',$b1).' c';
    1777. 

  1777.     $a0=$a1;
    1778. 

  1778.     $b0=$b1;
    1779. 

  1779.     $c0=$c1;
    1780. 

  1780.     $d0=$d1;    
    1781. 

  1781.   }
    1782. 

  1782.   if ($fill){
    1783. 

  1783.     $this->objects[$this->currentContents]['c'].=' f';
    1784. 

  1784.   } else {
    1785. 

  1785.     if ($close){
    1786. 

  1786.       $this->objects[$this->currentContents]['c'].=' s'; // small 's' signifies closing the path as well
    1787. 

  1787.     } else {
    1788. 

  1788.       $this->objects[$this->currentContents]['c'].=' S';
    1789. 

  1789.     }
    1790. 

  1790.   }
    1791. 

  1791.   if ($angle !=0){
    1792. 

  1792.     $this->objects[$this->currentContents]['c'].=' Q';
    1793. 

  1793.   }
    1794. 

  1794. }
    1795. 

  1795. 

  1796. /**
    1797. 

  1797. * this sets the line drawing style.
    1798. 

  1798. * width, is the thickness of the line in user units
    1799. 

  1799. * cap is the type of cap to put on the line, values can be 'butt','round','square'
    1800. 

  1800. *    where the diffference between 'square' and 'butt' is that 'square' projects a flat end past the
    1801. 

  1801. *    end of the line.
    1802. 

  1802. * join can be 'miter', 'round', 'bevel'
    1803. 

  1803. * dash is an array which sets the dash pattern, is a series of length values, which are the lengths of the
    1804. 

  1804. *   on and off dashes.
    1805. 

  1805. *   (2) represents 2 on, 2 off, 2 on , 2 off ...
    1806. 

  1806. *   (2,1) is 2 on, 1 off, 2 on, 1 off.. etc
    1807. 

  1807. * phase is a modifier on the dash pattern which is used to shift the point at which the pattern starts. 
    1808. 

  1808. */
    1809. 

  1809. function setLineStyle($width=1,$cap='',$join='',$dash='',$phase=0){
    1810. 

  1810. 

  1811.   // this is quite inefficient in that it sets all the parameters whenever 1 is changed, but will fix another day
    1812. 

  1812.   $string = '';
    1813. 

  1813.   if ($width>0){
    1814. 

  1814.     $string.= $width.' w';
    1815. 

  1815.   }
    1816. 

  1816.   $ca = array('butt'=>0,'round'=>1,'square'=>2);
    1817. 

  1817.   if (isset($ca[$cap])){
    1818. 

  1818.     $string.= ' '.$ca[$cap].' J';
    1819. 

  1819.   }
    1820. 

  1820.   $ja = array('miter'=>0,'round'=>1,'bevel'=>2);
    1821. 

  1821.   if (isset($ja[$join])){
    1822. 

  1822.     $string.= ' '.$ja[$join].' j';
    1823. 

  1823.   }
    1824. 

  1824.   if (is_array($dash)){
    1825. 

  1825.     $string.= ' [';
    1826. 

  1826.     foreach ($dash as $len){
    1827. 

  1827.       $string.=' '.$len;
    1828. 

  1828.     }
    1829. 

  1829.     $string.= ' ] '.$phase.' d';
    1830. 

  1830.   }
    1831. 

  1831.   $this->currentLineStyle = $string;
    1832. 

  1832.   $this->objects[$this->currentContents]['c'].="\n".$string;
    1833. 

  1833. }
    1834. 

  1834. 

  1835. /**
    1836. 

  1836. * draw a polygon, the syntax for this is similar to the GD polygon command
    1837. 

  1837. */
    1838. 

  1838. function polygon($p,$np,$f=0){
    1839. 

  1839.   $this->objects[$this->currentContents]['c'].="\n";
    1840. 

  1840.   $this->objects[$this->currentContents]['c'].=sprintf('%.3F',$p[0]).' '.sprintf('%.3F',$p[1]).' m ';
    1841. 

  1841.   for ($i=2;$i<$np*2;$i=$i+2){
    1842. 

  1842.     $this->objects[$this->currentContents]['c'].= sprintf('%.3F',$p[$i]).' '.sprintf('%.3F',$p[$i+1]).' l ';
    1843. 

  1843.   }
    1844. 

  1844.   if ($f==1){
    1845. 

  1845.     $this->objects[$this->currentContents]['c'].=' f';
    1846. 

  1846.   } else {
    1847. 

  1847.     $this->objects[$this->currentContents]['c'].=' S';
    1848. 

  1848.   }
    1849. 

  1849. }
    1850. 

  1850. 

  1851. /**
    1852. 

  1852. * a filled rectangle, note that it is the width and height of the rectangle which are the secondary paramaters, not
    1853. 

  1853. * the coordinates of the upper-right corner
    1854. 

  1854. */
    1855. 

  1855. function filledRectangle($x1,$y1,$width,$height){
    1856. 

  1856.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3F',$x1).' '.sprintf('%.3F',$y1).' '.sprintf('%.3F',$width).' '.sprintf('%.3F',$height).' re f';
    1857. 

  1857. }
    1858. 

  1858. 

  1859. /**
    1860. 

  1860. * draw a rectangle, note that it is the width and height of the rectangle which are the secondary paramaters, not
    1861. 

  1861. * the coordinates of the upper-right corner
    1862. 

  1862. */
    1863. 

  1863. function rectangle($x1,$y1,$width,$height){
    1864. 

  1864.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3F',$x1).' '.sprintf('%.3F',$y1).' '.sprintf('%.3F',$width).' '.sprintf('%.3F',$height).' re S';
    1865. 

  1865. }
    1866. 

  1866. 

  1867. /**
    1868. 

  1868. * add a new page to the document
    1869. 

  1869. * this also makes the new page the current active object
    1870. 

  1870. */
    1871. 

  1871. function newPage($insert=0,$id=0,$pos='after'){
    1872. 

  1872. 

  1873.   // if there is a state saved, then go up the stack closing them
    1874. 

  1874.   // then on the new page, re-open them with the right setings
    1875. 

  1875.   
    1876. 

  1876.   if ($this->nStateStack){
    1877. 

  1877.     for ($i=$this->nStateStack;$i>=1;$i--){
    1878. 

  1878.       $this->restoreState($i);
    1879. 

  1879.     }
    1880. 

  1880.   }
    1881. 

  1881. 

  1882.   $this->numObj++;
    1883. 

  1883.   if ($insert){
    1884. 

  1884.     // the id from the ezPdf class is the od of the contents of the page, not the page object itself
    1885. 

  1885.     // query that object to find the parent
    1886. 

  1886.     $rid = $this->objects[$id]['onPage'];
    1887. 

  1887.     $opt= array('rid'=>$rid,'pos'=>$pos);
    1888. 

  1888.     $this->o_page($this->numObj,'new',$opt);
    1889. 

  1889.   } else {
    1890. 

  1890.     $this->o_page($this->numObj,'new');
    1891. 

  1891.   }
    1892. 

  1892.   // if there is a stack saved, then put that onto the page
    1893. 

  1893.   if ($this->nStateStack){
    1894. 

  1894.     for ($i=1;$i<=$this->nStateStack;$i++){
    1895. 

  1895.       $this->saveState($i);
    1896. 

  1896.     }
    1897. 

  1897.   }  
    1898. 

  1898.   // and if there has been a stroke or fill colour set, then transfer them
    1899. 

  1899.   if ($this->currentColour['r']>=0){
    1900. 

  1900.     $this->setColor($this->currentColour['r'],$this->currentColour['g'],$this->currentColour['b'],1);
    1901. 

  1901.   }
    1902. 

  1902.   if ($this->currentStrokeColour['r']>=0){
    1903. 

  1903.     $this->setStrokeColor($this->currentStrokeColour['r'],$this->currentStrokeColour['g'],$this->currentStrokeColour['b'],1);
    1904. 

  1904.   }
    1905. 

  1905. 

  1906.   // if there is a line style set, then put this in too
    1907. 

  1907.   if (strlen($this->currentLineStyle)){
    1908. 

  1908.     $this->objects[$this->currentContents]['c'].="\n".$this->currentLineStyle;
    1909. 

  1909.   }
    1910. 

  1910. 

  1911.   // the call to the o_page object set currentContents to the present page, so this can be returned as the page id
    1912. 

  1912.   return $this->currentContents;
    1913. 

  1913. }
    1914. 

  1914. 

  1915. /**
    1916. 

  1916. * output the pdf code, streaming it to the browser
    1917. 

  1917. * the relevant headers are set so that hopefully the browser will recognise it
    1918. 

  1918. */
    1919. 

  1919. function stream($options=''){
    1920. 

  1920.   // setting the options allows the adjustment of the headers
    1921. 

  1921.   // values at the moment are:
    1922. 

  1922.   // 'Content-Disposition'=>'filename'  - sets the filename, though not too sure how well this will 
    1923. 

  1923.   //        work as in my trial the browser seems to use the filename of the php file with .pdf on the end
    1924. 

  1924.   // 'Accept-Ranges'=>1 or 0 - if this is not set to 1, then this header is not included, off by default
    1925. 

  1925.   //    this header seems to have caused some problems despite tha fact that it is supposed to solve
    1926. 

  1926.   //    them, so I am leaving it off by default.
    1927. 

  1927.   // 'compress'=> 1 or 0 - apply content stream compression, this is on (1) by default
    1928. 

  1928.   if (!is_array($options)){
    1929. 

  1929.     $options=array();
    1930. 

  1930.   }
    1931. 

  1931.   if ( isset($options['compress']) && $options['compress']==0){
    1932. 

  1932.     $tmp = $this->output(1);
    1933. 

  1933.   } else {
    1934. 

  1934.     $tmp = $this->output();
    1935. 

  1935.   }
    1936. 

  1936.   $fileName = (isset($options['Content-Disposition'])?$options['Content-Disposition']:'file.pdf');
    1937. 

  1937.   $fileNameC = (isset($options['Content-Type'])?"; name=\"".$options['Content-Type']."\"":'');
    1938. 

  1938.   header("Content-Type: application/pdf$fileNameC");
    1939. 

  1939.   header("Content-Length: ".strlen(ltrim($tmp)));
    1940. 

  1940.   header("Content-Disposition: inline; filename=\"".$fileName."\"");
    1941. 

  1941.   if (isset($options['Accept-Ranges']) && $options['Accept-Ranges']==1){
    1942. 

  1942.     header("Accept-Ranges: ".strlen(ltrim($tmp))); 
    1943. 

  1943.   }
    1944. 

  1944.   echo ltrim($tmp);
    1945. 

  1945. }
    1946. 

  1946. 

  1947. /**
    1948. 

  1948. * return the height in units of the current font in the given size
    1949. 

  1949. */
    1950. 

  1950. function getFontHeight($size){
    1951. 

  1951.   if (!$this->numFonts){
    1952. 

  1952.     $this->selectFont('./fonts/Helvetica');
    1953. 

  1953.   }
    1954. 

  1954.   // for the current font, and the given size, what is the height of the font in user units
    1955. 

  1955.   $h = $this->fonts[$this->currentFont]['FontBBox'][3]-$this->fonts[$this->currentFont]['FontBBox'][1];
    1956. 

  1956.   return $size*$h/1000;
    1957. 

  1957. }
    1958. 

  1958. 

  1959. /**
    1960. 

  1960. * return the font decender, this will normally return a negative number
    1961. 

  1961. * if you add this number to the baseline, you get the level of the bottom of the font
    1962. 

  1962. * it is in the pdf user units
    1963. 

  1963. */
    1964. 

  1964. function getFontDecender($size){
    1965. 

  1965.   // note that this will most likely return a negative value
    1966. 

  1966.   if (!$this->numFonts){
    1967. 

  1967.     $this->selectFont('./fonts/Helvetica');
    1968. 

  1968.   }
    1969. 

  1969.   $h = $this->fonts[$this->currentFont]['FontBBox'][1];
    1970. 

  1970.   return $size*$h/1000;
    1971. 

  1971. }
    1972. 

  1972. 

  1973. /**
    1974. 

  1974. * filter the text, this is applied to all text just before being inserted into the pdf document
    1975. 

  1975. * it escapes the various things that need to be escaped, and so on
    1976. 

  1976. *
    1977. 

  1977. * @access private
    1978. 

  1978. */
    1979. 

  1979. function filterText($text){
    1980. 

  1980.   $text = str_replace('\\','\\\\',$text);
    1981. 

  1981.   $text = str_replace('(','\(',$text);
    1982. 

  1982.   $text = str_replace(')','\)',$text);
    1983. 

  1983.   $text = str_replace('&lt;','<',$text);
    1984. 

  1984.   $text = str_replace('&gt;','>',$text);
    1985. 

  1985.   $text = str_replace('&#039;','\'',$text);
    1986. 

  1986.   $text = str_replace('&quot;','"',$text);
    1987. 

  1987.   $text = str_replace('&amp;','&',$text);
    1988. 

  1988. 

  1989.   return $text;
    1990. 

  1990. }
    1991. 

  1991. 

  1992. /**
    1993. 

  1993. * given a start position and information about how text is to be laid out, calculate where 
    1994. 

  1994. * on the page the text will end
    1995. 

  1995. *
    1996. 

  1996. * @access private
    1997. 

  1997. */
    1998. 

  1998. function PRVTgetTextPosition($x,$y,$angle,$size,$wa,$text){
    1999. 

  1999.   // given this information return an array containing x and y for the end position as elements 0 and 1
    2000. 

  2000.   $w = $this->getTextWidth($size,$text);
    2001. 

  2001.   // need to adjust for the number of spaces in this text
    2002. 

  2002.   $words = explode(' ',$text);
    2003. 

  2003.   $nspaces=count($words)-1;
    2004. 

  2004.   $w += $wa*$nspaces;
    2005. 

  2005.   $a = deg2rad((float)$angle);
    2006. 

  2006.   return array(cos($a)*$w+$x,-sin($a)*$w+$y);
    2007. 

  2007. }
    2008. 

  2008. 

  2009. /**
    2010. 

  2010. * wrapper function for PRVTcheckTextDirective1
    2011. 

  2011. *
    2012. 

  2012. * @access private
    2013. 

  2013. */
    2014. 

  2014. function PRVTcheckTextDirective(&$text,$i,&$f){
    2015. 

  2015.   $x=0;
    2016. 

  2016.   $y=0;
    2017. 

  2017.   return $this->PRVTcheckTextDirective1($text,$i,$f,0,$x,$y);
    2018. 

  2018. }
    2019. 

  2019. 

  2020. /**
    2021. 

  2021. * checks if the text stream contains a control directive
    2022. 

  2022. * if so then makes some changes and returns the number of characters involved in the directive
    2023. 

  2023. * this has been re-worked to include everything neccesary to fins the current writing point, so that
    2024. 

  2024. * the location can be sent to the callback function if required
    2025. 

  2025. * if the directive does not require a font change, then $f should be set to 0
    2026. 

  2026. *
    2027. 

  2027. * @access private
    2028. 

  2028. */
    2029. 

  2029. function PRVTcheckTextDirective1(&$text,$i,&$f,$final,&$x,&$y,$size=0,$angle=0,$wordSpaceAdjust=0){
    2030. 

  2030.   $directive = 0;
    2031. 

  2031.   $j=$i;
    2032. 

  2032.   if ($text[$j]=='<'){
    2033. 

  2033.     $j++;
    2034. 

  2034.     switch($text[$j]){
    2035. 

  2035.       case '/':
    2036. 

  2036.         $j++;
    2037. 

  2037.         if (strlen($text) <= $j){
    2038. 

  2038.           return $directive;
    2039. 

  2039.         }
    2040. 

  2040.         switch($text[$j]){
    2041. 

  2041.           case 'b':
    2042. 

  2042.           case 'i':
    2043. 

  2043.             $j++;
    2044. 

  2044.             if ($text[$j]=='>'){
    2045. 

  2045.               $p = strrpos($this->currentTextState,$text[$j-1]);
    2046. 

  2046.               if ($p !== false){
    2047. 

  2047.                 // then there is one to remove
    2048. 

  2048.                 $this->currentTextState = substr($this->currentTextState,0,$p).substr($this->currentTextState,$p+1);
    2049. 

  2049.               }
    2050. 

  2050.               $directive=$j-$i+1;
    2051. 

  2051.             }
    2052. 

  2052.             break;
    2053. 

  2053.           case 'c':
    2054. 

  2054.             // this this might be a callback function
    2055. 

  2055.             $j++;
    2056. 

  2056.             $k = strpos($text,'>',$j);
    2057. 

  2057.             if ($k!==false && $text[$j]==':'){
    2058. 

  2058.               // then this will be treated as a callback directive
    2059. 

  2059.               $directive = $k-$i+1;
    2060. 

  2060.               $f=0;
    2061. 

  2061.               // split the remainder on colons to get the function name and the paramater
    2062. 

  2062.               $tmp = substr($text,$j+1,$k-$j-1);
    2063. 

  2063.               $b1 = strpos($tmp,':');
    2064. 

  2064.               if ($b1!==false){
    2065. 

  2065.                 $func = substr($tmp,0,$b1);
    2066. 

  2066.                 $parm = substr($tmp,$b1+1);
    2067. 

  2067.               } else {
    2068. 

  2068.                 $func=$tmp;
    2069. 

  2069.                 $parm='';
    2070. 

  2070.               }
    2071. 

  2071.               if (!isset($func) || !strlen(trim($func))){
    2072. 

  2072.                 $directive=0;
    2073. 

  2073.               } else {
    2074. 

  2074.                 // only call the function if this is the final call
    2075. 

  2075.                 if ($final){
    2076. 

  2076.                   // need to assess the text position, calculate the text width to this point
    2077. 

  2077.                   // can use getTextWidth to find the text width I think
    2078. 

  2078.                   $tmp = $this->PRVTgetTextPosition($x,$y,$angle,$size,$wordSpaceAdjust,substr($text,0,$i));
    2079. 

  2079.                   $info = array('x'=>$tmp[0],'y'=>$tmp[1],'angle'=>$angle,'status'=>'end','p'=>$parm,'nCallback'=>$this->nCallback);
    2080. 

  2080.                   $x=$tmp[0];
    2081. 

  2081.                   $y=$tmp[1];
    2082. 

  2082.                   $ret = $this->$func($info);
    2083. 

  2083.                   if (is_array($ret)){
    2084. 

  2084.                     // then the return from the callback function could set the position, to start with, later will do font colour, and font
    2085. 

  2085.                     foreach($ret as $rk=>$rv){
    2086. 

  2086.                       switch($rk){
    2087. 

  2087.                         case 'x':
    2088. 

  2088.                         case 'y':
    2089. 

  2089.                           $$rk=$rv;
    2090. 

  2090.                           break;
    2091. 

  2091.                       }
    2092. 

  2092.                     }
    2093. 

  2093.                   }
    2094. 

  2094.                   // also remove from to the stack
    2095. 

  2095.                   // for simplicity, just take from the end, fix this another day
    2096. 

  2096.                   $this->nCallback--;
    2097. 

  2097.                   if ($this->nCallback<0){
    2098. 

  2098.                     $this->nCallBack=0;
    2099. 

  2099.                   }
    2100. 

  2100.                 }
    2101. 

  2101.               }
    2102. 

  2102.             }
    2103. 

  2103.             break;
    2104. 

  2104.         }
    2105. 

  2105.         break;
    2106. 

  2106.       case 'b':
    2107. 

  2107.       case 'i':
    2108. 

  2108.         $j++;
    2109. 

  2109.         if ($text[$j]=='>'){
    2110. 

  2110.           $this->currentTextState.=$text[$j-1];
    2111. 

  2111.           $directive=$j-$i+1;
    2112. 

  2112.         }
    2113. 

  2113.         break;
    2114. 

  2114.       case 'C':
    2115. 

  2115.         $noClose=1;
    2116. 

  2116.       case 'c':
    2117. 

  2117.         // this this might be a callback function
    2118. 

  2118.         $j++;
    2119. 

  2119.         $k = strpos($text,'>',$j);
    2120. 

  2120.         if ($k!==false && $text[$j]==':'){
    2121. 

  2121.           // then this will be treated as a callback directive
    2122. 

  2122.           $directive = $k-$i+1;
    2123. 

  2123.           $f=0;
    2124. 

  2124.           // split the remainder on colons to get the function name and the paramater
    2125. 

  2125. //          $bits = explode(':',substr($text,$j+1,$k-$j-1));
    2126. 

  2126.           $tmp = substr($text,$j+1,$k-$j-1);
    2127. 

  2127.           $b1 = strpos($tmp,':');
    2128. 

  2128.           if ($b1!==false){
    2129. 

  2129.             $func = substr($tmp,0,$b1);
    2130. 

  2130.             $parm = substr($tmp,$b1+1);
    2131. 

  2131.           } else {
    2132. 

  2132.             $func=$tmp;
    2133. 

  2133.             $parm='';
    2134. 

  2134.           }
    2135. 

  2135.           if (!isset($func) || !strlen(trim($func))){
    2136. 

  2136.             $directive=0;
    2137. 

  2137.           } else {
    2138. 

  2138.             // only call the function if this is the final call, ie, the one actually doing printing, not measurement
    2139. 

  2139.             if ($final){
    2140. 

  2140.               // need to assess the text position, calculate the text width to this point
    2141. 

  2141.               // can use getTextWidth to find the text width I think
    2142. 

  2142.               // also add the text height and decender
    2143. 

  2143.               $tmp = $this->PRVTgetTextPosition($x,$y,$angle,$size,$wordSpaceAdjust,substr($text,0,$i));
    2144. 

  2144.               $info = array('x'=>$tmp[0],'y'=>$tmp[1],'angle'=>$angle,'status'=>'start','p'=>$parm,'f'=>$func,'height'=>$this->getFontHeight($size),'decender'=>$this->getFontDecender($size));
    2145. 

  2145.               $x=$tmp[0];
    2146. 

  2146.               $y=$tmp[1];
    2147. 

  2147.               if (!isset($noClose) || !$noClose){
    2148. 

  2148.                 // only add to the stack if this is a small 'c', therefore is a start-stop pair
    2149. 

  2149.                 $this->nCallback++;
    2150. 

  2150.                 $info['nCallback']=$this->nCallback;
    2151. 

  2151.                 $this->callback[$this->nCallback]=$info;
    2152. 

  2152.               }
    2153. 

  2153.               $ret = $this->$func($info);
    2154. 

  2154.               if (is_array($ret)){
    2155. 

  2155.                 // then the return from the callback function could set the position, to start with, later will do font colour, and font
    2156. 

  2156.                 foreach($ret as $rk=>$rv){
    2157. 

  2157.                   switch($rk){
    2158. 

  2158.                     case 'x':
    2159. 

  2159.                     case 'y':
    2160. 

  2160.                       $$rk=$rv;
    2161. 

  2161.                       break;
    2162. 

  2162.                   }
    2163. 

  2163.                 }
    2164. 

  2164.               }
    2165. 

  2165.             }
    2166. 

  2166.           }
    2167. 

  2167.         }
    2168. 

  2168.         break;
    2169. 

  2169.     }
    2170. 

  2170.   } 
    2171. 

  2171.   return $directive;
    2172. 

  2172. }
    2173. 

  2173. 

  2174. /**
    2175. 

  2175. * add text to the document, at a specified location, size and angle on the page
    2176. 

  2176. */
    2177. 

  2177. function addText($x,$y,$size,$text,$angle=0,$wordSpaceAdjust=0){
    2178. 

  2178.   if (!$this->numFonts){$this->selectFont('./fonts/Helvetica');}
    2179. 

  2179. 

  2180.   // if there are any open callbacks, then they should be called, to show the start of the line
    2181. 

  2181.   if ($this->nCallback>0){
    2182. 

  2182.     for ($i=$this->nCallback;$i>0;$i--){
    2183. 

  2183.       // call each function
    2184. 

  2184.       $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']);
    2185. 

  2185.       $func = $this->callback[$i]['f'];
    2186. 

  2186.       $this->$func($info);
    2187. 

  2187.     }
    2188. 

  2188.   }
    2189. 

  2189.   if ($angle==0){
    2190. 

  2190.     $this->objects[$this->currentContents]['c'].="\n".'BT '.sprintf('%.3F',$x).' '.sprintf('%.3F',$y).' Td';
    2191. 

  2191.   } else {
    2192. 

  2192.     $a = deg2rad((float)$angle);
    2193. 

  2193.     $tmp = "\n".'BT ';
    2194. 

  2194.     $tmp .= sprintf('%.3F',cos($a)).' '.sprintf('%.3F',(-1.0*sin($a))).' '.sprintf('%.3F',sin($a)).' '.sprintf('%.3F',cos($a)).' ';
    2195. 

  2195.     $tmp .= sprintf('%.3F',$x).' '.sprintf('%.3F',$y).' Tm';
    2196. 

  2196.     $this->objects[$this->currentContents]['c'] .= $tmp;
    2197. 

  2197.   }
    2198. 

  2198.   if ($wordSpaceAdjust!=0 || $wordSpaceAdjust != $this->wordSpaceAdjust){
    2199. 

  2199.     $this->wordSpaceAdjust=$wordSpaceAdjust;
    2200. 

  2200.     $this->objects[$this->currentContents]['c'].=' '.sprintf('%.3F',$wordSpaceAdjust).' Tw';
    2201. 

  2201.   }
    2202. 

  2202.   $len=strlen($text);
    2203. 

  2203.   $start=0;
    2204. 

  2204.   for ($i=0;$i<$len;$i++){
    2205. 

  2205.     $f=1;
    2206. 

  2206.     $directive = $this->PRVTcheckTextDirective($text,$i,$f);
    2207. 

  2207.     if ($directive){
    2208. 

  2208.       // then we should write what we need to
    2209. 

  2209.       if ($i>$start){
    2210. 

  2210.         $part = substr($text,$start,$i-$start);
    2211. 

  2211.         $this->objects[$this->currentContents]['c'].=' /F'.$this->currentFontNum.' '.sprintf('%.1F',$size).' Tf ';
    2212. 

  2212.         $this->objects[$this->currentContents]['c'].=' ('.$this->filterText($part).') Tj';
    2213. 

  2213.       }
    2214. 

  2214.       if ($f){
    2215. 

  2215.         // then there was nothing drastic done here, restore the contents
    2216. 

  2216.         $this->setCurrentFont();
    2217. 

  2217.       } else {
    2218. 

  2218.         $this->objects[$this->currentContents]['c'] .= ' ET';
    2219. 

  2219.         $f=1;
    2220. 

  2220.         $xp=$x;
    2221. 

  2221.         $yp=$y;
    2222. 

  2222.         $directive = $this->PRVTcheckTextDirective1($text,$i,$f,1,$xp,$yp,$size,$angle,$wordSpaceAdjust);
    2223. 

  2223.         
    2224. 

  2224.         // restart the text object
    2225. 

  2225.           if ($angle==0){
    2226. 

  2226.             $this->objects[$this->currentContents]['c'].="\n".'BT '.sprintf('%.3F',$xp).' '.sprintf('%.3F',$yp).' Td';
    2227. 

  2227.           } else {
    2228. 

  2228.             $a = deg2rad((float)$angle);
    2229. 

  2229.             $tmp = "\n".'BT ';
    2230. 

  2230.             $tmp .= sprintf('%.3F',cos($a)).' '.sprintf('%.3F',(-1.0*sin($a))).' '.sprintf('%.3F',sin($a)).' '.sprintf('%.3F',cos($a)).' ';
    2231. 

  2231.             $tmp .= sprintf('%.3F',$xp).' '.sprintf('%.3F',$yp).' Tm';
    2232. 

  2232.             $this->objects[$this->currentContents]['c'] .= $tmp;
    2233. 

  2233.           }
    2234. 

  2234.           if ($wordSpaceAdjust!=0 || $wordSpaceAdjust != $this->wordSpaceAdjust){
    2235. 

  2235.             $this->wordSpaceAdjust=$wordSpaceAdjust;
    2236. 

  2236.             $this->objects[$this->currentContents]['c'].=' '.sprintf('%.3F',$wordSpaceAdjust).' Tw';
    2237. 

  2237.           }
    2238. 

  2238.       }
    2239. 

  2239.       // and move the writing point to the next piece of text
    2240. 

  2240.       $i=$i+$directive-1;
    2241. 

  2241.       $start=$i+1;
    2242. 

  2242.     }
    2243. 

  2243.     
    2244. 

  2244.   }
    2245. 

  2245.   if ($start<$len){
    2246. 

  2246.     $part = substr($text,$start);
    2247. 

  2247.     $this->objects[$this->currentContents]['c'].=' /F'.$this->currentFontNum.' '.sprintf('%.1F',$size).' Tf ';
    2248. 

  2248.     $this->objects[$this->currentContents]['c'].=' ('.$this->filterText($part).') Tj';
    2249. 

  2249.   }
    2250. 

  2250.   $this->objects[$this->currentContents]['c'].=' ET';
    2251. 

  2251. 

  2252.   // if there are any open callbacks, then they should be called, to show the end of the line
    2253. 

  2253.   if ($this->nCallback>0){
    2254. 

  2254.     for ($i=$this->nCallback;$i>0;$i--){
    2255. 

  2255.       // call each function
    2256. 

  2256.       $tmp = $this->PRVTgetTextPosition($x,$y,$angle,$size,$wordSpaceAdjust,$text);
    2257. 

  2257.       $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']);
    2258. 

  2258.       $func = $this->callback[$i]['f'];
    2259. 

  2259.       $this->$func($info);
    2260. 

  2260.     }
    2261. 

  2261.   }
    2262. 

  2262. 

  2263. }
    2264. 

  2264. 

  2265. /**
    2266. 

  2266. * calculate how wide a given text string will be on a page, at a given size.
    2267. 

  2267. * this can be called externally, but is alse used by the other class functions
    2268. 

  2268. */
    2269. 

  2269. function getTextWidth($size,$text){
    2270. 

  2270.   // this function should not change any of the settings, though it will need to
    2271. 

  2271.   // track any directives which change during calculation, so copy them at the start
    2272. 

  2272.   // and put them back at the end.
    2273. 

  2273.   $store_currentTextState = $this->currentTextState;
    2274. 

  2274. 

  2275.   if (!$this->numFonts){
    2276. 

  2276.     $this->selectFont('./fonts/Helvetica');
    2277. 

  2277.   }
    2278. 

  2278. 

  2279.   // converts a number or a float to a string so it can get the width
    2280. 

  2280.   $text = "$text";
    2281. 

  2281. 

  2282.   // hmm, this is where it all starts to get tricky - use the font information to
    2283. 

  2283.   // calculate the width of each character, add them up and convert to user units
    2284. 

  2284.   $w=0;
    2285. 

  2285.   $len=strlen($text);
    2286. 

  2286.   $cf = $this->currentFont;
    2287. 

  2287.   for ($i=0;$i<$len;$i++){
    2288. 

  2288.     $f=1;
    2289. 

  2289.     $directive = $this->PRVTcheckTextDirective($text,$i,$f);
    2290. 

  2290.     if ($directive){
    2291. 

  2291.       if ($f){
    2292. 

  2292.         $this->setCurrentFont();
    2293. 

  2293.         $cf = $this->currentFont;
    2294. 

  2294.       }
    2295. 

  2295.       $i=$i+$directive-1;
    2296. 

  2296.     } else {
    2297. 

  2297.       $char=ord($text[$i]);
    2298. 

  2298.       if (isset($this->fonts[$cf]['differences'][$char])){
    2299. 

  2299.         // then this character is being replaced by another
    2300. 

  2300.         $name = $this->fonts[$cf]['differences'][$char];
    2301. 

  2301.         if (isset($this->fonts[$cf]['C'][$name]['WX'])){
    2302. 

  2302.           $w+=$this->fonts[$cf]['C'][$name]['WX'];
    2303. 

  2303.         }
    2304. 

  2304.       } else if (isset($this->fonts[$cf]['C'][$char]['WX'])){
    2305. 

  2305.         $w+=$this->fonts[$cf]['C'][$char]['WX'];
    2306. 

  2306.       }
    2307. 

  2307.     }
    2308. 

  2308.   }
    2309. 

  2309.   
    2310. 

  2310.   $this->currentTextState = $store_currentTextState;
    2311. 

  2311.   $this->setCurrentFont();
    2312. 

  2312. 

  2313.   return $w*$size/1000;
    2314. 

  2314. }
    2315. 

  2315. 

  2316. /**
    2317. 

  2317. * do a part of the calculation for sorting out the justification of the text
    2318. 

  2318. *
    2319. 

  2319. * @access private
    2320. 

  2320. */
    2321. 

  2321. function PRVTadjustWrapText($text,$actual,$width,&$x,&$adjust,$justification){
    2322. 

  2322.   switch ($justification){
    2323. 

  2323.     case 'left':
    2324. 

  2324.       return;
    2325. 

  2325.       break;
    2326. 

  2326.     case 'right':
    2327. 

  2327.       $x+=$width-$actual;
    2328. 

  2328.       break;
    2329. 

  2329.     case 'center':
    2330. 

  2330.     case 'centre':
    2331. 

  2331.       $x+=($width-$actual)/2;
    2332. 

  2332.       break;
    2333. 

  2333.     case 'full':
    2334. 

  2334.       // count the number of words
    2335. 

  2335.       $words = explode(' ',$text);
    2336. 

  2336.       $nspaces=count($words)-1;
    2337. 

  2337.       if ($nspaces>0){
    2338. 

  2338.         $adjust = ($width-$actual)/$nspaces;
    2339. 

  2339.       } else {
    2340. 

  2340.         $adjust=0;
    2341. 

  2341.       }
    2342. 

  2342.       break;
    2343. 

  2343.   }
    2344. 

  2344. }
    2345. 

  2345. 

  2346. /**
    2347. 

  2347. * add text to the page, but ensure that it fits within a certain width
    2348. 

  2348. * if it does not fit then put in as much as possible, splitting at word boundaries
    2349. 

  2349. * and return the remainder.
    2350. 

  2350. * justification and angle can also be specified for the text
    2351. 

  2351. */
    2352. 

  2352. function addTextWrap($x,$y,$width,$size,$text,$justification='left',$angle=0,$test=0){
    2353. 

  2353.   // this will display the text, and if it goes beyond the width $width, will backtrack to the 
    2354. 

  2354.   // previous space or hyphen, and return the remainder of the text.
    2355. 

  2355. 

  2356.   // $justification can be set to 'left','right','center','centre','full'
    2357. 

  2357. 

  2358.   // need to store the initial text state, as this will change during the width calculation
    2359. 

  2359.   // but will need to be re-set before printing, so that the chars work out right
    2360. 

  2360.   $store_currentTextState = $this->currentTextState;
    2361. 

  2361. 

  2362.   if (!$this->numFonts){$this->selectFont('./fonts/Helvetica');}
    2363. 

  2363.   if ($width<=0){
    2364. 

  2364.     // error, pretend it printed ok, otherwise risking a loop
    2365. 

  2365.     return '';
    2366. 

  2366.   }
    2367. 

  2367.   $w=0;
    2368. 

  2368.   $break=0;
    2369. 

  2369.   $breakWidth=0;
    2370. 

  2370.   $len=strlen($text);
    2371. 

  2371.   $cf = $this->currentFont;
    2372. 

  2372.   $tw = $width/$size*1000;
    2373. 

  2373.   for ($i=0;$i<$len;$i++){
    2374. 

  2374.     $f=1;
    2375. 

  2375.     $directive = $this->PRVTcheckTextDirective($text,$i,$f);
    2376. 

  2376.     if ($directive){
    2377. 

  2377.       if ($f){
    2378. 

  2378.         $this->setCurrentFont();
    2379. 

  2379.         $cf = $this->currentFont;
    2380. 

  2380.       }
    2381. 

  2381.       $i=$i+$directive-1;
    2382. 

  2382.     } else {
    2383. 

  2383.       $cOrd = ord($text[$i]);
    2384. 

  2384.       if (isset($this->fonts[$cf]['differences'][$cOrd])){
    2385. 

  2385.         // then this character is being replaced by another
    2386. 

  2386.         $cOrd2 = $this->fonts[$cf]['differences'][$cOrd];
    2387. 

  2387.       } else {
    2388. 

  2388.         $cOrd2 = $cOrd;
    2389. 

  2389.       }
    2390. 

  2390.   
    2391. 

  2391.       if (isset($this->fonts[$cf]['C'][$cOrd2]['WX'])){
    2392. 

  2392.         $w+=$this->fonts[$cf]['C'][$cOrd2]['WX'];
    2393. 

  2393.       }
    2394. 

  2394.       if ($w>$tw){
    2395. 

  2395.         // then we need to truncate this line
    2396. 

  2396.         if ($break>0){
    2397. 

  2397.           // then we have somewhere that we can split :)
    2398. 

  2398.           if ($text[$break]==' '){
    2399. 

  2399.             $tmp = substr($text,0,$break);
    2400. 

  2400.           } else {
    2401. 

  2401.             $tmp = substr($text,0,$break+1);
    2402. 

  2402.           }
    2403. 

  2403.           $adjust=0;
    2404. 

  2404.           $this->PRVTadjustWrapText($tmp,$breakWidth,$width,$x,$adjust,$justification);
    2405. 

  2405. 

  2406.           // reset the text state
    2407. 

  2407.           $this->currentTextState = $store_currentTextState;
    2408. 

  2408.           $this->setCurrentFont();
    2409. 

  2409.           if (!$test){
    2410. 

  2410.             $this->addText($x,$y,$size,$tmp,$angle,$adjust);
    2411. 

  2411.           }
    2412. 

  2412.           return substr($text,$break+1);
    2413. 

  2413.         } else {
    2414. 

  2414.           // just split before the current character
    2415. 

  2415.           $tmp = substr($text,0,$i);
    2416. 

  2416.           $adjust=0;
    2417. 

  2417.           $ctmp=ord($text[$i]);
    2418. 

  2418.           if (isset($this->fonts[$cf]['differences'][$ctmp])){
    2419. 

  2419.             $ctmp=$this->fonts[$cf]['differences'][$ctmp];
    2420. 

  2420.           }
    2421. 

  2421.           $tmpw=($w-$this->fonts[$cf]['C'][$ctmp]['WX'])*$size/1000;
    2422. 

  2422.           $this->PRVTadjustWrapText($tmp,$tmpw,$width,$x,$adjust,$justification);
    2423. 

  2423.           // reset the text state
    2424. 

  2424.           $this->currentTextState = $store_currentTextState;
    2425. 

  2425.           $this->setCurrentFont();
    2426. 

  2426.           if (!$test){
    2427. 

  2427.             $this->addText($x,$y,$size,$tmp,$angle,$adjust);
    2428. 

  2428.           }
    2429. 

  2429.           return substr($text,$i);
    2430. 

  2430.         }
    2431. 

  2431.       }
    2432. 

  2432.       if ($text[$i]=='-'){
    2433. 

  2433.         $break=$i;
    2434. 

  2434.         $breakWidth = $w*$size/1000;
    2435. 

  2435.       }
    2436. 

  2436.       if ($text[$i]==' '){
    2437. 

  2437.         $break=$i;
    2438. 

  2438.         $ctmp=ord($text[$i]);
    2439. 

  2439.         if (isset($this->fonts[$cf]['differences'][$ctmp])){
    2440. 

  2440.           $ctmp=$this->fonts[$cf]['differences'][$ctmp];
    2441. 

  2441.         }
    2442. 

  2442.         $breakWidth = ($w-$this->fonts[$cf]['C'][$ctmp]['WX'])*$size/1000;
    2443. 

  2443.       }
    2444. 

  2444.     }
    2445. 

  2445.   }
    2446. 

  2446.   // then there was no need to break this line
    2447. 

  2447.   if ($justification=='full'){
    2448. 

  2448.     $justification='left';
    2449. 

  2449.   }
    2450. 

  2450.   $adjust=0;
    2451. 

  2451.   $tmpw=$w*$size/1000;
    2452. 

  2452.   $this->PRVTadjustWrapText($text,$tmpw,$width,$x,$adjust,$justification);
    2453. 

  2453.   // reset the text state
    2454. 

  2454.   $this->currentTextState = $store_currentTextState;
    2455. 

  2455.   $this->setCurrentFont();
    2456. 

  2456.   if (!$test){
    2457. 

  2457.     $this->addText($x,$y,$size,$text,$angle,$adjust,$angle);
    2458. 

  2458.   }
    2459. 

  2459.   return '';
    2460. 

  2460. }
    2461. 

  2461. 

  2462. /**
    2463. 

  2463. * this will be called at a new page to return the state to what it was on the 
    2464. 

  2464. * end of the previous page, before the stack was closed down
    2465. 

  2465. * This is to get around not being able to have open 'q' across pages
    2466. 

  2466. *
    2467. 

  2467. */
    2468. 

  2468. function saveState($pageEnd=0){
    2469. 

  2469.   if ($pageEnd){
    2470. 

  2470.     // this will be called at a new page to return the state to what it was on the 
    2471. 

  2471.     // end of the previous page, before the stack was closed down
    2472. 

  2472.     // This is to get around not being able to have open 'q' across pages
    2473. 

  2473.     $opt = $this->stateStack[$pageEnd]; // ok to use this as stack starts numbering at 1
    2474. 

  2474.     $this->setColor($opt['col']['r'],$opt['col']['g'],$opt['col']['b'],1);
    2475. 

  2475.     $this->setStrokeColor($opt['str']['r'],$opt['str']['g'],$opt['str']['b'],1);
    2476. 

  2476.     $this->objects[$this->currentContents]['c'].="\n".$opt['lin'];
    2477. 

  2477. //    $this->currentLineStyle = $opt['lin'];
    2478. 

  2478.   } else {
    2479. 

  2479.     $this->nStateStack++;
    2480. 

  2480.     $this->stateStack[$this->nStateStack]=array(
    2481. 

  2481.       'col'=>$this->currentColour
    2482. 

  2482.      ,'str'=>$this->currentStrokeColour
    2483. 

  2483.      ,'lin'=>$this->currentLineStyle
    2484. 

  2484.     );
    2485. 

  2485.   }
    2486. 

  2486.   $this->objects[$this->currentContents]['c'].="\nq";
    2487. 

  2487. }
    2488. 

  2488. 

  2489. /**
    2490. 

  2490. * restore a previously saved state
    2491. 

  2491. */
    2492. 

  2492. function restoreState($pageEnd=0){
    2493. 

  2493.   if (!$pageEnd){
    2494. 

  2494.     $n = $this->nStateStack;
    2495. 

  2495.     $this->currentColour = $this->stateStack[$n]['col'];
    2496. 

  2496.     $this->currentStrokeColour = $this->stateStack[$n]['str'];
    2497. 

  2497.     $this->objects[$this->currentContents]['c'].="\n".$this->stateStack[$n]['lin'];
    2498. 

  2498.     $this->currentLineStyle = $this->stateStack[$n]['lin'];
    2499. 

  2499.     unset($this->stateStack[$n]);
    2500. 

  2500.     $this->nStateStack--;
    2501. 

  2501.   }
    2502. 

  2502.   $this->objects[$this->currentContents]['c'].="\nQ";
    2503. 

  2503. }
    2504. 

  2504. 

  2505. /**
    2506. 

  2506. * make a loose object, the output will go into this object, until it is closed, then will revert to
    2507. 

  2507. * the current one.
    2508. 

  2508. * this object will not appear until it is included within a page.
    2509. 

  2509. * the function will return the object number
    2510. 

  2510. */
    2511. 

  2511. function openObject(){
    2512. 

  2512.   $this->nStack++;
    2513. 

  2513.   $this->stack[$this->nStack]=array('c'=>$this->currentContents,'p'=>$this->currentPage);
    2514. 

  2514.   // add a new object of the content type, to hold the data flow
    2515. 

  2515.   $this->numObj++;
    2516. 

  2516.   $this->o_contents($this->numObj,'new');
    2517. 

  2517.   $this->currentContents=$this->numObj;
    2518. 

  2518.   $this->looseObjects[$this->numObj]=1;
    2519. 

  2519.   
    2520. 

  2520.   return $this->numObj;
    2521. 

  2521. }
    2522. 

  2522. 

  2523. /**
    2524. 

  2524. * open an existing object for editing
    2525. 

  2525. */
    2526. 

  2526. function reopenObject($id){
    2527. 

  2527.    $this->nStack++;
    2528. 

  2528.    $this->stack[$this->nStack]=array('c'=>$this->currentContents,'p'=>$this->currentPage);
    2529. 

  2529.    $this->currentContents=$id;
    2530. 

  2530.    // also if this object is the primary contents for a page, then set the current page to its parent
    2531. 

  2531.    if (isset($this->objects[$id]['onPage'])){
    2532. 

  2532.      $this->currentPage = $this->objects[$id]['onPage'];
    2533. 

  2533.    }
    2534. 

  2534. }
    2535. 

  2535. 

  2536. /**
    2537. 

  2537. * close an object
    2538. 

  2538. */
    2539. 

  2539. function closeObject(){
    2540. 

  2540.   // close the object, as long as there was one open in the first place, which will be indicated by
    2541. 

  2541.   // an objectId on the stack.
    2542. 

  2542.   if ($this->nStack>0){
    2543. 

  2543.     $this->currentContents=$this->stack[$this->nStack]['c'];
    2544. 

  2544.     $this->currentPage=$this->stack[$this->nStack]['p'];
    2545. 

  2545.     $this->nStack--;
    2546. 

  2546.     // easier to probably not worry about removing the old entries, they will be overwritten
    2547. 

  2547.     // if there are new ones.
    2548. 

  2548.   }
    2549. 

  2549. }
    2550. 

  2550. 

  2551. /**
    2552. 

  2552. * stop an object from appearing on pages from this point on
    2553. 

  2553. */
    2554. 

  2554. function stopObject($id){
    2555. 

  2555.   // if an object has been appearing on pages up to now, then stop it, this page will
    2556. 

  2556.   // be the last one that could contian it.
    2557. 

  2557.   if (isset($this->addLooseObjects[$id])){
    2558. 

  2558.     $this->addLooseObjects[$id]='';
    2559. 

  2559.   }
    2560. 

  2560. }
    2561. 

  2561. 

  2562. /**
    2563. 

  2563. * after an object has been created, it wil only show if it has been added, using this function.
    2564. 

  2564. */
    2565. 

  2565. function addObject($id,$options='add'){
    2566. 

  2566.   // add the specified object to the page
    2567. 

  2567.   if (isset($this->looseObjects[$id]) && $this->currentContents!=$id){
    2568. 

  2568.     // then it is a valid object, and it is not being added to itself
    2569. 

  2569.     switch($options){
    2570. 

  2570.       case 'all':
    2571. 

  2571.         // then this object is to be added to this page (done in the next block) and 
    2572. 

  2572.         // all future new pages. 
    2573. 

  2573.         $this->addLooseObjects[$id]='all';
    2574. 

  2574.       case 'add':
    2575. 

  2575.         if (isset($this->objects[$this->currentContents]['onPage'])){
    2576. 

  2576.           // then the destination contents is the primary for the page
    2577. 

  2577.           // (though this object is actually added to that page)
    2578. 

  2578.           $this->o_page($this->objects[$this->currentContents]['onPage'],'content',$id);
    2579. 

  2579.         }
    2580. 

  2580.         break;
    2581. 

  2581.       case 'even':
    2582. 

  2582.         $this->addLooseObjects[$id]='even';
    2583. 

  2583.         $pageObjectId=$this->objects[$this->currentContents]['onPage'];
    2584. 

  2584.         if ($this->objects[$pageObjectId]['info']['pageNum']%2==0){
    2585. 

  2585.           $this->addObject($id); // hacky huh :)
    2586. 

  2586.         }
    2587. 

  2587.         break;
    2588. 

  2588.       case 'odd':
    2589. 

  2589.         $this->addLooseObjects[$id]='odd';
    2590. 

  2590.         $pageObjectId=$this->objects[$this->currentContents]['onPage'];
    2591. 

  2591.         if ($this->objects[$pageObjectId]['info']['pageNum']%2==1){
    2592. 

  2592.           $this->addObject($id); // hacky huh :)
    2593. 

  2593.         }
    2594. 

  2594.         break;
    2595. 

  2595.       case 'next':
    2596. 

  2596.         $this->addLooseObjects[$id]='all';
    2597. 

  2597.         break;
    2598. 

  2598.       case 'nexteven':
    2599. 

  2599.         $this->addLooseObjects[$id]='even';
    2600. 

  2600.         break;
    2601. 

  2601.       case 'nextodd':
    2602. 

  2602.         $this->addLooseObjects[$id]='odd';
    2603. 

  2603.         break;
    2604. 

  2604.     }
    2605. 

  2605.   }
    2606. 

  2606. }
    2607. 

  2607. 

  2608. /**
    2609. 

  2609. * add content to the documents info object
    2610. 

  2610. */
    2611. 

  2611. function addInfo($label,$value=0){
    2612. 

  2612.   // this will only work if the label is one of the valid ones.
    2613. 

  2613.   // modify this so that arrays can be passed as well.
    2614. 

  2614.   // if $label is an array then assume that it is key=>value pairs
    2615. 

  2615.   // else assume that they are both scalar, anything else will probably error
    2616. 

  2616.   if (is_array($label)){
    2617. 

  2617.     foreach ($label as $l=>$v){
    2618. 

  2618.       $this->o_info($this->infoObject,$l,$v);
    2619. 

  2619.     }
    2620. 

  2620.   } else {
    2621. 

  2621.     $this->o_info($this->infoObject,$label,$value);
    2622. 

  2622.   }
    2623. 

  2623. }
    2624. 

  2624. 

  2625. /**
    2626. 

  2626. * set the viewer preferences of the document, it is up to the browser to obey these.
    2627. 

  2627. */
    2628. 

  2628. function setPreferences($label,$value=0){
    2629. 

  2629.   // this will only work if the label is one of the valid ones.
    2630. 

  2630.   if (is_array($label)){
    2631. 

  2631.     foreach ($label as $l=>$v){
    2632. 

  2632.       $this->o_catalog($this->catalogId,'viewerPreferences',array($l=>$v));
    2633. 

  2633.     }
    2634. 

  2634.   } else {
    2635. 

  2635.     $this->o_catalog($this->catalogId,'viewerPreferences',array($label=>$value));
    2636. 

  2636.   }
    2637. 

  2637. }
    2638. 

  2638. 

  2639. /**
    2640. 

  2640. * extract an integer from a position in a byte stream
    2641. 

  2641. *
    2642. 

  2642. * @access private
    2643. 

  2643. */
    2644. 

  2644. function PRVT_getBytes(&$data,$pos,$num){
    2645. 

  2645.   // return the integer represented by $num bytes from $pos within $data
    2646. 

  2646.   $ret=0;
    2647. 

  2647.   for ($i=0;$i<$num;$i++){
    2648. 

  2648.     $ret=$ret*256;
    2649. 

  2649.     $ret+=ord($data[$pos+$i]);
    2650. 

  2650.   }
    2651. 

  2651.   return $ret;
    2652. 

  2652. }
    2653. 

  2653. 

  2654. /*
    2655. 

  2655. * Multiply - Images, with same Bitmap resource :-) makes PDF smaller | Updated: 2004-07-15
    2656. 

  2656. */
    2657. 

  2657. 

  2658. function addPngFromFile($file,$x,$y,$w=0,$h=0){
    2659. 

  2659.   // read in a png file, interpret it, then add to the system
    2660. 

  2660.   $error=0;
    2661. 

  2661.   $tmp = get_magic_quotes_runtime();
    2662. 

  2662.   set_magic_quotes_runtime(0);
    2663. 

  2663.   $fp = @fopen($file,'rb');
    2664. 

  2664.   if ($fp){
    2665. 

  2665.     $data='';
    2666. 

  2666.     while(!feof($fp)){
    2667. 

  2667.       $data .= fread($fp,1024);
    2668. 

  2668.     }
    2669. 

  2669.     fclose($fp);
    2670. 

  2670.   } else {
    2671. 

  2671.     $error = 1;
    2672. 

  2672.     $errormsg = 'trouble opening file: '.$file;
    2673. 

  2673.   }
    2674. 

  2674.   set_magic_quotes_runtime($tmp);
    2675. 

  2675.   
    2676. 

  2676.   if (!$error){
    2677. 

  2677.     $header = chr(137).chr(80).chr(78).chr(71).chr(13).chr(10).chr(26).chr(10);
    2678. 

  2678.     if (substr($data,0,8)!=$header){
    2679. 

  2679.       $error=1;
    2680. 

  2680.       $errormsg = 'this file does not have a valid header';
    2681. 

  2681.     }
    2682. 

  2682.   }
    2683. 

  2683. 

  2684.   if (!$error){
    2685. 

  2685.     // set pointer
    2686. 

  2686.     $p = 8;
    2687. 

  2687.     $len = strlen($data);
    2688. 

  2688.     // cycle through the file, identifying chunks
    2689. 

  2689.     $haveHeader=0;
    2690. 

  2690.     $info=array();
    2691. 

  2691.     $idata='';
    2692. 

  2692.     $pdata='';
    2693. 

  2693.     while ($p<$len){
    2694. 

  2694.       $chunkLen = $this->PRVT_getBytes($data,$p,4);
    2695. 

  2695.       $chunkType = substr($data,$p+4,4);
    2696. 

  2696. //      echo $chunkType.' - '.$chunkLen.'<br>';
    2697. 

  2697.     
    2698. 

  2698.       switch($chunkType){
    2699. 

  2699.         case 'IHDR':
    2700. 

  2700.           // this is where all the file information comes from
    2701. 

  2701.           $info['width']=$this->PRVT_getBytes($data,$p+8,4);
    2702. 

  2702.           $info['height']=$this->PRVT_getBytes($data,$p+12,4);
    2703. 

  2703.           $info['bitDepth']=ord($data[$p+16]);
    2704. 

  2704.           $info['colorType']=ord($data[$p+17]);
    2705. 

  2705.           $info['compressionMethod']=ord($data[$p+18]);
    2706. 

  2706.           $info['filterMethod']=ord($data[$p+19]);
    2707. 

  2707.           $info['interlaceMethod']=ord($data[$p+20]);
    2708. 

  2708. //print_r($info);
    2709. 

  2709.           $haveHeader=1;
    2710. 

  2710.           if ($info['compressionMethod']!=0){
    2711. 

  2711.             $error=1;
    2712. 

  2712.             $errormsg = 'unsupported compression method';
    2713. 

  2713.           }
    2714. 

  2714.           if ($info['filterMethod']!=0){
    2715. 

  2715.             $error=1;
    2716. 

  2716.             $errormsg = 'unsupported filter method';
    2717. 

  2717.           }
    2718. 

  2718.           break;
    2719. 

  2719.         case 'PLTE':
    2720. 

  2720.           $pdata.=substr($data,$p+8,$chunkLen);
    2721. 

  2721.           break;
    2722. 

  2722.         case 'IDAT':
    2723. 

  2723.           $idata.=substr($data,$p+8,$chunkLen);
    2724. 

  2724.           break;
    2725. 

  2725.         case 'tRNS': 
    2726. 

  2726.           //this chunk can only occur once and it must occur after the PLTE chunk and before IDAT chunk 
    2727. 

  2727.           //print "tRNS found, color type = ".$info['colorType']."<BR>"; 
    2728. 

  2728.           $transparency = array();
    2729. 

  2729.           if ($info['colorType'] == 3) { // indexed color, rbg 
    2730. 

  2730.           /* corresponding to entries in the plte chunk 
    2731. 

  2731.           Alpha for palette index 0: 1 byte 
    2732. 

  2732.           Alpha for palette index 1: 1 byte 
    2733. 

  2733.           ...etc... 
    2734. 

  2734.           */ 
    2735. 

  2735.             // there will be one entry for each palette entry. up until the last non-opaque entry.
    2736. 

  2736.             // set up an array, stretching over all palette entries which will be o (opaque) or 1 (transparent)
    2737. 

  2737.             $transparency['type']='indexed';
    2738. 

  2738.             $numPalette = strlen($pdata)/3;
    2739. 

  2739.             $trans=0;
    2740. 

  2740.             for ($i=$chunkLen;$i>=0;$i--){
    2741. 

  2741.               if (ord($data[$p+8+$i])==0){
    2742. 

  2742.                 $trans=$i;
    2743. 

  2743.               }
    2744. 

  2744.             }
    2745. 

  2745.             $transparency['data'] = $trans;
    2746. 

  2746.             
    2747. 

  2747.           } elseif($info['colorType'] == 0) { // grayscale 
    2748. 

  2748.           /* corresponding to entries in the plte chunk 
    2749. 

  2749.           Gray: 2 bytes, range 0 .. (2^bitdepth)-1 
    2750. 

  2750.           */ 
    2751. 

  2751. //            $transparency['grayscale']=$this->PRVT_getBytes($data,$p+8,2); // g = grayscale 
    2752. 

  2752.             $transparency['type']='indexed';
    2753. 

  2753.             $transparency['data'] = ord($data[$p+8+1]);
    2754. 

  2754.           
    2755. 

  2755.           } elseif($info['colorType'] == 2) { // truecolor 
    2756. 

  2756.           /* corresponding to entries in the plte chunk 
    2757. 

  2757.           Red: 2 bytes, range 0 .. (2^bitdepth)-1 
    2758. 

  2758.           Green: 2 bytes, range 0 .. (2^bitdepth)-1 
    2759. 

  2759.           Blue: 2 bytes, range 0 .. (2^bitdepth)-1 
    2760. 

  2760.           */ 
    2761. 

  2761.             $transparency['r']=$this->PRVT_getBytes($data,$p+8,2); // r from truecolor 
    2762. 

  2762.             $transparency['g']=$this->PRVT_getBytes($data,$p+10,2); // g from truecolor 
    2763. 

  2763.             $transparency['b']=$this->PRVT_getBytes($data,$p+12,2); // b from truecolor 
    2764. 

  2764.           
    2765. 

  2765.           } else { 
    2766. 

  2766.           //unsupported transparency type 
    2767. 

  2767.           } 
    2768. 

  2768.           // KS End new code 
    2769. 

  2769.           break; 
    2770. 

  2770.         default:
    2771. 

  2771.           break;
    2772. 

  2772.       }
    2773. 

  2773.     
    2774. 

  2774.       $p += $chunkLen+12;
    2775. 

  2775.     }
    2776. 

  2776.     
    2777. 

  2777.     if(!$haveHeader){
    2778. 

  2778.       $error = 1;
    2779. 

  2779.       $errormsg = 'information header is missing';
    2780. 

  2780.     }
    2781. 

  2781.     if (isset($info['interlaceMethod']) && $info['interlaceMethod']){
    2782. 

  2782.       $error = 1;
    2783. 

  2783.       $errormsg = 'There appears to be no support for interlaced images in pdf.';
    2784. 

  2784.     }
    2785. 

  2785.   }
    2786. 

  2786. 

  2787.   if (!$error && $info['bitDepth'] > 8){
    2788. 

  2788.     $error = 1;
    2789. 

  2789.     $errormsg = 'only bit depth of 8 or less is supported';
    2790. 

  2790.   }
    2791. 

  2791. 

  2792.   if (!$error){
    2793. 

  2793.     if ($info['colorType']!=2 && $info['colorType']!=0 && $info['colorType']!=3){
    2794. 

  2794.       $error = 1;
    2795. 

  2795.       $errormsg = 'transparancey alpha channel not supported, transparency only supported for palette images.';
    2796. 

  2796.     } else {
    2797. 

  2797.       switch ($info['colorType']){
    2798. 

  2798.         case 3:
    2799. 

  2799.           $color = 'DeviceRGB';
    2800. 

  2800.           $ncolor=1;
    2801. 

  2801.           break;
    2802. 

  2802.         case 2:
    2803. 

  2803.           $color = 'DeviceRGB';
    2804. 

  2804.           $ncolor=3;
    2805. 

  2805.           break;
    2806. 

  2806.         case 0:
    2807. 

  2807.           $color = 'DeviceGray';
    2808. 

  2808.           $ncolor=1;
    2809. 

  2809.           break;
    2810. 

  2810.       }
    2811. 

  2811.     }
    2812. 

  2812.   }
    2813. 

  2813.   if ($error){
    2814. 

  2814.     $this->addMessage('PNG error - ('.$file.') '.$errormsg);
    2815. 

  2815.     return;
    2816. 

  2816.   }
    2817. 

  2817.   if ($w==0){
    2818. 

  2818.     $w=$h/$info['height']*$info['width'];
    2819. 

  2819.   }
    2820. 

  2820.   if ($h==0){
    2821. 

  2821.     $h=$w*$info['height']/$info['width'];
    2822. 

  2822.   }
    2823. 

  2823. //print_r($info);
    2824. 

  2824.   // so this image is ok... add it in.
    2825. 

  2825.   $this->numImages++;
    2826. 

  2826.   $im=$this->numImages;
    2827. 

  2827.   $label='I'.$im;
    2828. 

  2828.   $this->numObj++;
    2829. 

  2829. //  $this->o_image($this->numObj,'new',array('label'=>$label,'data'=>$idata,'iw'=>$w,'ih'=>$h,'type'=>'png','ic'=>$info['width']));
    2830. 

  2830.   $options = array('label'=>$label,'data'=>$idata,'bitsPerComponent'=>$info['bitDepth'],'pdata'=>$pdata
    2831. 

  2831.                                       ,'iw'=>$info['width'],'ih'=>$info['height'],'type'=>'png','color'=>$color,'ncolor'=>$ncolor);
    2832. 

  2832.   if (isset($transparency)){
    2833. 

  2833.     $options['transparency']=$transparency;
    2834. 

  2834.   }
    2835. 

  2835.   /* Optimierung: Redundanzfreies Bilder - Laden */
    2836. 

  2836.   if(count($this->bg_files[$file])) {
    2837. 

  2837. 	$this->o_pages($this->currentNode,'xObject',array('label'=>$label,'objNum'=>$this->bg_files[$file]['obj']));
    2838. 

  2838. 	$this->numObj--;
    2839. 

  2839.   }else{
    2840. 

  2840. 	$this->o_image($this->numObj,'new',$options);
    2841. 

  2841. 	$this->bg_files[$file] = array('obj'=>($this->numObj-1));
    2842. 

  2842.   }
    2843. 

  2843. 

  2844.   $this->objects[$this->currentContents]['c'].="\nq";
    2845. 

  2845.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3F',$w)." 0 0 ".sprintf('%.3F',$h)." ".sprintf('%.3F',$x)." ".sprintf('%.3F',$y)." cm";
    2846. 

  2846.   $this->objects[$this->currentContents]['c'].="\n/".$label.' Do';
    2847. 

  2847.   $this->objects[$this->currentContents]['c'].="\nQ";
    2848. 

  2848. }
    2849. 

  2849. 

  2850. /**
    2851. 

  2851. * add a JPEG image into the document, from a file
    2852. 

  2852. */
    2853. 

  2853. function addJpegFromFile($img,$x,$y,$w=0,$h=0){
    2854. 

  2854.   // attempt to add a jpeg image straight from a file, using no GD commands
    2855. 

  2855.   // note that this function is unable to operate on a remote file.
    2856. 

  2856. 

  2857.   if (!file_exists($img)){
    2858. 

  2858.     return;
    2859. 

  2859.   }
    2860. 

  2860. 

  2861.   $tmp=getimagesize($img);
    2862. 

  2862.   $imageWidth=$tmp[0];
    2863. 

  2863.   $imageHeight=$tmp[1];
    2864. 

  2864. 

  2865.   if (isset($tmp['channels'])){
    2866. 

  2866.     $channels = $tmp['channels'];
    2867. 

  2867.   } else {
    2868. 

  2868.     $channels = 3;
    2869. 

  2869.   }
    2870. 

  2870. 

  2871.   if ($w<=0 && $h<=0){
    2872. 

  2872.     $w=$imageWidth;
    2873. 

  2873.   }
    2874. 

  2874.   if ($w==0){
    2875. 

  2875.     $w=$h/$imageHeight*$imageWidth;
    2876. 

  2876.   }
    2877. 

  2877.   if ($h==0){
    2878. 

  2878.     $h=$w*$imageHeight/$imageWidth;
    2879. 

  2879.   }
    2880. 

  2880. 

  2881.   $fp=fopen($img,'rb');
    2882. 

  2882. 

  2883.   $tmp = get_magic_quotes_runtime();
    2884. 

  2884.   set_magic_quotes_runtime(0);
    2885. 

  2885.   $data = fread($fp,filesize($img));
    2886. 

  2886.   set_magic_quotes_runtime($tmp);
    2887. 

  2887.   
    2888. 

  2888.   fclose($fp);
    2889. 

  2889. 

  2890.   $this->addJpegImage_common($data,$x,$y,$w,$h,$imageWidth,$imageHeight,$channels);
    2891. 

  2891. }
    2892. 

  2892. 

  2893. /**
    2894. 

  2894. * add an image into the document, from a GD object
    2895. 

  2895. * this function is not all that reliable, and I would probably encourage people to use 
    2896. 

  2896. * the file based functions
    2897. 

  2897. */
    2898. 

  2898. function addImage(&$img,$x,$y,$w=0,$h=0,$quality=75){
    2899. 

  2899.   // add a new image into the current location, as an external object
    2900. 

  2900.   // add the image at $x,$y, and with width and height as defined by $w & $h
    2901. 

  2901.   
    2902. 

  2902.   // note that this will only work with full colour images and makes them jpg images for display
    2903. 

  2903.   // later versions could present lossless image formats if there is interest.
    2904. 

  2904.   
    2905. 

  2905.   // there seems to be some problem here in that images that have quality set above 75 do not appear
    2906. 

  2906.   // not too sure why this is, but in the meantime I have restricted this to 75.  
    2907. 

  2907.   if ($quality>75){
    2908. 

  2908.     $quality=75;
    2909. 

  2909.   }
    2910. 

  2910. 

  2911.   // if the width or height are set to zero, then set the other one based on keeping the image
    2912. 

  2912.   // height/width ratio the same, if they are both zero, then give up :)
    2913. 

  2913.   $imageWidth=imagesx($img);
    2914. 

  2914.   $imageHeight=imagesy($img);
    2915. 

  2915.   
    2916. 

  2916.   if ($w<=0 && $h<=0){
    2917. 

  2917.     return;
    2918. 

  2918.   }
    2919. 

  2919.   if ($w==0){
    2920. 

  2920.     $w=$h/$imageHeight*$imageWidth;
    2921. 

  2921.   }
    2922. 

  2922.   if ($h==0){
    2923. 

  2923.     $h=$w*$imageHeight/$imageWidth;
    2924. 

  2924.   }
    2925. 

  2925.   
    2926. 

  2926.   // gotta get the data out of the img..
    2927. 

  2927. 

  2928.   // so I write to a temp file, and then read it back.. soo ugly, my apologies.
    2929. 

  2929.   $tmpName=tempnam(sys_get_temp_dir(),'img');
    2930. 

  2930.   imagejpeg($img,$tmpName,$quality);
    2931. 

  2931.   $fp=fopen($tmpName,'rb');
    2932. 

  2932. 

  2933.   $tmp = get_magic_quotes_runtime();
    2934. 

  2934.   set_magic_quotes_runtime(0);
    2935. 

  2935.   $fp = @fopen($tmpName,'rb');
    2936. 

  2936.   if ($fp){
    2937. 

  2937.     $data='';
    2938. 

  2938.     while(!feof($fp)){
    2939. 

  2939.       $data .= fread($fp,1024);
    2940. 

  2940.     }
    2941. 

  2941.     fclose($fp);
    2942. 

  2942.   } else {
    2943. 

  2943.     $error = 1;
    2944. 

  2944.     $errormsg = 'trouble opening file';
    2945. 

  2945.   }
    2946. 

  2946. //  $data = fread($fp,filesize($tmpName));
    2947. 

  2947.   set_magic_quotes_runtime($tmp);
    2948. 

  2948. //  fclose($fp);
    2949. 

  2949.   unlink($tmpName);
    2950. 

  2950.   $this->addJpegImage_common($data,$x,$y,$w,$h,$imageWidth,$imageHeight);
    2951. 

  2951. }
    2952. 

  2952. 

  2953. /**
    2954. 

  2954. * common code used by the two JPEG adding functions
    2955. 

  2955. *
    2956. 

  2956. * @access private
    2957. 

  2957. */
    2958. 

  2958. function addJpegImage_common(&$data,$x,$y,$w=0,$h=0,$imageWidth,$imageHeight,$channels=3){
    2959. 

  2959.   // note that this function is not to be called externally
    2960. 

  2960.   // it is just the common code between the GD and the file options
    2961. 

  2961.   $this->numImages++;
    2962. 

  2962.   $im=$this->numImages;
    2963. 

  2963.   $label='I'.$im;
    2964. 

  2964.   $this->numObj++;
    2965. 

  2965.   $this->o_image($this->numObj,'new',array('label'=>$label,'data'=>$data,'iw'=>$imageWidth,'ih'=>$imageHeight,'channels'=>$channels));
    2966. 

  2966.   $this->objects[$this->currentContents]['c'].="\nq";
    2967. 

  2967.   $this->objects[$this->currentContents]['c'].="\n".$w." 0 0 ".$h." ".$x." ".$y." cm";
    2968. 

  2968.   $this->objects[$this->currentContents]['c'].="\n/".$label.' Do';
    2969. 

  2969.   $this->objects[$this->currentContents]['c'].="\nQ";
    2970. 

  2970. }
    2971. 

  2971. 

  2972. /**
    2973. 

  2973. * specify where the document should open when it first starts
    2974. 

  2974. */
    2975. 

  2975. function openHere($style,$a=0,$b=0,$c=0){
    2976. 

  2976.   // this function will open the document at a specified page, in a specified style
    2977. 

  2977.   // the values for style, and the required paramters are:
    2978. 

  2978.   // 'XYZ'  left, top, zoom
    2979. 

  2979.   // 'Fit'
    2980. 

  2980.   // 'FitH' top
    2981. 

  2981.   // 'FitV' left
    2982. 

  2982.   // 'FitR' left,bottom,right
    2983. 

  2983.   // 'FitB'
    2984. 

  2984.   // 'FitBH' top
    2985. 

  2985.   // 'FitBV' left
    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->catalogId;
    2989. 

  2989.   $this->o_catalog($id,'openHere',$this->numObj);
    2990. 

  2990. }
    2991. 

  2991. 

  2992. /**
    2993. 

  2993. * create a labelled destination within the document
    2994. 

  2994. */
    2995. 

  2995. function addDestination($label,$style,$a=0,$b=0,$c=0){
    2996. 

  2996.   // associates the given label with the destination, it is done this way so that a destination can be specified after
    2997. 

  2997.   // it has been linked to
    2998. 

  2998.   // styles are the same as the 'openHere' function
    2999. 

  2999.   $this->numObj++;
    3000. 

  3000.   $this->o_destination($this->numObj,'new',array('page'=>$this->currentPage,'type'=>$style,'p1'=>$a,'p2'=>$b,'p3'=>$c));
    3001. 

  3001.   $id = $this->numObj;
    3002. 

  3002.   // store the label->idf relationship, note that this means that labels can be used only once
    3003. 

  3003.   $this->destinations["$label"]=$id;
    3004. 

  3004. }
    3005. 

  3005. 

  3006. /**
    3007. 

  3007. * define font families, this is used to initialize the font families for the default fonts
    3008. 

  3008. * and for the user to add new ones for their fonts. The default bahavious can be overridden should
    3009. 

  3009. * that be desired.
    3010. 

  3010. */
    3011. 

  3011. function setFontFamily($family,$options=''){
    3012. 

  3012.   if (!is_array($options)){
    3013. 

  3013.     if ($family=='init'){
    3014. 

  3014.       // set the known family groups
    3015. 

  3015.       // these font families will be used to enable bold and italic markers to be included
    3016. 

  3016.       // within text streams. html forms will be used... <b></b> <i></i>
    3017. 

  3017.       $this->fontFamilies['Helvetica.afm']=array(
    3018. 

  3018.          'b'=>'Helvetica-Bold.afm'
    3019. 

  3019.         ,'i'=>'Helvetica-Oblique.afm'
    3020. 

  3020.         ,'bi'=>'Helvetica-BoldOblique.afm'
    3021. 

  3021.         ,'ib'=>'Helvetica-BoldOblique.afm'
    3022. 

  3022.       );
    3023. 

  3023.       $this->fontFamilies['Courier.afm']=array(
    3024. 

  3024.          'b'=>'Courier-Bold.afm'
    3025. 

  3025.         ,'i'=>'Courier-Oblique.afm'
    3026. 

  3026.         ,'bi'=>'Courier-BoldOblique.afm'
    3027. 

  3027.         ,'ib'=>'Courier-BoldOblique.afm'
    3028. 

  3028.       );
    3029. 

  3029.       $this->fontFamilies['Times-Roman.afm']=array(
    3030. 

  3030.          'b'=>'Times-Bold.afm'
    3031. 

  3031.         ,'i'=>'Times-Italic.afm'
    3032. 

  3032.         ,'bi'=>'Times-BoldItalic.afm'
    3033. 

  3033.         ,'ib'=>'Times-BoldItalic.afm'
    3034. 

  3034.       );
    3035. 

  3035.     }
    3036. 

  3036.   } else {
    3037. 

  3037.     // the user is trying to set a font family
    3038. 

  3038.     // note that this can also be used to set the base ones to something else
    3039. 

  3039.     if (strlen($family)){
    3040. 

  3040.       $this->fontFamilies[$family] = $options;
    3041. 

  3041.     }
    3042. 

  3042.   }
    3043. 

  3043. }
    3044. 

  3044. 

  3045. /**
    3046. 

  3046. * used to add messages for use in debugging
    3047. 

  3047. */
    3048. 

  3048. function addMessage($message){
    3049. 

  3049.   $this->messages.=$message."\n";
    3050. 

  3050. }
    3051. 

  3051. 

  3052. /**
    3053. 

  3053. * a few functions which should allow the document to be treated transactionally.
    3054. 

  3054. */
    3055. 

  3055. function transaction($action){
    3056. 

  3056.   switch ($action){
    3057. 

  3057.     case 'start':
    3058. 

  3058.       // store all the data away into the checkpoint variable
    3059. 

  3059.       $data = get_object_vars($this);
    3060. 

  3060.       $this->checkpoint = $data;
    3061. 

  3061.       unset($data);
    3062. 

  3062.       break;
    3063. 

  3063.     case 'commit':
    3064. 

  3064.       if (is_array($this->checkpoint) && isset($this->checkpoint['checkpoint'])){
    3065. 

  3065.         $tmp = $this->checkpoint['checkpoint'];
    3066. 

  3066.         $this->checkpoint = $tmp;
    3067. 

  3067.         unset($tmp);
    3068. 

  3068.       } else {
    3069. 

  3069.         $this->checkpoint='';
    3070. 

  3070.       }
    3071. 

  3071.       break;
    3072. 

  3072.     case 'rewind':
    3073. 

  3073.       // do not destroy the current checkpoint, but move us back to the state then, so that we can try again
    3074. 

  3074.       if (is_array($this->checkpoint)){
    3075. 

  3075.         // can only abort if were inside a checkpoint
    3076. 

  3076.         $tmp = $this->checkpoint;
    3077. 

  3077.         foreach ($tmp as $k=>$v){
    3078. 

  3078.           if ($k != 'checkpoint'){
    3079. 

  3079.             $this->$k=$v;
    3080. 

  3080.           }
    3081. 

  3081.         }
    3082. 

  3082.         unset($tmp);
    3083. 

  3083.       }
    3084. 

  3084.       break;
    3085. 

  3085.     case 'abort':
    3086. 

  3086.       if (is_array($this->checkpoint)){
    3087. 

  3087.         // can only abort if were inside a checkpoint
    3088. 

  3088.         $tmp = $this->checkpoint;
    3089. 

  3089.         foreach ($tmp as $k=>$v){
    3090. 

  3090.           $this->$k=$v;
    3091. 

  3091.         }
    3092. 

  3092.         unset($tmp);
    3093. 

  3093.       }
    3094. 

  3094.       break;
    3095. 

  3095.   }
    3096. 

  3096. 

  3097. }
    3098. 

  3098. 

  3099. } // end of class
    3100. 

  3100. 

  3101. ?>
    3102.