<?php
/**
 * File containing the ezcDocumentPdfMainRenderer class
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 *
 * @package Document
 * @version //autogen//
 * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
 * @access private
 */

/**
 * Main PDF renderer class, dispatching to sub renderer, maintaining page
 * contexts and transactions.
 *
 * The basic principles behind the used stacked backtracking rendering
 * algorithm are explained below.
 *
 * The basics
 * ==========
 *
 * The rendering size of a single block (paragraph, image) cannot be guessed 
 * properly beforehand, because the dimensions depend on the associated styles 
 * and the driver which needs to render the styles. Because of different fonts 
 * the size of a single simple string may notably vary. The renderer do not 
 * know about font properties, but only the drivers do.
 *
 * Because of that the renderers (like the paragraph renderer) can only 
 * request the used dimensions for each word, or word part from the current 
 * driver and try to fit that word into the currently available space.
 *
 * Some general constraints, like the handling of orphans and widows, require 
 * the renderer to backtrack. If a orphans constraint could not be fulfilled 
 * with the first rendering try, the renderer needs to decide to render less 
 * lines on the prior page and therefore needs to revert all local rendering 
 * steps and retry the rendering with the additional knowledge.
 *
 * For widow constraints this may mean, that a full paragraph is moved to the 
 * next page, which could mean, that the title before that paragraph might 
 * also be relocated to the following page, which would mean to revert 
 * multiple renderers and elements. To make this possible the renderer wraps 
 * the driver in a transactional driver wrapper.
 *
 * The transactional driver wrapper
 * --------------------------------
 *
 * Like the last paragraph explained it might be necessary to revert (large) 
 * amounts of rendering operations. Once the rendering operations (like 
 * drawWord) hit the driver they are immediately serialized into the
 * respective output format (PDF), and could not be reverted anymore.
 *
 * So an additional layer has been implemented in the class 
 * ezcDocumentPdfTransactionalDriverWrapper, which implements the same 
 * interface as all the other drivers, as well as some additional methods to 
 * handle "transactions".
 *
 * A renderer, like the paragraph renderer, may start a transaction, receives 
 * an ID identifying the started transaction, and may then start its rendering 
 * operations. If the rendering reached a dead end, it may revert everything 
 * using the initially given transaction ID. The revert will affect all 
 * operations since the original call to startTransaction(), even if other 
 * sub-renderers also started transactions in the meantime.
 *
 * The logged calls to the driver are passed up to the real driver once save() 
 * is called explicitly for the given transaction ID, or the main renderer 
 * attempts to write the PDF into a file.
 *
 * Depending on the type of the call the driver wrapper logs and / or passes 
 * the call directly up to the actual driver.
 *
 * Calls which are logged only:
 *  - Everything performing actual rendering, like drawLine(), drawWord(), ...
 *
 * Calls which are logged and passed:
 *  - Everything setting the current style configuration, which might also be 
 *    relevant for font width estimation, especially: setStyle()
 *
 * Calls which are not logged, but passed:
 *  - Everything, which only requests properties, but does not change the 
 *    driver state, like getTextWidth()
 *
 * The stacked renderers
 * ---------------------
 *
 * The main renderer, which is defined in this class, is responsible for 
 * managing the pages, the available horizontal space on the current page and 
 * calling the sub renderers for the distinct parts in the Docbook document.
 *
 * For each part there is a specialized renderer, which is only responsible 
 * for rendering such a part, like a list renderer, a list item renderer or a 
 * paragraph renderer. The main renderer traverses the Docbook document and calls 
 * the appropriate renderer. You may register additional renderers with the 
 * main renderer, for your custom elements, or overwrite the defined default 
 * renderers.
 *
 * The main renderer also handles special page elements, like headers and 
 * footers for each page.
 *
 * The sub renderers ask the main renderer for new space, if they exceeded the 
 * available space in the current column / on the current page. This is 
 * implemented in the method getNextRenderingPosition(). This method might 
 * request a new page from the driver.
 *
 * The sub renderer may as well call other sub renderer, for stacked element 
 * definitions or may request rendering for all those elements by the main 
 * renderer calling back to the process() method.
 *
 * The table sub renderer
 * ----------------------
 *
 * The table renderer is a special sub renderer, since the common space 
 * estimation does not apply here. Tables are structured into cells and the 
 * elements contained in one cell may only use the space defined by the cell. 
 * The table renderer therefore mimics (and extends) the main renderer. So 
 * when the contents of one cell are rendered the sub renderers for the cell 
 * contents (paragraphs, lists, ...) receive an instance of the table renderer 
 * as their "new" main renderer. The table renderer overwrites the methods 
 * like process() and getNextRenderingPosition(), so the sub renderers render 
 * their stuff at the correct positions in the cell.
 *
 * The table renderer itself again dispatches to its main renderer, when, for 
 * example, allocating new pages. In case of a stacked table, the main 
 * renderer of a table renderer may again be a table renderer, which then 
 * dispatches to the original main renderer.
 *
 * Style inheritance
 * -----------------
 *
 * The definition of styles works just like CSS with HTML. Each element 
 * inherits the styles from its parent element, which are then overwritten by 
 * the defined styles in the (P)CSS file.
 *
 * The inferring of the styles for a given element is implemented in the 
 * ezcDocumentPcssStyleInferencer class. An instance of this class containing 
 * the currently defined styles is available during the whole rendering 
 * process and will provide the styles for any element, which is passed to the 
 * object.
 *
 * Hyphenation
 * -----------
 *
 * Hyphenation is a critical task for proper text rendering. A custom 
 * hyphenator may be defined and passed to the renderer. Each text renderer 
 * will the ask the hyphenator to split words, if the whole word does not fit 
 * into one line any more. It would be sensible to implement a hyphenator 
 * based on some available dictionary files.
 *
 * Tokenizer
 * ---------
 *
 * For some languages it might be necessary to implement a different text 
 * tokenizer, which does not just split words at whitespaces. To accomplish 
 * that you may implement and pass a custom tokenizer, which is the 
 * responsible for splitting texts.
 *
 * Some renderers, like the literal box renderer, may already use custom 
 * tokenizers, to implement special rendering tasks.
 *
 * @package Document
 * @access private
 * @version //autogen//
 */
