init

fpdi/filters/FilterASCII85.php

@@ -0,0 +1,98 @@
+<?php
+//
+//  FPDI - Version 1.3.1
+//
+//    Copyright 2004-2009 Setasign - Jan Slabon
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+if (!defined('ORD_z'))
+	define('ORD_z',ord('z'));
+if (!defined('ORD_exclmark'))
+	define('ORD_exclmark', ord('!'));
+if (!defined('ORD_u'))	
+	define('ORD_u', ord('u'));
+if (!defined('ORD_tilde'))
+	define('ORD_tilde', ord('~'));
+
+class FilterASCII85 {
+    
+    function error($msg) {
+        die($msg);
+    }
+    
+    function decode($in) {
+        $out = '';
+        $state = 0;
+        $chn = null;
+        
+        $l = strlen($in);
+        
+        for ($k = 0; $k < $l; ++$k) {
+            $ch = ord($in[$k]) & 0xff;
+            
+            if ($ch == ORD_tilde) {
+                break;
+            }
+            if (preg_match('/^\s$/',chr($ch))) {
+                continue;
+            }
+            if ($ch == ORD_z && $state == 0) {
+                $out .= chr(0).chr(0).chr(0).chr(0);
+                continue;
+            }
+            if ($ch < ORD_exclmark || $ch > ORD_u) {
+                $this->error('Illegal character in ASCII85Decode.');
+            }
+            
+            $chn[$state++] = $ch - ORD_exclmark;
+            
+            if ($state == 5) {
+                $state = 0;
+                $r = 0;
+                for ($j = 0; $j < 5; ++$j)
+                    $r = $r * 85 + $chn[$j];
+                $out .= chr($r >> 24);
+                $out .= chr($r >> 16);
+                $out .= chr($r >> 8);
+                $out .= chr($r);
+            }
+        }
+        $r = 0;
+        
+        if ($state == 1)
+            $this->error('Illegal length in ASCII85Decode.');
+        if ($state == 2) {
+            $r = $chn[0] * 85 * 85 * 85 * 85 + ($chn[1]+1) * 85 * 85 * 85;
+            $out .= chr($r >> 24);
+        }
+        else if ($state == 3) {
+            $r = $chn[0] * 85 * 85 * 85 * 85 + $chn[1] * 85 * 85 * 85  + ($chn[2]+1) * 85 * 85;
+            $out .= chr($r >> 24);
+            $out .= chr($r >> 16);
+        }
+        else if ($state == 4) {
+            $r = $chn[0] * 85 * 85 * 85 * 85 + $chn[1] * 85 * 85 * 85  + $chn[2] * 85 * 85  + ($chn[3]+1) * 85 ;
+            $out .= chr($r >> 24);
+            $out .= chr($r >> 16);
+            $out .= chr($r >> 8);
+        }
+
+        return $out;
+    }
+    
+    function encode($in) {
+        $this->error("ASCII85 encoding not implemented.");
+    }
+}

fpdi/filters/FilterASCII85_FPDI.php

@@ -0,0 +1,33 @@
+<?php
+//
+//  FPDI - Version 1.3.1
+//
+//    Copyright 2004-2009 Setasign - Jan Slabon
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+require_once('FilterASCII85.php');
+
+class FilterASCII85_FPDI extends FilterASCII85 {
+
+    var $fpdi;
+    
+    function FPDI_FilterASCII85(&$fpdi) {
+        $this->fpdi =& $fpdi;
+    }
+
+    function error($msg) {
+        $this->fpdi->error($msg);
+    }
+}

fpdi/filters/FilterLZW.php

@@ -0,0 +1,154 @@
+<?php
+//
+//  FPDI - Version 1.3.1
+//
+//    Copyright 2004-2009 Setasign - Jan Slabon
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+class FilterLZW {
+    
+    var $sTable = array();
+    var $data = null;
+    var $dataLength = 0;
+    var $tIdx;
+    var $bitsToGet = 9;
+    var $bytePointer;
+    var $bitPointer;
+    var $nextData = 0;
+    var $nextBits = 0;
+    var $andTable = array(511, 1023, 2047, 4095);
+
+    function error($msg) {
+        die($msg);
+    }
+    
+    /**
+     * Method to decode LZW compressed data.
+     *
+     * @param string data    The compressed data.
+     */
+    function decode($data) {
+
+        if($data[0] == 0x00 && $data[1] == 0x01) {
+            $this->error('LZW flavour not supported.');
+        }
+
+        $this->initsTable();
+
+        $this->data = $data;
+        $this->dataLength = strlen($data);
+
+        // Initialize pointers
+        $this->bytePointer = 0;
+        $this->bitPointer = 0;
+
+        $this->nextData = 0;
+        $this->nextBits = 0;
+
+        $oldCode = 0;
+
+        $string = '';
+        $uncompData = '';
+
+        while (($code = $this->getNextCode()) != 257) {
+            if ($code == 256) {
+                $this->initsTable();
+                $code = $this->getNextCode();
+
+                if ($code == 257) {
+                    break;
+                }
+
+                $uncompData .= $this->sTable[$code];
+                $oldCode = $code;
+
+            } else {
+
+                if ($code < $this->tIdx) {
+                    $string = $this->sTable[$code];
+                    $uncompData .= $string;
+
+                    $this->addStringToTable($this->sTable[$oldCode], $string[0]);
+                    $oldCode = $code;
+                } else {
+                    $string = $this->sTable[$oldCode];
+                    $string = $string.$string[0];
+                    $uncompData .= $string;
+
+                    $this->addStringToTable($string);
+                    $oldCode = $code;
+                }
+            }
+        }
+        
+        return $uncompData;
+    }
+
+
+    /**
+     * Initialize the string table.
+     */
+    function initsTable() {
+        $this->sTable = array();
+
+        for ($i = 0; $i < 256; $i++)
+            $this->sTable[$i] = chr($i);
+
+        $this->tIdx = 258;
+        $this->bitsToGet = 9;
+    }
+
+    /**
+     * Add a new string to the string table.
+     */
+    function addStringToTable ($oldString, $newString='') {
+        $string = $oldString.$newString;
+
+        // Add this new String to the table
+        $this->sTable[$this->tIdx++] = $string;
+
+        if ($this->tIdx == 511) {
+            $this->bitsToGet = 10;
+        } else if ($this->tIdx == 1023) {
+            $this->bitsToGet = 11;
+        } else if ($this->tIdx == 2047) {
+            $this->bitsToGet = 12;
+        }
+    }
+
+    // Returns the next 9, 10, 11 or 12 bits
+    function getNextCode() {
+        if ($this->bytePointer == $this->dataLength) {
+            return 257;
+        }
+
+        $this->nextData = ($this->nextData << 8) | (ord($this->data[$this->bytePointer++]) & 0xff);
+        $this->nextBits += 8;
+
+        if ($this->nextBits < $this->bitsToGet) {
+            $this->nextData = ($this->nextData << 8) | (ord($this->data[$this->bytePointer++]) & 0xff);
+            $this->nextBits += 8;
+        }
+
+        $code = ($this->nextData >> ($this->nextBits - $this->bitsToGet)) & $this->andTable[$this->bitsToGet-9];
+        $this->nextBits -= $this->bitsToGet;
+
+        return $code;
+    }
+    
+    function encode($in) {
+        $this->error("LZW encoding not implemented.");
+    }
+}

fpdi/filters/FilterLZW_FPDI.php

@@ -0,0 +1,33 @@
+<?php
+//
+//  FPDI - Version 1.3.1
+//
+//    Copyright 2004-2009 Setasign - Jan Slabon
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+require_once('FilterLZW.php');
+
+class FilterLZW_FPDI extends FilterLZW {
+
+    var $fpdi;
+
+    function FilterLZW_FPDI(&$fpdi) {
+        $this->fpdi =& $fpdi;
+    }
+    
+    function error($msg) {
+        $this->fpdi->error($msg);
+    }
+}

fpdi/fpdf_tpl.php

