You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1429 lines
49 KiB
1429 lines
49 KiB
<?php
|
|
/**
|
|
* Zend Framework
|
|
*
|
|
* LICENSE
|
|
*
|
|
* This source file is subject to the new BSD license that is bundled
|
|
* with this package in the file LICENSE.txt.
|
|
* It is also available through the world-wide-web at this URL:
|
|
* http://framework.zend.com/license/new-bsd
|
|
* If you did not receive a copy of the license and are unable to
|
|
* obtain it through the world-wide-web, please send an email
|
|
* to license@zend.com so we can send you a copy immediately.
|
|
*
|
|
* @category Zend
|
|
* @package Zend_Pdf
|
|
* @copyright Copyright (c) 2005-2014 Zend Technologies USA Inc. (http://www.zend.com)
|
|
* @license http://framework.zend.com/license/new-bsd New BSD License
|
|
* @version $Id$
|
|
*/
|
|
|
|
|
|
/** User land classes and interfaces turned on by Zend/Pdf.php file inclusion. */
|
|
/** @todo Section should be removed with ZF 2.0 release as obsolete */
|
|
|
|
/** Zend_Pdf_Page */
|
|
// require_once 'Zend/Pdf/Page.php';
|
|
|
|
/** Zend_Pdf_Style */
|
|
// require_once 'Zend/Pdf/Style.php';
|
|
|
|
/** Zend_Pdf_Color_GrayScale */
|
|
// require_once 'Zend/Pdf/Color/GrayScale.php';
|
|
|
|
/** Zend_Pdf_Color_Rgb */
|
|
// require_once 'Zend/Pdf/Color/Rgb.php';
|
|
|
|
/** Zend_Pdf_Color_Cmyk */
|
|
// require_once 'Zend/Pdf/Color/Cmyk.php';
|
|
|
|
/** Zend_Pdf_Color_Html */
|
|
// require_once 'Zend/Pdf/Color/Html.php';
|
|
|
|
/** Zend_Pdf_Image */
|
|
// require_once 'Zend/Pdf/Image.php';
|
|
|
|
/** Zend_Pdf_Font */
|
|
// require_once 'Zend/Pdf/Font.php';
|
|
|
|
/** Zend_Pdf_Resource_Extractor */
|
|
// require_once 'Zend/Pdf/Resource/Extractor.php';
|
|
|
|
/** Zend_Pdf_Canvas */
|
|
// require_once 'Zend/Pdf/Canvas.php';
|
|
|
|
|
|
/** Internally used classes */
|
|
// require_once 'Zend/Pdf/Element.php';
|
|
// require_once 'Zend/Pdf/Element/Array.php';
|
|
// require_once 'Zend/Pdf/Element/String/Binary.php';
|
|
// require_once 'Zend/Pdf/Element/Boolean.php';
|
|
// require_once 'Zend/Pdf/Element/Dictionary.php';
|
|
// require_once 'Zend/Pdf/Element/Name.php';
|
|
// require_once 'Zend/Pdf/Element/Null.php';
|
|
// require_once 'Zend/Pdf/Element/Numeric.php';
|
|
// require_once 'Zend/Pdf/Element/String.php';
|
|
|
|
|
|
/**
|
|
* General entity which describes PDF document.
|
|
* It implements document abstraction with a document level operations.
|
|
*
|
|
* Class is used to create new PDF document or load existing document.
|
|
* See details in a class constructor description
|
|
*
|
|
* Class agregates document level properties and entities (pages, bookmarks,
|
|
* document level actions, attachments, form object, etc)
|
|
*
|
|
* @category Zend
|
|
* @package Zend_Pdf
|
|
* @copyright Copyright (c) 2005-2014 Zend Technologies USA Inc. (http://www.zend.com)
|
|
* @license http://framework.zend.com/license/new-bsd New BSD License
|
|
*/
|
|
class Zend_Pdf
|
|
{
|
|
/**** Class Constants ****/
|
|
|
|
/**
|
|
* Version number of generated PDF documents.
|
|
*/
|
|
const PDF_VERSION = '1.4';
|
|
|
|
/**
|
|
* PDF file header.
|
|
*/
|
|
const PDF_HEADER = "%PDF-1.4\n%\xE2\xE3\xCF\xD3\n";
|
|
|
|
/**
|
|
* Pages collection
|
|
*
|
|
* @todo implement it as a class, which supports ArrayAccess and Iterator interfaces,
|
|
* to provide incremental parsing and pages tree updating.
|
|
* That will give good performance and memory (PDF size) benefits.
|
|
*
|
|
* @var array - array of Zend_Pdf_Page object
|
|
*/
|
|
public $pages = array();
|
|
|
|
/**
|
|
* Document properties
|
|
*
|
|
* It's an associative array with PDF meta information, values may
|
|
* be string, boolean or float.
|
|
* Returned array could be used directly to access, add, modify or remove
|
|
* document properties.
|
|
*
|
|
* Standard document properties: Title (must be set for PDF/X documents), Author,
|
|
* Subject, Keywords (comma separated list), Creator (the name of the application,
|
|
* that created document, if it was converted from other format), Trapped (must be
|
|
* true, false or null, can not be null for PDF/X documents)
|
|
*
|
|
* @var array
|
|
*/
|
|
public $properties = array();
|
|
|
|
/**
|
|
* Original properties set.
|
|
*
|
|
* Used for tracking properties changes
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $_originalProperties = array();
|
|
|
|
/**
|
|
* Document level javascript
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $_javaScript = null;
|
|
|
|
/**
|
|
* Document named destinations or "GoTo..." actions, used to refer
|
|
* document parts from outside PDF
|
|
*
|
|
* @var array - array of Zend_Pdf_Target objects
|
|
*/
|
|
protected $_namedTargets = array();
|
|
|
|
/**
|
|
* Document outlines
|
|
*
|
|
* @var array - array of Zend_Pdf_Outline objects
|
|
*/
|
|
public $outlines = array();
|
|
|
|
/**
|
|
* Original document outlines list
|
|
* Used to track outlines update
|
|
*
|
|
* @var array - array of Zend_Pdf_Outline objects
|
|
*/
|
|
protected $_originalOutlines = array();
|
|
|
|
/**
|
|
* Original document outlines open elements count
|
|
* Used to track outlines update
|
|
*
|
|
* @var integer
|
|
*/
|
|
protected $_originalOpenOutlinesCount = 0;
|
|
|
|
/**
|
|
* Pdf trailer (last or just created)
|
|
*
|
|
* @var Zend_Pdf_Trailer
|
|
*/
|
|
protected $_trailer = null;
|
|
|
|
/**
|
|
* PDF objects factory.
|
|
*
|
|
* @var Zend_Pdf_ElementFactory_Interface
|
|
*/
|
|
protected $_objFactory = null;
|
|
|
|
/**
|
|
* Memory manager for stream objects
|
|
*
|
|
* @var Zend_Memory_Manager|null
|
|
*/
|
|
protected static $_memoryManager = null;
|
|
|
|
/**
|
|
* Pdf file parser.
|
|
* It's not used, but has to be destroyed only with Zend_Pdf object
|
|
*
|
|
* @var Zend_Pdf_Parser
|
|
*/
|
|
protected $_parser;
|
|
|
|
|
|
/**
|
|
* List of inheritable attributesfor pages tree
|
|
*
|
|
* @var array
|
|
*/
|
|
protected static $_inheritableAttributes = array('Resources', 'MediaBox', 'CropBox', 'Rotate');
|
|
|
|
/**
|
|
* True if the object is a newly created PDF document (affects save() method behavior)
|
|
* False otherwise
|
|
*
|
|
* @var boolean
|
|
*/
|
|
protected $_isNewDocument = true;
|
|
|
|
/**
|
|
* Request used memory manager
|
|
*
|
|
* @return Zend_Memory_Manager
|
|
*/
|
|
static public function getMemoryManager()
|
|
{
|
|
if (self::$_memoryManager === null) {
|
|
// require_once 'Zend/Memory.php';
|
|
self::$_memoryManager = Zend_Memory::factory('none');
|
|
}
|
|
|
|
return self::$_memoryManager;
|
|
}
|
|
|
|
/**
|
|
* Set user defined memory manager
|
|
*
|
|
* @param Zend_Memory_Manager $memoryManager
|
|
*/
|
|
static public function setMemoryManager(Zend_Memory_Manager $memoryManager)
|
|
{
|
|
self::$_memoryManager = $memoryManager;
|
|
}
|
|
|
|
|
|
/**
|
|
* Create new PDF document from a $source string
|
|
*
|
|
* @param string $source
|
|
* @param integer $revision
|
|
* @return Zend_Pdf
|
|
*/
|
|
public static function parse(&$source = null, $revision = null)
|
|
{
|
|
return new Zend_Pdf($source, $revision);
|
|
}
|
|
|
|
/**
|
|
* Load PDF document from a file
|
|
*
|
|
* @param string $source
|
|
* @param integer $revision
|
|
* @return Zend_Pdf
|
|
*/
|
|
public static function load($source = null, $revision = null)
|
|
{
|
|
return new Zend_Pdf($source, $revision, true);
|
|
}
|
|
|
|
/**
|
|
* Render PDF document and save it.
|
|
*
|
|
* If $updateOnly is true and it's not a new document, then it only
|
|
* appends new section to the end of file.
|
|
*
|
|
* @param string $filename
|
|
* @param boolean $updateOnly
|
|
* @throws Zend_Pdf_Exception
|
|
*/
|
|
public function save($filename, $updateOnly = false)
|
|
{
|
|
if (($file = @fopen($filename, $updateOnly ? 'ab':'wb')) === false ) {
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
throw new Zend_Pdf_Exception( "Can not open '$filename' file for writing." );
|
|
}
|
|
|
|
$this->render($updateOnly, $file);
|
|
|
|
fclose($file);
|
|
}
|
|
|
|
/**
|
|
* Creates or loads PDF document.
|
|
*
|
|
* If $source is null, then it creates a new document.
|
|
*
|
|
* If $source is a string and $load is false, then it loads document
|
|
* from a binary string.
|
|
*
|
|
* If $source is a string and $load is true, then it loads document
|
|
* from a file.
|
|
* $revision used to roll back document to specified version
|
|
* (0 - current version, 1 - previous version, 2 - ...)
|
|
*
|
|
* @param string $source - PDF file to load
|
|
* @param integer $revision
|
|
* @param bool $load
|
|
* @throws Zend_Pdf_Exception
|
|
* @return Zend_Pdf
|
|
*/
|
|
public function __construct($source = null, $revision = null, $load = false)
|
|
{
|
|
// require_once 'Zend/Pdf/ElementFactory.php';
|
|
$this->_objFactory = Zend_Pdf_ElementFactory::createFactory(1);
|
|
|
|
if ($source !== null) {
|
|
// require_once 'Zend/Pdf/Parser.php';
|
|
$this->_parser = new Zend_Pdf_Parser($source, $this->_objFactory, $load);
|
|
$this->_pdfHeaderVersion = $this->_parser->getPDFVersion();
|
|
$this->_trailer = $this->_parser->getTrailer();
|
|
if ($this->_trailer->Encrypt !== null) {
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
throw new Zend_Pdf_Exception('Encrypted document modification is not supported');
|
|
}
|
|
if ($revision !== null) {
|
|
$this->rollback($revision);
|
|
} else {
|
|
$this->_loadPages($this->_trailer->Root->Pages);
|
|
}
|
|
|
|
$this->_loadNamedDestinations($this->_trailer->Root, $this->_parser->getPDFVersion());
|
|
$this->_loadOutlines($this->_trailer->Root);
|
|
|
|
if ($this->_trailer->Info !== null) {
|
|
$this->properties = $this->_trailer->Info->toPhp();
|
|
|
|
if (isset($this->properties['Trapped'])) {
|
|
switch ($this->properties['Trapped']) {
|
|
case 'True':
|
|
$this->properties['Trapped'] = true;
|
|
break;
|
|
|
|
case 'False':
|
|
$this->properties['Trapped'] = false;
|
|
break;
|
|
|
|
case 'Unknown':
|
|
$this->properties['Trapped'] = null;
|
|
break;
|
|
|
|
default:
|
|
// Wrong property value
|
|
// Do nothing
|
|
break;
|
|
}
|
|
}
|
|
|
|
$this->_originalProperties = $this->properties;
|
|
}
|
|
|
|
$this->_isNewDocument = false;
|
|
} else {
|
|
$this->_pdfHeaderVersion = Zend_Pdf::PDF_VERSION;
|
|
|
|
$trailerDictionary = new Zend_Pdf_Element_Dictionary();
|
|
|
|
/**
|
|
* Document id
|
|
*/
|
|
$docId = md5(uniqid(rand(), true)); // 32 byte (128 bit) identifier
|
|
$docIdLow = substr($docId, 0, 16); // first 16 bytes
|
|
$docIdHigh = substr($docId, 16, 16); // second 16 bytes
|
|
|
|
$trailerDictionary->ID = new Zend_Pdf_Element_Array();
|
|
$trailerDictionary->ID->items[] = new Zend_Pdf_Element_String_Binary($docIdLow);
|
|
$trailerDictionary->ID->items[] = new Zend_Pdf_Element_String_Binary($docIdHigh);
|
|
|
|
$trailerDictionary->Size = new Zend_Pdf_Element_Numeric(0);
|
|
|
|
// require_once 'Zend/Pdf/Trailer/Generator.php';
|
|
$this->_trailer = new Zend_Pdf_Trailer_Generator($trailerDictionary);
|
|
|
|
/**
|
|
* Document catalog indirect object.
|
|
*/
|
|
$docCatalog = $this->_objFactory->newObject(new Zend_Pdf_Element_Dictionary());
|
|
$docCatalog->Type = new Zend_Pdf_Element_Name('Catalog');
|
|
$docCatalog->Version = new Zend_Pdf_Element_Name(Zend_Pdf::PDF_VERSION);
|
|
$this->_trailer->Root = $docCatalog;
|
|
|
|
/**
|
|
* Pages container
|
|
*/
|
|
$docPages = $this->_objFactory->newObject(new Zend_Pdf_Element_Dictionary());
|
|
$docPages->Type = new Zend_Pdf_Element_Name('Pages');
|
|
$docPages->Kids = new Zend_Pdf_Element_Array();
|
|
$docPages->Count = new Zend_Pdf_Element_Numeric(0);
|
|
$docCatalog->Pages = $docPages;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retrive number of revisions.
|
|
*
|
|
* @return integer
|
|
*/
|
|
public function revisions()
|
|
{
|
|
$revisions = 1;
|
|
$currentTrailer = $this->_trailer;
|
|
|
|
while ($currentTrailer->getPrev() !== null && $currentTrailer->getPrev()->Root !== null ) {
|
|
$revisions++;
|
|
$currentTrailer = $currentTrailer->getPrev();
|
|
}
|
|
|
|
return $revisions++;
|
|
}
|
|
|
|
/**
|
|
* Rollback document $steps number of revisions.
|
|
* This method must be invoked before any changes, applied to the document.
|
|
* Otherwise behavior is undefined.
|
|
*
|
|
* @param integer $steps
|
|
*/
|
|
public function rollback($steps)
|
|
{
|
|
for ($count = 0; $count < $steps; $count++) {
|
|
if ($this->_trailer->getPrev() !== null && $this->_trailer->getPrev()->Root !== null) {
|
|
$this->_trailer = $this->_trailer->getPrev();
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
$this->_objFactory->setObjectCount($this->_trailer->Size->value);
|
|
|
|
// Mark content as modified to force new trailer generation at render time
|
|
$this->_trailer->Root->touch();
|
|
|
|
$this->pages = array();
|
|
$this->_loadPages($this->_trailer->Root->Pages);
|
|
}
|
|
|
|
/**
|
|
* Load pages recursively
|
|
*
|
|
* @param Zend_Pdf_Element_Reference $pages
|
|
* @param array|null $attributes
|
|
* @throws Zend_Pdf_Exception
|
|
*/
|
|
protected function _loadPages(Zend_Pdf_Element_Reference $pages, $attributes = array())
|
|
{
|
|
if ($pages->getType() != Zend_Pdf_Element::TYPE_DICTIONARY) {
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
throw new Zend_Pdf_Exception('Wrong argument');
|
|
}
|
|
|
|
foreach ($pages->getKeys() as $property) {
|
|
if (in_array($property, self::$_inheritableAttributes)) {
|
|
$attributes[$property] = $pages->$property;
|
|
$pages->$property = null;
|
|
}
|
|
}
|
|
|
|
|
|
foreach ($pages->Kids->items as $child) {
|
|
if ($child->Type->value == 'Pages') {
|
|
$this->_loadPages($child, $attributes);
|
|
} else if ($child->Type->value == 'Page') {
|
|
foreach (self::$_inheritableAttributes as $property) {
|
|
if ($child->$property === null && array_key_exists($property, $attributes)) {
|
|
/**
|
|
* Important note.
|
|
* If any attribute or dependant object is an indirect object, then it's still
|
|
* shared between pages.
|
|
*/
|
|
if ($attributes[$property] instanceof Zend_Pdf_Element_Object ||
|
|
$attributes[$property] instanceof Zend_Pdf_Element_Reference) {
|
|
$child->$property = $attributes[$property];
|
|
} else {
|
|
$child->$property = $this->_objFactory->newObject($attributes[$property]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// require_once 'Zend/Pdf/Page.php';
|
|
$this->pages[] = new Zend_Pdf_Page($child, $this->_objFactory);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load named destinations recursively
|
|
*
|
|
* @param Zend_Pdf_Element_Reference $root Document catalog entry
|
|
* @param string $pdfHeaderVersion
|
|
* @throws Zend_Pdf_Exception
|
|
*/
|
|
protected function _loadNamedDestinations(Zend_Pdf_Element_Reference $root, $pdfHeaderVersion)
|
|
{
|
|
if ($root->Version !== null && version_compare($root->Version->value, $pdfHeaderVersion, '>')) {
|
|
$versionIs_1_2_plus = version_compare($root->Version->value, '1.1', '>');
|
|
} else {
|
|
$versionIs_1_2_plus = version_compare($pdfHeaderVersion, '1.1', '>');
|
|
}
|
|
|
|
if ($versionIs_1_2_plus) {
|
|
// PDF version is 1.2+
|
|
// Look for Destinations structure at Name dictionary
|
|
if ($root->Names !== null && $root->Names->Dests !== null) {
|
|
// require_once 'Zend/Pdf/NameTree.php';
|
|
// require_once 'Zend/Pdf/Target.php';
|
|
foreach (new Zend_Pdf_NameTree($root->Names->Dests) as $name => $destination) {
|
|
$this->_namedTargets[$name] = Zend_Pdf_Target::load($destination);
|
|
}
|
|
}
|
|
} else {
|
|
// PDF version is 1.1 (or earlier)
|
|
// Look for Destinations sructure at Dest entry of document catalog
|
|
if ($root->Dests !== null) {
|
|
if ($root->Dests->getType() != Zend_Pdf_Element::TYPE_DICTIONARY) {
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
throw new Zend_Pdf_Exception('Document catalog Dests entry must be a dictionary.');
|
|
}
|
|
|
|
// require_once 'Zend/Pdf/Target.php';
|
|
foreach ($root->Dests->getKeys() as $destKey) {
|
|
$this->_namedTargets[$destKey] = Zend_Pdf_Target::load($root->Dests->$destKey);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load outlines recursively
|
|
*
|
|
* @param Zend_Pdf_Element_Reference $root Document catalog entry
|
|
* @throws Zend_Pdf_Exception
|
|
*/
|
|
protected function _loadOutlines(Zend_Pdf_Element_Reference $root)
|
|
{
|
|
if ($root->Outlines === null) {
|
|
return;
|
|
}
|
|
|
|
if ($root->Outlines->getType() != Zend_Pdf_Element::TYPE_DICTIONARY) {
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
throw new Zend_Pdf_Exception('Document catalog Outlines entry must be a dictionary.');
|
|
}
|
|
|
|
if ($root->Outlines->Type !== null && $root->Outlines->Type->value != 'Outlines') {
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
throw new Zend_Pdf_Exception('Outlines Type entry must be an \'Outlines\' string.');
|
|
}
|
|
|
|
if ($root->Outlines->First === null) {
|
|
return;
|
|
}
|
|
|
|
$outlineDictionary = $root->Outlines->First;
|
|
$processedDictionaries = new SplObjectStorage();
|
|
while ($outlineDictionary !== null && !$processedDictionaries->contains($outlineDictionary)) {
|
|
$processedDictionaries->attach($outlineDictionary);
|
|
|
|
// require_once 'Zend/Pdf/Outline/Loaded.php';
|
|
$this->outlines[] = new Zend_Pdf_Outline_Loaded($outlineDictionary);
|
|
|
|
$outlineDictionary = $outlineDictionary->Next;
|
|
}
|
|
|
|
$this->_originalOutlines = $this->outlines;
|
|
|
|
if ($root->Outlines->Count !== null) {
|
|
$this->_originalOpenOutlinesCount = $root->Outlines->Count->value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Orginize pages to tha pages tree structure.
|
|
*
|
|
* @todo atomatically attach page to the document, if it's not done yet.
|
|
* @todo check, that page is attached to the current document
|
|
*
|
|
* @todo Dump pages as a balanced tree instead of a plain set.
|
|
*/
|
|
protected function _dumpPages()
|
|
{
|
|
$root = $this->_trailer->Root;
|
|
$pagesContainer = $root->Pages;
|
|
|
|
$pagesContainer->touch();
|
|
$pagesContainer->Kids->items = array();
|
|
|
|
foreach ($this->pages as $page ) {
|
|
$page->render($this->_objFactory);
|
|
|
|
$pageDictionary = $page->getPageDictionary();
|
|
$pageDictionary->touch();
|
|
$pageDictionary->Parent = $pagesContainer;
|
|
|
|
$pagesContainer->Kids->items[] = $pageDictionary;
|
|
}
|
|
|
|
$this->_refreshPagesHash();
|
|
|
|
$pagesContainer->Count->touch();
|
|
$pagesContainer->Count->value = count($this->pages);
|
|
|
|
|
|
// Refresh named destinations list
|
|
foreach ($this->_namedTargets as $name => $namedTarget) {
|
|
if ($namedTarget instanceof Zend_Pdf_Destination_Explicit) {
|
|
// Named target is an explicit destination
|
|
if ($this->resolveDestination($namedTarget, false) === null) {
|
|
unset($this->_namedTargets[$name]);
|
|
}
|
|
} else if ($namedTarget instanceof Zend_Pdf_Action) {
|
|
// Named target is an action
|
|
if ($this->_cleanUpAction($namedTarget, false) === null) {
|
|
// Action is a GoTo action with an unresolved destination
|
|
unset($this->_namedTargets[$name]);
|
|
}
|
|
} else {
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
throw new Zend_Pdf_Exception('Wrong type of named targed (\'' . get_class($namedTarget) . '\').');
|
|
}
|
|
}
|
|
|
|
// Refresh outlines
|
|
// require_once 'Zend/Pdf/RecursivelyIteratableObjectsContainer.php';
|
|
$iterator = new RecursiveIteratorIterator(new Zend_Pdf_RecursivelyIteratableObjectsContainer($this->outlines), RecursiveIteratorIterator::SELF_FIRST);
|
|
foreach ($iterator as $outline) {
|
|
$target = $outline->getTarget();
|
|
|
|
if ($target !== null) {
|
|
if ($target instanceof Zend_Pdf_Destination) {
|
|
// Outline target is a destination
|
|
if ($this->resolveDestination($target, false) === null) {
|
|
$outline->setTarget(null);
|
|
}
|
|
} else if ($target instanceof Zend_Pdf_Action) {
|
|
// Outline target is an action
|
|
if ($this->_cleanUpAction($target, false) === null) {
|
|
// Action is a GoTo action with an unresolved destination
|
|
$outline->setTarget(null);
|
|
}
|
|
} else {
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
throw new Zend_Pdf_Exception('Wrong outline target.');
|
|
}
|
|
}
|
|
}
|
|
|
|
$openAction = $this->getOpenAction();
|
|
if ($openAction !== null) {
|
|
if ($openAction instanceof Zend_Pdf_Action) {
|
|
// OpenAction is an action
|
|
if ($this->_cleanUpAction($openAction, false) === null) {
|
|
// Action is a GoTo action with an unresolved destination
|
|
$this->setOpenAction(null);
|
|
}
|
|
} else if ($openAction instanceof Zend_Pdf_Destination) {
|
|
// OpenAction target is a destination
|
|
if ($this->resolveDestination($openAction, false) === null) {
|
|
$this->setOpenAction(null);
|
|
}
|
|
} else {
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
throw new Zend_Pdf_Exception('OpenAction has to be either PDF Action or Destination.');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Dump named destinations
|
|
*
|
|
* @todo Create a balanced tree instead of plain structure.
|
|
*/
|
|
protected function _dumpNamedDestinations()
|
|
{
|
|
ksort($this->_namedTargets, SORT_STRING);
|
|
|
|
$destArrayItems = array();
|
|
foreach ($this->_namedTargets as $name => $destination) {
|
|
$destArrayItems[] = new Zend_Pdf_Element_String($name);
|
|
|
|
if ($destination instanceof Zend_Pdf_Target) {
|
|
$destArrayItems[] = $destination->getResource();
|
|
} else {
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
throw new Zend_Pdf_Exception('PDF named destinations must be a Zend_Pdf_Target object.');
|
|
}
|
|
}
|
|
$destArray = $this->_objFactory->newObject(new Zend_Pdf_Element_Array($destArrayItems));
|
|
|
|
$DestTree = $this->_objFactory->newObject(new Zend_Pdf_Element_Dictionary());
|
|
$DestTree->Names = $destArray;
|
|
|
|
$root = $this->_trailer->Root;
|
|
|
|
if ($root->Names === null) {
|
|
$root->touch();
|
|
$root->Names = $this->_objFactory->newObject(new Zend_Pdf_Element_Dictionary());
|
|
} else {
|
|
$root->Names->touch();
|
|
}
|
|
$root->Names->Dests = $DestTree;
|
|
}
|
|
|
|
/**
|
|
* Dump outlines recursively
|
|
*/
|
|
protected function _dumpOutlines()
|
|
{
|
|
$root = $this->_trailer->Root;
|
|
|
|
if ($root->Outlines === null) {
|
|
if (count($this->outlines) == 0) {
|
|
return;
|
|
} else {
|
|
$root->Outlines = $this->_objFactory->newObject(new Zend_Pdf_Element_Dictionary());
|
|
$root->Outlines->Type = new Zend_Pdf_Element_Name('Outlines');
|
|
$updateOutlinesNavigation = true;
|
|
}
|
|
} else {
|
|
$updateOutlinesNavigation = false;
|
|
if (count($this->_originalOutlines) != count($this->outlines)) {
|
|
// If original and current outlines arrays have different size then outlines list was updated
|
|
$updateOutlinesNavigation = true;
|
|
} else if ( !(array_keys($this->_originalOutlines) === array_keys($this->outlines)) ) {
|
|
// If original and current outlines arrays have different keys (with a glance to an order) then outlines list was updated
|
|
$updateOutlinesNavigation = true;
|
|
} else {
|
|
foreach ($this->outlines as $key => $outline) {
|
|
if ($this->_originalOutlines[$key] !== $outline) {
|
|
$updateOutlinesNavigation = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$lastOutline = null;
|
|
$openOutlinesCount = 0;
|
|
if ($updateOutlinesNavigation) {
|
|
$root->Outlines->touch();
|
|
$root->Outlines->First = null;
|
|
|
|
foreach ($this->outlines as $outline) {
|
|
if ($lastOutline === null) {
|
|
// First pass. Update Outlines dictionary First entry using corresponding value
|
|
$lastOutline = $outline->dumpOutline($this->_objFactory, $updateOutlinesNavigation, $root->Outlines);
|
|
$root->Outlines->First = $lastOutline;
|
|
} else {
|
|
// Update previous outline dictionary Next entry (Prev is updated within dumpOutline() method)
|
|
$currentOutlineDictionary = $outline->dumpOutline($this->_objFactory, $updateOutlinesNavigation, $root->Outlines, $lastOutline);
|
|
$lastOutline->Next = $currentOutlineDictionary;
|
|
$lastOutline = $currentOutlineDictionary;
|
|
}
|
|
$openOutlinesCount += $outline->openOutlinesCount();
|
|
}
|
|
|
|
$root->Outlines->Last = $lastOutline;
|
|
} else {
|
|
foreach ($this->outlines as $outline) {
|
|
$lastOutline = $outline->dumpOutline($this->_objFactory, $updateOutlinesNavigation, $root->Outlines, $lastOutline);
|
|
$openOutlinesCount += $outline->openOutlinesCount();
|
|
}
|
|
}
|
|
|
|
if ($openOutlinesCount != $this->_originalOpenOutlinesCount) {
|
|
$root->Outlines->touch;
|
|
$root->Outlines->Count = new Zend_Pdf_Element_Numeric($openOutlinesCount);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create page object, attached to the PDF document.
|
|
* Method signatures:
|
|
*
|
|
* 1. Create new page with a specified pagesize.
|
|
* If $factory is null then it will be created and page must be attached to the document to be
|
|
* included into output.
|
|
* ---------------------------------------------------------
|
|
* new Zend_Pdf_Page(string $pagesize);
|
|
* ---------------------------------------------------------
|
|
*
|
|
* 2. Create new page with a specified pagesize (in default user space units).
|
|
* If $factory is null then it will be created and page must be attached to the document to be
|
|
* included into output.
|
|
* ---------------------------------------------------------
|
|
* new Zend_Pdf_Page(numeric $width, numeric $height);
|
|
* ---------------------------------------------------------
|
|
*
|
|
* @param mixed $param1
|
|
* @param mixed $param2
|
|
* @return Zend_Pdf_Page
|
|
*/
|
|
public function newPage($param1, $param2 = null)
|
|
{
|
|
// require_once 'Zend/Pdf/Page.php';
|
|
if ($param2 === null) {
|
|
return new Zend_Pdf_Page($param1, $this->_objFactory);
|
|
} else {
|
|
return new Zend_Pdf_Page($param1, $param2, $this->_objFactory);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the document-level Metadata
|
|
* or null Metadata stream is not presented
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getMetadata()
|
|
{
|
|
if ($this->_trailer->Root->Metadata !== null) {
|
|
return $this->_trailer->Root->Metadata->value;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the document-level Metadata (mast be valid XMP document)
|
|
*
|
|
* @param string $metadata
|
|
*/
|
|
public function setMetadata($metadata)
|
|
{
|
|
$metadataObject = $this->_objFactory->newStreamObject($metadata);
|
|
$metadataObject->dictionary->Type = new Zend_Pdf_Element_Name('Metadata');
|
|
$metadataObject->dictionary->Subtype = new Zend_Pdf_Element_Name('XML');
|
|
|
|
$this->_trailer->Root->Metadata = $metadataObject;
|
|
$this->_trailer->Root->touch();
|
|
}
|
|
|
|
/**
|
|
* Return the document-level JavaScript
|
|
* or null if there is no JavaScript for this document
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getJavaScript()
|
|
{
|
|
return $this->_javaScript;
|
|
}
|
|
|
|
/**
|
|
* Get open Action
|
|
* Returns Zend_Pdf_Target (Zend_Pdf_Destination or Zend_Pdf_Action object)
|
|
*
|
|
* @return Zend_Pdf_Target
|
|
*/
|
|
public function getOpenAction()
|
|
{
|
|
if ($this->_trailer->Root->OpenAction !== null) {
|
|
// require_once 'Zend/Pdf/Target.php';
|
|
return Zend_Pdf_Target::load($this->_trailer->Root->OpenAction);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set open Action which is actually Zend_Pdf_Destination or Zend_Pdf_Action object
|
|
*
|
|
* @param Zend_Pdf_Target $openAction
|
|
* @returns Zend_Pdf
|
|
*/
|
|
public function setOpenAction(Zend_Pdf_Target $openAction = null)
|
|
{
|
|
$root = $this->_trailer->Root;
|
|
$root->touch();
|
|
|
|
if ($openAction === null) {
|
|
$root->OpenAction = null;
|
|
} else {
|
|
$root->OpenAction = $openAction->getResource();
|
|
|
|
if ($openAction instanceof Zend_Pdf_Action) {
|
|
$openAction->dumpAction($this->_objFactory);
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Return an associative array containing all the named destinations (or GoTo actions) in the PDF.
|
|
* Named targets can be used to reference from outside
|
|
* the PDF, ex: 'http://www.something.com/mydocument.pdf#MyAction'
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getNamedDestinations()
|
|
{
|
|
return $this->_namedTargets;
|
|
}
|
|
|
|
/**
|
|
* Return specified named destination
|
|
*
|
|
* @param string $name
|
|
* @return Zend_Pdf_Destination_Explicit|Zend_Pdf_Action_GoTo
|
|
*/
|
|
public function getNamedDestination($name)
|
|
{
|
|
if (isset($this->_namedTargets[$name])) {
|
|
return $this->_namedTargets[$name];
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set specified named destination
|
|
*
|
|
* @param string $name
|
|
* @param Zend_Pdf_Destination_Explicit|Zend_Pdf_Action_GoTo $destination
|
|
* @throws Zend_Pdf_Exception
|
|
*/
|
|
public function setNamedDestination($name, $destination = null)
|
|
{
|
|
if ($destination !== null &&
|
|
!$destination instanceof Zend_Pdf_Action_GoTo &&
|
|
!$destination instanceof Zend_Pdf_Destination_Explicit) {
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
throw new Zend_Pdf_Exception('PDF named destination must refer an explicit destination or a GoTo PDF action.');
|
|
}
|
|
|
|
if ($destination !== null) {
|
|
$this->_namedTargets[$name] = $destination;
|
|
} else {
|
|
unset($this->_namedTargets[$name]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Pages collection hash:
|
|
* <page dictionary object hash id> => Zend_Pdf_Page
|
|
*
|
|
* @var SplObjectStorage
|
|
*/
|
|
protected $_pageReferences = null;
|
|
|
|
/**
|
|
* Pages collection hash:
|
|
* <page number> => Zend_Pdf_Page
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $_pageNumbers = null;
|
|
|
|
/**
|
|
* Refresh page collection hashes
|
|
*
|
|
* @return Zend_Pdf
|
|
*/
|
|
protected function _refreshPagesHash()
|
|
{
|
|
$this->_pageReferences = array();
|
|
$this->_pageNumbers = array();
|
|
$count = 1;
|
|
foreach ($this->pages as $page) {
|
|
$pageDictionaryHashId = spl_object_hash($page->getPageDictionary()->getObject());
|
|
$this->_pageReferences[$pageDictionaryHashId] = $page;
|
|
$this->_pageNumbers[$count++] = $page;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Resolve destination.
|
|
*
|
|
* Returns Zend_Pdf_Page page object or null if destination is not found within PDF document.
|
|
*
|
|
* @param Zend_Pdf_Destination $destination Destination to resolve
|
|
* @param bool $refreshPageCollectionHashes Refresh page collection hashes before processing
|
|
* @return Zend_Pdf_Page|null
|
|
* @throws Zend_Pdf_Exception
|
|
*/
|
|
public function resolveDestination(Zend_Pdf_Destination $destination, $refreshPageCollectionHashes = true)
|
|
{
|
|
if ($this->_pageReferences === null || $refreshPageCollectionHashes) {
|
|
$this->_refreshPagesHash();
|
|
}
|
|
|
|
if ($destination instanceof Zend_Pdf_Destination_Named) {
|
|
if (!isset($this->_namedTargets[$destination->getName()])) {
|
|
return null;
|
|
}
|
|
$destination = $this->getNamedDestination($destination->getName());
|
|
|
|
if ($destination instanceof Zend_Pdf_Action) {
|
|
if (!$destination instanceof Zend_Pdf_Action_GoTo) {
|
|
return null;
|
|
}
|
|
$destination = $destination->getDestination();
|
|
}
|
|
|
|
if (!$destination instanceof Zend_Pdf_Destination_Explicit) {
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
throw new Zend_Pdf_Exception('Named destination target has to be an explicit destination.');
|
|
}
|
|
}
|
|
|
|
// Named target is an explicit destination
|
|
$pageElement = $destination->getResource()->items[0];
|
|
|
|
if ($pageElement->getType() == Zend_Pdf_Element::TYPE_NUMERIC) {
|
|
// Page reference is a PDF number
|
|
if (!isset($this->_pageNumbers[$pageElement->value])) {
|
|
return null;
|
|
}
|
|
|
|
return $this->_pageNumbers[$pageElement->value];
|
|
}
|
|
|
|
// Page reference is a PDF page dictionary reference
|
|
$pageDictionaryHashId = spl_object_hash($pageElement->getObject());
|
|
if (!isset($this->_pageReferences[$pageDictionaryHashId])) {
|
|
return null;
|
|
}
|
|
return $this->_pageReferences[$pageDictionaryHashId];
|
|
}
|
|
|
|
/**
|
|
* Walk through action and its chained actions tree and remove nodes
|
|
* if they are GoTo actions with an unresolved target.
|
|
*
|
|
* Returns null if root node is deleted or updated action overwise.
|
|
*
|
|
* @todo Give appropriate name and make method public
|
|
*
|
|
* @param Zend_Pdf_Action $action
|
|
* @param bool $refreshPageCollectionHashes Refresh page collection hashes before processing
|
|
* @return Zend_Pdf_Action|null
|
|
*/
|
|
protected function _cleanUpAction(Zend_Pdf_Action $action, $refreshPageCollectionHashes = true)
|
|
{
|
|
if ($this->_pageReferences === null || $refreshPageCollectionHashes) {
|
|
$this->_refreshPagesHash();
|
|
}
|
|
|
|
// Named target is an action
|
|
if ($action instanceof Zend_Pdf_Action_GoTo &&
|
|
$this->resolveDestination($action->getDestination(), false) === null) {
|
|
// Action itself is a GoTo action with an unresolved destination
|
|
return null;
|
|
}
|
|
|
|
// Walk through child actions
|
|
$iterator = new RecursiveIteratorIterator($action, RecursiveIteratorIterator::SELF_FIRST);
|
|
|
|
$actionsToClean = array();
|
|
$deletionCandidateKeys = array();
|
|
foreach ($iterator as $chainedAction) {
|
|
if ($chainedAction instanceof Zend_Pdf_Action_GoTo &&
|
|
$this->resolveDestination($chainedAction->getDestination(), false) === null) {
|
|
// Some child action is a GoTo action with an unresolved destination
|
|
// Mark it as a candidate for deletion
|
|
$actionsToClean[] = $iterator->getSubIterator();
|
|
$deletionCandidateKeys[] = $iterator->getSubIterator()->key();
|
|
}
|
|
}
|
|
foreach ($actionsToClean as $id => $action) {
|
|
unset($action->next[$deletionCandidateKeys[$id]]);
|
|
}
|
|
|
|
return $action;
|
|
}
|
|
|
|
/**
|
|
* Extract fonts attached to the document
|
|
*
|
|
* returns array of Zend_Pdf_Resource_Font_Extracted objects
|
|
*
|
|
* @return array
|
|
* @throws Zend_Pdf_Exception
|
|
*/
|
|
public function extractFonts()
|
|
{
|
|
$fontResourcesUnique = array();
|
|
foreach ($this->pages as $page) {
|
|
$pageResources = $page->extractResources();
|
|
|
|
if ($pageResources->Font === null) {
|
|
// Page doesn't contain have any font reference
|
|
continue;
|
|
}
|
|
|
|
$fontResources = $pageResources->Font;
|
|
|
|
foreach ($fontResources->getKeys() as $fontResourceName) {
|
|
$fontDictionary = $fontResources->$fontResourceName;
|
|
|
|
if (! ($fontDictionary instanceof Zend_Pdf_Element_Reference ||
|
|
$fontDictionary instanceof Zend_Pdf_Element_Object) ) {
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
throw new Zend_Pdf_Exception('Font dictionary has to be an indirect object or object reference.');
|
|
}
|
|
|
|
$fontResourcesUnique[spl_object_hash($fontDictionary->getObject())] = $fontDictionary;
|
|
}
|
|
}
|
|
|
|
$fonts = array();
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
foreach ($fontResourcesUnique as $resourceId => $fontDictionary) {
|
|
try {
|
|
// Try to extract font
|
|
// require_once 'Zend/Pdf/Resource/Font/Extracted.php';
|
|
$extractedFont = new Zend_Pdf_Resource_Font_Extracted($fontDictionary);
|
|
|
|
$fonts[$resourceId] = $extractedFont;
|
|
} catch (Zend_Pdf_Exception $e) {
|
|
if ($e->getMessage() != 'Unsupported font type.') {
|
|
throw $e;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $fonts;
|
|
}
|
|
|
|
/**
|
|
* Extract font attached to the page by specific font name
|
|
*
|
|
* $fontName should be specified in UTF-8 encoding
|
|
*
|
|
* @param string $fontName
|
|
* @return Zend_Pdf_Resource_Font_Extracted|null
|
|
* @throws Zend_Pdf_Exception
|
|
*/
|
|
public function extractFont($fontName)
|
|
{
|
|
$fontResourcesUnique = array();
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
foreach ($this->pages as $page) {
|
|
$pageResources = $page->extractResources();
|
|
|
|
if ($pageResources->Font === null) {
|
|
// Page doesn't contain have any font reference
|
|
continue;
|
|
}
|
|
|
|
$fontResources = $pageResources->Font;
|
|
|
|
foreach ($fontResources->getKeys() as $fontResourceName) {
|
|
$fontDictionary = $fontResources->$fontResourceName;
|
|
|
|
if (! ($fontDictionary instanceof Zend_Pdf_Element_Reference ||
|
|
$fontDictionary instanceof Zend_Pdf_Element_Object) ) {
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
throw new Zend_Pdf_Exception('Font dictionary has to be an indirect object or object reference.');
|
|
}
|
|
|
|
$resourceId = spl_object_hash($fontDictionary->getObject());
|
|
if (isset($fontResourcesUnique[$resourceId])) {
|
|
continue;
|
|
} else {
|
|
// Mark resource as processed
|
|
$fontResourcesUnique[$resourceId] = 1;
|
|
}
|
|
|
|
if ($fontDictionary->BaseFont->value != $fontName) {
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
// Try to extract font
|
|
// require_once 'Zend/Pdf/Resource/Font/Extracted.php';
|
|
return new Zend_Pdf_Resource_Font_Extracted($fontDictionary);
|
|
} catch (Zend_Pdf_Exception $e) {
|
|
if ($e->getMessage() != 'Unsupported font type.') {
|
|
throw $e;
|
|
}
|
|
// Continue searhing
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Render the completed PDF to a string.
|
|
* If $newSegmentOnly is true and it's not a new document,
|
|
* then only appended part of PDF is returned.
|
|
*
|
|
* @param boolean $newSegmentOnly
|
|
* @param resource $outputStream
|
|
* @return string
|
|
* @throws Zend_Pdf_Exception
|
|
*/
|
|
public function render($newSegmentOnly = false, $outputStream = null)
|
|
{
|
|
if ($this->_isNewDocument) {
|
|
// Drop full document first time even $newSegmentOnly is set to true
|
|
$newSegmentOnly = false;
|
|
$this->_isNewDocument = false;
|
|
}
|
|
|
|
// Save document properties if necessary
|
|
if ($this->properties != $this->_originalProperties) {
|
|
$docInfo = $this->_objFactory->newObject(new Zend_Pdf_Element_Dictionary());
|
|
|
|
foreach ($this->properties as $key => $value) {
|
|
switch ($key) {
|
|
case 'Trapped':
|
|
switch ($value) {
|
|
case true:
|
|
$docInfo->$key = new Zend_Pdf_Element_Name('True');
|
|
break;
|
|
|
|
case false:
|
|
$docInfo->$key = new Zend_Pdf_Element_Name('False');
|
|
break;
|
|
|
|
case null:
|
|
$docInfo->$key = new Zend_Pdf_Element_Name('Unknown');
|
|
break;
|
|
|
|
default:
|
|
// require_once 'Zend/Pdf/Exception.php';
|
|
throw new Zend_Pdf_Exception('Wrong Trapped document property vale: \'' . $value . '\'. Only true, false and null values are allowed.');
|
|
break;
|
|
}
|
|
|
|
case 'CreationDate':
|
|
// break intentionally omitted
|
|
case 'ModDate':
|
|
$docInfo->$key = new Zend_Pdf_Element_String((string)$value);
|
|
break;
|
|
|
|
case 'Title':
|
|
// break intentionally omitted
|
|
case 'Author':
|
|
// break intentionally omitted
|
|
case 'Subject':
|
|
// break intentionally omitted
|
|
case 'Keywords':
|
|
// break intentionally omitted
|
|
case 'Creator':
|
|
// break intentionally omitted
|
|
case 'Producer':
|
|
if (extension_loaded('mbstring') === true) {
|
|
$detected = mb_detect_encoding($value);
|
|
if ($detected !== 'ASCII') {
|
|
$value = "\xfe\xff" . mb_convert_encoding($value, 'UTF-16', $detected);
|
|
}
|
|
}
|
|
$docInfo->$key = new Zend_Pdf_Element_String((string)$value);
|
|
break;
|
|
|
|
default:
|
|
// Set property using PDF type based on PHP type
|
|
$docInfo->$key = Zend_Pdf_Element::phpToPdf($value);
|
|
break;
|
|
}
|
|
}
|
|
|
|
$this->_trailer->Info = $docInfo;
|
|
}
|
|
|
|
$this->_dumpPages();
|
|
$this->_dumpNamedDestinations();
|
|
$this->_dumpOutlines();
|
|
|
|
// Check, that PDF file was modified
|
|
// File is always modified by _dumpPages() now, but future implementations may eliminate this.
|
|
if (!$this->_objFactory->isModified()) {
|
|
if ($newSegmentOnly) {
|
|
// Do nothing, return
|
|
return '';
|
|
}
|
|
|
|
if ($outputStream === null) {
|
|
return $this->_trailer->getPDFString();
|
|
} else {
|
|
$pdfData = $this->_trailer->getPDFString();
|
|
while ( strlen($pdfData) > 0 && ($byteCount = fwrite($outputStream, $pdfData)) != false ) {
|
|
$pdfData = substr($pdfData, $byteCount);
|
|
}
|
|
|
|
return '';
|
|
}
|
|
}
|
|
|
|
// offset (from a start of PDF file) of new PDF file segment
|
|
$offset = $this->_trailer->getPDFLength();
|
|
// Last Object number in a list of free objects
|
|
$lastFreeObject = $this->_trailer->getLastFreeObject();
|
|
|
|
// Array of cross-reference table subsections
|
|
$xrefTable = array();
|
|
// Object numbers of first objects in each subsection
|
|
$xrefSectionStartNums = array();
|
|
|
|
// Last cross-reference table subsection
|
|
$xrefSection = array();
|
|
// Dummy initialization of the first element (specail case - header of linked list of free objects).
|
|
$xrefSection[] = 0;
|
|
$xrefSectionStartNums[] = 0;
|
|
// Object number of last processed PDF object.
|
|
// Used to manage cross-reference subsections.
|
|
// Initialized by zero (specail case - header of linked list of free objects).
|
|
$lastObjNum = 0;
|
|
|
|
if ($outputStream !== null) {
|
|
if (!$newSegmentOnly) {
|
|
$pdfData = $this->_trailer->getPDFString();
|
|
while ( strlen($pdfData) > 0 && ($byteCount = fwrite($outputStream, $pdfData)) != false ) {
|
|
$pdfData = substr($pdfData, $byteCount);
|
|
}
|
|
}
|
|
} else {
|
|
$pdfSegmentBlocks = ($newSegmentOnly) ? array() : array($this->_trailer->getPDFString());
|
|
}
|
|
|
|
// Iterate objects to create new reference table
|
|
foreach ($this->_objFactory->listModifiedObjects() as $updateInfo) {
|
|
$objNum = $updateInfo->getObjNum();
|
|
|
|
if ($objNum - $lastObjNum != 1) {
|
|
// Save cross-reference table subsection and start new one
|
|
$xrefTable[] = $xrefSection;
|
|
$xrefSection = array();
|
|
$xrefSectionStartNums[] = $objNum;
|
|
}
|
|
|
|
if ($updateInfo->isFree()) {
|
|
// Free object cross-reference table entry
|
|
$xrefSection[] = sprintf("%010d %05d f \n", $lastFreeObject, $updateInfo->getGenNum());
|
|
$lastFreeObject = $objNum;
|
|
} else {
|
|
// In-use object cross-reference table entry
|
|
$xrefSection[] = sprintf("%010d %05d n \n", $offset, $updateInfo->getGenNum());
|
|
|
|
$pdfBlock = $updateInfo->getObjectDump();
|
|
$offset += strlen($pdfBlock);
|
|
|
|
if ($outputStream === null) {
|
|
$pdfSegmentBlocks[] = $pdfBlock;
|
|
} else {
|
|
while ( strlen($pdfBlock) > 0 && ($byteCount = fwrite($outputStream, $pdfBlock)) != false ) {
|
|
$pdfBlock = substr($pdfBlock, $byteCount);
|
|
}
|
|
}
|
|
}
|
|
$lastObjNum = $objNum;
|
|
}
|
|
// Save last cross-reference table subsection
|
|
$xrefTable[] = $xrefSection;
|
|
|
|
// Modify first entry (specail case - header of linked list of free objects).
|
|
$xrefTable[0][0] = sprintf("%010d 65535 f \n", $lastFreeObject);
|
|
|
|
$xrefTableStr = "xref\n";
|
|
foreach ($xrefTable as $sectId => $xrefSection) {
|
|
$xrefTableStr .= sprintf("%d %d \n", $xrefSectionStartNums[$sectId], count($xrefSection));
|
|
foreach ($xrefSection as $xrefTableEntry) {
|
|
$xrefTableStr .= $xrefTableEntry;
|
|
}
|
|
}
|
|
|
|
$this->_trailer->Size->value = $this->_objFactory->getObjectCount();
|
|
|
|
$pdfBlock = $xrefTableStr
|
|
. $this->_trailer->toString()
|
|
. "startxref\n" . $offset . "\n"
|
|
. "%%EOF\n";
|
|
|
|
$this->_objFactory->cleanEnumerationShiftCache();
|
|
|
|
if ($outputStream === null) {
|
|
$pdfSegmentBlocks[] = $pdfBlock;
|
|
|
|
return implode('', $pdfSegmentBlocks);
|
|
} else {
|
|
while ( strlen($pdfBlock) > 0 && ($byteCount = fwrite($outputStream, $pdfBlock)) != false ) {
|
|
$pdfBlock = substr($pdfBlock, $byteCount);
|
|
}
|
|
|
|
return '';
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the document-level JavaScript
|
|
*
|
|
* @param string $javascript
|
|
*/
|
|
public function setJavaScript($javascript)
|
|
{
|
|
$this->_javaScript = $javascript;
|
|
}
|
|
|
|
|
|
/**
|
|
* Convert date to PDF format (it's close to ASN.1 (Abstract Syntax Notation
|
|
* One) defined in ISO/IEC 8824).
|
|
*
|
|
* @todo This really isn't the best location for this method. It should
|
|
* probably actually exist as Zend_Pdf_Element_Date or something like that.
|
|
*
|
|
* @todo Address the following E_STRICT issue:
|
|
* PHP Strict Standards: date(): It is not safe to rely on the system's
|
|
* timezone settings. Please use the date.timezone setting, the TZ
|
|
* environment variable or the date_default_timezone_set() function. In
|
|
* case you used any of those methods and you are still getting this
|
|
* warning, you most likely misspelled the timezone identifier.
|
|
*
|
|
* @param integer $timestamp (optional) If omitted, uses the current time.
|
|
* @return string
|
|
*/
|
|
public static function pdfDate($timestamp = null)
|
|
{
|
|
if ($timestamp === null) {
|
|
$date = date('\D\:YmdHisO');
|
|
} else {
|
|
$date = date('\D\:YmdHisO', $timestamp);
|
|
}
|
|
return substr_replace($date, '\'', -2, 0) . '\'';
|
|
}
|
|
|
|
}
|