class ezcDocumentPdfMainRenderer extends ezcDocumentPdfRenderer implements ezcDocumentErrorReporting
{
    /**
     * Hyphenator used to split up words
     *
     * @var ezcDocumentPdfHyphenator
     */
    protected $hyphenator;

    /**
     * Tokenizer used to split up strings into words
     *
     * @var ezcDocumentPdfTokenizer
     */
    protected $tokenizer;

    /**
     * Document to render
     *
     * @var ezcDocumentDocbook
     */
    protected $document;

    /**
     * Last transactions started before rendering a new title. This is used to
     * determine, if a title is positioned as a single item in a column or on a
     * page and switch it to the next page in this case.
     *
     * @var mixed
     */
    protected $titleTransaction = null;

    /**
     * Indicator to restart rendering with an earlier item on the same level in
     * the DOM document tree.
     *
     * @var mixed
     */
    protected $restart = false;

    /**
     * Errors occured during the conversion process
     * 
     * @var array
     */
    protected $errors = array();

    /**
     * Maps document elements to handler functions
     *
     * Maps each document element of the associated namespace to its handler
     * method in the current class.
     *
     * @var array
     */
    protected $handlerMapping = array(
        'http://docbook.org/ns/docbook' => array(
            'article'       => 'initializeDocument',
            'section'       => 'renderBlock',
            'sectioninfo'   => 'appendMetaData',

            'para'          => 'renderParagraph',
            'title'         => 'renderTitle',

            'mediaobject'   => 'renderMediaObject',

            'literallayout' => 'renderLiteralLayout',

            'blockquote'    => 'renderBlockquote',

            'table'         => 'renderTable',

            'itemizedlist'  => 'renderList',
            'orderedlist'   => 'renderList',
            'variablelist'  => 'renderBlock',
            'varlistentry'  => 'renderBlock',
            'listitem'      => 'renderListItem',
            'term'          => 'renderTitle',
        ),
    );

