Document/src/document/pdf/renderer/text_box.php - zetacomponents - Git at Google

 <?php
 /**
  * File containing the ezcDocumentPdfTextBoxRenderer 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
  */

 /**
  * Renders a single text box
  *
  * Tries to render a single text box into the available space, and aborts if
  * not possible.
  *
  * Implements the basic methods for tokenizing the text, style based text
  * fitting into lines, etc. Should be extended by all classes implementing more
  * specific text rendering algorithms, since those base methods are implemented
  * generally enough to be reused.
  *
  * @package Document
  * @access private
  * @version //autogen//
  */
 class ezcDocumentPdfTextBoxRenderer extends ezcDocumentPdfBlockRenderer
 {
     /**
      * Render a single text box
      *
      * All markup inside of the given string is considered inline markup (in
      * CSS terms). Inline markup should be given as common docbook inline
      * markup, like <emphasis>.
      *
      * Returns a boolean indicator whether the rendering of the full text
      * in the available space succeeded or not.
      *
      * @param ezcDocumentPdfPage $page
      * @param ezcDocumentPdfHyphenator $hyphenator
      * @param ezcDocumentPdfTokenizer $tokenizer
      * @param ezcDocumentLocateableDomElement $text
      * @param ezcDocumentPdfMainRenderer $mainRenderer
      * @return bool
      */
     public function renderNode( ezcDocumentPdfPage $page, ezcDocumentPdfHyphenator $hyphenator, ezcDocumentPdfTokenizer $tokenizer, ezcDocumentLocateableDomElement $text, ezcDocumentPdfMainRenderer $mainRenderer )
     {
         // Inference page styles
         $styles = $this->styles->inferenceFormattingRules( $text );
         $width  = $page->innerWidth / $styles['text-columns']->value -
             ( $styles['text-column-spacing']->value * ( $styles['text-columns']->value - 1 ) );

         // Evaluate available space
         if ( ( $space = $this->evaluateAvailableBoundingBox( $page, $styles, $width ) ) === false )
         {
             return false;
         }

         // Iterate over tokens and try to fit them in the current line, use
         // hyphenator to split words.
         $tokens = $this->tokenize( $text, $tokenizer );
         $lines  = $this->fitTokensInLines( $tokens, $hyphenator, $space->width );

         // Evaluate required space by text box
         $required = 0;
         foreach ( $lines as $line )
         {
             $required += $line['height'] * $styles['line-height']->value;
         }

         // Check that enough space is available to render text box
         if ( $required > $space->height )
         {
             return false;
         }
         $space->height = $required;

         $this->renderBoxBackground( $space, $styles );
         $this->renderBoxBorder( $space, $styles );
         $this->renderTextBox( $lines, $space, $styles );
         $this->setBoxCovered( $page, $space, $styles );
         return true;
     }

     /**
      * Render text box
      *
      * Render a single text box, specified by the given lines array,
      * containing tokens and their styles, the available space and
      * the styles array for the currently rendered element.
      *
      * Returns false, if the box size was not sufficant for the
      * given text, and the covered vertical area otherwise.
      *
      * @param array $lines
      * @param ezcDocumentPdfBoundingBox $space
      * @param array $styles
      * @return boolean
      */
     protected function renderTextBox( array $lines, ezcDocumentPdfBoundingBox $space, array $styles )
     {
         $yPos = $space->y;
         foreach ( $lines as $nr => $line )
         {
             $yPos += $this->renderLine( $yPos, $nr, $line, $space, $styles ) * $styles['line-height']->value;

             // Check if we run out of vertical space
             if ( $yPos > ( $space->y + $space->height ) )
             {
                 return false;
             }
         }

         return $yPos - $space->y;
     }

     /**
      * Reverses a string
      *
      * Similar to PHPs strrev() function, but also works for UTF-8 strings.
      *
      * @param string $string
      * @return string
      */
     protected function strrev( $string )
     {
         if ( !is_string( $string ) || empty( $string ) )
         {
             return $string;
         }

         if ( strlen( $string ) === ( $length = iconv_strlen( $string, 'UTF-8' ) ) )
         {
             // String only contains of single-byte characters
             return strrev( $string );
         }

         $reverted = '';
         for ( $c = $length; $c > 0; --$c )
         {
             $reverted .= iconv_substr( $string, $c - 1, 1, 'UTF-8' );
         }
         return $reverted;
     }

     /**
      * Render a single line and return the used height
      *
      * @param float $position
      * @param int $number
      * @param array $line
      * @param ezcDocumentPdfBoundingBox $space
      * @param array $styles
      * @return void
      */
     protected function renderLine( $position, $number, array $line, ezcDocumentPdfBoundingBox $space, array $styles )
     {
         $spaceWidth = $this->driver->calculateWordWidth( ' ' );
         $lineWidth = 0;
         foreach ( $line['tokens'] as $token )
         {
             if ( !is_int( $token['word'] ) )
             {
                 $lineWidth += $token['width'];
             }
         }

         // Reverse alignement, if direction is set to "right-to-left"
         $align = $styles['text-align']->value;
         if ( $styles['direction']->value === 'rtl' )
         {
             switch ( $align )
             {
                 case 'right':
                     $align = 'left';
                 default:
                     $align = 'right';
             }
         }

         switch ( $align )
         {
             case 'center':
                 $offset = ( $space->width - $lineWidth - ( $line['spaces'] * $spaceWidth ) ) / 2;
                 break;
             case 'right':
                 $offset = $space->width - $lineWidth - ( $line['spaces'] * $spaceWidth );
                 break;
             case 'justify':
                 $offset = 0;
                 switch ( true )
                 {
                     case $number === $line['words']:
                         // Just use common space width in last line of a
                         // paragraph
                         $spaceWidth = $this->driver->calculateWordWidth( ' ' );
                         break;
                     case $line['words'] <= 1:
                         // Space width is irrelevant, if only one token is
                         // in the line
                         break;
                     default:
                         $spaceWidth = ( $space->width - $lineWidth ) / ( $line['spaces'] - 1 );
                 }
             default:
                 $offset = 0;
         }

         // Reverse tokens and words, if direction is set to "right-to-left"
         $tokens = $line['tokens'];
         if ( $styles['direction']->value === 'rtl' )
         {
             $tokens = array_reverse( $tokens );
             foreach ( $tokens as $nr => $token )
             {
                 if ( is_string( $token['word'] ) )
                 {
                     $tokens[$nr]['word'] = $this->strrev( $token['word'] );
                 }
             }
         }

         // Default to left alignement
         $xPos = $space->x + $offset;
         foreach ( $tokens as $token )
         {
             if ( $token['word'] === ezcDocumentPdfTokenizer::SPACE )
             {
                 $this->renderTextDecoration( $token['style'], $xPos, $position, $spaceWidth, $line['height'] );
                 $this->handleLinks( $token, $xPos, $position, $spaceWidth, $line['height'] );

                 $xPos += $spaceWidth;
             }
             else if ( is_string( $token['word'] ) )
             {
                 $this->renderTextDecoration( $token['style'], $xPos, $position, $token['width'], $line['height'] );

                 // Apply current styles
                 foreach ( $token['style'] as $style => $value )
                 {
                     $this->driver->setTextFormatting( $style, $value->value );
                 }

                 // Render word
                 $this->driver->drawWord( $xPos, $position + $line['height'], $token['word'] );
                 $this->handleLinks( $token, $xPos, $position, $token['width'], $line['height'] );
                 $xPos += $token['width'];
             }
         }

         return $line['height'];
     }

     /**
      * Handle links
      *
      * Handle embedded link markup for current token and perform the
      * appropriate calls to the driver.
      *
      * @param array $token
      * @param float $x
      * @param float $y
      * @param float $width
      * @param float $height
      * @return void
      */
     protected function handleLinks( array $token, $x, $y, $width, $height )
     {
         if ( $token['url'] !== null )
         {
             $this->driver->addExternalLink( $x, $y, $width, $height * 1.1, $token['url'] );
         }

         if ( $token['target'] !== null )
         {
             $this->driver->addInternalLink( $x, $y, $width, $height * 1.1, $token['target'] );
         }
     }

     /**
      * Render text decoration
      *
      * Render text decoration, like by a assigned text-decoration setting, or
      * background-colors, and similar.
      *
      * @param array $styles
      * @param float $x
      * @param float $y
      * @param float $width
      * @param float $height
      * @return void
      */
     protected function renderTextDecoration( array $styles, $x, $y, $width, $height )
     {
         // Directly exit, if there are no decorations to render
         if ( ( $styles['text-decoration']->value === 'none' ) &&
              ( !isset( $styles['background-color'] ) ||
                ( $styles['background-color']->value['alpha'] >= 1 ) ) )
         {
             return;
         }

         if ( isset( $styles['background-color'] ) &&
              ( $styles['background-color']->value['alpha'] < 1 ) )
         {
             $this->driver->drawPolygon(
                 array(
                     array( $x, $y ),
                     array( $x + $width, $y ),
                     array( $x + $width, $y + $height * $styles['line-height']->value ),
                     array( $x, $y + $height * $styles['line-height']->value ),
                 ),
                 $styles['background-color']->value
             );
         }

         if ( strpos( $styles['text-decoration'], 'line-through' ) !== false )
         {
             $this->driver->drawPolyline(
                 array(
                     array( $x, $y + $height - $styles['font-size']->value / 3 ),
                     array( $x + $width, $y + $height - $styles['font-size']->value / 3 ),
                 ),
                 $styles['color']->value,
                 // @todo: How thick should line-throughs be?
                 ezcDocumentPcssMeasure::create( '1px' )->get(),
                 false
             );
         }

         if ( strpos( $styles['text-decoration'], 'overline' ) !== false )
         {
             $this->driver->drawPolyline(
                 array(
                     array( $x, $y ),
                     array( $x + $width, $y ),
                 ),
                 $styles['color']->value,
                 // @todo: How thick should overlines be?
                 ezcDocumentPcssMeasure::create( '1px' )->get(),
                 false
             );
         }

         if ( strpos( $styles['text-decoration'], 'underline' ) !== false )
         {
             $this->driver->drawPolyline(
                 array(
                     array( $x, $y + $height * 1.1 ),
                     array( $x + $width, $y + $height * 1.1 ),
                 ),
                 $styles['color']->value,
                 // @todo: How thick should underlines be?
                 ezcDocumentPcssMeasure::create( '1px' )->get(),
                 false
             );
         }
     }

     /**
      * Tokenize the input string
      *
      * For proper word wrapping in the paragraph the strng needs to be
      * tokenized, while each token has to maintain its stack of assigned
      * formats.
      *
      * This method should return an array of tokens, also maintaining the
      * included whitespace characters, each associated with its markup
      * elements.
      *
      * @param ezcDocumentLocateableDomElement $element
      * @param ezcDocumentPdfTokenizer $tokenizer
      * @param bool $recursed
      * @return array
      */
     protected function tokenize( ezcDocumentLocateableDomElement $element, ezcDocumentPdfTokenizer $tokenizer, $recursed = false )
     {
         $tokens = array();
         $rules  = $this->styles->inferenceFormattingRules( $element, ezcDocumentPcssStyleInferencer::TEXT );

         // Do not inherit background and border rules from paragraph
         if ( !$recursed )
         {
             $rules = array_diff_key( $rules, array(
                 'background-color' => true,
                 'border'           => true,
             ) );
         }

         $url    = $element->tagName === 'ulink' && $element->hasAttribute( 'url'    ) ? $element->getAttribute( 'url'    ) : null;
         $target = $element->tagName === 'link'  && $element->hasAttribute( 'linked' ) ? $element->getAttribute( 'linked' ) : null;

         foreach ( $element->childNodes as $child )
         {
             switch ( $child->nodeType )
             {
                 // case XML_CDATA_SECTION_NODE:
                 case XML_TEXT_NODE:
                     $words = $tokenizer->tokenize( $child->textContent );
                     foreach ( $words as $word )
                     {
                         $tokens[] = array(
                             'word'   => $word,
                             'style'  => $rules,
                             'url'    => $url,
                             'target' => $target,
                         );
                     }
                     break;

                 case XML_ELEMENT_NODE:
                     $tokens = array_merge(
                         $tokens,
                         $this->tokenize( $child, $tokenizer, true )
                     );
                     break;
             }
         }

         if ( !$recursed )
         {
             // Remove double spaces
             foreach ( $tokens as $nr => $token )
             {
                 if ( ( $token['word'] === ezcDocumentPdfTokenizer::SPACE ) &&
                      isset( $tokens[$nr + 1] ) &&
                      ( $tokens[$nr + 1]['word'] === ezcDocumentPdfTokenizer::SPACE ) )
                 {
                     $i = 1;
                     do {
                         unset( $tokens[$nr + $i] );
                     } while ( isset( $tokens[$nr + ( ++$i )] ) &&
                               ( $tokens[$nr + $i]['word'] === ezcDocumentPdfTokenizer::SPACE ) );
                 }
             }
             $tokens = array_values( $tokens );

             // Remove optional starting spaces
             if ( count( $tokens ) &&
                  ( $tokens[0]['word'] === ezcDocumentPdfTokenizer::SPACE ) )
             {
                 $tokens = array_slice( $tokens, 1 );
             }
         }

         return $tokens;
     }

     /**
      * Force split a word.
      *
      * Force the splitting of a word, which did not fit in a line alone and
      * could not be splitted using the hyphenator. We just search for the
      * maximum word part length which fits the available space.
      *
      * Could be improved to use a binary search on the word length, but this
      * shouldn't happen too often anyways.
      *
      * @param string $word
      * @param float $available
      * @return array
      */
     protected function forceSplit( $word, $available )
     {
         $length = iconv_strlen( $word ) - 1;
         while ( $this->driver->calculateWordWidth( iconv_substr( $word, 0, $length ) ) > $available )
         {
             --$length;
         }

         return array(
             iconv_substr( $word, 0, $length ),
             iconv_substr( $word, $length )
         );
     }

     /**
      * Try to match tokens into lines
      *
      * Try to match tokens into lines of the given width. Returns an array with
      * words for each line. The words might already be split up by the
      * hyphenator.
      *
      * @param array $tokens
      * @param ezcDocumentPdfHyphenator $hyphenator
      * @param float $available
      * @return array
      */
     protected function fitTokensInLines( array $tokens, ezcDocumentPdfHyphenator $hyphenator, $available )
     {
         $lines    = array( array(
             'tokens' => array(),
             'height' => 0,
             'words'  => 0,
             'spaces' => 0,
         ) );
         $line     = 0;
         $consumed = 0;
         while ( $token = array_shift( $tokens ) )
         {
             // Handle forced line breaks
             if ( $token['word'] === ezcDocumentPdfTokenizer::FORCED )
             {
                 // Continue rendering in next line
                 $consumed = 0;
                 $lines[++$line] = array(
                     'tokens' => array(),
                     'height' => 0,
                     'words'  => 0,
                     'spaces' => 0,
                 );
                 continue;
             }

             // Pure wrapping tokens are irrleveant to width calculation
             if ( $token['word'] === ezcDocumentPdfTokenizer::WRAP )
             {
                 continue;
             }

             // Apply current styles
             foreach ( $token['style'] as $style => $value )
             {
                 // Only pass whitelist of properties to the backend. This is not really
                 // the right place to do this, but it reduces the amount of calls to
                 // the backend and the size of the call log massively.
                 if ( !( ( $style === 'font-style' ) ||
                         ( $style === 'font-weight' ) ||
                         ( $style === 'color' ) ||
                         ( $style === 'font-size' ) ||
                         ( $style === 'font-family' ) ) )
                 {
                     continue;
                 }

                 $this->driver->setTextFormatting( $style, $value->value );
             }

             // Just add space to consumed wird width
             if ( $token['word'] === ezcDocumentPdfTokenizer::SPACE )
             {
                 if ( $consumed > 0 )
                 {
                     $consumed += $width = $this->driver->calculateWordWidth( ' ' );
                     $token['width']           = $width;
                     $lines[$line]['tokens'][] = $token;
                     $lines[$line]['spaces']++;
                 }
                 continue;
             }

             $wordStack = array(
                 'tokens' => array(),
                 'height' => 0,
                 'words'  => 0,
                 'spaces' => 0,
             );
             $wConsumed = 0;
             do {
                 if ( ( $consumed + $wConsumed + ( $width = $this->driver->calculateWordWidth( $token['word'] ) ) ) < $available )
                 {
                     // The word just fits into the current line
                     $token['width']        = $width;
                     $wordStack['tokens'][] = $token;
                     $wordStack['height']   = max( $lines[$line]['height'], $this->driver->getCurrentLineHeight() );
                     $wordStack['words']++;
                     $wConsumed            += $width;

                     if ( !isset( $tokens[0] ) ||
                          ( $tokens[0]['word'] === ezcDocumentPdfTokenizer::WRAP ) ||
                          ( $tokens[0]['word'] === ezcDocumentPdfTokenizer::FORCED ) ||
                          ( $tokens[0]['word'] === ezcDocumentPdfTokenizer::SPACE ) )
                     {
                         // We are allowed to wrap, so we can continue with the
                         // next iteration and merge the current word stack with
                         // the line array.
                         $lines[$line]['tokens'] = array_merge( $lines[$line]['tokens'], $wordStack['tokens'] );
                         $lines[$line]['height'] = max( $lines[$line]['height'], $wordStack['height'] );
                         $lines[$line]['words'] += $wordStack['words'];
                         $consumed              += $wConsumed;
                         continue 2;
                     }

                     continue;
                 }

                 // Try to hyphenate the current word
                 $hyphens = array_reverse( $hyphenator->splitWord( $token['word'] ) );
                 foreach ( $hyphens as $hyphen )
                 {
                     if ( ( $consumed + $wConsumed + ( $width = $this->driver->calculateWordWidth( $hyphen[0] ) ) ) < $available )
                     {
                         $second         = $token;
                         $second['word'] = $hyphen[1];
                         array_unshift( $tokens, $second );

                         $token['width']           = $width;
                         $token['word']            = $hyphen[0];
                         $lines[$line]['tokens'] = array_merge( $lines[$line]['tokens'], $wordStack['tokens'], array( $token ) );
                         $lines[$line]['height'] = max( $lines[$line]['height'], $wordStack['height'], $this->driver->getCurrentLineHeight() );
                         $lines[$line]['words'] += $wordStack['words'] + 1;

                         // Continue rendering in next line
                         $consumed = 0;
                         $lines[++$line] = array(
                             'tokens' => array(),
                             'height' => 0,
                             'words'  => 0,
                             'spaces' => 0,
                         );
                         continue 3;
                     }
                 }

                 if ( ( $consumed + $wConsumed ) <= 0 )
                 {
                     // If we are already at the beginning of the line, and the
                     // word does still not fit, we forcefully split the word.
                     $hyphen = $this->forceSplit( $token['word'], $available );

                     $second         = $token;
                     $second['word'] = $hyphen[1];
                     array_unshift( $tokens, $second );

                     $token['width']         = $this->driver->calculateWordWidth( $hyphen[0] );
                     $token['word']          = $hyphen[0];
                     $lines[$line]['tokens'] = array( $token );
                     $lines[$line]['height'] = $this->driver->getCurrentLineHeight();
                     $lines[$line]['words']  = 1;

                     // Continue rendering in next line
                     $consumed = 0;
                     $lines[++$line] = array(
                         'tokens' => array(),
                         'height' => 0,
                         'words'  => 0,
                         'spaces' => 0,
                     );
                     continue 2;
                 }

                 // Did not fit using hyphenation, so retry after wrapping
                 // the current word stack into the next line.
                 array_unshift( $tokens, $token );

                 // Still does not fit, move whole word stack into the next line
                 // and try again
                 $token['width'] = $width = $this->driver->calculateWordWidth( $token['word'] );
                 $lines[++$line] = $wordStack;
                 $consumed       = $wConsumed;
                 continue 2;
             } while ( $token = array_shift( $tokens ) );
         }

         return $lines;
     }
 }
 ?>
	<?php
	/**
	* File containing the ezcDocumentPdfTextBoxRenderer 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
	*/

	/**
	* Renders a single text box
	*
	* Tries to render a single text box into the available space, and aborts if
	* not possible.
	*
	* Implements the basic methods for tokenizing the text, style based text
	* fitting into lines, etc. Should be extended by all classes implementing more
	* specific text rendering algorithms, since those base methods are implemented
	* generally enough to be reused.
	*
	* @package Document
	* @access private
	* @version //autogen//
	*/
	class ezcDocumentPdfTextBoxRenderer extends ezcDocumentPdfBlockRenderer
	{
	/**
	* Render a single text box
	*
	* All markup inside of the given string is considered inline markup (in
	* CSS terms). Inline markup should be given as common docbook inline
	* markup, like <emphasis>.
	*
	* Returns a boolean indicator whether the rendering of the full text
	* in the available space succeeded or not.
	*
	* @param ezcDocumentPdfPage $page
	* @param ezcDocumentPdfHyphenator $hyphenator
	* @param ezcDocumentPdfTokenizer $tokenizer
	* @param ezcDocumentLocateableDomElement $text
	* @param ezcDocumentPdfMainRenderer $mainRenderer
	* @return bool
	*/
	public function renderNode( ezcDocumentPdfPage $page, ezcDocumentPdfHyphenator $hyphenator, ezcDocumentPdfTokenizer $tokenizer, ezcDocumentLocateableDomElement $text, ezcDocumentPdfMainRenderer $mainRenderer )
	{
	// Inference page styles
	$styles = $this->styles->inferenceFormattingRules( $text );
	$width = $page->innerWidth / $styles['text-columns']->value -
	( $styles['text-column-spacing']->value * ( $styles['text-columns']->value - 1 ) );

	// Evaluate available space
	if ( ( $space = $this->evaluateAvailableBoundingBox( $page, $styles, $width ) ) === false )
	{
	return false;
	}

	// Iterate over tokens and try to fit them in the current line, use
	// hyphenator to split words.
	$tokens = $this->tokenize( $text, $tokenizer );
	$lines = $this->fitTokensInLines( $tokens, $hyphenator, $space->width );

	// Evaluate required space by text box
	$required = 0;
	foreach ( $lines as $line )
	{
	$required += $line['height'] * $styles['line-height']->value;
	}

	// Check that enough space is available to render text box
	if ( $required > $space->height )
	{
	return false;
	}
	$space->height = $required;

	$this->renderBoxBackground( $space, $styles );
	$this->renderBoxBorder( $space, $styles );
	$this->renderTextBox( $lines, $space, $styles );
	$this->setBoxCovered( $page, $space, $styles );
	return true;
	}

	/**
	* Render text box
	*
	* Render a single text box, specified by the given lines array,
	* containing tokens and their styles, the available space and
	* the styles array for the currently rendered element.
	*
	* Returns false, if the box size was not sufficant for the
	* given text, and the covered vertical area otherwise.
	*
	* @param array $lines
	* @param ezcDocumentPdfBoundingBox $space
	* @param array $styles
	* @return boolean
	*/
	protected function renderTextBox( array $lines, ezcDocumentPdfBoundingBox $space, array $styles )
	{
	$yPos = $space->y;
	foreach ( $lines as $nr => $line )
	{
	$yPos += $this->renderLine( $yPos, $nr, $line, $space, $styles ) * $styles['line-height']->value;

	// Check if we run out of vertical space
	if ( $yPos > ( $space->y + $space->height ) )
	{
	return false;
	}
	}

	return $yPos - $space->y;
	}

	/**
	* Reverses a string
	*
	* Similar to PHPs strrev() function, but also works for UTF-8 strings.
	*
	* @param string $string
	* @return string
	*/
	protected function strrev( $string )
	{
	if ( !is_string( $string ) \|\| empty( $string ) )
	{
	return $string;
	}

	if ( strlen( $string ) === ( $length = iconv_strlen( $string, 'UTF-8' ) ) )
	{
	// String only contains of single-byte characters
	return strrev( $string );
	}

	$reverted = '';
	for ( $c = $length; $c > 0; --$c )
	{
	$reverted .= iconv_substr( $string, $c - 1, 1, 'UTF-8' );
	}
	return $reverted;
	}

	/**
	* Render a single line and return the used height
	*
	* @param float $position
	* @param int $number
	* @param array $line
	* @param ezcDocumentPdfBoundingBox $space
	* @param array $styles
	* @return void
	*/
	protected function renderLine( $position, $number, array $line, ezcDocumentPdfBoundingBox $space, array $styles )
	{
	$spaceWidth = $this->driver->calculateWordWidth( ' ' );
	$lineWidth = 0;
	foreach ( $line['tokens'] as $token )
	{
	if ( !is_int( $token['word'] ) )
	{
	$lineWidth += $token['width'];
	}
	}

	// Reverse alignement, if direction is set to "right-to-left"
	$align = $styles['text-align']->value;
	if ( $styles['direction']->value === 'rtl' )
	{
	switch ( $align )
	{
	case 'right':
	$align = 'left';
	default:
	$align = 'right';
	}
	}

	switch ( $align )
	{
	case 'center':
	$offset = ( $space->width - $lineWidth - ( $line['spaces'] * $spaceWidth ) ) / 2;
	break;
	case 'right':
	$offset = $space->width - $lineWidth - ( $line['spaces'] * $spaceWidth );
	break;
	case 'justify':
	$offset = 0;
	switch ( true )
	{
	case $number === $line['words']:
	// Just use common space width in last line of a
	// paragraph
	$spaceWidth = $this->driver->calculateWordWidth( ' ' );
	break;
	case $line['words'] <= 1:
	// Space width is irrelevant, if only one token is
	// in the line
	break;
	default:
	$spaceWidth = ( $space->width - $lineWidth ) / ( $line['spaces'] - 1 );
	}
	default:
	$offset = 0;
	}

	// Reverse tokens and words, if direction is set to "right-to-left"
	$tokens = $line['tokens'];
	if ( $styles['direction']->value === 'rtl' )
	{
	$tokens = array_reverse( $tokens );
	foreach ( $tokens as $nr => $token )
	{
	if ( is_string( $token['word'] ) )
	{
	$tokens[$nr]['word'] = $this->strrev( $token['word'] );
	}
	}
	}

	// Default to left alignement
	$xPos = $space->x + $offset;
	foreach ( $tokens as $token )
	{
	if ( $token['word'] === ezcDocumentPdfTokenizer::SPACE )
	{
	$this->renderTextDecoration( $token['style'], $xPos, $position, $spaceWidth, $line['height'] );
	$this->handleLinks( $token, $xPos, $position, $spaceWidth, $line['height'] );

	$xPos += $spaceWidth;
	}
	else if ( is_string( $token['word'] ) )
	{
	$this->renderTextDecoration( $token['style'], $xPos, $position, $token['width'], $line['height'] );

	// Apply current styles
	foreach ( $token['style'] as $style => $value )
	{
	$this->driver->setTextFormatting( $style, $value->value );
	}

	// Render word
	$this->driver->drawWord( $xPos, $position + $line['height'], $token['word'] );
	$this->handleLinks( $token, $xPos, $position, $token['width'], $line['height'] );
	$xPos += $token['width'];
	}
	}

	return $line['height'];
	}

	/**
	* Handle links
	*
	* Handle embedded link markup for current token and perform the
	* appropriate calls to the driver.
	*
	* @param array $token
	* @param float $x
	* @param float $y
	* @param float $width
	* @param float $height
	* @return void
	*/
	protected function handleLinks( array $token, $x, $y, $width, $height )
	{
	if ( $token['url'] !== null )
	{
	$this->driver->addExternalLink( $x, $y, $width, $height * 1.1, $token['url'] );
	}

	if ( $token['target'] !== null )
	{
	$this->driver->addInternalLink( $x, $y, $width, $height * 1.1, $token['target'] );
	}
	}

	/**
	* Render text decoration
	*
	* Render text decoration, like by a assigned text-decoration setting, or
	* background-colors, and similar.
	*
	* @param array $styles
	* @param float $x
	* @param float $y
	* @param float $width
	* @param float $height
	* @return void
	*/
	protected function renderTextDecoration( array $styles, $x, $y, $width, $height )
	{
	// Directly exit, if there are no decorations to render
	if ( ( $styles['text-decoration']->value === 'none' ) &&
	( !isset( $styles['background-color'] ) \|\|
	( $styles['background-color']->value['alpha'] >= 1 ) ) )
	{
	return;
	}

	if ( isset( $styles['background-color'] ) &&
	( $styles['background-color']->value['alpha'] < 1 ) )
	{
	$this->driver->drawPolygon(
	array(
	array( $x, $y ),
	array( $x + $width, $y ),
	array( $x + $width, $y + $height * $styles['line-height']->value ),
	array( $x, $y + $height * $styles['line-height']->value ),
	),
	$styles['background-color']->value
	);
	}

	if ( strpos( $styles['text-decoration'], 'line-through' ) !== false )
	{
	$this->driver->drawPolyline(
	array(
	array( $x, $y + $height - $styles['font-size']->value / 3 ),
	array( $x + $width, $y + $height - $styles['font-size']->value / 3 ),
	),
	$styles['color']->value,
	// @todo: How thick should line-throughs be?
	ezcDocumentPcssMeasure::create( '1px' )->get(),
	false
	);
	}

	if ( strpos( $styles['text-decoration'], 'overline' ) !== false )
	{
	$this->driver->drawPolyline(
	array(
	array( $x, $y ),
	array( $x + $width, $y ),
	),
	$styles['color']->value,
	// @todo: How thick should overlines be?
	ezcDocumentPcssMeasure::create( '1px' )->get(),
	false
	);
	}

	if ( strpos( $styles['text-decoration'], 'underline' ) !== false )
	{
	$this->driver->drawPolyline(
	array(
	array( $x, $y + $height * 1.1 ),
	array( $x + $width, $y + $height * 1.1 ),
	),
	$styles['color']->value,
	// @todo: How thick should underlines be?
	ezcDocumentPcssMeasure::create( '1px' )->get(),
	false
	);
	}
	}

	/**
	* Tokenize the input string
	*
	* For proper word wrapping in the paragraph the strng needs to be
	* tokenized, while each token has to maintain its stack of assigned
	* formats.
	*
	* This method should return an array of tokens, also maintaining the
	* included whitespace characters, each associated with its markup
	* elements.
	*
	* @param ezcDocumentLocateableDomElement $element
	* @param ezcDocumentPdfTokenizer $tokenizer
	* @param bool $recursed
	* @return array
	*/
	protected function tokenize( ezcDocumentLocateableDomElement $element, ezcDocumentPdfTokenizer $tokenizer, $recursed = false )
	{
	$tokens = array();
	$rules = $this->styles->inferenceFormattingRules( $element, ezcDocumentPcssStyleInferencer::TEXT );

	// Do not inherit background and border rules from paragraph
	if ( !$recursed )
	{
	$rules = array_diff_key( $rules, array(
	'background-color' => true,
	'border' => true,
	) );
	}

	$url = $element->tagName === 'ulink' && $element->hasAttribute( 'url' ) ? $element->getAttribute( 'url' ) : null;
	$target = $element->tagName === 'link' && $element->hasAttribute( 'linked' ) ? $element->getAttribute( 'linked' ) : null;

	foreach ( $element->childNodes as $child )
	{
	switch ( $child->nodeType )
	{
	// case XML_CDATA_SECTION_NODE:
	case XML_TEXT_NODE:
	$words = $tokenizer->tokenize( $child->textContent );
	foreach ( $words as $word )
	{
	$tokens[] = array(
	'word' => $word,
	'style' => $rules,
	'url' => $url,
	'target' => $target,
	);
	}
	break;

	case XML_ELEMENT_NODE:
	$tokens = array_merge(
	$tokens,
	$this->tokenize( $child, $tokenizer, true )
	);
	break;
	}
	}

	if ( !$recursed )
	{
	// Remove double spaces
	foreach ( $tokens as $nr => $token )
	{
	if ( ( $token['word'] === ezcDocumentPdfTokenizer::SPACE ) &&
	isset( $tokens[$nr + 1] ) &&
	( $tokens[$nr + 1]['word'] === ezcDocumentPdfTokenizer::SPACE ) )
	{
	$i = 1;
	do {
	unset( $tokens[$nr + $i] );
	} while ( isset( $tokens[$nr + ( ++$i )] ) &&
	( $tokens[$nr + $i]['word'] === ezcDocumentPdfTokenizer::SPACE ) );
	}
	}
	$tokens = array_values( $tokens );

	// Remove optional starting spaces
	if ( count( $tokens ) &&
	( $tokens[0]['word'] === ezcDocumentPdfTokenizer::SPACE ) )
	{
	$tokens = array_slice( $tokens, 1 );
	}
	}

	return $tokens;
	}

	/**
	* Force split a word.
	*
	* Force the splitting of a word, which did not fit in a line alone and
	* could not be splitted using the hyphenator. We just search for the
	* maximum word part length which fits the available space.
	*
	* Could be improved to use a binary search on the word length, but this
	* shouldn't happen too often anyways.
	*
	* @param string $word
	* @param float $available
	* @return array
	*/
	protected function forceSplit( $word, $available )
	{
	$length = iconv_strlen( $word ) - 1;
	while ( $this->driver->calculateWordWidth( iconv_substr( $word, 0, $length ) ) > $available )
	{
	--$length;
	}

	return array(
	iconv_substr( $word, 0, $length ),
	iconv_substr( $word, $length )
	);
	}

	/**
	* Try to match tokens into lines
	*
	* Try to match tokens into lines of the given width. Returns an array with
	* words for each line. The words might already be split up by the
	* hyphenator.
	*
	* @param array $tokens
	* @param ezcDocumentPdfHyphenator $hyphenator
	* @param float $available
	* @return array
	*/
	protected function fitTokensInLines( array $tokens, ezcDocumentPdfHyphenator $hyphenator, $available )
	{
	$lines = array( array(
	'tokens' => array(),
	'height' => 0,
	'words' => 0,
	'spaces' => 0,
	) );
	$line = 0;
	$consumed = 0;
	while ( $token = array_shift( $tokens ) )
	{
	// Handle forced line breaks
	if ( $token['word'] === ezcDocumentPdfTokenizer::FORCED )
	{
	// Continue rendering in next line
	$consumed = 0;
	$lines[++$line] = array(
	'tokens' => array(),
	'height' => 0,
	'words' => 0,
	'spaces' => 0,
	);
	continue;
	}

	// Pure wrapping tokens are irrleveant to width calculation
	if ( $token['word'] === ezcDocumentPdfTokenizer::WRAP )
	{
	continue;
	}

	// Apply current styles
	foreach ( $token['style'] as $style => $value )
	{
	// Only pass whitelist of properties to the backend. This is not really
	// the right place to do this, but it reduces the amount of calls to
	// the backend and the size of the call log massively.
	if ( !( ( $style === 'font-style' ) \|\|
	( $style === 'font-weight' ) \|\|
	( $style === 'color' ) \|\|
	( $style === 'font-size' ) \|\|
	( $style === 'font-family' ) ) )
	{
	continue;
	}

	$this->driver->setTextFormatting( $style, $value->value );
	}

	// Just add space to consumed wird width
	if ( $token['word'] === ezcDocumentPdfTokenizer::SPACE )
	{
	if ( $consumed > 0 )
	{
	$consumed += $width = $this->driver->calculateWordWidth( ' ' );
	$token['width'] = $width;
	$lines[$line]['tokens'][] = $token;
	$lines[$line]['spaces']++;
	}
	continue;
	}

	$wordStack = array(
	'tokens' => array(),
	'height' => 0,
	'words' => 0,
	'spaces' => 0,
	);
	$wConsumed = 0;
	do {
	if ( ( $consumed + $wConsumed + ( $width = $this->driver->calculateWordWidth( $token['word'] ) ) ) < $available )
	{
	// The word just fits into the current line
	$token['width'] = $width;
	$wordStack['tokens'][] = $token;
	$wordStack['height'] = max( $lines[$line]['height'], $this->driver->getCurrentLineHeight() );
	$wordStack['words']++;
	$wConsumed += $width;

	if ( !isset( $tokens[0] ) \|\|
	( $tokens[0]['word'] === ezcDocumentPdfTokenizer::WRAP ) \|\|
	( $tokens[0]['word'] === ezcDocumentPdfTokenizer::FORCED ) \|\|
	( $tokens[0]['word'] === ezcDocumentPdfTokenizer::SPACE ) )
	{
	// We are allowed to wrap, so we can continue with the
	// next iteration and merge the current word stack with
	// the line array.
	$lines[$line]['tokens'] = array_merge( $lines[$line]['tokens'], $wordStack['tokens'] );
	$lines[$line]['height'] = max( $lines[$line]['height'], $wordStack['height'] );
	$lines[$line]['words'] += $wordStack['words'];
	$consumed += $wConsumed;
	continue 2;
	}

	continue;
	}

	// Try to hyphenate the current word
	$hyphens = array_reverse( $hyphenator->splitWord( $token['word'] ) );
	foreach ( $hyphens as $hyphen )
	{
	if ( ( $consumed + $wConsumed + ( $width = $this->driver->calculateWordWidth( $hyphen[0] ) ) ) < $available )
	{
	$second = $token;
	$second['word'] = $hyphen[1];
	array_unshift( $tokens, $second );

	$token['width'] = $width;
	$token['word'] = $hyphen[0];
	$lines[$line]['tokens'] = array_merge( $lines[$line]['tokens'], $wordStack['tokens'], array( $token ) );
	$lines[$line]['height'] = max( $lines[$line]['height'], $wordStack['height'], $this->driver->getCurrentLineHeight() );
	$lines[$line]['words'] += $wordStack['words'] + 1;

	// Continue rendering in next line
	$consumed = 0;
	$lines[++$line] = array(
	'tokens' => array(),
	'height' => 0,
	'words' => 0,
	'spaces' => 0,
	);
	continue 3;
	}
	}

	if ( ( $consumed + $wConsumed ) <= 0 )
	{
	// If we are already at the beginning of the line, and the
	// word does still not fit, we forcefully split the word.
	$hyphen = $this->forceSplit( $token['word'], $available );

	$second = $token;
	$second['word'] = $hyphen[1];
	array_unshift( $tokens, $second );

	$token['width'] = $this->driver->calculateWordWidth( $hyphen[0] );
	$token['word'] = $hyphen[0];
	$lines[$line]['tokens'] = array( $token );
	$lines[$line]['height'] = $this->driver->getCurrentLineHeight();
	$lines[$line]['words'] = 1;

	// Continue rendering in next line
	$consumed = 0;
	$lines[++$line] = array(
	'tokens' => array(),
	'height' => 0,
	'words' => 0,
	'spaces' => 0,
	);
	continue 2;
	}

	// Did not fit using hyphenation, so retry after wrapping
	// the current word stack into the next line.
	array_unshift( $tokens, $token );

	// Still does not fit, move whole word stack into the next line
	// and try again
	$token['width'] = $width = $this->driver->calculateWordWidth( $token['word'] );
	$lines[++$line] = $wordStack;
	$consumed = $wConsumed;
	continue 2;
	} while ( $token = array_shift( $tokens ) );
	}

	return $lines;
	}
	}
	?>