library/html2pdf/parsingHTML.class.php

   1 <?php
   2 /**
   3  * Logiciel : HTML2PDF - classe ParsingHTML
   4  *
   5  * Convertisseur HTML => PDF
   6  * Distribué sous la licence LGPL.
   7  *
   8  * @author              Laurent MINGUET <webmaster@html2pdf.fr>
   9  * @version             3.31
  10  */
  11
  12 class parsingHTML
  13 {
  14         var $html               = '';                           // code HTML à parser
  15         var $num                = 0;                            // numéro de table
  16         var $level              = 0;                            // niveaux de table
  17         var $encoding   = '';                           // encodage
  18         var $code               = array();                      // code HTML parsé
  19
  20         /**
  21          * Constructeur
  22          *
  23          * @return      null
  24          */
  25         function parsingHTML($encoding = 'ISO-8859-15')
  26         {
  27                 $this->num              = 0;
  28                 $this->level    = array($this->num);
  29                 $this->html             = '';
  30                 $this->code             = array();
  31                 $this->setEncoding($encoding);
  32         }
  33
  34         function setEncoding($encoding)
  35         {
  36                 $this->encoding = $encoding;
  37         }
  38
  39         /**
  40          * Définir le code HTML à parser
  41          *
  42          * @param       string code html
  43          * @return      null
  44          */
  45         function setHTML($html)
  46         {
  47                 $html = preg_replace('/<!--(.*)-->/isU', '', $html);
  48                 $this->html = $html;
  49         }
  50
  51         /**
  52          * parser le code HTML
  53          *
  54          * @return      null
  55          */
  56         function parse()
  57         {
  58                 $parents = array();
  59
  60                 // chercher les balises HTML du code
  61                 $tmp = array();
  62                 $this->searchCode($tmp);
  63
  64                 // identifier les balises une à une
  65                 $pre_in = false;
  66                 $pre_br = array(
  67                                         'name' => 'br',
  68                                         'close' => false,
  69                                         'param' => array(
  70                                                 'style' => array(),
  71                                                 'num'   => 0
  72                                         )
  73                                 );
  74
  75                 $balises_no_closed = array(
  76                                                                         'br', 'hr', 'img', 'col',
  77                                                                         'input', 'link', 'option',
  78                                                                         'circle', 'ellipse', 'path', 'rect', 'line', 'polygon', 'polyline'
  79                                                         );
  80                 $todos = array();
  81                 foreach($tmp as $part)
  82                 {
  83                         // si c'est un code
  84                         if ($part[0]=='code')
  85                         {
  86                                 $res = $this->analiseCode($part[1]);
  87
  88                                 // si le code est bien un code analisable
  89                                 if ($res)
  90                                 {
  91                                         $res['html_pos'] = $part[2];
  92                                         if (!in_array($res['name'], $balises_no_closed))
  93                                         {
  94                                                 if ($res['close'])
  95                                                 {
  96                                                         if (count($parents)<1)
  97                                                                 HTML2PDF::makeError(3, __FILE__, __LINE__, $res['name'], $this->getHtmlErrorCode($res['html_pos']));
  98                                                         else if ($parents[count($parents)-1]!=$res['name'])
  99                                                                 HTML2PDF::makeError(4, __FILE__, __LINE__, $parents, $this->getHtmlErrorCode($res['html_pos']));
 100                                                         else
 101                                                                 unset($parents[count($parents)-1]);
 102                                                 }
 103                                                 else
 104                                                 {
 105                                                         if ($res['autoclose'])
 106                                                         {
 107                                                                 $todos[] = $res;
 108                                                                 $res['params'] = array();
 109                                                                 $res['close'] = true;
 110                                                         }
 111                                                         else
 112                                                                 $parents[count($parents)] = $res['name'];
 113
 114                                                 }
 115                                                 if (($res['name']=='pre' || $res['name']=='code') && !$res['autoclose'])
 116                                                                 $pre_in = !$res['close'];
 117                                         }
 118
 119                                         $todos[] = $res;
 120                                 }
 121                                 // sinon (code non analisable) => on le transforme en texte
 122                                 else
 123                                 {
 124                                         $part[0]='txt';
 125                                 }
 126                         }
 127                         // sinon si c'est un texte
 128                         if ($part[0]=='txt')
 129                         {
 130                                 // enregistrer l'action correspondante
 131                                 if (!$pre_in)
 132                                 {
 133                                         // remplacer tous les espaces, tabulations, saufs de ligne multiples par de simples espaces
 134                                         $todos[] = array(
 135                                                                         'name'  => 'write',
 136                                                                         'close' => false,
 137                                                                         'param' => array('txt' => $this->prepareTxt($part[1])),
 138                                                                 );
 139                                 }
 140                                 else
 141                                 {
 142                                         $part[1] = str_replace("\r", '', $part[1]);
 143                                         $part[1] = explode("\n", $part[1]);
 144
 145                                         foreach($part[1] as $k => $txt)
 146                                         {
 147                                                 $txt = str_replace("\t", '        ', $txt);
 148                                                 $txt = str_replace(' ', '&nbsp;', $txt);
 149                                                 if ($k>0) $todos[] = $pre_br;
 150
 151                                                 $todos[] = array(
 152                                                                                 'name'  => 'write',
 153                                                                                 'close' => false,
 154                                                                                 'param' => array('txt' => $this->prepareTxt($txt, false)),
 155                                                                         );
 156                                         }
 157                                 }
 158                         }
 159                 }
 160
 161                 // pour chaque action identifiée, il faut nettoyer le début et la fin des textes
 162                 // en fonction des balises qui l'entourent.
 163                 $balises_clean = array('page', 'page_header', 'page_footer', 'form',
 164                                                                 'table', 'thead', 'tfoot', 'tr', 'td', 'th', 'br',
 165                                                                 'div', 'hr', 'p', 'ul', 'ol', 'li',
 166                                                                 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
 167                                                                 'bookmark', 'fieldset', 'legend',
 168                                                                 'draw', 'circle', 'ellipse', 'path', 'rect', 'line', 'g', 'polygon', 'polyline');
 169                 $nb = count($todos);
 170                 for($k=0; $k<$nb; $k++)
 171                 {
 172                         //si c'est un texte
 173                         if ($todos[$k]['name']=='write')
 174                         {
 175                                 // et qu'une balise spécifique le précède => on nettoye les espaces du début du texte
 176                                 if ($k>0 && in_array($todos[$k-1]['name'], $balises_clean))
 177                                         $todos[$k]['param']['txt'] = ltrim($todos[$k]['param']['txt']);
 178
 179                                 // et qu'une balise spécifique le suit => on nettoye les espaces de la fin du texte
 180                                 if ($k<$nb-1 && in_array($todos[$k+1]['name'], $balises_clean))
 181                                         $todos[$k]['param']['txt'] = rtrim($todos[$k]['param']['txt']);
 182
 183                                 if (!strlen($todos[$k]['param']['txt']))
 184                                         unset($todos[$k]);
 185                         }
 186                 }
 187                 if (count($parents)) HTML2PDF::makeError(5, __FILE__, __LINE__, $parents);
 188
 189                 // liste des actions sauvée
 190                 $this->code = array_values($todos);
 191         }
 192
 193         /**
 194          * preparer le texte une seule fois pour gagner du temps. vient de o_WRITE
 195          *
 196          * @param       string texte
 197          * @return      string texte
 198          */
 199         function prepareTxt($txt, $spaces = true)
 200         {
 201                 if ($spaces) $txt = preg_replace('/\s+/is', ' ', $txt);
 202                 $txt = str_replace('&euro;', '€', $txt);
 203                 $txt = html_entity_decode($txt, ENT_QUOTES, $this->encoding);
 204                 return $txt;
 205         }
 206
 207         /**
 208          * parser le code HTML
 209          *
 210          * @param       &array  tableau de retour des données
 211          * @return      null
 212          */
 213         function searchCode(&$tmp)
 214         {
 215                 // séparer les balises du texte
 216                 $tmp = array();
 217                 $reg = '/(<[^>]+>)|([^<]+)+/isU';
 218
 219                 // pour chaque élément trouvé :
 220                 $str = '';
 221                 $offset = 0;
 222                 while(preg_match($reg, $this->html, $parse, PREG_OFFSET_CAPTURE, $offset))
 223                 {
 224                         // si une balise a été détectée
 225                         if ($parse[1][0])
 226                         {
 227                                 // sauvegarde du texte précédent si il existe
 228                                 if ($str!=='')  $tmp[] = array('txt',$str);
 229
 230                                 // sauvegarde de la balise
 231                                 $tmp[] = array('code',trim($parse[1][0]), $offset);
 232
 233                                 // initialisation du texte suivant
 234                                 $str = '';
 235                         }
 236                         else
 237                         {
 238                                 // ajout du texte à la fin de celui qui est déjà détecté
 239                                 $str.= $parse[2][0];
 240                         }
 241                         // Update offset to the end of the match
 242                         $offset = $parse[0][1] + strlen($parse[0][0]);
 243                         unset($parse);
 244                 }
 245                 // si un texte est présent à la fin, on l'enregistre
 246                 if ($str!='') $tmp[] = array('txt',$str);
 247                 unset($str);
 248         }
 249
 250         /**
 251          * analyse une balise HTML
 252          *
 253          * @param       string  code HTML à identifier
 254          * @return      array   action correspondante
 255          */
 256         function analiseCode($code)
 257         {
 258                 // nom de la balise et ouverture ou fermeture
 259                 $balise = '<([\/]{0,1})([_a-z0-9]+)([\/>\s]+)';
 260                 if (!preg_match('/'.$balise.'/isU', $code, $match))
 261                         return null;
 262
 263                 $close  = ($match[1]=='/' ? true : false);
 264                 $autoclose = preg_match('/\/>$/isU', $code);
 265                 $name   = strtolower($match[2]);
 266
 267                 // paramètres obligatoires en fonction du nom de la balise
 268                 $param  = array();
 269                 $param['style'] = '';
 270                 if ($name=='img')       { $param['alt'] = '';   $param['src'] = ''; }
 271                 if ($name=='a')         { $param['href'] = '';  }
 272
 273                 // lecture des paramétres du type nom=valeur
 274                 $prop = '([a-zA-Z0-9_]+)=([^"\'\s>]+)';
 275                 preg_match_all('/'.$prop.'/is', $code, $match);
 276                 for($k=0; $k<count($match[0]); $k++)
 277                         $param[trim(strtolower($match[1][$k]))] = trim($match[2][$k]);
 278
 279                 // lecture des paramétres du type nom="valeur"
 280                 $prop = '([a-zA-Z0-9_]+)=["]([^"]*)["]';
 281                 preg_match_all('/'.$prop.'/is', $code, $match);
 282                 for($k=0; $k<count($match[0]); $k++)
 283                         $param[trim(strtolower($match[1][$k]))] = trim($match[2][$k]);
 284
 285                 // lecture des paramétres du type nom='valeur'
 286                 $prop = "([a-zA-Z0-9_]+)=[']([^']*)[']";
 287                 preg_match_all('/'.$prop.'/is', $code, $match);
 288                 for($k=0; $k<count($match[0]); $k++)
 289                         $param[trim(strtolower($match[1][$k]))] = trim($match[2][$k]);
 290
 291                 // mise en conformité en style de chaque paramètre
 292                 $color  = "#000000";
 293                 $border = null;
 294                 foreach($param as $key => $val)
 295                 {
 296                         $key = strtolower($key);
 297                         switch($key)
 298                         {
 299                                 case 'width':
 300                                         unset($param[$key]);
 301                                         $param['style'] .= 'width: '.$val.'px; ';
 302                                         break;
 303
 304                                 case 'align':
 305                                         if ($name==='img')
 306                                         {
 307                                                 unset($param[$key]);
 308                                                 $param['style'] .= 'float: '.$val.'; ';
 309                                         }
 310                                         elseif ($name!=='table')
 311                                         {
 312                                                 unset($param[$key]);
 313                                                 $param['style'] .= 'text-align: '.$val.'; ';
 314                                         }
 315                                         break;
 316
 317                                 case 'valign':
 318                                         unset($param[$key]);
 319                                         $param['style'] .= 'vertical-align: '.$val.'; ';
 320                                         break;
 321
 322                                 case 'height':
 323                                         unset($param[$key]);
 324                                         $param['style'] .= 'height: '.$val.'px; ';
 325                                         break;
 326
 327                                 case 'bgcolor':
 328                                         unset($param[$key]);
 329                                         $param['style'] .= 'background: '.$val.'; ';
 330                                         break;
 331
 332                                 case 'bordercolor':
 333                                         unset($param[$key]);
 334                                         $color = $val;
 335                                         break;
 336
 337                                 case 'border':
 338                                         unset($param[$key]);
 339                                         if (preg_match('/^[0-9]+$/isU', $val)) $val = $val.'px';
 340                                         $border = $val;
 341                                         break;
 342
 343                                 case 'cellpadding':
 344                                 case 'cellspacing':
 345                                         if (preg_match('/^([0-9]+)$/isU', $val)) $param[$key] = $val.'px';
 346                                         break;
 347
 348                                 case 'colspan':
 349                                 case 'rowspan':
 350                                         $val = preg_replace('/[^0-9]/isU', '', $val);
 351                                         if (!$val) $val = 1;
 352                                         $param[$key] = $val;
 353                                         break;
 354                         }
 355                 }
 356                 if ($border!==null)
 357                 {
 358                         if ($border)    $border = 'border: solid '.$border.' '.$color;
 359                         else                    $border = 'border: none';
 360
 361                         $param['style'] .= $border.'; ';
 362                         $param['border'] = $border;
 363                 }
 364
 365                 // lecture des styles - décomposition
 366                 $styles = explode(';', $param['style']);
 367                 $param['style'] = array();
 368                 foreach($styles as $style)
 369                 {
 370                         $tmp = explode(':', $style);
 371                         if (count($tmp)>1)
 372                         {
 373                                 $cod = $tmp[0]; unset($tmp[0]); $tmp = implode(':', $tmp);
 374                                 $param['style'][trim(strtolower($cod))] = preg_replace('/[\s]+/isU', ' ', trim($tmp));
 375                         }
 376                 }
 377
 378                 // détermination du niveau de table pour les ouverture, avec ajout d'un level
 379                 if (in_array($name, array('ul', 'ol', 'table')) && !$close)
 380                 {
 381                         $this->num++;
 382                         $this->level[count($this->level)] = $this->num;
 383                 }
 384
 385                 // attribution du niveau de table où se trouve l'élément
 386                 if (!isset($param['num'])) $param['num'] = $this->level[count($this->level)-1];
 387
 388                 // pour les fins de table : suppression d'un level
 389                 if (in_array($name, array('ul', 'ol', 'table')) && $close)
 390                 {
 391                         unset($this->level[count($this->level)-1]);
 392                 }
 393
 394                 if (isset($param['value']))     $param['value'] = $this->prepareTxt($param['value']);
 395                 if (isset($param['alt']))       $param['alt']   = $this->prepareTxt($param['alt']);
 396                 if (isset($param['title']))     $param['title'] = $this->prepareTxt($param['title']);
 397                 if (isset($param['class']))     $param['class'] = $this->prepareTxt($param['class']);
 398
 399                 // retour de l'action identifiée
 400                 return array('name' => $name, 'close' => $close ? 1 : 0, 'autoclose' => $autoclose, 'param' => $param);
 401         }
 402
 403         // récupérer un niveau complet d'HTML entre une ouverture de balise et la fermeture correspondante
 404         function getLevel($k)
 405         {
 406                 // si le code n'existe pas : fin
 407                 if (!isset($this->code[$k])) return array();
 408
 409                 // quelle balise faudra-t-il détecter
 410                 $detect = $this->code[$k]['name'];
 411
 412                 $level = 0;                     // niveau de profondeur
 413                 $end = false;           // etat de fin de recherche
 414                 $code = array();        // code extrait
 415
 416                 // tant que c'est pas fini, on boucle
 417                 while (!$end)
 418                 {
 419                         // action courante
 420                         $row = $this->code[$k];
 421
 422                         // si write => on ajoute le texte
 423                         if ($row['name']=='write')
 424                         {
 425                                 $code[] = $row;
 426                         }
 427                         // sinon, c'est une balise html
 428                         else
 429                         {
 430                                 $not = false; // indicateur de non prise en compte de la balise courante
 431
 432                                 // si c'est la balise que l'on cherche
 433                                 if ($row['name']==$detect)
 434                                 {
 435                                         if ($level==0) { $not = true; }                                 // si on est à la premiere balise : on l'ignore
 436                                         $level+= ($row['close'] ? -1 : 1);                              // modification du niveau en cours en fonction de l'ouvertre / fermeture
 437                                         if ($level==0) { $not = true; $end = true; }    // si on est au niveau 0 : on a fini
 438                                 }
 439
 440                                 // si on doit prendre en compte la balise courante
 441                                 if (!$not)
 442                                 {
 443                                         if (isset($row['style']['text-align'])) unset($row['style']['text-align']);
 444                                         $code[] = $row;
 445                                 }
 446                         }
 447
 448                         // on continue tant qu'il y a du code à analyser...
 449                         if (isset($this->code[$k+1]))
 450                                 $k++;
 451                         else
 452                                 $end = true;
 453                 }
 454
 455                 // retourne le code extrait
 456                 return $code;
 457         }
 458
 459         function getHtmlErrorCode($pos)
 460         {
 461                 return substr($this->html, $pos-30, 70);
 462         }
 463 }