    /**
     * Additional PDF parts.
     *
     * @var array
     */
    protected $parts = array();

    /**
     * Error reporting level
     * 
     * @var int
     */
    protected $errorReporting = 15;

    /**
     * PDF renderer options
     * 
     * @var ezcDocumentPdfOptions
     */
    protected $options;

    /**
     * Construct renderer from driver to use
     *
     * @param ezcDocumentPdfDriver $driver 
     * @param ezcDocumentPcssStyleInferencer $styles 
     * @param ezcDocumentPdfOptions $options 
     * @return void
     */
    public function __construct( ezcDocumentPdfDriver $driver, ezcDocumentPcssStyleInferencer $styles, ezcDocumentPdfOptions $options = null )
    {
        $this->driver = new ezcDocumentPdfTransactionalDriverWrapper();
        $this->driver->setDriver( $driver );
        $this->styles         = $styles;
        $this->options        = $options;
        $this->errorReporting = $options !== null ? $options->errorReporting : 15;
    }

    /**
     * Trigger visitor error
     *
     * Emit a vistitor error, and convert it to an exception depending on the
     * error reporting settings.
     *
     * @param int $level
     * @param string $message
     * @param string $file
     * @param int $line
     * @param int $position
     * @return void
     */
    public function triggerError( $level, $message, $file = null, $line = null, $position = null )
    {
        if ( $level & $this->errorReporting )
        {
            throw new ezcDocumentVisitException( $level, $message, $file, $line, $position );
        }
        else
        {
            // If the error should not been reported, we aggregate it to maybe
            // display it later.
            $this->errors[] = new ezcDocumentVisitException( $level, $message, $file, $line, $position );
        }
    }

    /**
     * Return list of errors occured during visiting the document.
     *
     * May be an empty array, if on errors occured, or a list of
     * ezcDocumentVisitException objects.
     *
     * @return array
     */
    public function getErrors()
    {
        return $this->errors;
    }

    /**
     * Tries to locate a file
     *
     * Tries to locate a file, referenced in a docbook document. If available
     * the document path is used a base for relative paths.
     *
     * @param string $file
     * @return string
     */
    public function locateFile( $file )
    {
        if ( !ezcBaseFile::isAbsolutePath( $file ) )
        {
            $file = $this->document->getPath() . $file;
        }

        if ( !is_file( $file ) )
        {
            throw new ezcBaseFileNotFoundException( $file );
        }

        return $file;
    }

    /**
     * Register an additional PDF part
     *
     * Register additional parts, like footnotes, headers or title pages.
     *
     * @param ezcDocumentPdfPart $part
     * @return void
     */
    public function registerPdfPart( ezcDocumentPdfPart $part )
    {
        $this->parts[] = $part;
        $part->registerContext( $this, $this->driver, $this->styles );
    }

    /**
     * Render given document
     *
     * Returns the rendered PDF as string
     *
     * @param ezcDocumentDocbook $document
     * @param ezcDocumentPdfHyphenator $hyphenator
     * @param ezcDocumentPdfTokenizer $tokenizer
     * @return string
     */
    public function render( ezcDocumentDocbook $document, ezcDocumentPdfHyphenator $hyphenator = null, ezcDocumentPdfTokenizer $tokenizer = null )
    {
        $this->hyphenator = $hyphenator !== null ? $hyphenator : new ezcDocumentPdfDefaultHyphenator();
        $this->tokenizer  = $tokenizer !== null ? $tokenizer : new ezcDocumentPdfDefaultTokenizer();
        $this->document   = $document;

        // Register custom fonts in driver
        $this->registerFonts();

        // Inject custom element class, for style inferencing
        $dom = $document->getDomDocument();

        // Reload the XML document with to a DOMDocument with a custom element
        // class. Just registering it on the existing document seems not to
        // work in all cases.
        $reloaded = new DOMDocument();
        $reloaded->registerNodeClass( 'DOMElement', 'ezcDocumentLocateableDomElement' );
        $reloaded->loadXml( $dom->saveXml() );

        $this->process( $reloaded );
        return $this->driver->save();
    }

