PageRenderTime 90ms CodeModel.GetById 18ms 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

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

    

  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 sele…
    1609.

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