@@ -0,0 +1,409 @@
+<?php
+//
+//  FPDF_TPL - Version 1.1.3
+//
+//    Copyright 2004-2009 Setasign - Jan Slabon
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+class FPDF_TPL extends FPDF {
+    /**
+     * Array of Tpl-Data
+     * @var array
+     */
+    var $tpls = array();
+
+    /**
+     * Current Template-ID
+     * @var int
+     */
+    var $tpl = 0;
+    
+    /**
+     * "In Template"-Flag
+     * @var boolean
+     */
+    var $_intpl = false;
+    
+    /**
+     * Nameprefix of Templates used in Resources-Dictonary
+     * @var string A String defining the Prefix used as Template-Object-Names. Have to beginn with an /
+     */
+    var $tplprefix = "/TPL";
+
+    /**
+     * Resources used By Templates and Pages
+     * @var array
+     */
+    var $_res = array();
+    
+    /**
+     * Last used Template data
+     *
+     * @var array
+     */
+    var $lastUsedTemplateData = array();
+    
+    /**
+     * Start a Template
+     *
+     * This method starts a template. You can give own coordinates to build an own sized
+     * Template. Pay attention, that the margins are adapted to the new templatesize.
+     * If you want to write outside the template, for example to build a clipped Template,
+     * you have to set the Margins and "Cursor"-Position manual after beginTemplate-Call.
+     *
+     * If no parameter is given, the template uses the current page-size.
+     * The Method returns an ID of the current Template. This ID is used later for using this template.
+     * Warning: A created Template is used in PDF at all events. Still if you don't use it after creation!
+     *
+     * @param int $x The x-coordinate given in user-unit
+     * @param int $y The y-coordinate given in user-unit
+     * @param int $w The width given in user-unit
+     * @param int $h The height given in user-unit
+     * @return int The ID of new created Template
+     */
+    function beginTemplate($x=null, $y=null, $w=null, $h=null) {
+        if ($this->page <= 0)
+            $this->error("You have to add a page to fpdf first!");
+
+        if ($x == null)
+            $x = 0;
+        if ($y == null)
+            $y = 0;
+        if ($w == null)
+            $w = $this->w;
+        if ($h == null)
+            $h = $this->h;
+
+        // Save settings
+        $this->tpl++;
+        $tpl =& $this->tpls[$this->tpl];
+        $tpl = array(
+            'o_x' => $this->x,
+            'o_y' => $this->y,
+            'o_AutoPageBreak' => $this->AutoPageBreak,
+            'o_bMargin' => $this->bMargin,
+            'o_tMargin' => $this->tMargin,
+            'o_lMargin' => $this->lMargin,
+            'o_rMargin' => $this->rMargin,
+            'o_h' => $this->h,
+            'o_w' => $this->w,
+            'buffer' => '',
+            'x' => $x,
+            'y' => $y,
+            'w' => $w,
+            'h' => $h
+        );
+
+        $this->SetAutoPageBreak(false);
+        
+        // Define own high and width to calculate possitions correct
+        $this->h = $h;
+        $this->w = $w;
+
+        $this->_intpl = true;
+        $this->SetXY($x+$this->lMargin, $y+$this->tMargin);
+        $this->SetRightMargin($this->w-$w+$this->rMargin);
+
+        return $this->tpl;
+    }
+    
+    /**
+     * End Template
+     *
+     * This method ends a template and reset initiated variables on beginTemplate.
+     *
+     * @return mixed If a template is opened, the ID is returned. If not a false is returned.
+     */
+    function endTemplate() {
+        if ($this->_intpl) {
+            $this->_intpl = false; 
+            $tpl =& $this->tpls[$this->tpl];
+            $this->SetXY($tpl['o_x'], $tpl['o_y']);
+            $this->tMargin = $tpl['o_tMargin'];
+            $this->lMargin = $tpl['o_lMargin'];
+            $this->rMargin = $tpl['o_rMargin'];
+            $this->h = $tpl['o_h'];
+            $this->w = $tpl['o_w'];
+            $this->SetAutoPageBreak($tpl['o_AutoPageBreak'], $tpl['o_bMargin']);
+            
+            return $this->tpl;
+        } else {
+            return false;
+        }
+    }
+    
+    /**
+     * Use a Template in current Page or other Template
+     *
+     * You can use a template in a page or in another template.
+     * You can give the used template a new size like you use the Image()-method.
+     * All parameters are optional. The width or height is calculated automaticaly
+     * if one is given. If no parameter is given the origin size as defined in
+     * beginTemplate() is used.
+     * The calculated or used width and height are returned as an array.
+     *
+     * @param int $tplidx A valid template-Id
+     * @param int $_x The x-position
+     * @param int $_y The y-position
+     * @param int $_w The new width of the template
+     * @param int $_h The new height of the template
+     * @retrun array The height and width of the template
+     */
+    function useTemplate($tplidx, $_x=null, $_y=null, $_w=0, $_h=0) {
+        if ($this->page <= 0)
+            $this->error("You have to add a page to fpdf first!");
+
+        if (!isset($this->tpls[$tplidx]))
+            $this->error("Template does not exist!");
+            
+        if ($this->_intpl) {
+            $this->_res['tpl'][$this->tpl]['tpls'][$tplidx] =& $this->tpls[$tplidx];
+        }
+        
+        $tpl =& $this->tpls[$tplidx];
+        $w = $tpl['w'];
+        $h = $tpl['h'];
+        
+        if ($_x == null)
+            $_x = 0;
+        if ($_y == null)
+            $_y = 0;
+            
+        $_x += $tpl['x'];
+        $_y += $tpl['y'];
+        
+        $wh = $this->getTemplateSize($tplidx, $_w, $_h);
+        $_w = $wh['w'];
+        $_h = $wh['h'];
+    
+        $tData = array(
+            'x' => $this->x,
+            'y' => $this->y,
+            'w' => $_w,
+            'h' => $_h,
+            'scaleX' => ($_w/$w),
+            'scaleY' => ($_h/$h),
+            'tx' => $_x,
+            'ty' =>  ($this->h-$_y-$_h),
+            'lty' => ($this->h-$_y-$_h) - ($this->h-$h) * ($_h/$h)
+        );
+        
+        $this->_out(sprintf("q %.4F 0 0 %.4F %.4F %.4F cm", $tData['scaleX'], $tData['scaleY'], $tData['tx']*$this->k, $tData['ty']*$this->k)); // Translate 
+        $this->_out(sprintf('%s%d Do Q', $this->tplprefix, $tplidx));
+
+        $this->lastUsedTemplateData = $tData;
+        
+        return array("w" => $_w, "h" => $_h);
+    }
+    
+    /**
+     * Get The calculated Size of a Template
+     *
+     * If one size is given, this method calculates the other one.
+     *
+     * @param int $tplidx A valid template-Id
+     * @param int $_w The width of the template
+     * @param int $_h The height of the template
+     * @return array The height and width of the template
+     */
+    function getTemplateSize($tplidx, $_w=0, $_h=0) {
+        if (!$this->tpls[$tplidx])
+            return false;
+
+        $tpl =& $this->tpls[$tplidx];
+        $w = $tpl['w'];
+        $h = $tpl['h'];
+        
+        if ($_w == 0 and $_h == 0) {
+            $_w = $w;
+            $_h = $h;
+        }
+
+    	if($_w==0)
+    		$_w = $_h*$w/$h;
+    	if($_h==0)
+    		$_h = $_w*$h/$w;
+    		
+        return array("w" => $_w, "h" => $_h);
+    }
+    
+    /**
+     * See FPDF/TCPDF-Documentation ;-)
+     */
+    function SetFont($family, $style='', $size=0, $fontfile='') {
+        if (!is_subclass_of($this, 'TCPDF') && func_num_args() > 3) {
+            $this->Error('More than 3 arguments for the SetFont method are only available in TCPDF.');
+        }
+        /**
+         * force the resetting of font changes in a template
+         */
+        if ($this->_intpl)
+            $this->FontFamily = '';
+            
+        parent::SetFont($family, $style, $size, $fontfile);
+       
+        $fontkey = $this->FontFamily.$this->FontStyle;
+        
+        if ($this->_intpl) {
+            $this->_res['tpl'][$this->tpl]['fonts'][$fontkey] =& $this->fonts[$fontkey];
+        } else {
+            $this->_res['page'][$this->page]['fonts'][$fontkey] =& $this->fonts[$fontkey];
+        }
+    }
+    
+    /**
+     * See FPDF/TCPDF-Documentation ;-)
+     */
+    function Image($file, $x, $y, $w=0, $h=0, $type='', $link='', $align='', $resize=false, $dpi=300, $palign='', $ismask=false, $imgmask=false, $border=0) {
+        if (!is_subclass_of($this, 'TCPDF') && func_num_args() > 7) {
+            $this->Error('More than 7 arguments for the Image method are only available in TCPDF.');
+        }
+        
+        parent::Image($file, $x, $y, $w, $h, $type, $link, $align, $resize, $dpi, $palign, $ismask, $imgmask, $border);
+        if ($this->_intpl) {
+            $this->_res['tpl'][$this->tpl]['images'][$file] =& $this->images[$file];
+        } else {
+            $this->_res['page'][$this->page]['images'][$file] =& $this->images[$file];
+        }
+    }
+    
+    /**
+     * See FPDF-Documentation ;-)
+     *
+     * AddPage is not available when you're "in" a template.
+     */
+    function AddPage($orientation='', $format='') {
+        if ($this->_intpl)
+            $this->Error('Adding pages in templates isn\'t possible!');
+        parent::AddPage($orientation, $format);
+    }
+
+    /**
+     * Preserve adding Links in Templates ...won't work
+     */
+    function Link($x, $y, $w, $h, $link, $spaces=0) {
+        if (!is_subclass_of($this, 'TCPDF') && func_num_args() > 5) {
+            $this->Error('More than 7 arguments for the Image method are only available in TCPDF.');
+        }
+        
+        if ($this->_intpl)
+            $this->Error('Using links in templates aren\'t possible!');
+        parent::Link($x, $y, $w, $h, $link, $spaces);
+    }
+    
+    function AddLink() {
+        if ($this->_intpl)
+            $this->Error('Adding links in templates aren\'t possible!');
+        return parent::AddLink();
+    }
+    
+    function SetLink($link, $y=0, $page=-1) {
+        if ($this->_intpl)
+            $this->Error('Setting links in templates aren\'t possible!');
+        parent::SetLink($link, $y, $page);
+    }
+    
+    /**
+     * Private Method that writes the form xobjects
+     */
+    function _putformxobjects() {
+        $filter=($this->compress) ? '/Filter /FlateDecode ' : '';
+	    reset($this->tpls);
+        foreach($this->tpls AS $tplidx => $tpl) {
+
+            $p=($this->compress) ? gzcompress($tpl['buffer']) : $tpl['buffer'];
+    		$this->_newobj();
+    		$this->tpls[$tplidx]['n'] = $this->n;
+    		$this->_out('<<'.$filter.'/Type /XObject');
+            $this->_out('/Subtype /Form');
+            $this->_out('/FormType 1');
+            $this->_out(sprintf('/BBox [%.2F %.2F %.2F %.2F]',
+                // llx
+                $tpl['x'],
+                // lly
+                -$tpl['y'],
+                // urx
+                ($tpl['w']+$tpl['x'])*$this->k,
+                // ury
+                ($tpl['h']-$tpl['y'])*$this->k
+            ));
+            
+            if ($tpl['x'] != 0 || $tpl['y'] != 0) {
+                $this->_out(sprintf('/Matrix [1 0 0 1 %.5F %.5F]',
+                     -$tpl['x']*$this->k*2, $tpl['y']*$this->k*2
+                ));
+            }
+            
+            $this->_out('/Resources ');
+
+            $this->_out('<</ProcSet [/PDF /Text /ImageB /ImageC /ImageI]');
+        	if (isset($this->_res['tpl'][$tplidx]['fonts']) && count($this->_res['tpl'][$tplidx]['fonts'])) {
+            	$this->_out('/Font <<');
+                foreach($this->_res['tpl'][$tplidx]['fonts'] as $font)
+            		$this->_out('/F'.$font['i'].' '.$font['n'].' 0 R');
+            	$this->_out('>>');
+            }
+        	if(isset($this->_res['tpl'][$tplidx]['images']) && count($this->_res['tpl'][$tplidx]['images']) || 
+        	   isset($this->_res['tpl'][$tplidx]['tpls']) && count($this->_res['tpl'][$tplidx]['tpls']))
+        	{
+                $this->_out('/XObject <<');
+                if (isset($this->_res['tpl'][$tplidx]['images']) && count($this->_res['tpl'][$tplidx]['images'])) {
+                    foreach($this->_res['tpl'][$tplidx]['images'] as $image)
+              			$this->_out('/I'.$image['i'].' '.$image['n'].' 0 R');
+                }
+                if (isset($this->_res['tpl'][$tplidx]['tpls']) && count($this->_res['tpl'][$tplidx]['tpls'])) {
+                    foreach($this->_res['tpl'][$tplidx]['tpls'] as $i => $tpl)
+                        $this->_out($this->tplprefix.$i.' '.$tpl['n'].' 0 R');
+                }
+                $this->_out('>>');
+        	}
+        	$this->_out('>>');
+        	
+        	$this->_out('/Length '.strlen($p).' >>');
+    		$this->_putstream($p);
+    		$this->_out('endobj');
+        }
+    }
+    
+    /**
+     * Overwritten to add _putformxobjects() after _putimages()
+     *
+     */
+    function _putimages() {
+        parent::_putimages();
+        $this->_putformxobjects();
+    }
+    
+    function _putxobjectdict() {
+        parent::_putxobjectdict();
+        
+        if (count($this->tpls)) {
+            foreach($this->tpls as $tplidx => $tpl) {
+                $this->_out(sprintf('%s%d %d 0 R', $this->tplprefix, $tplidx, $tpl['n']));
+            }
+        }
+    }
+
+    /**
+     * Private Method
+     */
+    function _out($s) {
+        if ($this->state==2 && $this->_intpl) {
+            $this->tpls[$this->tpl]['buffer'] .= $s."\n";
+        } else {
+            parent::_out($s);
+        }
+    }
+}