    /**
     * Register fonts in driver
     *
     * Register the font classes specified in the styles with the driver, so 
     * the driver can use the fonts during the rendering.
     * 
     * @return void
     */
    protected function registerFonts()
    {
        foreach ( $this->styles->getDefinitions( 'font-face' ) as $font )
        {
            if ( !isset( $font->formats['font-family'] ) )
            {
                $this->triggerError( E_WARNING, "Missing font-family declaration in @font-face specification.", $font->file, $font->line );
                continue;
            }
            $name = $font->formats['font-family']->value;

            if ( !isset( $font->formats['src'] ) )
            {
                $this->triggerError( E_WARNING, "Missing src declaration in @font-face specification.", $font->file, $font->line );
                continue;
            }
            $pathes = $font->formats['src']->value;

            $style = ezcDocumentPdfDriver::FONT_PLAIN;
            if ( isset( $font->formats['font-style'] ) &&
                 ( ( $font->formats['font-style']->value === 'oblique' ) ||
                   ( $font->formats['font-style']->value === 'italic' ) ) )
            {
                $style |= ezcDocumentPdfDriver::FONT_OBLIQUE;
            }

            if ( isset( $font->formats['font-weight'] ) &&
                 ( ( $font->formats['font-weight']->value === 'bold' ) ||
                   ( $font->formats['font-weight']->value === 'bolder' ) ) )
            {
                $style |= ezcDocumentPdfDriver::FONT_BOLD;
            }

            $this->driver->registerFont( $name, $style, $pathes );
        }
    }

    /**
     * Check column or page skip prerequisite
     *
     * If no content has been rendered any more in the current column, this
     * method should be called to check prerequisite for the skip, which is
     * especially important for already rendered items, which impose
     * assumptions on following contents.
     *
     * One example for this are titles, which should always be followed by at
     * least some content in the same column.
     *
     * Returns false, if prerequisite are not fulfileld and rendering should be
     * aborted.
     *
     * @param float $move
     * @param float $width
     * @return bool
     */
    public function checkSkipPrerequisites( $move, $width )
    {
        // Ensure the paragraph is on the same page / in the same column
        // like a title, of it is the first paragraph
        if ( $this->titleTransaction === null )
        {
            return true;
        }

        $this->driver->revert( $this->titleTransaction['transaction'] );

        // The rendering should now start again with the title on the
        // next column / page.
        $this->getNextRenderingPosition( $move, $width );
        $this->restart = $this->titleTransaction['position'] - 1;

        $this->titleTransaction = null;
        return false;
    }

    /**
     * Calculate text width
     *
     * Calculate the available horizontal space for texts depending on the
     * page layout settings.
     *
     * @param ezcDocumentPdfPage $page
     * @param ezcDocumentLocateableDomElement $text
     * @return float
     */
    public function calculateTextWidth( ezcDocumentPdfPage $page, ezcDocumentLocateableDomElement $text )
    {
        // Inference page styles
        $rules = $this->styles->inferenceFormattingRules( $text );

        return ( $page->innerWidth -
                ( $rules['text-column-spacing']->value * ( $rules['text-columns']->value - 1 ) )
            ) / $rules['text-columns']->value
            - $page->xOffset - $page->xReduce;
    }

    /**
     * Get next rendering position
     *
     * If the current space has been exceeded this method calculates
     * a new rendering position, optionally creates a new page for
     * this, or switches to the next column. The new rendering
     * position is set on the returned page object.
     *
     * As the parameter you need to pass the required width for the object to
     * place on the page.
     *
     * @param float $move
     * @param float $width
     * @return ezcDocumentPdfPage
     */
    public function getNextRenderingPosition( $move, $width )
    {
        // Then move paragraph into next column / page;
        $trans = $this->driver->startTransaction();
        $page  = $this->driver->currentPage();
        if ( ( ( $newX = $page->x + $move ) < ( $page->startX + $page->innerWidth ) ) &&
             ( ( $space = $page->testFitRectangle( $newX, null, $width, 2 ) ) !== false ) )
        {
            // Another column fits on the current page, find starting Y
            // position
            $page->x = $space->x;
            $page->y = $space->y;

            return $page;
        }

        // If there is no space for a new column, create a new page
        $oldPage = $page;
        $page = $this->driver->appendPage( $this->styles );
        $page->xOffset = $oldPage->xOffset;
        $page->xReduce = $oldPage->xReduce;
        foreach ( $this->parts as $part )
        {
            $part->hookPageCreation( $page );
        }
        return $page;
    }

