File indexing completed on 2024-05-12 06:02:53

 <?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-2015 Zend Technologies USA Inc. (http://www.zend.com)
  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  * @version    $Id$
  */
 
 /** 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';
 // require_once 'Zend/Pdf/Resource/Unified.php';
 
 // require_once 'Zend/Pdf/Canvas/Abstract.php';
 
 
 /**
  * PDF Page
  *
  * @package    Zend_Pdf
  * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  */
 class Zend_Pdf_Page extends Zend_Pdf_Canvas_Abstract
 {
   /**** Class Constants ****/
 
 
   /* Page Sizes */
 
     /**
      * Size representing an A4 page in portrait (tall) orientation.
      */
     const SIZE_A4                = '595:842:';
 
     /**
      * Size representing an A4 page in landscape (wide) orientation.
      */
     const SIZE_A4_LANDSCAPE      = '842:595:';
 
     /**
      * Size representing a US Letter page in portrait (tall) orientation.
      */
     const SIZE_LETTER            = '612:792:';
 
     /**
      * Size representing a US Letter page in landscape (wide) orientation.
      */
     const SIZE_LETTER_LANDSCAPE  = '792:612:';
 
 
   /* Shape Drawing */
 
     /**
      * Stroke the path only. Do not fill.
      */
     const SHAPE_DRAW_STROKE      = 0;
 
     /**
      * Fill the path only. Do not stroke.
      */
     const SHAPE_DRAW_FILL        = 1;
 
     /**
      * Fill and stroke the path.
      */
     const SHAPE_DRAW_FILL_AND_STROKE = 2;
 
 
   /* Shape Filling Methods */
 
     /**
      * Fill the path using the non-zero winding rule.
      */
     const FILL_METHOD_NON_ZERO_WINDING = 0;
 
     /**
      * Fill the path using the even-odd rule.
      */
     const FILL_METHOD_EVEN_ODD        = 1;
 
 
   /* Line Dash Types */
 
     /**
      * Solid line dash.
      */
     const LINE_DASHING_SOLID = 0;
 
 
 
     /**
      * Page dictionary (refers to an inderect Zend_Pdf_Element_Dictionary object).
      *
      * @var Zend_Pdf_Element_Reference|Zend_Pdf_Element_Object
      */
     protected $_dictionary;
 
     /**
      * PDF objects factory.
      *
      * @var Zend_Pdf_ElementFactory_Interface
      */
     protected $_objFactory = null;
 
     /**
      * Flag which signals, that page is created separately from any PDF document or
      * attached to anyone.
      *
      * @var boolean
      */
     protected $_attached;
 
     /**
      * Safe Graphics State semafore
      *
      * If it's false, than we can't be sure Graphics State is restored withing
      * context of previous contents stream (ex. drawing coordinate system may be rotated).
      * We should encompass existing content with save/restore GS operators
      *
      * @var boolean
      */
     protected $_safeGS;
 
     /**
      * Object constructor.
      * Constructor signatures:
      *
      * 1. Load PDF page from a parsed PDF file.
      *    Object factory is created by PDF parser.
      * ---------------------------------------------------------
      * new Zend_Pdf_Page(Zend_Pdf_Element_Dictionary       $pageDict,
      *                   Zend_Pdf_ElementFactory_Interface $factory);
      * ---------------------------------------------------------
      *
      * 2. Make a copy of the PDF page.
      *    New page is created in the same context as source page. Object factory is shared.
      *    Thus it will be attached to the document, but need to be placed into Zend_Pdf::$pages array
      *    to be included into output.
      * ---------------------------------------------------------
      * new Zend_Pdf_Page(Zend_Pdf_Page $page);
      * ---------------------------------------------------------
      *
      * 3. 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, Zend_Pdf_ElementFactory_Interface $factory = null);
      * ---------------------------------------------------------
      *
      * 4. 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, Zend_Pdf_ElementFactory_Interface $factory = null);
      * ---------------------------------------------------------
      *
      *
      * @param mixed $param1
      * @param mixed $param2
      * @param mixed $param3
      * @throws Zend_Pdf_Exception
      */
     public function __construct($param1, $param2 = null, $param3 = null)
     {
         if (($param1 instanceof Zend_Pdf_Element_Reference ||
              $param1 instanceof Zend_Pdf_Element_Object
             ) &&
             $param2 instanceof Zend_Pdf_ElementFactory_Interface &&
             $param3 === null
            ) {
             switch ($param1->getType()) {
                 case Zend_Pdf_Element::TYPE_DICTIONARY:
                     $this->_dictionary = $param1;
                     $this->_objFactory = $param2;
                     $this->_attached   = true;
                     $this->_safeGS     = false;
                     return;
                     break;
 
                 case Zend_Pdf_Element::TYPE_NULL:
                     $this->_objFactory = $param2;
                     $pageWidth = $pageHeight = 0;
                     break;
 
                 default:
                     // require_once 'Zend/Pdf/Exception.php';
                     throw new Zend_Pdf_Exception('Unrecognized object type.');
                     break;
 
             }
         } else if ($param1 instanceof Zend_Pdf_Page && $param2 === null && $param3 === null) {
             // Duplicate existing page.
             // Let already existing content and resources to be shared between pages
             // We don't give existing content modification functionality, so we don't need "deep copy"
             $this->_objFactory = $param1->_objFactory;
             $this->_attached   = &$param1->_attached;
             $this->_safeGS     = false;
 
             $this->_dictionary = $this->_objFactory->newObject(new Zend_Pdf_Element_Dictionary());
 
             foreach ($param1->_dictionary->getKeys() as $key) {
                 if ($key == 'Contents') {
                     // Clone Contents property
 
                     $this->_dictionary->Contents = new Zend_Pdf_Element_Array();
 
                     if ($param1->_dictionary->Contents->getType() != Zend_Pdf_Element::TYPE_ARRAY) {
                         // Prepare array of content streams and add existing stream
                         $this->_dictionary->Contents->items[] = $param1->_dictionary->Contents;
                     } else {
                         // Clone array of the content streams
                         foreach ($param1->_dictionary->Contents->items as $srcContentStream) {
                             $this->_dictionary->Contents->items[] = $srcContentStream;
                         }
                     }
                 } else {
                     $this->_dictionary->$key = $param1->_dictionary->$key;
                 }
             }
 
             return;
         } else if (is_string($param1) &&
                    ($param2 === null || $param2 instanceof Zend_Pdf_ElementFactory_Interface) &&
                    $param3 === null) {
             if ($param2 !== null) {
                 $this->_objFactory = $param2;
             } else {
                 // require_once 'Zend/Pdf/ElementFactory.php';
                 $this->_objFactory = Zend_Pdf_ElementFactory::createFactory(1);
             }
             $this->_attached   = false;
             $this->_safeGS     = true; /** New page created. That's users App responsibility to track GS changes */
 
             switch (strtolower($param1)) {
                 case 'a4':
                     $param1 = Zend_Pdf_Page::SIZE_A4;
                     break;
                 case 'a4-landscape':
                     $param1 = Zend_Pdf_Page::SIZE_A4_LANDSCAPE;
                     break;
                 case 'letter':
                     $param1 = Zend_Pdf_Page::SIZE_LETTER;
                     break;
                 case 'letter-landscape':
                     $param1 = Zend_Pdf_Page::SIZE_LETTER_LANDSCAPE;
                     break;
                 default:
                     // should be in "x:y" or "x:y:" form
             }
 
             $pageDim = explode(':', $param1);
             if(count($pageDim) == 2  ||  count($pageDim) == 3) {
                 $pageWidth  = $pageDim[0];
                 $pageHeight = $pageDim[1];
             } else {
                 /**
                  * @todo support of user defined pagesize notations, like:
                  *       "210x297mm", "595x842", "8.5x11in", "612x792"
                  */
                 // require_once 'Zend/Pdf/Exception.php';
                 throw new Zend_Pdf_Exception('Wrong pagesize notation.');
             }
             /**
              * @todo support of pagesize recalculation to "default user space units"
              */
 
         } else if (is_numeric($param1) && is_numeric($param2) &&
                    ($param3 === null || $param3 instanceof Zend_Pdf_ElementFactory_Interface)) {
             if ($param3 !== null) {
                 $this->_objFactory = $param3;
             } else {
                 // require_once 'Zend/Pdf/ElementFactory.php';
                 $this->_objFactory = Zend_Pdf_ElementFactory::createFactory(1);
             }
 
             $this->_attached = false;
             $this->_safeGS   = true; /** New page created. That's users App responsibility to track GS changes */
             $pageWidth  = $param1;
             $pageHeight = $param2;
 
         } else {
             // require_once 'Zend/Pdf/Exception.php';
             throw new Zend_Pdf_Exception('Unrecognized method signature, wrong number of arguments or wrong argument types.');
         }
 
         $this->_dictionary = $this->_objFactory->newObject(new Zend_Pdf_Element_Dictionary());
         $this->_dictionary->Type         = new Zend_Pdf_Element_Name('Page');
         // require_once 'Zend/Pdf.php';
         $this->_dictionary->LastModified = new Zend_Pdf_Element_String(Zend_Pdf::pdfDate());
         $this->_dictionary->Resources    = new Zend_Pdf_Element_Dictionary();
         $this->_dictionary->MediaBox     = new Zend_Pdf_Element_Array();
         $this->_dictionary->MediaBox->items[] = new Zend_Pdf_Element_Numeric(0);
         $this->_dictionary->MediaBox->items[] = new Zend_Pdf_Element_Numeric(0);
         $this->_dictionary->MediaBox->items[] = new Zend_Pdf_Element_Numeric($pageWidth);
         $this->_dictionary->MediaBox->items[] = new Zend_Pdf_Element_Numeric($pageHeight);
         $this->_dictionary->Contents     = new Zend_Pdf_Element_Array();
     }
 
 
     /**
      * Attach resource to the canvas
      *
      * Method returns a name of the resource which can be used
      * as a resource reference within drawing instructions stream
      * Allowed types: 'ExtGState', 'ColorSpace', 'Pattern', 'Shading',
      * 'XObject', 'Font', 'Properties'
      *
      * @param string $type
      * @param Zend_Pdf_Resource $resource
      * @return string
      */
     protected function _attachResource($type, Zend_Pdf_Resource $resource)
     {
         // Check that Resources dictionary contains appropriate resource set
         if ($this->_dictionary->Resources->$type === null) {
             $this->_dictionary->Resources->touch();
             $this->_dictionary->Resources->$type = new Zend_Pdf_Element_Dictionary();
         } else {
             $this->_dictionary->Resources->$type->touch();
         }
 
         // Check, that resource is already attached to resource set.
         $resObject = $resource->getResource();
         foreach ($this->_dictionary->Resources->$type->getKeys() as $ResID) {
             if ($this->_dictionary->Resources->$type->$ResID === $resObject) {
                 return $ResID;
             }
         }
 
         $idCounter = 1;
         do {
             $newResName = $type[0] . $idCounter++;
         } while ($this->_dictionary->Resources->$type->$newResName !== null);
 
         $this->_dictionary->Resources->$type->$newResName = $resObject;
         $this->_objFactory->attach($resource->getFactory());
 
         return $newResName;
     }
 
     /**
      * Add procedureSet to the Page description
      *
      * @param string $procSetName
      */
     protected function _addProcSet($procSetName)
     {
         // Check that Resources dictionary contains ProcSet entry
         if ($this->_dictionary->Resources->ProcSet === null) {
             $this->_dictionary->Resources->touch();
             $this->_dictionary->Resources->ProcSet = new Zend_Pdf_Element_Array();
         } else {
             $this->_dictionary->Resources->ProcSet->touch();
         }
 
         foreach ($this->_dictionary->Resources->ProcSet->items as $procSetEntry) {
             if ($procSetEntry->value == $procSetName) {
                 // Procset is already included into a ProcSet array
                 return;
             }
         }
 
         $this->_dictionary->Resources->ProcSet->items[] = new Zend_Pdf_Element_Name($procSetName);
     }
 
     /**
      * Returns dictionaries of used resources.
      *
      * Used for canvas implementations interoperability
      *
      * Structure of the returned array:
      * array(
      *   <resTypeName> => array(
      *                      <resName> => <Zend_Pdf_Resource object>,
      *                      <resName> => <Zend_Pdf_Resource object>,
      *                      <resName> => <Zend_Pdf_Resource object>,
      *                      ...
      *                    ),
      *   <resTypeName> => array(
      *                      <resName> => <Zend_Pdf_Resource object>,
      *                      <resName> => <Zend_Pdf_Resource object>,
      *                      <resName> => <Zend_Pdf_Resource object>,
      *                      ...
      *                    ),
      *   ...
      *   'ProcSet' => array()
      * )
      *
      * where ProcSet array is a list of used procedure sets names (strings).
      * Allowed procedure set names: 'PDF', 'Text', 'ImageB', 'ImageC', 'ImageI'
      *
      * @internal
      * @return array
      */
     public function getResources()
     {
         $resources = array();
         $resDictionary = $this->_dictionary->Resources;
 
         foreach ($resDictionary->getKeys() as $resType) {
             $resources[$resType] = array();
 
             if ($resType == 'ProcSet') {
                 foreach ($resDictionary->ProcSet->items as $procSetEntry) {
                     $resources[$resType][] = $procSetEntry->value;
                 }
             } else {
                 $resMap = $resDictionary->$resType;
 
                 foreach ($resMap->getKeys() as $resId) {
                     $resources[$resType][$resId] =new Zend_Pdf_Resource_Unified($resMap->$resId);
                 }
             }
         }
 
         return $resources;
     }
 
     /**
      * Get drawing instructions stream
      *
      * It has to be returned as a PDF stream object to make it reusable.
      *
      * @internal
      * @returns Zend_Pdf_Resource_ContentStream
      */
     public function getContents()
     {
         /** @todo implementation */
     }
 
     /**
      * Return the height of this page in points.
      *
      * @return float
      */
     public function getHeight()
     {
         return $this->_dictionary->MediaBox->items[3]->value -
                $this->_dictionary->MediaBox->items[1]->value;
     }
 
     /**
      * Return the width of this page in points.
      *
      * @return float
      */
     public function getWidth()
     {
         return $this->_dictionary->MediaBox->items[2]->value -
                $this->_dictionary->MediaBox->items[0]->value;
     }
 
     /**
      * Clone page, extract it and dependent objects from the current document,
      * so it can be used within other docs.
      */
     public function __clone()
     {
         $factory = Zend_Pdf_ElementFactory::createFactory(1);
         $processed = array();
 
         // Clone dictionary object.
         // Do it explicitly to prevent sharing page attributes between different
         // results of clonePage() operation (other resources are still shared)
         $dictionary = new Zend_Pdf_Element_Dictionary();
         foreach ($this->_dictionary->getKeys() as $key) {
             $dictionary->$key = $this->_dictionary->$key->makeClone($factory->getFactory(),
                                                                         $processed,
                                                                         Zend_Pdf_Element::CLONE_MODE_SKIP_PAGES);
         }
 
         $this->_dictionary = $factory->newObject($dictionary);
         $this->_objFactory     = $factory;
         $this->_attached       = false;
         $this->_style          = null;
         $this->_font           = null;
     }
 
     /**
      * Clone page, extract it and dependent objects from the current document,
      * so it can be used within other docs.
      *
      * @internal
      * @param Zend_Pdf_ElementFactory_Interface $factory
      * @param array $processed
      * @return Zend_Pdf_Page
      */
     public function clonePage($factory, &$processed)
     {
         // Clone dictionary object.
         // Do it explicitly to prevent sharing page attributes between different
         // results of clonePage() operation (other resources are still shared)
         $dictionary = new Zend_Pdf_Element_Dictionary();
         foreach ($this->_dictionary->getKeys() as $key) {
             $dictionary->$key = $this->_dictionary->$key->makeClone($factory->getFactory(),
                                                                         $processed,
                                                                         Zend_Pdf_Element::CLONE_MODE_SKIP_PAGES);
         }
 
         $clonedPage = new Zend_Pdf_Page($factory->newObject($dictionary), $factory);
         $clonedPage->_attached = false;
 
         return $clonedPage;
     }
 
     /**
      * Retrive PDF file reference to the page
      *
      * @internal
      * @return Zend_Pdf_Element_Dictionary
      */
     public function getPageDictionary()
     {
         return $this->_dictionary;
     }
 
     /**
      * Dump current drawing instructions into the content stream.
      *
      * @todo Don't forget to close all current graphics operations (like path drawing)
      *
      * @throws Zend_Pdf_Exception
      */
     public function flush()
     {
         if ($this->_saveCount != 0) {
             // require_once 'Zend/Pdf/Exception.php';
             throw new Zend_Pdf_Exception('Saved graphics state is not restored');
         }
 
         if ($this->_contents == '') {
             return;
         }
 
         if ($this->_dictionary->Contents->getType() != Zend_Pdf_Element::TYPE_ARRAY) {
             /**
              * It's a stream object.
              * Prepare Contents page attribute for update.
              */
             $this->_dictionary->touch();
 
             $currentPageContents = $this->_dictionary->Contents;
             $this->_dictionary->Contents = new Zend_Pdf_Element_Array();
             $this->_dictionary->Contents->items[] = $currentPageContents;
         } else {
             $this->_dictionary->Contents->touch();
         }
 
         if ((!$this->_safeGS)  &&  (count($this->_dictionary->Contents->items) != 0)) {
             /**
              * Page already has some content which is not treated as safe.
              *
              * Add save/restore GS operators
              */
             $this->_addProcSet('PDF');
 
             $newContentsArray = new Zend_Pdf_Element_Array();
             $newContentsArray->items[] = $this->_objFactory->newStreamObject(" q\n");
             foreach ($this->_dictionary->Contents->items as $contentStream) {
                 $newContentsArray->items[] = $contentStream;
             }
             $newContentsArray->items[] = $this->_objFactory->newStreamObject(" Q\n");
 
             $this->_dictionary->touch();
             $this->_dictionary->Contents = $newContentsArray;
 
             $this->_safeGS = true;
         }
 
         $this->_dictionary->Contents->items[] =
                 $this->_objFactory->newStreamObject($this->_contents);
 
         $this->_contents = '';
     }
 
     /**
      * Prepare page to be rendered into PDF.
      *
      * @todo Don't forget to close all current graphics operations (like path drawing)
      *
      * @param Zend_Pdf_ElementFactory_Interface $objFactory
      * @throws Zend_Pdf_Exception
      */
     public function render(Zend_Pdf_ElementFactory_Interface $objFactory)
     {
         $this->flush();
 
         if ($objFactory === $this->_objFactory) {
             // Page is already attached to the document.
             return;
         }
 
         if ($this->_attached) {
             // require_once 'Zend/Pdf/Exception.php';
             throw new Zend_Pdf_Exception('Page is attached to other documen. Use clone $page to get it context free.');
         } else {
             $objFactory->attach($this->_objFactory);
         }
     }
 
     /**
      * Extract resources attached to the page
      *
      * This method is not intended to be used in userland, but helps to optimize some document wide operations
      *
      * returns array of Zend_Pdf_Element_Dictionary objects
      *
      * @internal
      * @return array
      */
     public function extractResources()
     {
         return $this->_dictionary->Resources;
     }
 
     /**
      * Extract fonts attached to the page
      *
      * returns array of Zend_Pdf_Resource_Font_Extracted objects
      *
      * @return array
      * @throws Zend_Pdf_Exception
      */
     public function extractFonts()
     {
         if ($this->_dictionary->Resources->Font === null) {
             // Page doesn't have any font attached
             // Return empty array
             return array();
         }
 
         $fontResources = $this->_dictionary->Resources->Font;
 
         $fontResourcesUnique = array();
         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 {
                 // require_once 'Zend/Pdf/Resource/Font/Extracted.php';
                 // Try to extract font
                 $extractedFont = new Zend_Pdf_Resource_Font_Extracted($fontDictionary);
 
                 $fonts[$resourceId] = $extractedFont;
             } catch (Zend_Pdf_Exception $e) {
                 if ($e->getMessage() != 'Unsupported font type.') {
                     throw new Zend_Pdf_Exception($e->getMessage(), $e->getCode(), $e);
                 }
             }
         }
 
         return $fonts;
     }
 
     /**
      * Extract font attached to the page by specific font name
      *
      * $fontName should be specified in UTF-8 encoding
      *
      * @return Zend_Pdf_Resource_Font_Extracted|null
      * @throws Zend_Pdf_Exception
      */
     public function extractFont($fontName)
     {
         if ($this->_dictionary->Resources->Font === null) {
             // Page doesn't have any font attached
             return null;
         }
 
         $fontResources = $this->_dictionary->Resources->Font;
 
         $fontResourcesUnique = array();
 
         // require_once 'Zend/Pdf/Exception.php';
         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 new Zend_Pdf_Exception($e->getMessage(), $e->getCode(), $e);
                 }
 
                 // Continue searhing font with specified name
             }
         }
 
         return null;
     }
 
     /**
      *
      * @param Zend_Pdf_Annotation $annotation
      * @return Zend_Pdf_Page
      */
     public function attachAnnotation(Zend_Pdf_Annotation $annotation)
     {
         $annotationDictionary = $annotation->getResource();
         if (!$annotationDictionary instanceof Zend_Pdf_Element_Object  &&
             !$annotationDictionary instanceof Zend_Pdf_Element_Reference) {
             $annotationDictionary = $this->_objFactory->newObject($annotationDictionary);
         }
 
         if ($this->_dictionary->Annots === null) {
             $this->_dictionary->touch();
             $this->_dictionary->Annots = new Zend_Pdf_Element_Array();
         } else {
             $this->_dictionary->Annots->touch();
         }
 
         $this->_dictionary->Annots->items[] = $annotationDictionary;
 
         $annotationDictionary->touch();
         $annotationDictionary->P = $this->_dictionary;
 
         return $this;
     }
 }