PageRenderTime 62ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 1ms

/build/PhpDocumentor/phpDocumentor/Converters/PDF/default/class.pdf.php

http://github.com/jstayton/QueryBuilder
PHP | 2047 lines | 1440 code | 99 blank | 508 comment | 248 complexity | 9c0a48217c7843621afbceff25ee671b MD5 | raw file
Possible License(s): LGPL-2.1 
    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * @package Cpdf
    4. 

  4.  */
    5. 

  5. /**
    6. 

  6. * Cpdf
    7. 

  7. *
    8. 

  8. *
    9. 

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

  10. * any requirement for additional modules.
    11. 

  11. *
    12. 

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

  13. * simplify the creation of documents.
    14. 

  14. *
    15. 

  15. * IMPORTANT NOTE
    16. 

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

  17. * 
    18. 

  18. * LICENCE
    19. 

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

  20. *
    21. 

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

  22. * @version 	009
    23. 

  23. * @package Cpdf
    24. 

  24. * @link http://www.ros.co.nz/pdf
    25. 

  25. */
    26. 

  26. class Cpdf {
    27. 

  27. 

  28. /**
    29. 

  29. * the current number of pdf objects in the document
    30. 

  30. */
    31. 

  31. var $numObj=0;
    32. 

  32. /**
    33. 

  33. * this array contains all of the pdf objects, ready for final assembly
    34. 

  34. */
    35. 

  35. var $objects = array();
    36. 

  36. /**
    37. 

  37. * the objectId (number within the objects array) of the document catalog
    38. 

  38. */
    39. 

  39. var $catalogId;
    40. 

  40. /**
    41. 

  41. * array carrying information about the fonts that the system currently knows about
    42. 

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

  43. */
    44. 

  44. var $fonts=array(); 
    45. 

  45. /**
    46. 

  46. * a record of the current font
    47. 

  47. */
    48. 

  48. var $currentFont='';
    49. 

  49. /**
    50. 

  50. * the current base font
    51. 

  51. */
    52. 

  52. var $currentBaseFont='';
    53. 

  53. /**
    54. 

  54. * the number of the current font within the font array
    55. 

  55. */
    56. 

  56. var $currentFontNum=0;
    57. 

  57. /**
    58. 

  58. * 
    59. 

  59. */
    60. 

  60. var $currentNode;
    61. 

  61. /**
    62. 

  62. * object number of the current page
    63. 

  63. */
    64. 

  64. var $currentPage;
    65. 

  65. /**
    66. 

  66. * object number of the currently active contents block
    67. 

  67. */
    68. 

  68. var $currentContents;
    69. 

  69. /**
    70. 

  70. * number of fonts within the system
    71. 

  71. */
    72. 

  72. var $numFonts=0;
    73. 

  73. /**
    74. 

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

  75. */
    76. 

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

  77. /**
    78. 

  78. * current colour for stroke operations (lines etc.)
    79. 

  79. */
    80. 

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

  81. /**
    82. 

  82. * current style that lines are drawn in
    83. 

  83. */
    84. 

  84. var $currentLineStyle='';
    85. 

  85. /**
    86. 

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

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

  88. */
    89. 

  89. var $stateStack = array();
    90. 

  90. /**
    91. 

  91. * number of elements within the state stack
    92. 

  92. */
    93. 

  93. var $nStateStack = 0;
    94. 

  94. /**
    95. 

  95. * number of page objects within the document
    96. 

  96. */
    97. 

  97. var $numPages=0;
    98. 

  98. /**
    99. 

  99. * object Id storage stack
    100. 

  100. */
    101. 

  101. var $stack=array();
    102. 

  102. /**
    103. 

  103. * number of elements within the object Id storage stack
    104. 

  104. */
    105. 

  105. var $nStack=0;
    106. 

  106. /**
    107. 

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

  108. * these have been added with the addObject function
    109. 

  109. */
    110. 

  110. var $looseObjects=array();
    111. 

  111. /**
    112. 

  112. * array contains infomation about how the loose objects are to be added to the document
    113. 

  113. */
    114. 

  114. var $addLooseObjects=array();
    115. 

  115. /**
    116. 

  116. * the objectId of the information object for the document
    117. 

  117. * this contains authorship, title etc.
    118. 

  118. */
    119. 

  119. var $infoObject=0;
    120. 

  120. /**
    121. 

  121. * number of images being tracked within the document
    122. 

  122. */
    123. 

  123. var $numImages=0;
    124. 

  124. /**
    125. 

  125. * an array containing options about the document
    126. 

  126. * it defaults to turning on the compression of the objects
    127. 

  127. */
    128. 

  128. var $options=array('compression'=>1);
    129. 

  129. /**
    130. 

  130. * the objectId of the first page of the document
    131. 

  131. */
    132. 

  132. var $firstPageId;
    133. 

  133. /**
    134. 

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

  135. * when the spacing is changed.
    136. 

  136. */
    137. 

  137. var $wordSpaceAdjust=0;
    138. 

  138. /**
    139. 

  139. * the object Id of the procset object
    140. 

  140. */
    141. 

  141. var $procsetObjectId;
    142. 

  142. /**
    143. 

  143. * store the information about the relationship between font families
    144. 

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

  145. * the value of this array is initialised in the constuctor function.
    146. 

  146. */
    147. 

  147. var $fontFamilies = array();
    148. 

  148. /**
    149. 

  149. * track if the current font is bolded or italicised
    150. 

  150. */
    151. 

  151. var $currentTextState = ''; 
    152. 

  152. /**
    153. 

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

  154. */
    155. 

  155. var $messages='';
    156. 

  156. /**
    157. 

  157. * the ancryption array for the document encryption is stored here
    158. 

  158. */
    159. 

  159. var $arc4='';
    160. 

  160. /**
    161. 

  161. * the object Id of the encryption information
    162. 

  162. */
    163. 

  163. var $arc4_objnum=0;
    164. 

  164. /**
    165. 

  165. * the file identifier, used to uniquely identify a pdf document
    166. 

  166. */
    167. 

  167. var $fileIdentifier='';
    168. 

  168. /**
    169. 

  169. * a flag to say if a document is to be encrypted or not
    170. 

  170. */
    171. 

  171. var $encrypted=0;
    172. 

  172. /**
    173. 

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

  174. */
    175. 

  175. var $encryptionKey='';
    176. 

  176. /**
    177. 

  177. * array which forms a stack to keep track of nested callback functions
    178. 

  178. */
    179. 

  179. var $callback = array();
    180. 

  180. /**
    181. 

  181. * the number of callback functions in the callback array
    182. 

  182. */
    183. 

  183. var $nCallback = 0;
    184. 

  184. /**
    185. 

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

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

  187. */
    188. 

  188. var $destinations = array();
    189. 

  189. /**
    190. 

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

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

  192. * note that this includes the objects array, so these can be large.
    193. 

  193. */
    194. 

  194. var $checkpoint = '';
    195. 

  195. /**
    196. 

  196. * class constructor
    197. 

  197. * this will start a new document
    198. 

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

  199. */
    200. 

  200. function Cpdf ($pageSize=array(0,0,612,792)){
    201. 

  201.   $this->newDocument($pageSize);
    202. 

  202.   
    203. 

  203.   // also initialize the font families that are known about already
    204. 

  204.   $this->setFontFamily('init');
    205. 

  205. //  $this->fileIdentifier = md5('xxxxxxxx'.time());
    206. 

  206. 

  207. }
    208. 

  208. 

  209. /**
    210. 

  210. * Document object methods (internal use only)
    211. 

  211. *
    212. 

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

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

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

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

  216. *           'new' - create the object with the id $id
    217. 

  217. *           'out' - produce the output for the pdf object
    218. 

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

  219. *
    220. 

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

  221. * within the pdf 'file'.
    222. 

  222. */
    223. 

  223. 

  224. /**
    225. 

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

  226. */
    227. 

  227. function o_destination($id,$action,$options=''){
    228. 

  228.   if ($action!='new'){
    229. 

  229.     $o =& $this->objects[$id];
    230. 

  230.   }
    231. 

  231.   switch($action){
    232. 

  232.     case 'new':
    233. 

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

  234.       $tmp = '';
    235. 

  235.       switch ($options['type']){
    236. 

  236.         case 'XYZ':
    237. 

  237.         case 'FitR':
    238. 

  238.           $tmp =  ' '.$options['p3'].$tmp;
    239. 

  239.         case 'FitH':
    240. 

  240.         case 'FitV':
    241. 

  241.         case 'FitBH':
    242. 

  242.         case 'FitBV':
    243. 

  243.           $tmp =  ' '.$options['p1'].' '.$options['p2'].$tmp;
    244. 

  244.         case 'Fit':
    245. 

  245.         case 'FitB':
    246. 

  246.           $tmp =  $options['type'].$tmp;
    247. 

  247.           $this->objects[$id]['info']['string']=$tmp;
    248. 

  248.           $this->objects[$id]['info']['page']=$options['page'];
    249. 

  249.       }
    250. 

  250.       break;
    251. 

  251.     case 'out':
    252. 

  252.       $tmp = $o['info'];
    253. 

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

  254.       return $res;
    255. 

  255.       break;
    256. 

  256.   }
    257. 

  257. }
    258. 

  258. 

  259. /**
    260. 

  260. * set the viewer preferences
    261. 

  261. */
    262. 

  262. function o_viewerPreferences($id,$action,$options=''){
    263. 

  263.   if ($action!='new'){
    264. 

  264.     $o =& $this->objects[$id];
    265. 

  265.   }
    266. 

  266.   switch ($action){
    267. 

  267.     case 'new':
    268. 

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

  269.       break;
    270. 

  270.     case 'add':
    271. 

  271.       foreach($options as $k=>$v){
    272. 

  272.         switch ($k){
    273. 

  273.           case 'HideToolbar':
    274. 

  274.           case 'HideMenubar':
    275. 

  275.           case 'HideWindowUI':
    276. 

  276.           case 'FitWindow':
    277. 

  277.           case 'CenterWindow':
    278. 

  278.           case 'NonFullScreenPageMode':
    279. 

  279.           case 'Direction':
    280. 

  280.             $o['info'][$k]=$v;
    281. 

  281.           break;
    282. 

  282.         }
    283. 

  283.       }
    284. 

  284.       break;
    285. 

  285.     case 'out':
    286. 

  286. 

  287.       $res="\n".$id." 0 obj\n".'<< ';
    288. 

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

  289.         $res.="\n/".$k.' '.$v;
    290. 

  290.       }
    291. 

  291.       $res.="\n>>\n";
    292. 

  292.       return $res;
    293. 

  293.       break;
    294. 

  294.   }
    295. 

  295. }
    296. 

  296. 

  297. /**
    298. 

  298. * define the document catalog, the overall controller for the document
    299. 

  299. */
    300. 

  300. function o_catalog($id,$action,$options=''){
    301. 

  301.   if ($action!='new'){
    302. 

  302.     $o =& $this->objects[$id];
    303. 

  303.   }
    304. 

  304.   switch ($action){
    305. 

  305.     case 'new':
    306. 

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

  307.       $this->catalogId=$id;
    308. 

  308.       break;
    309. 

  309.     case 'outlines':
    310. 

  310.     case 'pages':
    311. 

  311.     case 'openHere':
    312. 

  312.       $o['info'][$action]=$options;
    313. 

  313.       break;
    314. 

  314.     case 'viewerPreferences':
    315. 

  315.       if (!isset($o['info']['viewerPreferences'])){
    316. 

  316.         $this->numObj++;
    317. 

  317.         $this->o_viewerPreferences($this->numObj,'new');
    318. 

  318.         $o['info']['viewerPreferences']=$this->numObj;
    319. 

  319.       }
    320. 

  320.       $vp = $o['info']['viewerPreferences'];
    321. 

  321.       $this->o_viewerPreferences($vp,'add',$options);
    322. 

  322.       break;
    323. 

  323.     case 'out':
    324. 

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

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

  326.         switch($k){
    327. 

  327.           case 'outlines':
    328. 

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

  329.             break;
    330. 

  330.           case 'pages':
    331. 

  331.             $res.="\n".'/Pages '.$v.' 0 R';
    332. 

  332.             break;
    333. 

  333.           case 'viewerPreferences':
    334. 

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

  335.             break;
    336. 

  336.           case 'openHere':
    337. 

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

  338.             break;
    339. 

  339.         }
    340. 

  340.       }
    341. 

  341.       $res.=" >>\nendobj";
    342. 

  342.       return $res;
    343. 

  343.       break;
    344. 

  344.   }
    345. 

  345. }
    346. 

  346. 

  347. /**
    348. 

  348. * object which is a parent to the pages in the document
    349. 

  349. */
    350. 

  350. function o_pages($id,$action,$options=''){
    351. 

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

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

  353.   }
    354. 

  354.   switch ($action){
    355. 

  355.     case 'new':
    356. 

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

  357.       $this->o_catalog($this->catalogId,'pages',$id);
    358. 

  358.       break;
    359. 

  359.     case 'page':
    360. 

  360.       if (!is_array($options)){
    361. 

  361.         // then it will just be the id of the new page
    362. 

  362.         $o['info']['pages'][]=$options;
    363. 

  363.       } else {
    364. 

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

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

  366.         if (isset($options['id']) && isset($options['rid']) && isset($options['pos'])){
    367. 

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

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

  369.             // then there is a match
    370. 

  370.             // make a space
    371. 

  371.             switch ($options['pos']){
    372. 

  372.               case 'before':
    373. 

  373.                 $k = $i;
    374. 

  374.                 break;
    375. 

  375.               case 'after':
    376. 

  376.                 $k=$i+1;
    377. 

  377.                 break;
    378. 

  378.               default:
    379. 

  379.                 $k=-1;
    380. 

  380.                 break;
    381. 

  381.             }
    382. 

  382.             if ($k>=0){
    383. 

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

  384.                 $o['info']['pages'][$j+1]=$o['info']['pages'][$j];
    385. 

  385.               }
    386. 

  386.               $o['info']['pages'][$k]=$options['id'];
    387. 

  387.             }
    388. 

  388.           }
    389. 

  389.         } 
    390. 

  390.       }
    391. 

  391.       break;
    392. 

  392.     case 'procset':
    393. 

  393.       $o['info']['procset']=$options;
    394. 

  394.       break;
    395. 

  395.     case 'mediaBox':
    396. 

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

  397.       break;
    398. 

  398.     case 'font':
    399. 

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

  400.       break;
    401. 

  401.     case 'xObject':
    402. 

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

  403.       break;
    404. 

  404.     case 'out':
    405. 

  405.       if (count($o['info']['pages'])){
    406. 

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

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

  408.           $res.=$v." 0 R\n";
    409. 

  409.         }
    410. 

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

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

  412.           $res.="\n/Resources <<";
    413. 

  413.           if (isset($o['info']['procset'])){
    414. 

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

  415.           }
    416. 

  416.           if (isset($o['info']['fonts']) && count($o['info']['fonts'])){
    417. 

  417.             $res.="\n/Font << ";
    418. 

  418.             foreach($o['info']['fonts'] as $finfo){
    419. 

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

  420.             }
    421. 

  421.             $res.=" >>";
    422. 

  422.           }
    423. 

  423.           if (isset($o['info']['xObjects']) && count($o['info']['xObjects'])){
    424. 

  424.             $res.="\n/XObject << ";
    425. 

  425.             foreach($o['info']['xObjects'] as $finfo){
    426. 

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

  427.             }
    428. 

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

  429.           }
    430. 

  430.           $res.="\n>>";
    431. 

  431.           if (isset($o['info']['mediaBox'])){
    432. 

  432.             $tmp=$o['info']['mediaBox'];
    433. 

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

  434.           }
    435. 

  435.         }
    436. 

  436.         $res.="\n >>\nendobj";
    437. 

  437.       } else {
    438. 

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

  439.       }
    440. 

  440.       return $res;
    441. 

  441.     break;
    442. 

  442.   }
    443. 

  443. }
    444. 

  444. 

  445. /**
    446. 

  446. * define the outlines in the doc, empty for now
    447. 

  447. */
    448. 

  448. function o_outlines($id,$action,$options=''){
    449. 

  449.   if ($action!='new'){
    450. 

  450.     $o =& $this->objects[$id];
    451. 

  451.   }
    452. 

  452.   switch ($action){
    453. 

  453.     case 'new':
    454. 

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

  455.       $this->o_catalog($this->catalogId,'outlines',$id);
    456. 

  456.       break;
    457. 

  457.     case 'outline':
    458. 

  458.       $o['info']['outlines'][]=$options;
    459. 

  459.       break;
    460. 

  460.     case 'out':
    461. 

  461.       if (count($o['info']['outlines'])){
    462. 

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

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

  464.           $res.=$v." 0 R ";
    465. 

  465.         }
    466. 

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

  467.       } else {
    468. 

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

  469.       }
    470. 

  470.       return $res;
    471. 

  471.       break;
    472. 

  472.   }
    473. 

  473. }
    474. 

  474. 

  475. /**
    476. 

  476. * an object to hold the font description
    477. 

  477. */
    478. 

  478. function o_font($id,$action,$options=''){
    479. 

  479.   if ($action!='new'){
    480. 

  480.     $o =& $this->objects[$id];
    481. 

  481.   }
    482. 

  482.   switch ($action){
    483. 

  483.     case 'new':
    484. 

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

  485.       $fontNum=$this->numFonts;
    486. 

  486.       $this->objects[$id]['info']['fontNum']=$fontNum;
    487. 

  487.       // deal with the encoding and the differences
    488. 

  488.       if (isset($options['differences'])){
    489. 

  489.         // then we'll need an encoding dictionary
    490. 

  490.         $this->numObj++;
    491. 

  491.         $this->o_fontEncoding($this->numObj,'new',$options);
    492. 

  492.         $this->objects[$id]['info']['encodingDictionary']=$this->numObj;
    493. 

  493.       } else if (isset($options['encoding'])){
    494. 

  494.         // we can specify encoding here
    495. 

  495.         switch($options['encoding']){
    496. 

  496.           case 'WinAnsiEncoding':
    497. 

  497.           case 'MacRomanEncoding':
    498. 

  498.           case 'MacExpertEncoding':
    499. 

  499.             $this->objects[$id]['info']['encoding']=$options['encoding'];
    500. 

  500.             break;
    501. 

  501.           case 'none':
    502. 

  502.             break;
    503. 

  503.           default:
    504. 

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

  505.             break;
    506. 

  506.         }
    507. 

  507.       } else {
    508. 

  508.         $this->objects[$id]['info']['encoding']='WinAnsiEncoding';
    509. 

  509.       }
    510. 

  510.       // also tell the pages node about the new font
    511. 

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

  512.       break;
    513. 

  513.     case 'add':
    514. 

  514.       foreach ($options as $k=>$v){
    515. 

  515.         switch ($k){
    516. 

  516.           case 'BaseFont':
    517. 

  517.             $o['info']['name'] = $v;
    518. 

  518.             break;
    519. 

  519.           case 'FirstChar':
    520. 

  520.           case 'LastChar':
    521. 

  521.           case 'Widths':
    522. 

  522.           case 'FontDescriptor':
    523. 

  523.           case 'SubType':
    524. 

  524.           $this->addMessage('o_font '.$k." : ".$v);
    525. 

  525.             $o['info'][$k] = $v;
    526. 

  526.             break;
    527. 

  527.         }
    528. 

  528.      }
    529. 

  529.       break;
    530. 

  530.     case 'out':
    531. 

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

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

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

  534.       if (isset($o['info']['encodingDictionary'])){
    535. 

  535.         // then place a reference to the dictionary
    536. 

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

  537.       } else if (isset($o['info']['encoding'])){
    538. 

  538.         // use the specified encoding
    539. 

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

  540.       }
    541. 

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

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

  543.       }
    544. 

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

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

  546.       }
    547. 

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

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

  549.       }
    550. 

  550.       if (isset($o['info']['FontDescriptor'])){
    551. 

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

  552.       }
    553. 

  553.       $res.=">>\nendobj";
    554. 

  554.       return $res;
    555. 

  555.       break;
    556. 

  556.   }
    557. 

  557. }
    558. 

  558. 

  559. /**
    560. 

  560. * a font descriptor, needed for including additional fonts
    561. 

  561. */
    562. 

  562. function o_fontDescriptor($id,$action,$options=''){
    563. 

  563.   if ($action!='new'){
    564. 

  564.     $o =& $this->objects[$id];
    565. 

  565.   }
    566. 

  566.   switch ($action){
    567. 

  567.     case 'new':
    568. 

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

  569.       break;
    570. 

  570.     case 'out':
    571. 

  571.       $res="\n".$id." 0 obj\n<< /Type /FontDescriptor\n";
    572. 

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

  573.         switch ($label){
    574. 

  574.           case 'Ascent':
    575. 

  575.           case 'CapHeight':
    576. 

  576.           case 'Descent':
    577. 

  577.           case 'Flags':
    578. 

  578.           case 'ItalicAngle':
    579. 

  579.           case 'StemV':
    580. 

  580.           case 'AvgWidth':
    581. 

  581.           case 'Leading':
    582. 

  582.           case 'MaxWidth':
    583. 

  583.           case 'MissingWidth':
    584. 

  584.           case 'StemH':
    585. 

  585.           case 'XHeight':
    586. 

  586.           case 'CharSet':
    587. 

  587.             if (strlen($value)){
    588. 

  588.               $res.='/'.$label.' '.$value."\n";
    589. 

  589.             }
    590. 

  590.             break;
    591. 

  591.           case 'FontFile':
    592. 

  592.           case 'FontFile2':
    593. 

  593.           case 'FontFile3':
    594. 

  594.             $res.='/'.$label.' '.$value." 0 R\n";
    595. 

  595.             break;
    596. 

  596.           case 'FontBBox':
    597. 

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

  598.             break;
    599. 

  599.           case 'FontName':
    600. 

  600.             $res.='/'.$label.' /'.$value."\n";
    601. 

  601.             break;
    602. 

  602.         }
    603. 

  603.       }
    604. 

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

  605.       return $res;
    606. 

  606.       break;
    607. 

  607.   }
    608. 

  608. }
    609. 

  609. 

  610. /**
    611. 

  611. * the font encoding
    612. 

  612. */
    613. 

  613. function o_fontEncoding($id,$action,$options=''){
    614. 

  614.   if ($action!='new'){
    615. 

  615.     $o =& $this->objects[$id];
    616. 

  616.   }
    617. 

  617.   switch ($action){
    618. 

  618.     case 'new':
    619. 

  619.       // the options array should contain 'differences' and maybe 'encoding'
    620. 

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

  621.       break;
    622. 

  622.     case 'out':
    623. 

  623.       $res="\n".$id." 0 obj\n<< /Type /Encoding\n";
    624. 

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

  625.         $o['info']['encoding']='WinAnsiEncoding';
    626. 

  626.       }
    627. 

  627.       if ($o['info']['encoding']!='none'){
    628. 

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

  629.       }
    630. 

  630.       $res.="/Differences \n[";
    631. 

  631.       $onum=-100;
    632. 

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

  633.         if ($num!=$onum+1){
    634. 

  634.           // we cannot make use of consecutive numbering
    635. 

  635.           $res.= "\n".$num." /".$label;
    636. 

  636.         } else {
    637. 

  637.           $res.= " /".$label;
    638. 

  638.         }
    639. 

  639.         $onum=$num;
    640. 

  640.       }
    641. 

  641.       $res.="\n]\n>>\nendobj";
    642. 

  642.       return $res;
    643. 

  643.       break;
    644. 

  644.   }
    645. 

  645. }
    646. 

  646. 

  647. /**
    648. 

  648. * the document procset, solves some problems with printing to old PS printers
    649. 

  649. */
    650. 

  650. function o_procset($id,$action,$options=''){
    651. 

  651.   if ($action!='new'){
    652. 

  652.     $o =& $this->objects[$id];
    653. 

  653.   }
    654. 

  654.   switch ($action){
    655. 

  655.     case 'new':
    656. 

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

  657.       $this->o_pages($this->currentNode,'procset',$id);
    658. 

  658.       $this->procsetObjectId=$id;
    659. 

  659.       break;
    660. 

  660.     case 'add':
    661. 

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

  662.       // obselete, the items are required for printing to some postscript printers
    663. 

  663.       switch ($options) {
    664. 

  664.         case 'ImageB':
    665. 

  665.         case 'ImageC':
    666. 

  666.         case 'ImageI':
    667. 

  667.           $o['info'][$options]=1;
    668. 

  668.           break;
    669. 

  669.       }
    670. 

  670.       break;
    671. 

  671.     case 'out':
    672. 

  672.       $res="\n".$id." 0 obj\n[";
    673. 

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

  674.         $res.='/'.$label.' ';
    675. 

  675.       }
    676. 

  676.       $res.="]\nendobj";
    677. 

  677.       return $res;
    678. 

  678.       break;
    679. 

  679.   }
    680. 

  680. }
    681. 

  681. 

  682. /**
    683. 

  683. * define the document information
    684. 

  684. */
    685. 

  685. function o_info($id,$action,$options=''){
    686. 

  686.   if ($action!='new'){
    687. 

  687.     $o =& $this->objects[$id];
    688. 

  688.   }
    689. 

  689.   switch ($action){
    690. 

  690.     case 'new':
    691. 

  691.       $this->infoObject=$id;
    692. 

  692.       $date='D:'.date('Ymd');
    693. 

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

  694.       break;
    695. 

  695.     case 'Title':
    696. 

  696.     case 'Author':
    697. 

  697.     case 'Subject':
    698. 

  698.     case 'Keywords':
    699. 

  699.     case 'Creator':
    700. 

  700.     case 'Producer':
    701. 

  701.     case 'CreationDate':
    702. 

  702.     case 'ModDate':
    703. 

  703.     case 'Trapped':
    704. 

  704.       $o['info'][$action]=$options;
    705. 

  705.       break;
    706. 

  706.     case 'out':
    707. 

  707.       if ($this->encrypted){
    708. 

  708.         $this->encryptInit($id);
    709. 

  709.       }
    710. 

  710.       $res="\n".$id." 0 obj\n<<\n";
    711. 

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

  712.         $res.='/'.$k.' (';
    713. 

  713.         if ($this->encrypted){
    714. 

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

  715.         } else {
    716. 

  716.           $res.=$this->filterText($v);
    717. 

  717.         }
    718. 

  718.         $res.=")\n";
    719. 

  719.       }
    720. 

  720.       $res.=">>\nendobj";
    721. 

  721.       return $res;
    722. 

  722.       break;
    723. 

  723.   }
    724. 

  724. }
    725. 

  725. 

  726. /**
    727. 

  727. * an action object, used to link to URLS initially
    728. 

  728. */
    729. 

  729. function o_action($id,$action,$options=''){
    730. 

  730.   if ($action!='new'){
    731. 

  731.     $o =& $this->objects[$id];
    732. 

  732.   }
    733. 

  733.   switch ($action){
    734. 

  734.     case 'new':
    735. 

  735.       if (is_array($options)){
    736. 

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

  737.       } else {
    738. 

  738.         // then assume a URI action
    739. 

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

  740.       }
    741. 

  741.       break;
    742. 

  742.     case 'out':
    743. 

  743.       if ($this->encrypted){
    744. 

  744.         $this->encryptInit($id);
    745. 

  745.       }
    746. 

  746.       $res="\n".$id." 0 obj\n<< /Type /Action";
    747. 

  747.       switch($o['type']){
    748. 

  748.         case 'ilink':
    749. 

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

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

  751.           break;
    752. 

  752.         case 'URI':
    753. 

  753.           $res.="\n/S /URI\n/URI (";
    754. 

  754.           if ($this->encrypted){
    755. 

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

  756.           } else {
    757. 

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

  758.           }
    759. 

  759.           $res.=")";
    760. 

  760.           break;
    761. 

  761.       }
    762. 

  762.       $res.="\n>>\nendobj";
    763. 

  763.       return $res;
    764. 

  764.       break;
    765. 

  765.   }
    766. 

  766. }
    767. 

  767. 

  768. /**
    769. 

  769. * an annotation object, this will add an annotation to the current page.
    770. 

  770. * initially will support just link annotations 
    771. 

  771. */
    772. 

  772. function o_annotation($id,$action,$options=''){
    773. 

  773.   if ($action!='new'){
    774. 

  774.     $o =& $this->objects[$id];
    775. 

  775.   }
    776. 

  776.   switch ($action){
    777. 

  777.     case 'new':
    778. 

  778.       // add the annotation to the current page
    779. 

  779.       $pageId = $this->currentPage;
    780. 

  780.       $this->o_page($pageId,'annot',$id);
    781. 

  781.       // and add the action object which is going to be required
    782. 

  782.       switch($options['type']){
    783. 

  783.         case 'link':
    784. 

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

  785.           $this->numObj++;
    786. 

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

  787.           $this->objects[$id]['info']['actionId']=$this->numObj;
    788. 

  788.           break;
    789. 

  789.         case 'ilink':
    790. 

  790.           // this is to a named internal link
    791. 

  791.           $label = $options['label'];
    792. 

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

  793.           $this->numObj++;
    794. 

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

  795.           $this->objects[$id]['info']['actionId']=$this->numObj;
    796. 

  796.           break;
    797. 

  797.       }
    798. 

  798.       break;
    799. 

  799.     case 'out':
    800. 

  800.       $res="\n".$id." 0 obj\n<< /Type /Annot";
    801. 

  801.       switch($o['info']['type']){
    802. 

  802.         case 'link':
    803. 

  803.         case 'ilink':
    804. 

  804.           $res.= "\n/Subtype /Link";
    805. 

  805.           break;
    806. 

  806.       }
    807. 

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

  808.       $res.="\n/Border [0 0 0]";
    809. 

  809.       $res.="\n/H /I";
    810. 

  810.       $res.="\n/Rect [ ";
    811. 

  811.       foreach($o['info']['rect'] as $v){
    812. 

  812.         $res.= sprintf("%.4f ",$v);
    813. 

  813.       }
    814. 

  814.       $res.="]";
    815. 

  815.       $res.="\n>>\nendobj";
    816. 

  816.       return $res;
    817. 

  817.       break;
    818. 

  818.   }
    819. 

  819. }
    820. 

  820. 

  821. /**
    822. 

  822. * a page object, it also creates a contents object to hold its contents
    823. 

  823. */
    824. 

  824. function o_page($id,$action,$options=''){
    825. 

  825.   if ($action!='new'){
    826. 

  826.     $o =& $this->objects[$id];
    827. 

  827.   }
    828. 

  828.   switch ($action){
    829. 

  829.     case 'new':
    830. 

  830.       $this->numPages++;
    831. 

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

  832.       if (is_array($options)){
    833. 

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

  834.         $options['id']=$id;
    835. 

  835.         $this->o_pages($this->currentNode,'page',$options);
    836. 

  836.       } else {
    837. 

  837.         $this->o_pages($this->currentNode,'page',$id);
    838. 

  838.       }
    839. 

  839.       $this->currentPage=$id;
    840. 

  840.       //make a contents object to go with this page
    841. 

  841.       $this->numObj++;
    842. 

  842.       $this->o_contents($this->numObj,'new',$id);
    843. 

  843.       $this->currentContents=$this->numObj;
    844. 

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

  845.       $this->objects[$id]['info']['contents'][]=$this->numObj;
    846. 

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

  847.       foreach($this->addLooseObjects as $oId=>$target){
    848. 

  848.         if ($target=='all' || $match==$target){
    849. 

  849.           $this->objects[$id]['info']['contents'][]=$oId;
    850. 

  850.         }
    851. 

  851.       }
    852. 

  852.       break;
    853. 

  853.     case 'content':
    854. 

  854.       $o['info']['contents'][]=$options;
    855. 

  855.       break;
    856. 

  856.     case 'annot':
    857. 

  857.       // add an annotation to this page
    858. 

  858.       if (!isset($o['info']['annot'])){
    859. 

  859.         $o['info']['annot']=array();
    860. 

  860.       }
    861. 

  861.       // $options should contain the id of the annotation dictionary
    862. 

  862.       $o['info']['annot'][]=$options;
    863. 

  863.       break;
    864. 

  864.     case 'out':
    865. 

  865.       $res="\n".$id." 0 obj\n<< /Type /Page";
    866. 

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

  867.       if (isset($o['info']['annot'])){
    868. 

  868.         $res.="\n/Annots [";
    869. 

  869.         foreach($o['info']['annot'] as $aId){
    870. 

  870.           $res.=" ".$aId." 0 R";
    871. 

  871.         }
    872. 

  872.         $res.=" ]";
    873. 

  873.       }
    874. 

  874.       $count = count($o['info']['contents']);
    875. 

  875.       if ($count==1){
    876. 

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

  877.       } else if ($count>1){
    878. 

  878.         $res.="\n/Contents [\n";
    879. 

  879.         foreach ($o['info']['contents'] as $cId){
    880. 

  880.           $res.=$cId." 0 R\n";
    881. 

  881.         }
    882. 

  882.         $res.="]";
    883. 

  883.       }
    884. 

  884.       $res.="\n>>\nendobj";
    885. 

  885.       return $res;
    886. 

  886.       break;
    887. 

  887.   }
    888. 

  888. }
    889. 

  889. 

  890. /**
    891. 

  891. * the contents objects hold all of the content which appears on pages
    892. 

  892. */
    893. 

  893. function o_contents($id,$action,$options=''){
    894. 

  894.   if ($action!='new'){
    895. 

  895.     $o =& $this->objects[$id];
    896. 

  896.   }
    897. 

  897.   switch ($action){
    898. 

  898.     case 'new':
    899. 

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

  900.       if (strlen($options) && intval($options)){
    901. 

  901.         // then this contents is the primary for a page
    902. 

  902.         $this->objects[$id]['onPage']=$options;
    903. 

  903.       } else if ($options=='raw'){
    904. 

  904.         // then this page contains some other type of system object
    905. 

  905.         $this->objects[$id]['raw']=1;
    906. 

  906.       }
    907. 

  907.       break;
    908. 

  908.     case 'add':
    909. 

  909.       // add more options to the decleration
    910. 

  910.       foreach ($options as $k=>$v){
    911. 

  911.         $o['info'][$k]=$v;
    912. 

  912.       }
    913. 

  913.     case 'out':
    914. 

  914.       $tmp=$o['c'];
    915. 

  915.       $res= "\n".$id." 0 obj\n";
    916. 

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

  917.         $res.=$tmp;
    918. 

  918.       } else {
    919. 

  919.         $res.= "<<";
    920. 

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

  921.           // then implement ZLIB based compression on this content stream
    922. 

  922.           $res.=" /Filter /FlateDecode";
    923. 

  923.           $tmp = gzcompress($tmp);
    924. 

  924.         }
    925. 

  925.         if ($this->encrypted){
    926. 

  926.           $this->encryptInit($id);
    927. 

  927.           $tmp = $this->ARC4($tmp);
    928. 

  928.         }
    929. 

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

  930.           $res .= "\n/".$k.' '.$v;
    931. 

  931.         }
    932. 

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

  933.       }
    934. 

  934.       $res.="\nendobj\n";
    935. 

  935.       return $res;
    936. 

  936.       break;
    937. 

  937.   }
    938. 

  938. }
    939. 

  939. 

  940. /**
    941. 

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

  942. */
    943. 

  943. function o_image($id,$action,$options=''){
    944. 

  944.   if ($action!='new'){
    945. 

  945.     $o =& $this->objects[$id];
    946. 

  946.   }
    947. 

  947.   switch($action){
    948. 

  948.     case 'new':
    949. 

  949.       // make the new object
    950. 

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

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

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

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

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

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

  956.         if (!isset($options['channels'])){
    957. 

  957.           $options['channels']=3;
    958. 

  958.         }
    959. 

  959.         switch($options['channels']){
    960. 

  960.           case 1:
    961. 

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

  962.             break;
    963. 

  963.           default:
    964. 

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

  965.             break;
    966. 

  966.         }
    967. 

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

  968.         $this->objects[$id]['info']['BitsPerComponent']=8;
    969. 

  969.       } else if ($options['type']=='png'){
    970. 

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

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

  972.         if (strlen($options['pdata'])){
    973. 

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

  974.           $this->numObj++;
    975. 

  975.           $this->o_contents($this->numObj,'new');
    976. 

  976.           $this->objects[$this->numObj]['c']=$options['pdata'];
    977. 

  977.           $tmp.=$this->numObj.' 0 R';
    978. 

  978.           $tmp .=' ]';
    979. 

  979.           $this->objects[$id]['info']['ColorSpace'] = $tmp;
    980. 

  980.           if (isset($options['transparency'])){
    981. 

  981.             switch($options['transparency']['type']){
    982. 

  982.               case 'indexed':
    983. 

  983.                 $tmp=' [ '.$options['transparency']['data'].' '.$options['transparency']['data'].'] ';
    984. 

  984.                 $this->objects[$id]['info']['Mask'] = $tmp;
    985. 

  985.                 break;
    986. 

  986.             }
    987. 

  987.           }
    988. 

  988.         } else {
    989. 

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

  990.         }
    991. 

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

  992.       }
    993. 

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

  994.       // the label passed in with it.
    995. 

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

  996.       // also make sure that we have the right procset object for it.
    997. 

  997.       $this->o_procset($this->procsetObjectId,'add','ImageC');
    998. 

  998.       break;
    999. 

  999.     case 'out':
    1000. 

  1000.       $tmp=$o['data'];
    1001. 

  1001.       $res= "\n".$id." 0 obj\n<<";
    1002. 

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

  1003.         $res.="\n/".$k.' '.$v;
    1004. 

  1004.       }
    1005. 

  1005.       if ($this->encrypted){
    1006. 

  1006.         $this->encryptInit($id);
    1007. 

  1007.         $tmp = $this->ARC4($tmp);
    1008. 

  1008.       }
    1009. 

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

  1010.       return $res;
    1011. 

  1011.       break;
    1012. 

  1012.   }
    1013. 

  1013. }
    1014. 

  1014. 

  1015. /**
    1016. 

  1016. * encryption object.
    1017. 

  1017. */
    1018. 

  1018. function o_encryption($id,$action,$options=''){
    1019. 

  1019.   if ($action!='new'){
    1020. 

  1020.     $o =& $this->objects[$id];
    1021. 

  1021.   }
    1022. 

  1022.   switch($action){
    1023. 

  1023.     case 'new':
    1024. 

  1024.       // make the new object
    1025. 

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

  1026.       $this->arc4_objnum=$id;
    1027. 

  1027.       // figure out the additional paramaters required
    1028. 

  1028.       $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);
    1029. 

  1029.       $len = strlen($options['owner']);
    1030. 

  1030.       if ($len>32){
    1031. 

  1031.         $owner = substr($options['owner'],0,32);
    1032. 

  1032.       } else if ($len<32){
    1033. 

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

  1034.       } else {
    1035. 

  1035.         $owner = $options['owner'];
    1036. 

  1036.       }
    1037. 

  1037.       $len = strlen($options['user']);
    1038. 

  1038.       if ($len>32){
    1039. 

  1039.         $user = substr($options['user'],0,32);
    1040. 

  1040.       } else if ($len<32){
    1041. 

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

  1042.       } else {
    1043. 

  1043.         $user = $options['user'];
    1044. 

  1044.       }
    1045. 

  1045.       $tmp = $this->md5_16($owner);
    1046. 

  1046.       $okey = substr($tmp,0,5);
    1047. 

  1047.       $this->ARC4_init($okey);
    1048. 

  1048.       $ovalue=$this->ARC4($user);
    1049. 

  1049.       $this->objects[$id]['info']['O']=$ovalue;
    1050. 

  1050.       // now make the u value, phew.
    1051. 

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

  1052.       $ukey = substr($tmp,0,5);
    1053. 

  1053. 

  1054.       $this->ARC4_init($ukey);
    1055. 

  1055.       $this->encryptionKey = $ukey;
    1056. 

  1056.       $this->encrypted=1;
    1057. 

  1057.       $uvalue=$this->ARC4($pad);
    1058. 

  1058. 

  1059.       $this->objects[$id]['info']['U']=$uvalue;
    1060. 

  1060.       $this->encryptionKey=$ukey;
    1061. 

  1061.      
    1062. 

  1062.       // initialize the arc4 array
    1063. 

  1063.       break;
    1064. 

  1064.     case 'out':
    1065. 

  1065.       $res= "\n".$id." 0 obj\n<<";
    1066. 

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

  1067.       $res.="\n/V 1";
    1068. 

  1068.       $res.="\n/R 2";
    1069. 

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

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

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

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

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

  1074.       $res.="\n>>\nendobj\n";
    1075. 

  1075.       
    1076. 

  1076.       return $res;
    1077. 

  1077.       break;
    1078. 

  1078.   }
    1079. 

  1079. }
    1080. 

  1080.       
    1081. 

  1081. /**
    1082. 

  1082. * ARC4 functions
    1083. 

  1083. * A series of function to implement ARC4 encoding in PHP
    1084. 

  1084. */
    1085. 

  1085. 

  1086. /**
    1087. 

  1087. * calculate the 16 byte version of the 128 bit md5 digest of the string
    1088. 

  1088. */
    1089. 

  1089. function md5_16($string){
    1090. 

  1090.   $tmp = md5($string);
    1091. 

  1091.   $out='';
    1092. 

  1092.   for ($i=0;$i<=30;$i=$i+2){
    1093. 

  1093.     $out.=chr(hexdec(substr($tmp,$i,2)));
    1094. 

  1094.   }
    1095. 

  1095.   return $out;
    1096. 

  1096. }
    1097. 

  1097. 

  1098. /**
    1099. 

  1099. * initialize the encryption for processing a particular object 
    1100. 

  1100. */
    1101. 

  1101. function encryptInit($id){
    1102. 

  1102.   $tmp = $this->encryptionKey;
    1103. 

  1103.   $hex = dechex($id);
    1104. 

  1104.   if (strlen($hex)<6){
    1105. 

  1105.     $hex = substr('000000',0,6-strlen($hex)).$hex;
    1106. 

  1106.   }
    1107. 

  1107.   $tmp.= chr(hexdec(substr($hex,4,2))).chr(hexdec(substr($hex,2,2))).chr(hexdec(substr($hex,0,2))).chr(0).chr(0);
    1108. 

  1108.   $key = $this->md5_16($tmp);
    1109. 

  1109.   $this->ARC4_init(substr($key,0,10));
    1110. 

  1110. }
    1111. 

  1111. 

  1112. /**
    1113. 

  1113. * initialize the ARC4 encryption
    1114. 

  1114. */
    1115. 

  1115. function ARC4_init($key=''){
    1116. 

  1116.   $this->arc4 = '';
    1117. 

  1117.   // setup the control array
    1118. 

  1118.   if (strlen($key)==0){
    1119. 

  1119.     return;
    1120. 

  1120.   }
    1121. 

  1121.   $k = '';
    1122. 

  1122.   while(strlen($k)<256){
    1123. 

  1123.     $k.=$key;
    1124. 

  1124.   }
    1125. 

  1125.   $k=substr($k,0,256);
    1126. 

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

  1127.     $this->arc4 .= chr($i);
    1128. 

  1128.   }
    1129. 

  1129.   $j=0;
    1130. 

  1130.   for ($i=0;$i<256;$i++){
    1131. 

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

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

  1133.     $this->arc4[$i]=$this->arc4[$j];
    1134. 

  1134.     $this->arc4[$j]=$t;
    1135. 

  1135.   }    
    1136. 

  1136. }
    1137. 

  1137. 

  1138. /**
    1139. 

  1139. * ARC4 encrypt a text string
    1140. 

  1140. */
    1141. 

  1141. function ARC4($text){
    1142. 

  1142.   $len=strlen($text);
    1143. 

  1143.   $a=0;
    1144. 

  1144.   $b=0;
    1145. 

  1145.   $c = $this->arc4;
    1146. 

  1146.   $out='';
    1147. 

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

  1148.     $a = ($a+1)%256;
    1149. 

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

  1150.     $b = ($b+ord($t))%256;
    1151. 

  1151.     $c[$a]=$c[$b];
    1152. 

  1152.     $c[$b]=$t;
    1153. 

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

  1154.     $out.=chr(ord($text[$i]) ^ $k);
    1155. 

  1155.   }
    1156. 

  1156.   
    1157. 

  1157.   return $out;
    1158. 

  1158. }
    1159. 

  1159. 

  1160. /**
    1161. 

  1161. * functions which can be called to adjust or add to the document
    1162. 

  1162. */
    1163. 

  1163. 

  1164. /**
    1165. 

  1165. * add a link in the document to an external URL
    1166. 

  1166. */
    1167. 

  1167. function addLink($url,$x0,$y0,$x1,$y1){
    1168. 

  1168.   $this->numObj++;
    1169. 

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

  1170.   $this->o_annotation($this->numObj,'new',$info);
    1171. 

  1171. }
    1172. 

  1172. 

  1173. /**
    1174. 

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

  1175. */
    1176. 

  1176. function addInternalLink($label,$x0,$y0,$x1,$y1){
    1177. 

  1177.   $this->numObj++;
    1178. 

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

  1179.   $this->o_annotation($this->numObj,'new',$info);
    1180. 

  1180. }
    1181. 

  1181. 

  1182. /**
    1183. 

  1183. * set the encryption of the document
    1184. 

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

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

  1186. */
    1187. 

  1187. function setEncryption($userPass='',$ownerPass='',$pc=array()){
    1188. 

  1188.   $p=bindec(11000000);
    1189. 

  1189. 

  1190.   $options = array(
    1191. 

  1191.      'print'=>4
    1192. 

  1192.     ,'modify'=>8
    1193. 

  1193.     ,'copy'=>16
    1194. 

  1194.     ,'add'=>32
    1195. 

  1195.   );
    1196. 

  1196.   foreach($pc as $k=>$v){
    1197. 

  1197.     if ($v && isset($options[$k])){
    1198. 

  1198.       $p+=$options[$k];
    1199. 

  1199.     } else if (isset($options[$v])){
    1200. 

  1200.       $p+=$options[$v];
    1201. 

  1201.     }
    1202. 

  1202.   }
    1203. 

  1203.   // implement encryption on the document
    1204. 

  1204.   if ($this->arc4_objnum == 0){
    1205. 

  1205.     // then the block does not exist already, add it.
    1206. 

  1206.     $this->numObj++;
    1207. 

  1207.     if (strlen($ownerPass)==0){
    1208. 

  1208.       $ownerPass=$userPass;
    1209. 

  1209.     }
    1210. 

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

  1211.   }
    1212. 

  1212. }
    1213. 

  1213. 

  1214. /**
    1215. 

  1215. * should be used for internal checks, not implemented as yet
    1216. 

  1216. */
    1217. 

  1217. function checkAllHere(){
    1218. 

  1218. }
    1219. 

  1219. 

  1220. /**
    1221. 

  1221. * return the pdf stream as a string returned from the function
    1222. 

  1222. */
    1223. 

  1223. function output($debug=0){
    1224. 

  1224. 

  1225.   if ($debug){
    1226. 

  1226.     // turn compression off
    1227. 

  1227.     $this->options['compression']=0;
    1228. 

  1228.   }
    1229. 

  1229. 

  1230.   if ($this->arc4_objnum){
    1231. 

  1231.     $this->ARC4_init($this->encryptionKey);
    1232. 

  1232.   }
    1233. 

  1233. 

  1234.   $this->checkAllHere();
    1235. 

  1235. 

  1236.   $xref=array();
    1237. 

  1237.   $content="%PDF-1.3\n%â??Ó\n";
    1238. 

  1238. //  $content="%PDF-1.3\n";
    1239. 

  1239.   $pos=strlen($content);
    1240. 

  1240.   foreach($this->objects as $k=>$v){
    1241. 

  1241.     $tmp='o_'.$v['t'];
    1242. 

  1242.     $cont=$this->$tmp($k,'out');
    1243. 

  1243.     $content.=$cont;
    1244. 

  1244.     $xref[]=$pos;
    1245. 

  1245.     $pos+=strlen($cont);
    1246. 

  1246.   }
    1247. 

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

  1248.   foreach($xref as $p){
    1249. 

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

  1250.   }
    1251. 

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

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

  1253.   if ($this->arc4_objnum > 0){
    1254. 

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

  1255.   }
    1256. 

  1256.   if (strlen($this->fileIdentifier)){
    1257. 

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

  1258.   }
    1259. 

  1259.   $content .= "  >>\nstartxref\n".$pos."\n%%EOF\n";
    1260. 

  1260.   return $content;
    1261. 

  1261. }
    1262. 

  1262. 

  1263. /**
    1264. 

  1264. * intialize a new document
    1265. 

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

  1266. * this function is called automatically by the constructor function
    1267. 

  1267. *
    1268. 

  1268. * @access private
    1269. 

  1269. */
    1270. 

  1270. function newDocument($pageSize=array(0,0,612,792)){
    1271. 

  1271.   $this->numObj=0;
    1272. 

  1272.   $this->objects = array();
    1273. 

  1273. 

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

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

  1276. 

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

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

  1279. 

  1280.   $this->numObj++;
    1281. 

  1281.   $this->o_pages($this->numObj,'new');
    1282. 

  1282. 

  1283.   $this->o_pages($this->numObj,'mediaBox',$pageSize);
    1284. 

  1284.   $this->currentNode = 3;
    1285. 

  1285. 

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

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

  1288. 

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

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

  1291. 

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

  1293.   $this->o_page($this->numObj,'new');
    1294. 

  1294. 

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

  1296.   // startup
    1297. 

  1297.   $this->firstPageId = $this->currentContents;
    1298. 

  1298. }
    1299. 

  1299. 

  1300. /**
    1301. 

  1301. * open the font file and return a php structure containing it.
    1302. 

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

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

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

  1305. * files.
    1306. 

  1306. *
    1307. 

  1307. * @access private
    1308. 

  1308. */
    1309. 

  1309. function openFont($font){
    1310. 

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

  1311.   $pos=strrpos($font,'/');
    1312. 

  1312.   if ($pos===false){
    1313. 

  1313.     $dir = './';
    1314. 

  1314.     $name = $font;
    1315. 

  1315.   } else {
    1316. 

  1316.     $dir=substr($font,0,$pos+1);
    1317. 

  1317.     $name=substr($font,$pos+1);
    1318. 

  1318.   }
    1319. 

  1319. 

  1320.   if (substr($name,-4)=='.afm'){
    1321. 

  1321.     $name=substr($name,0,strlen($name)-4);
    1322. 

  1322.   }
    1323. 

  1323.   $this->addMessage('openFont: '.$font.' - '.$name);
    1324. 

  1324.   if (file_exists($dir.'php_'.$name.'.afm')){
    1325. 

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

  1326.     $tmp = file($dir.'php_'.$name.'.afm');
    1327. 

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

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

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

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

  1331.       unset($this->fonts[$font]);
    1332. 

  1332.     }
    1333. 

  1333.   }
    1334. 

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

  1335.     // then rebuild the php_<font>.afm file from the <font>.afm file
    1336. 

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

  1337.     $data = array();
    1338. 

  1338.     $file = file($dir.$name.'.afm');
    1339. 

  1339.     foreach ($file as $rowA){
    1340. 

  1340.       $row=trim($rowA);
    1341. 

  1341.       $pos=strpos($row,' ');
    1342. 

  1342.       if ($pos){
    1343. 

  1343.         // then there must be some keyword
    1344. 

  1344.         $key = substr($row,0,$pos);
    1345. 

  1345.         switch ($key){
    1346. 

  1346.           case 'FontName':
    1347. 

  1347.           case 'FullName':
    1348. 

  1348.           case 'FamilyName':
    1349. 

  1349.           case 'Weight':
    1350. 

  1350.           case 'ItalicAngle':
    1351. 

  1351.           case 'IsFixedPitch':
    1352. 

  1352.           case 'CharacterSet':
    1353. 

  1353.           case 'UnderlinePosition':
    1354. 

  1354.           case 'UnderlineThickness':
    1355. 

  1355.           case 'Version':
    1356. 

  1356.           case 'EncodingScheme':
    1357. 

  1357.           case 'CapHeight':
    1358. 

  1358.           case 'XHeight':
    1359. 

  1359.           case 'Ascender':
    1360. 

  1360.           case 'Descender':
    1361. 

  1361.           case 'StdHW':
    1362. 

  1362.           case 'StdVW':
    1363. 

  1363.           case 'StartCharMetrics':
    1364. 

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

  1365.             break;
    1366. 

  1366.           case 'FontBBox':
    1367. 

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

  1368.             break;
    1369. 

  1369.           case 'C':
    1370. 

  1370.             //C 39 ; WX 222 ; N quoteright ; B 53 463 157 718 ;
    1371. 

  1371.             $bits=explode(';',trim($row));
    1372. 

  1372.             $dtmp=array();
    1373. 

  1373.             foreach($bits as $bit){
    1374. 

  1374.               $bits2 = explode(' ',trim($bit));
    1375. 

  1375.               if (strlen($bits2[0])){
    1376. 

  1376.                 if (count($bits2)>2){
    1377. 

  1377.                   $dtmp[$bits2[0]]=array();
    1378. 

  1378.                   for ($i=1;$i<count($bits2);$i++){
    1379. 

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

  1380.                   }
    1381. 

  1381.                 } else if (count($bits2)==2){
    1382. 

  1382.                   $dtmp[$bits2[0]]=$bits2[1];
    1383. 

  1383.                 }
    1384. 

  1384.               }
    1385. 

  1385.             }
    1386. 

  1386.             if ($dtmp['C']>=0){
    1387. 

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

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

  1389.             } else {
    1390. 

  1390.               $data['C'][$dtmp['N']]=$dtmp;
    1391. 

  1391.             }
    1392. 

  1392.             break;
    1393. 

  1393.           case 'KPX':
    1394. 

  1394.             //KPX Adieresis yacute -40
    1395. 

  1395.             $bits=explode(' ',trim($row));
    1396. 

  1396.             $data['KPX'][$bits[1]][$bits[2]]=$bits[3];
    1397. 

  1397.             break;
    1398. 

  1398.         }
    1399. 

  1399.       }
    1400. 

  1400.     }
    1401. 

  1401.     $data['_version_']=1;
    1402. 

  1402.     $this->fonts[$font]=$data;
    1403. 

  1403.     $fp = fopen($dir.'php_'.$name.'.afm','w');
    1404. 

  1404.     fwrite($fp,serialize($data));
    1405. 

  1405.     fclose($fp);
    1406. 

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

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

  1408. //    echo 'Font not Found '.$font;
    1409. 

  1409.   }
    1410. 

  1410. }
    1411. 

  1411. 

  1412. /**
    1413. 

  1413. * if the font is not loaded then load it and make the required object
    1414. 

  1414. * else just make it the current font
    1415. 

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

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

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

  1418. *
    1419. 

  1419. */
    1420. 

  1420. function selectFont($fontName,$encoding='',$set=1){
    1421. 

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

  1422.     // load the file
    1423. 

  1423.     $this->openFont($fontName);
    1424. 

  1424.     if (isset($this->fonts[$fontName])){
    1425. 

  1425.       $this->numObj++;
    1426. 

  1426.       $this->numFonts++;
    1427. 

  1427.       $pos=strrpos($fontName,'/');
    1428. 

  1428. //      $dir=substr($fontName,0,$pos+1);
    1429. 

  1429.       $name=substr($fontName,$pos+1);
    1430. 

  1430.       if (substr($name,-4)=='.afm'){
    1431. 

  1431.         $name=substr($name,0,strlen($name)-4);
    1432. 

  1432.       }
    1433. 

  1433.       $options=array('name'=>$name);
    1434. 

  1434.       if (is_array($encoding)){
    1435. 

  1435.         // then encoding and differences might be set
    1436. 

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

  1437.           $options['encoding']=$encoding['encoding'];
    1438. 

  1438.         }
    1439. 

  1439.         if (isset($encoding['differences'])){
    1440. 

  1440.           $options['differences']=$encoding['differences'];
    1441. 

  1441.         }
    1442. 

  1442.       } else if (strlen($encoding)){
    1443. 

  1443.         // then perhaps only the encoding has been set
    1444. 

  1444.         $options['encoding']=$encoding;
    1445. 

  1445.       }
    1446. 

  1446.       $fontObj = $this->numObj;
    1447. 

  1447.       $this->o_font($this->numObj,'new',$options);
    1448. 

  1448.       $this->fonts[$fontName]['fontNum']=$this->numFonts;
    1449. 

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

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

  1451.       // references into the font object
    1452. 

  1452.       $basefile = substr($fontName,0,strlen($fontName)-4);
    1453. 

  1453.       if (file_exists($basefile.'.pfb')){
    1454. 

  1454.         $fbtype = 'pfb';
    1455. 

  1455.       } else if (file_exists($basefile.'.ttf')){
    1456. 

  1456.         $fbtype = 'ttf';
    1457. 

  1457.       } else {
    1458. 

  1458.         $fbtype='';
    1459. 

  1459.       }
    1460. 

  1460.       $fbfile = $basefile.'.'.$fbtype;
    1461. 

  1461.       
    1462. 

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

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

  1464.       $this->addMessage('selectFont: checking for - '.$fbfile);
    1465. 

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

  1466.         $adobeFontName = $this->fonts[$fontName]['FontName'];
    1467. 

  1467. //        $fontObj = $this->numObj;
    1468. 

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

  1469.         // find the array of fond widths, and put that into an object.
    1470. 

  1470.         $firstChar = -1;
    1471. 

  1471.         $lastChar = 0;
    1472. 

  1472.         $widths = array();
    1473. 

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

  1474.           if (intval($num)>0 || $num=='0'){
    1475. 

  1475.             if ($lastChar>0 && $num>$lastChar+1){
    1476. 

  1476.               for($i=$lastChar+1;$i<$num;$i++){
    1477. 

  1477.                 $widths[] = 0;
    1478. 

  1478.               }
    1479. 

  1479.             }
    1480. 

  1480.             $widths[] = $d['WX'];
    1481. 

  1481.             if ($firstChar==-1){
    1482. 

  1482.               $firstChar = $num;
    1483. 

  1483.             }
    1484. 

  1484.             $lastChar = $num;
    1485. 

  1485.           }
    1486. 

  1486.         }
    1487. 

  1487.         // also need to adjust the widths for the differences array
    1488. 

  1488.         if (isset($options['differences'])){
    1489. 

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

  1490.             if ($charNum>$lastChar){
    1491. 

  1491.               for($i=$lastChar+1;$i<=$charNum;$i++){
    1492. 

  1492.                 $widths[]=0;
    1493. 

  1493.               }
    1494. 

  1494.               $lastChar=$charNum;
    1495. 

  1495.             }
    1496. 

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

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

  1498.             }
    1499. 

  1499.           }
    1500. 

  1500.         }
    1501. 

  1501.         $this->addMessage('selectFont: FirstChar='.$firstChar);
    1502. 

  1502.         $this->addMessage('selectFont: LastChar='.$lastChar);
    1503. 

  1503.         $this->numObj++;
    1504. 

  1504.         $this->o_contents($this->numObj,'new','raw');
    1505. 

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

  1506.         foreach($widths as $width){
    1507. 

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

  1508.         }
    1509. 

  1509.         $this->objects[$this->numObj]['c'].=' ]';
    1510. 

  1510.         $widthid = $this->numObj;
    1511. 

  1511. 

  1512.         // load the pfb file, and put that into an object too.
    1513. 

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

  1514.         // simple utility to convert them from pfa to pfb.
    1515. 

  1515.         $fp = fopen($fbfile,'rb');
    1516. 

  1516.         $tmp = get_magic_quotes_runtime();
    1517. 

  1517.         set_magic_quotes_runtime(0);
    1518. 

  1518.         $data = fread($fp,filesize($fbfile));
    1519. 

  1519.         set_magic_quotes_runtime($tmp);
    1520. 

  1520.         fclose($fp);
    1521. 

  1521. 

  1522.         // create the font descriptor
    1523. 

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

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

  1525.         $this->numObj++;
    1526. 

  1526.         $pfbid = $this->numObj;
    1527. 

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

  1528.         $flags=0;
    1529. 

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

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

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

  1532. 

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

  1534.         $fdopt = array(
    1535. 

  1535.          'Flags'=>$flags
    1536. 

  1536.          ,'FontName'=>$adobeFontName
    1537. 

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

  1538.         );
    1539. 

  1539.         foreach($list as $k=>$v){
    1540. 

  1540.           if (isset($this->fonts[$fontName][$v])){
    1541. 

  1541.             $fdopt[$k]=$this->fonts[$fontName][$v];
    1542. 

  1542.           }
    1543. 

  1543.         }
    1544. 

  1544. 

  1545.         if ($fbtype=='pfb'){
    1546. 

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

  1547.         } else if ($fbtype=='ttf'){
    1548. 

  1548.           $fdopt['FontFile2']=$pfbid;
    1549. 

  1549.         }
    1550. 

  1550.         $this->o_fontDescriptor($fontDescriptorId,'new',$fdopt);        
    1551. 

  1551. 

  1552.         // embed the font program
    1553. 

  1553.         $this->o_contents($this->numObj,'new');
    1554. 

  1554.         $this->objects[$pfbid]['c'].=$data;
    1555. 

  1555.         // determine the cruicial lengths within this file
    1556. 

  1556.         if ($fbtype=='pfb'){
    1557. 

  1557.           $l1 = strpos($data,'eexec')+6;
    1558. 

  1558.           $l2 = strpos($data,'00000000')-$l1;
    1559. 

  1559.           $l3 = strlen($data)-$l2-$l1;
    1560. 

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

  1561.         } else if ($fbtype=='ttf'){
    1562. 

  1562.           $l1 = strlen($data);
    1563. 

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

  1564.         }
    1565. 

  1565. 

  1566. 

  1567.         // tell the font object about all this new stuff
    1568. 

  1568.         $tmp = array('BaseFont'=>$adobeFontName,'Widths'=>$widthid
    1569. 

  1569.                                       ,'FirstChar'=>$firstChar,'LastChar'=>$lastChar
    1570. 

  1570.                                       ,'FontDescriptor'=>$fontDescriptorId);
    1571. 

  1571.         if ($fbtype=='ttf'){
    1572. 

  1572.           $tmp['SubType']='TrueType';
    1573. 

  1573.         }
    1574. 

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

  1575.         foreach($tmp as $fk=>$fv){
    1576. 

  1576.           $this->addMessage($fk." : ".$fv);
    1577. 

  1577.         }
    1578. 

  1578.         $this->o_font($fontObj,'add',$tmp);
    1579. 

  1579. 

  1580.       } else {
    1581. 

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

  1582.       }
    1583. 

  1583. 

  1584. 

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

  1586.       //first time that a font is selected, else they are ignored
    1587. 

  1587.       if (isset($options['differences'])){
    1588. 

  1588.         $this->fonts[$fontName]['differences']=$options['differences'];
    1589. 

  1589.       }
    1590. 

  1590.     }
    1591. 

  1591.   }
    1592. 

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

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

  1594.     $this->currentBaseFont=$fontName;
    1595. 

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

  1596.     // applied to it as well.
    1597. 

  1597.     $this->setCurrentFont();
    1598. 

  1598.   }
    1599. 

  1599.   return $this->currentFontNum;
    1600. 

  1600. }
    1601. 

  1601. 

  1602. /**
    1603. 

  1603. * sets up the current font, based on the font families, and the current text state
    1604. 

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

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

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

  1607. * the currentFont setting to whatever the appropriatte family one is.
    1608. 

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

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

  1610. * currentBaseFont.
    1611. 

  1611. *
    1612. 

  1612. * @access private
    1613. 

  1613. */
    1614. 

  1614. function setCurrentFont(){
    1615. 

  1615.   if (strlen($this->currentBaseFont)==0){
    1616. 

  1616.     // then assume an initial font
    1617. 

  1617.     $this->selectFont('./fonts/Helvetica.afm');
    1618. 

  1618.   }
    1619. 

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

  1620.   if (strlen($this->currentTextState)
    1621. 

  1621.     && isset($this->fontFamilies[$cf]) 
    1622. 

  1622.       && isset($this->fontFamilies[$cf][$this->currentTextState])){
    1623. 

  1623.     // then we are in some state or another
    1624. 

  1624.     // and this font has a family, and the current setting exists within it
    1625. 

  1625.     // select the font, then return it
    1626. 

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

  1627.     $this->selectFont($nf,'',0);
    1628. 

  1628.     $this->currentFont = $nf;
    1629. 

  1629.     $this->currentFontNum = $this->fonts[$nf]['fontNum'];
    1630. 

  1630.   } else {
    1631. 

  1631.     // the this font must not have the right family member for the current state
    1632. 

  1632.     // simply assume the base font
    1633. 

  1633.     $this->currentFont = $this->currentBaseFont;
    1634. 

  1634.     $this->currentFontNum = $this->fonts[$this->currentFont]['fontNum'];    
    1635. 

  1635.   }
    1636. 

  1636. }
    1637. 

  1637. 

  1638. /**
    1639. 

  1639. * function for the user to find out what the ID is of the first page that was created during
    1640. 

  1640. * startup - useful if they wish to add something to it later.
    1641. 

  1641. */
    1642. 

  1642. function getFirstPageId(){
    1643. 

  1643.   return $this->firstPageId;
    1644. 

  1644. }
    1645. 

  1645. 

  1646. /**
    1647. 

  1647. * add content to the currently active object
    1648. 

  1648. *
    1649. 

  1649. * @access private
    1650. 

  1650. */
    1651. 

  1651. function addContent($content){
    1652. 

  1652.   $this->objects[$this->currentContents]['c'].=$content;
    1653. 

  1653. }
    1654. 

  1654. 

  1655. /**
    1656. 

  1656. * sets the colour for fill operations
    1657. 

  1657. */
    1658. 

  1658. function setColor($r,$g,$b,$force=0){
    1659. 

  1659.   if ($r>=0 && ($force || $r!=$this->currentColour['r'] || $g!=$this->currentColour['g'] || $b!=$this->currentColour['b'])){
    1660. 

  1660.     $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$r).' '.sprintf('%.3f',$g).' '.sprintf('%.3f',$b).' rg';
    1661. 

  1661.     $this->currentColour=array('r'=>$r,'g'=>$g,'b'=>$b);
    1662. 

  1662.   }
    1663. 

  1663. }
    1664. 

  1664. 

  1665. /**
    1666. 

  1666. * sets the colour for stroke operations
    1667. 

  1667. */
    1668. 

  1668. function setStrokeColor($r,$g,$b,$force=0){
    1669. 

  1669.   if ($r>=0 && ($force || $r!=$this->currentStrokeColour['r'] || $g!=$this->currentStrokeColour['g'] || $b!=$this->currentStrokeColour['b'])){
    1670. 

  1670.     $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$r).' '.sprintf('%.3f',$g).' '.sprintf('%.3f',$b).' RG';
    1671. 

  1671.     $this->currentStrokeColour=array('r'=>$r,'g'=>$g,'b'=>$b);
    1672. 

  1672.   }
    1673. 

  1673. }
    1674. 

  1674. 

  1675. /**
    1676. 

  1676. * draw a line from one set of coordinates to another
    1677. 

  1677. */
    1678. 

  1678. function line($x1,$y1,$x2,$y2){
    1679. 

  1679.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$x1).' '.sprintf('%.3f',$y1).' m '.sprintf('%.3f',$x2).' '.sprintf('%.3f',$y2).' l S';
    1680. 

  1680. }
    1681. 

  1681. 

  1682. /**
    1683. 

  1683. * draw a bezier curve based on 4 control points
    1684. 

  1684. */
    1685. 

  1685. function curve($x0,$y0,$x1,$y1,$x2,$y2,$x3,$y3){
    1686. 

  1686.   // in the current line style, draw a bezier curve from (x0,y0) to (x3,y3) using the other two points
    1687. 

  1687.   // as the control points for the curve.
    1688. 

  1688.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$x0).' '.sprintf('%.3f',$y0).' m '.sprintf('%.3f',$x1).' '.sprintf('%.3f',$y1);
    1689. 

  1689.   $this->objects[$this->currentContents]['c'].= ' '.sprintf('%.3f',$x2).' '.sprintf('%.3f',$y2).' '.sprintf('%.3f',$x3).' '.sprintf('%.3f',$y3).' c S';
    1690. 

  1690. }
    1691. 

  1691. 

  1692. /**
    1693. 

  1693. * draw a part of an ellipse
    1694. 

  1694. */
    1695. 

  1695. function partEllipse($x0,$y0,$astart,$afinish,$r1,$r2=0,$angle=0,$nSeg=8){
    1696. 

  1696.   $this->ellipse($x0,$y0,$r1,$r2,$angle,$nSeg,$astart,$afinish,0);
    1697. 

  1697. }
    1698. 

  1698. 

  1699. /**
    1700. 

  1700. * draw a filled ellipse
    1701. 

  1701. */
    1702. 

  1702. function filledEllipse($x0,$y0,$r1,$r2=0,$angle=0,$nSeg=8,$astart=0,$afinish=360){
    1703. 

  1703.   return $this->ellipse($x0,$y0,$r1,$r2=0,$angle,$nSeg,$astart,$afinish,1,1);
    1704. 

  1704. }
    1705. 

  1705. 

  1706. /**
    1707. 

  1707. * draw an ellipse
    1708. 

  1708. * note that the part and filled ellipse are just special cases of this function
    1709. 

  1709. *
    1710. 

  1710. * draws an ellipse in the current line style
    1711. 

  1711. * centered at $x0,$y0, radii $r1,$r2
    1712. 

  1712. * if $r2 is not set, then a circle is drawn
    1713. 

  1713. * nSeg is not allowed to be less than 2, as this will simply draw a line (and will even draw a 
    1714. 

  1714. * pretty crappy shape at 2, as we are approximating with bezier curves.
    1715. 

  1715. */
    1716. 

  1716. function ellipse($x0,$y0,$r1,$r2=0,$angle=0,$nSeg=8,$astart=0,$afinish=360,$close=1,$fill=0){
    1717. 

  1717.   if ($r1==0){
    1718. 

  1718.     return;
    1719. 

  1719.   }
    1720. 

  1720.   if ($r2==0){
    1721. 

  1721.     $r2=$r1;
    1722. 

  1722.   }
    1723. 

  1723.   if ($nSeg<2){
    1724. 

  1724.     $nSeg=2;
    1725. 

  1725.   }
    1726. 

  1726. 

  1727.   $astart = deg2rad((float)$astart);
    1728. 

  1728.   $afinish = deg2rad((float)$afinish);
    1729. 

  1729.   $totalAngle =$afinish-$astart;
    1730. 

  1730. 

  1731.   $dt = $totalAngle/$nSeg;
    1732. 

  1732.   $dtm = $dt/3;
    1733. 

  1733. 

  1734.   if ($angle != 0){
    1735. 

  1735.     $a = -1*deg2rad((float)$angle);
    1736. 

  1736.     $tmp = "\n q ";
    1737. 

  1737.     $tmp .= sprintf('%.3f',cos($a)).' '.sprintf('%.3f',(-1.0*sin($a))).' '.sprintf('%.3f',sin($a)).' '.sprintf('%.3f',cos($a)).' ';
    1738. 

  1738.     $tmp .= sprintf('%.3f',$x0).' '.sprintf('%.3f',$y0).' cm';
    1739. 

  1739.     $this->objects[$this->currentContents]['c'].= $tmp;
    1740. 

  1740.     $x0=0;
    1741. 

  1741.     $y0=0;
    1742. 

  1742.   }
    1743. 

  1743. 

  1744.   $t1 = $astart;
    1745. 

  1745.   $a0 = $x0+$r1*cos($t1);
    1746. 

  1746.   $b0 = $y0+$r2*sin($t1);
    1747. 

  1747.   $c0 = -$r1*sin($t1);
    1748. 

  1748.   $d0 = $r2*cos($t1);
    1749. 

  1749. 

  1750.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$a0).' '.sprintf('%.3f',$b0).' m ';
    1751. 

  1751.   for ($i=1;$i<=$nSeg;$i++){
    1752. 

  1752.     // draw this bit of the total curve
    1753. 

  1753.     $t1 = $i*$dt+$astart;
    1754. 

  1754.     $a1 = $x0+$r1*cos($t1);
    1755. 

  1755.     $b1 = $y0+$r2*sin($t1);
    1756. 

  1756.     $c1 = -$r1*sin($t1);
    1757. 

  1757.     $d1 = $r2*cos($t1);
    1758. 

  1758.     $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',($a0+$c0*$dtm)).' '.sprintf('%.3f',($b0+$d0*$dtm));
    1759. 

  1759.     $this->objects[$this->currentContents]['c'].= ' '.sprintf('%.3f',($a1-$c1*$dtm)).' '.sprintf('%.3f',($b1-$d1*$dtm)).' '.sprintf('%.3f',$a1).' '.sprintf('%.3f',$b1).' c';
    1760. 

  1760.     $a0=$a1;
    1761. 

  1761.     $b0=$b1;
    1762. 

  1762.     $c0=$c1;
    1763. 

  1763.     $d0=$d1;    
    1764. 

  1764.   }
    1765. 

  1765.   if ($fill){
    1766. 

  1766.     $this->objects[$this->currentContents]['c'].=' f';
    1767. 

  1767.   } else {
    1768. 

  1768.     if ($close){
    1769. 

  1769.       $this->objects[$this->currentContents]['c'].=' s'; // small 's' signifies closing the path as well
    1770. 

  1770.     } else {
    1771. 

  1771.       $this->objects[$this->currentContents]['c'].=' S';
    1772. 

  1772.     }
    1773. 

  1773.   }
    1774. 

  1774.   if ($angle !=0){
    1775. 

  1775.     $this->objects[$this->currentContents]['c'].=' Q';
    1776. 

  1776.   }
    1777. 

  1777. }
    1778. 

  1778. 

  1779. /**
    1780. 

  1780. * this sets the line drawing style.
    1781. 

  1781. * width, is the thickness of the line in user units
    1782. 

  1782. * cap is the type of cap to put on the line, values can be 'butt','round','square'
    1783. 

  1783. *    where the diffference between 'square' and 'butt' is that 'square' projects a flat end past the
    1784. 

  1784. *    end of the line.
    1785. 

  1785. * join can be 'miter', 'round', 'bevel'
    1786. 

  1786. * dash is an array which sets the dash pattern, is a series of length values, which are the lengths of the
    1787. 

  1787. *   on and off dashes.
    1788. 

  1788. *   (2) represents 2 on, 2 off, 2 on , 2 off ...
    1789. 

  1789. *   (2,1) is 2 on, 1 off, 2 on, 1 off.. etc
    1790. 

  1790. * phase is a modifier on the dash pattern which is used to shift the point at which the pattern starts. 
    1791. 

  1791. */
    1792. 

  1792. function setLineStyle($width=1,$cap='',$join='',$dash='',$phase=0){
    1793. 

  1793. 

  1794.   // this is quite inefficient in that it sets all the parameters whenever 1 is changed, but will fix another day
    1795. 

  1795.   $string = '';
    1796. 

  1796.   if ($width>0){
    1797. 

  1797.     $string.= $width.' w';
    1798. 

  1798.   }
    1799. 

  1799.   $ca = array('butt'=>0,'round'=>1,'square'=>2);
    1800. 

  1800.   if (isset($ca[$cap])){
    1801. 

  1801.     $string.= ' '.$ca[$cap].' J';
    1802. 

  1802.   }
    1803. 

  1803.   $ja = array('miter'=>0,'round'=>1,'bevel'=>2);
    1804. 

  1804.   if (isset($ja[$join])){
    1805. 

  1805.     $string.= ' '.$ja[$join].' j';
    1806. 

  1806.   }
    1807. 

  1807.   if (is_array($dash)){
    1808. 

  1808.     $string.= ' [';
    1809. 

  1809.     foreach ($dash as $len){
    1810. 

  1810.       $string.=' '.$len;
    1811. 

  1811.     }
    1812. 

  1812.     $string.= ' ] '.$phase.' d';
    1813. 

  1813.   }
    1814. 

  1814.   $this->currentLineStyle = $string;
    1815. 

  1815.   $this->objects[$this->currentContents]['c'].="\n".$string;
    1816. 

  1816. }
    1817. 

  1817. 

  1818. /**
    1819. 

  1819. * draw a polygon, the syntax for this is similar to the GD polygon command
    1820. 

  1820. */
    1821. 

  1821. function polygon($p,$np,$f=0){
    1822. 

  1822.   $this->objects[$this->currentContents]['c'].="\n";
    1823. 

  1823.   $this->objects[$this->currentContents]['c'].=sprintf('%.3f',$p[0]).' '.sprintf('%.3f',$p[1]).' m ';
    1824. 

  1824.   for ($i=2;$i<$np*2;$i=$i+2){
    1825. 

  1825.     $this->objects[$this->currentContents]['c'].= sprintf('%.3f',$p[$i]).' '.sprintf('%.3f',$p[$i+1]).' l ';
    1826. 

  1826.   }
    1827. 

  1827.   if ($f==1){
    1828. 

  1828.     $this->objects[$this->currentContents]['c'].=' f';
    1829. 

  1829.   } else {
    1830. 

  1830.     $this->objects[$this->currentContents]['c'].=' S';
    1831. 

  1831.   }
    1832. 

  1832. }
    1833. 

  1833. 

  1834. /**
    1835. 

  1835. * a filled rectangle, note that it is the width and height of the rectangle which are the secondary paramaters, not
    1836. 

  1836. * the coordinates of the upper-right corner
    1837. 

  1837. */
    1838. 

  1838. function filledRectangle($x1,$y1,$width,$height){
    1839. 

  1839.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$x1).' '.sprintf('%.3f',$y1).' '.sprintf('%.3f',$width).' '.sprintf('%.3f',$height).' re f';
    1840. 

  1840. }
    1841. 

  1841. 

  1842. /**
    1843. 

  1843. * draw a rectangle, note that it is the width and height of the rectangle which are the secondary paramaters, not
    1844. 

  1844. * the coordinates of the upper-right corner
    1845. 

  1845. */
    1846. 

  1846. function rectangle($x1,$y1,$width,$height){
    1847. 

  1847.   $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$x1).' '.sprintf('%.3f',$y1).' '.sprintf('%.3f',$width).' '.sprintf('%.3f',$height).' re S';
    1848. 

  1848. }
    1849. 

  1849. 

  1850. /**
    1851. 

  1851. * add a new page to the document
    1852. 

  1852. * this also makes the new page the current active object
    1853. 

  1853. */
    1854. 

  1854. function newPage($insert=0,$id=0,$pos='after'){
    1855. 

  1855. 

  1856.   // if there is a state saved, then go up the stack closing them
    1857. 

  1857.   // then on the new page, re-open them with the right setings
    1858. 

  1858.   
    1859. 

  1859.   if ($this->nStateStack){
    1860. 

  1860.     for ($i=$this->nStateStack;$i>=1;$i--){
    1861. 

  1861.       $this->restoreState($i);
    1862. 

  1862.     }
    1863. 

  1863.   }
    1864. 

  1864. 

  1865.   $this->numObj++;
    1866. 

  1866.   if ($insert){
    1867. 

  1867.     // the id from the ezPdf class is the od of the contents of the page, not the page object itself
    1868. 

  1868.     // query that object to find the parent
    1869. 

  1869.     $rid = $this->objects[$id]['onPage'];
    1870. 

  1870.     $opt= array('rid'=>$rid,'pos'=>$pos);
    1871. 

  1871.     $this->o_page($this->numObj,'new',$opt);
    1872. 

  1872.   } else {
    1873. 

  1873.     $this->o_page($this->numObj,'new');
    1874. 

  1874.   }
    1875. 

  1875.   // if there is a stack saved, then put that onto the page
    1876. 

  1876.   if ($this->nStateStack){
    1877. 

  1877.     for ($i=1;$i<=$this->nStateStack;$i++){
    1878. 

  1878.       $this->saveState($i);
    1879. 

  1879.     }
    1880. 

  1880.   }  
    1881. 

  1881.   // and if there has been a stroke or fill colour set, then transfer them
    1882. 

  1882.   if ($this->currentColour['r']>=0){
    1883. 

  1883.     $this->setColor($this->currentColour['r'],$this->currentColour['g'],$this->currentColour['b'],1);
    1884. 

  1884.   }
    1885. 

  1885.   if ($this->currentStrokeColour['r']>=0){
    1886. 

  1886.     $this->setStrokeColor($this->currentStrokeColour['r'],$this->currentStrokeColour['g'],$this->currentStrokeColour['b'],1);
    1887. 

  1887.   }
    1888. 

  1888. 

  1889.   // if there is a line style set, then put this in too
    1890. 

  1890.   if (strlen($this->currentLineStyle)){
    1891. 

  1891.     $this->objects[$this->currentContents]['c'].="\n".$this->currentLineStyle;
    1892. 

  1892.   }
    1893. 

  1893. 

  1894.   // the call to the o_page object set currentContents to the present page, so this can be returned as the page id
    1895. 

  1895.   return $this->currentContents;
    1896. 

  1896. }
    1897. 

  1897. 

  1898. /**
    1899. 

  1899. * output the pdf code, streaming it to the browser
    1900. 

  1900. * the relevant headers are set so that hopefully the browser will recognise it
    1901. 

  1901. */
    1902. 

  1902. function stream($options=''){
    1903. 

  1903.   // setting the options allows the adjustment of the headers
    1904. 

  1904.   // values at the moment are:
    1905. 

  1905.   // 'Content-Disposition'=>'filename'  - sets the filename, though not too sure how well this will 
    1906. 

  1906.   //        work as in my trial the browser seems to use the filename of the php file with .pdf on the end
    1907. 

  1907.   // 'Accept-Ranges'=>1 or 0 - if this is not set to 1, then this header is not included, off by default
    1908. 

  1908.   //    this header seems to have caused some problems despite tha fact that it is supposed to solve
    1909. 

  1909.   //    them, so I am leaving it off by default.
    1910. 

  1910.   // 'compress'=> 1 or 0 - apply content stream compression, this is on (1) by default
    1911. 

  1911.   if (!is_array($options)){
    1912. 

  1912.     $options=array();
    1913. 

  1913.   }
    1914. 

  1914.   if ( isset($options['compress']) && $options['compress']==0){
    1915. 

  1915.     $tmp = $this->output(1);
    1916. 

  1916.   } else {
    1917. 

  1917.     $tmp = $this->output();
    1918. 

  1918.   }
    1919. 

  1919.   header("Content-type: application/pdf");
    1920. 

  1920.   header("Content-Length: ".strlen(ltrim($tmp)));
    1921. 

  1921.   $fileName = (isset($options['Content-Disposition'])?$options['Content-Disposition']:'file.pdf');
    1922. 

  1922.   header("Content-Disposition: inline; filename=".$fileName);
    1923. 

  1923.   if (isset($options['Accept-Ranges']) && $options['Accept-Ranges']==1){
    1924. 

  1924.     header("Accept-Ranges: ".strlen(ltrim($tmp))); 
    1925. 

  1925.   }
    1926. 

  1926.   echo ltrim($tmp);
    1927. 

  1927. }
    1928. 

  1928. 

  1929. /**
    1930. 

  1930. * return the height in units of the current font in the given size
    1931. 

  1931. */
    1932. 

  1932. function getFontHeight($size){
    1933. 

  1933.   if (!$this->numFonts){
    1934. 

  1934.     $this->selectFont('./fonts/Helvetica');
    1935. 

  1935.   }
    1936. 

  1936.   // for the current font, and the given size, what is the height of the font in user units
    1937. 

  1937.   $h = $this->fonts[$this->currentFont]['FontBBox'][3]-$this->fonts[$this->currentFont]['FontBBox'][1];
    1938. 

  1938.   return $size*$h/1000;
    1939. 

  1939. }
    1940. 

  1940. 

  1941. /**
    1942. 

  1942. * return the font decender, this will normally return a negative number
    1943. 

  1943. * if you add this number to the baseline, you get the level of the bottom of the font
    1944. 

  1944. * it is in the pdf user units
    1945. 

  1945. */
    1946. 

  1946. function getFontDecender($size){
    1947. 

  1947.   // note that this will most likely return a negative value
    1948. 

  1948.   if (!$this->numFonts){
    1949. 

  1949.     $this->selectFont('./fonts/Helvetica');
    1950. 

  1950.   }
    1951. 

  1951.   $h = $this->fonts[$this->currentFont]['FontBBox'][1];
    1952. 

  1952.   return $size*$h/1000;
    1953. 

  1953. }
    1954. 

  1954. 

  1955. /**
    1956. 

  1956. * filter the text, this is applied to all text just before being inserted into the pdf document
    1957. 

  1957. * it escapes the various things that need to be escaped, and so on
    1958. 

  1958. *
    1959. 

  1959. * @access private
    1960. 

  1960. */
    1961. 

  1961. function filterText($text){
    1962. 

  1962.   $text = str_replace('\\','\\\\',$text);
    1963. 

  1963.   $text = str_replace('(','\(',$text);
    1964. 

  1964.   $text = str_replace(')','\)',$text);
    1965. 

  1965.   $text = str_replace('&lt;','<',$text);
    1966. 

  1966.   $text = str_replace('&gt;','>',$text);
    1967. 

  1967.   $text = str_replace('&#039;','\'',$text);
    1968. 

  1968.   $text = str_replace('&quot;','"',$text);
    1969. 

  1969.   $text = str_replace('&amp;','&',$text);
    1970. 

  1970. 

  1971.   return $text;
    1972. 

  1972. }
    1973. 

  1973. 

  1974. /**
    1975. 

  1975. * given a start position and information about how text is to be laid out, calculate where 
    1976. 

  1976. * on the page the text will end
    1977. 

  1977. *
    1978. 

  1978. * @access private
    1979. 

  1979. */
    1980. 

  1980. function PRVTgetTextPosition($x,$y,$angle,$size,$wa,$text){
    1981. 

  1981.   // given this information return an array containing x and y for the end position as elements 0 and 1
    1982. 

  1982.   $w = $this->getTextWidth($size,$text);
    1983. 

  1983.   // need to adjust for the number of spaces in this text
    1984. 

  1984.   $words = explode(' ',$text);
    1985. 

  1985.   $nspaces=count($words)-1;
    1986. 

  1986.   $w += $wa*$nspaces;
    1987. 

  1987.   $a = deg2rad((float)$angle);
    1988. 

  1988.   return array(cos($a)*$w+$x,-sin($a)*$w+$y);
    1989. 

  1989. }
    1990. 

  1990. 

  1991. /**
    1992. 

  1992. * wrapper function for PRVTcheckTextDirective1
    1993. 

  1993. *
    1994. 

  1994. * @access private
    1995. 

  1995. */
    1996. 

  1996. function PRVTcheckTextDirective(&$text,$i,&$f){
    1997. 

  1997.   $x=0;
    1998. 

  1998.   $y=0;
    1999. 

  1999.   return $this->PRVTcheckTextDirective1($text,$i,$f,0,$x,$y);
    2000. 

  2000. }
    2001. 

  2001. 

  2002. /**
    2003. 

  2003. * checks if the text stream contains a control directive
    2004. 

  2004. * if so then makes some changes and returns the number of characters involved in the directive
    2005. 

  2005. * this has been re-worked to include everything neccesary to fins the current writing point, so that
    2006. 

  2006. * the location can be sent to the callback function if required
    2007. 

  2007. * if the directive does not require a font change, then $f should be set to 0
    2008. 

  2008. *
    2009. 

  2009. * @access private
    2010. 

  2010. */
    2011. 

  2011. function PRVTcheckTextDirective1(&$text,$i,&$f,$final,&$x,&$y,$size=0,$angle=0,$wordSpaceAdjust=0){
    2012. 

  2012.   $directive = 0;
    2013. 

  2013.   $j=$i;
    2014. 

  2014.   if ($text[$j]=='<'){
    2015. 

  2015.     $j++;
    2016. 

  2016.     switch($text[$j]){
    2017. 

  2017.       case '/':
    2018. 

  2018.         $j++;
    2019. 

  2019.         if (strlen($text) <= $j){
    2020. 

  2020.           return $directive;
    2021. 

  2021.         }
    2022. 

  2022.         switch($text[$j]){
    2023. 

  2023.           case 'b':
    2024. 

  2024.           case 'i':
    2025. 

  2025.             $j++;
    2026. 

  2026.             if ($text[$j]=='>'){
    2027. 

  2027.               $p = strrpos($this->currentTextState,$text[$j-1]);
    2028. 

  2028.               if ($p !== false){
    2029. 

  2029.                 // then there is one to remove
    2030. 

  2030.                 $this->currentTextState = substr($this->currentTextState,0,$p).substr($this->currentTextState,$p+1);
    2031. 

  2031.               }
    2032. 

  2032.               $directive=$j-$i+1;
    2033. 

  2033.             }
    2034. 

  2034.             break;
    2035. 

  2035.           case 'c':
    2036. 

  2036.             // this this might be a callback function
    2037. 

  2037.             $j++;
    2038. 

  2038.             $k = strpos($text,'>',$j);
    2039. 

  2039.             if ($k!==false && $text[$j]==':'){
    2040. 

  2040.               // then this will be treated as a callback directive
    2041. 

  2041.               $directive = $k-$i+1;
    2042. 

  2042.               $f=0;
    2043. 

  2043.               // split the remainder on colons to get the function name and the paramater
    2044. 

  2044.               $tmp = substr($text,$j+1,$k-$j-1);
    2045. 

  2045.               $b1 = strpos($tmp,':');
    2046. 

  2046.               if ($b1!==false){
    2047. 

  2047.                 $func = su
    2048.