fpdi/fpdi.php

@@ -0,0 +1,505 @@
+<?php
+//
+//  FPDI - Version 1.3.1
+//
+//    Copyright 2004-2009 Setasign - Jan Slabon
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+define('FPDI_VERSION','1.3.1');
+
+// Check for TCPDF and remap TCPDF to FPDF
+if (class_exists('TCPDF')) {
+    require_once('fpdi2tcpdf_bridge.php');
+}
+
+require_once('fpdf_tpl.php');
+require_once('fpdi_pdf_parser.php');
+
+
+class FPDI extends FPDF_TPL {
+    /**
+     * Actual filename
+     * @var string
+     */
+    var $current_filename;
+
+    /**
+     * Parser-Objects
+     * @var array
+     */
+    var $parsers;
+    
+    /**
+     * Current parser
+     * @var object
+     */
+    var $current_parser;
+    
+    /**
+     * object stack
+     * @var array
+     */
+    var $_obj_stack;
+    
+    /**
+     * done object stack
+     * @var array
+     */
+    var $_don_obj_stack;
+
+    /**
+     * Current Object Id.
+     * @var integer
+     */
+    var $_current_obj_id;
+    
+    /**
+     * The name of the last imported page box
+     * @var string
+     */
+    var $lastUsedPageBox;
+    
+    var $_importedPages = array();
+    
+    
+    /**
+     * Set a source-file
+     *
+     * @param string $filename a valid filename
+     * @return int number of available pages
+     */
+    function setSourceFile($filename) {
+        $this->current_filename = $filename;
+        $fn =& $this->current_filename;
+
+        if (!isset($this->parsers[$fn]))
+            $this->parsers[$fn] =& new fpdi_pdf_parser($fn, $this);
+        $this->current_parser =& $this->parsers[$fn];
+        
+        return $this->parsers[$fn]->getPageCount();
+    }
+    
+    /**
+     * Import a page
+     *
+     * @param int $pageno pagenumber
+     * @return int Index of imported page - to use with fpdf_tpl::useTemplate()
+     */
+    function importPage($pageno, $boxName='/CropBox') {
+        if ($this->_intpl) {
+            return $this->error('Please import the desired pages before creating a new template.');
+        }
+        
+        $fn =& $this->current_filename;
+        
+        // check if page already imported
+        $pageKey = $fn.((int)$pageno).$boxName;
+        if (isset($this->_importedPages[$pageKey]))
+            return $this->_importedPages[$pageKey];
+        
+        $parser =& $this->parsers[$fn];
+        $parser->setPageno($pageno);
+
+        $this->tpl++;
+        $this->tpls[$this->tpl] = array();
+        $tpl =& $this->tpls[$this->tpl];
+        $tpl['parser'] =& $parser;
+        $tpl['resources'] = $parser->getPageResources();
+        $tpl['buffer'] = $parser->getContent();
+        
+        if (!in_array($boxName, $parser->availableBoxes))
+            return $this->Error(sprintf('Unknown box: %s', $boxName));
+        $pageboxes = $parser->getPageBoxes($pageno);
+        
+        /**
+         * MediaBox
+         * CropBox: Default -> MediaBox
+         * BleedBox: Default -> CropBox
+         * TrimBox: Default -> CropBox
+         * ArtBox: Default -> CropBox
+         */
+        if (!isset($pageboxes[$boxName]) && ($boxName == '/BleedBox' || $boxName == '/TrimBox' || $boxName == '/ArtBox'))
+            $boxName = '/CropBox';
+        if (!isset($pageboxes[$boxName]) && $boxName == '/CropBox')
+            $boxName = '/MediaBox';
+        
+        if (!isset($pageboxes[$boxName]))
+            return false;
+        $this->lastUsedPageBox = $boxName;
+        
+        $box = $pageboxes[$boxName];
+        $tpl['box'] = $box;
+        
+        // To build an array that can be used by PDF_TPL::useTemplate()
+        $this->tpls[$this->tpl] = array_merge($this->tpls[$this->tpl],$box);
+        
+        // An imported page will start at 0,0 everytime. Translation will be set in _putformxobjects()
+        $tpl['x'] = 0;
+        $tpl['y'] = 0;
+        
+        $page =& $parser->pages[$parser->pageno];
+        
+        // handle rotated pages
+        $rotation = $parser->getPageRotation($pageno);
+        $tpl['_rotationAngle'] = 0;
+        if (isset($rotation[1]) && ($angle = $rotation[1] % 360) != 0) {
+            $steps = $angle / 90;
+                
+            $_w = $tpl['w'];
+            $_h = $tpl['h'];
+            $tpl['w'] = $steps % 2 == 0 ? $_w : $_h;
+            $tpl['h'] = $steps % 2 == 0 ? $_h : $_w;
+            
+            $tpl['_rotationAngle'] = $angle*-1;
+        }
+        
+        $this->_importedPages[$pageKey] = $this->tpl;
+        
+        return $this->tpl;
+    }
+    
+    function getLastUsedPageBox() {
+        return $this->lastUsedPageBox;
+    }
+    
+    function useTemplate($tplidx, $_x=null, $_y=null, $_w=0, $_h=0, $adjustPageSize=false) {
+        if ($adjustPageSize == true && is_null($_x) && is_null($_y)) {
+            $size = $this->getTemplateSize($tplidx, $_w, $_h);
+            $format = array($size['w'], $size['h']);
+            if ($format[0]!=$this->CurPageFormat[0] || $format[1]!=$this->CurPageFormat[1]) {
+                $this->w=$format[0];
+                $this->h=$format[1];
+                $this->wPt=$this->w*$this->k;
+        		$this->hPt=$this->h*$this->k;
+        		$this->PageBreakTrigger=$this->h-$this->bMargin;
+        		$this->CurPageFormat=$format;
+        		$this->PageSizes[$this->page]=array($this->wPt, $this->hPt);
+            }
+        }
+        
+        $this->_out('q 0 J 1 w 0 j 0 G 0 g'); // reset standard values
+        $s = parent::useTemplate($tplidx, $_x, $_y, $_w, $_h);
+        $this->_out('Q');
+        return $s;
+    }
+    
+    /**
+     * Private method, that rebuilds all needed objects of source files
+     */
+    function _putimportedobjects() {
+        if (is_array($this->parsers) && count($this->parsers) > 0) {
+            foreach($this->parsers AS $filename => $p) {
+                $this->current_parser =& $this->parsers[$filename];
+                if (isset($this->_obj_stack[$filename]) && is_array($this->_obj_stack[$filename])) {
+                    while(($n = key($this->_obj_stack[$filename])) !== null) {
+                        $nObj = $this->current_parser->pdf_resolve_object($this->current_parser->c,$this->_obj_stack[$filename][$n][1]);
+						
+                        $this->_newobj($this->_obj_stack[$filename][$n][0]);
+                        
+                        if ($nObj[0] == PDF_TYPE_STREAM) {
+							$this->pdf_write_value ($nObj);
+                        } else {
+                            $this->pdf_write_value ($nObj[1]);
+                        }
+                        
+                        $this->_out('endobj');
+                        $this->_obj_stack[$filename][$n] = null; // free memory
+                        unset($this->_obj_stack[$filename][$n]);
+                        reset($this->_obj_stack[$filename]);
+                    }
+                }
+            }
+        }
+    }
+    
+    
+    /**
+     * Private Method that writes the form xobjects
+     */
+    function _putformxobjects() {
+        $filter=($this->compress) ? '/Filter /FlateDecode ' : '';
+	    reset($this->tpls);
+        foreach($this->tpls AS $tplidx => $tpl) {
+            $p=($this->compress) ? gzcompress($tpl['buffer']) : $tpl['buffer'];
+    		$this->_newobj();
+    		$cN = $this->n; // TCPDF/Protection: rem current "n"
+    		
+    		$this->tpls[$tplidx]['n'] = $this->n;
+    		$this->_out('<<'.$filter.'/Type /XObject');
+            $this->_out('/Subtype /Form');
+            $this->_out('/FormType 1');
+            
+            $this->_out(sprintf('/BBox [%.2F %.2F %.2F %.2F]', 
+                (isset($tpl['box']['llx']) ? $tpl['box']['llx'] : $tpl['x'])*$this->k,
+                (isset($tpl['box']['lly']) ? $tpl['box']['lly'] : -$tpl['y'])*$this->k,
+                (isset($tpl['box']['urx']) ? $tpl['box']['urx'] : $tpl['w'] + $tpl['x'])*$this->k,
+                (isset($tpl['box']['ury']) ? $tpl['box']['ury'] : $tpl['h']-$tpl['y'])*$this->k
+            ));
+            
+            $c = 1;
+            $s = 0;
+            $tx = 0;
+            $ty = 0;
+            
+            if (isset($tpl['box'])) {
+                $tx = -$tpl['box']['llx'];
+                $ty = -$tpl['box']['lly']; 
+                
+                if ($tpl['_rotationAngle'] <> 0) {
+                    $angle = $tpl['_rotationAngle'] * M_PI/180;
+                    $c=cos($angle);
+                    $s=sin($angle);
+                    
+                    switch($tpl['_rotationAngle']) {
+                        case -90:
+                           $tx = -$tpl['box']['lly'];
+                           $ty = $tpl['box']['urx'];
+                           break;
+                        case -180:
+                            $tx = $tpl['box']['urx'];
+                            $ty = $tpl['box']['ury'];
+                            break;
+                        case -270:
+                            $tx = $tpl['box']['ury'];
+                            $ty = 0;
+                            break;
+                    }
+                }
+            } else if ($tpl['x'] != 0 || $tpl['y'] != 0) {
+                $tx = -$tpl['x']*2;
+                $ty = $tpl['y']*2;
+            }
+            
+            $tx *= $this->k;
+            $ty *= $this->k;
+            
+            if ($c != 1 || $s != 0 || $tx != 0 || $ty != 0) {
+                $this->_out(sprintf('/Matrix [%.5F %.5F %.5F %.5F %.5F %.5F]',
+                    $c, $s, -$s, $c, $tx, $ty
+                ));
+            }
+            
+            $this->_out('/Resources ');
+
+            if (isset($tpl['resources'])) {
+                $this->current_parser =& $tpl['parser'];
+                $this->pdf_write_value($tpl['resources']); // "n" will be changed
+            } else {
+                $this->_out('<</ProcSet [/PDF /Text /ImageB /ImageC /ImageI]');
+            	if (isset($this->_res['tpl'][$tplidx]['fonts']) && count($this->_res['tpl'][$tplidx]['fonts'])) {
+                	$this->_out('/Font <<');
+                    foreach($this->_res['tpl'][$tplidx]['fonts'] as $font)
+                		$this->_out('/F'.$font['i'].' '.$font['n'].' 0 R');
+                	$this->_out('>>');
+                }
+            	if(isset($this->_res['tpl'][$tplidx]['images']) && count($this->_res['tpl'][$tplidx]['images']) || 
+            	   isset($this->_res['tpl'][$tplidx]['tpls']) && count($this->_res['tpl'][$tplidx]['tpls']))
+            	{
+                    $this->_out('/XObject <<');
+                    if (isset($this->_res['tpl'][$tplidx]['images']) && count($this->_res['tpl'][$tplidx]['images'])) {
+                        foreach($this->_res['tpl'][$tplidx]['images'] as $image)
+                  			$this->_out('/I'.$image['i'].' '.$image['n'].' 0 R');
+                    }
+                    if (isset($this->_res['tpl'][$tplidx]['tpls']) && count($this->_res['tpl'][$tplidx]['tpls'])) {
+                        foreach($this->_res['tpl'][$tplidx]['tpls'] as $i => $tpl)
+                            $this->_out($this->tplprefix.$i.' '.$tpl['n'].' 0 R');
+                    }
+                    $this->_out('>>');
+            	}
+            	$this->_out('>>');
+            }
+
+            $nN = $this->n; // TCPDF: rem new "n"
+            $this->n = $cN; // TCPDF: reset to current "n"
+            $this->_out('/Length '.strlen($p).' >>');
+    		$this->_putstream($p);
+    		$this->_out('endobj');
+    		$this->n = $nN; // TCPDF: reset to new "n"
+        }
+        
+        $this->_putimportedobjects();
+    }
+
+    /**
+     * Rewritten to handle existing own defined objects
+     */
+    function _newobj($obj_id=false,$onlynewobj=false) {
+        if (!$obj_id) {
+            $obj_id = ++$this->n;
+        }
+
+        //Begin a new object
+        if (!$onlynewobj) {
+            $this->offsets[$obj_id] = is_subclass_of($this, 'TCPDF') ? $this->bufferlen : strlen($this->buffer);
+            $this->_out($obj_id.' 0 obj');
+            $this->_current_obj_id = $obj_id; // for later use with encryption
+        }
+        return $obj_id;
+    }
+
+    /**
+     * Writes a value
+     * Needed to rebuild the source document
+     *
+     * @param mixed $value A PDF-Value. Structure of values see cases in this method
+     */
+    function pdf_write_value(&$value)
+    {
+        if (is_subclass_of($this, 'TCPDF')) {
+            parent::pdf_write_value($value);
+        }
+        
+        switch ($value[0]) {
+
+    		case PDF_TYPE_TOKEN :
+                $this->_straightOut($value[1] . ' ');
+    			break;
+		    case PDF_TYPE_NUMERIC :
+    		case PDF_TYPE_REAL :
+                if (is_float($value[1]) && $value[1] != 0) {
+    			    $this->_straightOut(rtrim(rtrim(sprintf('%F', $value[1]), '0'), '.') .' ');
+    			} else {
+        			$this->_straightOut($value[1] . ' ');
+    			}
+    			break;
+    			
+    		case PDF_TYPE_ARRAY :
+
+    			// An array. Output the proper
+    			// structure and move on.
+
+    			$this->_straightOut('[');
+                for ($i = 0; $i < count($value[1]); $i++) {
+    				$this->pdf_write_value($value[1][$i]);
+    			}
+
+    			$this->_out(']');
+    			break;
+
+    		case PDF_TYPE_DICTIONARY :
+
+    			// A dictionary.
+    			$this->_straightOut('<<');
+
+    			reset ($value[1]);
+
+    			while (list($k, $v) = each($value[1])) {
+    				$this->_straightOut($k . ' ');
+    				$this->pdf_write_value($v);
+    			}
+
+    			$this->_straightOut('>>');
+    			break;
+
+    		case PDF_TYPE_OBJREF :
+
+    			// An indirect object reference
+    			// Fill the object stack if needed
+    			$cpfn =& $this->current_parser->filename;
+    			
+    			if (!isset($this->_don_obj_stack[$cpfn][$value[1]])) {
+    			    $this->_newobj(false,true);
+    			    $this->_obj_stack[$cpfn][$value[1]] = array($this->n, $value);
+                    $this->_don_obj_stack[$cpfn][$value[1]] = array($this->n, $value); // Value is maybee obsolete!!!
+                }
+                $objid = $this->_don_obj_stack[$cpfn][$value[1]][0];
+
+    			$this->_out($objid.' 0 R');
+    			break;
+
+    		case PDF_TYPE_STRING :
+
+    			// A string.
+                $this->_straightOut('('.$value[1].')');
+
+    			break;
+
+    		case PDF_TYPE_STREAM :
+
+    			// A stream. First, output the
+    			// stream dictionary, then the
+    			// stream data itself.
+                $this->pdf_write_value($value[1]);
+    			$this->_out('stream');
+    			$this->_out($value[2][1]);
+    			$this->_out('endstream');
+    			break;
+            case PDF_TYPE_HEX :
+                $this->_straightOut('<'.$value[1].'>');
+                break;
+
+            case PDF_TYPE_BOOLEAN :
+    		    $this->_straightOut($value[1] ? 'true ' : 'false ');
+    		    break;
+            
+    		case PDF_TYPE_NULL :
+                // The null object.
+
+    			$this->_straightOut('null ');
+    			break;
+    	}
+    }
+    
+    
+    /**
+     * Modified so not each call will add a newline to the output.
+     */
+    function _straightOut($s) {
+        if (!is_subclass_of($this, 'TCPDF')) {
+            if($this->state==2)
+        		$this->pages[$this->page] .= $s;
+        	else
+        		$this->buffer .= $s;
+        } else {
+            if ($this->state == 2) {
+				if (isset($this->footerlen[$this->page]) AND ($this->footerlen[$this->page] > 0)) {
+					// puts data before page footer
+					$page = substr($this->getPageBuffer($this->page), 0, -$this->footerlen[$this->page]);
+					$footer = substr($this->getPageBuffer($this->page), -$this->footerlen[$this->page]);
+					$this->setPageBuffer($this->page, $page.' '.$s."\n".$footer);
+				} else {
+					$this->setPageBuffer($this->page, $s, true);
+				}
+			} else {
+				$this->setBuffer($s);
+			}
+        }
+    }
+
+    /**
+     * rewritten to close opened parsers
+     *
+     */
+    function _enddoc() {
+        parent::_enddoc();
+        $this->_closeParsers();
+    }
+    
+    /**
+     * close all files opened by parsers
+     */
+    function _closeParsers() {
+        if ($this->state > 2 && count($this->parsers) > 0) {
+          	foreach ($this->parsers as $k => $_){
+            	$this->parsers[$k]->closeFile();
+            	$this->parsers[$k] = null;
+            	unset($this->parsers[$k]);
+            }
+            return true;
+        }
+        return false;
+    }
+
+}