    /**
     * Process a single element with the registered renderers.
     * 
     * @param DOMElement $element 
     * @param int $number
     * @return int
     */
    public function processNode( DOMElement $element, $number = 0 )
    {
        // Default to docbook namespace, if no namespace is defined
        $namespace = $element->namespaceURI === null ? 'http://docbook.org/ns/docbook' : $element->namespaceURI;

        if ( !isset( $this->handlerMapping[$namespace] ) ||
             !isset( $this->handlerMapping[$namespace][$element->tagName] ) )
        {
            $this->triggerError(
                E_NOTICE,
                "Unknown and unhandled element: {$namespace}:{$element->tagName}."
            );
            return $number;
        }

        $method = $this->handlerMapping[$namespace][$element->tagName];
        $this->$method( $element, $number );

        // Check if the rendering process should be restarted at an earlier
        // point
        if ( $this->restart !== false )
        {
            $number = $this->restart;
            $this->restart = false;
            return $number;
        }

        return $number;
    }

    /**
     * Recurse into DOMDocument tree and call appropriate element handlers
     *
     * @param DOMNode $element
     * @return void
     */
    public function process( DOMNode $element )
    {
        $childNodes = $element->childNodes;
        $nodeCount  = $childNodes->length;

        for ( $i = 0; $i < $nodeCount; ++$i )
        {
            $child = $childNodes->item( $i );
            if ( $child->nodeType !== XML_ELEMENT_NODE )
            {
                continue;
            }

            $i = $this->processNode( $child, $i );
        }
    }

    /**
     * Ignore elements, which should not be rendered
     *
     * @param ezcDocumentLocateableDomElement $element
     * @return void
     */
    private function ignore( ezcDocumentLocateableDomElement $element )
    {
        // Just do nothing.
    }

    /**
     * Initialize document according to detected root node
     *
     * @param ezcDocumentLocateableDomElement $element
     * @return void
     */
    private function initializeDocument( ezcDocumentLocateableDomElement $element )
    {
        // Call hooks for started document
        foreach ( $this->parts as $part )
        {
            $part->hookDocumentCreation( $element );
        }

        $page = $this->driver->appendPage( $this->styles );
        // Call hooks for fresh new first page
        foreach ( $this->parts as $part )
        {
            $part->hookPageCreation( $page );
        }

        // Continue processing sub nodes
        $this->process( $element );

        // Call hooks for finished document
        foreach ( $this->parts as $part )
        {
            $part->hookDocumentRendering( $element );
        }
    }

    /**
     * Append document metadata
     * 
     * @param ezcDocumentLocateableDomElement $element 
     * @return void
     */
    private function appendMetaData( ezcDocumentLocateableDomElement $element )
    {
        $childNodes = $element->childNodes;
        $nodeCount  = $childNodes->length;

        // Default metadata values
        $metadata = array(
            'created'  => date( 'r' ),
            'modified' => date( 'r' ),
        );

        // Fields mapped to metadata identifiers
        $fields = array(
            'http://docbook.org/ns/docbook' => array(
                'title'    => 'title',
                'author'   => 'author',
                'authors'  => 'author',
                'subtitle' => 'subject',
                'pubdate'  => 'created',
                'date'     => 'modified',
            ),
        );

        for ( $i = 0; $i < $nodeCount; ++$i )
        {
            $child = $childNodes->item( $i );
            if ( $child->nodeType !== XML_ELEMENT_NODE )
            {
                continue;
            }

            $namespace = $element->namespaceURI === null ? 'http://docbook.org/ns/docbook' : $element->namespaceURI;
            if ( isset( $fields[$namespace] ) &&
                 isset( $fields[$namespace][$child->tagName] ) )
            {
                $metadata[$fields[$namespace][$child->tagName]] = $child->textContent;
            }
        }

        foreach ( $metadata as $key => $value )
        {
            $this->driver->setMetaData( $key, $value );
        }
    }

