| blob | 5135b465f9f5005f98406cf1ed52080b7d0e4714 |
1 <?php
2 /**
3 * Cpdf
4 *
5 * http://www.ros.co.nz/pdf
6 *
7 * A PHP class to provide the basic functionality to create a pdf document without
8 * any requirement for additional modules.
9 *
10 * Note that they companion class CezPdf can be used to extend this class and dramatically
11 * simplify the creation of documents.
12 *
13 * IMPORTANT NOTE
14 * there is no warranty, implied or otherwise with this software.
15 *
16 * LICENCE
17 * This code has been placed in the Public Domain for all to enjoy.
18 *
19 * @author Wayne Munro <pdf@ros.co.nz>
20 * @version 009
21 * @package Cpdf
22 */
25 /**
26 * the current number of pdf objects in the document
27 */
29 /**
30 * this array contains all of the pdf objects, ready for final assembly
31 */
33 /**
34 * the objectId (number within the objects array) of the document catalog
35 */
37 /**
38 * array carrying information about the fonts that the system currently knows about
39 * used to ensure that a font is not loaded twice, among other things
40 */
42 /**
43 * a record of the current font
44 */
46 /**
47 * the current base font
48 */
50 /**
51 * the number of the current font within the font array
52 */
54 /**
55 *
56 */
58 /**
59 * object number of the current page
60 */
62 /**
63 * object number of the currently active contents block
64 */
66 /**
67 * number of fonts within the system
68 */
70 /**
71 * current colour for fill operations, defaults to inactive value, all three components should be between 0 and 1 inclusive when active
72 */
74 /**
75 * current colour for stroke operations (lines etc.)
76 */
78 /**
79 * current style that lines are drawn in
80 */
82 /**
83 * an array which is used to save the state of the document, mainly the colours and styles
84 * it is used to temporarily change to another state, the change back to what it was before
85 */
87 /**
88 * number of elements within the state stack
89 */
91 /**
92 * number of page objects within the document
93 */
95 /**
96 * object Id storage stack
97 */
99 /**
100 * number of elements within the object Id storage stack
101 */
103 /**
104 * an array which contains information about the objects which are not firmly attached to pages
105 * these have been added with the addObject function
106 */
108 /**
109 * array contains infomation about how the loose objects are to be added to the document
110 */
112 /**
113 * the objectId of the information object for the document
114 * this contains authorship, title etc.
115 */
117 /**
118 * number of images being tracked within the document
119 */
121 /**
122 * an array containing options about the document
123 * it defaults to turning on the compression of the objects
124 */
126 /**
127 * the objectId of the first page of the document
128 */
130 /**
131 * used to track the last used value of the inter-word spacing, this is so that it is known
132 * when the spacing is changed.
133 */
135 /**
136 * the object Id of the procset object
137 */
139 /**
140 * store the information about the relationship between font families
141 * this used so that the code knows which font is the bold version of another font, etc.
142 * the value of this array is initialised in the constuctor function.
143 */
145 /**
146 * track if the current font is bolded or italicised
147 */
149 /**
150 * messages are stored here during processing, these can be selected afterwards to give some useful debug information
151 */
153 /**
154 * the ancryption array for the document encryption is stored here
155 */
157 /**
158 * the object Id of the encryption information
159 */
161 /**
162 * the file identifier, used to uniquely identify a pdf document
163 */
165 /**
166 * a flag to say if a document is to be encrypted or not
167 */
169 /**
170 * the ancryption key for the encryption of all the document content (structure is not encrypted)
171 */
173 /**
174 * array which forms a stack to keep track of nested callback functions
175 */
177 /**
178 * the number of callback functions in the callback array
179 */
181 /**
182 * store label->id pairs for named destinations, these will be used to replace internal links
183 * done this way so that destinations can be defined after the location that links to them
184 */
186 /**
187 * store the stack for the transaction commands, each item in here is a record of the values of all the
188 * variables within the class, so that the user can rollback at will (from each 'start' command)
189 * note that this includes the objects array, so these can be large.
190 */
192 /**
193 * class constructor
194 * this will start a new document
195 * @var array array of 4 numbers, defining the bottom left and upper right corner of the page. first two are normally zero.
196 */
200 // also initialize the font families that are known about already
202 // $this->fileIdentifier = md5('xxxxxxxx'.time());
204 }
206 /**
207 * Document object methods (internal use only)
208 *
209 * There is about one object method for each type of object in the pdf document
210 * Each function has the same call list ($id,$action,$options).
211 * $id = the object ID of the object, or what it is to be if it is being created
212 * $action = a string specifying the action to be performed, though ALL must support:
213 * 'new' - create the object with the id $id
214 * 'out' - produce the output for the pdf object
215 * $options = optional, a string or array containing the various parameters for the object
216 *
217 * These, in conjunction with the output function are the ONLY way for output to be produced
218 * within the pdf 'file'.
219 */
221 /**
222 *destination object, used to specify the location for the user to jump to, presently on opening
223 */
227 }
246 }
253 }
254 }
256 /**
257 * set the viewer preferences
258 */
262 }
279 }
280 }
287 }
291 }
292 }
294 /**
295 * define the document catalog, the overall controller for the document
296 */
300 }
316 }
336 }
337 }
341 }
342 }
344 /**
345 * object which is a parent to the pages in the document
346 */
350 }
358 // then it will just be the id of the new page
361 // then it should be an array having 'id','rid','pos', where rid=the page to which this one will be placed relative
362 // and pos is either 'before' or 'after', saying where this page will fit.
366 // then there is a match
367 // make a space
378 }
382 }
384 }
385 }
386 }
387 }
406 }
408 if ((isset($o['info']['fonts']) && count($o['info']['fonts'])) || isset($o['info']['procset'])){
412 }
417 }
419 }
424 }
426 }
430 $res.="\n/MediaBox [".sprintf('%.3f',$tmp[0]).' '.sprintf('%.3f',$tmp[1]).' '.sprintf('%.3f',$tmp[2]).' '.sprintf('%.3f',$tmp[3]).']';
431 }
432 }
436 }
439 }
440 }
442 /**
443 * define the outlines in the doc, empty for now
444 */
448 }
462 }
466 }
469 }
470 }
472 /**
473 * an object to hold the font description
474 */
478 }
481 $this->objects[$id]=array('t'=>'font','info'=>array('name'=>$options['name'],'SubType'=>'Type1'));
484 // deal with the encoding and the differences
486 // then we'll need an encoding dictionary
491 // we can specify encoding here
503 }
506 }
507 // also tell the pages node about the new font
524 }
525 }
532 // then place a reference to the dictionary
535 // use the specified encoding
537 }
540 }
543 }
546 }
549 }
553 }
554 }
556 /**
557 * a font descriptor, needed for including additional fonts
558 */
562 }
586 }
599 }
600 }
604 }
605 }
607 /**
608 * the font encoding
609 */
613 }
616 // the options array should contain 'differences' and maybe 'encoding'
623 }
626 }
631 // we cannot make use of consecutive numbering
635 }
637 }
641 }
642 }
644 /**
645 * the document procset, solves some problems with printing to old PS printers
646 */
650 }
658 // this is to add new items to the procset list, despite the fact that this is considered
659 // obselete, the items are required for printing to some postscript printers
666 }
672 }
676 }
677 }
679 /**
680 * define the document information
681 */
685 }
690 $this->objects[$id]=array('t'=>'info','info'=>array('Creator'=>'R and OS php pdf writer, http://www.ros.co.nz','CreationDate'=>$date));
706 }
714 }
716 }
720 }
721 }
723 /**
724 * an action object, used to link to URLS initially
725 */
729 }
735 // then assume a URI action
737 }
742 }
746 // there will be an 'label' setting, this is the name of the destination
755 }
758 }
762 }
763 }
765 /**
766 * an annotation object, this will add an annotation to the current page.
767 * initially will support just link annotations
768 */
772 }
775 // add the annotation to the current page
778 // and add the action object which is going to be required
787 // this is to a named internal link
794 }
803 }
810 }
815 }
816 }
818 /**
819 * a page object, it also creates a contents object to hold its contents
820 */
824 }
828 $this->objects[$id]=array('t'=>'page','info'=>array('parent'=>$this->currentNode,'pageNum'=>$this->numPages));
830 // then this must be a page insertion, array shoudl contain 'rid','pos'=[before|after]
835 }
837 //make a contents object to go with this page
847 }
848 }
854 // add an annotation to this page
857 }
858 // $options should contain the id of the annotation dictionary
868 }
870 }
878 }
880 }
884 }
885 }
887 /**
888 * the contents objects hold all of the content which appears on pages
889 */
893 }
898 // then this contents is the primary for a page
901 // then this page contains some other type of system object
903 }
906 // add more options to the decleration
909 }
918 // then implement ZLIB based compression on this content stream
921 }
925 }
928 }
930 }
934 }
935 }
937 /**
938 * an image object, will be an XObject in the document, includes description and data
939 */
943 }
946 // make the new object
955 }
963 }
968 $this->objects[$id]['info']['DecodeParms']='<< /Predictor 15 /Colors '.$options['ncolor'].' /Columns '.$options['iw'].' /BitsPerComponent '.$options['bitsPerComponent'].'>>';
983 }
984 }
987 }
989 }
990 // assign it a place in the named resource dictionary as an external object, according to
991 // the label passed in with it.
993 // also make sure that we have the right procset object for it.
1001 }
1005 }
1009 }
1010 }
1012 /**
1013 * encryption object.
1014 */
1018 }
1021 // make the new object
1024 // figure out the additional paramaters required
1025 $pad = chr(0x28).chr(0xBF).chr(0x4E).chr(0x5E).chr(0x4E).chr(0x75).chr(0x8A).chr(0x41).chr(0x64).chr(0x00).chr(0x4E).chr(0x56).chr(0xFF).chr(0xFA).chr(0x01).chr(0x08).chr(0x2E).chr(0x2E).chr(0x00).chr(0xB6).chr(0xD0).chr(0x68).chr(0x3E).chr(0x80).chr(0x2F).chr(0x0C).chr(0xA9).chr(0xFE).chr(0x64).chr(0x53).chr(0x69).chr(0x7A);
1033 }
1041 }
1047 // now make the u value, phew.
1048 $tmp = $this->md5_16($user.$ovalue.chr($options['p']).chr(255).chr(255).chr(255).$this->fileIdentifier);
1059 // initialize the arc4 array
1068 // and the p-value needs to be converted to account for the twos-complement approach
1075 }
1076 }
1078 /**
1079 * ARC4 functions
1080 * A series of function to implement ARC4 encoding in PHP
1081 */
1083 /**
1084 * calculate the 16 byte version of the 128 bit md5 digest of the string
1085 */
1091 }
1093 }
1095 /**
1096 * initialize the encryption for processing a particular object
1097 */
1103 }
1104 $tmp.= chr(hexdec(substr($hex,4,2))).chr(hexdec(substr($hex,2,2))).chr(hexdec(substr($hex,0,2))).chr(0).chr(0);
1107 }
1109 /**
1110 * initialize the ARC4 encryption
1111 */
1114 // setup the control array
1117 }
1121 }
1125 }
1132 }
1133 }
1135 /**
1136 * ARC4 encrypt a text string
1137 */
1152 }
1155 }
1157 /**
1158 * functions which can be called to adjust or add to the document
1159 */
1161 /**
1162 * add a link in the document to an external URL
1163 */
1168 }
1170 /**
1171 * add a link in the document to an internal destination (ie. within the document)
1172 */
1177 }
1179 /**
1180 * set the encryption of the document
1181 * can be used to turn it on and/or set the passwords which it will have.
1182 * also the functions that the user will have are set here, such as print, modify, add
1183 */
1192 );
1198 }
1199 }
1200 // implement encryption on the document
1202 // then the block does not exist already, add it.
1206 }
1208 }
1209 }
1211 /**
1212 * should be used for internal checks, not implemented as yet
1213 */
1215 }
1217 /**
1218 * return the pdf stream as a string returned from the function
1219 */
1223 // turn compression off
1225 }
1229 }
1235 // $content="%PDF-1.3\n";
1243 }
1247 }
1248 $content.="\ntrailer\n << /Size ".(count($xref)+1)."\n /Root 1 0 R\n /Info ".$this->infoObject." 0 R\n";
1249 // if encryption has been applied to this document then add the marker for this dictionary
1252 }
1255 }
1258 }
1260 /**
1261 * intialize a new document
1262 * if this is called on an existing document results may be unpredictable, but the existing document would be lost at minimum
1263 * this function is called automatically by the constructor function
1264 *
1265 * @access private
1266 */
1292 // need to store the first page id as there is no way to get it to the user during
1293 // startup
1295 }
1297 /**
1298 * open the font file and return a php structure containing it.
1299 * first check if this one has been done before and saved in a form more suited to php
1300 * note that if a php serialized version does not exist it will try and make one, but will
1301 * require write access to the directory to do it... it is MUCH faster to have these serialized
1302 * files.
1303 *
1304 * @access private
1305 */
1307 // assume that $font contains both the path and perhaps the extension to the file, split them
1315 }
1319 }
1326 // if the font file is old, then clear it out and prepare for re-creation
1329 }
1330 }
1332 // then rebuild the php_<font>.afm file from the <font>.afm file
1340 // then there must be some keyword
1367 //C 39 ; WX 222 ; N quoteright ; B 53 463 157 718 ;
1377 }
1380 }
1381 }
1382 }
1388 }
1391 //KPX Adieresis yacute -40
1395 }
1396 }
1397 }
1406 // echo 'Font not Found '.$font;
1407 }
1408 }
1410 /**
1411 * if the font is not loaded then load it and make the required object
1412 * else just make it the current font
1413 * the encoding array can contain 'encoding'=> 'none','WinAnsiEncoding','MacRomanEncoding' or 'MacExpertEncoding'
1414 * note that encoding='none' will need to be used for symbolic fonts
1415 * and 'differences' => an array of mappings between numbers 0->255 and character names.
1416 *
1417 */
1420 // load the file
1426 // $dir=substr($fontName,0,$pos+1);
1430 }
1433 // then encoding and differences might be set
1436 }
1439 }
1441 // then perhaps only the encoding has been set
1443 }
1447 // if this is a '.afm' font, and there is a '.pfa' file to go with it ( as there
1448 // should be for all non-basic fonts), then load it into an object and put the
1449 // references into the font object
1457 }
1460 // $pfbfile = substr($fontName,0,strlen($fontName)-4).'.pfb';
1461 // $ttffile = substr($fontName,0,strlen($fontName)-4).'.ttf';
1465 // $fontObj = $this->numObj;
1467 // find the array of fond widths, and put that into an object.
1476 }
1477 }
1481 }
1483 }
1484 }
1485 // also need to adjust the widths for the differences array
1491 }
1493 }
1496 }
1497 }
1498 }
1506 }
1510 // load the pfb file, and put that into an object too.
1511 // note that pdf supports only binary format type 1 font files, though there is a
1512 // simple utility to convert them from pfa to pfb.
1520 // create the font descriptor
1525 // determine flags (more than a little flakey, hopefully will not matter much)
1531 $list = array('Ascent'=>'Ascender','CapHeight'=>'CapHeight','Descent'=>'Descender','FontBBox'=>'FontBBox','ItalicAngle'=>'ItalicAngle');
1536 );
1540 }
1541 }
1547 }
1550 // embed the font program
1553 // determine the cruicial lengths within this file
1562 }
1565 // tell the font object about all this new stuff
1571 }
1575 }
1579 $this->addMessage('selectFont: pfb or ttf file not found, ok if this is one of the 14 standard fonts');
1580 }
1583 // also set the differences here, note that this means that these will take effect only the
1584 //first time that a font is selected, else they are ignored
1587 }
1588 }
1589 }
1591 // so if for some reason the font was not set in the last one then it will not be selected
1593 // the next line means that if a new font is selected, then the current text state will be
1594 // applied to it as well.
1596 }
1598 }
1600 /**
1601 * sets up the current font, based on the font families, and the current text state
1602 * note that this system is quite flexible, a <b><i> font can be completely different to a
1603 * <i><b> font, and even <b><b> will have to be defined within the family to have meaning
1604 * This function is to be called whenever the currentTextState is changed, it will update
1605 * the currentFont setting to whatever the appropriatte family one is.
1606 * If the user calls selectFont themselves then that will reset the currentBaseFont, and the currentFont
1607 * This function will change the currentFont to whatever it should be, but will not change the
1608 * currentBaseFont.
1609 *
1610 * @access private
1611 */
1614 // then assume an initial font
1616 }
1621 // then we are in some state or another
1622 // and this font has a family, and the current setting exists within it
1623 // select the font, then return it
1624 $nf = substr($this->currentBaseFont,0,strrpos($this->currentBaseFont,'/')+1).$this->fontFamilies[$cf][$this->currentTextState];
1629 // the this font must not have the right family member for the current state
1630 // simply assume the base font
1633 }
1634 }
1636 /**
1637 * function for the user to find out what the ID is of the first page that was created during
1638 * startup - useful if they wish to add something to it later.
1639 */
1642 }
1644 /**
1645 * add content to the currently active object
1646 *
1647 * @access private
1648 */
1651 }
1653 /**
1654 * sets the colour for fill operations
1655 */
1657 if ($r>=0 && ($force || $r!=$this->currentColour['r'] || $g!=$this->currentColour['g'] || $b!=$this->currentColour['b'])){
1658 $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$r).' '.sprintf('%.3f',$g).' '.sprintf('%.3f',$b).' rg';
1660 }
1661 }
1663 /**
1664 * sets the colour for stroke operations
1665 */
1667 if ($r>=0 && ($force || $r!=$this->currentStrokeColour['r'] || $g!=$this->currentStrokeColour['g'] || $b!=$this->currentStrokeColour['b'])){
1668 $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$r).' '.sprintf('%.3f',$g).' '.sprintf('%.3f',$b).' RG';
1670 }
1671 }
1673 /**
1674 * draw a line from one set of coordinates to another
1675 */
1677 $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$x1).' '.sprintf('%.3f',$y1).' m '.sprintf('%.3f',$x2).' '.sprintf('%.3f',$y2).' l S';
1678 }
1680 /**
1681 * draw a bezier curve based on 4 control points
1682 */
1684 // in the current line style, draw a bezier curve from (x0,y0) to (x3,y3) using the other two points
1685 // as the control points for the curve.
1686 $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$x0).' '.sprintf('%.3f',$y0).' m '.sprintf('%.3f',$x1).' '.sprintf('%.3f',$y1);
1687 $this->objects[$this->currentContents]['c'].= ' '.sprintf('%.3f',$x2).' '.sprintf('%.3f',$y2).' '.sprintf('%.3f',$x3).' '.sprintf('%.3f',$y3).' c S';
1688 }
1690 /**
1691 * draw a part of an ellipse
1692 */
1695 }
1697 /**
1698 * draw a filled ellipse
1699 */
1702 }
1704 /**
1705 * draw an ellipse
1706 * note that the part and filled ellipse are just special cases of this function
1707 *
1708 * draws an ellipse in the current line style
1709 * centered at $x0,$y0, radii $r1,$r2
1710 * if $r2 is not set, then a circle is drawn
1711 * nSeg is not allowed to be less than 2, as this will simply draw a line (and will even draw a
1712 * pretty crappy shape at 2, as we are approximating with bezier curves.
1713 */
1717 }
1720 }
1723 }
1735 $tmp .= sprintf('%.3f',cos($a)).' '.sprintf('%.3f',(-1.0*sin($a))).' '.sprintf('%.3f',sin($a)).' '.sprintf('%.3f',cos($a)).' ';
1740 }
1748 $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$a0).' '.sprintf('%.3f',$b0).' m ';
1750 // draw this bit of the total curve
1756 $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',($a0+$c0*$dtm)).' '.sprintf('%.3f',($b0+$d0*$dtm));
1757 $this->objects[$this->currentContents]['c'].= ' '.sprintf('%.3f',($a1-$c1*$dtm)).' '.sprintf('%.3f',($b1-$d1*$dtm)).' '.sprintf('%.3f',$a1).' '.sprintf('%.3f',$b1).' c';
1762 }
1767 $this->objects[$this->currentContents]['c'].=' s'; // small 's' signifies closing the path as well
1770 }
1771 }
1774 }
1775 }
1777 /**
1778 * this sets the line drawing style.
1779 * width, is the thickness of the line in user units
1780 * cap is the type of cap to put on the line, values can be 'butt','round','square'
1781 * where the diffference between 'square' and 'butt' is that 'square' projects a flat end past the
1782 * end of the line.
1783 * join can be 'miter', 'round', 'bevel'
1784 * dash is an array which sets the dash pattern, is a series of length values, which are the lengths of the
1785 * on and off dashes.
1786 * (2) represents 2 on, 2 off, 2 on , 2 off ...
1787 * (2,1) is 2 on, 1 off, 2 on, 1 off.. etc
1788 * phase is a modifier on the dash pattern which is used to shift the point at which the pattern starts.
1789 */
1792 // this is quite inefficient in that it sets all the parameters whenever 1 is changed, but will fix another day
1796 }
1800 }
1804 }
1809 }
1811 }
1814 }
1816 /**
1817 * draw a polygon, the syntax for this is similar to the GD polygon command
1818 */
1821 $this->objects[$this->currentContents]['c'].=sprintf('%.3f',$p[0]).' '.sprintf('%.3f',$p[1]).' m ';
1823 $this->objects[$this->currentContents]['c'].= sprintf('%.3f',$p[$i]).' '.sprintf('%.3f',$p[$i+1]).' l ';
1824 }
1829 }
1830 }
1832 /**
1833 * a filled rectangle, note that it is the width and height of the rectangle which are the secondary paramaters, not
1834 * the coordinates of the upper-right corner
1835 */
1837 $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$x1).' '.sprintf('%.3f',$y1).' '.sprintf('%.3f',$width).' '.sprintf('%.3f',$height).' re f';
1838 }
1840 /**
1841 * draw a rectangle, note that it is the width and height of the rectangle which are the secondary paramaters, not
1842 * the coordinates of the upper-right corner
1843 */
1845 $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$x1).' '.sprintf('%.3f',$y1).' '.sprintf('%.3f',$width).' '.sprintf('%.3f',$height).' re S';
1846 }
1848 /**
1849 * add a new page to the document
1850 * this also makes the new page the current active object
1851 */
1854 // if there is a state saved, then go up the stack closing them
1855 // then on the new page, re-open them with the right setings
1860 }
1861 }
1865 // the id from the ezPdf class is the od of the contents of the page, not the page object itself
1866 // query that object to find the parent
1872 }
1873 // if there is a stack saved, then put that onto the page
1877 }
1878 }
1879 // and if there has been a stroke or fill colour set, then transfer them
1881 $this->setColor($this->currentColour['r'],$this->currentColour['g'],$this->currentColour['b'],1);
1882 }
1884 $this->setStrokeColor($this->currentStrokeColour['r'],$this->currentStrokeColour['g'],$this->currentStrokeColour['b'],1);
1885 }
1887 // if there is a line style set, then put this in too
1890 }
1892 // the call to the o_page object set currentContents to the present page, so this can be returned as the page id
1894 }
1896 /**
1897 * output the pdf code, streaming it to the browser
1898 * the relevant headers are set so that hopefully the browser will recognise it
1899 */
1901 // setting the options allows the adjustment of the headers
1902 // values at the moment are:
1903 // 'Content-Disposition'=>'filename' - sets the filename, though not too sure how well this will
1904 // work as in my trial the browser seems to use the filename of the php file with .pdf on the end
1905 // 'Accept-Ranges'=>1 or 0 - if this is not set to 1, then this header is not included, off by default
1906 // this header seems to have caused some problems despite tha fact that it is supposed to solve
1907 // them, so I am leaving it off by default.
1908 // 'compress'=> 1 or 0 - apply content stream compression, this is on (1) by default
1911 }
1916 }
1918 // Rod's mods below are based on this tip:
1919 // http://sourceforge.net/forum/forum.php?thread_id=1420028&forum_id=147987
1924 $fileName = (isset($options['Content-Disposition'])?$options['Content-Disposition']:'file.pdf');
1925 // header("Content-Disposition: inline; filename=".$fileName);
1926 // This supports a new "inline" keyword in the options array. If true, the
1927 // Content-Disposition header is set to indicate an inline document:
1931 // End of Rod's mods.
1935 }
1937 }
1939 /**
1940 * return the height in units of the current font in the given size
1941 */
1945 }
1946 // for the current font, and the given size, what is the height of the font in user units
1947 $h = $this->fonts[$this->currentFont]['FontBBox'][3]-$this->fonts[$this->currentFont]['FontBBox'][1];
1949 }
1951 /**
1952 * return the font decender, this will normally return a negative number
1953 * if you add this number to the baseline, you get the level of the bottom of the font
1954 * it is in the pdf user units
1955 */
1957 // note that this will most likely return a negative value
1960 }
1963 }
1965 /**
1966 * filter the text, this is applied to all text just before being inserted into the pdf document
1967 * it escapes the various things that need to be escaped, and so on
1968 *
1969 * @access private
1970 */
1982 }
1984 /**
1985 * given a start position and information about how text is to be laid out, calculate where
1986 * on the page the text will end
1987 *
1988 * @access private
1989 */
1991 // given this information return an array containing x and y for the end position as elements 0 and 1
1993 // need to adjust for the number of spaces in this text
1999 }
2001 /**
2002 * wrapper function for PRVTcheckTextDirective1
2003 *
2004 * @access private
2005 */
2010 }
2012 /**
2013 * checks if the text stream contains a control directive
2014 * if so then makes some changes and returns the number of characters involved in the directive
2015 * this has been re-worked to include everything neccesary to fins the current writing point, so that
2016 * the location can be sent to the callback function if required
2017 * if the directive does not require a font change, then $f should be set to 0
2018 *
2019 * @access private
2020 */
2021 function PRVTcheckTextDirective1(&$text,$i,&$f,$final,&$x,&$y,$size=0,$angle=0,$wordSpaceAdjust=0){
2031 }
2039 // then there is one to remove
2040 $this->currentTextState = substr($this->currentTextState,0,$p).substr($this->currentTextState,$p+1);
2041 }
2043 }
2046 // this this might be a callback function
2050 // then this will be treated as a callback directive
2053 // split the remainder on colons to get the function name and the paramater
2062 }
2066 // only call the function if this is the final call
2068 // need to assess the text position, calculate the text width to this point
2069 // can use getTextWidth to find the text width I think
2071 $info = array('x'=>$tmp[0],'y'=>$tmp[1],'angle'=>$angle,'status'=>'end','p'=>$parm,'nCallback'=>$this->nCallback);
2076 // then the return from the callback function could set the position, to start with, later will do font colour, and font
2083 }
2084 }
2085 }
2086 // also remove from to the stack
2087 // for simplicity, just take from the end, fix this another day
2091 }
2092 }
2093 }
2094 }
2096 }
2104 }
2109 // this this might be a callback function
2113 // then this will be treated as a callback directive
2116 // split the remainder on colons to get the function name and the paramater
2117 // $bits = explode(':',substr($text,$j+1,$k-$j-1));
2126 }
2130 // only call the function if this is the final call, ie, the one actually doing printing, not measurement
2132 // need to assess the text position, calculate the text width to this point
2133 // can use getTextWidth to find the text width I think
2134 // also add the text height and decender
2136 $info = array('x'=>$tmp[0],'y'=>$tmp[1],'angle'=>$angle,'status'=>'start','p'=>$parm,'f'=>$func,'height'=>$this->getFontHeight($size),'decender'=>$this->getFontDecender($size));
2140 // only add to the stack if this is a small 'c', therefore is a start-stop pair
2144 }
2147 // then the return from the callback function could set the position, to start with, later will do font colour, and font
2154 }
2155 }
2156 }
2157 }
2158 }
2159 }
2161 }
2162 }
2164 }
2166 /**
2167 * add text to the document, at a specified location, size and angle on the page
2168 */
2172 // if there are any open callbacks, then they should be called, to show the start of the line
2175 // call each function
2176 $info = array('x'=>$x,'y'=>$y,'angle'=>$angle,'status'=>'sol','p'=>$this->callback[$i]['p'],'nCallback'=>$this->callback[$i]['nCallback'],'height'=>$this->callback[$i]['height'],'decender'=>$this->callback[$i]['decender']);
2179 }
2180 }
2182 $this->objects[$this->currentContents]['c'].="\n".'BT '.sprintf('%.3f',$x).' '.sprintf('%.3f',$y).' Td';
2186 $tmp .= sprintf('%.3f',cos($a)).' '.sprintf('%.3f',(-1.0*sin($a))).' '.sprintf('%.3f',sin($a)).' '.sprintf('%.3f',cos($a)).' ';
2189 }
2193 }
2200 // then we should write what we need to
2203 $this->objects[$this->currentContents]['c'].=' /F'.$this->currentFontNum.' '.sprintf('%.1f',$size).' Tf ';
2205 }
2207 // then there was nothing drastic done here, restore the contents
2214 $directive = $this->PRVTcheckTextDirective1($text,$i,$f,1,$xp,$yp,$size,$angle,$wordSpaceAdjust);
2216 // restart the text object
2218 $this->objects[$this->currentContents]['c'].="\n".'BT '.sprintf('%.3f',$xp).' '.sprintf('%.3f',$yp).' Td';
2222 $tmp .= sprintf('%.3f',cos($a)).' '.sprintf('%.3f',(-1.0*sin($a))).' '.sprintf('%.3f',sin($a)).' '.sprintf('%.3f',cos($a)).' ';
2225 }
2229 }
2230 }
2231 // and move the writing point to the next piece of text
2234 }
2236 }
2239 $this->objects[$this->currentContents]['c'].=' /F'.$this->currentFontNum.' '.sprintf('%.1f',$size).' Tf ';
2241 }
2244 // if there are any open callbacks, then they should be called, to show the end of the line
2247 // call each function
2249 $info = array('x'=>$tmp[0],'y'=>$tmp[1],'angle'=>$angle,'status'=>'eol','p'=>$this->callback[$i]['p'],'nCallback'=>$this->callback[$i]['nCallback'],'height'=>$this->callback[$i]['height'],'decender'=>$this->callback[$i]['decender']);
2252 }
2253 }
2255 }
2257 /**
2258 * calculate how wide a given text string will be on a page, at a given size.
2259 * this can be called externally, but is alse used by the other class functions
2260 */
2262 // this function should not change any of the settings, though it will need to
2263 // track any directives which change during calculation, so copy them at the start
2264 // and put them back at the end.
2269 }
2271 // converts a number or a float to a string so it can get the width
2274 // hmm, this is where it all starts to get tricky - use the font information to
2275 // calculate the width of each character, add them up and convert to user units
2286 }
2291 // then this character is being replaced by another
2295 }
2298 }
2299 }
2300 }
2306 }
2308 /**
2309 * do a part of the calculation for sorting out the justification of the text
2310 *
2311 * @access private
2312 */
2326 // count the number of words
2333 }
2335 }
2336 }
2338 /**
2339 * add text to the page, but ensure that it fits within a certain width
2340 * if it does not fit then put in as much as possible, splitting at word boundaries
2341 * and return the remainder.
2342 * justification and angle can also be specified for the text
2343 */
2345 // this will display the text, and if it goes beyond the width $width, will backtrack to the
2346 // previous space or hyphen, and return the remainder of the text.
2348 // $justification can be set to 'left','right','center','centre','full'
2350 // need to store the initial text state, as this will change during the width calculation
2351 // but will need to be re-set before printing, so that the chars work out right
2356 // error, pretend it printed ok, otherwise risking a loop
2358 }
2372 }
2377 // then this character is being replaced by another
2381 }
2385 }
2387 // then we need to truncate this line
2389 // then we have somewhere that we can split :)
2394 }
2398 // reset the text state
2403 }
2406 // just split before the current character
2412 }
2415 // reset the text state
2420 }
2422 }
2423 }
2427 }
2433 }
2435 }
2436 }
2437 }
2438 // then there was no need to break this line
2441 }
2445 // reset the text state
2450 }
2452 }
2454 /**
2455 * this will be called at a new page to return the state to what it was on the
2456 * end of the previous page, before the stack was closed down
2457 * This is to get around not being able to have open 'q' across pages
2458 *
2459 */
2462 // this will be called at a new page to return the state to what it was on the
2463 // end of the previous page, before the stack was closed down
2464 // This is to get around not being able to have open 'q' across pages
2469 // $this->currentLineStyle = $opt['lin'];
2476 );
2477 }
2479 }
2481 /**
2482 * restore a previously saved state
2483 */
2493 }
2495 }
2497 /**
2498 * make a loose object, the output will go into this object, until it is closed, then will revert to
2499 * the current one.
2500 * this object will not appear until it is included within a page.
2501 * the function will return the object number
2502 */
2506 // add a new object of the content type, to hold the data flow
2513 }
2515 /**
2516 * open an existing object for editing
2517 */
2522 // also if this object is the primary contents for a page, then set the current page to its parent
2525 }
2526 }
2528 /**
2529 * close an object
2530 */
2532 // close the object, as long as there was one open in the first place, which will be indicated by
2533 // an objectId on the stack.
2538 // easier to probably not worry about removing the old entries, they will be overwritten
2539 // if there are new ones.
2540 }
2541 }
2543 /**
2544 * stop an object from appearing on pages from this point on
2545 */
2547 // if an object has been appearing on pages up to now, then stop it, this page will
2548 // be the last one that could contian it.
2551 }
2552 }
2554 /**
2555 * after an object has been created, it wil only show if it has been added, using this function.
2556 */
2558 // add the specified object to the page
2560 // then it is a valid object, and it is not being added to itself
2563 // then this object is to be added to this page (done in the next block) and
2564 // all future new pages.
2568 // then the destination contents is the primary for the page
2569 // (though this object is actually added to that page)
2571 }
2578 }
2585 }
2596 }
2597 }
2598 }
2600 /**
2601 * add content to the documents info object
2602 */
2604 // this will only work if the label is one of the valid ones.
2605 // modify this so that arrays can be passed as well.
2606 // if $label is an array then assume that it is key=>value pairs
2607 // else assume that they are both scalar, anything else will probably error
2611 }
2614 }
2615 }
2617 /**
2618 * set the viewer preferences of the document, it is up to the browser to obey these.
2619 */
2621 // this will only work if the label is one of the valid ones.
2625 }
2628 }
2629 }
2631 /**
2632 * extract an integer from a position in a byte stream
2633 *
2634 * @access private
2635 */
2637 // return the integer represented by $num bytes from $pos within $data
2642 }
2644 }
2646 /**
2647 * add a PNG image into the document, from a file
2648 * this should work with remote files
2649 */
2651 // read in a png file, interpret it, then add to the system
2660 }
2665 }
2673 }
2674 }
2677 // set pointer
2680 // cycle through the file, identifying chunks
2688 // echo $chunkType.' - '.$chunkLen.'<br>';
2692 // this is where all the file information comes from
2700 //print_r($info);
2705 }
2709 }
2718 //this chunk can only occur once and it must occur after the PLTE chunk and before IDAT chunk
2719 //print "tRNS found, color type = ".$info['colorType']."<BR>";
2722 /* corresponding to entries in the plte chunk
2723 Alpha for palette index 0: 1 byte
2724 Alpha for palette index 1: 1 byte
2725 ...etc...
2726 */
2727 // there will be one entry for each palette entry. up until the last non-opaque entry.
2728 // set up an array, stretching over all palette entries which will be o (opaque) or 1 (transparent)
2735 }
2736 }
2740 /* corresponding to entries in the plte chunk
2741 Gray: 2 bytes, range 0 .. (2^bitdepth)-1
2742 */
2743 // $transparency['grayscale']=$this->PRVT_getBytes($data,$p+8,2); // g = grayscale
2748 /* corresponding to entries in the plte chunk
2749 Red: 2 bytes, range 0 .. (2^bitdepth)-1
2750 Green: 2 bytes, range 0 .. (2^bitdepth)-1
2751 Blue: 2 bytes, range 0 .. (2^bitdepth)-1
2752 */
2758 //unsupported transparency type
2759 }
2760 // KS End new code
2764 }
2767 }
2772 }
2776 }
2777 }
2782 }
2787 $errormsg = 'transparancey alpha channel not supported, transparency only supported for palette images.';
2802 }
2803 }
2804 }
2808 }
2811 }
2814 }
2815 //print_r($info);
2816 // so this image is ok... add it in.
2821 // $this->o_image($this->numObj,'new',array('label'=>$label,'data'=>$idata,'iw'=>$w,'ih'=>$h,'type'=>'png','ic'=>$info['width']));
2822 $options = array('label'=>$label,'data'=>$idata,'bitsPerComponent'=>$info['bitDepth'],'pdata'=>$pdata
2826 }
2830 $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$w)." 0 0 ".sprintf('%.3f',$h)." ".sprintf('%.3f',$x)." ".sprintf('%.3f',$y)." cm";
2833 }
2835 /**
2836 * add a JPEG image into the document, from a file
2837 */
2839 // attempt to add a jpeg image straight from a file, using no GD commands
2840 // note that this function is unable to operate on a remote file.
2844 }
2854 }
2858 }
2861 }
2864 }
2876 }
2878 /**
2879 * add an image into the document, from a GD object
2880 * this function is not all that reliable, and I would probably encourage people to use
2881 * the file based functions
2882 */
2884 // add a new image into the current location, as an external object
2885 // add the image at $x,$y, and with width and height as defined by $w & $h
2887 // note that this will only work with full colour images and makes them jpg images for display
2888 // later versions could present lossless image formats if there is interest.
2890 // there seems to be some problem here in that images that have quality set above 75 do not appear
2891 // not too sure why this is, but in the meantime I have restricted this to 75.
2894 }
2896 // if the width or height are set to zero, then set the other one based on keeping the image
2897 // height/width ratio the same, if they are both zero, then give up :)
2903 }
2906 }
2909 }
2911 // gotta get the data out of the img..
2913 // so I write to a temp file, and then read it back.. soo ugly, my apologies.
2926 }
2931 }
2932 // $data = fread($fp,filesize($tmpName));
2934 // fclose($fp);
2937 }
2939 /**
2940 * common code used by the two JPEG adding functions
2941 *
2942 * @access private
2943 */
2945 // note that this function is not to be called externally
2946 // it is just the common code between the GD and the file options
2951 $this->o_image($this->numObj,'new',array('label'=>$label,'data'=>$data,'iw'=>$imageWidth,'ih'=>$imageHeight,'channels'=>$channels));
2954 $this->objects[$this->currentContents]['c'].="\n".sprintf('%.3f',$w)." 0 0 ".sprintf('%.3f',$h)." ".sprintf('%.3f',$x)." ".sprintf('%.3f',$y)." cm";
2957 }
2959 /**
2960 * specify where the document should open when it first starts
2961 */
2963 // this function will open the document at a specified page, in a specified style
2964 // the values for style, and the required paramters are:
2965 // 'XYZ' left, top, zoom
2966 // 'Fit'
2967 // 'FitH' top
2968 // 'FitV' left
2969 // 'FitR' left,bottom,right
2970 // 'FitB'
2971 // 'FitBH' top
2972 // 'FitBV' left
2974 $this->o_destination($this->numObj,'new',array('page'=>$this->currentPage,'type'=>$style,'p1'=>$a,'p2'=>$b,'p3'=>$c));
2977 }
2979 /**
2980 * create a labelled destination within the document
2981 */
2983 // associates the given label with the destination, it is done this way so that a destination can be specified after
2984 // it has been linked to
2985 // styles are the same as the 'openHere' function
2987 $this->o_destination($this->numObj,'new',array('page'=>$this->currentPage,'type'=>$style,'p1'=>$a,'p2'=>$b,'p3'=>$c));
2989 // store the label->idf relationship, note that this means that labels can be used only once
2991 }
2993 /**
2994 * define font families, this is used to initialize the font families for the default fonts
2995 * and for the user to add new ones for their fonts. The default bahavious can be overridden should
2996 * that be desired.
2997 */
3001 // set the known family groups
3002 // these font families will be used to enable bold and italic markers to be included
3003 // within text streams. html forms will be used... <b></b> <i></i>
3009 );
3015 );
3021 );
3022 }
3024 // the user is trying to set a font family
3025 // note that this can also be used to set the base ones to something else
3028 }
3029 }
3030 }
3032 /**
3033 * used to add messages for use in debugging
3034 */
3037 }
3039 /**
3040 * a few functions which should allow the document to be treated transactionally.
3041 */
3045 // store all the data away into the checkpoint variable
3057 }
3060 // do not destroy the current checkpoint, but move us back to the state then, so that we can try again
3062 // can only abort if were inside a checkpoint
3067 }
3068 }
3070 }
3074 // can only abort if were inside a checkpoint
3078 }
3080 }
3082 }
3084 }
3088 ?>