vendor/phenx/php-svg-lib/src/Svg/Document.php

   1 <?php
   2 /**
   3  * @package php-svg-lib
   4  * @link    http://github.com/PhenX/php-svg-lib
   5  * @author  Fabien Ménager <fabien.menager@gmail.com>
   6  * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
   7  */
   8
   9 namespace Svg;
  10
  11 use Svg\Surface\SurfaceInterface;
  12 use Svg\Tag\AbstractTag;
  13 use Svg\Tag\Anchor;
  14 use Svg\Tag\Circle;
  15 use Svg\Tag\Ellipse;
  16 use Svg\Tag\Group;
  17 use Svg\Tag\ClipPath;
  18 use Svg\Tag\Image;
  19 use Svg\Tag\Line;
  20 use Svg\Tag\LinearGradient;
  21 use Svg\Tag\Path;
  22 use Svg\Tag\Polygon;
  23 use Svg\Tag\Polyline;
  24 use Svg\Tag\Rect;
  25 use Svg\Tag\Stop;
  26 use Svg\Tag\Text;
  27 use Svg\Tag\StyleTag;
  28 use Svg\Tag\UseTag;
  29
  30 class Document extends AbstractTag
  31 {
  32     protected $filename;
  33     public $inDefs = false;
  34
  35     protected $x;
  36     protected $y;
  37     protected $width;
  38     protected $height;
  39
  40     protected $subPathInit;
  41     protected $pathBBox;
  42     protected $viewBox;
  43
  44     /** @var resource */
  45     protected $parser;
  46
  47     /** @var SurfaceInterface */
  48     protected $surface;
  49
  50     /** @var AbstractTag[] */
  51     protected $stack = array();
  52
  53     /** @var AbstractTag[] */
  54     protected $defs = array();
  55
  56     /** @var \Sabberworm\CSS\CSSList\Document[] */
  57     protected $styleSheets = array();
  58
  59     public function loadFile($filename)
  60     {
  61         $this->filename = $filename;
  62     }
  63
  64     protected function initParser() {
  65         $parser = xml_parser_create("utf-8");
  66         xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, false);
  67         xml_set_element_handler(
  68             $parser,
  69             array($this, "_tagStart"),
  70             array($this, "_tagEnd")
  71         );
  72         xml_set_character_data_handler(
  73             $parser,
  74             array($this, "_charData")
  75         );
  76
  77         return $this->parser = $parser;
  78     }
  79
  80     public function __construct() {
  81
  82     }
  83
  84     /**
  85      * @return SurfaceInterface
  86      */
  87     public function getSurface()
  88     {
  89         return $this->surface;
  90     }
  91
  92     public function getStack()
  93     {
  94         return $this->stack;
  95     }
  96
  97     public function getWidth()
  98     {
  99         return $this->width;
 100     }
 101
 102     public function getHeight()
 103     {
 104         return $this->height;
 105     }
 106
 107     public function getDimensions() {
 108         $rootAttributes = null;
 109
 110         $parser = xml_parser_create("utf-8");
 111         xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, false);
 112         xml_set_element_handler(
 113             $parser,
 114             function ($parser, $name, $attributes) use (&$rootAttributes) {
 115                 if ($name === "svg" && $rootAttributes === null) {
 116                     $attributes = array_change_key_case($attributes, CASE_LOWER);
 117
 118                     $rootAttributes = $attributes;
 119                 }
 120             },
 121             function ($parser, $name) {}
 122         );
 123
 124         $fp = fopen($this->filename, "r");
 125         while ($line = fread($fp, 8192)) {
 126             xml_parse($parser, $line, false);
 127
 128             if ($rootAttributes !== null) {
 129                 break;
 130             }
 131         }
 132
 133         xml_parser_free($parser);
 134
 135         return $this->handleSizeAttributes($rootAttributes);
 136     }
 137
 138     public function handleSizeAttributes($attributes){
 139         if ($this->width === null) {
 140             if (isset($attributes["width"])) {
 141                 $width = Style::convertSize($attributes["width"], 400);
 142                 $this->width  = $width;
 143             }
 144
 145             if (isset($attributes["height"])) {
 146                 $height = Style::convertSize($attributes["height"], 300);
 147                 $this->height = $height;
 148             }
 149
 150             if (isset($attributes['viewbox'])) {
 151                 $viewBox = preg_split('/[\s,]+/is', trim($attributes['viewbox']));
 152                 if (count($viewBox) == 4) {
 153                     $this->x = $viewBox[0];
 154                     $this->y = $viewBox[1];
 155
 156                     if (!$this->width) {
 157                         $this->width = $viewBox[2];
 158                     }
 159                     if (!$this->height) {
 160                         $this->height = $viewBox[3];
 161                     }
 162                 }
 163             }
 164         }
 165
 166         return array(
 167             0        => $this->width,
 168             1        => $this->height,
 169
 170             "width"  => $this->width,
 171             "height" => $this->height,
 172         );
 173     }
 174
 175     public function getDocument(){
 176         return $this;
 177     }
 178
 179     /**
 180      * Append a style sheet
 181      *
 182      * @param \Sabberworm\CSS\CSSList\Document $stylesheet
 183      */
 184     public function appendStyleSheet($stylesheet) {
 185         $this->styleSheets[] = $stylesheet;
 186     }
 187
 188     /**
 189      * Get the document style sheets
 190      *
 191      * @return \Sabberworm\CSS\CSSList\Document[]
 192      */
 193     public function getStyleSheets() {
 194         return $this->styleSheets;
 195     }
 196
 197     protected function before($attributes)
 198     {
 199         $surface = $this->getSurface();
 200
 201         $style = new DefaultStyle();
 202         $style->inherit($this);
 203         $style->fromAttributes($attributes);
 204
 205         $this->setStyle($style);
 206
 207         $surface->setStyle($style);
 208     }
 209
 210     public function render(SurfaceInterface $surface)
 211     {
 212         $this->inDefs = false;
 213         $this->surface = $surface;
 214
 215         $parser = $this->initParser();
 216
 217         if ($this->x || $this->y) {
 218             $surface->translate(-$this->x, -$this->y);
 219         }
 220
 221         $fp = fopen($this->filename, "r");
 222         while ($line = fread($fp, 8192)) {
 223             xml_parse($parser, $line, false);
 224         }
 225
 226         xml_parse($parser, "", true);
 227
 228         xml_parser_free($parser);
 229     }
 230
 231     protected function svgOffset($attributes)
 232     {
 233         $this->attributes = $attributes;
 234
 235         $this->handleSizeAttributes($attributes);
 236     }
 237
 238     public function getDef($id) {
 239         $id = ltrim($id, "#");
 240
 241         return isset($this->defs[$id]) ? $this->defs[$id] : null;
 242     }
 243
 244     private function _tagStart($parser, $name, $attributes)
 245     {
 246         $this->x = 0;
 247         $this->y = 0;
 248
 249         $tag = null;
 250
 251         $attributes = array_change_key_case($attributes, CASE_LOWER);
 252
 253         switch (strtolower($name)) {
 254             case 'defs':
 255                 $this->inDefs = true;
 256                 return;
 257
 258             case 'svg':
 259                 if (count($this->attributes)) {
 260                     $tag = new Group($this, $name);
 261                 }
 262                 else {
 263                     $tag = $this;
 264                     $this->svgOffset($attributes);
 265                 }
 266                 break;
 267
 268             case 'path':
 269                 $tag = new Path($this, $name);
 270                 break;
 271
 272             case 'rect':
 273                 $tag = new Rect($this, $name);
 274                 break;
 275
 276             case 'circle':
 277                 $tag = new Circle($this, $name);
 278                 break;
 279
 280             case 'ellipse':
 281                 $tag = new Ellipse($this, $name);
 282                 break;
 283
 284             case 'image':
 285                 $tag = new Image($this, $name);
 286                 break;
 287
 288             case 'line':
 289                 $tag = new Line($this, $name);
 290                 break;
 291
 292             case 'polyline':
 293                 $tag = new Polyline($this, $name);
 294                 break;
 295
 296             case 'polygon':
 297                 $tag = new Polygon($this, $name);
 298                 break;
 299
 300             case 'lineargradient':
 301                 $tag = new LinearGradient($this, $name);
 302                 break;
 303
 304             case 'radialgradient':
 305                 $tag = new LinearGradient($this, $name);
 306                 break;
 307
 308             case 'stop':
 309                 $tag = new Stop($this, $name);
 310                 break;
 311
 312             case 'style':
 313                 $tag = new StyleTag($this, $name);
 314                 break;
 315
 316             case 'a':
 317                 $tag = new Anchor($this, $name);
 318                 break;
 319
 320             case 'g':
 321             case 'symbol':
 322                 $tag = new Group($this, $name);
 323                 break;
 324
 325             case 'clippath':
 326                 $tag = new ClipPath($this, $name);
 327                 break;
 328
 329             case 'use':
 330                 $tag = new UseTag($this, $name);
 331                 break;
 332
 333             case 'text':
 334                 $tag = new Text($this, $name);
 335                 break;
 336
 337             case 'desc':
 338                 return;
 339         }
 340
 341         if ($tag) {
 342             if (isset($attributes["id"])) {
 343                 $this->defs[$attributes["id"]] = $tag;
 344             }
 345             else {
 346                 /** @var AbstractTag $top */
 347                 $top = end($this->stack);
 348                 if ($top && $top != $tag) {
 349                     $top->children[] = $tag;
 350                 }
 351             }
 352
 353             $this->stack[] = $tag;
 354
 355             $tag->handle($attributes);
 356         }
 357     }
 358
 359     function _charData($parser, $data)
 360     {
 361         $stack_top = end($this->stack);
 362
 363         if ($stack_top instanceof Text || $stack_top instanceof StyleTag) {
 364             $stack_top->appendText($data);
 365         }
 366     }
 367
 368     function _tagEnd($parser, $name)
 369     {
 370         /** @var AbstractTag $tag */
 371         $tag = null;
 372         switch (strtolower($name)) {
 373             case 'defs':
 374                 $this->inDefs = false;
 375                 return;
 376
 377             case 'svg':
 378             case 'path':
 379             case 'rect':
 380             case 'circle':
 381             case 'ellipse':
 382             case 'image':
 383             case 'line':
 384             case 'polyline':
 385             case 'polygon':
 386             case 'radialgradient':
 387             case 'lineargradient':
 388             case 'stop':
 389             case 'style':
 390             case 'text':
 391             case 'g':
 392             case 'symbol':
 393             case 'clippath':
 394             case 'use':
 395             case 'a':
 396                 $tag = array_pop($this->stack);
 397                 break;
 398         }
 399
 400         if (!$this->inDefs && $tag) {
 401             $tag->handleEnd();
 402         }
 403     }
 404 }