    /**
     * Handle calls to block element renderer
     *
     * @param ezcDocumentLocateableDomElement $element
     * @return void
     */
    private function renderBlock( ezcDocumentLocateableDomElement $element )
    {
        $renderer = new ezcDocumentPdfBlockRenderer( $this->driver, $this->styles );
        $page     = $this->driver->currentPage();
        return $renderer->renderNode( $page, $this->hyphenator, $this->tokenizer, $element, $this );
    }

    /**
     * Handle calls to block element renderer
     *
     * @param ezcDocumentLocateableDomElement $element
     * @return void
     */
    private function renderBlockquote( ezcDocumentLocateableDomElement $element )
    {
        $renderer = new ezcDocumentPdfBlockquoteRenderer( $this->driver, $this->styles );
        $page     = $this->driver->currentPage();
        return $renderer->renderNode( $page, $this->hyphenator, $this->tokenizer, $element, $this );
    }

    /**
     * Handle calls to table element renderer
     *
     * @param ezcDocumentLocateableDomElement $element
     * @return void
     */
    private function renderTable( ezcDocumentLocateableDomElement $element )
    {
        $renderer = new ezcDocumentPdfTableRenderer( $this->driver, $this->styles, $this->options );
        $page     = $this->driver->currentPage();
        return $renderer->renderNode( $page, $this->hyphenator, $this->tokenizer, $element, $this );
    }

    /**
     * Handle calls to List element renderer
     *
     * @param ezcDocumentLocateableDomElement $element
     * @return void
     */
    private function renderList( ezcDocumentLocateableDomElement $element )
    {
        $renderer = new ezcDocumentPdfListRenderer( $this->driver, $this->styles );
        $page     = $this->driver->currentPage();
        return $renderer->renderNode( $page, $this->hyphenator, $this->tokenizer, $element, $this );
    }

    /**
     * Handle calls to list item element renderer
     *
     * @param ezcDocumentLocateableDomElement $element
     * @return void
     */
    private function renderListItem( ezcDocumentLocateableDomElement $element )
    {
        $renderer = new ezcDocumentPdfListItemRenderer( $this->driver, $this->styles, new ezcDocumentNoListItemGenerator(), 0 );
        $page     = $this->driver->currentPage();
        return $renderer->renderNode( $page, $this->hyphenator, $this->tokenizer, $element, $this );
    }

    /**
     * Handle calls to paragraph renderer
     *
     * @param ezcDocumentLocateableDomElement $element
     * @return void
     */
    private function renderParagraph( ezcDocumentLocateableDomElement $element )
    {
        $renderer = new ezcDocumentPdfWrappingTextBoxRenderer( $this->driver, $this->styles );
        $page     = $this->driver->currentPage();
        $styles   = $this->styles->inferenceFormattingRules( $element );

        // Just try to render at current position first
        $trans = $this->driver->startTransaction();
        if ( $renderer->renderNode( $page, $this->hyphenator, $this->tokenizer, $element, $this ) )
        {
            $this->titleTransaction = null;
            $this->handleAnchors( $element );
            return true;
        }

        // Check if something requested a rendering restart at a prior point,
        // only continue otherwise.
        if ( ( $this->restart !== false ) ||
             ( !$this->checkSkipPrerequisites(
                    ( $pWidth = $this->calculateTextWidth( $page, $element ) ) +
                    $styles['text-column-spacing']->value,
                    $pWidth
                ) ) )
        {
            return false;
        }

        // If that did not work, switch to the next possible location and start
        // there.
        $this->driver->revert( $trans );
        $this->getNextRenderingPosition(
            ( $pWidth = $this->calculateTextWidth( $page, $element ) ) +
            $styles['text-column-spacing']->value,
            $pWidth
        );
        return $this->renderParagraph( $element );
    }

