]> git.llucax.com Git - mecon/meconlib.git/blob - lib/MLIB/PDF/external/phppdflib.class.php
Se agrega un ejemplo sobre la utilizacion de los PDF con la nueva clase
[mecon/meconlib.git] / lib / MLIB / PDF / external / phppdflib.class.php
1 <?php
2 /*
3    php pdf generation library
4    Copyright (C) Potential Technologies 2002 - 2003
5    http://www.potentialtech.com
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20
21    $Id: phppdflib.class.php,v 2.6 2003/08/29 21:15:21 wmoran Exp $
22 */
23
24 class pdffile
25 {
26     /* $objects is an array that stores the objects
27      * that will become the pdf when ->generate()
28      * is called.
29      * The layout of ->objects does not directly
30      * mimic the pdf format, although it is similar.
31      * nextoid always holds the next available oid ( oid is short for object id )
32      */
33     var $objects, $nextoid;
34
35     /* xreftable is an array containing data to
36      * create the xref section (PDF calls it a referance table)
37      */
38     var $xreftable, $nextobj;
39
40     /* These arrays allow quick translation between
41      * pdflib OIDs and the final PDF OIDs (OID stands for object ids)
42      */
43     var $libtopdf, $pdftolib;
44
45     // Errors
46     var $ermsg = array(), $erno = array();
47
48     var $builddata;         // Various data required during the pdf build
49     var $nextpage;          // Tracks the next page number
50     var $widths, $needsset; // Store the font width arrays here
51     var $default;           // Default values for objects
52     var $x, $chart, $template;  // extension class is instantiated here if requested
53     /* Constructor function: is automatically called when the
54      * object is created.  Used to set up the environment
55      */
56     function pdffile()
57     {
58         /* Per spec, obj 0 should always have a generation
59          * number of 65535 and is always free
60          */
61         $this->xreftable[0]["gennum"] = 65535;
62         $this->xreftable[0]["offset"] = 0;
63         $this->xreftable[0]["free"] = "f";
64
65         // Object #1 will always be the Document Catalog
66         $this->xreftable[1]["gennum"] = 0;
67         $this->xreftable[1]["free"] = "n";
68
69         // Object #2 will always be the root pagenode
70         $this->xreftable[2]["gennum"] = 0;
71         $this->xreftable[2]["free"] = "n";
72         $this->pdftolib[2] = 1;
73         $this->libtopdf[1] = 2;
74
75         // Object #3 is always the resource library
76         $this->xreftable[3]["gennum"] = 0;
77         $this->xreftable[3]["free"] = "n";
78
79         /* nextoid starts at 2 because all
80          * drawing functions return either the
81          * object ID or FALSE on error, so we can't
82          * return an OID of 0, because it equates
83          * to false and error checking would think
84          * the procedure failed
85          */
86         $this->nextoid = 2;
87         $this->nextobj = 3;
88
89         // Pages start at 0
90         $this->nextpage = 0;
91
92         // Font width tables are not set unless they are needed
93         $this->needsset = true;
94
95         // Set all the default values
96         $t['pagesize'] = 'letter';
97         $t['font'] = 'Helvetica';
98         $t['height'] = 12;
99         $t['align'] = 'left';
100         $t['width'] = 1;
101         $t['rotation'] = 0;
102         $t['scale'] = 1;
103         $t['strokecolor'] = $this->get_color('black');
104         $t['fillcolor'] = $this->get_color('black');
105         $t['margin-left'] = $t['margin-right'] = $t['margin-top'] = $t['margin-bottom'] =72;
106         $t['tmode'] = 0; // Text: fill
107         $t['smode'] = 1; // Shapes: stroke
108         $this->default = $t;
109     }
110
111 /******************************************************
112  * These functions are the public ones, they are the  *
113  * way that the user will actually enter the data     *
114  * that will become the pdf                           *
115  ******************************************************/
116
117     function set_default($setting, $value)
118     {
119         switch ($setting) {
120         case 'margin' :
121             $this->default['margin-left'] = $value;
122             $this->default['margin-right'] = $value;
123             $this->default['margin-top'] = $value;
124             $this->default['margin-bottom'] = $value;
125             break;
126
127         case 'mode' :
128             $this->default['tmode'] = $this->default['smode'] = $value;
129             break;
130
131         default :
132             $this->default[$setting] = $value;
133         }
134         return true;
135     }
136     
137     function draw_rectangle($top, $left, $bottom, $right, $parent, $attrib = array())
138     {
139         if ($this->objects[$parent]["type"] != "page") {
140             $this->_push_std_error(6001);
141             return false;
142         }
143         $o = $this->_addnewoid();
144         $attrib = $this->_resolve_param($attrib, false);
145         $this->_resolve_colors($n, $attrib);
146         $this->objects[$o] = $n;
147         $this->objects[$o]["width"] = $attrib["width"];
148         $this->objects[$o]["type"] = "rectangle";
149         $this->_adjust_margin($left, $top, $parent);
150         $this->_adjust_margin($right, $bottom, $parent);
151         $this->objects[$o]["top"] = $top;
152         $this->objects[$o]["left"] = $left;
153         $this->objects[$o]["bottom"] = $bottom;
154         $this->objects[$o]["right"] = $right;
155         $this->objects[$o]["parent"] = $parent;
156         $this->objects[$o]["mode"] = $this->_resolve_mode($attrib, 'smode');
157         return $o;
158     }
159
160     function draw_circle($x, $y, $r, $parent, $attrib = array())
161     {
162         if ($this->objects[$parent]["type"] != "page") {
163             $this->_push_std_error(6001);
164             return false;
165         }
166         $o = $this->_addnewoid();
167         $attrib = $this->_resolve_param($attrib, false);
168         $this->_resolve_colors($n, $attrib);
169         $n['width'] = $attrib['width'];
170         $this->_adjust_margin($x, $y, $parent);
171         $n['x'] = $x;
172         $n['y'] = $y;
173         $n['radius'] = $r;
174         $n['type'] = 'circle';
175         $n['parent'] = $parent;
176         $n['mode'] = $this->_resolve_mode($attrib, 'smode');
177         $this->objects[$o] = $n;
178         return $o;
179     }
180
181     function draw_line($x, $y, $parent, $attrib = array())
182     {
183         if ($this->objects[$parent]["type"] != "page") {
184             $this->_push_std_error(6001);
185             return false;
186         }
187         if (count($x) != count($y)) {
188             $this->_push_error(6002, "X & Y variables must have equal number of elements");
189             return false;
190         }
191         $o = $this->_addnewoid();
192         $attrib = $this->_resolve_param($attrib, false);
193         $this->_resolve_colors($n, $attrib);
194         $this->objects[$o] = $n;
195         @$this->objects[$o]["width"] = $attrib["width"];
196         $this->objects[$o]['mode'] = $this->_resolve_mode($attrib, 'smode');
197         $this->objects[$o]["type"] = "line";
198         foreach ($x as $key => $value) {
199             if (isset($x[$key]) && isset($y[$key])) {
200                 $this->_adjust_margin($x[$key], $y[$key], $parent);
201             }
202         }
203         $this->objects[$o]["x"] = $x;
204         $this->objects[$o]["y"] = $y;
205         $this->objects[$o]["parent"] = $parent;
206         return $o;
207     }
208
209     // draw text
210     function draw_text($left, $bottom, $text, $parent, $attrib = array())
211     {
212         if ($this->objects[$parent]["type"] != "page") {
213             $this->_push_std_error(6001);
214             return false;
215         }
216         $attrib = $this->_resolve_param($attrib);
217         // Validate the font
218         if (!($n["font"] = $this->_use_font($attrib))) {
219             // Couldn't find/add the font
220             $this->_push_error(6003, "Font was not found");
221             return false;
222         }
223         if (isset($attrib["rotation"])) {
224             $n["rotation"] = $attrib["rotation"];
225         }
226         $n['mode'] = $this->_resolve_mode($attrib, 'tmode');
227         if (isset($attrib["height"]) && $attrib["height"] > 0) {
228            $n["height"] = $attrib["height"];
229         }
230         $this->_resolve_colors($n, $attrib);
231         $n["type"] = "texts";
232         $this->_adjust_margin($left, $bottom, $parent);
233         $n["left"] = $left;
234         $n["bottom"] = $bottom;
235         $n["text"] = $text;
236         $n["parent"] = $parent;
237
238         $o = $this->_addnewoid();
239         $this->objects[$o] = $n;
240         return $o;
241     }
242
243     function new_page($size = null)
244     {
245         if (is_null($size)) {
246             $size = $this->default['pagesize'];
247         }
248         switch ($size) {
249         case "letter" :
250             $o = $this->_addnewoid();
251             $this->objects[$o]["height"] = 792;
252             $this->objects[$o]["width"] = 612;
253             break;
254
255         case "legal" :
256             $o = $this->_addnewoid();
257             $this->objects[$o]["height"] = 1008;
258             $this->objects[$o]["width"] = 612;
259             break;
260
261         case "executive" :
262             $o = $this->_addnewoid();
263             $this->objects[$o]["height"] = 720;
264             $this->objects[$o]["width"] = 540;
265             break;
266
267         case "tabloid" :
268             $o = $this->_addnewoid();
269             $this->objects[$o]["height"] = 1224;
270             $this->objects[$o]["width"] = 792;
271             break;
272
273         case "a3" :
274             $o = $this->_addnewoid();
275             $this->objects[$o]["height"] = 1188;
276             $this->objects[$o]["width"] = 842;
277             break;
278
279         case "a4" :
280             $o = $this->_addnewoid();
281             $this->objects[$o]["height"] = 842;
282             $this->objects[$o]["width"] = 595;
283             break;
284
285         case "a5" :
286             $o = $this->_addnewoid();
287             $this->objects[$o]["height"] = 598;
288             $this->objects[$o]["width"] = 418;
289             break;
290
291         default :
292             if (preg_match("/in/",$size)) {
293                 $o = $this->_addnewoid();
294                 $size = substr($size, 0, strlen($size) - 2);
295                 $dims = split("x",$size);
296                 $this->objects[$o]["height"] = ($dims[1] * 72);
297                 $this->objects[$o]["width"] = ($dims[0] * 72);
298             } else {
299                 if (preg_match("/cm/",$size)) {
300                     $o = $this->_addnewoid();
301                     $size = substr($size, 0, strlen($size) - 2);
302                     $dims = split("x",$size);
303                     $this->objects[$o]["height"] = ($dims[1] * 28.346);
304                     $this->objects[$o]["width"] = ($dims[0] * 28.346);
305                 } else {
306                     $this->_push_error(6004, "Could not deciper page size description: $size");
307                     return false;
308                 }
309
310             }
311         }
312         $this->objects[$o]['type'] = 'page';
313         $this->objects[$o]['parent'] = 1;
314         $this->objects[$o]['number'] = $this->nextpage;
315         $this->nextpage ++;
316         foreach (array('margin-left', 'margin-right', 'margin-top', 'margin-bottom') as $margin) {
317                 $this->objects[$o][$margin] = $this->default[$margin];
318         }
319         return $o;
320     }
321
322     function swap_pages($p1, $p2)
323     {
324         if ($this->objects[$p1]["type"] != "page" ||
325             $this->objects[$p2]["type"] != "page") {
326                 $this->_push_std_error(6001);
327                 return false;
328         }
329         $temp = $this->objects[$p1]["number"];
330         $this->objects[$p1]["number"] = $this->objects[$p2]["number"];
331         $this->objects[$p2]["number"] = $temp;
332         return true;
333     }
334
335     function move_page_before($page, $infrontof)
336     {
337         if ($this->objects[$page]["type"] != "page" ||
338             $this->objects[$infrontof]["type"] != "page") {
339                 $this->_push_std_error(6001);
340                 return false;
341         }
342         if ($page == $infrontof) {
343             $this->_push_error(6005, "You're trying to swap a page with itself");
344             return false;
345         }
346         $target = $this->objects[$infrontof]["number"];
347         $leaving = $this->objects[$page]["number"];
348         foreach ($this->objects as $id => $o) {
349             if ($o["type"] == "page") {
350                 if ($target < $leaving) {
351                     if ($o["number"] >= $target && $o["number"] < $leaving) {
352                         $this->objects[$id]["number"]++;
353                     }
354                 } else {
355                     if ($o["number"] < $target && $o["number"] > $leaving) {
356                         $this->objects[$id]["number"]--;
357                     }
358                 }
359             }
360         }
361         if ($target < $leaving) {
362             $this->objects[$page]["number"] = $target;
363         } else {
364             $this->objects[$page]["number"] = $target - 1;
365         }
366         return true;
367     }
368
369     function new_font($identifier)
370     {
371         $n["type"] = "font";
372
373         switch ($identifier) {
374         /* The "standard" Type 1 fonts
375          * These are "guaranteed" to be available
376          * to the viewer application and don't
377          * need embedded
378          */
379         case "Courier":
380         case "Courier-Bold":
381         case "Courier-Oblique":
382         case "Courier-BoldOblique":
383         case "Helvetica":
384         case "Helvetica-Bold":
385         case "Helvetica-Oblique":
386         case "Helvetica-BoldOblique":
387         case "Times-Roman":
388         case "Times-Bold":
389         case "Times-Italic":
390         case "Times-BoldItalic":
391         case "Symbol":
392         case "ZapfDingbats":
393             $o = $this->_addnewoid();
394             $this->builddata["fonts"][$o] = $identifier;
395             $n["subtype"] = "Type1";
396             $n["basefont"] = $identifier;
397             break;
398
399         default:
400             if ($this->objects[$identifier]["type"] != "fontembed") {
401                 $this->_push_error(6006, "Object must be of type 'fontembed'");
402                 return false;
403             } else {
404                 // Not ready yet
405                 $this->_push_error(6007, "Feature not implemented yet");
406                 return false;
407             }
408         }
409         $this->objects[$o] = $n;
410         return $o;
411     }
412
413     function generate($clevel = 9)
414     {
415         // Validate the compression level
416         if (!$clevel) {
417             $this->builddata["compress"] = false;
418         } else {
419             if ($clevel < 10) {
420                 $this->builddata["compress"] = $clevel;
421             } else {
422                 $this->builddata["compress"] = 9;
423             }
424         }
425         /* Preprocess objects to see if they can
426          * be combined into a single stream
427          * We scan through each page, and create
428          * a multistream object out of all viable
429          * child objects
430          */
431         $temparray = $this->objects;
432         foreach ($this->objects as $oid => $def) {
433             if ( $def["type"] == "page" ) {
434                 unset($temp);
435                 $temp['data'] = "";
436                 reset($temparray);
437                 while ( list ($liboid, $obj) = each($temparray) ) {
438                     if (isset($obj["parent"]) && $obj["parent"] == $oid) {
439                         switch ($obj["type"]) {
440                         case "texts" :
441                             $temp["data"] .= $this->_make_text($liboid);
442                             $this->objects[$liboid]["type"] = "null";
443                             $this->objects[$liboid]["parent"] = -1;
444                             break;
445
446                         case "rectangle" :
447                             $temp["data"] .= $this->_make_rect($liboid);
448                             $this->objects[$liboid]["type"] = "null";
449                             $this->objects[$liboid]["parent"] = -1;
450                             break;
451
452                         case "iplace" :
453                             $temp["data"] .= $this->_place_raw_image($liboid);
454                             $this->objects[$liboid]["type"] = "null";
455                             $this->objects[$liboid]["parent"] = -1;
456                             break;
457
458                         case "line" :
459                             $temp["data"] .= $this->_make_line($liboid);
460                             $this->objects[$liboid]["type"] = "null";
461                             $this->objects[$liboid]["parent"] = -1;
462                             break;
463
464                         case "circle" :
465                             $temp["data"] .= $this->_make_circle($liboid);
466                             $this->objects[$liboid]["type"] = "null";
467                             $this->objects[$liboid]["parent"] = -1;
468                             break;
469                         }
470                     }
471                 }
472                 if (strlen($temp["data"]) > 0) {
473                     // this line takes the next available oid
474                     $o = $this->_addnewoid();
475                     $temp["type"] = "mstream";
476                     $temp["parent"] = $oid;
477                     $this->objects[$o] = $temp;
478                 }
479             }
480         }
481         unset($temparray);
482
483         // Generate a list of PDF object IDs to
484         // use and map them to phppdflib IDs
485         foreach ( $this->objects as $oid => $properties ) {
486             if ( $this->_becomes_object( $properties["type"] ) ) {
487                 $o = $this->_addtoxreftable(0,0);
488                 $this->libtopdf[$oid] = $o;
489                 $this->pdftolib[$o] = $oid;
490             }
491         }
492
493         /* First characters represent the version
494          * of the PDF spec to conform to.
495          * The PDF spec recommends that the next
496          * four bytes be a comment containing four
497          * non-ASCII characters, to convince
498          * (for example) ftp programs that this is
499          * a binary file
500          */
501         $os = "%PDF-1.3%\xe2\xe3\xcf\xd3\x0a";
502
503         // Create the Document Catalog
504         $carray["Type"] = "/Catalog";
505         $carray["Pages"] = "2 0 R";
506         $temp = $this->_makedictionary($carray);
507         $temp = "1 0 obj" . $temp . "endobj\x0a";
508         $this->xreftable[1]["offset"] = strlen($os);
509         $os .= $temp;
510
511         // Create the root page node
512         unset($carray);
513         $kids = $this->_order_pages(2);
514         $this->xreftable[2]["offset"] = strlen($os);
515         $os .= "2 0 " . $this->_makepagenode($kids, "" ) . "\x0a";
516
517         /* Create a resource dictionary for the entire
518          * PDF file.  This may not be the most efficient
519          * way to store it, but it makes the code simple.
520          * At some point, we should analyze performance
521          * and see if it's worth splitting the resource
522          * dictionary up
523          */
524         unset($temp);
525         unset($carray);
526         if (isset($this->builddata["fonts"]) && count($this->builddata["fonts"]) > 0) {
527             foreach ($this->builddata["fonts"] as $id => $base) {
528                 $ta["F$id"] = $this->libtopdf[$id] . " 0 R";
529             }
530             $temp["Font"] = $this->_makedictionary($ta);
531         }
532         reset($this->objects);
533         while (list($id, $obj) = each($this->objects)) {
534             if ($obj["type"] == "image") {
535                 $xol["Img$id"] = $this->libtopdf[$id] . " 0 R";
536             }
537         }
538         if ( isset($xol) && count($xol) > 0 ) {
539             $temp["XObject"] = $this->_makedictionary($xol);
540         }
541         $this->xreftable[3]["offset"] = strlen($os);
542         $os .= "3 0 obj";
543         if (isset($temp)) {
544             $os .= $this->_makedictionary($temp);
545         } else {
546             $os .= '<<>>';
547         }
548         $os .= " endobj\x0a";
549
550         // Go through and add the rest of the objects
551         foreach ( $this->pdftolib as $pdfoid => $liboid ) {
552             if ($pdfoid < 4) {
553                 continue;
554             }
555             // Set the location of the start
556             $this->xreftable[$pdfoid]["offset"] = strlen($os);
557             switch ( $this->objects[$liboid]["type"] ) {
558             case "page":
559                 $kids = $this->_get_kids($pdfoid);
560                 $os .= $pdfoid . " 0 ";
561                 $os .= $this->_makepage($this->objects[$liboid]["parent"],
562                                         $kids, $liboid);
563                 break;
564
565             case "rectangle":
566                 $os .= $pdfoid . " 0 obj";
567                 $os .= $this->_streamify($this->_make_rect($liboid));
568                 $os .= " endobj";
569                 break;
570
571             case "line":
572                 $os .= $pdfoid . " 0 obj";
573                 $os .= $this->_streamify($this->_make_line($liboid));
574                 $os .= " endobj";
575                 break;
576
577             case "circle":
578                 $os .= $pdfoid . " 0 obj";
579                 $os .= $this->_streamify($this->_make_circle($liboid));
580                 $os .= " endobj";
581                 break;
582
583             case "texts":
584                 $os .= $pdfoid . " 0 obj";
585                 $temp = $this->_make_text($liboid);
586                 $os .= $this->_streamify($temp) . " endobj";
587                 break;
588
589             case "mstream":
590                 $os .= $pdfoid . " 0 obj" .
591                        $this->_streamify(trim($this->objects[$liboid]["data"])) .
592                        " endobj";
593                 break;
594
595             case "image":
596                 $os .= $pdfoid . " 0 obj";
597                 $os .= $this->_make_raw_image($liboid);
598                 $os .= " endobj";
599                 break;
600
601             case "iplace":
602                 $os .= $pdfoid . " 0 obj";
603                 $os .= $this->_streamify($this->_place_raw_image($liboid));
604                 $os .= " endobj";
605                 break;
606
607             case "font" :
608                 $os .= $pdfoid . " 0 obj";
609                 unset ( $temp );
610                 $temp["Type"] = "/Font";
611                 $temp["Subtype"] = "/" . $this->objects[$liboid]["subtype"];
612                 $temp["BaseFont"] = "/" . $this->objects[$liboid]["basefont"];
613                 $temp["Encoding"] = "/WinAnsiEncoding";
614                 $temp["Name"] = "/F$liboid";
615                 $os .= $this->_makedictionary($temp);
616                 $os .= " endobj";
617                 break;
618             }
619             $os .= "\x0a";
620         }
621
622         // Create an Info entry
623         $info = $this->_addtoxreftable(0,0);
624         $this->xreftable[$info]["offset"] = strlen($os);
625         unset($temp);
626         $temp["Producer"] =
627             $this->_stringify("phppdflib http://www.potentialtech.com/ppl.php");
628         $os .= $info . " 0 obj" . $this->_makedictionary($temp) . " endobj\x0a";
629
630         // Create the xref table
631         $this->builddata["startxref"] = strlen($os);
632         $os .= "xref\x0a0 " . (string)($this->nextobj + 1) . "\x0a";
633         for ( $i = 0; $i <= $this->nextobj; $i ++ ) {
634             $os .= sprintf("%010u %05u %s \x0a", $this->xreftable[$i]["offset"],
635                            $this->xreftable[$i]["gennum"],
636                            $this->xreftable[$i]["free"]);
637         }
638
639         // Create document trailer
640         $os .= "trailer\x0a";
641         unset($temp);
642         $temp["Size"] = $this->nextobj + 1;
643         $temp["Root"] = "1 0 R";
644         $temp["Info"] = $info . " 0 R";
645         $os .= $this->_makedictionary($temp);
646         $os .= "\x0astartxref\x0a";
647         $os .= $this->builddata["startxref"] . "\x0a";
648
649         // Required end of file marker
650         $os .= "%%EOF\x0a";
651
652         return $os;
653     }
654
655     function png_embed($data)
656     {
657         // Sanity, make sure this is a png
658         if (substr($data, 0, 8) != "\x89PNG\x0d\x0a\x1a\x0a") {
659             $this->_push_error(6011, 'brand not valid');
660             return false;
661         }
662         $data = substr($data, 12);
663         if (substr($data, 0, 4) != 'IHDR') {
664                 $this->_push_error(6011, 'IHDR chunk missing');
665             return false;
666         }
667         $data = substr($data, 4);
668         $width = $this->_int_val(substr($data, 0, 4));
669         $height = $this->_int_val(substr($data, 4, 4));
670         $data = substr($data, 8);
671         $bpc = ord(substr($data, 0, 1));
672         $ct  = ord(substr($data, 1, 1));
673         if ($bpc > 8) {
674             $this->_push_error(6014, '16 bit PNG unsupported');
675             return false;
676         }
677         switch ($ct) {
678         case 0 : $cspace = '/DeviceGray'; break;
679         case 2 : $cspace = '/DeviceRGB'; break;
680         case 3 : $cspace = '/Indexed'; break;
681         default:
682             $this->_push_error(6015, 'PNG with alpha not supported');
683             return false;
684         }
685         if (ord(substr($data, 2, 1)) != 0) {
686             $this->_push_error(6016, 'Unknown compression type');
687             return false;
688         }
689         if (ord(substr($data, 3, 1)) != 0) {
690             $this->_push_error(6017, 'Unknown PNG filter method');
691             return false;
692         }
693         if (ord(substr($data, 4, 1)) != 0) {
694             $this->_push_error(6018, 'PNG interlacing not supported');
695             return false;
696         }
697         $params['Predictor'] = '15';
698         $params['Colors'] = $ct == 2 ? 3 : 1;
699         $params['BitsPerComponent'] = $bpc;
700         $params['Columns'] = $width;
701         $additional['DecodeParms'] = $this->_makedictionary($params);
702         $data = substr($data, 9);
703         $pal = '';
704         $trns = '';
705         $rawdata = '';
706         do {
707             $n = $this->_int_val(substr($data, 0, 4));
708             $type = substr($data, 4, 4);
709             $data = substr($data, 8);
710             switch ($type) {
711             case 'PLTE' :
712                 $pal = substr($data, 0, $n);
713                 $data = substr($data, $n + 4);
714                 break;
715                 
716             case 'tRNS' :
717                 $t = substr($data, 0, $n);
718                 if ($ct == 0)
719                     $trns = array(ord(substr($t, 1, 1)));
720                 elseif ($ct == 2)
721                     $trns = array(ord(substr($t, 1, 1)),
722                                   ord(substr($t, 3, 1)),
723                                   ord(substr($t, 5, 1)));
724                 else {
725                     $pos = strpos($t, chr(0));
726                     if (is_int($pos))
727                         $trns = array($pos);
728                 }
729                 $data = substr($data, $n + 4);
730                 break;
731                 
732             case 'IDAT' :
733                 $rawdata .= substr($data, 0, $n);
734                 $data = substr($data, $n + 4);
735                 break;
736                 
737             case 'IEND' :
738                 break 2;
739             
740             default :
741                 $data = substr($data, $n + 4);
742             }
743         } while ($n);
744         if ($cspace == '/Indexed') {
745             $this->_push_error(6011, 'Indexed without palette');
746             return false;
747         }
748         return $this->image_raw_embed($rawdata,
749                                       $cspace,
750                                       $bpc,
751                                       $height,
752                                       $width,
753                                       '/FlateDecode',
754                                       $additional);
755     }
756
757     function jfif_embed($data)
758     {
759         /* Sanity check: Check magic numbers to see if
760          * this is really a JFIF stream
761          */
762         if ( substr($data, 0, 4) != "\xff\xd8\xff\xe0" ||
763              substr($data, 6, 4) != "JFIF" ) {
764             // This is not in JFIF format
765             $this->_push_std_error(6008);
766             return false;
767         }
768
769         /* Now we'll scan through all the markers in the
770          * JFIF and extract whatever data we need from them
771          * We're not being terribly anal about validating
772          * the structure of the JFIF, so a corrupt stream
773          * could have very unpredictable results
774          */
775         // Default values
776         $pos = 0;
777         $size = strlen($data);
778
779         while ( $pos < $size ) {
780             $marker = substr($data, $pos + 1, 1);
781             // Just skip these markers
782             if ($marker == "\xd8" || $marker == "\xd9" || $marker == "\x01") {
783                 $pos += 2;
784                 continue;
785             }
786             if ($marker == "\xff") {
787                 $pos ++;
788                 continue;
789             }
790
791             switch ($marker) {
792             // Start of frame
793             // Baseline
794             case "\xc0":
795             // Extended sequential
796             case "\xc1":
797             // Differential sequential
798             case "\xc5":
799             // Progressive
800             case "\xc2":
801             // differential progressive
802             case "\xc6":
803             // Lossless
804             case "\xc3":
805             // differential lossless
806             case "\xc7":
807             // Arithmetic encoded
808             case "\xc9":
809             case "\xca":
810             case "\xcb":
811             case "\xcd":
812             case "\xce":
813             case "\xcf":
814                 $precision = $this->_int_val(substr($data, $pos + 4, 1));
815                 $height = $this->_int_val(substr($data, $pos + 5, 2));
816                 $width = $this->_int_val(substr($data, $pos + 7, 2));
817                 $numcomp = $this->_int_val(substr($data, $pos + 9, 1));
818                 if ( $numcomp != 3 && $numcomp != 1 ) {
819                     // Abort if we aren't encoded as B&W or YCbCr
820                     $this->_push_std_error(6008);
821                     return false;
822                 }
823                 $pos += 2 + $this->_int_val(substr($data, $pos + 2, 2));
824                 break 2;
825             }
826
827             /* All marker identifications continue the
828              * loop, thus if we got here, we need to skip
829              * this marker as we don't understand it.
830              */
831             $pos += 2 + $this->_int_val(substr($data, $pos + 2, 2));
832         }
833         $cspace = $numcomp == 1 ? "/DeviceGray" : "/DeviceRGB";
834         return $this->image_raw_embed($data,
835                                       $cspace,
836                                       $precision,
837                                       $height,
838                                       $width,
839                                       "/DCTDecode");
840     }
841
842     function image_raw_embed($data,
843                              $cspace,
844                              $bpc,
845                              $height,
846                              $width,
847                              $filter = "",
848                              $addtl = array())
849     {
850         $o = $this->_addnewoid();
851         $t['additional'] = $addtl;
852         $t['data'] = $data;
853         $t['colorspace'] = $cspace;
854         $t['bpc'] = $bpc;
855         $t['type'] = "image";
856         $t['height'] = $height;
857         $t['width'] = $width;
858         $t['filter'] = $filter;
859         $this->objects[$o] = $t;
860         return $o;
861     }
862
863     function get_image_size($id)
864     {
865         if ($this->objects[$id]['type'] != 'image') {
866             $this->_push_std_error(6009);
867             return false;
868         }
869         $r['width'] = $this->objects[$id]['width'];
870         $r['height'] = $this->objects[$id]['height'];
871         return $r;
872     }
873
874     function image_place($oid, $bottom, $left, $parent, $param = array())
875     {
876         if ($this->objects[$oid]["type"] != "image") {
877             $this->_push_std_error(6009);
878             return false;
879         }
880         if ($this->objects[$parent]["type"] != "page") {
881             $this->_push_std_error(6001);
882             return false;
883         }
884
885         $o = $this->_addnewoid();
886         $param = $this->_resolve_param($param, false);
887         $t["type"] = "iplace";
888         $this->_adjust_margin($left, $bottom, $parent);
889         $t["bottom"] = $bottom;
890         $t["left"] = $left;
891         $t["parent"] = $parent;
892         // find out what the image size should be
893         $width = $this->objects[$oid]["width"];
894         $height = $this->objects[$oid]["height"];
895         $scale = $param['scale'];
896         if (is_array($scale)) {
897             $t["xscale"] = $scale["x"] * $width;
898             $t["yscale"] = $scale["y"] * $height;
899         } else {
900             $t["xscale"] = $scale * $width;
901             $t["yscale"] = $scale * $height;
902         }
903         $t["rotation"] = $param['rotation'];
904         $t["image"] = $oid;
905         $this->objects[$o] = $t;
906         return $o;
907     }
908
909     function strlen($string , $params = false, $tabwidth = 4)
910     {
911         if ($this->needsset) {
912             require_once(dirname(__FILE__) . '/strlen.inc.php');
913         }
914         if (empty($params["font"])) {
915             $font = $this->default['font'];
916         } else {
917             $font = $params["font"];
918             switch ($font) {
919                 case "Times-Roman" :
920                     $font = "Times";
921                     break;
922                 case "Helvetica-Oblique" :
923                     $font = "Helvetica";
924                     break;
925                 case "Helvetica-BoldOblique" :
926                     $font = "Helvetica-Bold";
927                     break;
928                 case "ZapfDingbats" :
929                     $font = "Dingbats";
930                     break;
931             }
932         }
933         if ($params["height"] == 0) {
934             $size = $this->default['height'];
935         } else {
936             $size = $params["height"];
937         }
938         $tab = '';
939         for ($i = 0; $i < $tabwidth; $i++) {
940                 $tab .= ' ';
941         }
942         $string = str_replace(chr(9), $tab, $string);
943         if (substr($font, 0, 7) == "Courier") {
944             // Courier is a fixed-width font
945             $width = strlen($string) * 600;
946         } else {
947             $width = 0;
948             $len = strlen($string);
949             for ($i = 0; $i < $len; $i++) {
950                 $width += $this->widths[$font][ord($string{$i})];
951             }
952         }
953         // We now have the string width in font units
954         return $width * $size / 1000;
955     }
956
957     function wrap_line(&$text, $width, $param = array())
958     {
959         $maxchars = (int)(1.1 * $width / $this->strlen("i", $param));
960         $words = explode(" ", substr($text, 0, $maxchars));
961         if ($this->strlen($words[0]) >= $width) {
962             $this->_push_error(3001, "Single token too long for allowed space");
963             $final = $words[0];
964         } else {
965             $space = $this->strlen(" ", $param);
966             $len = 0;
967             $word = 0;
968             $final = "";
969             while ($len < $width) {
970                 if ($word >= count($words)) {
971                     break;
972                 }
973                 $temp = $this->strlen($words[$word], $param);
974                 if ( ($len + $temp) <= $width) {
975                     $final .= $words[$word] . " ";
976                     $word ++;
977                 }
978                 $len += $space + $temp;
979             }
980         }
981         $text = substr($text, strlen($final));
982         return $final;
983     }
984
985     function word_wrap($words, $width, $param = array())
986     {
987         // break $words into an array separated by manual paragraph break character
988         $paragraph = explode("\n", $words);
989         // find the width of 1 space in this font
990         $swidth = $this->strlen( " " , $param );
991         // uses each element of $paragraph array and splits it at spaces
992         for ($lc = 0; $lc < count($paragraph); $lc++){
993             while (strlen($paragraph[$lc]) > 0) {
994                 $returnarray[] = $this->wrap_line($paragraph[$lc], $width, $param);
995             }
996         }
997         return $returnarray;
998     }
999
1000     function draw_one_paragraph($top, $left, $bottom, $right, $text, $page, $param = array())
1001     {
1002         $param = $this->_resolve_param($param);
1003         $height = 1.1 * $param['height'];
1004         $width = $right - $left;
1005         while ($top > $bottom) {
1006             if (strlen($text) < 1) {
1007                 break;
1008             }
1009             $top -= $height;
1010             if ($top >= $bottom) {
1011                 $line = $this->wrap_line($text, $width, $param);
1012                 switch ($param['align']) {
1013                 case 'right' :
1014                     $line = trim($line);
1015                     $l = $right - $this->strlen($line, $param);
1016                     break;
1017
1018                 case 'center' :
1019                     $line = trim($line);
1020                     $l = $left + (($width - $this->strlen($line, $param)) / 2);
1021                     break;
1022                 
1023                 default :
1024                     $l = $left;
1025                 }
1026                 $this->draw_text($l, $top, $line, $page, $param);
1027             } else {
1028                 $top += $height;
1029                 break;
1030             }
1031         }
1032         if (strlen($text) > 0) {
1033             return $text;
1034         } else {
1035             return $top;
1036         }
1037     }
1038
1039     function draw_paragraph($top, $left, $bottom, $right, $text, $page, $param = array())
1040     {
1041         $paras = split("\n", $text);
1042         for ($i = 0; $i < count($paras); $i++) {
1043             $over = $this->draw_one_paragraph($top,
1044                                               $left,
1045                                               $bottom,
1046                                               $right,
1047                                               $paras[$i],
1048                                               $page,
1049                                               $param);
1050             if (is_string($over)) {
1051                 break;
1052             }
1053             $top = $over;
1054         }
1055         $rv = $over;
1056         if ($i < count($paras)) {
1057             for ($x = $i + 1; $x < count($paras); $x++) {
1058                 $rv .= "\n" . $paras[$x];
1059             }
1060         }
1061         return $rv;
1062     }
1063
1064     function error_array()
1065     {
1066         $rv = array();
1067         while (count($this->ermsg) > 0) {
1068             $this->pop_error($num, $msg);
1069             $rv[] = "Error $num: $msg";
1070         }
1071         return $rv;
1072     }
1073
1074     function pop_error(&$num, &$msg)
1075     {
1076         $num = array_pop($this->erno);
1077         $msg = array_pop($this->ermsg);
1078         if (is_null($num)) {
1079                 return false;
1080         } else {
1081                 return $num;
1082         }
1083     }
1084
1085     function enable($name)
1086     {
1087         $name = strtolower($name);
1088         @include_once(dirname(__FILE__) . "/${name}.class.php");
1089         $this->x[$name] = new $name;
1090         $this->x[$name]->pdf = &$this;
1091         switch ($name) {
1092         case 'chart' :
1093         case 'template' :
1094                 $this->$name = &$this->x[$name];
1095             break;
1096         }
1097     }
1098
1099     function get_color($desc)
1100     {
1101
1102         $r = array();
1103         switch (strtolower($desc)) {
1104         case 'black' :
1105             $r['red'] = $r['blue'] = $r['green'] = 0;
1106             break;
1107
1108         case 'white' :
1109             $r['red'] = $r['blue'] = $r['green'] = 1;
1110             break;
1111             
1112         case 'red' :
1113             $r['red'] = 1;
1114             $r['blue'] = $r['green'] = 0;
1115             break;
1116             
1117         case 'blue' :
1118             $r['blue'] = 1;
1119             $r['red'] = $r['green'] = 0;
1120             break;
1121
1122         case 'green' :
1123             $r['green'] = 1;
1124             $r['blue'] = $r['red'] = 0;
1125             break;
1126
1127         default :
1128                 if (substr($desc, 0, 1) == '#') {
1129                 // Parse out a hex triplet
1130                 $v = substr($desc, 1, 2);
1131                 $r['red'] = eval("return ord(\"\\x$v\");") / 255;
1132                 $v = substr($desc, 3, 2);
1133                 $r['green'] = eval("return ord(\"\\x$v\");") / 255;
1134                 $v = substr($desc, 5, 2);
1135                 $r['blue'] = eval("return ord(\"\\x$v\");") / 255;
1136             } else {
1137                 // Error condition?
1138                 $this->_push_error(6012, "Unparsable color identifier: $desc");
1139                 $r = false;
1140             }
1141         }
1142         return $r;
1143     }
1144
1145 /******************************************************
1146  * These functions are internally used by the library *
1147  * and shouldn't really be called by a user of        *
1148  * phppdflib                                          *
1149  ******************************************************/
1150
1151     function _resolve_mode($attrib, $mode)
1152     {
1153         $rmode = $attrib[$mode];
1154         if ($rmode != 0) {
1155             $r = $rmode;
1156         } else {
1157             switch ($rmode) {
1158             case "fill":
1159                 $r = 0;
1160                 break;
1161
1162             case "stroke":
1163                 $r = 1;
1164                 break;
1165
1166             case "fill+stroke":
1167                 $r = 2;
1168                 break;
1169             }
1170         }
1171         return $r;
1172     }
1173
1174     function _adjust_margin(&$x, &$y, $page)
1175     {
1176         $x += $this->objects[$page]['margin-left'];
1177         $y += $this->objects[$page]['margin-bottom'];
1178     }
1179
1180     function _resolve_param($param, $text = true)
1181     {
1182         $rv = $this->default;
1183         if (is_array($param)) {
1184             if (isset($param['mode'])) {
1185                 $param['tmode'] = $param['smode'] = $param['mode'];
1186             }
1187             foreach ($param as $key => $value) {
1188                 $rv[$key] = $value;
1189             }
1190         }
1191         return $rv;
1192     }
1193     
1194     function _push_error($num, $msg)
1195     {
1196         array_push($this->erno, $num);
1197         array_push($this->ermsg, $msg);
1198     }
1199
1200     function _push_std_error($num)
1201     {
1202         switch ($num) {
1203             case 6001 : $m = "Object must be of type 'page'"; break;
1204             case 6008 : $m = "Data stream not recognized as JFIF"; break;
1205             case 6009 : $m = "Object must be of type 'image'"; break;
1206             case 6011 : $m = "Data stream not recognized as PNG"; break;
1207             default : $m = "_push_std_error() called with invalid error number: $num"; break;
1208         }
1209         $this->_push_error($num, $m);
1210     }
1211
1212     function _resolve_colors(&$n, $attrib)
1213     {
1214         $temp = array('red','green','blue');
1215         foreach ($temp as $colcomp) {
1216             if (isset($attrib['fillcolor'][$colcomp])) {
1217                 $n['fillcolor'][$colcomp] = $attrib['fillcolor'][$colcomp];
1218             }
1219             if (isset($attrib['strokecolor'][$colcomp])) {
1220                 $n['strokecolor'][$colcomp] = $attrib['strokecolor'][$colcomp];
1221             }
1222         }
1223     }
1224
1225     /* Check to see if a requested font is already in the
1226      * list, if not add it.  Either way, return the libid
1227      * of the font
1228      */
1229     function _use_font($id)
1230     {
1231         if (!isset($id['font'])) {
1232             $id['font'] = $this->default['font'];
1233         }
1234         if ( isset($this->builddata["fonts"]) && count($this->builddata["fonts"]) > 0 ) {
1235             foreach ($this->builddata["fonts"] as $libid => $name) {
1236                 if ($name == $id['font']) {
1237                     return $libid;
1238                 }
1239             }
1240         }
1241         /* The font isn't in the table, so we add it
1242          * and return it's ID
1243          */
1244         return $this->new_font($id['font']);
1245     }
1246
1247     /* Convert a big-endian byte stream into an integer */
1248     function _int_val($string)
1249     {
1250         $r = 0;
1251         for ($i = 0; $i < strlen($string); $i ++ ) {
1252             $r += ord($string{$i}) * pow(256, strlen($string) - $i -1);
1253         }
1254         return $r;
1255     }
1256
1257     function _make_raw_image($liboid)
1258     {
1259         if (is_array($this->objects[$liboid]['additional']))
1260             $s = $this->objects[$liboid]['additional'];
1261         $s["Type"] = "/XObject";
1262         $s["Subtype"] = "/Image";
1263         $s["Width"] = $this->objects[$liboid]["width"];
1264         $s["Height"] = $this->objects[$liboid]["height"];
1265         $s["ColorSpace"] = $this->objects[$liboid]["colorspace"];
1266         $s["BitsPerComponent"] = $this->objects[$liboid]["bpc"];
1267         if (strlen($this->objects[$liboid]["filter"]) > 0) {
1268             $s["Filter"] = $this->objects[$liboid]["filter"];
1269         }
1270         return $this->_streamify($this->objects[$liboid]["data"], $s);
1271     }
1272
1273     function _place_raw_image($liboid)
1274     {
1275         $xscale = $this->objects[$liboid]["xscale"];
1276         $yscale = $this->objects[$liboid]["yscale"];
1277         $angle = $this->objects[$liboid]["rotation"];
1278         $temp = "q 1 0 0 1 " .
1279                 $this->objects[$liboid]["left"] . " " .
1280                 $this->objects[$liboid]["bottom"] . " cm ";
1281         if ($angle != 0) {
1282             $temp .= $this->_rotate($angle) . " cm ";
1283         }
1284         if ($xscale != 1 || $yscale != 1) {
1285             $temp .= "$xscale 0 0 $yscale 0 0 cm ";
1286         }
1287         $temp .= "/Img" . $this->objects[$liboid]["image"] .
1288                  " Do Q\x0a";
1289         return $temp;
1290     }
1291
1292     function _rotate($angle)
1293     {
1294         $a = deg2rad($angle);
1295         $cos = cos($a);
1296         $sin = sin($a);
1297         $r = sprintf("%1\$1.6f %2\$1.6f %3\$1.6f %1\$1.6f 0 0", $cos, $sin, -$sin);
1298         return $r;
1299     }
1300
1301     function _get_operator($liboid)
1302     {
1303         switch ($this->objects[$liboid]['mode']) {
1304         case 0 : return "f"; break;
1305         case 1 : return "S"; break;
1306         case 2 : return "b"; break;
1307         }
1308     }
1309
1310     function _make_line($liboid)
1311     {
1312         $gstate = "";
1313         if ( $colortest = $this->_colorset($liboid) ) {
1314             $gstate .= $colortest . " ";
1315         }
1316         if ( isset($this->objects[$liboid]["width"]) && $this->objects[$liboid]["width"] != 1 ) {
1317             $gstate .= $this->objects[$liboid]["width"] . " w ";
1318         }
1319         $firstpoint = true;
1320         $temp = "";
1321         foreach ($this->objects[$liboid]["x"] as $pointid => $x) {
1322             $y = $this->objects[$liboid]["y"][$pointid];
1323             $temp .= $x . " " . $y . " ";
1324             if ($firstpoint) {
1325                 $temp .= "m ";
1326                 $firstpoint = false;
1327             } else {
1328                 $temp .= "l ";
1329             }
1330         }
1331         $temp .= $this->_get_operator($liboid);
1332         if ( strlen($gstate) > 0 ) {
1333             $temp = "q " . $gstate . $temp . " Q";
1334         }
1335         return $temp . "\x0a";
1336     }
1337
1338     function _make_rect($liboid)
1339     {
1340         $gstate = "";
1341         if ( $colortest = $this->_colorset($liboid) ) {
1342             $gstate .= $colortest . " ";
1343         }
1344         if ( isset($this->objects[$liboid]["width"]) && $this->objects[$liboid]["width"] != 1 ) {
1345             $gstate .= $this->objects[$liboid]["width"] . " w ";
1346         }
1347         $temp = $this->objects[$liboid]["left"] . " ";
1348         $temp .= $this->objects[$liboid]["bottom"];
1349         $temp .= " " . ( $this->objects[$liboid]["right"]
1350                  - $this->objects[$liboid]["left"] );
1351         $temp .= " " . ( $this->objects[$liboid]["top"]
1352                  - $this->objects[$liboid]["bottom"] );
1353         $temp .= ' re ';
1354         $temp .= $this->_get_operator($liboid);
1355         if ( strlen($gstate) > 0 ) {
1356             $temp = "q " . $gstate . $temp . " Q";
1357         }
1358         return $temp . "\x0a";
1359     }
1360
1361     function _make_circle($liboid)
1362     {
1363         $gstate = "";
1364         if ( $colortest = $this->_colorset($liboid) ) {
1365             $gstate .= $colortest . " ";
1366         }
1367         if ( isset($this->objects[$liboid]["width"]) && $this->objects[$liboid]["width"] != 1 ) {
1368             $gstate .= $this->objects[$liboid]["width"] . " w ";
1369         }
1370         $r = $this->objects[$liboid]['radius'];
1371         $x = $this->objects[$liboid]['x'];
1372         $y = $this->objects[$liboid]['y'];
1373         $ql = $x - $r;
1374         $pt = $y + $r * 1.33333;
1375         $qr = $x + $r;
1376         $pb = $y - $r * 1.33333;
1377         $temp = "$ql $y m ";
1378         $temp .= "$ql $pt $qr $pt $qr $y c ";
1379         $temp .= "$qr $pb $ql $pb $ql $y c ";
1380         $temp .= $this->_get_operator($liboid);
1381         if ( strlen($gstate) > 0 ) {
1382             $temp = "q " . $gstate . $temp . " Q";
1383         }
1384         return $temp . "\x0a";
1385     }
1386
1387     function _make_text($liboid)
1388     {
1389         $statechange = ""; $locateinbt = true;
1390         $statechange = $this->_colorset($liboid);
1391         if (isset($this->objects[$liboid]["rotation"]) && $this->objects[$liboid]["rotation"] != 0) {
1392             $statechange .= "1 0 0 1 " .
1393                             $this->objects[$liboid]["left"] . " " .
1394                             $this->objects[$liboid]["bottom"] . " cm " .
1395                             $this->_rotate($this->objects[$liboid]["rotation"]) .
1396                             " cm ";
1397             $locateinbt = false;
1398         }
1399         $temp = "BT ";
1400         if ($this->objects[$liboid]["mode"] != 0) {
1401             $temp .= $this->objects[$liboid]["mode"] .
1402                             " Tr ";
1403             // Adjust stroke width
1404             $statechange .= $this->objects[$liboid]["height"] / 35 . " w ";
1405         }
1406         $temp .= "/F" . $this->objects[$liboid]["font"] . " ";
1407         $temp .= $this->objects[$liboid]["height"];
1408         $temp .= " Tf ";
1409         if ($locateinbt) {
1410             $temp .= $this->objects[$liboid]["left"] . " " .
1411                      $this->objects[$liboid]["bottom"];
1412         } else {
1413             $temp .= "0 0";
1414         }
1415         $temp .= " Td ";
1416         $temp .= $this->_stringify($this->objects[$liboid]["text"]);
1417         $temp .= " Tj ";
1418         $temp .= "ET";
1419         if (strlen($statechange) > 0) {
1420             $temp = "q " . $statechange . $temp . " Q";
1421         }
1422         return $temp . "\x0a";
1423     }
1424
1425     function _colorset($libid)
1426     {
1427         $red = isset($this->objects[$libid]['fillcolor']["red"]) ? (float)$this->objects[$libid]['fillcolor']["red"] : 0;
1428         $green = isset($this->objects[$libid]['fillcolor']["green"]) ? (float)$this->objects[$libid]['fillcolor']["green"] : 0;
1429         $blue = isset($this->objects[$libid]['fillcolor']["blue"]) ? (float)$this->objects[$libid]['fillcolor']["blue"] : 0;
1430         if (($red > 0) || ($green > 0) || ($blue > 0)) {
1431             $r = $red . " " . $green . " " . $blue;
1432             $r .= " rg ";
1433         } else {
1434             $r = "";
1435         }
1436         $red = isset($this->objects[$libid]['strokecolor']["red"]) ? (float)$this->objects[$libid]['strokecolor']["red"] : 0;
1437         $green = isset($this->objects[$libid]['strokecolor']["green"]) ? (float)$this->objects[$libid]['strokecolor']["green"] : 0;
1438         $blue = isset($this->objects[$libid]['strokecolor']["blue"]) ? (float)$this->objects[$libid]['strokecolor']["blue"] : 0;
1439         if (($red > 0) || ($green > 0) || ($blue > 0) ) {
1440             $r .= $red . " " . $green . " " . $blue;
1441             $r .= " RG ";
1442         }
1443         return $r;
1444     }
1445
1446     /* Used to determine what pdflib objects need converted
1447      * to actual PDF objects.
1448      */
1449     function _becomes_object($object)
1450     {
1451         if ($object == "null") {
1452             return false;
1453         }
1454         return true;
1455     }
1456
1457     /* builds an array of child objects */
1458     function _get_kids($pdfid)
1459     {
1460         $libid = $this->pdftolib[$pdfid];
1461         foreach( $this->objects as $obid => $object ) {
1462             if (isset($object["parent"]) && $object["parent"] == $libid) {
1463                 $kids[] = $this->libtopdf[$obid] . " 0 R";
1464             }
1465         }
1466         return $kids;
1467     }
1468
1469     /* builds an array of pages, in order */
1470     function _order_pages($pdfid)
1471     {
1472         $libid = $this->pdftolib[$pdfid];
1473         foreach( $this->objects as $obid => $object ) {
1474             if (isset($object["parent"]) && $object["parent"] == $libid) {
1475                 $kids[$object["number"]] = $this->libtopdf[$obid] . " 0 R";
1476             }
1477         }
1478         ksort($kids);
1479         return $kids;
1480     }
1481
1482     /* simple helper function to return the current oid
1483      * and increment it by one
1484      */
1485     function _addnewoid()
1486     {
1487         $o = $this->nextoid;
1488         $this->nextoid++;
1489         return $o;
1490     }
1491
1492     /* The xreftable will contain a list of all the
1493      * objects in the pdf file and the number of bytes
1494      * from the beginning of the file that the object
1495      * occurs. Each time we add an object, we call this
1496      * to record it's location, then call ->_genxreftable()
1497      * to generate the table from array
1498      */
1499     function _addtoxreftable($offset, $gennum)
1500     {
1501         $this->nextobj ++;
1502         $this->xreftable[$this->nextobj]["offset"] = $offset;
1503         $this->xreftable[$this->nextobj]["gennum"] = $gennum;
1504         $this->xreftable[$this->nextobj]["free"] = "n";
1505         return $this->nextobj;
1506     }
1507
1508     /* Returns a properly formatted pdf dictionary
1509      * containing entries specified by
1510      * the array $entries
1511      */
1512     function _makedictionary($entries)
1513     {
1514         $rs = "<<\x0a";
1515         if (isset($entries) && count($entries) > 0) {
1516             foreach ($entries as $key => $value) {
1517                 $rs .= "/" . $key . " " . $value . "\x0a";
1518             }
1519         }
1520         $rs .= ">>";
1521         return $rs;
1522     }
1523
1524     /* returns a properly formatted pdf array */
1525     function _makearray($entries)
1526     {
1527         $rs = "[";
1528         if ( is_array($entries) ) {
1529             foreach ($entries as $entry) {
1530                 $rs .= $entry . " ";
1531             }
1532         } else {
1533             $rs .= $entries;
1534         }
1535         $rs = rtrim($rs) . "]";
1536         return $rs;
1537     }
1538
1539     /* Returns a properly formatted string, with any
1540      * special characters escaped
1541      */
1542     function _stringify($string)
1543     {
1544         // Escape potentially problematic characters
1545         $string = preg_replace("-\\\\-","\\\\\\\\",$string);
1546         $bad = array ("-\(-", "-\)-" );
1547         $good = array ("\\(", "\\)" );
1548         $string = preg_replace($bad,$good,$string);
1549         return "(" . rtrim($string) . ")";
1550     }
1551
1552     function _streamify($data, $sarray = array())
1553     {
1554         /* zlib compression is a compile time option
1555          * for php, thus we need to make sure it's
1556          * available before using it.
1557          */
1558         $go = true;
1559         if (function_exists('gzcompress') && $this->builddata['compress']) {
1560             if ( !isset($sarray['Filter']) || strlen($sarray['Filter']) == 0 ) {
1561                 $sarray['Filter'] = '/FlateDecode';
1562             } else {
1563                 if ($sarray['Filter'] != '/FlateDecode')
1564                     $sarray['Filter'] = '[/FlateDecode ' . $sarray['Filter'] . ']';
1565                 else
1566                     $go = false;
1567             }
1568             if ($go) $data = gzcompress($data, $this->builddata['compress']);
1569         }
1570         $sarray['Length'] = strlen($data);
1571         $os = $this->_makedictionary($sarray);
1572         $os .= "stream\x0a" . $data . "\x0aendstream";
1573         return $os;
1574     }
1575
1576     /* Returns a properly formatted page node
1577      * page nodes with 0 kids are not created
1578      */
1579     function _makepagenode($kids, $addtlopts = false)
1580     {
1581         $parray["Type"] = "/Pages";
1582         if ( isset($kids) AND count($kids) > 0 ) {
1583             // Array of child objects
1584             $parray["Kids"] = $this->_makearray($kids);
1585             // Number of pages
1586             $parray["Count"] = count($kids);
1587         } else {
1588             // No kids is an error condition
1589             $this->_push_error(600, "Pagenode has no children");
1590             return false;
1591         }
1592         if ( is_array($addtlopts) ) {
1593             foreach ( $addtlopts as $key => $value ) {
1594                 $parray[$key] = $value;
1595             }
1596         }
1597
1598         /* The resource dictionary is always object 3
1599          */
1600         $parray["Resources"] = "3 0 R";
1601
1602         $os = $this->_makedictionary($parray);
1603         $os = "obj" . $os . "endobj";
1604         return $os;
1605     }
1606
1607     function _makepage($parent, $contents, $liboid)
1608     {
1609         $parray["Type"] = "/Page";
1610         $parray["Parent"] = $this->libtopdf[$parent] . " 0 R";
1611         $parray["Contents"] = $this->_makearray($contents);
1612         $parray["MediaBox"] = "[0 0 "
1613                             . $this->objects[$liboid]["width"] . " "
1614                             . $this->objects[$liboid]["height"] . "]";
1615         $os = $this->_makedictionary($parray);
1616         $os = "obj" . $os . "endobj";
1617         return $os;
1618     }
1619
1620 }
1621 ?>