fpdi/fpdi2tcpdf_bridge.php

@@ -0,0 +1,171 @@
+<?php
+//
+//  FPDI - Version 1.3.1
+//
+//    Copyright 2004-2009 Setasign - Jan Slabon
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+/**
+ * This class is used as a bridge between TCPDF and FPDI
+ * and will create the possibility to use both FPDF and TCPDF
+ * via one FPDI version.
+ * 
+ * We'll simply remap TCPDF to FPDF again.
+ * 
+ * It'll be loaded and extended by FPDF_TPL.
+ */
+class FPDF extends TCPDF {
+    
+    function __get($name) {
+        switch ($name) {
+            case 'PDFVersion':
+                return $this->PDFVersion;
+            case 'k':
+                return $this->k;
+            default:
+                // Error handling
+                $this->Error('Cannot access protected property '.get_class($this).':$'.$name.' / Undefined property: '.get_class($this).'::$'.$name);
+        }
+    }
+
+    function __set($name, $value) {
+        switch ($name) {
+            case 'PDFVersion':
+                $this->PDFVersion = $value;
+                break;
+            default:
+                // Error handling
+                $this->Error('Cannot access protected property '.get_class($this).':$'.$name.' / Undefined property: '.get_class($this).'::$'.$name);
+        }
+    }
+
+    /**
+     * Encryption of imported data by FPDI
+     *
+     * @param array $value
+     */
+    function pdf_write_value(&$value) {
+        switch ($value[0]) {
+    		case PDF_TYPE_STRING :
+				if ($this->encrypted) {
+				    $value[1] = $this->_unescape($value[1]);
+                    $value[1] = $this->_RC4($this->_objectkey($this->_current_obj_id), $value[1]);
+                 	$value[1] = $this->_escape($value[1]);
+                } 
+    			break;
+    			
+			case PDF_TYPE_STREAM :
+			    if ($this->encrypted) {
+			        $value[2][1] = $this->_RC4($this->_objectkey($this->_current_obj_id), $value[2][1]);
+                }
+                break;
+                
+            case PDF_TYPE_HEX :
+            	if ($this->encrypted) {
+                	$value[1] = $this->hex2str($value[1]);
+                	$value[1] = $this->_RC4($this->_objectkey($this->_current_obj_id), $value[1]);
+                    
+                	// remake hexstring of encrypted string
+    				$value[1] = $this->str2hex($value[1]);
+                }
+                break;
+    	}
+    }
+    
+    /**
+     * Unescapes a PDF string
+     *
+     * @param string $s
+     * @return string
+     */
+    function _unescape($s) {
+        $out = '';
+        for ($count = 0, $n = strlen($s); $count < $n; $count++) {
+            if ($s[$count] != '\\' || $count == $n-1) {
+                $out .= $s[$count];
+            } else {
+                switch ($s[++$count]) {
+                    case ')':
+                    case '(':
+                    case '\\':
+                        $out .= $s[$count];
+                        break;
+                    case 'f':
+                        $out .= chr(0x0C);
+                        break;
+                    case 'b':
+                        $out .= chr(0x08);
+                        break;
+                    case 't':
+                        $out .= chr(0x09);
+                        break;
+                    case 'r':
+                        $out .= chr(0x0D);
+                        break;
+                    case 'n':
+                        $out .= chr(0x0A);
+                        break;
+                    case "\r":
+                        if ($count != $n-1 && $s[$count+1] == "\n")
+                            $count++;
+                        break;
+                    case "\n":
+                        break;
+                    default:
+                        // Octal-Values
+                        if (ord($s[$count]) >= ord('0') &&
+                            ord($s[$count]) <= ord('9')) {
+                            $oct = ''. $s[$count];
+                                
+                            if (ord($s[$count+1]) >= ord('0') &&
+                                ord($s[$count+1]) <= ord('9')) {
+                                $oct .= $s[++$count];
+                                
+                                if (ord($s[$count+1]) >= ord('0') &&
+                                    ord($s[$count+1]) <= ord('9')) {
+                                    $oct .= $s[++$count];    
+                                }                            
+                            }
+                            
+                            $out .= chr(octdec($oct));
+                        } else {
+                            $out .= $s[$count];
+                        }
+                }
+            }
+        }
+        return $out;
+    }
+    
+    /**
+     * Hexadecimal to string
+     *
+     * @param string $hex
+     * @return string
+     */
+    function hex2str($hex) {
+    	return pack('H*', str_replace(array("\r", "\n", ' '), '', $hex));
+    }
+    
+    /**
+     * String to hexadecimal
+     *
+     * @param string $str
+     * @return string
+     */
+    function str2hex($str) {
+        return current(unpack('H*', $str));
+    }
+}