    /**
     * Handle calls to title renderer
     *
     * @param ezcDocumentLocateableDomElement $element
     * @param int $position
     */
    private function renderTitle( ezcDocumentLocateableDomElement $element, $position )
    {
        $styles   = $this->styles->inferenceFormattingRules( $element );
        $renderer = new ezcDocumentPdfTitleRenderer( $this->driver, $this->styles );
        $page     = $this->driver->currentPage();

        // Just try to render at current position first
        $this->titleTransaction = array(
            'transaction' => $this->driver->startTransaction(),
            'page'        => $page,
            'xPos'        => $page->x,
            'position'    => $position,
        );
        if ( $renderer->renderNode( $page, $this->hyphenator, $this->tokenizer, $element, $this ) )
        {
            $this->handleAnchors( $element );
            return true;
        }
        $this->driver->revert( $this->titleTransaction['transaction'] );

        $this->getNextRenderingPosition(
            ( $pWidth = $this->calculateTextWidth( $page, $element ) ) +
            $styles['text-column-spacing']->value,
            $pWidth
        );
        return $this->renderTitle( $element, $position );
    }

    /**
     * Handle calls to media object renderer
     *
     * @param ezcDocumentLocateableDomElement $element
     * @return void
     */
    private function renderMediaObject( ezcDocumentLocateableDomElement $element )
    {
        $renderer = new ezcDocumentPdfMediaObjectRenderer( $this->driver, $this->styles );
        $page     = $this->driver->currentPage();

        // Just try to render at current position first
        $trans = $this->driver->startTransaction();
        $renderer->renderNode( $page, $this->hyphenator, $this->tokenizer, $element, $this );
        $this->handleAnchors( $element );
    }

    /**
     * Handle calls to paragraph renderer
     *
     * @param ezcDocumentLocateableDomElement $element
     * @return void
     */
    private function renderLiteralLayout( ezcDocumentLocateableDomElement $element )
    {
        $renderer = new ezcDocumentPdfLiteralBlockRenderer( $this->driver, $this->styles );
        $page     = $this->driver->currentPage();
        $styles   = $this->styles->inferenceFormattingRules( $element );

        // Just try to render at current position first
        $trans = $this->driver->startTransaction();
        if ( $renderer->renderNode( $page, $this->hyphenator, $this->tokenizer, $element, $this ) )
        {
            $this->titleTransaction = null;
            $this->handleAnchors( $element );
            return true;
        }

        // Check if something requested a rendering restart at a prior point,
        // only continue otherwise.
        if ( ( $this->restart !== false ) ||
             ( !$this->checkSkipPrerequisites(
                    ( $pWidth = $this->calculateTextWidth( $page, $element ) ) +
                    $styles['text-column-spacing']->value,
                    $pWidth
                ) ) )
        {
            return false;
        }

        // If that did not work, switch to the next possible location and start
        // there.
        $this->driver->revert( $trans );
        $this->getNextRenderingPosition(
            ( $pWidth = $this->calculateTextWidth( $page, $element ) ) +
            $styles['text-column-spacing']->value,
            $pWidth
        );
        return $this->renderParagraph( $element );
    }

    /**
     * Handle all anchors inside the current element
     *
     * Finds all anchors somewhere in the current element and adds reference
     * targets for them.
     * 
     * @param ezcDocumentLocateableDomElement $element 
     * @return void
     */
    private function handleAnchors( ezcDocumentLocateableDomElement $element )
    {
        $xpath = new DOMXPath( $element->ownerDocument );
        $xpath->registerNamespace( 'doc', 'http://docbook.org/ns/docbook' );
        foreach ( $xpath->query( './/doc:anchor', $element ) as $anchor )
        {
            $this->driver->addInternalLinkTarget( $anchor->getAttribute( 'id' ) );
        }
    }
}

?>