vendor/dompdf/dompdf/src/Adapter/GD.php

   1 <?php
   2 /**
   3  * @package dompdf
   4  * @link    http://dompdf.github.com/
   5  * @author  Benj Carson <benjcarson@digitaljunkies.ca>
   6  * @author  Fabien Ménager <fabien.menager@gmail.com>
   7  * @license http://www.gnu.org/copyleft/lesser.html GNU Lesser General Public License
   8  */
   9 namespace Dompdf\Adapter;
  10
  11 use Dompdf\Canvas;
  12 use Dompdf\Dompdf;
  13 use Dompdf\Image\Cache;
  14 use Dompdf\Helpers;
  15
  16 /**
  17  * Image rendering interface
  18  *
  19  * Renders to an image format supported by GD (jpeg, gif, png, xpm).
  20  * Not super-useful day-to-day but handy nonetheless
  21  *
  22  * @package dompdf
  23  */
  24 class GD implements Canvas
  25 {
  26     /**
  27      * @var Dompdf
  28      */
  29     private $_dompdf;
  30
  31     /**
  32      * Resource handle for the image
  33      *
  34      * @var resource
  35      */
  36     private $_img;
  37
  38     /**
  39      * Resource handle for the image
  40      *
  41      * @var resource[]
  42      */
  43     private $_imgs;
  44
  45     /**
  46      * Apparent canvas width in pixels
  47      *
  48      * @var int
  49      */
  50     private $_width;
  51
  52     /**
  53      * Apparent canvas height in pixels
  54      *
  55      * @var int
  56      */
  57     private $_height;
  58
  59     /**
  60      * Actual image width in pixels
  61      *
  62      * @var int
  63      */
  64     private $_actual_width;
  65
  66     /**
  67      * Actual image height in pixels
  68      *
  69      * @var int
  70      */
  71     private $_actual_height;
  72
  73     /**
  74      * Current page number
  75      *
  76      * @var int
  77      */
  78     private $_page_number;
  79
  80     /**
  81      * Total number of pages
  82      *
  83      * @var int
  84      */
  85     private $_page_count;
  86
  87     /**
  88      * Image antialias factor
  89      *
  90      * @var float
  91      */
  92     private $_aa_factor;
  93
  94     /**
  95      * Allocated colors
  96      *
  97      * @var array
  98      */
  99     private $_colors;
 100
 101     /**
 102      * Background color
 103      *
 104      * @var int
 105      */
 106     private $_bg_color;
 107
 108     /**
 109      * Background color array
 110      *
 111      * @var int
 112      */
 113     private $_bg_color_array;
 114
 115     /**
 116      * Actual DPI
 117      *
 118      * @var int
 119      */
 120     private $dpi;
 121
 122     /**
 123      * Amount to scale font sizes
 124      *
 125      * Font sizes are 72 DPI, GD internally uses 96. Scale them proportionally.
 126      * 72 / 96 = 0.75.
 127      *
 128      * @var float
 129      */
 130     const FONT_SCALE = 0.75;
 131
 132     /**
 133      * Class constructor
 134      *
 135      * @param mixed $size The size of image to create: array(x1,y1,x2,y2) or "letter", "legal", etc.
 136      * @param string $orientation The orientation of the document (either 'landscape' or 'portrait')
 137      * @param Dompdf $dompdf
 138      * @param float $aa_factor Anti-aliasing factor, 1 for no AA
 139      * @param array $bg_color Image background color: array(r,g,b,a), 0 <= r,g,b,a <= 1
 140      */
 141     public function __construct($size = 'letter', $orientation = "portrait", Dompdf $dompdf, $aa_factor = 1.0, $bg_color = array(1, 1, 1, 0))
 142     {
 143
 144         if (!is_array($size)) {
 145             $size = strtolower($size);
 146
 147             if (isset(CPDF::$PAPER_SIZES[$size])) {
 148                 $size = CPDF::$PAPER_SIZES[$size];
 149             } else {
 150                 $size = CPDF::$PAPER_SIZES["letter"];
 151             }
 152         }
 153
 154         if (strtolower($orientation) === "landscape") {
 155             list($size[2], $size[3]) = array($size[3], $size[2]);
 156         }
 157
 158         $this->_dompdf = $dompdf;
 159
 160         $this->dpi = $this->get_dompdf()->getOptions()->getDpi();
 161
 162         if ($aa_factor < 1) {
 163             $aa_factor = 1;
 164         }
 165
 166         $this->_aa_factor = $aa_factor;
 167
 168         $size[2] *= $aa_factor;
 169         $size[3] *= $aa_factor;
 170
 171         $this->_width = $size[2] - $size[0];
 172         $this->_height = $size[3] - $size[1];
 173
 174         $this->_actual_width = $this->_upscale($this->_width);
 175         $this->_actual_height = $this->_upscale($this->_height);
 176
 177         if (is_null($bg_color) || !is_array($bg_color)) {
 178             // Pure white bg
 179             $bg_color = array(1, 1, 1, 0);
 180         }
 181
 182         $this->_bg_color_array = $bg_color;
 183
 184         $this->new_page();
 185     }
 186
 187     /**
 188      * @return Dompdf
 189      */
 190     public function get_dompdf()
 191     {
 192         return $this->_dompdf;
 193     }
 194
 195     /**
 196      * Return the GF image resource
 197      *
 198      * @return resource
 199      */
 200     public function get_image()
 201     {
 202         return $this->_img;
 203     }
 204
 205     /**
 206      * Return the image's width in pixels
 207      *
 208      * @return float
 209      */
 210     public function get_width()
 211     {
 212         return $this->_width / $this->_aa_factor;
 213     }
 214
 215     /**
 216      * Return the image's height in pixels
 217      *
 218      * @return float
 219      */
 220     public function get_height()
 221     {
 222         return $this->_height / $this->_aa_factor;
 223     }
 224
 225     /**
 226      * Returns the current page number
 227      * @return int
 228      */
 229     public function get_page_number()
 230     {
 231         return $this->_page_number;
 232     }
 233
 234     /**
 235      * Returns the total number of pages in the document
 236      * @return int
 237      */
 238     public function get_page_count()
 239     {
 240         return $this->_page_count;
 241     }
 242
 243     /**
 244      * Sets the current page number
 245      *
 246      * @param int $num
 247      */
 248     public function set_page_number($num)
 249     {
 250         $this->_page_number = $num;
 251     }
 252
 253     /**
 254      * Sets the page count
 255      *
 256      * @param int $count
 257      */
 258     public function set_page_count($count)
 259     {
 260         $this->_page_count = $count;
 261     }
 262
 263     /**
 264      * Sets the opacity
 265      *
 266      * @param $opacity
 267      * @param $mode
 268      */
 269     public function set_opacity($opacity, $mode = "Normal")
 270     {
 271         // FIXME
 272     }
 273
 274     /**
 275      * Allocate a new color.  Allocate with GD as needed and store
 276      * previously allocated colors in $this->_colors.
 277      *
 278      * @param array $color The new current color
 279      * @return int           The allocated color
 280      */
 281     private function _allocate_color($color)
 282     {
 283         $a = isset($color["alpha"]) ? $color["alpha"] : 1;
 284
 285         if (isset($color["c"])) {
 286             $color = Helpers::cmyk_to_rgb($color);
 287         }
 288
 289         list($r, $g, $b) = $color;
 290
 291         $r *= 255;
 292         $g *= 255;
 293         $b *= 255;
 294         $a = 127 - ($a * 127);
 295
 296         // Clip values
 297         $r = $r > 255 ? 255 : $r;
 298         $g = $g > 255 ? 255 : $g;
 299         $b = $b > 255 ? 255 : $b;
 300         $a = $a > 127 ? 127 : $a;
 301
 302         $r = $r < 0 ? 0 : $r;
 303         $g = $g < 0 ? 0 : $g;
 304         $b = $b < 0 ? 0 : $b;
 305         $a = $a < 0 ? 0 : $a;
 306
 307         $key = sprintf("#%02X%02X%02X%02X", $r, $g, $b, $a);
 308
 309         if (isset($this->_colors[$key])) {
 310             return $this->_colors[$key];
 311         }
 312
 313         if ($a != 0) {
 314             $this->_colors[$key] = imagecolorallocatealpha($this->get_image(), $r, $g, $b, $a);
 315         } else {
 316             $this->_colors[$key] = imagecolorallocate($this->get_image(), $r, $g, $b);
 317         }
 318
 319         return $this->_colors[$key];
 320     }
 321
 322     /**
 323      * Scales value up to the current canvas DPI from 72 DPI
 324      *
 325      * @param float $length
 326      * @return float
 327      */
 328     private function _upscale($length)
 329     {
 330         return ($length * $this->dpi) / 72 * $this->_aa_factor;
 331     }
 332
 333     /**
 334      * Scales value down from the current canvas DPI to 72 DPI
 335      *
 336      * @param float $length
 337      * @return float
 338      */
 339     private function _downscale($length)
 340     {
 341         return ($length / $this->dpi * 72) / $this->_aa_factor;
 342     }
 343
 344     /**
 345      * Draws a line from x1,y1 to x2,y2
 346      *
 347      * See {@link Style::munge_color()} for the format of the color array.
 348      * See {@link Cpdf::setLineStyle()} for a description of the format of the
 349      * $style parameter (aka dash).
 350      *
 351      * @param float $x1
 352      * @param float $y1
 353      * @param float $x2
 354      * @param float $y2
 355      * @param array $color
 356      * @param float $width
 357      * @param array $style
 358      */
 359     public function line($x1, $y1, $x2, $y2, $color, $width, $style = null)
 360     {
 361
 362         // Scale by the AA factor and DPI
 363         $x1 = $this->_upscale($x1);
 364         $y1 = $this->_upscale($y1);
 365         $x2 = $this->_upscale($x2);
 366         $y2 = $this->_upscale($y2);
 367         $width = $this->_upscale($width);
 368
 369         $c = $this->_allocate_color($color);
 370
 371         // Convert the style array if required
 372         if (is_array($style) && count($style) > 0) {
 373             $gd_style = array();
 374
 375             if (count($style) == 1) {
 376                 for ($i = 0; $i < $style[0] * $this->_aa_factor; $i++) {
 377                     $gd_style[] = $c;
 378                 }
 379
 380                 for ($i = 0; $i < $style[0] * $this->_aa_factor; $i++) {
 381                     $gd_style[] = $this->_bg_color;
 382                 }
 383             } else {
 384                 $i = 0;
 385                 foreach ($style as $length) {
 386                     if ($i % 2 == 0) {
 387                         // 'On' pattern
 388                         for ($i = 0; $i < $style[0] * $this->_aa_factor; $i++) {
 389                             $gd_style[] = $c;
 390                         }
 391
 392                     } else {
 393                         // Off pattern
 394                         for ($i = 0; $i < $style[0] * $this->_aa_factor; $i++) {
 395                             $gd_style[] = $this->_bg_color;
 396                         }
 397                     }
 398                     $i++;
 399                 }
 400             }
 401
 402             if (!empty($gd_style)) {
 403                 imagesetstyle($this->get_image(), $gd_style);
 404                 $c = IMG_COLOR_STYLED;
 405             }
 406         }
 407
 408         imagesetthickness($this->get_image(), $width);
 409
 410         imageline($this->get_image(), $x1, $y1, $x2, $y2, $c);
 411     }
 412
 413     /**
 414      * @param float $x1
 415      * @param float $y1
 416      * @param float $r1
 417      * @param float $r2
 418      * @param float $astart
 419      * @param float $aend
 420      * @param array $color
 421      * @param float $width
 422      * @param array $style
 423      */
 424     public function arc($x1, $y1, $r1, $r2, $astart, $aend, $color, $width, $style = array())
 425     {
 426         // @todo
 427     }
 428
 429     /**
 430      * Draws a rectangle at x1,y1 with width w and height h
 431      *
 432      * See {@link Style::munge_color()} for the format of the color array.
 433      * See {@link Cpdf::setLineStyle()} for a description of the $style
 434      * parameter (aka dash)
 435      *
 436      * @param float $x1
 437      * @param float $y1
 438      * @param float $w
 439      * @param float $h
 440      * @param array $color
 441      * @param float $width
 442      * @param array $style
 443      */
 444     public function rectangle($x1, $y1, $w, $h, $color, $width, $style = null)
 445     {
 446
 447         // Scale by the AA factor and DPI
 448         $x1 = $this->_upscale($x1);
 449         $y1 = $this->_upscale($y1);
 450         $w = $this->_upscale($w);
 451         $h = $this->_upscale($h);
 452         $width = $this->_upscale($width);
 453
 454         $c = $this->_allocate_color($color);
 455
 456         // Convert the style array if required
 457         if (is_array($style) && count($style) > 0) {
 458             $gd_style = array();
 459
 460             foreach ($style as $length) {
 461                 for ($i = 0; $i < $length; $i++) {
 462                     $gd_style[] = $c;
 463                 }
 464             }
 465
 466             if (!empty($gd_style)) {
 467                 imagesetstyle($this->get_image(), $gd_style);
 468                 $c = IMG_COLOR_STYLED;
 469             }
 470         }
 471
 472         imagesetthickness($this->get_image(), $width);
 473
 474         imagerectangle($this->get_image(), $x1, $y1, $x1 + $w, $y1 + $h, $c);
 475     }
 476
 477     /**
 478      * Draws a filled rectangle at x1,y1 with width w and height h
 479      *
 480      * See {@link Style::munge_color()} for the format of the color array.
 481      *
 482      * @param float $x1
 483      * @param float $y1
 484      * @param float $w
 485      * @param float $h
 486      * @param array $color
 487      */
 488     public function filled_rectangle($x1, $y1, $w, $h, $color)
 489     {
 490         // Scale by the AA factor and DPI
 491         $x1 = $this->_upscale($x1);
 492         $y1 = $this->_upscale($y1);
 493         $w = $this->_upscale($w);
 494         $h = $this->_upscale($h);
 495
 496         $c = $this->_allocate_color($color);
 497
 498         imagefilledrectangle($this->get_image(), $x1, $y1, $x1 + $w, $y1 + $h, $c);
 499     }
 500
 501     /**
 502      * Starts a clipping rectangle at x1,y1 with width w and height h
 503      *
 504      * @param float $x1
 505      * @param float $y1
 506      * @param float $w
 507      * @param float $h
 508      */
 509     public function clipping_rectangle($x1, $y1, $w, $h)
 510     {
 511         // @todo
 512     }
 513
 514     public function clipping_roundrectangle($x1, $y1, $w, $h, $rTL, $rTR, $rBR, $rBL)
 515     {
 516         // @todo
 517     }
 518
 519     /**
 520      * Ends the last clipping shape
 521      */
 522     public function clipping_end()
 523     {
 524         // @todo
 525     }
 526
 527     /**
 528      *
 529      */
 530     public function save()
 531     {
 532         $this->get_dompdf()->getOptions()->setDpi(72);
 533     }
 534
 535     /**
 536      *
 537      */
 538     public function restore()
 539     {
 540         $this->get_dompdf()->getOptions()->setDpi($this->dpi);
 541     }
 542
 543     /**
 544      * @param $angle
 545      * @param $x
 546      * @param $y
 547      */
 548     public function rotate($angle, $x, $y)
 549     {
 550         // @todo
 551     }
 552
 553     /**
 554      * @param $angle_x
 555      * @param $angle_y
 556      * @param $x
 557      * @param $y
 558      */
 559     public function skew($angle_x, $angle_y, $x, $y)
 560     {
 561         // @todo
 562     }
 563
 564     /**
 565      * @param $s_x
 566      * @param $s_y
 567      * @param $x
 568      * @param $y
 569      */
 570     public function scale($s_x, $s_y, $x, $y)
 571     {
 572         // @todo
 573     }
 574
 575     /**
 576      * @param $t_x
 577      * @param $t_y
 578      */
 579     public function translate($t_x, $t_y)
 580     {
 581         // @todo
 582     }
 583
 584     /**
 585      * @param $a
 586      * @param $b
 587      * @param $c
 588      * @param $d
 589      * @param $e
 590      * @param $f
 591      */
 592     public function transform($a, $b, $c, $d, $e, $f)
 593     {
 594         // @todo
 595     }
 596
 597     /**
 598      * Draws a polygon
 599      *
 600      * The polygon is formed by joining all the points stored in the $points
 601      * array.  $points has the following structure:
 602      * <code>
 603      * array(0 => x1,
 604      *       1 => y1,
 605      *       2 => x2,
 606      *       3 => y2,
 607      *       ...
 608      *       );
 609      * </code>
 610      *
 611      * See {@link Style::munge_color()} for the format of the color array.
 612      * See {@link Cpdf::setLineStyle()} for a description of the $style
 613      * parameter (aka dash)
 614      *
 615      * @param array $points
 616      * @param array $color
 617      * @param float $width
 618      * @param array $style
 619      * @param bool $fill Fills the polygon if true
 620      */
 621     public function polygon($points, $color, $width = null, $style = null, $fill = false)
 622     {
 623
 624         // Scale each point by the AA factor and DPI
 625         foreach (array_keys($points) as $i) {
 626             $points[$i] = $this->_upscale($points[$i]);
 627         }
 628
 629         $c = $this->_allocate_color($color);
 630
 631         // Convert the style array if required
 632         if (is_array($style) && count($style) > 0 && !$fill) {
 633             $gd_style = array();
 634
 635             foreach ($style as $length) {
 636                 for ($i = 0; $i < $length; $i++) {
 637                     $gd_style[] = $c;
 638                 }
 639             }
 640
 641             if (!empty($gd_style)) {
 642                 imagesetstyle($this->get_image(), $gd_style);
 643                 $c = IMG_COLOR_STYLED;
 644             }
 645         }
 646
 647         imagesetthickness($this->get_image(), $width);
 648
 649         if ($fill) {
 650             imagefilledpolygon($this->get_image(), $points, count($points) / 2, $c);
 651         } else {
 652             imagepolygon($this->get_image(), $points, count($points) / 2, $c);
 653         }
 654     }
 655
 656     /**
 657      * Draws a circle at $x,$y with radius $r
 658      *
 659      * See {@link Style::munge_color()} for the format of the color array.
 660      * See {@link Cpdf::setLineStyle()} for a description of the $style
 661      * parameter (aka dash)
 662      *
 663      * @param float $x
 664      * @param float $y
 665      * @param float $r
 666      * @param array $color
 667      * @param float $width
 668      * @param array $style
 669      * @param bool $fill Fills the circle if true
 670      */
 671     public function circle($x, $y, $r, $color, $width = null, $style = null, $fill = false)
 672     {
 673         // Scale by the AA factor and DPI
 674         $x = $this->_upscale($x);
 675         $y = $this->_upscale($y);
 676         $r = $this->_upscale($r);
 677
 678         $c = $this->_allocate_color($color);
 679
 680         // Convert the style array if required
 681         if (is_array($style) && count($style) > 0 && !$fill) {
 682             $gd_style = array();
 683
 684             foreach ($style as $length) {
 685                 for ($i = 0; $i < $length; $i++) {
 686                     $gd_style[] = $c;
 687                 }
 688             }
 689
 690             if (!empty($gd_style)) {
 691                 imagesetstyle($this->get_image(), $gd_style);
 692                 $c = IMG_COLOR_STYLED;
 693             }
 694         }
 695
 696         imagesetthickness($this->get_image(), $width);
 697
 698         if ($fill) {
 699             imagefilledellipse($this->get_image(), $x, $y, $r, $r, $c);
 700         } else {
 701             imageellipse($this->get_image(), $x, $y, $r, $r, $c);
 702         }
 703     }
 704
 705     /**
 706      * Add an image to the pdf.
 707      * The image is placed at the specified x and y coordinates with the
 708      * given width and height.
 709      *
 710      * @param string $img_url the path to the image
 711      * @param float $x x position
 712      * @param float $y y position
 713      * @param int $w width (in pixels)
 714      * @param int $h height (in pixels)
 715      * @param string $resolution
 716      * @return void
 717      *
 718      * @throws \Exception
 719      * @internal param string $img_type the type (e.g. extension) of the image
 720      */
 721     public function image($img_url, $x, $y, $w, $h, $resolution = "normal")
 722     {
 723         $img_type = Cache::detect_type($img_url, $this->get_dompdf()->getHttpContext());
 724
 725         if (!$img_type) {
 726             return;
 727         }
 728
 729         $func_name = "imagecreatefrom$img_type";
 730         if (!function_exists($func_name)) {
 731             if (!method_exists("Dompdf\Helpers", $func_name)) {
 732                 throw new \Exception("Function $func_name() not found.  Cannot convert $type image: $img_url.  Please install the image PHP extension.");
 733             }
 734             $func_name = "\\Dompdf\\Helpers::" . $func_name;
 735         }
 736         $src = @call_user_func($func_name, $img_url);
 737
 738         if (!$src) {
 739             return; // Probably should add to $_dompdf_errors or whatever here
 740         }
 741
 742         // Scale by the AA factor and DPI
 743         $x = $this->_upscale($x);
 744         $y = $this->_upscale($y);
 745
 746         $w = $this->_upscale($w);
 747         $h = $this->_upscale($h);
 748
 749         $img_w = imagesx($src);
 750         $img_h = imagesy($src);
 751
 752         imagecopyresampled($this->get_image(), $src, $x, $y, 0, 0, $w, $h, $img_w, $img_h);
 753     }
 754
 755     /**
 756      * Writes text at the specified x and y coordinates
 757      * See {@link Style::munge_color()} for the format of the color array.
 758      *
 759      * @param float $x
 760      * @param float $y
 761      * @param string $text the text to write
 762      * @param string $font the font file to use
 763      * @param float $size the font size, in points
 764      * @param array $color
 765      * @param float $word_spacing word spacing adjustment
 766      * @param float $char_spacing
 767      * @param float $angle Text angle
 768      *
 769      * @return void
 770      */
 771     public function text($x, $y, $text, $font, $size, $color = array(0, 0, 0), $word_spacing = 0.0, $char_spacing = 0.0, $angle = 0.0)
 772     {
 773         // Scale by the AA factor and DPI
 774         $x = $this->_upscale($x);
 775         $y = $this->_upscale($y);
 776         $size = $this->_upscale($size) * self::FONT_SCALE;
 777
 778         $h = $this->get_font_height_actual($font, $size);
 779         $c = $this->_allocate_color($color);
 780
 781         // imagettftext() converts numeric entities to their respective
 782         // character. Preserve any originally double encoded entities to be
 783         // represented as is.
 784         // eg: &amp;#160; will render &#160; rather than its character.
 785         $text = preg_replace('/&(#(?:x[a-fA-F0-9]+|[0-9]+);)/', '&#38;\1', $text);
 786
 787         $text = mb_encode_numericentity($text, array(0x0080, 0xff, 0, 0xff), 'UTF-8');
 788
 789         $font = $this->get_ttf_file($font);
 790
 791         // FIXME: word spacing
 792         imagettftext($this->get_image(), $size, $angle, $x, $y + $h, $c, $font, $text);
 793     }
 794
 795     public function javascript($code)
 796     {
 797         // Not implemented
 798     }
 799
 800     /**
 801      * Add a named destination (similar to <a name="foo">...</a> in html)
 802      *
 803      * @param string $anchorname The name of the named destination
 804      */
 805     public function add_named_dest($anchorname)
 806     {
 807         // Not implemented
 808     }
 809
 810     /**
 811      * Add a link to the pdf
 812      *
 813      * @param string $url The url to link to
 814      * @param float $x The x position of the link
 815      * @param float $y The y position of the link
 816      * @param float $width The width of the link
 817      * @param float $height The height of the link
 818      */
 819     public function add_link($url, $x, $y, $width, $height)
 820     {
 821         // Not implemented
 822     }
 823
 824     /**
 825      * Add meta information to the PDF
 826      *
 827      * @param string $label label of the value (Creator, Producer, etc.)
 828      * @param string $value the text to set
 829      */
 830     public function add_info($label, $value)
 831     {
 832         // N/A
 833     }
 834
 835     /**
 836      * @param string $view
 837      * @param array $options
 838      */
 839     public function set_default_view($view, $options = array())
 840     {
 841         // N/A
 842     }
 843
 844     /**
 845      * Calculates text size, in points
 846      *
 847      * @param string $text the text to be sized
 848      * @param string $font the desired font
 849      * @param float $size the desired font size
 850      * @param float $word_spacing word spacing, if any
 851      * @param float $char_spacing char spacing, if any
 852      *
 853      * @return float
 854      */
 855     public function get_text_width($text, $font, $size, $word_spacing = 0.0, $char_spacing = 0.0)
 856     {
 857         $font = $this->get_ttf_file($font);
 858         $size = $this->_upscale($size) * self::FONT_SCALE;
 859
 860         // imagettfbbox() converts numeric entities to their respective
 861         // character. Preserve any originally double encoded entities to be
 862         // represented as is.
 863         // eg: &amp;#160; will render &#160; rather than its character.
 864         $text = preg_replace('/&(#(?:x[a-fA-F0-9]+|[0-9]+);)/', '&#38;\1', $text);
 865
 866         $text = mb_encode_numericentity($text, array(0x0080, 0xffff, 0, 0xffff), 'UTF-8');
 867
 868         // FIXME: word spacing
 869         list($x1, , $x2) = imagettfbbox($size, 0, $font, $text);
 870
 871         // Add additional 1pt to prevent text overflow issues
 872         return $this->_downscale($x2 - $x1) + 1;
 873     }
 874
 875     /**
 876      * @param $font
 877      * @return string
 878      */
 879     public function get_ttf_file($font)
 880     {
 881         if ( stripos($font, ".ttf") === false ) {
 882             $font .= ".ttf";
 883         }
 884
 885         if (!file_exists($font)) {
 886             $font_metrics = $this->_dompdf->getFontMetrics();
 887             $font = $font_metrics->getFont($this->_dompdf->getOptions()->getDefaultFont()) . ".ttf";
 888             if (!file_exists($font)) {
 889                 if (strpos($font, "mono")) {
 890                     $font = $font_metrics->getFont("DejaVu Mono") . ".ttf";
 891                 } elseif (strpos($font, "sans") !== false) {
 892                     $font = $font_metrics->getFont("DejaVu Sans") . ".ttf";
 893                 } elseif (strpos($font, "serif")) {
 894                     $font = $font_metrics->getFont("DejaVu Serif") . ".ttf";
 895                 } else {
 896                     $font = $font_metrics->getFont("DejaVu Sans") . ".ttf";
 897                 }
 898             }
 899         }
 900
 901         return $font;
 902     }
 903
 904     /**
 905      * Calculates font height, in points
 906      *
 907      * @param string $font
 908      * @param float $size
 909      * @return float
 910      */
 911     public function get_font_height($font, $size)
 912     {
 913         $size = $this->_upscale($size) * self::FONT_SCALE;
 914
 915         $height = $this->get_font_height_actual($font, $size);
 916
 917         return $this->_downscale($height);
 918     }
 919
 920     private function get_font_height_actual($font, $size)
 921     {
 922         $font = $this->get_ttf_file($font);
 923         $ratio = $this->_dompdf->getOptions()->getFontHeightRatio();
 924
 925         // FIXME: word spacing
 926         list(, $y2, , , , $y1) = imagettfbbox($size, 0, $font, "MXjpqytfhl"); // Test string with ascenders, descenders and caps
 927         return ($y2 - $y1) * $ratio;
 928     }
 929
 930     /**
 931      * @param string $font
 932      * @param float $size
 933      * @return float
 934      */
 935     public function get_font_baseline($font, $size)
 936     {
 937         $ratio = $this->_dompdf->getOptions()->getFontHeightRatio();
 938         return $this->get_font_height($font, $size) / $ratio;
 939     }
 940
 941     /**
 942      * Starts a new page
 943      *
 944      * Subsequent drawing operations will appear on the new page.
 945      */
 946     public function new_page()
 947     {
 948         $this->_page_number++;
 949         $this->_page_count++;
 950
 951         $this->_img = imagecreatetruecolor($this->_actual_width, $this->_actual_height);
 952
 953         $this->_bg_color = $this->_allocate_color($this->_bg_color_array);
 954         imagealphablending($this->_img, true);
 955         imagesavealpha($this->_img, true);
 956         imagefill($this->_img, 0, 0, $this->_bg_color);
 957
 958         $this->_imgs[] = $this->_img;
 959     }
 960
 961     public function open_object()
 962     {
 963         // N/A
 964     }
 965
 966     public function close_object()
 967     {
 968         // N/A
 969     }
 970
 971     public function add_object()
 972     {
 973         // N/A
 974     }
 975
 976     public function page_text()
 977     {
 978         // N/A
 979     }
 980
 981     /**
 982      * Streams the image to the client.
 983      *
 984      * @param string $filename The filename to present to the client.
 985      * @param array $options Associative array: 'type' => jpeg|jpg|png; 'quality' => 0 - 100 (JPEG only);
 986      *     'page' => Number of the page to output (defaults to the first); 'Attachment': 1 or 0 (default 1).
 987      */
 988     public function stream($filename, $options = array())
 989     {
 990         if (headers_sent()) {
 991             die("Unable to stream image: headers already sent");
 992         }
 993
 994         if (!isset($options["type"])) $options["type"] = "png";
 995         if (!isset($options["Attachment"])) $options["Attachment"] = true;
 996         $type = strtolower($options["type"]);
 997
 998         switch ($type) {
 999             case "jpg":
1000             case "jpeg":
1001                 $contentType = "image/jpeg";
1002                 $extension = ".jpg";
1003                 break;
1004             case "png":
1005             default:
1006                 $contentType = "image/png";
1007                 $extension = ".png";
1008                 break;
1009         }
1010
1011         header("Cache-Control: private");
1012         header("Content-Type: $contentType");
1013
1014         $filename = str_replace(array("\n", "'"), "", basename($filename, ".$type")) . $extension;
1015         $attachment = $options["Attachment"] ? "attachment" : "inline";
1016         header(Helpers::buildContentDispositionHeader($attachment, $filename));
1017
1018         $this->_output($options);
1019         flush();
1020     }
1021
1022     /**
1023      * Returns the image as a string.
1024      *
1025      * @param array $options Associative array: 'type' => jpeg|jpg|png; 'quality' => 0 - 100 (JPEG only);
1026      *     'page' => Number of the page to output (defaults to the first).
1027      * @return string
1028      */
1029     public function output($options = array())
1030     {
1031         ob_start();
1032
1033         $this->_output($options);
1034
1035         return ob_get_clean();
1036     }
1037
1038     /**
1039      * Outputs the image stream directly.
1040      *
1041      * @param array $options Associative array: 'type' => jpeg|jpg|png; 'quality' => 0 - 100 (JPEG only);
1042      *     'page' => Number of the page to output (defaults to the first).
1043      */
1044     private function _output($options = array())
1045     {
1046         if (!isset($options["type"])) $options["type"] = "png";
1047         if (!isset($options["page"])) $options["page"] = 1;
1048         $type = strtolower($options["type"]);
1049
1050         if (isset($this->_imgs[$options["page"] - 1])) {
1051             $img = $this->_imgs[$options["page"] - 1];
1052         } else {
1053             $img = $this->_imgs[0];
1054         }
1055
1056         // Perform any antialiasing
1057         if ($this->_aa_factor != 1) {
1058             $dst_w = $this->_actual_width / $this->_aa_factor;
1059             $dst_h = $this->_actual_height / $this->_aa_factor;
1060             $dst = imagecreatetruecolor($dst_w, $dst_h);
1061             imagecopyresampled($dst, $img, 0, 0, 0, 0,
1062                 $dst_w, $dst_h,
1063                 $this->_actual_width, $this->_actual_height);
1064         } else {
1065             $dst = $img;
1066         }
1067
1068         switch ($type) {
1069             case "jpg":
1070             case "jpeg":
1071                 if (!isset($options["quality"])) {
1072                     $options["quality"] = 75;
1073                 }
1074
1075                 imagejpeg($dst, null, $options["quality"]);
1076                 break;
1077             case "png":
1078             default:
1079                 imagepng($dst);
1080                 break;
1081         }
1082
1083         if ($this->_aa_factor != 1) {
1084             imagedestroy($dst);
1085         }
1086     }
1087 }