fpdi/fpdi_pdf_parser.php

@@ -0,0 +1,384 @@
+<?php
+//
+//  FPDI - Version 1.3.1
+//
+//    Copyright 2004-2009 Setasign - Jan Slabon
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+require_once('pdf_parser.php');
+
+class fpdi_pdf_parser extends pdf_parser {
+
+    /**
+     * Pages
+     * Index beginns at 0
+     *
+     * @var array
+     */
+    var $pages;
+    
+    /**
+     * Page count
+     * @var integer
+     */
+    var $page_count;
+    
+    /**
+     * actual page number
+     * @var integer
+     */
+    var $pageno;
+    
+    /**
+     * PDF Version of imported Document
+     * @var string
+     */
+    var $pdfVersion;
+    
+    /**
+     * FPDI Reference
+     * @var object
+     */
+    var $fpdi;
+    
+    /**
+     * Available BoxTypes
+     *
+     * @var array
+     */
+    var $availableBoxes = array('/MediaBox', '/CropBox', '/BleedBox', '/TrimBox', '/ArtBox');
+        
+    /**
+     * Constructor
+     *
+     * @param string $filename  Source-Filename
+     * @param object $fpdi      Object of type fpdi
+     */
+    function fpdi_pdf_parser($filename, &$fpdi) {
+        $this->fpdi =& $fpdi;
+		
+        parent::pdf_parser($filename);
+
+        // resolve Pages-Dictonary
+        $pages = $this->pdf_resolve_object($this->c, $this->root[1][1]['/Pages']);
+
+        // Read pages
+        $this->read_pages($this->c, $pages, $this->pages);
+        
+        // count pages;
+        $this->page_count = count($this->pages);
+    }
+    
+    /**
+     * Overwrite parent::error()
+     *
+     * @param string $msg  Error-Message
+     */
+    function error($msg) {
+    	$this->fpdi->error($msg);	
+    }
+    
+    /**
+     * Get pagecount from sourcefile
+     *
+     * @return int
+     */
+    function getPageCount() {
+        return $this->page_count;
+    }
+
+
+    /**
+     * Set pageno
+     *
+     * @param int $pageno Pagenumber to use
+     */
+    function setPageno($pageno) {
+        $pageno = ((int) $pageno) - 1;
+
+        if ($pageno < 0 || $pageno >= $this->getPageCount()) {
+            $this->fpdi->error('Pagenumber is wrong!');
+        }
+
+        $this->pageno = $pageno;
+    }
+    
+    /**
+     * Get page-resources from current page
+     *
+     * @return array
+     */
+    function getPageResources() {
+        return $this->_getPageResources($this->pages[$this->pageno]);
+    }
+    
+    /**
+     * Get page-resources from /Page
+     *
+     * @param array $obj Array of pdf-data
+     */
+    function _getPageResources ($obj) { // $obj = /Page
+    	$obj = $this->pdf_resolve_object($this->c, $obj);
+
+        // If the current object has a resources
+    	// dictionary associated with it, we use
+    	// it. Otherwise, we move back to its
+    	// parent object.
+        if (isset ($obj[1][1]['/Resources'])) {
+    		$res = $this->pdf_resolve_object($this->c, $obj[1][1]['/Resources']);
+    		if ($res[0] == PDF_TYPE_OBJECT)
+                return $res[1];
+            return $res;
+    	} else {
+    		if (!isset ($obj[1][1]['/Parent'])) {
+    			return false;
+    		} else {
+                $res = $this->_getPageResources($obj[1][1]['/Parent']);
+                if ($res[0] == PDF_TYPE_OBJECT)
+                    return $res[1];
+                return $res;
+    		}
+    	}
+    }
+
+
+    /**
+     * Get content of current page
+     *
+     * If more /Contents is an array, the streams are concated
+     *
+     * @return string
+     */
+    function getContent() {
+        $buffer = '';
+        
+        if (isset($this->pages[$this->pageno][1][1]['/Contents'])) {
+            $contents = $this->_getPageContent($this->pages[$this->pageno][1][1]['/Contents']);
+            foreach($contents AS $tmp_content) {
+                $buffer .= $this->_rebuildContentStream($tmp_content).' ';
+            }
+        }
+        
+        return $buffer;
+    }
+    
+    
+    /**
+     * Resolve all content-objects
+     *
+     * @param array $content_ref
+     * @return array
+     */
+    function _getPageContent($content_ref) {
+        $contents = array();
+        
+        if ($content_ref[0] == PDF_TYPE_OBJREF) {
+            $content = $this->pdf_resolve_object($this->c, $content_ref);
+            if ($content[1][0] == PDF_TYPE_ARRAY) {
+                $contents = $this->_getPageContent($content[1]);
+            } else {
+                $contents[] = $content;
+            }
+        } else if ($content_ref[0] == PDF_TYPE_ARRAY) {
+            foreach ($content_ref[1] AS $tmp_content_ref) {
+                $contents = array_merge($contents,$this->_getPageContent($tmp_content_ref));
+            }
+        }
+
+        return $contents;
+    }
+
+
+    /**
+     * Rebuild content-streams
+     *
+     * @param array $obj
+     * @return string
+     */
+    function _rebuildContentStream($obj) {
+        $filters = array();
+        
+        if (isset($obj[1][1]['/Filter'])) {
+            $_filter = $obj[1][1]['/Filter'];
+
+            if ($_filter[0] == PDF_TYPE_TOKEN) {
+                $filters[] = $_filter;
+            } else if ($_filter[0] == PDF_TYPE_ARRAY) {
+                $filters = $_filter[1];
+            }
+        }
+
+        $stream = $obj[2][1];
+
+        foreach ($filters AS $_filter) {
+            switch ($_filter[1]) {
+                case '/FlateDecode':
+                    if (function_exists('gzuncompress')) {
+                        $stream = (strlen($stream) > 0) ? @gzuncompress($stream) : '';
+                    } else {
+                        $this->error(sprintf('To handle %s filter, please compile php with zlib support.',$_filter[1]));
+                    }
+                    if ($stream === false) {
+                        $this->error('Error while decompressing stream.');
+                    }
+                break;
+                case '/LZWDecode':
+                    include_once('filters/FilterLZW_FPDI.php');
+                    $decoder =& new FilterLZW_FPDI($this->fpdi);
+                    $stream = $decoder->decode($stream);
+                    break;
+                case '/ASCII85Decode':
+                    include_once('filters/FilterASCII85_FPDI.php');
+                    $decoder =& new FilterASCII85_FPDI($this->fpdi);
+                    $stream = $decoder->decode($stream);
+                    break;
+                case null:
+                    $stream = $stream;
+                break;
+                default:
+                    $this->error(sprintf('Unsupported Filter: %s',$_filter[1]));
+            }
+        }
+        
+        return $stream;
+    }
+    
+    
+    /**
+     * Get a Box from a page
+     * Arrayformat is same as used by fpdf_tpl
+     *
+     * @param array $page a /Page
+     * @param string $box_index Type of Box @see $availableBoxes
+     * @return array
+     */
+    function getPageBox($page, $box_index) {
+        $page = $this->pdf_resolve_object($this->c,$page);
+        $box = null;
+        if (isset($page[1][1][$box_index]))
+            $box =& $page[1][1][$box_index];
+        
+        if (!is_null($box) && $box[0] == PDF_TYPE_OBJREF) {
+            $tmp_box = $this->pdf_resolve_object($this->c,$box);
+            $box = $tmp_box[1];
+        }
+            
+        if (!is_null($box) && $box[0] == PDF_TYPE_ARRAY) {
+            $b =& $box[1];
+            return array('x' => $b[0][1]/$this->fpdi->k,
+                         'y' => $b[1][1]/$this->fpdi->k,
+                         'w' => abs($b[0][1]-$b[2][1])/$this->fpdi->k,
+                         'h' => abs($b[1][1]-$b[3][1])/$this->fpdi->k,
+                         'llx' => min($b[0][1], $b[2][1])/$this->fpdi->k,
+                         'lly' => min($b[1][1], $b[3][1])/$this->fpdi->k,
+                         'urx' => max($b[0][1], $b[2][1])/$this->fpdi->k,
+                         'ury' => max($b[1][1], $b[3][1])/$this->fpdi->k,
+                         );
+        } else if (!isset ($page[1][1]['/Parent'])) {
+            return false;
+        } else {
+            return $this->getPageBox($this->pdf_resolve_object($this->c, $page[1][1]['/Parent']), $box_index);
+        }
+    }
+
+    function getPageBoxes($pageno) {
+        return $this->_getPageBoxes($this->pages[$pageno-1]);
+    }
+    
+    /**
+     * Get all Boxes from /Page
+     *
+     * @param array a /Page
+     * @return array
+     */
+    function _getPageBoxes($page) {
+        $boxes = array();
+
+        foreach($this->availableBoxes AS $box) {
+            if ($_box = $this->getPageBox($page,$box)) {
+                $boxes[$box] = $_box;
+            }
+        }
+
+        return $boxes;
+    }
+
+    /**
+     * Get the page rotation by pageno
+     *
+     * @param integer $pageno
+     * @return array
+     */
+    function getPageRotation($pageno) {
+        return $this->_getPageRotation($this->pages[$pageno-1]);
+    }
+    
+    function _getPageRotation ($obj) { // $obj = /Page
+    	$obj = $this->pdf_resolve_object($this->c, $obj);
+    	if (isset ($obj[1][1]['/Rotate'])) {
+    		$res = $this->pdf_resolve_object($this->c, $obj[1][1]['/Rotate']);
+    		if ($res[0] == PDF_TYPE_OBJECT)
+                return $res[1];
+            return $res;
+    	} else {
+    		if (!isset ($obj[1][1]['/Parent'])) {
+    			return false;
+    		} else {
+                $res = $this->_getPageRotation($obj[1][1]['/Parent']);
+                if ($res[0] == PDF_TYPE_OBJECT)
+                    return $res[1];
+                return $res;
+    		}
+    	}
+    }
+    
+    /**
+     * Read all /Page(es)
+     *
+     * @param object pdf_context
+     * @param array /Pages
+     * @param array the result-array
+     */
+    function read_pages (&$c, &$pages, &$result) {
+        // Get the kids dictionary
+    	$kids = $this->pdf_resolve_object ($c, $pages[1][1]['/Kids']);
+
+        if (!is_array($kids))
+            $this->error('Cannot find /Kids in current /Page-Dictionary');
+        foreach ($kids[1] as $v) {
+    		$pg = $this->pdf_resolve_object ($c, $v);
+            if ($pg[1][1]['/Type'][1] === '/Pages') {
+                // If one of the kids is an embedded
+    			// /Pages array, resolve it as well.
+                $this->read_pages ($c, $pg, $result);
+    		} else {
+    			$result[] = $pg;
+    		}
+    	}
+    }
+
+    
+    
+    /**
+     * Get PDF-Version
+     *
+     * And reset the PDF Version used in FPDI if needed
+     */
+    function getPDFVersion() {
+        parent::getPDFVersion();
+        $this->fpdi->PDFVersion = max($this->fpdi->PDFVersion, $this->pdfVersion);
+    }
+    
+}

