source: trunk/client/inc/hpdf/html2pdf.class.php@ 2

Last change on this file since 2 was 2, checked in by root, 15 years ago

importo il progetto
File size: 131.8 KB
RevLine 
[2]1<?php
2/**
3 * Logiciel : HTML2PDF
4 *
5 * Convertisseur HTML => PDF, utilise fpdf de Olivier PLATHEY
6 * Distribué sous la licence GPL.
7 *
8 * @author Laurent MINGUET <webmaster@spipu.net>
9 * @version 3.21 - 05/05/2009
10 */
11
12if (!defined('__CLASS_HTML2PDF__'))
13{
14 define('__CLASS_HTML2PDF__', '3.21');
15
16 // vous pouvez utiliser cette fonction de debug comme suit
17 // pour voir le temps et la mémoire utilisés (sous linux) pour la conversion :
18 // echo HTML2PDFgetTimerDebug();
19 // $html2pdf->WriteHTML($content);
20 // echo HTML2PDFgetTimerDebug();
21 function HTML2PDFgetTimerDebug($debug=false)
22 {
23 global $TIMER_ACTION_LAST;
24 list($usec, $sec) = explode(" ", microtime());
25 $time = (float)$sec + (float)$usec;
26 $mem = HTML2PDFgetMem();
27
28 if (!$TIMER_ACTION_LAST)
29 {
30 if ($debug) $ret = null;
31 else $ret = 'Debug : init'."<br />\n";
32 }
33 else
34 {
35 $aff_time = $time-$TIMER_ACTION_LAST[0];
36 $aff_mem = $mem;
37 if ($debug) $ret = array($aff_time, $aff_mem);
38 else $ret = 'Timer : '.number_format($aff_time, 3, '.', '').'s - Memory used '.$aff_mem.' Ko'."<br />\n";
39 }
40 $TIMER_ACTION_LAST = array($time, $mem);
41 return $ret;
42 }
43 function HTML2PDFgetMem() { return function_exists('memory_get_usage') ? floor(memory_get_usage()/1024) : 0; }
44
45 require_once(dirname(__FILE__).'/_mypdf/mypdf.class.php'); // classe mypdf dérivé de fpdf de Olivier PLATHEY
46 require_once(dirname(__FILE__).'/parsingHTML.class.php'); // classe de parsing HTML
47 require_once(dirname(__FILE__).'/styleHTML.class.php'); // classe de gestion des styles
48
49 global $HTML2PDF_TABLEAU; $HTML2PDF_TABLEAU = array(); // tableau global necessaire à la gestion des tables imbriquées
50
51 class HTML2PDF
52 {
53 var $langue = 'fr'; // langue des messages
54 var $sens = 'P'; // sens d'affichage Portrait ou Landscape
55 var $format = 'A4'; // format de la page : A4, A3, ...
56 var $background = array(); // informations sur le background
57 var $testTDin1page = true; // activer le test de TD ne devant pas depasser une page
58
59 var $style = null; // objet de style
60 var $parsing = null; // objet de parsing
61 var $parse_pos = 0; // position du parsing
62 var $temp_pos = 0; // position temporaire pour multi tableau
63
64 var $sub_html = null; // sous html
65 var $sub_part = false; // indicateur de sous html
66 var $isSubPart = false; // indique que le convertisseur courant est un sous html
67
68 var $pdf = null; // objet PDF
69 var $maxX = 0; // zone maxi X
70 var $maxY = 0; // zone maxi Y
71
72 var $FirstPage = true; // premier page
73
74 var $defaultLeft = 0; // marges par default de la page
75 var $defaultTop = 0;
76 var $defaultRight = 0;
77 var $defaultBottom = 0;
78
79 var $margeLeft = 0; //marges réelles de la page
80 var $margeTop = 0;
81 var $margeRight = 0;
82 var $margeBottom = 0;
83 var $marges = array();
84 var $Maxs = array();
85
86 var $maxH = 0; // plus grande hauteur dans la ligne, pour saut de ligne à corriger
87 var $inLink = ''; // indique si on est à l'interieur d'un lien
88 var $lstAncre = array(); // liste des ancres détectées ou créées
89 var $subHEADER = array(); // tableau des sous commandes pour faire l'HEADER
90 var $subFOOTER = array(); // tableau des sous commandes pour faire le FOOTER
91 var $subSTATES = array(); // tableau de sauvegarde de certains paramètres
92 var $defLIST = array(); // tableau de sauvegarde de l'etat des UL et OL
93
94 var $lstChamps = array(); // liste des champs
95 var $lstSelect = array(); // options du select en cours
96 var $previousCall = null; // dernier appel
97 var $isInTfoot = false; // indique si on est dans un tfoot
98 var $pageMarges = array(); // marges spécifiques dues aux floats
99 var $isAfterFloat = false; // indique si on est apres un float
100
101 /**
102 * Constructeur
103 *
104 * @param string sens portrait ou landscape
105 * @param string format A4, A5, ...
106 * @param string langue : fr, en, it...
107 * @param array marges par defaut, dans l'ordre (left, top, right, bottom)
108 * @param boolean forcer la création de la premiere page, ne pas utiliser, c'est utilisé en interne pour la gestion des tableaux
109 * @return null
110 */
111 function HTML2PDF($sens = 'P', $format = 'A4', $langue='fr', $marges = array(5, 5, 5, 8), $force_page = false)
112 {
113 // sauvegarde des paramètres
114 $this->sens = $sens;
115 $this->format = $format;
116 $this->FirstPage = true;
117 $this->langue = strtolower($langue);
118 $this->setTestTdInOnePage(true);
119
120 // chargement du fichier de langue
121 $this->textLOAD($this->langue);
122
123 // création de l' objet PDF
124 $this->pdf = new MyPDF($sens, 'mm', $format);
125
126 // initialisation des styles
127 $this->style = new styleHTML($this->pdf);
128 $this->style->FontSet();
129 $this->defLIST = array();
130
131 // initialisation du parsing
132 $this->parsing = new parsingHTML();
133 $this->sub_html = null;
134 $this->sub_part = false;
135
136 // initialisation des marges
137 $this->setDefaultMargins($marges[0], $marges[1], $marges[2], $marges[3]);
138 $this->setMargins();
139 $this->marges = array();
140
141 // initialisation des champs de formulaire
142 $this->lstChamps = array();
143
144 // premier page forcée
145 if ($force_page) $this->setNewPage($this->sens);
146 }
147
148 /**
149 * activer ou desactiver le test de TD ne devant pas depasser une page
150 *
151 * @param boolean nouvel etat
152 * @return boolean ancien etat
153 */
154 function setTestTdInOnePage($mode = true)
155 {
156 $old = $this->testTDin1page;
157
158 $this->testTDin1page = $mode ? true : false;
159
160 return $old;
161 }
162
163 /**
164 * définir les marges par défault
165 *
166 * @param int en mm, marge left
167 * @param int en mm, marge top
168 * @param int en mm, marge right. si null, left=right
169 * @param int en mm, marge bottom. si null, bottom=8
170 * @return null
171 */
172 function setDefaultMargins($left, $top, $right = null, $bottom = null)
173 {
174 if ($right===null) $right = $left;
175 if ($bottom===null) $bottom = 8;
176
177 $this->defaultLeft = $this->style->ConvertToMM($left.'mm');
178 $this->defaultTop = $this->style->ConvertToMM($top.'mm');
179 $this->defaultRight = $this->style->ConvertToMM($right.'mm');
180 $this->defaultBottom = $this->style->ConvertToMM($bottom.'mm');
181 }
182
183 /**
184 * définir les marges réelles, fonctions de la balise page
185 *
186 * @return null
187 */
188 function setMargins()
189 {
190 $this->margeLeft = $this->defaultLeft + (isset($this->background['left']) ? $this->background['left'] : 0);
191 $this->margeRight = $this->defaultRight + (isset($this->background['right']) ? $this->background['right'] : 0);
192 $this->margeTop = $this->defaultTop + (isset($this->background['top']) ? $this->background['top'] : 0);
193 $this->margeBottom = $this->defaultBottom + (isset($this->background['bottom']) ? $this->background['bottom'] : 0);
194
195 $this->pdf->SetMargins($this->margeLeft, $this->margeTop, $this->margeRight);
196 $this->pdf->cMargin = 0;
197 $this->pdf->SetAutoPageBreak(false, $this->margeBottom);
198 }
199
200 /**
201 * recuperer les positions x minimales et maximales en fonction d'une hauteur
202 *
203 * @param float y
204 * @return array(float, float)
205 */
206 function getMargins($y)
207 {
208 $y = floor($y*100);
209 $x = array($this->pdf->lMargin, $this->pdf->w-$this->pdf->rMargin);
210
211 foreach($this->pageMarges as $m_y => $m_x)
212 if ($m_y<=$y) $x = $m_x;
213
214 return $x;
215 }
216
217 /**
218 * ajouter une marge suite a un float
219 *
220 * @param string left ou right
221 * @param float x1
222 * @param float y1
223 * @param float x2
224 * @param float y2
225 * @return null
226 */
227 function addMargins($float, $x1, $y1, $x2, $y2)
228 {
229 $old1 = $this->getMargins($y1);
230 $old2 = $this->getMargins($y2);
231 if ($float=='left') $old1[0] = $x2;
232 if ($float=='right') $old1[1] = $x1;
233
234 $y1 = floor($y1*100);
235 $y2 = floor($y2*100);
236
237 foreach($this->pageMarges as $m_y => $m_x)
238 {
239 if ($m_y<$y1) continue;
240 if ($m_y>$y2) break;
241 if ($float=='left' && $this->pageMarges[$m_y][0]<$x2) unset($this->pageMarges[$m_y]);
242 if ($float=='right' && $this->pageMarges[$m_y][1]>$x1) unset($this->pageMarges[$m_y]);
243 }
244
245 $this->pageMarges[$y1] = $old1;
246 $this->pageMarges[$y2] = $old2;
247
248 ksort($this->pageMarges);
249
250 $this->isAfterFloat = true;
251 }
252
253 /**
254 * définir des nouvelles marges et sauvegarder les anciennes
255 *
256 * @param float marge left
257 * @param float marge top
258 * @param float marge right
259 * @return null
260 */
261 function saveMargin($ml, $mt, $mr)
262 {
263 $this->marges[] = array('l' => $this->pdf->lMargin, 't' => $this->pdf->tMargin, 'r' => $this->pdf->rMargin, 'page' => $this->pageMarges);
264 $this->pdf->SetMargins($ml, $mt, $mr);
265
266 $this->pageMarges = array();
267 $this->pageMarges[floor($mt*100)] = array($ml, $this->pdf->w-$mr);
268 }
269
270 /**
271 * récuperer les dernières marches sauvées
272 *
273 * @return null
274 */
275 function loadMargin()
276 {
277 $old = array_pop($this->marges);
278 if ($old)
279 {
280 $ml = $old['l'];
281 $mt = $old['t'];
282 $mr = $old['r'];
283 $mP = $old['page'];
284 }
285 else
286 {
287 $ml = $this->margeLeft;
288 $mt = 0;
289 $mr = $this->margeRight;
290 $mP = array($mt => array($ml, $this->pdf->w-$mr));
291 }
292
293 $this->pdf->SetMargins($ml, $mt, $mr);
294 $this->pageMarges = $mP;
295 }
296
297 /**
298 * permet d'ajouter une fonte.
299 *
300 * @param string nom de la fonte
301 * @param string style de la fonte
302 * @param string fichier de la fonte
303 * @return null
304 */
305 function AddFont($family, $style='', $file='')
306 {
307 $this->pdf->AddFont($family, $style, $file);
308 }
309
310 /**
311 * sauvegarder l'état actuelle des maximums
312 *
313 * @return null
314 */
315 function saveMax()
316 {
317 $this->Maxs[] = array($this->maxX, $this->maxY, $this->maxH);
318 }
319
320 /**
321 * charger le dernier état sauvé des maximums
322 *
323 * @return null
324 */
325 function loadMax()
326 {
327 $old = array_pop($this->Maxs);
328
329 if ($old)
330 {
331 $this->maxX = $old[0];
332 $this->maxY = $old[1];
333 $this->maxH = $old[2];
334 }
335 else
336 {
337 $this->maxX = 0;
338 $this->maxY = 0;
339 $this->maxH = 0;
340 }
341 }
342
343 /**
344 * afficher l'header contenu dans page_header
345 *
346 * @return null
347 */
348 function SetPageHeader()
349 {
350 if (!count($this->subHEADER)) return false;
351
352 $OLD_parse_pos = $this->parse_pos;
353 $OLD_parse_code = $this->parsing->code;
354
355 $this->parse_pos = 0;
356 $this->parsing->code = $this->subHEADER;
357 $this->MakeHTMLcode();
358
359 $this->parse_pos = $OLD_parse_pos;
360 $this->parsing->code = $OLD_parse_code;
361 }
362
363 /**
364 * afficher le footer contenu dans page_footer
365 *
366 * @return null
367 */
368 function SetPageFooter()
369 {
370 if (!count($this->subFOOTER)) return false;
371
372 $OLD_parse_pos = $this->parse_pos;
373 $OLD_parse_code = $this->parsing->code;
374
375 $this->parse_pos = 0;
376 $this->parsing->code = $this->subFOOTER;
377 $this->MakeHTMLcode();
378
379 $this->parse_pos = $OLD_parse_pos;
380 $this->parsing->code = $OLD_parse_code;
381 }
382
383 /**
384 * saut de ligne avec une hauteur spécifique
385 *
386 * @param float hauteur de la ligne
387 * @return null
388 */
389 function setNewLine($h)
390 {
391 $this->pdf->Ln($h);
392
393 list($lx, $rx) = $this->getMargins($this->pdf->y);
394 $this->pdf->x=$lx;
395 }
396
397 /**
398 * création d'une nouvelle page avec une orientation particuliere
399 *
400 * @param string sens P=portrait ou L=landscape
401 * @param array tableau des propriétés du fond de la page
402 * @return null
403 */
404 function setNewPage($orientation = '', $background = null)
405 {
406/*
407 if (!$this->FirstPage)
408 {
409 $info = debug_backtrace(); foreach($info as $k => $v) { unset($info[$k]['object']); unset($info[$k]['type']); unset($info[$k]['args']);}
410 echo '<pre>'.print_r($info, true).'</pre><hr>';
411 }
412*/
413 $this->FirstPage = false;
414
415 $this->sens = $orientation ? $orientation : $this->sens;
416 $this->background = $background!==null ? $background : $this->background;
417 $this->maxY = 0;
418 $this->maxX = 0;
419
420 $this->pdf->lMargin = $this->defaultLeft;
421 $this->pdf->rMargin = $this->defaultRight;
422 $this->pdf->tMargin = $this->defaultTop;
423 $this->pdf->AddPage($this->sens);
424
425 if (!$this->sub_part && !$this->isSubPart)
426 {
427 if (is_array($this->background))
428 {
429 if (isset($this->background['color']) && $this->background['color'])
430 {
431 $this->pdf->SetFillColor($this->background['color'][0], $this->background['color'][1], $this->background['color'][2]);
432 $this->pdf->Rect(0, 0, $this->pdf->w, $this->pdf->h, 'F');
433 }
434
435 if (isset($this->background['img']) && $this->background['img'])
436 $this->pdf->Image($this->background['img'], $this->background['posX'], $this->background['posY'], $this->background['width']);
437 }
438
439 $this->SetPageHeader();
440 $this->SetPageFooter();
441 }
442
443 $this->SetMargins();
444 $this->pdf->y = $this->margeTop;
445 list($lx, $rx) = $this->getMargins($this->pdf->y);
446 $this->pdf->x=$lx;
447 }
448
449 /**
450 * récupération du PDF
451 *
452 * @param string nom du fichier PDF
453 * @param boolean destination
454 * @return string contenu éventuel du pdf
455 *
456 *
457 * Destination où envoyer le document. Le paramètre peut prendre les valeurs suivantes :
458 * true : equivalent à I
459 * false : equivalent à S
460 * I : envoyer en inline au navigateur. Le plug-in est utilisé s'il est installé. Le nom indiqué dans name est utilisé lorsque l'on sélectionne "Enregistrer sous" sur le lien générant le PDF.
461 * D : envoyer au navigateur en forçant le téléchargement, avec le nom indiqué dans name.
462 * F : sauver dans un fichier local, avec le nom indiqué dans name (peut inclure un répertoire).
463 * S : renvoyer le document sous forme de chaîne. name est ignoré.
464 */
465 function Output($name = '', $dest = false)
466 {
467 // nettoyage
468 global $HTML2PDF_TABLEAU; $HTML2PDF_TABLEAU = array();
469
470 // interpretation des paramètres
471 if ($dest===false) $dest = 'I';
472 if ($dest===true) $dest = 'S';
473 if ($dest==='') $dest = 'I';
474 if ($name=='') $name='document.pdf';
475
476 // verification de la destination
477 $dest = strtoupper($dest);
478 if (!in_array($dest, array('I', 'D', 'F', 'S'))) $dest = 'I';
479
480 // verification du nom
481 if (strtolower(substr($name, -4))!='.pdf')
482 {
483 echo 'ERROR : The output document name "'.$name.'" is not a PDF name';
484 exit;
485 }
486
487
488 return $this->pdf->Output($name, $dest);
489 }
490
491 /**
492 * création d'un sous HTML2PDF pour la gestion des tableaux imbriqués
493 *
494 * @param HTML2PDF futur sous HTML2PDF passé en référence pour créatio
495 * @return null
496 */
497 function CreateSubHTML(&$sub_html, $cellmargin=0)
498 {
499 // initialisation du sous objet
500 $sub_html = new HTML2PDF(
501 $this->sens,
502 $this->format,
503 $this->langue,
504 array($this->defaultLeft,$this->defaultTop,$this->defaultRight,$this->defaultBottom),
505 true
506 );
507 $sub_html->isSubPart = true;
508 $sub_html->setTestTdInOnePage($this->testTDin1page);
509
510 $sub_html->style->css = $this->style->css;
511 $sub_html->style->css_keys = $this->style->css_keys;
512 $sub_html->style->table = $this->style->table;
513 $sub_html->style->value = $this->style->value;
514 $sub_html->style->value['text-align'] = 'left';
515 $sub_html->defLIST = $this->defLIST;
516
517 // initialisation de la largeur
518 if ($this->style->value['width'])
519 {
520 $marge = $cellmargin*2;
521 $marge+= $this->style->value['padding']['l'] + $this->style->value['padding']['r'];
522 $marge+= $this->style->value['border']['l']['width'] + $this->style->value['border']['r']['width'];
523 $marge = $sub_html->pdf->w - $this->style->value['width'] + $marge;
524 }
525 else
526 $marge = $this->margeLeft+$this->margeRight;
527
528 $sub_html->saveMargin(0, 0, $marge);
529
530 // initialisation des fontes
531 $sub_html->pdf->fonts = &$this->pdf->fonts;
532 $sub_html->pdf->FontFiles = &$this->pdf->FontFiles;
533 $sub_html->pdf->diffs = &$this->pdf->diffs;
534
535 // initialisation des positions et autre
536 $sub_html->maxX = 0;
537 $sub_html->maxY = 0;
538 $sub_html->maxH = 0;
539 $sub_html->pdf->setX(0);
540 $sub_html->pdf->setY(0);
541 $sub_html->style->FontSet();
542 }
543
544 /**
545 * destruction d'un sous HTML2PDF pour la gestion des tableaux imbriqués
546 *
547 * @return null
548 */
549 function DestroySubHTML()
550 {
551
552 unset($this->sub_html);
553 $this->sub_html = null;
554 }
555
556 /**
557 * Convertir un nombre arabe en nombre romain
558 *
559 * @param integer nombre à convertir
560 * @return string nombre converti
561 */
562 function listeArab2Rom($nb_ar)
563 {
564 $nb_b10 = array('I','X','C','M');
565 $nb_b5 = array('V','L','D');
566 $nb_ro = '';
567
568 if ($nb_ar<1) return $nb_ar;
569 if ($nb_ar>3999) return $nb_ar;
570
571 for($i=3; $i>=0 ; $i--)
572 {
573 $chiffre=floor($nb_ar/pow(10,$i));
574 if($chiffre>=1)
575 {
576 $nb_ar=$nb_ar-$chiffre*pow(10,$i);
577 if($chiffre<=3)
578 {
579 for($j=$chiffre; $j>=1; $j--)
580 {
581 $nb_ro=$nb_ro.$nb_b10[$i];
582 }
583 }
584 else if($chiffre==9)
585 {
586 $nb_ro=$nb_ro.$nb_b10[$i].$nb_b10[$i+1];
587 }
588 elseif($chiffre==4)
589 {
590 $nb_ro=$nb_ro.$nb_b10[$i].$nb_b5[$i];
591 }
592 else
593 {
594 $nb_ro=$nb_ro.$nb_b5[$i];
595 for($j=$chiffre-5; $j>=1; $j--)
596 {
597 $nb_ro=$nb_ro.$nb_b10[$i];
598 }
599 }
600 }
601 }
602 return $nb_ro;
603 }
604
605 /**
606 * Ajouter un LI au niveau actuel
607 *
608 * @return null
609 */
610 function listeAddLi()
611 {
612 $this->defLIST[count($this->defLIST)-1]['nb']++;
613 }
614
615 function listeGetWidth() { return '7mm'; }
616 function listeGetPadding() { return '1mm'; }
617
618 /**
619 * Recuperer le LI du niveau actuel
620 *
621 * @return string chaine à afficher
622 */
623 function listeGetLi()
624 {
625 $im = $this->defLIST[count($this->defLIST)-1]['img'];
626 $st = $this->defLIST[count($this->defLIST)-1]['style'];
627 $nb = $this->defLIST[count($this->defLIST)-1]['nb'];
628 $up = (substr($st, 0, 6)=='upper-');
629
630 if ($im) return array(false, false, $im);
631
632 switch($st)
633 {
634 case 'none':
635 return array('arial', true, ' ');
636
637 case 'upper-alpha':
638 case 'lower-alpha':
639 $str = '';
640 while($nb>26)
641 {
642 $str = chr(96+$nb%26).$str;
643 $nb = floor($nb/26);
644 }
645 $str = chr(96+$nb).$str;
646
647 return array('arial', false, ($up ? strtoupper($str) : $str).'.');
648
649 case 'upper-roman':
650 case 'lower-roman':
651 $str = $this->listeArab2Rom($nb);
652
653 return array('arial', false, ($up ? strtoupper($str) : $str).'.');
654
655 case 'decimal':
656 return array('arial', false, $nb.'.');
657
658 case 'square':
659 return array('zapfdingbats', true, chr(110));
660
661 case 'circle':
662 return array('zapfdingbats', true, chr(109));
663
664 case 'disc':
665 default:
666 return array('zapfdingbats', true, chr(108));
667 }
668 }
669
670 /**
671 * Ajouter un niveau de liste
672 *
673 * @param string type de liste : ul, ol
674 * @param string style de la liste
675 * @return null
676 */
677 function listeAddLevel($type = 'ul', $style = '', $img = null)
678 {
679 if ($img)
680 {
681 if (preg_match('/^url\(([^)]+)\)$/isU', trim($img), $match))
682 $img = $match[1];
683 else
684 $img = null;
685 }
686 else
687 $img = null;
688
689 if (!in_array($type, array('ul', 'ol'))) $type = 'ul';
690 if (!in_array($style, array('lower-alpha', 'upper-alpha', 'upper-roman', 'lower-roman', 'decimal', 'square', 'circle', 'disc', 'none'))) $style = '';
691
692 if (!$style)
693 {
694 if ($type=='ul') $style = 'disc';
695 else $style = 'decimal';
696 }
697 $this->defLIST[count($this->defLIST)] = array('style' => $style, 'nb' => 0, 'img' => $img);
698 }
699
700 /**
701 * Supprimer un niveau de liste
702 *
703 * @return null
704 */
705 function listeDelLevel()
706 {
707 if (count($this->defLIST))
708 {
709 unset($this->defLIST[count($this->defLIST)-1]);
710 $this->defLIST = array_values($this->defLIST);
711 }
712 }
713
714 /**
715 * traitement d'un code HTML
716 *
717 * @param string code HTML à convertir
718 * @param boolean afficher en pdf (false) ou en html (true)
719 * @return null
720 */
721 function WriteHTML($html, $vue = false)
722 {
723 $html = str_replace('[[page_nb]]', '{nb}', $html);
724
725 $html = str_replace('[[date_y]]', date('Y'), $html);
726 $html = str_replace('[[date_m]]', date('m'), $html);
727 $html = str_replace('[[date_d]]', date('d'), $html);
728
729 $html = str_replace('[[date_h]]', date('H'), $html);
730 $html = str_replace('[[date_i]]', date('i'), $html);
731 $html = str_replace('[[date_s]]', date('s'), $html);
732
733 // si on veut voir le résultat en HTML => on appelle la fonction
734 if ($vue) $this->vueHTML($html);
735
736 // sinon, traitement pour conversion en PDF :
737 // parsing
738 $this->sub_pdf = false;
739 $this->style->readStyle($html);
740 $this->parsing->setHTML($html);
741 $this->parsing->parse();
742 $this->MakeHTMLcode();
743 }
744
745 function MakeHTMLcode()
746 {
747 // pour chaque element identifié par le parsing
748 for($this->parse_pos=0; $this->parse_pos<count($this->parsing->code); $this->parse_pos++)
749 {
750 // récupération de l'élément
751 $todo = $this->parsing->code[$this->parse_pos];
752
753 // si c'est une ouverture de tableau
754 if (in_array($todo['name'], array('table', 'ul', 'ol')) && !$todo['close'])
755 {
756 // on va créer un sous HTML, et on va travailler sur une position temporaire
757 $tag_open = $todo['name'];
758
759 $this->sub_part = true;
760 $this->temp_pos = $this->parse_pos;
761
762 // pour tous les éléments jusqu'à la fermeture de la table afin de préparer les dimensions
763 while(isset($this->parsing->code[$this->temp_pos]) && !($this->parsing->code[$this->temp_pos]['name']==$tag_open && $this->parsing->code[$this->temp_pos]['close']))
764 {
765 $this->loadAction($this->parsing->code[$this->temp_pos]);
766 $this->temp_pos++;
767 }
768 if (isset($this->parsing->code[$this->temp_pos])) $this->loadAction($this->parsing->code[$this->temp_pos]);
769 $this->sub_part = false;
770 }
771
772 // chargement de l'action correspondant à l'élément
773 $this->loadAction($todo);
774 }
775 }
776
777
778
779 /**
780 * affichage en mode HTML du contenu
781 *
782 * @param string contenu
783 * @return null
784 */
785 function vueHTML($content)
786 {
787 $content = preg_replace('/<page_header([^>]*)>/isU', '<hr>'.HTML2PDF::textGET('vue01').' : $1<hr><div$1>', $content);
788 $content = preg_replace('/<page_footer([^>]*)>/isU', '<hr>'.HTML2PDF::textGET('vue02').' : $1<hr><div$1>', $content);
789 $content = preg_replace('/<page([^>]*)>/isU', '<hr>'.HTML2PDF::textGET('vue03').' : $1<hr><div$1>', $content);
790 $content = preg_replace('/<\/page([^>]*)>/isU', '</div><hr>', $content);
791 $content = preg_replace('/<bookmark([^>]*)>/isU', '<hr>bookmark : $1<hr>', $content);
792 $content = preg_replace('/<\/bookmark([^>]*)>/isU', '', $content);
793
794 echo '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
795<html>
796 <head>
797 <title>'.HTML2PDF::textGET('vue04').' HTML</title>
798 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" >
799 </head>
800 <body style="padding: 10px; font-size: 10pt;font-family: Arial;">
801'.$content.'
802 </body>
803</html>';
804 exit;
805 }
806
807 /**
808 * chargement de l'action correspondante à un element de parsing
809 *
810 * @param array élément de parsing
811 * @return null
812 */
813 function loadAction($row)
814 {
815 // nom de l'action
816 $fnc = ($row['close'] ? 'c_' : 'o_').strtoupper($row['name']);
817
818 // parametres de l'action
819 $param = $row['param'];
820
821 // si aucune page n'est créé, on la créé
822 if ($fnc!='o_PAGE' && $this->FirstPage)
823 {
824 $this->setNewPage();
825 }
826
827 // lancement de l'action
828 if (is_callable(array(&$this, $fnc)))
829 {
830 $this->{$fnc}($param);
831 $this->previousCall = $fnc;
832 }
833 else
834 {
835 HTML2PDF::makeError(1, __FILE__, __LINE__, strtoupper($row['name']));
836 }
837 }
838
839 /**
840 * balise : PAGE
841 * mode : OUVERTURE
842 *
843 * @param array paramètres de l'élément de parsing
844 * @return null
845 */
846 function o_PAGE($param)
847 {
848 $newPageSet= (!isset($param['pageset']) || $param['pageset']!='old');
849
850 $this->maxH = 0;
851 if ($newPageSet)
852 {
853 $this->subHEADER = array();
854 $this->subFOOTER = array();
855
856 // identification de l'orientation demandée
857 $orientation = '';
858 if (isset($param['orientation']))
859 {
860 $param['orientation'] = strtolower($param['orientation']);
861 if ($param['orientation']=='p') $orientation = 'P';
862 if ($param['orientation']=='portrait') $orientation = 'P';
863
864 if ($param['orientation']=='l') $orientation = 'L';
865 if ($param['orientation']=='paysage') $orientation = 'L';
866 if ($param['orientation']=='landscape') $orientation = 'L';
867 }
868
869 // identification des propriétés du background
870 $background = array();
871 if (isset($param['backimg']))
872 {
873 $background['img'] = isset($param['backimg']) ? $param['backimg'] : ''; // nom de l'image
874 $background['posX'] = isset($param['backimgx']) ? $param['backimgx'] : 'center'; // position horizontale de l'image
875 $background['posY'] = isset($param['backimgy']) ? $param['backimgy'] : 'middle'; // position verticale de l'image
876 $background['width'] = isset($param['backimgw']) ? $param['backimgw'] : '100%'; // taille de l'image (100% = largueur de la feuille)
877
878 // conversion du nom de l'image, en cas de paramètres en _GET
879 $background['img'] = str_replace('&amp;', '&', $background['img']);
880 // conversion des positions
881 if ($background['posX']=='left') $background['posX'] = '0%';
882 if ($background['posX']=='center') $background['posX'] = '50%';
883 if ($background['posX']=='right') $background['posX'] = '100%';
884 if ($background['posY']=='top') $background['posY'] = '0%';
885 if ($background['posY']=='middle') $background['posY'] = '50%';
886 if ($background['posY']=='bottom') $background['posY'] = '100%';
887
888
889 // si il y a une image de précisé
890 if ($background['img'])
891 {
892 // est-ce que c'est une image ?
893 $infos=@GetImageSize($background['img']);
894 if (count($infos)>1)
895 {
896 // taille de l'image, en fonction de la taille spécifiée.
897 $Wi = $this->style->ConvertToMM($background['width'], $this->pdf->w);
898 $Hi = $Wi*$infos[1]/$infos[0];
899
900 // récupération des dimensions et positions de l'image
901 $background['width'] = $Wi;
902 $background['posX'] = $this->style->ConvertToMM($background['posX'], $this->pdf->w - $Wi);
903 $background['posY'] = $this->style->ConvertToMM($background['posY'], $this->pdf->h - $Hi);
904 }
905 else
906 $background = array();
907 }
908 else
909 $background = array();
910 }
911
912 // marges TOP et BOTTOM pour le texte.
913 $background['top'] = isset($param['backtop']) ? $param['backtop'] : '0';
914 $background['bottom'] = isset($param['backbottom']) ? $param['backbottom'] : '0';
915 $background['left'] = isset($param['backleft']) ? $param['backleft'] : '0';
916 $background['right'] = isset($param['backright']) ? $param['backright'] : '0';
917
918 if (preg_match('/^([0-9]*)$/isU', $background['top'])) $background['top'] .= 'mm';
919 if (preg_match('/^([0-9]*)$/isU', $background['bottom'])) $background['bottom'] .= 'mm';
920 if (preg_match('/^([0-9]*)$/isU', $background['left'])) $background['left'] .= 'mm';
921 if (preg_match('/^([0-9]*)$/isU', $background['right'])) $background['right'] .= 'mm';
922
923 $background['top'] = $this->style->ConvertToMM($background['top'], $this->pdf->h);
924 $background['bottom'] = $this->style->ConvertToMM($background['bottom'], $this->pdf->h);
925 $background['left'] = $this->style->ConvertToMM($background['left'], $this->pdf->w);
926 $background['right'] = $this->style->ConvertToMM($background['right'], $this->pdf->w);
927
928 $res = false;
929 $background['color'] = isset($param['backcolor']) ? $this->style->ConvertToRVB($param['backcolor'], $res) : null;
930 if (!$res) $background['color'] = null;
931
932 $this->style->save();
933 $this->style->analyse('PAGE', $param);
934 $this->style->setPosition($this->pdf->x, $this->pdf->y);
935 $this->style->FontSet();
936
937 // nouvelle page
938 $this->setNewPage($orientation, $background);
939
940 // footer automatique
941 if (isset($param['footer']))
942 {
943 $lst = explode(';', $param['footer']);
944 foreach($lst as $key => $val) $lst[$key] = trim(strtolower($val));
945 $page = in_array('page', $lst);
946 $date = in_array('date', $lst);
947 $heure = in_array('heure', $lst);
948 $form = in_array('form', $lst);
949 }
950 else
951 {
952 $page = null;
953 $date = null;
954 $heure = null;
955 $form = null;
956 }
957 $this->pdf->SetMyFooter($page, $date, $heure, $form);
958 }
959 else
960 {
961 $this->style->save();
962 $this->style->analyse('PAGE', $param);
963 $this->style->setPosition($this->pdf->x, $this->pdf->y);
964 $this->style->FontSet();
965
966 $this->setNewPage();
967 }
968
969 }
970
971 /**
972 * balise : PAGE
973 * mode : FERMETURE
974 *
975 * @param array paramètres de l'élément de parsing
976 * @return null
977 */
978 function c_PAGE($param)
979 {
980 $this->maxH = 0;
981
982 $this->style->load();
983 $this->style->FontSet();
984 }
985
986
987 function o_PAGE_HEADER($param)
988 {
989 $this->subHEADER = array();
990 for($this->parse_pos; $this->parse_pos<count($this->parsing->code); $this->parse_pos++)
991 {
992 $todo = $this->parsing->code[$this->parse_pos];
993 if ($todo['name']=='page_header') $todo['name']='page_header_sub';
994 $this->subHEADER[] = $todo;
995 if (strtolower($todo['name'])=='page_header_sub' && $todo['close']) break;
996 }
997
998 $this->SetPageHeader();
999 }
1000
1001 function o_PAGE_FOOTER($param)
1002 {
1003 $this->subFOOTER = array();
1004 for($this->parse_pos; $this->parse_pos<count($this->parsing->code); $this->parse_pos++)
1005 {
1006 $todo = $this->parsing->code[$this->parse_pos];
1007 if ($todo['name']=='page_footer') $todo['name']='page_footer_sub';
1008 $this->subFOOTER[] = $todo;
1009 if (strtolower($todo['name'])=='page_footer_sub' && $todo['close']) break;
1010 }
1011
1012 $this->SetPageFooter();
1013 }
1014
1015 function o_PAGE_HEADER_SUB($param)
1016 {
1017 $this->subSTATES = array();
1018 $this->subSTATES['x'] = $this->pdf->x;
1019 $this->subSTATES['y'] = $this->pdf->y;
1020 $this->subSTATES['s'] = $this->style->value;
1021 $this->subSTATES['t'] = $this->style->table;
1022 $this->subSTATES['ml'] = $this->pdf->lMargin;
1023 $this->subSTATES['mr'] = $this->pdf->rMargin;
1024 $this->subSTATES['mt'] = $this->pdf->tMargin;
1025 $this->subSTATES['mb'] = $this->pdf->bMargin;
1026
1027 $this->pdf->x = $this->defaultLeft;
1028 $this->pdf->y = $this->defaultTop;
1029 $this->style->initStyle();
1030 $this->style->resetStyle();
1031 $this->style->value['width'] = $this->pdf->w - $this->defaultLeft - $this->defaultRight;
1032 $this->style->table = array();
1033 $this->pdf->lMargin = $this->defaultLeft;
1034 $this->pdf->rMargin = $this->defaultRight;
1035 $this->pdf->tMargin = $this->defaultTop;
1036 $this->pdf->bMargin = $this->defaultBottom;
1037 $this->pdf->PageBreakTrigger = $this->pdf->h - $this->pdf->bMargin;
1038
1039 $this->style->save();
1040 $this->style->analyse('page_header_sub', $param);
1041 $this->style->setPosition($this->pdf->x, $this->pdf->y);
1042 $this->style->FontSet();
1043 }
1044
1045 function c_PAGE_HEADER_SUB($param)
1046 {
1047 $this->style->load();
1048
1049 $this->pdf->x = $this->subSTATES['x'];
1050 $this->pdf->y = $this->subSTATES['y'];
1051 $this->style->value = $this->subSTATES['s'];
1052 $this->style->table = $this->subSTATES['t'];
1053 $this->pdf->lMargin = $this->subSTATES['ml'];
1054 $this->pdf->rMargin = $this->subSTATES['mr'];
1055 $this->pdf->tMargin = $this->subSTATES['mt'];
1056 $this->pdf->bMargin = $this->subSTATES['mb'];
1057 $this->pdf->PageBreakTrigger = $this->pdf->h - $this->pdf->bMargin;
1058
1059 $this->style->FontSet();
1060 }
1061
1062 function o_PAGE_FOOTER_SUB($param)
1063 {
1064 $this->subSTATES = array();
1065 $this->subSTATES['x'] = $this->pdf->x;
1066 $this->subSTATES['y'] = $this->pdf->y;
1067 $this->subSTATES['s'] = $this->style->value;
1068 $this->subSTATES['t'] = $this->style->table;
1069 $this->subSTATES['ml'] = $this->pdf->lMargin;
1070 $this->subSTATES['mr'] = $this->pdf->rMargin;
1071 $this->subSTATES['mt'] = $this->pdf->tMargin;
1072 $this->subSTATES['mb'] = $this->pdf->bMargin;
1073
1074 $this->pdf->x = $this->defaultLeft;
1075 $this->pdf->y = $this->defaultTop;
1076 $this->style->initStyle();
1077 $this->style->resetStyle();
1078 $this->style->value['width'] = $this->pdf->w - $this->defaultLeft - $this->defaultRight;
1079 $this->style->table = array();
1080 $this->pdf->lMargin = $this->defaultLeft;
1081 $this->pdf->rMargin = $this->defaultRight;
1082 $this->pdf->tMargin = $this->defaultTop;
1083 $this->pdf->bMargin = $this->defaultBottom;
1084 $this->pdf->PageBreakTrigger = $this->pdf->h - $this->pdf->bMargin;
1085
1086 // on en créé un sous HTML que l'on transforme en PDF
1087 // pour récupérer la hauteur
1088 // on extrait tout ce qui est contenu dans le FOOTER
1089 $sub = null;
1090 $res = $this->parsing->getLevel($this->parse_pos);
1091 $this->CreateSubHTML($sub);
1092 $sub->writeHTML($res[1]);
1093 $this->pdf->y = $this->pdf->h - $sub->maxY - $this->defaultBottom - 0.01;
1094 unset($sub);
1095
1096 $this->style->save();
1097 $this->style->analyse('page_footer_sub', $param);
1098 $this->style->setPosition($this->pdf->x, $this->pdf->y);
1099 $this->style->FontSet();
1100 }
1101
1102 function c_PAGE_FOOTER_SUB($param)
1103 {
1104 $this->style->load();
1105
1106 $this->pdf->x = $this->subSTATES['x'];
1107 $this->pdf->y = $this->subSTATES['y'];
1108 $this->style->value = $this->subSTATES['s'];
1109 $this->style->table = $this->subSTATES['t'];
1110 $this->pdf->lMargin = $this->subSTATES['ml'];
1111 $this->pdf->rMargin = $this->subSTATES['mr'];
1112 $this->pdf->tMargin = $this->subSTATES['mt'];
1113 $this->pdf->bMargin = $this->subSTATES['mb'];
1114 $this->pdf->PageBreakTrigger = $this->pdf->h - $this->pdf->bMargin;
1115
1116 $this->style->FontSet();
1117 }
1118
1119 /**
1120 * balise : NOBREAK
1121 * mode : OUVERTURE
1122 *
1123 * @param array paramètres de l'élément de parsing
1124 * @return null
1125 */
1126 function o_NOBREAK($param)
1127 {
1128 $this->maxH = 0;
1129 // on extrait tout ce qui est contenu dans le NOBREAK
1130 $res = $this->parsing->getLevel($this->parse_pos);
1131
1132 // on en créé un sous HTML que l'on transforme en PDF
1133 // pour analyse les dimensions
1134 // et voir si ca rentre
1135 $sub = null;
1136 $this->CreateSubHTML($sub);
1137 $sub->writeHTML($res[1]);
1138
1139 $y = $this->pdf->getY();
1140 if (
1141 $sub->maxY < ($this->pdf->h - $this->pdf->tMargin-$this->pdf->bMargin) &&
1142 $y + $sub->maxY>=($this->pdf->h - $this->pdf->bMargin)
1143 )
1144 $this->setNewPage();
1145 unset($sub);
1146 }
1147
1148
1149 /**
1150 * balise : NOBREAK
1151 * mode : FERMETURE
1152 *
1153 * @param array paramètres de l'élément de parsing
1154 * @return null
1155 */
1156 function c_NOBREAK($param)
1157 {
1158 $this->maxH = 0;
1159
1160 }
1161
1162 /**
1163 * balise : DIV
1164 * mode : OUVERTURE
1165 *
1166 * @param array paramètres de l'élément de parsing
1167 * @return null
1168 */
1169 function o_DIV($param, $other = 'div')
1170 {
1171 $this->style->save();
1172 $this->style->analyse($other, $param);
1173 $this->style->FontSet();
1174
1175 $align_object = null;
1176 if ($this->style->value['margin-auto']) $align_object = 'center';
1177
1178 $marge = array();
1179 $marge['l'] = $this->style->value['border']['l']['width'] + $this->style->value['padding']['l']+0.03;
1180 $marge['r'] = $this->style->value['border']['r']['width'] + $this->style->value['padding']['r']+0.03;
1181 $marge['t'] = $this->style->value['border']['t']['width'] + $this->style->value['padding']['t']+0.03;
1182 $marge['b'] = $this->style->value['border']['b']['width'] + $this->style->value['padding']['b']+0.03;
1183
1184 // on extrait tout ce qui est contenu dans la DIV
1185 $res = $this->parsing->getLevel($this->parse_pos);
1186
1187 // on en créé un sous HTML que l'on transforme en PDF
1188 // pour analyse les dimensions
1189 $w = 0; $h = 0;
1190 if (trim($res[1]))
1191 {
1192 $sub = null;
1193 $this->CreateSubHTML($sub);
1194 $sub->writeHTML($res[1]);
1195 $w = $sub->maxX;
1196 $h = $sub->maxY;
1197 unset($sub);
1198 }
1199
1200 $w+= $marge['l']+$marge['r'];
1201 $h+= $marge['t']+$marge['b'];
1202
1203 $this->style->value['width'] = max($w, $this->style->value['width']);
1204 $this->style->value['height'] = max($h, $this->style->value['height']);
1205
1206 if (!$this->style->value['position'])
1207 {
1208 if (
1209 $this->style->value['width'] < ($this->pdf->w - $this->pdf->lMargin-$this->pdf->rMargin) &&
1210 $this->pdf->x + $this->style->value['width']>=($this->pdf->w - $this->pdf->rMargin)
1211 )
1212 $this->o_BR(array());
1213
1214 if (
1215 $this->style->value['height'] < ($this->pdf->h - $this->pdf->tMargin-$this->pdf->bMargin) &&
1216 $this->pdf->y + $this->style->value['height']>=($this->pdf->h - $this->pdf->bMargin)
1217 )
1218 $this->setNewPage();
1219
1220 // en cas d'alignement => correction
1221 $w = $this->style->value['width'];
1222 $old = isset($this->style->table[count($this->style->table)-1]) ? $this->style->table[count($this->style->table)-1] : $this->style->value;
1223 $parent_w = $old['width'] ? $old['width'] : $this->pdf->w - $this->pdf->lMargin - $this->pdf->rMargin;
1224
1225 if ($parent_w>$w)
1226 {
1227 if ($align_object=='center') $this->pdf->x = $this->pdf->x + ($parent_w-$w)*0.5;
1228 else if ($align_object=='right') $this->pdf->x = $this->pdf->x + $parent_w-$w;
1229 }
1230
1231 $this->style->setPosition($this->pdf->x, $this->pdf->y);
1232 }
1233 else
1234 {
1235 $this->style->setPosition($this->pdf->x, $this->pdf->y);
1236 $this->saveMax();
1237 $this->saveX = 0;
1238 $this->saveY = 0;
1239 $this->saveH = 0;
1240 }
1241
1242 // initialisation du style des bordures de la premiere partie de tableau
1243 $this->Rectangle(
1244 $this->style->value['x'],
1245 $this->style->value['y'],
1246 $this->style->value['width'],
1247 $this->style->value['height'],
1248 $this->style->value['border'],
1249 $this->style->value['padding'],
1250 0,
1251 $this->style->value['background']
1252 );
1253
1254
1255 $marge = array();
1256 $marge['l'] = $this->style->value['border']['l']['width'] + $this->style->value['padding']['l']+0.03;
1257 $marge['r'] = $this->style->value['border']['r']['width'] + $this->style->value['padding']['r']+0.03;
1258 $marge['t'] = $this->style->value['border']['t']['width'] + $this->style->value['padding']['t']+0.03;
1259 $marge['b'] = $this->style->value['border']['b']['width'] + $this->style->value['padding']['b']+0.03;
1260
1261 $this->style->value['width'] = $this->style->value['width']-$marge['l']-$marge['r'];
1262 $this->style->value['height'] = $this->style->value['height']-$marge['r']-$marge['b'];
1263
1264 // limitation des marges aux dimensions de la div
1265 $mL = $this->style->value['x']+$marge['l'];
1266 $mR = $this->pdf->w - $mL - $this->style->value['width'];
1267 $this->saveMargin($mL, 0, $mR);
1268
1269 // positionnement en fonction
1270 $h_corr = $this->style->value['height'];
1271 $h_reel = $h-$marge['b']-$marge['t'];
1272 switch($this->style->value['vertical-align'])
1273 {
1274 case 'bottom':
1275 $y_corr = $h_corr-$h_reel;
1276 break;
1277
1278 case 'middle':
1279 $y_corr = ($h_corr-$h_reel)*0.5;
1280 break;
1281
1282 case 'top':
1283 default:
1284 $y_corr = 0;
1285 break;
1286 }
1287
1288 $this->pdf->setX($this->style->value['x']+$marge['l']);
1289 $this->pdf->setY($this->style->value['y']+$marge['t']+$y_corr);
1290
1291 }
1292 function o_BLOCKQUOTE($param) { $this->o_DIV($param, 'blockquote'); }
1293
1294 /**
1295 * balise : DIV
1296 * mode : FERMETURE
1297 *
1298 * @param array paramètres de l'élément de parsing
1299 * @return null
1300 */
1301 function c_DIV($param)
1302 {
1303 $marge = array();
1304 $marge['l'] = $this->style->value['border']['l']['width'] + $this->style->value['padding']['l']+0.03;
1305 $marge['r'] = $this->style->value['border']['r']['width'] + $this->style->value['padding']['r']+0.03;
1306 $marge['t'] = $this->style->value['border']['t']['width'] + $this->style->value['padding']['t']+0.03;
1307 $marge['b'] = $this->style->value['border']['b']['width'] + $this->style->value['padding']['b']+0.03;
1308
1309 $x = $this->style->value['x'];
1310 $y = $this->style->value['y'];
1311 $w = $this->style->value['width']+$marge['l']+$marge['r'];
1312 $h = $this->style->value['height']+$marge['t']+$marge['b'];
1313
1314 // correction pour les margins
1315 $w+= $this->style->value['margin']['r'];
1316 $h+= $this->style->value['margin']['b'];
1317
1318 if ($this->style->value['position']!='absolute')
1319 {
1320 // position
1321 $this->pdf->x = $x+$w;
1322 $this->pdf->y = $y;
1323
1324 // position MAX
1325 $this->maxX = max($this->maxX, $x+$w);
1326 $this->maxY = max($this->maxY, $y+$h);
1327 $this->maxH = max($this->maxH, $h);
1328 }
1329 else
1330 {
1331 // position
1332 $this->pdf->x = $this->style->value['xc'];
1333 $this->pdf->y = $this->style->value['yc'];
1334
1335 $this->loadMax();
1336 }
1337
1338 $block = ($this->style->value['display']!='inline' && $this->style->value['position']!='absolute');
1339
1340 $this->style->load();
1341 $this->style->FontSet();
1342 $this->loadMargin();
1343
1344 if ($block) $this->o_BR(array());
1345 }
1346 function c_BLOCKQUOTE($param) { $this->c_DIV($param); }
1347
1348 /**
1349 * balise : BARCODE
1350 * mode : OUVERTURE
1351 *
1352 * @param array paramètres de l'élément de parsing
1353 * @return null
1354 */
1355 function o_BARCODE($param)
1356 {
1357
1358 $lst_barcode = array(
1359 'EAN13' => '0.35mm',
1360 'UPC_A' => '0.35mm',
1361 'CODE39' => '1.00mm',
1362 );
1363 if (isset($param['type'])) $param['type'] = strtoupper($param['type']);
1364
1365 if (!isset($param['type']) || !isset($lst_barcode[$param['type']])) $param['type']=='CODE39';
1366 if (!isset($param['value'])) $param['value'] = 0;
1367 if (!isset($param['bar_w'])) $param['bar_w'] = $lst_barcode[$param['type']];
1368 if (!isset($param['bar_h'])) $param['bar_h'] = '10mm';
1369
1370 if (!isset($param['style']['color'])) $param['style']['color'] = '#000000';
1371 $param['style']['background-color'] = $param['style']['color'];
1372
1373 $this->style->save();
1374 $this->style->analyse('barcode', $param);
1375 $this->style->setPosition($this->pdf->x, $this->pdf->y);
1376 $this->style->FontSet();
1377
1378
1379 $x = $this->pdf->getX();
1380 $y = $this->pdf->getY();
1381 $w = $this->style->ConvertToMM($param['bar_w']);
1382 $h = $this->style->ConvertToMM($param['bar_h']);
1383
1384 $infos = $this->pdf->{'BARCODE_'.$param['type']}($x, $y, $param['value'], $h, $w);
1385
1386 // position maximale globale
1387 $this->maxX = max($this->maxX, $x+$infos[0]);
1388 $this->maxY = max($this->maxY, $y+$infos[1]);
1389 $this->maxH = max($this->maxH, $infos[1]);
1390
1391 $this->pdf->setX($x+$infos[0]);
1392
1393 $this->style->load();
1394 $this->style->FontSet();
1395 }
1396
1397 /**
1398 * balise : BARCODE
1399 * mode : FERMETURE
1400 *
1401 * @param array paramètres de l'élément de parsing
1402 * @return null
1403 */
1404 function c_BARCODE($param)
1405 {
1406 // completement inutile
1407 }
1408
1409 /**
1410 * balise : BOOKMARK
1411 * mode : OUVERTURE
1412 *
1413 * @param array paramètres de l'élément de parsing
1414 * @return null
1415 */
1416 function o_BOOKMARK($param)
1417 {
1418 $titre = isset($param['title']) ? trim($param['title']) : '';
1419 $level = isset($param['level']) ? floor($param['level']) : 0;
1420
1421 if ($level<0) $level = 0;
1422 if ($titre) $this->pdf->Bookmark($titre, $level, -1);
1423 }
1424
1425 /**
1426 * balise : BOOKMARK
1427 * mode : FERMETURE
1428 *
1429 * @param array paramètres de l'élément de parsing
1430 * @return null
1431 */
1432 function c_BOOKMARK($param)
1433 {
1434 // completement inutile
1435 }
1436
1437 /**
1438 * balise : WRITE
1439 * mode : OUVERTURE
1440 *
1441 * @param array paramètres de l'élément de parsing
1442 * @return null
1443 */
1444 function o_WRITE($param)
1445 {
1446 $fill = false; //($this->style->value['background']['color']!=null);
1447
1448 // récupération du texte à écrire, et conversion
1449 $txt = $param['txt'];
1450 $txt = str_replace('&euro;', '€', $txt);
1451
1452 if ($this->isAfterFloat)
1453 {
1454 $txt = preg_replace('/^([\s]*)([^\s])/isU', '$2', $txt);
1455 $this->isAfterFloat = false;
1456 }
1457
1458 $txt = html_entity_decode($txt, ENT_QUOTES, 'ISO-8859-15');
1459// $txt = utf8_decode(html_entity_decode($txt, ENT_QUOTES, 'UTF-8'));
1460
1461 $txt = str_replace('[[page_cu]]', $this->pdf->PageNo(), $txt);
1462
1463 // tailles du texte
1464 $h = 1.08*$this->style->value['font-size'];
1465 $dh = $h*$this->style->value['mini-decal'];
1466
1467 $w = $this->pdf->GetStringWidth($txt);
1468
1469 // identification de l'alignement
1470 $align = 'L';
1471 if ($this->style->value['text-align']!='left')
1472 {
1473 $w = $this->style->value['width'];
1474 if ($this->style->value['text-align']=='center') $align = 'C';
1475 if ($this->style->value['text-align']=='right') $align = 'R';
1476 }
1477
1478 $maxX = 0; // plus grande largeur du texte apres retour à la ligne
1479 $x = $this->pdf->getX(); // position du texte
1480 $y = $this->pdf->getY();
1481 $w = $this->pdf->GetStringWidth($txt); // largeur du texte
1482 list($left, $right) = $this->getMargins($y); // marges autorisees
1483 $nb = 0; // nbr de lignes découpées
1484
1485 // tant que ca ne rentre pas sur la ligne et qu'on a du texte => on découpe
1486 while($x+$w>$right && $x<$right && strlen($txt))
1487 {
1488 // liste des mots
1489 $lst = explode(' ', $txt);
1490
1491 // trouver une phrase qui rentre dans la largeur, en ajoutant les mots 1 à 1
1492 $i=0;
1493 $old = '';
1494 $str = $lst[0];
1495 while(($x+$this->pdf->GetStringWidth($str))<=$right)
1496 {
1497 unset($lst[$i]);
1498 $old = $str;
1499
1500 $i++;
1501 $str.= ' '.$lst[$i];
1502 }
1503 $str = $old;
1504
1505 // si rien de rentre, et que le premier mot ne rentre de toute facon pas dans une ligne, on le force...
1506 if ($i==0 && (($left+$this->pdf->GetStringWidth($lst[0]))>=$right))
1507 {
1508 $str = $lst[0];
1509 unset($lst[0]);
1510 }
1511
1512 // récupération des mots restant, et calcul de la largeur
1513 $txt = implode(' ', $lst);
1514 $w = $this->pdf->GetStringWidth($str);
1515
1516 // ecriture du bout de phrase extrait et qui rentre
1517 $wc = ($align=='L' ? $w : $this->style->value['width']);
1518 if ($right - $left<$wc) $wc = $right - $left;
1519 $this->pdf->Cell($wc, $h+$dh, $str, 0, 0, $align, $fill, $this->inLink);
1520 $this->maxH = max($this->maxH, $this->style->getLineHeight());
1521
1522 // détermination de la largeur max
1523 $maxX = max($maxX, $this->pdf->getX());
1524
1525 // nouvelle position et nouvelle largeur pour la boucle
1526 $w = $this->pdf->GetStringWidth($txt);
1527 $y = $this->pdf->getY();
1528 $x = $this->pdf->getX();
1529
1530 // si il reste du text à afficher
1531 if (strlen($txt))
1532 {
1533 // retour à la ligne
1534 $this->o_BR(array('style' => ''));
1535
1536 $y = $this->pdf->getY();
1537 $x = $this->pdf->getX();
1538
1539 // si la prochaine ligne ne rentre pas dans la page => nouvelle page
1540 if ($y + $h>$this->pdf->h - $this->pdf->bMargin) $this->setNewPage();
1541
1542 // ligne suplémentaire. au bout de 1000 : trop long => erreur
1543 $nb++;
1544 if ($nb>1000) HTML2PDF::makeError(2, __FILE__, __LINE__, array($txt, $right-$left, $this->pdf->GetStringWidth($txt)));
1545
1546 list($left, $right) = $this->getMargins($y); // marges autorisees
1547 }
1548 }
1549
1550 // si il reste du text apres découpe, c'est qu'il rentre direct => on l'affiche
1551 if (strlen($txt))
1552 {
1553 $this->pdf->Cell(($align=='L' ? $w : $this->style->value['width']), $h+$dh, $txt, 0, 0, $align, $fill, $this->inLink);
1554 $this->maxH = max($this->maxH, $this->style->getLineHeight());
1555 }
1556
1557 // détermination des positions MAX
1558 $maxX = max($maxX, $this->pdf->getX());
1559 $maxY = $this->pdf->getY()+$h;
1560
1561 // position maximale globale
1562 $this->maxX = max($this->maxX, $maxX);
1563 $this->maxY = max($this->maxY, $maxY);
1564 }
1565
1566 /**
1567 * tracer une image
1568 *
1569 * @param string nom du fichier source
1570 * @return null
1571 */
1572 function Image($src, $sub_li=false)
1573 {
1574 // est-ce que c'est une image ?
1575 $infos=@GetImageSize($src);
1576
1577 if (count($infos)<2)
1578 {
1579 HTML2PDF::makeError(6, __FILE__, __LINE__, $src);
1580 return false;
1581 }
1582
1583 // récupération des dimensions dans l'unité du PDF
1584 $wi = $infos[0]/$this->pdf->k;
1585 $hi = $infos[1]/$this->pdf->k;
1586
1587 // détermination des dimensions d'affichage en fonction du style
1588 if ($this->style->value['width'] && $this->style->value['height'])
1589 {
1590 $w = $this->style->value['width'];
1591 $h = $this->style->value['height'];
1592 }
1593 else if ($this->style->value['width'])
1594 {
1595 $w = $this->style->value['width'];
1596 $h = $hi*$w/$wi;
1597
1598 }
1599 else if ($this->style->value['height'])
1600 {
1601 $h = $this->style->value['height'];
1602 $w = $wi*$h/$hi;
1603 }
1604 else
1605 {
1606 $w = 72./96.*$wi;
1607 $h = 72./96.*$hi;
1608 }
1609
1610 // detection du float
1611 $float = $this->style->getFloat();
1612 if ($float && $this->maxH) $this->o_BR(array());
1613
1614 // position d'affichage
1615 $x = $this->pdf->getX();
1616 $y = $this->pdf->getY();
1617
1618 // si l'image ne rentre pas dans la page => nouvelle page
1619 if ($y + $h>$this->pdf->h - $this->pdf->bMargin)
1620 {
1621 $this->setNewPage();
1622 $x = $this->pdf->getX();
1623 $y = $this->pdf->getY();
1624 }
1625
1626 // correction pour l'affichage d'une puce image
1627 $hT = 0.80*$this->style->value['font-size'];
1628 if ($sub_li && $h<$hT)
1629 {
1630 $y+=($hT-$h);
1631 }
1632
1633 $yc = $y-$this->style->value['margin']['t'];
1634
1635 // détermination de la position réelle d'affichage en fonction du text-align du parent
1636 $old = isset($this->style->table[count($this->style->table)-1]) ? $this->style->table[count($this->style->table)-1] : $this->style->value;
1637
1638 if ( $old['width'])
1639 {
1640 $parent_w = $old['width'];
1641 $parent_x = $x;
1642 }
1643 else
1644 {
1645 $parent_w = $this->pdf->w - $this->pdf->lMargin - $this->pdf->rMargin;
1646 $parent_x = $this->pdf->lMargin;
1647 }
1648
1649 if ($float)
1650 {
1651 list($lx, $rx) = $this->getMargins($yc);
1652 $parent_x = $lx;
1653 $parent_w = $rx-$lx;
1654 }
1655
1656 if ($parent_w>$w && $float!='left')
1657 {
1658 if ($float=='right' || $this->style->value['text-align']=='right') $x = $parent_x + $parent_w - $w-$this->style->value['margin']['r']-$this->style->value['margin']['l'];
1659 else if ($this->style->value['text-align']=='center') $x = $parent_x + 0.5*($parent_w - $w);
1660 }
1661
1662 // affichage de l'image, et positionnement à la suite
1663 if (!$this->sub_part && !$this->isSubPart) $this->pdf->Image($src, $x, $y, $w, $h, '', $this->inLink);
1664
1665 $x-= $this->style->value['margin']['l'];
1666 $y-= $this->style->value['margin']['t'];
1667 $w+= $this->style->value['margin']['l'] + $this->style->value['margin']['r'];
1668 $h+= $this->style->value['margin']['t'] + $this->style->value['margin']['b'];
1669
1670 if ($float=='left')
1671 {
1672 $this->maxX = max($this->maxX, $x+$w);
1673 $this->maxY = max($this->maxY, $y+$h);
1674
1675 $this->addMargins($float, $x, $y, $x+$w, $y+$h);
1676
1677 list($lx, $rx) = $this->getMargins($yc);
1678 $this->pdf->x = $lx;
1679 $this->pdf->y = $yc;
1680 }
1681 else if ($float=='right')
1682 {
1683// $this->maxX = max($this->maxX, $x+$w);
1684 $this->maxY = max($this->maxY, $y+$h);
1685
1686 $this->addMargins($float, $x, $y, $x+$w, $y+$h);
1687
1688 list($lx, $rx) = $this->getMargins($yc);
1689 $this->pdf->x = $lx;
1690 $this->pdf->y = $yc;
1691 }
1692 else
1693 {
1694 $this->pdf->SetX($x+$w);
1695 $this->maxX = max($this->maxX, $x+$w);
1696 $this->maxY = max($this->maxY, $y+$h);
1697 $this->maxH = max($this->maxH, $h);
1698 }
1699 }
1700
1701 /**
1702 * Tracer un rectanble
1703 *
1704 * @param float position X
1705 * @param float position Y
1706 * @param float Largeur
1707 * @param float Hauteur
1708 * @param array Tableau de style de définition des borders
1709 * @param float padding - marge intérieur au rectangle => non utile mais on le passe en paramètre
1710 * @param float margin - marge exterieur au rectangle
1711 * @param array Tableau de style de définition du background
1712 * @return null
1713 */
1714 function Rectangle($x, $y, $w, $h, $border, $padding, $margin, $background)
1715 {
1716 if ($this->sub_part || $this->isSubPart) return false;
1717 if ($h===null) return false;
1718
1719 $x+= $margin;
1720 $y+= $margin;
1721 $w-= $margin*2;
1722 $h-= $margin*2;
1723
1724 // récupération des radius
1725 $radius_h = $border['radius'][0];
1726 $radius_v = $border['radius'][1];
1727
1728 // verification des coins en radius
1729 $coin_TL = ($radius_h && $radius_v && $radius_v>$border['t']['width'] && $radius_h>$border['l']['width']) ? array($radius_h, $radius_v) : null;
1730 $coin_TR = ($radius_h && $radius_v && $radius_v>$border['t']['width'] && $radius_h>$border['r']['width']) ? array($radius_h, $radius_v) : null;
1731 $coin_BL = ($radius_h && $radius_v && $radius_v>$border['b']['width'] && $radius_h>$border['l']['width']) ? array($radius_h, $radius_v) : null;
1732 $coin_BR = ($radius_h && $radius_v && $radius_v>$border['b']['width'] && $radius_h>$border['r']['width']) ? array($radius_h, $radius_v) : null;
1733
1734
1735
1736 // traitement de la couleur de fond
1737 $STYLE = '';
1738 if ($background['color'])
1739 {
1740 $this->pdf->SetFillColor($background['color'][0], $background['color'][1], $background['color'][2]);
1741 $STYLE.= 'F';
1742 }
1743
1744 if ($STYLE)
1745 {
1746 $this->pdf->clippingPathOpen($x, $y, $w, $h, $coin_TL,$coin_TR, $coin_BL, $coin_BR);
1747 $this->pdf->Rect($x, $y, $w, $h, $STYLE);
1748 $this->pdf->clippingPathClose();
1749 }
1750
1751 // traitement de l'image de fond
1752 if ($background['image'])
1753 {
1754 $i_name = $background['image'];
1755 $i_position = $background['position']!==null ? $background['position'] : array(0, 0);
1756 $i_repeat = $background['repeat']!==null ? $background['repeat'] : array(true, true);
1757
1758 // taile du fond (il faut retirer les borders
1759 $b_x = $x;
1760 $b_y = $y;
1761 $b_w = $w;
1762 $b_h = $h;
1763
1764 if ($border['b']['width']) { $b_h-= $border['b']['width']; }
1765 if ($border['l']['width']) { $b_w-= $border['l']['width']; $b_x+= $border['l']['width']; }
1766 if ($border['t']['width']) { $b_h-= $border['t']['width']; $b_y+= $border['t']['width']; }
1767 if ($border['r']['width']) { $b_w-= $border['r']['width']; }
1768
1769 // est-ce que c'est une image ?
1770 $i_infos=@GetImageSize($i_name);
1771
1772 if (count($i_infos)<2)
1773 {
1774 HTML2PDF::makeError(6, __FILE__, __LINE__, $i_name);
1775 return false;
1776 }
1777
1778 // récupération des dimensions dans l'unité du PDF
1779 $i_width = 72./96.*$i_infos[0]/$this->pdf->k;
1780 $i_height = 72./96.*$i_infos[1]/$this->pdf->k;
1781
1782 if ($i_repeat[0]) $i_position[0] = $b_x;
1783 else if(preg_match('/^([-]?[0-9\.]+)%/isU', $i_position[0], $match)) $i_position[0] = $b_x + $match[1]*($b_w-$i_width)/100;
1784 else $i_position[0] = $b_x+$i_position[0];
1785
1786 if ($i_repeat[1]) $i_position[1] = $b_y;
1787 else if(preg_match('/^([-]?[0-9\.]+)%/isU', $i_position[1], $match)) $i_position[1] = $b_y + $match[1]*($b_h-$i_height)/100;
1788 else $i_position[1] = $b_y+$i_position[1];
1789
1790 $i_x_min = $b_x;
1791 $i_x_max = $b_x+$b_w;
1792 $i_y_min = $b_y;
1793 $i_y_max = $b_y+$b_h;
1794
1795 if (!$i_repeat[0] && !$i_repeat[1])
1796 {
1797 $i_x_min = $i_position[0]; $i_x_max = $i_position[0]+$i_width;
1798 $i_y_min = $i_position[1]; $i_y_max = $i_position[1]+$i_height;
1799 }
1800 else if ($i_repeat[0] && !$i_repeat[1])
1801 {
1802 $i_y_min = $i_position[1]; $i_y_max = $i_position[1]+$i_height;
1803 }
1804 elseif (!$i_repeat[0] && $i_repeat[1])
1805 {
1806 $i_x_min = $i_position[0]; $i_x_max = $i_position[0]+$i_width;
1807 }
1808
1809 if (is_array($coin_TL)) { $coin_TL[0]-= $border['l']['width']; $coin_TL[1]-= $border['t']['width']; }
1810 if (is_array($coin_TR)) { $coin_TR[0]-= $border['r']['width']; $coin_TR[1]-= $border['t']['width']; }
1811 if (is_array($coin_BL)) { $coin_BL[0]-= $border['l']['width']; $coin_BL[1]-= $border['b']['width']; }
1812 if (is_array($coin_BR)) { $coin_BR[0]-= $border['r']['width']; $coin_BR[1]-= $border['b']['width']; }
1813
1814 $this->pdf->clippingPathOpen($b_x, $b_y, $b_w, $b_h, $coin_TL, $coin_TR, $coin_BL, $coin_BR);
1815 for ($i_y=$i_y_min; $i_y<$i_y_max; $i_y+=$i_height)
1816 {
1817 for ($i_x=$i_x_min; $i_x<$i_x_max; $i_x+=$i_width)
1818 {
1819 $c_x = null;
1820 $c_y = null;
1821 $c_w = $i_width;
1822 $c_h = $i_height;
1823 if ($i_y_max-$i_y<$i_height)
1824 {
1825 $c_x = $i_x;
1826 $c_y = $i_y;
1827 $c_h = $i_y_max-$i_y;
1828 }
1829 if ($i_x_max-$i_x<$i_width)
1830 {
1831 $c_x = $i_x;
1832 $c_y = $i_y;
1833 $c_w = $i_x_max-$i_x;
1834 }
1835
1836 $this->pdf->Image($i_name, $i_x, $i_y, $i_width, $i_height, '', '');
1837 }
1838 }
1839 $this->pdf->clippingPathClose();
1840 }
1841
1842 $x-= 0.01;
1843 $y-= 0.01;
1844 $w+= 0.02;
1845 $h+= 0.02;
1846 if ($border['b']['width']) $border['b']['width']+= 0.02;
1847 if ($border['l']['width']) $border['l']['width']+= 0.02;
1848 if ($border['t']['width']) $border['t']['width']+= 0.02;
1849 if ($border['r']['width']) $border['r']['width']+= 0.02;
1850
1851 if ($border['b']['width'] && $border['b']['color'][0]!==null)
1852 {
1853 $pt = array();
1854 $pt[] = $x+$w; $pt[] = $y+$h;
1855 $pt[] = $x+$w-$border['r']['width']; $pt[] = $y+$h;
1856 $pt[] = $x+$border['l']['width']; $pt[] = $y+$h;
1857 $pt[] = $x; $pt[] = $y+$h;
1858 $pt[] = $x+$border['l']['width']; $pt[] = $y+$h-$border['b']['width'];
1859 $pt[] = $x+$w-$border['r']['width']; $pt[] = $y+$h-$border['b']['width'];
1860
1861 $bord = 3;
1862 if (is_array($coin_BL))
1863 {
1864 $bord-=2;
1865 $pt[4] += $radius_h-$border['l']['width'];
1866 $pt[8] += $radius_h-$border['l']['width'];
1867 unset($pt[6]);unset($pt[7]);
1868 }
1869 if (is_array($coin_BR))
1870 {
1871 $courbe = array();
1872 $courbe[] = $x+$w; $courbe[] = $y+$h-$radius_v;
1873 $courbe[] = $x+$w-$radius_h; $courbe[] = $y+$h;
1874 $courbe[] = $x+$w-$border['r']['width']; $courbe[] = $y+$h-$radius_v;
1875 $courbe[] = $x+$w-$radius_h; $courbe[] = $y+$h-$border['b']['width'];
1876 $courbe[] = $x+$w-$radius_h; $courbe[] = $y+$h-$radius_v;
1877 $this->Courbe($courbe, $border['b']['color']);
1878
1879 $bord-=1;
1880 $pt[2] -= $radius_h-$border['r']['width'];
1881 $pt[10]-= $radius_h-$border['r']['width'];
1882 unset($pt[0]);unset($pt[1]);
1883
1884 }
1885
1886 $pt = array_values($pt);
1887 $this->Line($pt, $border['b']['color'], $border['b']['type'], $border['b']['width'], $bord);
1888 }
1889
1890 if ($border['l']['width'] && $border['l']['color'][0]!==null)
1891 {
1892 $pt = array();
1893 $pt[] = $x; $pt[] = $y+$h;
1894 $pt[] = $x; $pt[] = $y+$h-$border['b']['width'];
1895 $pt[] = $x; $pt[] = $y+$border['t']['width'];
1896 $pt[] = $x; $pt[] = $y;
1897 $pt[] = $x+$border['l']['width']; $pt[] = $y+$border['t']['width'];
1898 $pt[] = $x+$border['l']['width']; $pt[] = $y+$h-$border['b']['width'];
1899
1900 $bord = 3;
1901 if (is_array($coin_BL))
1902 {
1903 $courbe = array();
1904 $courbe[] = $x+$radius_h; $courbe[] = $y+$h;
1905 $courbe[] = $x; $courbe[] = $y+$h-$radius_v;
1906 $courbe[] = $x+$radius_h; $courbe[] = $y+$h-$border['b']['width'];
1907 $courbe[] = $x+$border['l']['width']; $courbe[] = $y+$h-$radius_v;
1908 $courbe[] = $x+$radius_h; $courbe[] = $y+$h-$radius_v;
1909 $this->Courbe($courbe, $border['l']['color']);
1910
1911 $bord-=1;
1912 $pt[3] -= $radius_v-$border['b']['width'];
1913 $pt[11]-= $radius_v-$border['b']['width'];
1914 unset($pt[0]);unset($pt[1]);
1915 }
1916 if (is_array($coin_TL))
1917 {
1918 $bord-=2;
1919 $pt[5] += $radius_v-$border['t']['width'];
1920 $pt[9] += $radius_v-$border['t']['width'];
1921 unset($pt[6]);unset($pt[7]);
1922 }
1923
1924 $pt = array_values($pt);
1925 $this->Line($pt, $border['l']['color'], $border['l']['type'], $border['l']['width'], $bord);
1926 }
1927
1928 if ($border['t']['width'] && $border['t']['color'][0]!==null)
1929 {
1930 $pt = array();
1931 $pt[] = $x; $pt[] = $y;
1932 $pt[] = $x+$border['l']['width']; $pt[] = $y;
1933 $pt[] = $x+$w-$border['r']['width']; $pt[] = $y;
1934 $pt[] = $x+$w; $pt[] = $y;
1935 $pt[] = $x+$w-$border['r']['width']; $pt[] = $y+$border['t']['width'];
1936 $pt[] = $x+$border['l']['width']; $pt[] = $y+$border['t']['width'];
1937
1938 $bord = 3;
1939 if (is_array($coin_TL))
1940 {
1941 $courbe = array();
1942 $courbe[] = $x; $courbe[] = $y+$radius_v;
1943 $courbe[] = $x+$radius_h; $courbe[] = $y;
1944 $courbe[] = $x+$border['l']['width']; $courbe[] = $y+$radius_v;
1945 $courbe[] = $x+$radius_h; $courbe[] = $y+$border['t']['width'];
1946 $courbe[] = $x+$radius_h; $courbe[] = $y+$radius_v;
1947 $this->Courbe($courbe, $border['t']['color']);
1948
1949 $bord-=1;
1950 $pt[2] += $radius_h-$border['l']['width'];
1951 $pt[10]+= $radius_h-$border['l']['width'];
1952 unset($pt[0]);unset($pt[1]);
1953 }
1954 if (is_array($coin_TR))
1955 {
1956 $bord-=2;
1957 $pt[4] -= $radius_h-$border['r']['width'];
1958 $pt[8] -= $radius_h-$border['r']['width'];
1959 unset($pt[6]);unset($pt[7]);
1960 }
1961
1962 $pt = array_values($pt);
1963 $this->Line($pt, $border['t']['color'], $border['t']['type'], $border['t']['width'], $bord);
1964 }
1965
1966 if ($border['r']['width'] && $border['r']['color'][0]!==null)
1967 {
1968 $pt = array();
1969 $pt[] = $x+$w; $pt[] = $y;
1970 $pt[] = $x+$w; $pt[] = $y+$border['t']['width'];
1971 $pt[] = $x+$w; $pt[] = $y+$h-$border['b']['width'];
1972 $pt[] = $x+$w; $pt[] = $y+$h;
1973 $pt[] = $x+$w-$border['r']['width']; $pt[] = $y+$h-$border['b']['width'];
1974 $pt[] = $x+$w-$border['r']['width']; $pt[] = $y+$border['t']['width'];
1975
1976 $bord = 3;
1977 if (is_array($coin_TR))
1978 {
1979 $courbe = array();
1980 $courbe[] = $x+$w-$radius_h; $courbe[] = $y;
1981 $courbe[] = $x+$w; $courbe[] = $y+$radius_v;
1982 $courbe[] = $x+$w-$radius_h; $courbe[] = $y+$border['t']['width'];
1983 $courbe[] = $x+$w-$border['r']['width']; $courbe[] = $y+$radius_v;
1984 $courbe[] = $x+$w-$radius_h; $courbe[] = $y+$radius_v;
1985 $this->Courbe($courbe, $border['r']['color']);
1986
1987 $bord-=1;
1988 $pt[3] += $radius_v-$border['t']['width'];
1989 $pt[11]+= $radius_v-$border['t']['width'];
1990 unset($pt[0]);unset($pt[1]);
1991 }
1992 if (is_array($coin_BR))
1993 {
1994 $bord-=2;
1995 $pt[5] -= $radius_v-$border['b']['width'];
1996 $pt[9] -= $radius_v-$border['b']['width'];
1997 unset($pt[6]);unset($pt[7]);
1998 }
1999
2000 $pt = array_values($pt);
2001 $this->Line($pt, $border['r']['color'], $border['r']['type'], $border['r']['width'], $bord);
2002 }
2003
2004 if ($background) $this->pdf->SetFillColor($background['color'][0], $background['color'][1], $background['color'][2]);
2005 }
2006
2007 function Courbe($pt, $color)
2008 {
2009 $this->pdf->SetFillColor($color[0], $color[1], $color[2]);
2010
2011 $this->pdf->drawCourbe($pt[0], $pt[1], $pt[2], $pt[3], $pt[4], $pt[5], $pt[6], $pt[7], $pt[8], $pt[9]);
2012 }
2013
2014 /**
2015 * Tracer une ligne epaisse défini par ses points avec des extreminites en biseau
2016 *
2017 * @param array liste des points definissant le tour de la ligne
2018 * @param float couleur RVB
2019 * @param string type de ligne
2020 * @param float largeur de la ligne
2021 * @return null
2022 */
2023 function Line($pt, $color, $type, $width, $bord=3)
2024 {
2025 $this->pdf->SetFillColor($color[0], $color[1], $color[2]);
2026 if ($type=='dashed' || $type=='dotted')
2027 {
2028 if ($bord==1)
2029 {
2030 $tmp = array(); $tmp[]=$pt[0]; $tmp[]=$pt[1]; $tmp[]=$pt[2]; $tmp[]=$pt[3]; $tmp[]=$pt[8]; $tmp[]=$pt[9];
2031 $this->pdf->Polygon($tmp, 'F');
2032
2033 $tmp = array(); $tmp[]=$pt[2]; $tmp[]=$pt[3]; $tmp[]=$pt[4]; $tmp[]=$pt[5]; $tmp[]=$pt[6]; $tmp[]=$pt[7]; $tmp[]=$pt[8]; $tmp[]=$pt[9];
2034 $pt = $tmp;
2035 }
2036 else if ($bord==2)
2037 {
2038 $tmp = array(); $tmp[]=$pt[2]; $tmp[]=$pt[3]; $tmp[]=$pt[4]; $tmp[]=$pt[5]; $tmp[]=$pt[6]; $tmp[]=$pt[7];
2039 $this->pdf->Polygon($tmp, 'F');
2040
2041 $tmp = array(); $tmp[]=$pt[0]; $tmp[]=$pt[1]; $tmp[]=$pt[2]; $tmp[]=$pt[3]; $tmp[]=$pt[6]; $tmp[]=$pt[7]; $tmp[]=$pt[8]; $tmp[]=$pt[9];
2042 $pt = $tmp;
2043 }
2044 else if ($bord==3)
2045 {
2046 $tmp = array(); $tmp[]=$pt[0]; $tmp[]=$pt[1]; $tmp[]=$pt[2]; $tmp[]=$pt[3]; $tmp[]=$pt[10]; $tmp[]=$pt[11];
2047 $this->pdf->Polygon($tmp, 'F');
2048
2049 $tmp = array(); $tmp[]=$pt[4]; $tmp[]=$pt[5]; $tmp[]=$pt[6]; $tmp[]=$pt[7]; $tmp[]=$pt[8]; $tmp[]=$pt[9];
2050 $this->pdf->Polygon($tmp, 'F');
2051
2052 $tmp = array(); $tmp[]=$pt[2]; $tmp[]=$pt[3]; $tmp[]=$pt[4]; $tmp[]=$pt[5]; $tmp[]=$pt[8]; $tmp[]=$pt[9]; $tmp[]=$pt[10]; $tmp[]=$pt[11];
2053 $pt = $tmp;
2054 }
2055
2056 if ($pt[2]==$pt[0])
2057 {
2058 $l = abs(($pt[3]-$pt[1])*0.5);
2059 $px = 0;
2060 $py = $width;
2061 $x1 = $pt[0]; $y1 = ($pt[3]+$pt[1])*0.5;
2062 $x2 = $pt[6]; $y2 = ($pt[7]+$pt[5])*0.5;
2063 }
2064 else
2065 {
2066 $l = abs(($pt[2]-$pt[0])*0.5);
2067 $px = $width;
2068 $py = 0;
2069 $x1 = ($pt[2]+$pt[0])*0.5; $y1 = $pt[1];
2070 $x2 = ($pt[6]+$pt[4])*0.5; $y2 = $pt[7];
2071 }
2072 if ($type=='dashed')
2073 {
2074 $px = $px*3.;
2075 $py = $py*3.;
2076 }
2077 $mode = ($l/($px+$py)<.5);
2078
2079 for($i=0; $l-($px+$py)*($i-0.5)>0; $i++)
2080 {
2081 if (($i%2)==$mode)
2082 {
2083 $j = $i-0.5;
2084 $lx1 = $px*($j); if ($lx1<-$l) $lx1 =-$l;
2085 $ly1 = $py*($j); if ($ly1<-$l) $ly1 =-$l;
2086 $lx2 = $px*($j+1); if ($lx2>$l) $lx2 = $l;
2087 $ly2 = $py*($j+1); if ($ly2>$l) $ly2 = $l;
2088
2089 $tmp = array();
2090 $tmp[] = $x1+$lx1; $tmp[] = $y1+$ly1;
2091 $tmp[] = $x1+$lx2; $tmp[] = $y1+$ly2;
2092 $tmp[] = $x2+$lx2; $tmp[] = $y2+$ly2;
2093 $tmp[] = $x2+$lx1; $tmp[] = $y2+$ly1;
2094 $this->pdf->Polygon($tmp, 'F');
2095
2096 if ($j>0)
2097 {
2098 $tmp = array();
2099 $tmp[] = $x1-$lx1; $tmp[] = $y1-$ly1;
2100 $tmp[] = $x1-$lx2; $tmp[] = $y1-$ly2;
2101 $tmp[] = $x2-$lx2; $tmp[] = $y2-$ly2;
2102 $tmp[] = $x2-$lx1; $tmp[] = $y2-$ly1;
2103 $this->pdf->Polygon($tmp, 'F');
2104 }
2105 }
2106 }
2107 }
2108 else if ($type=='solid')
2109 {
2110 $this->pdf->Polygon($pt, 'F');
2111 }
2112 }
2113
2114 /**
2115 * balise : BR
2116 * mode : OUVERTURE
2117 *
2118 * @param array paramètres de l'élément de parsing
2119 * @return null
2120 */
2121 function o_BR($param)
2122 {
2123 $h = $this->style->getLineHeight();
2124 $h = max($this->maxH, $h);
2125 $y = $this->pdf->getY();
2126
2127 // si la ligne est vide, la position maximale n'a pas été mise à jour => on la met à jour
2128 if ($this->maxH==0) $this->maxY = max($this->maxY, $y+$h);
2129
2130 // si le saut de ligne rentre => on le prend en compte, sinon nouvelle page
2131 if ($y+$h<$this->pdf->h - $this->pdf->bMargin) $this->setNewLine($h);
2132 else $this->setNewPage();
2133
2134 $this->maxH = 0;
2135 }
2136
2137 /**
2138 * balise : HR
2139 * mode : OUVERTURE
2140 *
2141 * @param array paramètres de l'élément de parsing
2142 * @return null
2143 */
2144 function o_HR($param)
2145 {
2146 if ($this->maxH) $this->o_BR($param);
2147
2148 $f_size = $this->style->value['font-size'];
2149 $this->style->value['font-size']=$f_size*0.5; $this->o_BR($param);
2150 $this->style->value['font-size']=0;
2151
2152 $param['style']['width'] = '100%';
2153
2154 $this->style->save();
2155 $this->style->value['height']=$this->style->ConvertToMM('1mm');
2156
2157 $this->style->analyse('hr', $param);
2158 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2159 $this->style->FontSet();
2160
2161 $h = $this->style->value['height'];
2162 if ($h) $h-= $this->style->value['border']['t']['width']+$this->style->value['border']['b']['width'];
2163 if ($h<=0) $h = $this->style->value['border']['t']['width']+$this->style->value['border']['b']['width'];
2164
2165 $this->Rectangle($this->pdf->x, $this->pdf->y, $this->style->value['width'], $h, $this->style->value['border'], 0, 0, $this->style->value['background']);
2166 $this->maxH = $h;
2167
2168 $this->style->load();
2169 $this->style->FontSet();
2170
2171 $this->o_BR($param);
2172
2173 $this->style->value['font-size']=$f_size*0.5; $this->o_BR($param);
2174 $this->style->value['font-size']=$f_size;
2175 }
2176
2177 /**
2178 * balise : B
2179 * mode : OUVERTURE
2180 *
2181 * @param array paramètres de l'élément de parsing
2182 * @return null
2183 */
2184 function o_B($param, $other = 'b')
2185 {
2186 $this->style->save();
2187 $this->style->value['font-bold'] = true;
2188 $this->style->analyse($other, $param);
2189 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2190 $this->style->FontSet();
2191 }
2192 function o_STRONG($param) { $this->o_B($param, 'strong'); }
2193
2194 /**
2195 * balise : B
2196 * mode : FERMETURE
2197 *
2198 * @param array paramètres de l'élément de parsing
2199 * @return null
2200 */
2201 function c_B($param)
2202 {
2203 $this->style->load();
2204 $this->style->FontSet();
2205 }
2206 function c_STRONG($param) { $this->c_B($param); }
2207
2208 /**
2209 * balise : I
2210 * mode : OUVERTURE
2211 *
2212 * @param array paramètres de l'élément de parsing
2213 * @return null
2214 */
2215 function o_I($param, $other = 'i')
2216 {
2217 $this->style->save();
2218 $this->style->value['font-italic'] = true;
2219 $this->style->analyse($other, $param);
2220 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2221 $this->style->FontSet();
2222 }
2223 function o_ADDRESS($param) { $this->o_I($param, 'address'); }
2224 function o_CITE($param) { $this->o_I($param, 'cite'); }
2225 function o_EM($param) { $this->o_I($param, 'em'); }
2226 function o_SAMP($param) { $this->o_I($param, 'samp'); }
2227
2228 /**
2229 * balise : I
2230 * mode : FERMETURE
2231 *
2232 * @param array paramètres de l'élément de parsing
2233 * @return null
2234 */
2235 function c_I($param)
2236 {
2237 $this->style->load();
2238 $this->style->FontSet();
2239 }
2240 function c_ADDRESS($param) { $this->c_I($param); }
2241 function c_CITE($param) { $this->c_I($param); }
2242 function c_EM($param) { $this->c_I($param); }
2243 function c_SAMP($param) { $this->c_I($param); }
2244
2245 /**
2246 * balise : S
2247 * mode : OUVERTURE
2248 *
2249 * @param array paramètres de l'élément de parsing
2250 * @return null
2251 */
2252 function o_S($param)
2253 {
2254 $this->style->save();
2255 $this->style->value['font-linethrough'] = true;
2256 $this->style->analyse('s', $param);
2257 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2258 $this->style->FontSet();
2259 }
2260
2261 /**
2262 * balise : S
2263 * mode : FERMETURE
2264 *
2265 * @param array paramètres de l'élément de parsing
2266 * @return null
2267 */
2268 function c_S($param)
2269 {
2270 $this->style->load();
2271 $this->style->FontSet();
2272 }
2273
2274 /**
2275 * balise : U
2276 * mode : OUVERTURE
2277 *
2278 * @param array paramètres de l'élément de parsing
2279 * @return null
2280 */
2281 function o_U($param)
2282 {
2283 $this->style->save();
2284 $this->style->value['font-underline'] = true;
2285 $this->style->analyse('u', $param);
2286 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2287 $this->style->FontSet();
2288 }
2289
2290 /**
2291 * balise : U
2292 * mode : FERMETURE
2293 *
2294 * @param array paramètres de l'élément de parsing
2295 * @return null
2296 */
2297 function c_U($param)
2298 {
2299 $this->style->load();
2300 $this->style->FontSet();
2301 }
2302
2303 /**
2304 * balise : A
2305 * mode : OUVERTURE
2306 *
2307 * @param array paramètres de l'élément de parsing
2308 * @return null
2309 */
2310 function o_A($param)
2311 {
2312 $this->inLink = str_replace('&amp;', '&', isset($param['href']) ? $param['href'] : '');
2313
2314 if (isset($param['name']))
2315 {
2316 $nom = $param['name'];
2317 if (!isset($this->lstAncre[$nom])) $this->lstAncre[$nom] = array($this->pdf->AddLink(), false);
2318
2319 if (!$this->lstAncre[$nom][1])
2320 {
2321 $this->lstAncre[$nom][1] = true;
2322 $this->pdf->SetLink($this->lstAncre[$nom][0], -1, -1);
2323 }
2324 }
2325
2326 if (preg_match('/^#([^#]+)$/isU', $this->inLink, $match))
2327 {
2328 $nom = $match[1];
2329 if (!isset($this->lstAncre[$nom])) $this->lstAncre[$nom] = array($this->pdf->AddLink(), false);
2330
2331 $this->inLink = $this->lstAncre[$nom][0];
2332 }
2333
2334 $this->style->save();
2335 $this->style->value['font-underline'] = true;
2336 $this->style->value['color'] = array(20, 20, 250);
2337 $this->style->analyse('a', $param);
2338 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2339 $this->style->FontSet();
2340 }
2341
2342 /**
2343 * balise : A
2344 * mode : FERMETURE
2345 *
2346 * @param array paramètres de l'élément de parsing
2347 * @return null
2348 */
2349 function c_A($param)
2350 {
2351 $this->inLink = '';
2352 $this->style->load();
2353 $this->style->FontSet();
2354 }
2355
2356 /**
2357 * balise : H1
2358 * mode : OUVERTURE
2359 *
2360 * @param array paramètres de l'élément de parsing
2361 * @return null
2362 */
2363 function o_H1($param)
2364 {
2365 $this->o_BR(array());
2366 $this->style->save();
2367 $this->style->value['font-bold'] = true;
2368 $this->style->value['font-size'] = $this->style->ConvertToMM('28px');
2369 $this->style->analyse('h1', $param);
2370 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2371 $this->style->FontSet();
2372 }
2373
2374 /**
2375 * balise : H1
2376 * mode : FERMETURE
2377 *
2378 * @param array paramètres de l'élément de parsing
2379 * @return null
2380 */
2381 function c_H1($param)
2382 {
2383 $this->o_BR(array());
2384 $this->style->load();
2385 $this->style->FontSet();
2386 $this->o_BR(array());
2387 }
2388
2389 /**
2390 * balise : H2
2391 * mode : OUVERTURE
2392 *
2393 * @param array paramètres de l'élément de parsing
2394 * @return null
2395 */
2396 function o_H2($param)
2397 {
2398 $this->o_BR(array());
2399 $this->style->save();
2400 $this->style->value['font-bold'] = true;
2401 $this->style->value['font-size'] = $this->style->ConvertToMM('24px');
2402 $this->style->analyse('h2', $param);
2403 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2404 $this->style->FontSet();
2405 }
2406
2407 /**
2408 * balise : H2
2409 * mode : FERMETURE
2410 *
2411 * @param array paramètres de l'élément de parsing
2412 * @return null
2413 */
2414 function c_H2($param)
2415 {
2416 $this->o_BR(array());
2417 $this->style->load();
2418 $this->style->FontSet();
2419 $this->o_BR(array());
2420 }
2421
2422 /**
2423 * balise : H3
2424 * mode : OUVERTURE
2425 *
2426 * @param array paramètres de l'élément de parsing
2427 * @return null
2428 */
2429 function o_H3($param)
2430 {
2431 $this->o_BR(array());
2432 $this->style->save();
2433 $this->style->value['font-bold'] = true;
2434 $this->style->value['font-size'] = $this->style->ConvertToMM('20px');
2435 $this->style->analyse('h3', $param);
2436 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2437 $this->style->FontSet();
2438 }
2439
2440 /**
2441 * balise : H3
2442 * mode : FERMETURE
2443 *
2444 * @param array paramètres de l'élément de parsing
2445 * @return null
2446 */
2447 function c_H3($param)
2448 {
2449 $this->o_BR(array());
2450 $this->style->load();
2451 $this->style->FontSet();
2452 $this->o_BR(array());
2453 }
2454
2455 /**
2456 * balise : H4
2457 * mode : OUVERTURE
2458 *
2459 * @param array paramètres de l'élément de parsing
2460 * @return null
2461 */
2462 function o_H4($param)
2463 {
2464 $this->o_BR(array());
2465 $this->style->save();
2466 $this->style->value['font-bold'] = true;
2467 $this->style->value['font-size'] = $this->style->ConvertToMM('16px');
2468 $this->style->analyse('h4', $param);
2469 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2470 $this->style->FontSet();
2471 }
2472
2473 /**
2474 * balise : H4
2475 * mode : FERMETURE
2476 *
2477 * @param array paramètres de l'élément de parsing
2478 * @return null
2479 */
2480 function c_H4($param)
2481 {
2482 $this->o_BR(array());
2483 $this->style->load();
2484 $this->style->FontSet();
2485 $this->o_BR(array());
2486 }
2487
2488 /**
2489 * balise : H5
2490 * mode : OUVERTURE
2491 *
2492 * @param array paramètres de l'élément de parsing
2493 * @return null
2494 */
2495 function o_H5($param)
2496 {
2497 $this->o_BR(array());
2498 $this->style->save();
2499 $this->style->value['font-bold'] = true;
2500 $this->style->value['font-size'] = $this->style->ConvertToMM('12px');
2501 $this->style->analyse('h5', $param);
2502 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2503 $this->style->FontSet();
2504 }
2505
2506 /**
2507 * balise : H5
2508 * mode : FERMETURE
2509 *
2510 * @param array paramètres de l'élément de parsing
2511 * @return null
2512 */
2513 function c_H5($param)
2514 {
2515 $this->o_BR(array());
2516 $this->style->load();
2517 $this->style->FontSet();
2518 $this->o_BR(array());
2519 }
2520
2521 /**
2522 * balise : H6
2523 * mode : OUVERTURE
2524 *
2525 * @param array paramètres de l'élément de parsing
2526 * @return null
2527 */
2528 function o_H6($param)
2529 {
2530 $this->o_BR(array());
2531 $this->style->save();
2532 $this->style->value['font-bold'] = true;
2533 $this->style->value['font-size'] = $this->style->ConvertToMM('9px');
2534 $this->style->analyse('h6', $param);
2535 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2536 $this->style->FontSet();
2537 }
2538
2539 /**
2540 * balise : H6
2541 * mode : FERMETURE
2542 *
2543 * @param array paramètres de l'élément de parsing
2544 * @return null
2545 */
2546 function c_H6($param)
2547 {
2548 $this->o_BR(array());
2549 $this->style->load();
2550 $this->style->FontSet();
2551 $this->o_BR(array());
2552 }
2553
2554 /**
2555 * balise : SPAN
2556 * mode : OUVERTURE
2557 *
2558 * @param array paramètres de l'élément de parsing
2559 * @return null
2560 */
2561 function o_SPAN($param, $other = 'span')
2562 {
2563 $this->style->save();
2564 $this->style->analyse($other, $param);
2565 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2566 $this->style->FontSet();
2567 }
2568 function o_FONT($param) { $this->o_SPAN($param, 'font'); }
2569
2570 /**
2571 * balise : SPAN
2572 * mode : FERMETURE
2573 *
2574 * @param array paramètres de l'élément de parsing
2575 * @return null
2576 */
2577 function c_SPAN($param)
2578 {
2579 $this->style->load();
2580 $this->style->FontSet();
2581 }
2582 function c_FONT($param) { $this->c_SPAN($param); }
2583
2584
2585 /**
2586 * balise : P
2587 * mode : OUVERTURE
2588 *
2589 * @param array paramètres de l'élément de parsing
2590 * @return null
2591 */
2592 function o_P($param)
2593 {
2594 if (!in_array($this->previousCall, array('c_P', 'c_UL')))
2595 {
2596 if ($this->maxH) $this->o_BR(array());
2597 $this->o_BR(array());
2598 }
2599
2600 $this->style->save();
2601 $this->style->analyse('p', $param);
2602 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2603 $this->style->FontSet();
2604
2605 if ($this->style->value['text-indent']>0) $this->pdf->x+= $this->style->value['text-indent'];
2606 }
2607
2608 /**
2609 * balise : P
2610 * mode : FERMETURE
2611 *
2612 * @param array paramètres de l'élément de parsing
2613 * @return null
2614 */
2615 function c_P($param)
2616 {
2617 if ($this->maxH) $this->o_BR(array());
2618 $this->o_BR(array());
2619 $this->style->load();
2620 $this->style->FontSet();
2621
2622 }
2623
2624 /**
2625 * balise : PRE
2626 * mode : OUVERTURE
2627 *
2628 * @param array paramètres de l'élément de parsing
2629 * @return null
2630 */
2631 function o_PRE($param, $other = 'pre')
2632 {
2633 if ($other=='pre' && $this->maxH) $this->o_BR(array());
2634
2635 $this->style->save();
2636 $this->style->value['font-family'] = 'courier';
2637 $this->style->analyse($other, $param);
2638 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2639 $this->style->FontSet();
2640
2641 if ($other=='pre') $this->o_DIV($param, $other);
2642 }
2643 function o_CODE($param) { $this->o_PRE($param, 'code'); }
2644
2645 /**
2646 * balise : PRE
2647 * mode : FERMETURE
2648 *
2649 * @param array paramètres de l'élément de parsing
2650 * @return null
2651 */
2652 function c_PRE($param, $other = 'pre')
2653 {
2654 if ($other=='pre')
2655 {
2656 $this->c_DIV($param);
2657 $this->o_BR(array());
2658 }
2659 $this->style->load();
2660 $this->style->FontSet();
2661 }
2662 function c_CODE($param) { $this->c_PRE($param, 'code'); }
2663
2664 /**
2665 * balise : BIG
2666 * mode : OUVERTURE
2667 *
2668 * @param array paramètres de l'élément de parsing
2669 * @return null
2670 */
2671 function o_BIG($param)
2672 {
2673 $this->style->save();
2674 $this->style->value['mini-decal']-= $this->style->value['mini-size']*0.2;
2675 $this->style->value['mini-size'] *= 1.2;
2676 $this->style->analyse('big', $param);
2677 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2678 $this->style->FontSet();
2679 }
2680
2681 /**
2682 * balise : BIG
2683 * mode : FERMETURE
2684 *
2685 * @param array paramètres de l'élément de parsing
2686 * @return null
2687 */
2688 function c_BIG($param)
2689 {
2690 $this->style->load();
2691 $this->style->FontSet();
2692 }
2693
2694 /**
2695 * balise : SMALL
2696 * mode : OUVERTURE
2697 *
2698 * @param array paramètres de l'élément de parsing
2699 * @return null
2700 */
2701 function o_SMALL($param)
2702 {
2703 $this->style->save();
2704 $this->style->value['mini-decal']+= $this->style->value['mini-size']*0.18;
2705 $this->style->value['mini-size'] *= 0.82;
2706 $this->style->analyse('small', $param);
2707 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2708 $this->style->FontSet();
2709 }
2710
2711 /**
2712 * balise : SMALL
2713 * mode : FERMETURE
2714 *
2715 * @param array paramètres de l'élément de parsing
2716 * @return null
2717 */
2718 function c_SMALL($param)
2719 {
2720 $this->style->load();
2721 $this->style->FontSet();
2722 }
2723
2724
2725 /**
2726 * balise : SUP
2727 * mode : OUVERTURE
2728 *
2729 * @param array paramètres de l'élément de parsing
2730 * @return null
2731 */
2732 function o_SUP($param)
2733 {
2734 $this->style->save();
2735 $this->style->value['mini-decal']-= $this->style->value['mini-size']*0.25;
2736 $this->style->value['mini-size'] *= 0.75;
2737 $this->style->analyse('sup', $param);
2738 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2739 $this->style->FontSet();
2740 }
2741
2742 /**
2743 * balise : SUP
2744 * mode : FERMETURE
2745 *
2746 * @param array paramètres de l'élément de parsing
2747 * @return null
2748 */
2749 function c_SUP($param)
2750 {
2751 $this->style->load();
2752 $this->style->FontSet();
2753 }
2754
2755 /**
2756 * balise : SUB
2757 * mode : OUVERTURE
2758 *
2759 * @param array paramètres de l'élément de parsing
2760 * @return null
2761 */
2762 function o_SUB($param)
2763 {
2764 $this->style->save();
2765 $this->style->value['mini-decal']+= $this->style->value['mini-size']*0.25;
2766 $this->style->value['mini-size'] *= 0.75;
2767 $this->style->analyse('sub', $param);
2768 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2769 $this->style->FontSet();
2770 $this->inSub = 1;
2771 }
2772
2773 /**
2774 * balise : SUB
2775 * mode : FERMETURE
2776 *
2777 * @param array paramètres de l'élément de parsing
2778 * @return null
2779 */
2780 function c_SUB($param)
2781 {
2782 $this->style->load();
2783 $this->style->FontSet();
2784 }
2785
2786 /**
2787 * balise : UL
2788 * mode : OUVERTURE
2789 *
2790 * @param array paramètres de l'élément de parsing
2791 * @return null
2792 */
2793 function o_UL($param, $other = 'ul')
2794 {
2795 if (!in_array($this->previousCall, array('c_P', 'c_UL')))
2796 {
2797 if ($this->maxH) $this->o_BR(array());
2798 if (!count($this->defLIST)) $this->o_BR(array());
2799 }
2800
2801 if (!isset($param['style']['width'])) $param['allwidth'] = true;
2802 $param['cellspacing'] = 0;
2803
2804 // une liste est traitée comme un tableau
2805 $this->o_TABLE($param, $other);
2806
2807 // ajouter un niveau de liste
2808 $this->listeAddLevel($other, $this->style->value['list-style-type'], $this->style->value['list-style-image']);
2809 }
2810 function o_OL($param) { $this->o_UL($param, 'ol'); }
2811
2812 /**
2813 * balise : UL
2814 * mode : FERMETURE
2815 *
2816 * @param array paramètres de l'élément de parsing
2817 * @return null
2818 */
2819 function c_UL($param)
2820 {
2821 // fin du tableau
2822 $this->c_TABLE($param);
2823
2824 // enlever un niveau de liste
2825 $this->listeDelLevel();
2826
2827 if (!$this->sub_part)
2828 {
2829 if (!count($this->defLIST)) $this->o_BR(array());
2830 }
2831 }
2832 function c_OL($param) { $this->c_UL($param); }
2833
2834 /**
2835 * balise : LI
2836 * mode : OUVERTURE
2837 *
2838 * @param array paramètres de l'élément de parsing
2839 * @return null
2840 */
2841 function o_LI($param)
2842 {
2843 // ajouter une puce au niveau actuel
2844 $this->listeAddLi();
2845
2846 if (!isset($param['style']['width'])) $param['style']['width'] = '100%';
2847
2848 // preparation du style de la puce
2849 $paramPUCE = $param;
2850
2851 $inf = $this->listeGetLi();
2852 if ($inf[0])
2853 {
2854 $paramPUCE['style']['font-family'] = $inf[0];
2855 $paramPUCE['style']['text-align'] = 'right';
2856 $paramPUCE['style']['vertical-align'] = 'top';
2857 $paramPUCE['style']['width'] = $this->listeGetWidth();
2858 $paramPUCE['style']['padding-right'] = $this->listeGetPadding();
2859 $paramPUCE['txt'] = $inf[2];
2860 }
2861 else
2862 {
2863 $paramPUCE['style']['text-align'] = 'right';
2864 $paramPUCE['style']['vertical-align'] = 'top';
2865 $paramPUCE['style']['width'] = $this->listeGetWidth();
2866 $paramPUCE['style']['padding-right'] = $this->listeGetPadding();
2867 $paramPUCE['src'] = $inf[2];
2868 $paramPUCE['sub_li'] = true;
2869 }
2870
2871 // nouvelle ligne
2872 $this->o_TR($param, 'li');
2873
2874 $this->style->save();
2875
2876 if ($inf[1])
2877 {
2878 $this->style->value['mini-decal']+= $this->style->value['mini-size']*0.25;
2879 $this->style->value['mini-size'] *= 0.75;
2880 }
2881
2882 // si on est dans un sub_html => preparation, sinon affichage classique
2883 if ($this->sub_part)
2884 {
2885 // TD pour la puce
2886 $tmp_pos = $this->temp_pos;
2887 $tmp_lst1 = $this->parsing->code[$tmp_pos+1];
2888 $tmp_lst2 = $this->parsing->code[$tmp_pos+2];
2889 $this->parsing->code[$tmp_pos+1] = array();
2890 $this->parsing->code[$tmp_pos+1]['name'] = (isset($paramPUCE['src'])) ? 'img' : 'write';
2891 $this->parsing->code[$tmp_pos+1]['param'] = $paramPUCE; unset($this->parsing->code[$tmp_pos+1]['param']['style']['width']);
2892 $this->parsing->code[$tmp_pos+1]['close'] = 0;
2893 $this->parsing->code[$tmp_pos+2] = array();
2894 $this->parsing->code[$tmp_pos+2]['name'] = 'li';
2895 $this->parsing->code[$tmp_pos+2]['param'] = $paramPUCE;
2896 $this->parsing->code[$tmp_pos+2]['close'] = 1;
2897 $this->o_TD($paramPUCE, 'li_sub');
2898 $this->c_TD($param);
2899 $this->temp_pos = $tmp_pos;
2900 $this->parsing->code[$tmp_pos+1] = $tmp_lst1;
2901 $this->parsing->code[$tmp_pos+2] = $tmp_lst2;
2902 }
2903 else
2904 {
2905 // TD pour la puce
2906 $this->o_TD($paramPUCE, 'li_sub');
2907 unset($paramPUCE['style']['width']);
2908 if (isset($paramPUCE['src'])) $this->o_IMG($paramPUCE);
2909 else $this->o_WRITE($paramPUCE);
2910 $this->c_TD($paramPUCE);
2911 }
2912 $this->style->load();
2913
2914
2915 // td pour le contenu
2916 $this->o_TD($param, 'li');
2917 }
2918
2919 /**
2920 * balise : LI
2921 * mode : FERMETURE
2922 *
2923 * @param array paramètres de l'élément de parsing
2924 * @return null
2925 */
2926 function c_LI($param)
2927 {
2928 // fin du contenu
2929 $this->c_TD($param, 'li');
2930
2931 // fin de la ligne
2932 $this->c_TR($param, 'li');
2933 }
2934
2935 /**
2936 * balise : TBODY
2937 * mode : OUVERTURE
2938 *
2939 * @param array paramètres de l'élément de parsing
2940 * @return null
2941 */
2942 function o_TBODY($param)
2943 {
2944 $this->style->save();
2945 $this->style->analyse('tbody', $param);
2946 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2947 $this->style->FontSet();
2948 }
2949
2950 /**
2951 * balise : TBODY
2952 * mode : FERMETURE
2953 *
2954 * @param array paramètres de l'élément de parsing
2955 * @return null
2956 */
2957 function c_TBODY($param)
2958 {
2959 $this->style->load();
2960 $this->style->FontSet();
2961 }
2962
2963 /**
2964 * balise : THEAD
2965 * mode : OUVERTURE
2966 *
2967 * @param array paramètres de l'élément de parsing
2968 * @return null
2969 */
2970 function o_THEAD($param)
2971 {
2972 global $HTML2PDF_TABLEAU;
2973
2974 $this->style->save();
2975 $this->style->analyse('thead', $param);
2976 $this->style->setPosition($this->pdf->x, $this->pdf->y);
2977 $this->style->FontSet();
2978
2979 // si on est en mode sub_html : sauvegarde du numéro du TR
2980 if ($this->sub_part)
2981 {
2982 $HTML2PDF_TABLEAU[$param['num']]['thead']['tr'][0] = $HTML2PDF_TABLEAU[$param['num']]['tr_curr'];
2983 $HTML2PDF_TABLEAU[$param['num']]['thead']['code'] = array();
2984 for($pos=$this->temp_pos; $pos<count($this->parsing->code); $pos++)
2985 {
2986 $todo = $this->parsing->code[$pos];
2987 if (strtolower($todo['name'])=='thead') $todo['name'] = 'thead_sub';
2988 $HTML2PDF_TABLEAU[$param['num']]['thead']['code'][] = $todo;
2989 if (strtolower($todo['name'])=='thead_sub' && $todo['close']) break;
2990 }
2991 }
2992 else
2993 {
2994 $res = $this->parsing->getLevel($this->parse_pos);
2995 $this->parse_pos = $res[0]-1;
2996 $HTML2PDF_TABLEAU[$param['num']]['tr_curr']+= count($HTML2PDF_TABLEAU[$param['num']]['thead']['tr']);
2997 }
2998 }
2999
3000 /**
3001 * balise : THEAD
3002 * mode : FERMETURE
3003 *
3004 * @param array paramètres de l'élément de parsing
3005 * @return null
3006 */
3007 function c_THEAD($param)
3008 {
3009 $this->style->load();
3010 $this->style->FontSet();
3011
3012 // si on est en mode sub_html : sauvegarde du numéro du TR
3013 if ($this->sub_part)
3014 {
3015 global $HTML2PDF_TABLEAU;
3016 $min = $HTML2PDF_TABLEAU[$param['num']]['thead']['tr'][0];
3017 $max = $HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1;
3018 $HTML2PDF_TABLEAU[$param['num']]['thead']['tr'] = range($min, $max);
3019 }
3020 }
3021
3022 /**
3023 * balise : TFOOT
3024 * mode : OUVERTURE
3025 *
3026 * @param array paramètres de l'élément de parsing
3027 * @return null
3028 */
3029 function o_TFOOT($param)
3030 {
3031 global $HTML2PDF_TABLEAU;
3032
3033 $this->style->save();
3034 $this->style->analyse('tfoot', $param);
3035 $this->style->setPosition($this->pdf->x, $this->pdf->y);
3036 $this->style->FontSet();
3037
3038 // si on est en mode sub_html : sauvegarde du numéro du TR
3039 if ($this->sub_part)
3040 {
3041 $HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr'][0] = $HTML2PDF_TABLEAU[$param['num']]['tr_curr'];
3042 $HTML2PDF_TABLEAU[$param['num']]['tfoot']['code'] = array();
3043 for($pos=$this->temp_pos; $pos<count($this->parsing->code); $pos++)
3044 {
3045 $todo = $this->parsing->code[$pos];
3046 if (strtolower($todo['name'])=='tfoot') $todo['name'] = 'tfoot_sub';
3047 $HTML2PDF_TABLEAU[$param['num']]['tfoot']['code'][] = $todo;
3048 if (strtolower($todo['name'])=='tfoot_sub' && $todo['close']) break;
3049 }
3050 }
3051 else
3052 {
3053 $res = $this->parsing->getLevel($this->parse_pos+1);
3054 $this->parse_pos = $res[0];
3055 $HTML2PDF_TABLEAU[$param['num']]['tr_curr']+= count($HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr']);
3056 }
3057 }
3058
3059 /**
3060 * balise : TFOOT
3061 * mode : FERMETURE
3062 *
3063 * @param array paramètres de l'élément de parsing
3064 * @return null
3065 */
3066 function c_TFOOT($param)
3067 {
3068 $this->style->load();
3069 $this->style->FontSet();
3070
3071 // si on est en mode sub_html : sauvegarde du numéro du TR
3072 if ($this->sub_part)
3073 {
3074 global $HTML2PDF_TABLEAU;
3075
3076 $min = $HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr'][0];
3077 $max = $HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1;
3078 $HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr'] = range($min, $max);
3079 }
3080 }
3081
3082 /**
3083 * balise : THEAD_SUB
3084 * mode : OUVERTURE
3085 *
3086 * @param array paramètres de l'élément de parsing
3087 * @return null
3088 */
3089 function o_THEAD_SUB($param)
3090 {
3091 $this->style->save();
3092 $this->style->analyse('thead', $param);
3093 $this->style->setPosition($this->pdf->x, $this->pdf->y);
3094 $this->style->FontSet();
3095 }
3096
3097 /**
3098 * balise : THEAD_SUB
3099 * mode : FERMETURE
3100 *
3101 * @param array paramètres de l'élément de parsing
3102 * @return null
3103 */
3104 function c_THEAD_SUB($param)
3105 {
3106 $this->style->load();
3107 $this->style->FontSet();
3108 }
3109
3110 /**
3111 * balise : TFOOT_SUB
3112 * mode : OUVERTURE
3113 *
3114 * @param array paramètres de l'élément de parsing
3115 * @return null
3116 */
3117 function o_TFOOT_SUB($param)
3118 {
3119 $this->style->save();
3120 $this->style->analyse('tfoot', $param);
3121 $this->style->setPosition($this->pdf->x, $this->pdf->y);
3122 $this->style->FontSet();
3123 }
3124
3125 /**
3126 * balise : TFOOT_SUB
3127 * mode : FERMETURE
3128 *
3129 * @param array paramètres de l'élément de parsing
3130 * @return null
3131 */
3132 function c_TFOOT_SUB($param)
3133 {
3134 $this->style->load();
3135 $this->style->FontSet();
3136 }
3137
3138 /**
3139 * balise : FORM
3140 * mode : OUVERTURE
3141 *
3142 * @param array paramètres de l'élément de parsing
3143 * @return null
3144 */
3145 function o_FORM($param)
3146 {
3147 $this->style->save();
3148 $this->style->analyse('form', $param);
3149 $this->style->setPosition($this->pdf->x, $this->pdf->y);
3150 $this->style->FontSet();
3151 }
3152
3153 /**
3154 * balise : FORM
3155 * mode : FERMETURE
3156 *
3157 * @param array paramètres de l'élément de parsing
3158 * @return null
3159 */
3160 function c_FORM($param)
3161 {
3162 $this->style->load();
3163 $this->style->FontSet();
3164 }
3165
3166 /**
3167 * balise : TABLE
3168 * mode : OUVERTURE
3169 *
3170 * @param array paramètres de l'élément de parsing
3171 * @return null
3172 */
3173 function o_TABLE($param, $other = 'table')
3174 {
3175 $this->maxH = 0;
3176 // utilisation du tableau des paramétres des tables
3177 global $HTML2PDF_TABLEAU;
3178
3179 $align_object = isset($param['align']) ? strtolower($param['align']) : 'left';
3180 if (isset($param['align'])) unset($param['align']);
3181 if (!in_array($align_object, array('left', 'center', 'right'))) $align_object = 'left';
3182
3183 // lecture et initialisation du style
3184 $this->style->save();
3185 $this->style->analyse($other, $param);
3186 $this->style->setPosition($this->pdf->x, $this->pdf->y);
3187 $this->style->FontSet();
3188
3189 if ($this->style->value['margin-auto']) $align_object = 'center';
3190
3191 // est-on en collapse
3192 $collapse = false;
3193 if ($other=='table')
3194 $collapse = isset($this->style->value['border']['collapse']) ? $this->style->value['border']['collapse'] : false;
3195
3196 // si oui il faut adapté les borders
3197 if ($collapse)
3198 {
3199 $param['style']['border'] = 'none';
3200 $param['cellspacing'] = 0;
3201 $none = $this->style->readBorder('none');
3202 $this->style->value['border']['t'] = $none;
3203 $this->style->value['border']['r'] = $none;
3204 $this->style->value['border']['b'] = $none;
3205 $this->style->value['border']['l'] = $none;
3206 }
3207
3208 // si on est en mode sub_html : initialisation des dimensions et autres
3209 if ($this->sub_part)
3210 {
3211 $HTML2PDF_TABLEAU[$param['num']] = array();
3212 $HTML2PDF_TABLEAU[$param['num']]['cellpadding'] = $this->style->ConvertToMM(isset($param['cellpadding']) ? $param['cellpadding'] : '1px'); // cellpadding du tableau
3213 $HTML2PDF_TABLEAU[$param['num']]['cellspacing'] = $this->style->ConvertToMM(isset($param['cellspacing']) ? $param['cellspacing'] : '2px'); // cellspacing du tableau
3214 $HTML2PDF_TABLEAU[$param['num']]['cases'] = array(); // liste des propriétés des cases
3215 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = 0; // colonne courante
3216 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = 0; // ligne courante
3217 $HTML2PDF_TABLEAU[$param['num']]['curr_x'] = $this->pdf->getX(); // position courante X
3218 $HTML2PDF_TABLEAU[$param['num']]['curr_y'] = $this->pdf->getY(); // position courante Y
3219 $HTML2PDF_TABLEAU[$param['num']]['width'] = 0; // largeur globale
3220 $HTML2PDF_TABLEAU[$param['num']]['height'] = 0; // hauteur globale
3221 $HTML2PDF_TABLEAU[$param['num']]['align'] = $align_object;
3222 $HTML2PDF_TABLEAU[$param['num']]['marge'] = array();
3223 $HTML2PDF_TABLEAU[$param['num']]['marge']['t'] = $this->style->value['padding']['t']+$this->style->value['border']['t']['width']+$HTML2PDF_TABLEAU[$param['num']]['cellspacing']*0.5;
3224 $HTML2PDF_TABLEAU[$param['num']]['marge']['r'] = $this->style->value['padding']['r']+$this->style->value['border']['r']['width']+$HTML2PDF_TABLEAU[$param['num']]['cellspacing']*0.5;
3225 $HTML2PDF_TABLEAU[$param['num']]['marge']['b'] = $this->style->value['padding']['b']+$this->style->value['border']['b']['width']+$HTML2PDF_TABLEAU[$param['num']]['cellspacing']*0.5;
3226 $HTML2PDF_TABLEAU[$param['num']]['marge']['l'] = $this->style->value['padding']['l']+$this->style->value['border']['l']['width']+$HTML2PDF_TABLEAU[$param['num']]['cellspacing']*0.5;
3227 $HTML2PDF_TABLEAU[$param['num']]['page'] = 0; // nombre de pages
3228 $HTML2PDF_TABLEAU[$param['num']]['new_page'] = true; // nouvelle page pour le TR courant
3229 $HTML2PDF_TABLEAU[$param['num']]['style_value'] = null; // style du tableau
3230 $HTML2PDF_TABLEAU[$param['num']]['thead'] = array(); // infos sur le thead
3231 $HTML2PDF_TABLEAU[$param['num']]['tfoot'] = array(); // infos sur le tfoot
3232 $HTML2PDF_TABLEAU[$param['num']]['thead']['tr'] = array(); // tr du thead
3233 $HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr'] = array(); // tr du tfoot
3234 $HTML2PDF_TABLEAU[$param['num']]['thead']['height'] = 0; // hauteur du thead
3235 $HTML2PDF_TABLEAU[$param['num']]['tfoot']['height'] = 0; // hauteur du tfoot
3236 $HTML2PDF_TABLEAU[$param['num']]['thead']['code'] = array(); // contenu HTML du thead
3237 $HTML2PDF_TABLEAU[$param['num']]['tfoot']['code'] = array(); // contenu HTML du tfoot
3238
3239 $this->saveMargin($this->pdf->lMargin, $this->pdf->tMargin, $this->pdf->rMargin);
3240
3241 // adaptation de la largeur en fonction des marges du tableau
3242 $this->style->value['width']-= $HTML2PDF_TABLEAU[$param['num']]['marge']['l'] + $HTML2PDF_TABLEAU[$param['num']]['marge']['r'];
3243 }
3244 else
3245 {
3246 // on repart à la premiere page du tableau et à la premiere case
3247 $HTML2PDF_TABLEAU[$param['num']]['page'] = 0;
3248 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = 0;
3249 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = 0;
3250 $HTML2PDF_TABLEAU[$param['num']]['td_x'] = $HTML2PDF_TABLEAU[$param['num']]['marge']['l']+$HTML2PDF_TABLEAU[$param['num']]['curr_x'];
3251 $HTML2PDF_TABLEAU[$param['num']]['td_y'] = $HTML2PDF_TABLEAU[$param['num']]['marge']['t']+$HTML2PDF_TABLEAU[$param['num']]['curr_y'];
3252
3253 // initialisation du style des bordures de la premiere partie de tableau
3254 $this->Rectangle(
3255 $HTML2PDF_TABLEAU[$param['num']]['curr_x'],
3256 $HTML2PDF_TABLEAU[$param['num']]['curr_y'],
3257 $HTML2PDF_TABLEAU[$param['num']]['width'],
3258 isset($HTML2PDF_TABLEAU[$param['num']]['height'][0]) ? $HTML2PDF_TABLEAU[$param['num']]['height'][0] : null,
3259 $this->style->value['border'],
3260 $this->style->value['padding'],
3261 0,
3262 $this->style->value['background']
3263 );
3264
3265 $HTML2PDF_TABLEAU[$param['num']]['style_value'] = $this->style->value;
3266 }
3267 }
3268
3269 /**
3270 * balise : TABLE
3271 * mode : FERMETURE
3272 *
3273 * @param array paramètres de l'élément de parsing
3274 * @return null
3275 */
3276 function c_TABLE($param)
3277 {
3278 $this->maxH = 0;
3279 global $HTML2PDF_TABLEAU;
3280
3281 // restauration du style
3282 $this->style->load();
3283 $this->style->FontSet();
3284
3285 // si on est en mode sub_html : initialisation des dimensions et autres
3286 if ($this->sub_part)
3287 {
3288 // ajustement de la taille des cases
3289 $this->calculTailleCases($HTML2PDF_TABLEAU[$param['num']]['cases']);
3290
3291 // calcul de la hauteur du THEAD et du TFOOT
3292 $lst = array('thead', 'tfoot');
3293 foreach($lst as $mode)
3294 {
3295 $HTML2PDF_TABLEAU[$param['num']][$mode]['height'] = 0;
3296 foreach($HTML2PDF_TABLEAU[$param['num']][$mode]['tr'] as $tr)
3297 {
3298 // hauteur de la ligne tr
3299 $h = 0;
3300 for($i=0; $i<count($HTML2PDF_TABLEAU[$param['num']]['cases'][$tr]); $i++)
3301 if ($HTML2PDF_TABLEAU[$param['num']]['cases'][$tr][$i]['rowspan']==1)
3302 $h = max($h, $HTML2PDF_TABLEAU[$param['num']]['cases'][$tr][$i]['h']);
3303 $HTML2PDF_TABLEAU[$param['num']][$mode]['height']+= $h;
3304 }
3305 }
3306
3307 // calcul des dimensions du tableau - Largeur
3308 $HTML2PDF_TABLEAU[$param['num']]['width'] = $HTML2PDF_TABLEAU[$param['num']]['marge']['l'] + $HTML2PDF_TABLEAU[$param['num']]['marge']['r'];
3309 if (isset($HTML2PDF_TABLEAU[$param['num']]['cases'][0]))
3310 foreach($HTML2PDF_TABLEAU[$param['num']]['cases'][0] as $case)
3311 $HTML2PDF_TABLEAU[$param['num']]['width']+= $case['w'];
3312
3313 // positionnement du tableau horizontalement;
3314 $old = isset($this->style->table[count($this->style->table)-1]) ? $this->style->table[count($this->style->table)-1] : $this->style->value;
3315 $parent_w = $old['width'] ? $old['width'] : $this->pdf->w - $this->pdf->lMargin - $this->pdf->rMargin;
3316 $x = $HTML2PDF_TABLEAU[$param['num']]['curr_x'];
3317 $w = $HTML2PDF_TABLEAU[$param['num']]['width'];
3318 if ($parent_w>$w)
3319 {
3320 if ($HTML2PDF_TABLEAU[$param['num']]['align']=='center')
3321 $x = $x + ($parent_w-$w)*0.5;
3322 else if ($HTML2PDF_TABLEAU[$param['num']]['align']=='right')
3323 $x = $x + $parent_w-$w;
3324
3325 $HTML2PDF_TABLEAU[$param['num']]['curr_x'] = $x;
3326 }
3327
3328
3329 // calcul des dimensions du tableau - hauteur du tableau sur chaque page
3330 $HTML2PDF_TABLEAU[$param['num']]['height'] = array();
3331
3332 $h0 = $HTML2PDF_TABLEAU[$param['num']]['marge']['t'] + $HTML2PDF_TABLEAU[$param['num']]['marge']['b']; // minimum de hauteur à cause des marges
3333 $h0+= $HTML2PDF_TABLEAU[$param['num']]['thead']['height'] + $HTML2PDF_TABLEAU[$param['num']]['tfoot']['height']; // et du tfoot et thead
3334 $max = $this->pdf->h - $this->pdf->bMargin; // max de hauteur par page
3335 $y = $HTML2PDF_TABLEAU[$param['num']]['curr_y']; // position Y actuelle
3336 $height = $h0;
3337
3338 // on va lire les hauteurs de chaque ligne, une à une, et voir si ca rentre sur la page.
3339 for($k=0; $k<count($HTML2PDF_TABLEAU[$param['num']]['cases']); $k++)
3340 {
3341 // si c'est des lignes du thead ou du tfoot : on passe
3342 if (in_array($k, $HTML2PDF_TABLEAU[$param['num']]['thead']['tr'])) continue;
3343 if (in_array($k, $HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr'])) continue;
3344
3345 // hauteur de la ligne $k
3346 $th = 0;
3347 $h = 0;
3348 for($i=0; $i<count($HTML2PDF_TABLEAU[$param['num']]['cases'][$k]); $i++)
3349 {
3350 $h = max($h, $HTML2PDF_TABLEAU[$param['num']]['cases'][$k][$i]['h']);
3351
3352 if ($HTML2PDF_TABLEAU[$param['num']]['cases'][$k][$i]['rowspan']==1)
3353 $th = max($th, $HTML2PDF_TABLEAU[$param['num']]['cases'][$k][$i]['h']);
3354 }
3355
3356 // si la ligne ne rentre pas dans la page
3357 // => la hauteur sur cette page est trouvée, et on passe à la page d'apres
3358 if ($y+$h+$height>$max)
3359 {
3360 if ($height==$h0) $height = null;
3361 $HTML2PDF_TABLEAU[$param['num']]['height'][] = $height;
3362 $height = $h0;
3363 $y = $this->margeTop;
3364 }
3365 $height+= $th;
3366 }
3367 // rajout du reste de tableau (si il existe) à la derniere page
3368 if ($height!=$h0 || $k==0) $HTML2PDF_TABLEAU[$param['num']]['height'][] = $height;
3369 }
3370 else
3371 {
3372 if (count($HTML2PDF_TABLEAU[$param['num']]['tfoot']['code']))
3373 {
3374 $tmp_tr = $HTML2PDF_TABLEAU[$param['num']]['tr_curr'];
3375 $tmp_td = $HTML2PDF_TABLEAU[$param['num']]['td_curr'];
3376 $OLD_parse_pos = $this->parse_pos;
3377 $OLD_parse_code = $this->parsing->code;
3378
3379 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = $HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr'][0];
3380 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = 0;
3381 $this->parse_pos = 0;
3382 $this->parsing->code = $HTML2PDF_TABLEAU[$param['num']]['tfoot']['code'];
3383 $this->MakeHTMLcode();
3384
3385 $this->parse_pos = $OLD_parse_pos;
3386 $this->parsing->code = $OLD_parse_code;
3387 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = $tmp_tr;
3388 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = $tmp_td;
3389 }
3390
3391 // determination des coordonnées de sortie du tableau
3392 $x = $HTML2PDF_TABLEAU[$param['num']]['curr_x'] + $HTML2PDF_TABLEAU[$param['num']]['width'];
3393 if (count($HTML2PDF_TABLEAU[$param['num']]['height'])>1)
3394 $y = $this->margeTop+$HTML2PDF_TABLEAU[$param['num']]['height'][count($HTML2PDF_TABLEAU[$param['num']]['height'])-1];
3395 else if (count($HTML2PDF_TABLEAU[$param['num']]['height'])==1)
3396 $y = $HTML2PDF_TABLEAU[$param['num']]['curr_y']+$HTML2PDF_TABLEAU[$param['num']]['height'][count($HTML2PDF_TABLEAU[$param['num']]['height'])-1];
3397 else
3398 $y = $HTML2PDF_TABLEAU[$param['num']]['curr_y'];
3399
3400 // restauration des marges
3401 $this->loadMargin();
3402
3403 // position de sortie du tableau
3404 $this->pdf->setX($x);
3405 $this->pdf->setY($y);
3406 $this->maxX = max($this->maxX, $x);
3407 $this->maxY = max($this->maxY, $y);
3408 }
3409 }
3410
3411 /**
3412 * balise : TR
3413 * mode : OUVERTURE
3414 *
3415 * @param array paramètres de l'élément de parsing
3416 * @return null
3417 */
3418 function o_TR($param, $other = 'tr')
3419 {
3420 $this->maxH = 0;
3421 global $HTML2PDF_TABLEAU;
3422
3423 // analyse du style
3424 $this->style->save();
3425 $this->style->analyse($other, $param);
3426 $this->style->setPosition($this->pdf->x, $this->pdf->y);
3427 $this->style->FontSet();
3428
3429 // positionnement dans le tableau
3430 $HTML2PDF_TABLEAU[$param['num']]['tr_curr']++;
3431 $HTML2PDF_TABLEAU[$param['num']]['td_curr']= 0;
3432
3433 // si on est pas dans un sub_html
3434 if (!$this->sub_part)
3435 {
3436 // Y courant apres la ligne
3437 $ty=null;
3438 for($ii=0; $ii<count($HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1]); $ii++)
3439 $ty = max($ty, $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$ii]['h']);
3440
3441 $hfoot = $HTML2PDF_TABLEAU[$param['num']]['tfoot']['height'];
3442
3443 // si la ligne ne rentre pas dans la page => nouvelle page
3444 if (!$this->isInTfoot && $HTML2PDF_TABLEAU[$param['num']]['td_y'] + $HTML2PDF_TABLEAU[$param['num']]['marge']['b'] + $ty +$hfoot> $this->pdf->h - $this->pdf->bMargin)
3445 {
3446 if (count($HTML2PDF_TABLEAU[$param['num']]['tfoot']['code']))
3447 {
3448 $tmp_tr = $HTML2PDF_TABLEAU[$param['num']]['tr_curr'];
3449 $tmp_td = $HTML2PDF_TABLEAU[$param['num']]['td_curr'];
3450 $OLD_parse_pos = $this->parse_pos;
3451 $OLD_parse_code = $this->parsing->code;
3452
3453 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = $HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr'][0];
3454 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = 0;
3455 $this->parse_pos = 0;
3456 $this->parsing->code = $HTML2PDF_TABLEAU[$param['num']]['tfoot']['code'];
3457 $this->isInTfoot = true;
3458 $this->MakeHTMLcode();
3459 $this->isInTfoot = false;
3460
3461 $this->parse_pos = $OLD_parse_pos;
3462 $this->parsing->code = $OLD_parse_code;
3463 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = $tmp_tr;
3464 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = $tmp_td;
3465 }
3466
3467 $HTML2PDF_TABLEAU[$param['num']]['new_page'] = true;
3468 $this->setNewPage();
3469
3470 $HTML2PDF_TABLEAU[$param['num']]['page']++;
3471 $HTML2PDF_TABLEAU[$param['num']]['curr_y'] = $this->pdf->getY();
3472 $HTML2PDF_TABLEAU[$param['num']]['td_y'] = $HTML2PDF_TABLEAU[$param['num']]['curr_y']+$HTML2PDF_TABLEAU[$param['num']]['marge']['t'];
3473
3474 // si la hauteur de cette partie a bien été calculée, on trace le cadre
3475 if (isset($HTML2PDF_TABLEAU[$param['num']]['height'][$HTML2PDF_TABLEAU[$param['num']]['page']]))
3476 {
3477 $old = $this->style->value;
3478 $this->style->value = $HTML2PDF_TABLEAU[$param['num']]['style_value'];
3479
3480 // initialisation du style des bordures de la premiere partie de tableau
3481 $this->Rectangle(
3482 $HTML2PDF_TABLEAU[$param['num']]['curr_x'],
3483 $HTML2PDF_TABLEAU[$param['num']]['curr_y'],
3484 $HTML2PDF_TABLEAU[$param['num']]['width'],
3485 $HTML2PDF_TABLEAU[$param['num']]['height'][$HTML2PDF_TABLEAU[$param['num']]['page']],
3486 $this->style->value['border'],
3487 $this->style->value['padding'],
3488 $HTML2PDF_TABLEAU[$param['num']]['cellspacing']*0.5,
3489 $this->style->value['background']
3490 );
3491
3492 $this->style->value = $old;
3493 }
3494 }
3495
3496 if ($HTML2PDF_TABLEAU[$param['num']]['new_page'] && count($HTML2PDF_TABLEAU[$param['num']]['thead']['code']))
3497 {
3498 $HTML2PDF_TABLEAU[$param['num']]['new_page'] = false;
3499 $tmp_tr = $HTML2PDF_TABLEAU[$param['num']]['tr_curr'];
3500 $tmp_td = $HTML2PDF_TABLEAU[$param['num']]['td_curr'];
3501 $OLD_parse_pos = $this->parse_pos;
3502 $OLD_parse_code = $this->parsing->code;
3503
3504 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = $HTML2PDF_TABLEAU[$param['num']]['thead']['tr'][0];
3505 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = 0;
3506 $this->parse_pos = 0;
3507 $this->parsing->code = $HTML2PDF_TABLEAU[$param['num']]['thead']['code'];
3508 $this->MakeHTMLcode();
3509
3510 $this->parse_pos = $OLD_parse_pos;
3511 $this->parsing->code = $OLD_parse_code;
3512 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = $tmp_tr;
3513 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = $tmp_td;
3514 $HTML2PDF_TABLEAU[$param['num']]['new_page'] = true;
3515 }
3516 }
3517 else
3518 {
3519 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1] = array();
3520 }
3521 }
3522
3523 /**
3524 * balise : TR
3525 * mode : FERMETURE
3526 *
3527 * @param array paramètres de l'élément de parsing
3528 * @return null
3529 */
3530 function c_TR($param)
3531 {
3532 $this->maxH = 0;
3533 global $HTML2PDF_TABLEAU;
3534
3535 // restauration du style
3536 $this->style->load();
3537 $this->style->FontSet();
3538
3539 // si on est pas dans un sub_html
3540 if (!$this->sub_part)
3541 {
3542 // Y courant apres la ligne
3543 $ty=null;
3544 for($ii=0; $ii<count($HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1]); $ii++)
3545 if ($HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$ii]['rowspan']==1)
3546 $ty = $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$ii]['h'];
3547
3548 // mise à jour des coordonnées courantes
3549 $HTML2PDF_TABLEAU[$param['num']]['td_x'] = $HTML2PDF_TABLEAU[$param['num']]['curr_x']+$HTML2PDF_TABLEAU[$param['num']]['marge']['l'];
3550 $HTML2PDF_TABLEAU[$param['num']]['td_y']+= $ty;
3551 $HTML2PDF_TABLEAU[$param['num']]['new_page'] = false;
3552 }
3553 }
3554
3555 /**
3556 * balise : TD
3557 * mode : OUVERTURE
3558 *
3559 * @param array paramètres de l'élément de parsing
3560 * @return null
3561 */
3562 function o_TD($param, $other = 'td')
3563 {
3564 $this->maxH = 0;
3565 global $HTML2PDF_TABLEAU;
3566
3567 $param['cellpadding'] = $HTML2PDF_TABLEAU[$param['num']]['cellpadding'].'mm';
3568 $param['cellspacing'] = $HTML2PDF_TABLEAU[$param['num']]['cellspacing'].'mm';
3569
3570 if ($other=='li')
3571 {
3572 $special_li = true;
3573 }
3574 else
3575 {
3576 $special_li = false;
3577 if ($other=='li_sub')
3578 {
3579 $param['style']['border'] = 'none';
3580 $param['style']['background-color'] = 'transparent';
3581 $param['style']['background-image'] = 'none';
3582 $param['style']['background-position'] = '';
3583 $param['style']['background-repeat'] = '';
3584 $other = 'li';
3585 }
3586 }
3587
3588 // est-on en collapse
3589 $collapse = false;
3590 if (in_array($other, array('td', 'th')))
3591 $collapse = isset($this->style->value['border']['collapse']) ? $this->style->value['border']['collapse'] : false;
3592
3593
3594 // analyse du style
3595 $this->style->save();
3596 $this->style->analyse($other, $param);
3597
3598 if ($special_li)
3599 {
3600 $this->style->value['width']-= $this->style->ConvertToMM($this->listeGetWidth());
3601 $this->style->value['width']-= $this->style->ConvertToMM($this->listeGetPadding());
3602 }
3603 $this->style->setPosition($this->pdf->x, $this->pdf->y);
3604 $this->style->FontSet();
3605
3606 // si on est en collapse : modification du style
3607 if ($collapse)
3608 {
3609 if (!$this->sub_part)
3610 {
3611 if ($HTML2PDF_TABLEAU[$param['num']]['tr_curr']>1 && !$HTML2PDF_TABLEAU[$param['num']]['new_page'])
3612 $this->style->value['border']['t'] = $this->style->readBorder('none');
3613 }
3614
3615 if ($HTML2PDF_TABLEAU[$param['num']]['td_curr']>0)
3616 $this->style->value['border']['l'] = $this->style->readBorder('none');
3617 }
3618
3619 $marge = array();
3620 $marge['t'] = $this->style->value['padding']['t']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['t']['width'];
3621 $marge['r'] = $this->style->value['padding']['r']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['r']['width'];
3622 $marge['b'] = $this->style->value['padding']['b']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['b']['width'];
3623 $marge['l'] = $this->style->value['padding']['l']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['l']['width'];
3624
3625 // si on est dans un sub_html
3626 if ($this->sub_part)
3627 {
3628 // on se positionne dans le tableau
3629 $HTML2PDF_TABLEAU[$param['num']]['td_curr']++;
3630 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1] = array();
3631 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['w'] = 0;
3632 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['h'] = 0;
3633 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['dw'] = 0;
3634 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['colspan'] = isset($param['colspan']) ? $param['colspan'] : 1;
3635 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['rowspan'] = isset($param['rowspan']) ? $param['rowspan'] : 1;
3636
3637 // on extrait tout ce qui est contenu dans le TD
3638 $res = $this->parsing->getLevel($this->temp_pos);
3639
3640 // on en créé un sous HTML que l'on transforme en PDF
3641 // pour analyse les dimensions
3642 // et les récupérer dans le tableau global.
3643 $this->CreateSubHTML($this->sub_html);
3644 $this->sub_html->writeHTML($res[1]);
3645 $this->temp_pos = $res[0]-2;
3646 }
3647 else
3648 {
3649 // on se positionne dans le tableau
3650 $HTML2PDF_TABLEAU[$param['num']]['td_curr']++;
3651 $HTML2PDF_TABLEAU[$param['num']]['td_x']+= $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['dw'];
3652
3653 // initialisation du style des bordures de la premiere partie de tableau
3654 $this->Rectangle(
3655 $HTML2PDF_TABLEAU[$param['num']]['td_x'],
3656 $HTML2PDF_TABLEAU[$param['num']]['td_y'],
3657 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['w'],
3658 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['h'],
3659 $this->style->value['border'],
3660 $this->style->value['padding'],
3661 $HTML2PDF_TABLEAU[$param['num']]['cellspacing']*0.5,
3662 $this->style->value['background']
3663 );
3664
3665
3666 $this->style->value['width'] = $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['w'] - $marge['l'] - $marge['r'];
3667
3668 // limitation des marges aux dimensions de la case
3669 $mL = $HTML2PDF_TABLEAU[$param['num']]['td_x']+$marge['l'];
3670 $mR = $this->pdf->w - $mL - $this->style->value['width'];
3671 $this->saveMargin($mL, 0, $mR);
3672
3673 // positionnement en fonction
3674 $h_corr = $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['h'];
3675 $h_reel = $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['real_h'];
3676 switch($this->style->value['vertical-align'])
3677 {
3678 case 'bottom':
3679 $y_corr = $h_corr-$h_reel;
3680 break;
3681
3682 case 'middle':
3683 $y_corr = ($h_corr-$h_reel)*0.5;
3684 break;
3685
3686 case 'top':
3687 default:
3688 $y_corr = 0;
3689 break;
3690 }
3691
3692 $this->pdf->setX($HTML2PDF_TABLEAU[$param['num']]['td_x']+$marge['l']);
3693 $this->pdf->setY($HTML2PDF_TABLEAU[$param['num']]['td_y']+$marge['t']+$y_corr);
3694 }
3695 }
3696
3697 /**
3698 * balise : TD
3699 * mode : FERMETURE
3700 *
3701 * @param array paramètres de l'élément de parsing
3702 * @return null
3703 */
3704 function c_TD($param)
3705 {
3706 $this->maxH = 0;
3707 global $HTML2PDF_TABLEAU;
3708
3709 // récupération de la marge
3710 $marge = array();
3711 $marge['t'] = $this->style->value['padding']['t']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['t']['width'];
3712 $marge['r'] = $this->style->value['padding']['r']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['r']['width'];
3713 $marge['b'] = $this->style->value['padding']['b']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['b']['width'];
3714 $marge['l'] = $this->style->value['padding']['l']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['l']['width'];
3715 $marge['t']+= 0.01;
3716 $marge['r']+= 0.01;
3717 $marge['b']+= 0.01;
3718 $marge['l']+= 0.01;
3719
3720 // si on est dans un sub_html
3721 if ($this->sub_part)
3722 {
3723 if ($this->testTDin1page && $this->sub_html->pdf->page>1) HTML2PDF::makeError(7, __FILE__, __LINE__);
3724
3725 // dimentions de cette case
3726 $w0 = $this->sub_html->maxX + $marge['l'] + $marge['r'];
3727 $h0 = $this->sub_html->maxY + $marge['t'] + $marge['b'];
3728
3729 // dimensions imposées par le style
3730 $w2 = $this->style->value['width'] + $marge['l'] + $marge['r'];
3731 $h2 = $this->style->value['height'] + $marge['t'] + $marge['b'];
3732
3733 // dimension finale de la case = max des 2 ci-dessus
3734 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['w'] = max(array($w0, $w2));
3735 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['h'] = max(array($h0, $h2));
3736
3737 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['real_w'] = $w0;
3738 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['real_h'] = $h0;
3739
3740 // suppresion du sous_html
3741 $this->DestroySubHTML();
3742 }
3743 else
3744 {
3745 $this->loadMargin();
3746 //positionnement
3747 $HTML2PDF_TABLEAU[$param['num']]['td_x']+= $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['w'];
3748 }
3749
3750 // restauration du style
3751 $this->style->load();
3752 $this->style->FontSet();
3753 }
3754
3755 function calculTailleCases(&$cases)
3756 {
3757 // construction d'un tableau de correlation
3758 $corr = array();
3759
3760 // on fait correspondre chaque case d'un tableau normé aux cases réelles, en prennant en compte les colspan et rowspan
3761 $Yr=0;
3762 for($y=0; $y<count($cases); $y++)
3763 {
3764 $Xr=0; while(isset($corr[$Yr][$Xr])) $Xr++;
3765
3766 for($x=0; $x<count($cases[$y]); $x++)
3767 {
3768 for($j=0; $j<$cases[$y][$x]['rowspan']; $j++)
3769 {
3770 for($i=0; $i<$cases[$y][$x]['colspan']; $i++)
3771 {
3772 $corr[$Yr+$j][$Xr+$i] = ($i+$j>0) ? '' : array($x, $y, $cases[$y][$x]['colspan'], $cases[$y][$x]['rowspan']);
3773 }
3774 }
3775 $Xr+= $cases[$y][$x]['colspan'];
3776 while(isset($corr[$Yr][$Xr])) $Xr++;
3777 }
3778 $Yr++;
3779 }
3780
3781 if (!isset($corr[0])) return true;
3782
3783 // on détermine, pour les cases sans colspan, la largeur maximale de chaque colone
3784 $sw = array();
3785 for($x=0; $x<count($corr[0]); $x++)
3786 {
3787 $m=0;
3788 for($y=0; $y<count($corr); $y++)
3789 if (isset($corr[$y][$x]) && is_array($corr[$y][$x]) && $corr[$y][$x][2]==1)
3790 $m = max($m, $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w']);
3791 $sw[$x] = $m;
3792 }
3793
3794 // on vérifie que cette taille est valide avec les colones en colspan
3795 for($x=0; $x<count($corr[0]); $x++)
3796 {
3797 for($y=0; $y<count($corr); $y++)
3798 {
3799 if (isset($corr[$y][$x]) && is_array($corr[$y][$x]) && $corr[$y][$x][2]>1)
3800 {
3801 // somme des colonnes correspondant au colspan
3802 $s = 0; for($i=0; $i<$corr[$y][$x][2]; $i++) $s+= $sw[$x+$i];
3803
3804 // si la somme est inférieure à la taille necessaire => règle de 3 pour adapter
3805 if ($s>0 && $s<$cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w'])
3806 for($i=0; $i<$corr[$y][$x][2]; $i++)
3807 $sw[$x+$i] = $sw[$x+$i]/$s*$cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w'];
3808 }
3809 }
3810 }
3811
3812 // on applique les nouvelles largeurs
3813 for($x=0; $x<count($corr[0]); $x++)
3814 {
3815 for($y=0; $y<count($corr); $y++)
3816 {
3817 if (isset($corr[$y][$x]) && is_array($corr[$y][$x]))
3818 {
3819 if ($corr[$y][$x][2]==1)
3820 {
3821 $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w'] = $sw[$x];
3822 }
3823 else
3824 {
3825 // somme des colonnes correspondant au colspan
3826 $s = 0; for($i=0; $i<$corr[$y][$x][2]; $i++) $s+= $sw[$x+$i];
3827 $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w'] = $s;
3828 }
3829 }
3830 }
3831 }
3832
3833 // on détermine, pour les cases sans rowspan, la hauteur maximale de chaque colone
3834 $sh = array();
3835 for($y=0; $y<count($corr); $y++)
3836 {
3837 $m=0;
3838 for($x=0; $x<count($corr[0]); $x++)
3839 if (isset($corr[$y][$x]) && is_array($corr[$y][$x]) && $corr[$y][$x][3]==1)
3840 $m = max($m, $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['h']);
3841 $sh[$y] = $m;
3842 }
3843
3844
3845 // on vérifie que cette taille est valide avec les lignes en rowspan
3846 for($y=0; $y<count($corr); $y++)
3847 {
3848 for($x=0; $x<count($corr[0]); $x++)
3849 {
3850 if (isset($corr[$y][$x]) && is_array($corr[$y][$x]) && $corr[$y][$x][3]>1)
3851 {
3852 // somme des colonnes correspondant au colspan
3853 $s = 0; for($i=0; $i<$corr[$y][$x][3]; $i++) $s+= $sh[$y+$i];
3854
3855 // si la somme est inférieure à la taille necessaire => règle de 3 pour adapter
3856 if ($s>0 && $s<$cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['h'])
3857 for($i=0; $i<$corr[$y][$x][3]; $i++)
3858 $sh[$y+$i] = $sh[$y+$i]/$s*$cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['h'];
3859 }
3860 }
3861 }
3862
3863
3864 // on applique les nouvelles hauteurs
3865 for($y=0; $y<count($corr); $y++)
3866 {
3867 for($x=0; $x<count($corr[0]); $x++)
3868 {
3869 if (isset($corr[$y][$x]) && is_array($corr[$y][$x]))
3870 {
3871 if ($corr[$y][$x][3]==1)
3872 {
3873 $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['h'] = $sh[$y];
3874 }
3875 else
3876 {
3877 // somme des lignes correspondant au rowspan
3878 $s = 0; for($i=0; $i<$corr[$y][$x][3]; $i++) $s+= $sh[$y+$i];
3879 $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['h'] = $s;
3880
3881 for($j=1; $j<$corr[$y][$x][3]; $j++)
3882 {
3883 $tx = $x+1;
3884 $ty = $y+$j;
3885 for(true; isset($corr[$ty][$tx]) && !is_array($corr[$ty][$tx]); $tx++);
3886 if (isset($corr[$ty][$tx])) $cases[$corr[$ty][$tx][1]][$corr[$ty][$tx][0]]['dw']+= $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w'];
3887
3888 }
3889 }
3890 }
3891 }
3892 }
3893 }
3894
3895 /**
3896 * balise : TH
3897 * mode : OUVERTURE
3898 *
3899 * @param array paramètres de l'élément de parsing
3900 * @return null
3901 */
3902 function o_TH($param)
3903 {
3904 $this->maxH = 0;
3905 // identique à TD mais en gras
3906 if (!isset($param['style']['font-weight'])) $param['style']['font-weight'] = 'bold';
3907 $this->o_TD($param, 'th');
3908 }
3909
3910 /**
3911 * balise : TH
3912 * mode : FERMETURE
3913 *
3914 * @param array paramètres de l'élément de parsing
3915 * @return null
3916 */
3917 function c_TH($param)
3918 {
3919 $this->maxH = 0;
3920 // identique à TD
3921 $this->c_TD($param);
3922 }
3923
3924 /**
3925 * balise : IMG
3926 * mode : OUVERTURE
3927 *
3928 * @param array paramètres de l'élément de parsing
3929 * @return null
3930 */
3931 function o_IMG($param)
3932 {
3933 // analyse du style
3934 $src = str_replace('&amp;', '&', $param['src']);
3935
3936 $this->style->save();
3937 $this->style->value['width'] = 0;
3938 $this->style->value['height'] = 0;
3939 $this->style->value['border'] = array(
3940 'type' => 'none',
3941 'width' => 0,
3942 'color' => array(0, 0, 0),
3943 );
3944 $this->style->value['background'] = array(
3945 'color' => null,
3946 'image' => null,
3947 'position' => null,
3948 'repeat' => null
3949 );
3950 $this->style->analyse('img', $param);
3951 $this->style->setPosition($this->pdf->x, $this->pdf->y);
3952 $this->style->FontSet();
3953
3954 // affichage de l'image
3955 $this->Image($src, isset($param['sub_li']));
3956
3957 // restauration du style
3958 $this->style->load();
3959 $this->style->FontSet();
3960 }
3961
3962 /**
3963 * balise : SELECT
3964 * mode : OUVERTURE
3965 *
3966 * @param array paramètres de l'élément de parsing
3967 * @return null
3968 */
3969 function o_SELECT($param)
3970 {
3971 // preparation du champs
3972 if (!isset($param['name'])) $param['name'] = 'champs_pdf_'.(count($this->lstChamps)+1);
3973
3974 $param['name'] = strtolower($param['name']);
3975
3976 if (isset($this->champs[$param['name']]))
3977 $this->champs[$param['name']]++;
3978 else
3979 $this->champs[$param['name']] = 1;
3980
3981 $this->style->save();
3982 $this->style->analyse('select', $param);
3983 $this->style->setPosition($this->pdf->x, $this->pdf->y);
3984 $this->style->FontSet();
3985
3986 $this->lstSelect = array();
3987 $this->lstSelect['name'] = $param['name'];
3988 $this->lstSelect['multi'] = isset($param['multiple']) ? true : false;
3989 $this->lstSelect['size'] = isset($param['size']) ? $param['size'] : 1;
3990 $this->lstSelect['options'] = array();
3991
3992 if ($this->lstSelect['multi'] && $this->lstSelect['size']<3) $this->lstSelect['size'] = 3;
3993 }
3994
3995 /**
3996 * balise : OPTION
3997 * mode : OUVERTURE
3998 *
3999 * @param array paramètres de l'élément de parsing
4000 * @return null
4001 */
4002 function o_OPTION($param)
4003 {
4004 // on extrait tout ce qui est contenu dans l'option
4005 $res = $this->parsing->getLevel($this->parse_pos);
4006 $this->parse_pos = $res[0]-2;
4007 $texte = $res[1];
4008 $value = isset($param['value']) ? $param['value'] : 'auto_opt_'.(count($this->lstSelect)+1);
4009
4010 $this->lstSelect['options'][$value] = $texte;
4011 }
4012
4013 /**
4014 * balise : OPTION
4015 * mode : FERMETURE
4016 *
4017 * @param array paramètres de l'élément de parsing
4018 * @return null
4019 */
4020 function c_OPTION($param) { }
4021
4022 /**
4023 * balise : SELECT
4024 * mode : FERMETURE
4025 *
4026 * @param array paramètres de l'élément de parsing
4027 * @return null
4028 */
4029 function c_SELECT()
4030 {
4031 // position d'affichage
4032 $x = $this->pdf->getX();
4033 $y = $this->pdf->getY();
4034 $f = 1.08*$this->style->value['font-size'];
4035
4036 $w = $this->style->value['width']; if (!$w) $w = 50;
4037 $h = ($f*1.07*$this->lstSelect['size'] + 1);
4038 $prop = array();
4039 if ($this->lstSelect['multi']) $prop['multipleSelection'] = true;
4040 $this->pdf->form_Select($this->lstSelect['name'], $x, $y, $w, $h, $this->lstSelect['options'], $this->lstSelect['size']>1, $prop);
4041
4042 $this->maxX = max($this->maxX, $x+$w);
4043 $this->maxY = max($this->maxY, $y+$h);
4044 $this->maxH = max($this->maxH, $h);
4045 $this->pdf->setX($x+$w);
4046
4047 $this->style->load();
4048 $this->style->FontSet();
4049
4050 $this->lstSelect = array();
4051 }
4052
4053 /**
4054 * balise : TEXTAREA
4055 * mode : OUVERTURE
4056 *
4057 * @param array paramètres de l'élément de parsing
4058 * @return null
4059 */
4060 function o_TEXTAREA($param)
4061 {
4062 // preparation du champs
4063 if (!isset($param['name'])) $param['name'] = 'champs_pdf_'.(count($this->lstChamps)+1);
4064
4065 $param['name'] = strtolower($param['name']);
4066
4067 if (isset($this->champs[$param['name']]))
4068 $this->champs[$param['name']]++;
4069 else
4070 $this->champs[$param['name']] = 1;
4071
4072 $this->style->save();
4073 $this->style->analyse('textarea', $param);
4074 $this->style->setPosition($this->pdf->x, $this->pdf->y);
4075 $this->style->FontSet();
4076
4077 // position d'affichage
4078 $x = $this->pdf->getX();
4079 $y = $this->pdf->getY();
4080 $fx = 0.65*$this->style->value['font-size'];
4081 $fy = 1.08*$this->style->value['font-size'];
4082
4083 // on extrait tout ce qui est contenu dans le textarea
4084 $res = $this->parsing->getLevel($this->parse_pos);
4085 $this->parse_pos = $res[0]-2;
4086 $texte = $res[1];
4087
4088 $w = $fx*(isset($param['cols']) ? $param['cols'] : 22)+1;
4089 $h = $fy*1.07*(isset($param['rows']) ? $param['rows'] : 3)+3;
4090
4091// if ($this->style->value['width']) $w = $this->style->value['width'];
4092// if ($this->style->value['height']) $h = $this->style->value['height'];
4093
4094 $prop = array();
4095 $prop['value'] = $texte;
4096 $prop['multiline'] = true;
4097
4098 $this->pdf->form_InputText($param['name'], $x, $y, $w, $h, $prop);
4099
4100 $this->maxX = max($this->maxX, $x+$w);
4101 $this->maxY = max($this->maxY, $y+$h);
4102 $this->maxH = max($this->maxH, $h);
4103 $this->pdf->setX($x+$w);
4104
4105 }
4106
4107 /**
4108 * balise : TEXTAREA
4109 * mode : FERMETURE
4110 *
4111 * @param array paramètres de l'élément de parsing
4112 * @return null
4113 */
4114 function c_TEXTAREA()
4115 {
4116 $this->style->load();
4117 $this->style->FontSet();
4118 }
4119
4120 /**
4121 * balise : INPUT
4122 * mode : OUVERTURE
4123 *
4124 * @param array paramètres de l'élément de parsing
4125 * @return null
4126 */
4127 function o_INPUT($param)
4128 {
4129 // preparation du champs
4130 if (!isset($param['name'])) $param['name'] = 'champs_pdf_'.(count($this->lstChamps)+1);
4131 if (!isset($param['value'])) $param['value'] = '';
4132 if (!isset($param['type'])) $param['type'] = 'text';
4133
4134 $param['name'] = strtolower($param['name']);
4135 $param['type'] = strtolower($param['type']);
4136
4137 if (!in_array($param['type'], array('text', 'checkbox', 'radio', 'hidden', 'submit', 'reset', 'button'))) $param['type'] = 'text';
4138
4139 if (isset($this->champs[$param['name']]))
4140 $this->champs[$param['name']]++;
4141 else
4142 $this->champs[$param['name']] = 1;
4143
4144 $this->style->save();
4145 $this->style->analyse('input', $param);
4146 $this->style->setPosition($this->pdf->x, $this->pdf->y);
4147 $this->style->FontSet();
4148
4149 $name = $param['name'];
4150
4151 // position d'affichage
4152 $x = $this->pdf->getX();
4153 $y = $this->pdf->getY();
4154 $f = 1.08*$this->style->value['font-size'];
4155
4156 switch($param['type'])
4157 {
4158 case 'checkbox':
4159 $w = 3;
4160 $h = $w;
4161 if ($h<$f) $y+= ($f-$h)*0.5;
4162 $this->pdf->form_InputCheckBox($name, $x, $y, $w, isset($param['checked']));
4163 break;
4164
4165 case 'radio':
4166 $w = 3;
4167 $h = $w;
4168 if ($h<$f) $y+= ($f-$h)*0.5;
4169 $this->pdf->form_InputRadio($name, $x, $y, $w);
4170 break;
4171
4172 case 'hidden':
4173 $w = 0;
4174 $h = 0;
4175 $this->pdf->form_InputHidden($name, $param['value']);
4176 break;
4177
4178 case 'text':
4179 $w = $this->style->value['width']; if (!$w) $w = 40;
4180 $h = $f*1.3;
4181 $prop = array();
4182 $prop['value'] = $param['value'];
4183 $this->pdf->form_InputText($name, $x, $y, $w, $h, $prop);
4184 break;
4185
4186 case 'submit':
4187 case 'reset':
4188 case 'button':
4189 $action = isset($param['onclick']) ? $param['onclick'] : '';
4190 $w = $this->style->value['width']; if (!$w) $w = 40;
4191 $h = $this->style->value['height']; if (!$h) $h = $f*1.3;
4192 $prop = array();
4193 $this->pdf->form_InputButton($name, $x, $y, $w, $h, $param['value'], $action, $prop);
4194 break;
4195
4196 default:
4197 $w = 0;
4198 $h = 0;
4199 break;
4200 }
4201
4202 $this->maxX = max($this->maxX, $x+$w);
4203 $this->maxY = max($this->maxY, $y+$h);
4204 $this->maxH = max($this->maxH, $h);
4205 $this->pdf->setX($x+$w);
4206
4207 $this->style->load();
4208 $this->style->FontSet();
4209 }
4210
4211 function textLOAD($langue)
4212 {
4213 if (!preg_match('/^([a-z0-9]+)$/isU', $langue))
4214 {
4215 echo 'ERROR : language code <b>'.$langue.'</b> incorrect.';
4216 exit;
4217 }
4218
4219 $file = dirname(__FILE__).'/langues/'.strtolower($langue).'.txt';
4220 if (!is_file($file))
4221 {
4222 echo 'ERROR : language code <b>'.$langue.'</b> unknown.<br>';
4223 echo 'You can create the translation file <b>'.$file.'</b> and send it to me in order to integrate it into a future version.';
4224 exit;
4225 }
4226
4227 $texte = array();
4228 $infos = file($file);
4229 foreach($infos as $val)
4230 {
4231 $val = trim($val);
4232 $val = explode("\t", $val);
4233 if (count($val)<2) continue;
4234
4235 $t_k = trim($val[0]); unset($val[0]);
4236 $t_v = trim(implode(' ', $val));
4237 if ($t_k && $t_v) $texte[$t_k] = $t_v;
4238 }
4239 global $HTML2PDF_TEXTE_FILE;
4240 $HTML2PDF_TEXTE_FILE = $texte;
4241 }
4242
4243 function textGET($key)
4244 {
4245 global $HTML2PDF_TEXTE_FILE;
4246 if (!isset($HTML2PDF_TEXTE_FILE[$key])) return '######';
4247
4248 return $HTML2PDF_TEXTE_FILE[$key];
4249 }
4250
4251 function makeError($err, $file, $line, $other = null)
4252 {
4253 $msg = '';
4254 switch($err)
4255 {
4256 case 1:
4257 $msg = (HTML2PDF::textGET('err01'));
4258 $msg = str_replace('[[OTHER]]', $other, $msg);
4259 break;
4260
4261 case 2:
4262 $msg = (HTML2PDF::textGET('err02'));
4263 $msg = str_replace('[[OTHER_0]]', $other[0], $msg);
4264 $msg = str_replace('[[OTHER_1]]', $other[1], $msg);
4265 $msg = str_replace('[[OTHER_2]]', $other[2], $msg);
4266 break;
4267
4268 case 3:
4269 $msg = (HTML2PDF::textGET('err03'));
4270 $msg = str_replace('[[OTHER]]', $other, $msg);
4271 break;
4272
4273 case 4:
4274 $msg = (HTML2PDF::textGET('err04'));
4275 $msg = str_replace('[[OTHER]]', print_r($other, true), $msg);
4276 break;
4277
4278 case 5:
4279 $msg = (HTML2PDF::textGET('err05'));
4280 $msg = str_replace('[[OTHER]]', print_r($other, true), $msg);
4281 break;
4282
4283 case 6:
4284 $msg = (HTML2PDF::textGET('err06'));
4285 $msg = str_replace('[[OTHER]]', $other, $msg);
4286 break;
4287
4288 case 7:
4289 $msg = (HTML2PDF::textGET('err07'));
4290 break;
4291 }
4292 echo '<span style="color: #AA0000; font-weight: bold;">'.(HTML2PDF::textGET('txt01')).$err.'</span><br>';
4293 echo (HTML2PDF::textGET('txt02')).' '.$file.'<br>';
4294 echo (HTML2PDF::textGET('txt03')).' '.$line.'<br>';
4295 echo '<br>';
4296 echo $msg;
4297 exit;
4298 }
4299 }
4300}
4301
Note: See TracBrowser for help on using the repository browser.