fpdi/pdf_context.php

@@ -0,0 +1,97 @@
+<?php
+//
+//  FPDI - Version 1.3.1
+//
+//    Copyright 2004-2009 Setasign - Jan Slabon
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+class pdf_context {
+
+    /**
+     * Modi
+     *
+     * @var integer 0 = file | 1 = string
+     */
+    var $_mode = 0;
+    
+	var $file;
+	var $buffer;
+	var $offset;
+	var $length;
+
+	var $stack;
+
+	// Constructor
+
+	function pdf_context(&$f) {
+		$this->file =& $f;
+		if (is_string($this->file))
+		    $this->_mode = 1;
+		$this->reset();
+	}
+
+	// Optionally move the file
+	// pointer to a new location
+	// and reset the buffered data
+
+	function reset($pos = null, $l = 100) {
+	    if ($this->_mode == 0) {
+        	if (!is_null ($pos)) {
+    			fseek ($this->file, $pos);
+    		}
+    
+    		$this->buffer = $l > 0 ? fread($this->file, $l) : '';
+    		$this->length = strlen($this->buffer);
+    		if ($this->length < $l)
+                $this->increase_length($l - $this->length);
+	    } else {
+	        $this->buffer = $this->file;
+	        $this->length = strlen($this->buffer);
+	    }
+		$this->offset = 0;
+		$this->stack = array();
+	}
+
+	// Make sure that there is at least one
+	// character beyond the current offset in
+	// the buffer to prevent the tokenizer
+	// from attempting to access data that does
+	// not exist
+
+	function ensure_content() {
+		if ($this->offset >= $this->length - 1) {
+			return $this->increase_length();
+		} else {
+			return true;
+		}
+	}
+
+	// Forcefully read more data into the buffer
+
+	function increase_length($l=100) {
+		if ($this->_mode == 0 && feof($this->file)) {
+			return false;
+		} else if ($this->_mode == 0) {
+		    $totalLength = $this->length + $l;
+		    do {
+                $this->buffer .= fread($this->file, $totalLength-$this->length);
+            } while ((($this->length = strlen($this->buffer)) != $totalLength) && !feof($this->file));
+			
+			return true;
+		} else {
+	        return false;
+		}
+	}
+}

fpdi/pdf_parser.php

@@ -0,0 +1,706 @@
+<?php
+//
+//  FPDI - Version 1.3.1
+//
+//    Copyright 2004-2009 Setasign - Jan Slabon
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+if (!defined ('PDF_TYPE_NULL'))
+    define ('PDF_TYPE_NULL', 0);
+if (!defined ('PDF_TYPE_NUMERIC'))
+    define ('PDF_TYPE_NUMERIC', 1);
+if (!defined ('PDF_TYPE_TOKEN'))
+    define ('PDF_TYPE_TOKEN', 2);
+if (!defined ('PDF_TYPE_HEX'))
+    define ('PDF_TYPE_HEX', 3);
+if (!defined ('PDF_TYPE_STRING'))
+    define ('PDF_TYPE_STRING', 4);
+if (!defined ('PDF_TYPE_DICTIONARY'))
+    define ('PDF_TYPE_DICTIONARY', 5);
+if (!defined ('PDF_TYPE_ARRAY'))
+    define ('PDF_TYPE_ARRAY', 6);
+if (!defined ('PDF_TYPE_OBJDEC'))
+    define ('PDF_TYPE_OBJDEC', 7);
+if (!defined ('PDF_TYPE_OBJREF'))
+    define ('PDF_TYPE_OBJREF', 8);
+if (!defined ('PDF_TYPE_OBJECT'))
+    define ('PDF_TYPE_OBJECT', 9);
+if (!defined ('PDF_TYPE_STREAM'))
+    define ('PDF_TYPE_STREAM', 10);
+if (!defined ('PDF_TYPE_BOOLEAN'))
+    define ('PDF_TYPE_BOOLEAN', 11);
+if (!defined ('PDF_TYPE_REAL'))
+    define ('PDF_TYPE_REAL', 12);
+    
+require_once('pdf_context.php');
+
+if (!class_exists('pdf_parser')) {
+    
+class pdf_parser {
+	
+	/**
+     * Filename
+     * @var string
+     */
+    var $filename;
+    
+    /**
+     * File resource
+     * @var resource
+     */
+    var $f;
+    
+    /**
+     * PDF Context
+     * @var object pdf_context-Instance
+     */
+    var $c;
+    
+    /**
+     * xref-Data
+     * @var array
+     */
+    var $xref;
+
+    /**
+     * root-Object
+     * @var array
+     */
+    var $root;
+	
+    /**
+     * PDF version of the loaded document
+     * @var string
+     */
+    var $pdfVersion;
+    
+    /**
+     * Constructor
+     *
+     * @param string $filename  Source-Filename
+     */
+	function pdf_parser($filename) {
+        $this->filename = $filename;
+        
+        $this->f = @fopen($this->filename, 'rb');
+
+        if (!$this->f)
+            $this->error(sprintf('Cannot open %s !', $filename));
+
+        $this->getPDFVersion();
+
+        $this->c =& new pdf_context($this->f);
+        
+        // Read xref-Data
+        $this->xref = array();
+        $this->pdf_read_xref($this->xref, $this->pdf_find_xref());
+        
+        // Check for Encryption
+        $this->getEncryption();
+
+        // Read root
+        $this->pdf_read_root();
+    }
+    
+    /**
+     * Close the opened file
+     */
+    function closeFile() {
+    	if (isset($this->f) && is_resource($this->f)) {
+    	    fclose($this->f);	
+    		unset($this->f);
+    	}	
+    }
+    
+    /**
+     * Print Error and die
+     *
+     * @param string $msg  Error-Message
+     */
+    function error($msg) {
+    	die('<b>PDF-Parser Error:</b> '.$msg);	
+    }
+    
+    /**
+     * Check Trailer for Encryption
+     */
+    function getEncryption() {
+        if (isset($this->xref['trailer'][1]['/Encrypt'])) {
+            $this->error('File is encrypted!');
+        }
+    }
+    
+	/**
+     * Find/Return /Root
+     *
+     * @return array
+     */
+    function pdf_find_root() {
+        if ($this->xref['trailer'][1]['/Root'][0] != PDF_TYPE_OBJREF) {
+            $this->error('Wrong Type of Root-Element! Must be an indirect reference');
+        }
+        
+        return $this->xref['trailer'][1]['/Root'];
+    }
+
+    /**
+     * Read the /Root
+     */
+    function pdf_read_root() {
+        // read root
+        $this->root = $this->pdf_resolve_object($this->c, $this->pdf_find_root());
+    }
+    
+    /**
+     * Get PDF-Version
+     *
+     * And reset the PDF Version used in FPDI if needed
+     */
+    function getPDFVersion() {
+        fseek($this->f, 0);
+        preg_match('/\d\.\d/',fread($this->f,16),$m);
+        if (isset($m[0]))
+            $this->pdfVersion = $m[0];
+        return $this->pdfVersion;
+    }
+    
+    /**
+     * Find the xref-Table
+     */
+    function pdf_find_xref() {
+       	$toRead = 1500;
+                
+        $stat = fseek ($this->f, -$toRead, SEEK_END);
+        if ($stat === -1) {
+            fseek ($this->f, 0);
+        }
+       	$data = fread($this->f, $toRead);
+        
+        $pos = strlen($data) - strpos(strrev($data), strrev('startxref')); 
+        $data = substr($data, $pos);
+        
+        if (!preg_match('/\s*(\d+).*$/s', $data, $matches)) {
+            $this->error('Unable to find pointer to xref table');
+    	}
+
+    	return (int) $matches[1];
+    }
+
+    /**
+     * Read xref-table
+     *
+     * @param array $result Array of xref-table
+     * @param integer $offset of xref-table
+     */
+    function pdf_read_xref(&$result, $offset) {
+        
+        fseek($this->f, $o_pos = $offset-20); // set some bytes backwards to fetch errorious docs
+            
+        $data = fread($this->f, 100);
+        
+        $xrefPos = strrpos($data, 'xref');
+
+        if ($xrefPos === false) {
+            fseek($this->f, $offset);
+            $c =&  new pdf_context($this->f);
+            $xrefStreamObjDec = $this->pdf_read_value($c);
+            
+            if (is_array($xrefStreamObjDec) && isset($xrefStreamObjDec[0]) && $xrefStreamObjDec[0] == PDF_TYPE_OBJDEC) {
+                $this->error(sprintf('This document (%s) probably uses a compression technique which is not supported by the free parser shipped with FPDI.', $this->filename));
+            } else {            
+                $this->error('Unable to find xref table.');
+            }
+        }
+        
+        if (!isset($result['xref_location'])) {
+            $result['xref_location'] = $o_pos+$xrefPos;
+            $result['max_object'] = 0;
+    	}
+
+    	$cylces = -1;
+        $bytesPerCycle = 100;
+        
+    	fseek($this->f, $o_pos = $o_pos+$xrefPos+4); // set the handle directly after the "xref"-keyword
+        $data = fread($this->f, $bytesPerCycle);
+        
+        while (($trailerPos = strpos($data, 'trailer', max($bytesPerCycle*$cylces++, 0))) === false && !feof($this->f)) {
+            $data .= fread($this->f, $bytesPerCycle);
+        }
+        
+        if ($trailerPos === false) {
+            $this->error('Trailer keyword not found after xref table');
+        }
+        
+        $data = substr($data, 0, $trailerPos);
+        
+        // get Line-Ending
+        preg_match_all("/(\r\n|\n|\r)/", substr($data, 0, 100), $m); // check the first 100 bytes for linebreaks
+
+        $differentLineEndings = count(array_unique($m[0]));
+        if ($differentLineEndings > 1) {
+            $lines = preg_split("/(\r\n|\n|\r)/", $data, -1, PREG_SPLIT_NO_EMPTY);
+        } else {
+            $lines = explode($m[0][1], $data);
+        }
+        
+        $data = $differentLineEndings = $m = null;
+        unset($data, $differentLineEndings, $m);
+        
+        $linesCount = count($lines);
+        
+        $start = 1;
+        
+        for ($i = 0; $i < $linesCount; $i++) {
+            $line = trim($lines[$i]);
+            if ($line) {
+                $pieces = explode(' ', $line);
+                $c = count($pieces);
+                switch($c) {
+                    case 2:
+                        $start = (int)$pieces[0];
+                        $end   = $start+(int)$pieces[1];
+                        if ($end > $result['max_object'])
+                            $result['max_object'] = $end;
+                        break;
+                    case 3:
+                        if (!isset($result['xref'][$start]))
+                            $result['xref'][$start] = array();
+                        
+                        if (!array_key_exists($gen = (int) $pieces[1], $result['xref'][$start])) {
+                	        $result['xref'][$start][$gen] = $pieces[2] == 'n' ? (int) $pieces[0] : null;
+                	    }
+                        $start++;
+                        break;
+                    default:
+                        $this->error('Unexpected data in xref table');
+                }
+            }
+        }
+        
+        $lines = $pieces = $line = $start = $end = $gen = null;
+        unset($lines, $pieces, $line, $start, $end, $gen);
+        
+        fseek($this->f, $o_pos+$trailerPos+7);
+        
+        $c =&  new pdf_context($this->f);
+	    $trailer = $this->pdf_read_value($c);
+	    
+	    $c = null;
+	    unset($c);
+	    
+	    if (!isset($result['trailer'])) {
+            $result['trailer'] = $trailer;          
+	    }
+	    
+	    if (isset($trailer[1]['/Prev'])) {
+	        $this->pdf_read_xref($result, $trailer[1]['/Prev'][1]);
+	    } 
+	    
+	    $trailer = null;
+	    unset($trailer);
+        
+        return true;
+    }
+    
+    /**
+     * Reads an Value
+     *
+     * @param object $c pdf_context
+     * @param string $token a Token
+     * @return mixed
+     */
+    function pdf_read_value(&$c, $token = null) {
+    	if (is_null($token)) {
+    	    $token = $this->pdf_read_token($c);
+    	}
+    	
+        if ($token === false) {
+    	    return false;
+    	}
+
+    	switch ($token) {
+            case	'<':
+    			// This is a hex string.
+    			// Read the value, then the terminator
+
+                $pos = $c->offset;
+
+    			while(1) {
+
+                    $match = strpos ($c->buffer, '>', $pos);
+				
+    				// If you can't find it, try
+    				// reading more data from the stream
+
+    				if ($match === false) {
+    					if (!$c->increase_length()) {
+    						return false;
+    					} else {
+                        	continue;
+                    	}
+    				}
+
+    				$result = substr ($c->buffer, $c->offset, $match - $c->offset);
+    				$c->offset = $match + 1;
+    				
+    				return array (PDF_TYPE_HEX, $result);
+                }
+                
+                break;
+    		case	'<<':
+    			// This is a dictionary.
+
+    			$result = array();
+
+    			// Recurse into this function until we reach
+    			// the end of the dictionary.
+    			while (($key = $this->pdf_read_token($c)) !== '>>') {
+    				if ($key === false) {
+    					return false;
+    				}
+    				
+    				if (($value =   $this->pdf_read_value($c)) === false) {
+    					return false;
+    				}
+    				
+    				// Catch missing value
+    				if ($value[0] == PDF_TYPE_TOKEN && $value[1] == '>>') {
+    				    $result[$key] = array(PDF_TYPE_NULL);
+    				    break;
+    				}
+    				
+    				$result[$key] = $value;
+    			}
+				
+    			return array (PDF_TYPE_DICTIONARY, $result);
+
+    		case	'[':
+    			// This is an array.
+
+    			$result = array();
+
+    			// Recurse into this function until we reach
+    			// the end of the array.
+    			while (($token = $this->pdf_read_token($c)) !== ']') {
+                    if ($token === false) {
+    					return false;
+    				}
+					
+    				if (($value = $this->pdf_read_value($c, $token)) === false) {
+                        return false;
+    				}
+					
+    				$result[] = $value;
+    			}
+    			
+                return array (PDF_TYPE_ARRAY, $result);
+
+    		case	'('		:
+                // This is a string
+                $pos = $c->offset;
+                
+                $openBrackets = 1;
+    			do {
+                    for (; $openBrackets != 0 && $pos < $c->length; $pos++) {
+                        switch (ord($c->buffer[$pos])) {
+                            case 0x28: // '('
+                                $openBrackets++;
+                                break;
+                            case 0x29: // ')'
+                                $openBrackets--;
+                                break;
+                            case 0x5C: // backslash
+                                $pos++;
+                        }
+                    }
+    			} while($openBrackets != 0 && $c->increase_length());
+    			
+    			$result = substr($c->buffer, $c->offset, $pos - $c->offset - 1);
+    			$c->offset = $pos;
+    			
+    			return array (PDF_TYPE_STRING, $result);
+
+            case 'stream':
+            	$o_pos = ftell($c->file)-strlen($c->buffer);
+		        $o_offset = $c->offset;
+		        
+		        $c->reset($startpos = $o_pos + $o_offset);
+		        
+		        $e = 0; // ensure line breaks in front of the stream
+		        if ($c->buffer[0] == chr(10) || $c->buffer[0] == chr(13))
+		        	$e++;
+		        if ($c->buffer[1] == chr(10) && $c->buffer[0] != chr(10))
+		        	$e++;
+		        
+		        if ($this->actual_obj[1][1]['/Length'][0] == PDF_TYPE_OBJREF) {
+		        	$tmp_c =& new pdf_context($this->f);
+		        	$tmp_length = $this->pdf_resolve_object($tmp_c,$this->actual_obj[1][1]['/Length']);
+		        	$length = $tmp_length[1][1];
+		        } else {
+		        	$length = $this->actual_obj[1][1]['/Length'][1];	
+		        }
+		        
+		        if ($length > 0) {
+    		        $c->reset($startpos+$e,$length);
+    		        $v = $c->buffer;
+		        } else {
+		            $v = '';   
+		        }
+		        $c->reset($startpos+$e+$length+9); // 9 = strlen("endstream")
+		        
+		        return array(PDF_TYPE_STREAM, $v);
+		        
+	        default	:
+            	if (is_numeric ($token)) {
+                    // A numeric token. Make sure that
+    				// it is not part of something else.
+    				if (($tok2 = $this->pdf_read_token ($c)) !== false) {
+                        if (is_numeric ($tok2)) {
+
+    						// Two numeric tokens in a row.
+    						// In this case, we're probably in
+    						// front of either an object reference
+    						// or an object specification.
+    						// Determine the case and return the data
+    						if (($tok3 = $this->pdf_read_token ($c)) !== false) {
+                                switch ($tok3) {
+    								case	'obj'	:
+                                        return array (PDF_TYPE_OBJDEC, (int) $token, (int) $tok2);
+    								case	'R'		:
+    									return array (PDF_TYPE_OBJREF, (int) $token, (int) $tok2);
+    							}
+    							// If we get to this point, that numeric value up
+    							// there was just a numeric value. Push the extra
+    							// tokens back into the stack and return the value.
+    							array_push ($c->stack, $tok3);
+    						}
+    					}
+
+    					array_push ($c->stack, $tok2);
+    				}
+
+    				if ($token === (string)((int)$token))
+        				return array (PDF_TYPE_NUMERIC, (int)$token);
+    				else 
+    					return array (PDF_TYPE_REAL, (float)$token);
+    			} else if ($token == 'true' || $token == 'false') {
+                    return array (PDF_TYPE_BOOLEAN, $token == 'true');
+    			} else if ($token == 'null') {
+    			   return array (PDF_TYPE_NULL);
+    			} else {
+                    // Just a token. Return it.
+    				return array (PDF_TYPE_TOKEN, $token);
+    			}
+         }
+    }
+    
+    /**
+     * Resolve an object
+     *
+     * @param object $c pdf_context
+     * @param array $obj_spec The object-data
+     * @param boolean $encapsulate Must set to true, cause the parsing and fpdi use this method only without this para
+     */
+    function pdf_resolve_object(&$c, $obj_spec, $encapsulate = true) {
+        // Exit if we get invalid data
+    	if (!is_array($obj_spec)) {
+            $ret = false;
+    	    return $ret;
+    	}
+
+    	if ($obj_spec[0] == PDF_TYPE_OBJREF) {
+
+    		// This is a reference, resolve it
+    		if (isset($this->xref['xref'][$obj_spec[1]][$obj_spec[2]])) {
+
+    			// Save current file position
+    			// This is needed if you want to resolve
+    			// references while you're reading another object
+    			// (e.g.: if you need to determine the length
+    			// of a stream)
+
+    			$old_pos = ftell($c->file);
+
+    			// Reposition the file pointer and
+    			// load the object header.
+				
+    			$c->reset($this->xref['xref'][$obj_spec[1]][$obj_spec[2]]);
+
+    			$header = $this->pdf_read_value($c);
+
+    			if ($header[0] != PDF_TYPE_OBJDEC || $header[1] != $obj_spec[1] || $header[2] != $obj_spec[2]) {
+    				$this->error("Unable to find object ({$obj_spec[1]}, {$obj_spec[2]}) at expected location");
+    			}
+
+    			// If we're being asked to store all the information
+    			// about the object, we add the object ID and generation
+    			// number for later use
+				$result = array();
+				$this->actual_obj =& $result;
+    			if ($encapsulate) {
+    				$result = array (
+    					PDF_TYPE_OBJECT,
+    					'obj' => $obj_spec[1],
+    					'gen' => $obj_spec[2]
+    				);
+    			} 
+
+    			// Now simply read the object data until
+    			// we encounter an end-of-object marker
+    			while(1) {
+                    $value = $this->pdf_read_value($c);
+					if ($value === false || count($result) > 4) {
+						// in this case the parser coudn't find an endobj so we break here
+						break;
+    				}
+
+    				if ($value[0] == PDF_TYPE_TOKEN && $value[1] === 'endobj') {
+    					break;
+    				}
+
+                    $result[] = $value;
+    			}
+
+    			$c->reset($old_pos);
+
+                if (isset($result[2][0]) && $result[2][0] == PDF_TYPE_STREAM) {
+                    $result[0] = PDF_TYPE_STREAM;
+                }
+
+    			return $result;
+    		}
+    	} else {
+    		return $obj_spec;
+    	}
+    }
+
+    
+    
+    /**
+     * Reads a token from the file
+     *
+     * @param object $c pdf_context
+     * @return mixed
+     */
+    function pdf_read_token(&$c)
+    {
+    	// If there is a token available
+    	// on the stack, pop it out and
+    	// return it.
+
+    	if (count($c->stack)) {
+    		return array_pop($c->stack);
+    	}
+
+    	// Strip away any whitespace
+
+    	do {
+    		if (!$c->ensure_content()) {
+    			return false;
+    		}
+    		$c->offset += strspn($c->buffer, " \n\r\t", $c->offset);
+    	} while ($c->offset >= $c->length - 1);
+
+    	// Get the first character in the stream
+
+    	$char = $c->buffer[$c->offset++];
+
+    	switch ($char) {
+
+    		case '[':
+    		case ']':
+    		case '(':
+    		case ')':
+    		
+    			// This is either an array or literal string
+    			// delimiter, Return it
+
+    			return $char;
+
+    		case '<':
+    		case '>':
+
+    			// This could either be a hex string or
+    			// dictionary delimiter. Determine the
+    			// appropriate case and return the token
+
+    			if ($c->buffer[$c->offset] == $char) {
+    				if (!$c->ensure_content()) {
+    				    return false;
+    				}
+    				$c->offset++;
+    				return $char . $char;
+    			} else {
+    				return $char;
+    			}
+
+			case '%':
+			    
+			    // This is a comment - jump over it!
+			    
+                $pos = $c->offset;
+    			while(1) {
+    			    $match = preg_match("/(\r\n|\r|\n)/", $c->buffer, $m, PREG_OFFSET_CAPTURE, $pos);
+                    if ($match === 0) {
+    					if (!$c->increase_length()) {
+    						return false;
+    					} else {
+                        	continue;
+                    	}
+    				}
+
+    				$c->offset = $m[0][1]+strlen($m[0][0]);
+    				
+    				return $this->pdf_read_token($c);
+                }
+                
+			default:
+
+    			// This is "another" type of token (probably
+    			// a dictionary entry or a numeric value)
+    			// Find the end and return it.
+
+    			if (!$c->ensure_content()) {
+    				return false;
+    			}
+
+    			while(1) {
+
+    				// Determine the length of the token
+
+    				$pos = strcspn($c->buffer, " %[]<>()\r\n\t/", $c->offset);
+    				
+    				if ($c->offset + $pos <= $c->length - 1) {
+    					break;
+    				} else {
+    					// If the script reaches this point,
+    					// the token may span beyond the end
+    					// of the current buffer. Therefore,
+    					// we increase the size of the buffer
+    					// and try again--just to be safe.
+
+    					$c->increase_length();
+    				}
+    			}
+
+    			$result = substr($c->buffer, $c->offset - 1, $pos + 1);
+
+    			$c->offset += $pos;
+    			return $result;
+    	}
+    }
+}
+
+}