?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added HTML2PDF and FPDI to the project.
[openemr.git] / library / html2pdf / html2pdf.class.php
blob1c550fa71077b6e5b83a7e3ddcbdcc8dfbda2bd9
1 <?php
2 /**
3 * Logiciel : HTML2PDF
4 *
5 * Convertisseur HTML => PDF, utilise FPDF
6 * Distribué sous la licence LGPL.
7 *
8 * @author Laurent MINGUET <webmaster@html2pdf.fr>
9 * @version 3.31
10 */
11
12 if (!defined('__CLASS_HTML2PDF__'))
13 {
14 define('__CLASS_HTML2PDF__', '3.31');
15
16 require_once(dirname(__FILE__).'/_mypdf/mypdf.class.php'); // classe mypdf
17 require_once(dirname(__FILE__).'/parsingHTML.class.php'); // classe de parsing HTML
18 require_once(dirname(__FILE__).'/styleHTML.class.php'); // classe de gestion des styles
19
20 global $HTML2PDF_TABLEAU; $HTML2PDF_TABLEAU = array(); // tableau global necessaire à la gestion des tables imbriquées
21 global $HTML2PDF_TEXTES; $HTML2PDF_TEXTES = array(); // tableau comprennant le fichier de langue
22
23 class HTML2PDF
24 {
25 var $pdf = null; // objet PDF
26 var $style = null; // objet de style
27 var $parsing = null; // objet de parsing
28
29 var $langue = 'fr'; // langue des messages
30 var $sens = 'P'; // sens d'affichage Portrait ou Landscape
31 var $format = 'A4'; // format de la page : A4, A3, ...
32 var $encoding = ''; // charset encoding
33
34 var $background = array(); // informations sur le background
35 var $testTDin1page = true; // activer le test de TD ne devant pas depasser une page
36 var $testIsImage = true; // test si les images existes ou non
37 var $testIsDeprecated = false; // test si certaines fonctions sont deprecated
38 var $isSubPart = false; // indique que le convertisseur courant est un sous html
39
40 var $parse_pos = 0; // position du parsing
41 var $temp_pos = 0; // position temporaire pour multi tableau
42 var $page = 0; // numero de la page courante
43
44 var $sub_html = null; // sous html
45 var $sub_part = false; // indicateur de sous html
46
47 var $maxX = 0; // zone maxi X
48 var $maxY = 0; // zone maxi Y
49 var $maxE = 0; // nomre d'elements dans la zone
50 var $maxH = 0; // plus grande hauteur dans la ligne, pour saut de ligne à corriger
51 var $maxSave = array(); // tableau de sauvegarde des maximaux
52 var $currentH = 0; // hauteur de la ligne courante
53
54 var $firstPage = true; // premier page
55
56 var $defaultLeft = 0; // marges par default de la page
57 var $defaultTop = 0;
58 var $defaultRight = 0;
59 var $defaultBottom = 0;
60
61 var $margeLeft = 0; //marges réelles de la page
62 var $margeTop = 0;
63 var $margeRight = 0;
64 var $margeBottom = 0;
65 var $marges = array(); // tableau de sauvegarde des differents etats des marges de la page courante
66
67 var $inLink = ''; // indique si on est à l'interieur d'un lien
68 var $lstAncre = array(); // liste des ancres détectées ou créées
69 var $subHEADER = array(); // tableau des sous commandes pour faire l'HEADER
70 var $subFOOTER = array(); // tableau des sous commandes pour faire le FOOTER
71 var $subSTATES = array(); // tableau de sauvegarde de certains paramètres
72 var $defLIST = array(); // tableau de sauvegarde de l'etat des UL et OL
73
74 var $lstChamps = array(); // liste des champs
75 var $lstSelect = array(); // options du select en cours
76 var $previousCall = null; // dernier appel
77 var $pageMarges = array(); // marges spécifiques dues aux floats
78 var $isInThead = false; // indique si on est dans un thead
79 var $isInTfoot = false; // indique si on est dans un tfoot
80 var $isInOverflow = false; // indique si on est dans une div overflow
81 var $isInFooter = false; // indique si on est dans un footer ou non
82 var $isInDraw = null; // indique si on est en mode dessin
83 var $isAfterFloat = false; // indique si on est apres un float
84 var $forOneLine = false; // indique si on est dans un sous HTML ne servant qu'a calculer la taille de la prochaine ligne
85 var $isInForm = false; // indique si on est dans un formulaire. Contient dans ce cas là l'action de celui-ci
86
87 var $DEBUG_actif = false; // indique si on est en mode debug
88 var $DEBUG_ok_usage = false; // indique l'existance de la fonction memory_get_usage
89 var $DEBUG_ok_peak = false; // indique l'existance de la fonction memory_get_peak_usage
90 var $DEBUG_level = 0; // niveau du debug
91 var $DEBUG_start_time = 0; //
92 var $DEBUG_last_time = 0; //
93 var $defaultFont = null; // fonte par défaut si la fonte demandée n'existe pas
94
95 /**
96 * Constructeur
97 *
98 * @param string sens portrait ou landscape
99 * @param string format A4, A5, ...
100 * @param string langue : fr, en, it...
101 * @param array marges par defaut, dans l'ordre (left, top, right, bottom)
102 * @return null
103 */
104 function HTML2PDF($sens = 'P', $format = 'A4', $langue='fr', $marges = array(5, 5, 5, 8))
105 {
106 // sauvegarde des paramètres
107 $this->page = 0;
108 $this->sens = $sens;
109 $this->format = $format;
110 $this->encoding = 'ISO-8859-15';
111
112 $this->firstPage = true;
113 $this->langue = strtolower($langue);
114
115 // chargement du fichier de langue
116 HTML2PDF::textLOAD($this->langue);
117
118 // création de l' objet PDF
119 $this->pdf = new MyPDF($sens, 'mm', $format);
120
121 // initialisation des styles
122 $this->style = new styleHTML($this->pdf);
123 $this->style->FontSet();
124 $this->defLIST = array();
125
126 // initialisations diverses
127 $this->setTestTdInOnePage(true);
128 $this->setTestIsImage(true);
129 $this->setTestIsDeprecated(true);
130 $this->setDefaultFont(null);
131
132 // initialisation du parsing
133 $this->parsing = new parsingHTML($this->encoding);
134 $this->sub_html = null;
135 $this->sub_part = false;
136
137 // initialisation des marges
138 if (!is_array($marges)) $marges = array($marges, $marges, $marges, $marges);
139 $this->setDefaultMargins($marges[0], $marges[1], $marges[2], $marges[3]);
140 $this->setMargins();
141 $this->marges = array();
142
143 // initialisation des champs de formulaire
144 $this->lstChamps = array();
145 }
146
147 /**
148 * activer le debug mode
149 *
150 * @return null
151 */
152 function setModeDebug()
153 {
154 list($usec, $sec) = explode(' ', microtime());
155
156 $this->DEBUG_actif = true;
157 $this->DEBUG_ok_usage = function_exists('memory_get_usage');
158 $this->DEBUG_ok_peak = function_exists('memory_get_peak_usage');
159 $this->DEBUG_start_time = (float)$sec + (float)$usec;
160 $this->DEBUG_last_time = (float)$sec + (float)$usec;
161
162 $this->DEBUG_stepline('step', 'time', 'delta', 'memory', 'peak');
163 $this->DEBUG_add('Init debug');
164 }
165
166 /**
167 * rajouter une ligne de debug
168 *
169 * @param string nom de l'etape
170 * @param boolean true=monter d'un niveau, false=descendre d'un niveau, null : ne rien faire
171 * @return null
172 */
173 function DEBUG_add($nom, $level=null)
174 {
175 list($usec, $sec) = explode(' ', microtime());
176 if ($level===true) $this->DEBUG_level++;
177
178 $nom = str_repeat(' ',$this->DEBUG_level). $nom.($level===true ? ' Begin' : ($level===false ? ' End' : ''));
179 $time = (float)$sec + (float)$usec;
180 $usage = ($this->DEBUG_ok_usage ? memory_get_usage() : 0);
181 $peak = ($this->DEBUG_ok_peak ? memory_get_peak_usage() : 0);
182
183 $this->DEBUG_stepline(
184 $nom,
185 number_format(($time - $this->DEBUG_start_time)*1000, 1, '.', ' ').' ms',
186 number_format(($time - $this->DEBUG_last_time)*1000, 1, '.', ' ').' ms',
187 number_format($usage/1024, 1, '.', ' ').' Ko',
188 number_format($peak/1024, 1, '.', ' ').' Ko');
189
190 $this->DEBUG_last_time = $time;
191 if ($level===false) $this->DEBUG_level--;
192 return true;
193 }
194
195 /**
196 * affiche une ligne de debug
197 *
198 * @param string nom de l'etape
199 * @param string valeur 1
200 * @param string valeur 2
201 * @param string valeur 3
202 * @param string valeur 4
203 * @return null
204 */
205 function DEBUG_stepline($nom, $val1, $val2, $val3, $val4)
206 {
207 $txt = str_pad($nom, 30, ' ', STR_PAD_RIGHT).
208 str_pad($val1, 12, ' ', STR_PAD_LEFT).
209 str_pad($val2, 12, ' ', STR_PAD_LEFT).
210 str_pad($val3, 15, ' ', STR_PAD_LEFT).
211 str_pad($val4, 15, ' ', STR_PAD_LEFT);
212
213 echo '<pre style="padding:0; margin:0">'.$txt.'</pre>';
214 }
215
216 /**
217 * renseigner l'encoding à utiliser
218 *
219 * @param string nouvel encoding
220 * @return string ancien encoding
221 */
222 function setEncoding($encoding = 'ISO-8859-15')
223 {
224 $old = $this->encoding;
225 $this->encoding = $encoding;
226 $this->parsing->setEncoding($this->encoding);
227 return $old;
228 }
229
230 /**
231 * activer ou desactiver le test de TD ne devant pas depasser une page
232 *
233 * @param boolean nouvel etat
234 * @return boolean ancien etat
235 */
236 function setTestTdInOnePage($mode = true)
237 {
238 $old = $this->testTDin1page;
239 $this->testTDin1page = $mode ? true : false;
240 return $old;
241 }
242
243 /**
244 * activer ou desactiver le test sur la présence des images
245 *
246 * @param boolean nouvel etat
247 * @return boolean ancien etat
248 */
249 function setTestIsImage($mode = true)
250 {
251 $old = $this->testIsImage;
252 $this->testIsImage = $mode ? true : false;
253 return $old;
254 }
255
256 /**
257 * activer ou desactiver le test sur les fonctions deprecated
258 *
259 * @param boolean nouvel etat
260 * @return boolean ancien etat
261 */
262 function setTestIsDeprecated($mode = true)
263 {
264 $old = $this->testIsDeprecated;
265 $this->testIsDeprecated = $mode ? true : false;
266 return $old;
267 }
268
269 /**
270 * définit la fonte par défaut si aucun fonte n'est spécifiée, ou si la fonte demandée n'existe pas
271 *
272 * @param string nom de la fonte par defaut. si null : Arial pour fonte non spécifiée, et erreur pour fonte non existante
273 * @return string nom de l'ancienne fonte par defaut
274 */
275 function setDefaultFont($default = null)
276 {
277 $old = $this->defaultFont;
278 $this->defaultFont = $default;
279 $this->style->setDefaultFont($default);
280 return $old;
281 }
282
283 /**
284 * définir les marges par défault
285 *
286 * @param int en mm, marge left
287 * @param int en mm, marge top
288 * @param int en mm, marge right. si null, left=right
289 * @param int en mm, marge bottom. si null, bottom=8
290 * @return null
291 */
292 function setDefaultMargins($left, $top, $right = null, $bottom = null)
293 {
294 if ($right===null) $right = $left;
295 if ($bottom===null) $bottom = 8;
296
297 $this->defaultLeft = $this->style->ConvertToMM($left.'mm');
298 $this->defaultTop = $this->style->ConvertToMM($top.'mm');
299 $this->defaultRight = $this->style->ConvertToMM($right.'mm');
300 $this->defaultBottom = $this->style->ConvertToMM($bottom.'mm');
301 }
302
303 /**
304 * définir les marges réelles, fonctions de la balise page
305 *
306 * @return null
307 */
308 function setMargins()
309 {
310 $this->margeLeft = $this->defaultLeft + (isset($this->background['left']) ? $this->background['left'] : 0);
311 $this->margeRight = $this->defaultRight + (isset($this->background['right']) ? $this->background['right'] : 0);
312 $this->margeTop = $this->defaultTop + (isset($this->background['top']) ? $this->background['top'] : 0);
313 $this->margeBottom = $this->defaultBottom + (isset($this->background['bottom']) ? $this->background['bottom'] : 0);
314
315 $this->pdf->SetMargins($this->margeLeft, $this->margeTop, $this->margeRight);
316 $this->pdf->setcMargin(0);
317 $this->pdf->SetAutoPageBreak(false, $this->margeBottom);
318
319 $this->pageMarges = array();
320 $this->pageMarges[floor($this->margeTop*100)] = array($this->margeLeft, $this->pdf->getW()-$this->margeRight);
321 }
322
323 /**
324 * recuperer les positions x minimales et maximales en fonction d'une hauteur
325 *
326 * @param float y
327 * @return array(float, float)
328 */
329 function getMargins($y)
330 {
331 $y = floor($y*100);
332 $x = array($this->pdf->getlMargin(), $this->pdf->getW()-$this->pdf->getrMargin());
333
334 foreach($this->pageMarges as $m_y => $m_x)
335 if ($m_y<=$y) $x = $m_x;
336
337 return $x;
338 }
339
340 /**
341 * ajouter une marge suite a un float
342 *
343 * @param string left ou right
344 * @param float x1
345 * @param float y1
346 * @param float x2
347 * @param float y2
348 * @return null
349 */
350 function addMargins($float, $x1, $y1, $x2, $y2)
351 {
352 $old1 = $this->getMargins($y1);
353 $old2 = $this->getMargins($y2);
354 if ($float=='left') $old1[0] = $x2;
355 if ($float=='right') $old1[1] = $x1;
356
357 $y1 = floor($y1*100);
358 $y2 = floor($y2*100);
359
360 foreach($this->pageMarges as $m_y => $m_x)
361 {
362 if ($m_y<$y1) continue;
363 if ($m_y>$y2) break;
364 if ($float=='left' && $this->pageMarges[$m_y][0]<$x2) unset($this->pageMarges[$m_y]);
365 if ($float=='right' && $this->pageMarges[$m_y][1]>$x1) unset($this->pageMarges[$m_y]);
366 }
367
368 $this->pageMarges[$y1] = $old1;
369 $this->pageMarges[$y2] = $old2;
370
371 ksort($this->pageMarges);
372
373 $this->isAfterFloat = true;
374 }
375
376 /**
377 * définir des nouvelles marges et sauvegarder les anciennes
378 *
379 * @param float marge left
380 * @param float marge top
381 * @param float marge right
382 * @return null
383 */
384 function saveMargin($ml, $mt, $mr)
385 {
386 $this->marges[] = array('l' => $this->pdf->getlMargin(), 't' => $this->pdf->gettMargin(), 'r' => $this->pdf->getrMargin(), 'page' => $this->pageMarges);
387 $this->pdf->SetMargins($ml, $mt, $mr);
388
389 $this->pageMarges = array();
390 $this->pageMarges[floor($mt*100)] = array($ml, $this->pdf->getW()-$mr);
391 }
392
393 /**
394 * récuperer les dernières marches sauvées
395 *
396 * @return null
397 */
398 function loadMargin()
399 {
400 $old = array_pop($this->marges);
401 if ($old)
402 {
403 $ml = $old['l'];
404 $mt = $old['t'];
405 $mr = $old['r'];
406 $mP = $old['page'];
407 }
408 else
409 {
410 $ml = $this->margeLeft;
411 $mt = 0;
412 $mr = $this->margeRight;
413 $mP = array($mt => array($ml, $this->pdf->getW()-$mr));
414 }
415
416 $this->pdf->SetMargins($ml, $mt, $mr);
417 $this->pageMarges = $mP;
418 }
419
420 /**
421 * permet d'ajouter une fonte.
422 *
423 * @param string nom de la fonte
424 * @param string style de la fonte
425 * @param string fichier de la fonte
426 * @return null
427 */
428 function addFont($family, $style='', $file='')
429 {
430 $this->pdf->AddFont($family, $style, $file);
431 }
432
433 /**
434 * sauvegarder l'état actuelle des maximums
435 *
436 * @return null
437 */
438 function saveMax()
439 {
440 $this->maxSave[] = array($this->maxX, $this->maxY, $this->maxH, $this->maxE);
441 }
442
443 /**
444 * charger le dernier état sauvé des maximums
445 *
446 * @return null
447 */
448 function loadMax()
449 {
450 $old = array_pop($this->maxSave);
451
452 if ($old)
453 {
454 $this->maxX = $old[0];
455 $this->maxY = $old[1];
456 $this->maxH = $old[2];
457 $this->maxE = $old[3];
458 }
459 else
460 {
461 $this->maxX = 0;
462 $this->maxY = 0;
463 $this->maxH = 0;
464 $this->maxE = 0;
465 }
466 }
467
468 /**
469 * afficher l'header contenu dans page_header
470 *
471 * @return null
472 */
473 function setPageHeader()
474 {
475 if (!count($this->subHEADER)) return false;
476
477 $OLD_parse_pos = $this->parse_pos;
478 $OLD_parse_code = $this->parsing->code;
479
480 $this->parse_pos = 0;
481 $this->parsing->code = $this->subHEADER;
482 $this->makeHTMLcode();
483
484 $this->parse_pos = $OLD_parse_pos;
485 $this->parsing->code = $OLD_parse_code;
486 }
487
488 /**
489 * afficher le footer contenu dans page_footer
490 *
491 * @return null
492 */
493 function setPageFooter()
494 {
495 if (!count($this->subFOOTER)) return false;
496
497 $OLD_parse_pos = $this->parse_pos;
498 $OLD_parse_code = $this->parsing->code;
499
500 $this->parse_pos = 0;
501 $this->parsing->code = $this->subFOOTER;
502 $this->isInFooter = true;
503 $this->makeHTMLcode();
504 $this->isInFooter = false;
505
506 $this->parse_pos = $OLD_parse_pos;
507 $this->parsing->code = $OLD_parse_code;
508 }
509
510 /**
511 * saut de ligne avec une hauteur spécifique
512 *
513 * @param float hauteur de la ligne
514 * @param integer position reelle courante si saut de ligne pendant l'ecriture d'un texte
515 * @return null
516 */
517 function setNewLine($h, $curr = null)
518 {
519 $this->pdf->Ln($h);
520
521 $this->setNewPositionForNewLine($curr);
522 }
523
524 /**
525 * création d'une nouvelle page avec le format et l'orientation spécifies
526 *
527 * @param mixed format de la page : A5, A4, array(width, height)
528 * @param string sens P=portrait ou L=landscape
529 * @param array tableau des propriétés du fond de la page
530 * @param integer position reelle courante si saut de ligne pendant l'ecriture d'un texte
531 * @return null
532 */
533 function setNewPage($format = null, $orientation = '', $background = null, $curr = null)
534 {
535 $this->firstPage = false;
536
537 $this->format = $format ? $format : $this->format;
538 $this->sens = $orientation ? $orientation : $this->sens;
539 $this->background = $background!==null ? $background : $this->background;
540 $this->maxY = 0;
541 $this->maxX = 0;
542 $this->maxH = 0;
543
544 $this->pdf->SetMargins($this->defaultLeft, $this->defaultTop, $this->defaultRight);
545 $this->pdf->AddPage($this->sens, $this->format);
546 $this->page++;
547
548 if (!$this->sub_part && !$this->isSubPart)
549 {
550 if (is_array($this->background))
551 {
552 if (isset($this->background['color']) && $this->background['color'])
553 {
554 $this->pdf->setMyFillColor($this->background['color']);
555 $this->pdf->Rect(0, 0, $this->pdf->getW(), $this->pdf->getH(), 'F');
556 }
557
558 if (isset($this->background['img']) && $this->background['img'])
559 $this->pdf->Image($this->background['img'], $this->background['posX'], $this->background['posY'], $this->background['width']);
560 }
561
562 $this->setPageHeader();
563 $this->setPageFooter();
564 }
565
566 $this->setMargins();
567 $this->pdf->setY($this->margeTop);
568
569 $this->setNewPositionForNewLine($curr);
570 $this->maxH = 0;
571 }
572
573 /**
574 * calcul de la position de debut de la prochaine ligne en fonction de l'alignement voulu
575 *
576 * @param integer position reelle courante si saut de ligne pendant l'ecriture d'un texte
577 * @return null
578 */
579 function setNewPositionForNewLine($curr = null)
580 {
581 list($lx, $rx) = $this->getMargins($this->pdf->getY());
582 $this->pdf->setX($lx);
583 $wMax = $rx-$lx;
584 $this->currentH = 0;
585
586 if ($this->sub_part || $this->isSubPart || $this->forOneLine)
587 {
588 // $this->pdf->setWordSpacing(0);
589 return null;
590 }
591 /*
592 if (
593 $this->style->value['text-align']!='right' &&
594 $this->style->value['text-align']!='center' &&
595 $this->style->value['text-align']!='justify'
596 )
597 {
598 // $this->pdf->setWordSpacing(0);
599 return null;
600 }
601 */
602 $sub = null;
603 $this->createSubHTML($sub);
604 $sub->saveMargin(0, 0, $sub->pdf->getW()-$wMax);
605 $sub->forOneLine = true;
606 $sub->parse_pos = $this->parse_pos;
607 $sub->parsing->code = $this->parsing->code;
608
609 if ($curr!==null && $sub->parsing->code[$this->parse_pos]['name']=='write')
610 {
611 $txt = $sub->parsing->code[$this->parse_pos]['param']['txt'];
612 $txt = str_replace('[[page_cu]]', $sub->page, $txt);
613 $sub->parsing->code[$this->parse_pos]['param']['txt'] = substr($txt, $curr);
614 }
615 else
616 $sub->parse_pos++;
617
618 // pour chaque element identifié par le parsing
619 $res = null;
620 for($sub->parse_pos; $sub->parse_pos<count($sub->parsing->code); $sub->parse_pos++)
621 {
622 $todo = $sub->parsing->code[$sub->parse_pos];
623 $res = $sub->loadAction($todo);
624 if (!$res) break;
625 }
626
627 $w = $sub->maxX; // largeur maximale
628 $h = $sub->maxH; // hauteur maximale
629 $e = ($res===null ? $sub->maxE : 0); // nombre d'éléments maximal
630 $this->destroySubHTML($sub);
631
632 if ($this->style->value['text-align']=='center')
633 $this->pdf->setX(($rx+$this->pdf->getX()-$w)*0.5-0.01);
634 elseif ($this->style->value['text-align']=='right')
635 $this->pdf->setX($rx-$w-0.01);
636 else
637 $this->pdf->setX($lx);
638
639 $this->currentH = $h;
640 /*
641 if ($this->style->value['text-align']=='justify' && $e>1)
642 $this->pdf->setWordSpacing(($wMax-$w)/($e-1));
643 else
644 $this->pdf->setWordSpacing(0);
645 */
646 }
647
648 /**
649 * récupération du PDF
650 *
651 * @param string nom du fichier PDF
652 * @param boolean destination
653 * @return string contenu éventuel du pdf
654 *
655 *
656 * Destination où envoyer le document. Le paramètre peut prendre les valeurs suivantes :
657 * true : equivalent à I
658 * false : equivalent à S
659 * 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.
660 * D : envoyer au navigateur en forçant le téléchargement, avec le nom indiqué dans name.
661 * F : sauver dans un fichier local, avec le nom indiqué dans name (peut inclure un répertoire).
662 * S : renvoyer le document sous forme de chaîne. name est ignoré.
663 */
664 function Output($name = '', $dest = false)
665 {
666 // nettoyage
667 global $HTML2PDF_TABLEAU; $HTML2PDF_TABLEAU = array();
668
669 if ($this->DEBUG_actif)
670 {
671 $this->DEBUG_add('Before output');
672 $this->pdf->Close();
673 exit;
674 }
675
676 // interpretation des paramètres
677 if ($dest===false) $dest = 'I';
678 if ($dest===true) $dest = 'S';
679 if ($dest==='') $dest = 'I';
680 if ($name=='') $name='document.pdf';
681
682 // verification de la destination
683 $dest = strtoupper($dest);
684 if (!in_array($dest, array('I', 'D', 'F', 'S'))) $dest = 'I';
685
686 // verification du nom
687 if (strtolower(substr($name, -4))!='.pdf')
688 {
689 echo 'ERROR : The output document name "'.$name.'" is not a PDF name';
690 exit;
691 }
692
693 return $this->pdf->Output($name, $dest);
694 }
695
696 /**
697 * création d'un sous HTML2PDF pour la gestion des tableaux imbriqués
698 *
699 * @param HTML2PDF futur sous HTML2PDF passé en référence pour création
700 * @param integer marge eventuelle de l'objet si simulation d'un TD
701 * @return null
702 */
703 function createSubHTML(&$sub_html, $cellmargin=0)
704 {
705 // calcul de la largueur
706 if ($this->style->value['width'])
707 {
708 $marge = $cellmargin*2;
709 $marge+= $this->style->value['padding']['l'] + $this->style->value['padding']['r'];
710 $marge+= $this->style->value['border']['l']['width'] + $this->style->value['border']['r']['width'];
711 $marge = $this->pdf->getW() - $this->style->value['width'] + $marge;
712 }
713 else
714 $marge = $this->margeLeft+$this->margeRight;
715
716 //clonage
717 $sub_html = new HTML2PDF(
718 $this->sens,
719 $this->format,
720 $this->langue,
721 array($this->defaultLeft,$this->defaultTop,$this->defaultRight,$this->defaultBottom)
722 );
723 $sub_html->setIsSubPart();
724 $sub_html->setEncoding($this->encoding);
725 $sub_html->setTestTdInOnePage($this->testTDin1page);
726 $sub_html->setTestIsImage($this->testIsImage);
727 $sub_html->setTestIsDeprecated($this->testIsDeprecated);
728 $sub_html->setDefaultFont($this->defaultFont);
729 $sub_html->style->css = $this->style->css;
730 $sub_html->style->css_keys = $this->style->css_keys;
731 $sub_html->pdf->cloneFontFrom($this->pdf);
732
733 $sub_html->style->table = $this->style->table;
734 $sub_html->style->value = $this->style->value;
735 $sub_html->style->setOnlyLeft();
736 $sub_html->setNewPage($this->format, $this->sens);
737 $sub_html->initSubHtml($marge, $this->page, $this->defLIST);
738
739 // initialisation des positions et autre
740 $sub_html->maxX = 0;
741 $sub_html->maxY = 0;
742 $sub_html->maxH = 0;
743 $sub_html->pdf->setXY(0, 0);
744 }
745
746 /**
747 * initialise le sous HTML2PDF. Ne pas utiliser directement. seul la fonction createSubHTML doit l'utiliser
748 *
749 * @return null
750 */
751 function initSubHtml($marge, $page, $defLIST)
752 {
753 $this->saveMargin(0, 0, $marge);
754 $this->defLIST = $defLIST;
755
756 $this->page = $page;
757 $this->pdf->setXY(0, 0);
758 $this->style->FontSet();
759 }
760
761 function setIsSubPart()
762 {
763 $this->isSubPart = true;
764 }
765
766 /**
767 * destruction d'un sous HTML2PDF pour la gestion des tableaux imbriqués
768 *
769 * @return null
770 */
771 function destroySubHTML(&$sub_html)
772 {
773 unset($sub_html);
774 $sub_html = null;
775 }
776
777 /**
778 * Convertir un nombre arabe en nombre romain
779 *
780 * @param integer nombre à convertir
781 * @return string nombre converti
782 */
783 function listeArab2Rom($nb_ar)
784 {
785 $nb_b10 = array('I','X','C','M');
786 $nb_b5 = array('V','L','D');
787 $nb_ro = '';
788
789 if ($nb_ar<1) return $nb_ar;
790 if ($nb_ar>3999) return $nb_ar;
791
792 for($i=3; $i>=0 ; $i--)
793 {
794 $chiffre=floor($nb_ar/pow(10,$i));
795 if($chiffre>=1)
796 {
797 $nb_ar=$nb_ar-$chiffre*pow(10,$i);
798 if($chiffre<=3)
799 {
800 for($j=$chiffre; $j>=1; $j--)
801 {
802 $nb_ro=$nb_ro.$nb_b10[$i];
803 }
804 }
805 else if($chiffre==9)
806 {
807 $nb_ro=$nb_ro.$nb_b10[$i].$nb_b10[$i+1];
808 }
809 elseif($chiffre==4)
810 {
811 $nb_ro=$nb_ro.$nb_b10[$i].$nb_b5[$i];
812 }
813 else
814 {
815 $nb_ro=$nb_ro.$nb_b5[$i];
816 for($j=$chiffre-5; $j>=1; $j--)
817 {
818 $nb_ro=$nb_ro.$nb_b10[$i];
819 }
820 }
821 }
822 }
823 return $nb_ro;
824 }
825
826 /**
827 * Ajouter un LI au niveau actuel
828 *
829 * @return null
830 */
831 function listeAddLi()
832 {
833 $this->defLIST[count($this->defLIST)-1]['nb']++;
834 }
835
836 function listeGetWidth() { return '7mm'; }
837 function listeGetPadding() { return '1mm'; }
838
839 /**
840 * Recuperer le LI du niveau actuel
841 *
842 * @return string chaine à afficher
843 */
844 function listeGetLi()
845 {
846 $im = $this->defLIST[count($this->defLIST)-1]['img'];
847 $st = $this->defLIST[count($this->defLIST)-1]['style'];
848 $nb = $this->defLIST[count($this->defLIST)-1]['nb'];
849 $up = (substr($st, 0, 6)=='upper-');
850
851 if ($im) return array(false, false, $im);
852
853 switch($st)
854 {
855 case 'none':
856 return array('helvetica', true, ' ');
857
858 case 'upper-alpha':
859 case 'lower-alpha':
860 $str = '';
861 while($nb>26)
862 {
863 $str = chr(96+$nb%26).$str;
864 $nb = floor($nb/26);
865 }
866 $str = chr(96+$nb).$str;
867
868 return array('helvetica', false, ($up ? strtoupper($str) : $str).'.');
869
870 case 'upper-roman':
871 case 'lower-roman':
872 $str = $this->listeArab2Rom($nb);
873
874 return array('helvetica', false, ($up ? strtoupper($str) : $str).'.');
875
876 case 'decimal':
877 return array('helvetica', false, $nb.'.');
878
879 case 'square':
880 return array('zapfdingbats', true, chr(110));
881
882 case 'circle':
883 return array('zapfdingbats', true, chr(109));
884
885 case 'disc':
886 default:
887 return array('zapfdingbats', true, chr(108));
888 }
889 }
890
891 /**
892 * Ajouter un niveau de liste
893 *
894 * @param string type de liste : ul, ol
895 * @param string style de la liste
896 * @return null
897 */
898 function listeAddLevel($type = 'ul', $style = '', $img = null)
899 {
900 if ($img)
901 {
902 if (preg_match('/^url\(([^)]+)\)$/isU', trim($img), $match))
903 $img = $match[1];
904 else
905 $img = null;
906 }
907 else
908 $img = null;
909
910 if (!in_array($type, array('ul', 'ol'))) $type = 'ul';
911 if (!in_array($style, array('lower-alpha', 'upper-alpha', 'upper-roman', 'lower-roman', 'decimal', 'square', 'circle', 'disc', 'none'))) $style = '';
912
913 if (!$style)
914 {
915 if ($type=='ul') $style = 'disc';
916 else $style = 'decimal';
917 }
918 $this->defLIST[count($this->defLIST)] = array('style' => $style, 'nb' => 0, 'img' => $img);
919 }
920
921 /**
922 * Supprimer un niveau de liste
923 *
924 * @return null
925 */
926 function listeDelLevel()
927 {
928 if (count($this->defLIST))
929 {
930 unset($this->defLIST[count($this->defLIST)-1]);
931 $this->defLIST = array_values($this->defLIST);
932 }
933 }
934
935 /**
936 * traitement d'un code HTML fait pour HTML2PDF
937 *
938 * @param string code HTML à convertir
939 * @param boolean afficher en pdf (false) ou en html adapté (true)
940 * @return null
941 */
942 function writeHTML($html, $vue = false)
943 {
944 // si c'est une vrai page HTML, une conversion s'impose
945 if (preg_match('/<body/isU', $html))
946 $html = $this->getHtmlFromPage($html);
947
948 $html = str_replace('[[page_nb]]', '{nb}', $html);
949
950 $html = str_replace('[[date_y]]', date('Y'), $html);
951 $html = str_replace('[[date_m]]', date('m'), $html);
952 $html = str_replace('[[date_d]]', date('d'), $html);
953
954 $html = str_replace('[[date_h]]', date('H'), $html);
955 $html = str_replace('[[date_i]]', date('i'), $html);
956 $html = str_replace('[[date_s]]', date('s'), $html);
957
958 // si on veut voir le résultat en HTML => on appelle la fonction
959 if ($vue) $this->vueHTML($html);
960
961 // sinon, traitement pour conversion en PDF :
962 // parsing
963 $this->sub_pdf = false;
964 $this->style->readStyle($html);
965 $this->parsing->setHTML($html);
966 $this->parsing->parse();
967 $this->makeHTMLcode();
968 }
969
970 /**
971 * traitement du code d'une vrai page HTML pour l'adapter à HTML2PDF
972 *
973 * @param string code HTML à adapter
974 * @return string code HTML adapté
975 */
976 function getHtmlFromPage($html)
977 {
978 $html = str_replace('<BODY', '<body', $html);
979 $html = str_replace('</BODY', '</body', $html);
980
981 // extraction du contenu
982 $res = explode('<body', $html);
983 if (count($res)<2) return $html;
984 $content = '<page'.$res[1];
985 $content = explode('</body', $content);
986 $content = $content[0].'</page>';
987
988 // extraction des balises link
989 preg_match_all('/<link([^>]*)>/isU', $html, $match);
990 foreach($match[0] as $src)
991 $content = $src.'</link>'.$content;
992
993 // extraction des balises style
994 preg_match_all('/<style[^>]*>(.*)<\/style[^>]*>/isU', $html, $match);
995 foreach($match[0] as $src)
996 $content = $src.$content;
997
998 return $content;
999 }
1000
1001 /**
1002 * execute les différentes actions du code HTML
1003 *
1004 * @return null
1005 */
1006 function makeHTMLcode()
1007 {
1008 // pour chaque element identifié par le parsing
1009 for($this->parse_pos=0; $this->parse_pos<count($this->parsing->code); $this->parse_pos++)
1010 {
1011 // récupération de l'élément
1012 $todo = $this->parsing->code[$this->parse_pos];
1013
1014 // si c'est une ouverture de tableau
1015 if (in_array($todo['name'], array('table', 'ul', 'ol')) && !$todo['close'])
1016 {
1017 // on va créer un sous HTML, et on va travailler sur une position temporaire
1018 $tag_open = $todo['name'];
1019
1020 $this->sub_part = true;
1021 $this->temp_pos = $this->parse_pos;
1022
1023 // pour tous les éléments jusqu'à la fermeture de la table afin de préparer les dimensions
1024 while(isset($this->parsing->code[$this->temp_pos]) && !($this->parsing->code[$this->temp_pos]['name']==$tag_open && $this->parsing->code[$this->temp_pos]['close']))
1025 {
1026 $this->loadAction($this->parsing->code[$this->temp_pos]);
1027 $this->temp_pos++;
1028 }
1029 if (isset($this->parsing->code[$this->temp_pos])) $this->loadAction($this->parsing->code[$this->temp_pos]);
1030 $this->sub_part = false;
1031 }
1032
1033 // chargement de l'action correspondant à l'élément
1034 $this->loadAction($todo);
1035 }
1036 }
1037
1038
1039
1040 /**
1041 * affichage en mode HTML du contenu
1042 *
1043 * @param string contenu
1044 * @return null
1045 */
1046 function vueHTML($content)
1047 {
1048 $content = preg_replace('/<page_header([^>]*)>/isU', '<hr>'.HTML2PDF::textGET('vue01').' : $1<hr><div$1>', $content);
1049 $content = preg_replace('/<page_footer([^>]*)>/isU', '<hr>'.HTML2PDF::textGET('vue02').' : $1<hr><div$1>', $content);
1050 $content = preg_replace('/<page([^>]*)>/isU', '<hr>'.HTML2PDF::textGET('vue03').' : $1<hr><div$1>', $content);
1051 $content = preg_replace('/<\/page([^>]*)>/isU', '</div><hr>', $content);
1052 $content = preg_replace('/<bookmark([^>]*)>/isU', '<hr>bookmark : $1<hr>', $content);
1053 $content = preg_replace('/<\/bookmark([^>]*)>/isU', '', $content);
1054 $content = preg_replace('/<barcode([^>]*)>/isU', '<hr>barcode : $1<hr>', $content);
1055 $content = preg_replace('/<\/barcode([^>]*)>/isU', '', $content);
1056 $content = preg_replace('/<qrcode([^>]*)>/isU', '<hr>qrcode : $1<hr>', $content);
1057 $content = preg_replace('/<\/qrcode([^>]*)>/isU', '', $content);
1058
1059 echo '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
1060 <html>
1061 <head>
1062 <title>'.HTML2PDF::textGET('vue04').' HTML</title>
1063 <meta http-equiv="Content-Type" content="text/html; charset='.$this->encoding.'" >
1064 </head>
1065 <body style="padding: 10px; font-size: 10pt;font-family: Verdana;">
1066 '.$content.'
1067 </body>
1068 </html>';
1069 exit;
1070 }
1071
1072 /**
1073 * chargement de l'action correspondante à un element de parsing
1074 *
1075 * @param array élément de parsing
1076 * @return null
1077 */
1078 function loadAction($row)
1079 {
1080 // nom de l'action
1081 $fnc = ($row['close'] ? 'c_' : 'o_').strtoupper($row['name']);
1082
1083 // parametres de l'action
1084 $param = $row['param'];
1085
1086 // si aucune page n'est créé, on la créé
1087 if ($fnc!='o_PAGE' && $this->firstPage)
1088 {
1089 $this->setNewPage();
1090 }
1091
1092 // lancement de l'action
1093 if (is_callable(array(&$this, $fnc)))
1094 {
1095 $res = $this->{$fnc}($param);
1096 $this->previousCall = $fnc;
1097 return $res;
1098 }
1099 else
1100 {
1101 HTML2PDF::makeError(1, __FILE__, __LINE__, strtoupper($row['name']), $this->parsing->getHtmlErrorCode($row['html_pos']));
1102 return false;
1103 }
1104 }
1105
1106 /**
1107 * balise : PAGE
1108 * mode : OUVERTURE
1109 *
1110 * @param array paramètres de l'élément de parsing
1111 * @return null
1112 */
1113 function o_PAGE($param)
1114 {
1115 if ($this->forOneLine) return false;
1116 if ($this->DEBUG_actif) $this->DEBUG_add('PAGE n°'.($this->page+1), true);
1117
1118 $newPageSet= (!isset($param['pageset']) || $param['pageset']!='old');
1119
1120 $this->maxH = 0;
1121 if ($newPageSet)
1122 {
1123 $this->subHEADER = array();
1124 $this->subFOOTER = array();
1125
1126 // identification de l'orientation demandée
1127 $orientation = '';
1128 if (isset($param['orientation']))
1129 {
1130 $param['orientation'] = strtolower($param['orientation']);
1131 if ($param['orientation']=='p') $orientation = 'P';
1132 if ($param['orientation']=='portrait') $orientation = 'P';
1133
1134 if ($param['orientation']=='l') $orientation = 'L';
1135 if ($param['orientation']=='paysage') $orientation = 'L';
1136 if ($param['orientation']=='landscape') $orientation = 'L';
1137 }
1138
1139 // identification de l'orientation demandée
1140 $format = null;
1141 if (isset($param['format']))
1142 {
1143 $format = strtolower($param['format']);
1144 if (preg_match('/^([0-9]+)x([0-9]+)$/isU', $format, $match))
1145 {
1146 $format = array(intval($match[1]), intval($match[2]));
1147 }
1148 }
1149
1150 // identification des propriétés du background
1151 $background = array();
1152 if (isset($param['backimg']))
1153 {
1154 $background['img'] = isset($param['backimg']) ? $param['backimg'] : ''; // nom de l'image
1155 $background['posX'] = isset($param['backimgx']) ? $param['backimgx'] : 'center'; // position horizontale de l'image
1156 $background['posY'] = isset($param['backimgy']) ? $param['backimgy'] : 'middle'; // position verticale de l'image
1157 $background['width'] = isset($param['backimgw']) ? $param['backimgw'] : '100%'; // taille de l'image (100% = largueur de la feuille)
1158
1159 // conversion du nom de l'image, en cas de paramètres en _GET
1160 $background['img'] = str_replace('&amp;', '&', $background['img']);
1161 // conversion des positions
1162 if ($background['posX']=='left') $background['posX'] = '0%';
1163 if ($background['posX']=='center') $background['posX'] = '50%';
1164 if ($background['posX']=='right') $background['posX'] = '100%';
1165 if ($background['posY']=='top') $background['posY'] = '0%';
1166 if ($background['posY']=='middle') $background['posY'] = '50%';
1167 if ($background['posY']=='bottom') $background['posY'] = '100%';
1168
1169
1170 // si il y a une image de précisé
1171 if ($background['img'])
1172 {
1173 // est-ce que c'est une image ?
1174 $infos=@GetImageSize($background['img']);
1175 if (count($infos)>1)
1176 {
1177 // taille de l'image, en fonction de la taille spécifiée.
1178 $Wi = $this->style->ConvertToMM($background['width'], $this->pdf->getW());
1179 $Hi = $Wi*$infos[1]/$infos[0];
1180
1181 // récupération des dimensions et positions de l'image
1182 $background['width'] = $Wi;
1183 $background['posX'] = $this->style->ConvertToMM($background['posX'], $this->pdf->getW() - $Wi);
1184 $background['posY'] = $this->style->ConvertToMM($background['posY'], $this->pdf->getH() - $Hi);
1185 }
1186 else
1187 $background = array();
1188 }
1189 else
1190 $background = array();
1191 }
1192
1193 // marges TOP et BOTTOM pour le texte.
1194 $background['top'] = isset($param['backtop']) ? $param['backtop'] : '0';
1195 $background['bottom'] = isset($param['backbottom']) ? $param['backbottom'] : '0';
1196 $background['left'] = isset($param['backleft']) ? $param['backleft'] : '0';
1197 $background['right'] = isset($param['backright']) ? $param['backright'] : '0';
1198
1199 if (preg_match('/^([0-9]*)$/isU', $background['top'])) $background['top'] .= 'mm';
1200 if (preg_match('/^([0-9]*)$/isU', $background['bottom'])) $background['bottom'] .= 'mm';
1201 if (preg_match('/^([0-9]*)$/isU', $background['left'])) $background['left'] .= 'mm';
1202 if (preg_match('/^([0-9]*)$/isU', $background['right'])) $background['right'] .= 'mm';
1203
1204 $background['top'] = $this->style->ConvertToMM($background['top'], $this->pdf->getH());
1205 $background['bottom'] = $this->style->ConvertToMM($background['bottom'], $this->pdf->getH());
1206 $background['left'] = $this->style->ConvertToMM($background['left'], $this->pdf->getW());
1207 $background['right'] = $this->style->ConvertToMM($background['right'], $this->pdf->getW());
1208
1209 $res = false;
1210 $background['color'] = isset($param['backcolor']) ? $this->style->ConvertToColor($param['backcolor'], $res) : null;
1211 if (!$res) $background['color'] = null;
1212
1213 $this->style->save();
1214 $this->style->analyse('PAGE', $param);
1215 $this->style->setPosition();
1216 $this->style->FontSet();
1217
1218 // nouvelle page
1219 $this->setNewPage($format, $orientation, $background);
1220
1221 // footer automatique
1222 if (isset($param['footer']))
1223 {
1224 $lst = explode(';', $param['footer']);
1225 foreach($lst as $key => $val) $lst[$key] = trim(strtolower($val));
1226 $page = in_array('page', $lst);
1227 $date = in_array('date', $lst);
1228 $heure = in_array('heure', $lst);
1229 $form = in_array('form', $lst);
1230 }
1231 else
1232 {
1233 $page = null;
1234 $date = null;
1235 $heure = null;
1236 $form = null;
1237 }
1238 $this->pdf->SetMyFooter($page, $date, $heure, $form);
1239 }
1240 else
1241 {
1242 $this->style->save();
1243 $this->style->analyse('PAGE', $param);
1244 $this->style->setPosition();
1245 $this->style->FontSet();
1246
1247 $this->setNewPage();
1248 }
1249
1250 return true;
1251 }
1252
1253 /**
1254 * balise : PAGE
1255 * mode : FERMETURE
1256 *
1257 * @param array paramètres de l'élément de parsing
1258 * @return null
1259 */
1260 function c_PAGE($param)
1261 {
1262 if ($this->forOneLine) return false;
1263
1264 $this->maxH = 0;
1265
1266 $this->style->load();
1267 $this->style->FontSet();
1268
1269 if ($this->DEBUG_actif) $this->DEBUG_add('PAGE n°'.$this->page, false);
1270
1271 return true;
1272 }
1273
1274
1275 function o_PAGE_HEADER($param)
1276 {
1277 if ($this->forOneLine) return false;
1278
1279 $this->subHEADER = array();
1280 for($this->parse_pos; $this->parse_pos<count($this->parsing->code); $this->parse_pos++)
1281 {
1282 $todo = $this->parsing->code[$this->parse_pos];
1283 if ($todo['name']=='page_header') $todo['name']='page_header_sub';
1284 $this->subHEADER[] = $todo;
1285 if (strtolower($todo['name'])=='page_header_sub' && $todo['close']) break;
1286 }
1287
1288 $this->setPageHeader();
1289
1290 return true;
1291 }
1292
1293 function o_PAGE_FOOTER($param)
1294 {
1295 if ($this->forOneLine) return false;
1296
1297 $this->subFOOTER = array();
1298 for($this->parse_pos; $this->parse_pos<count($this->parsing->code); $this->parse_pos++)
1299 {
1300 $todo = $this->parsing->code[$this->parse_pos];
1301 if ($todo['name']=='page_footer') $todo['name']='page_footer_sub';
1302 $this->subFOOTER[] = $todo;
1303 if (strtolower($todo['name'])=='page_footer_sub' && $todo['close']) break;
1304 }
1305
1306 $this->setPageFooter();
1307
1308 return true;
1309 }
1310
1311 function o_PAGE_HEADER_SUB($param)
1312 {
1313 if ($this->forOneLine) return false;
1314
1315 // sauvegarde de l'état
1316 $this->subSTATES = array();
1317 $this->subSTATES['x'] = $this->pdf->getX();
1318 $this->subSTATES['y'] = $this->pdf->getY();
1319 $this->subSTATES['s'] = $this->style->value;
1320 $this->subSTATES['t'] = $this->style->table;
1321 $this->subSTATES['ml'] = $this->margeLeft;
1322 $this->subSTATES['mr'] = $this->margeRight;
1323 $this->subSTATES['mt'] = $this->margeTop;
1324 $this->subSTATES['mb'] = $this->margeBottom;
1325 $this->subSTATES['mp'] = $this->pageMarges;
1326
1327 // nouvel etat pour le footer
1328 $this->pageMarges = array();
1329 $this->margeLeft = $this->defaultLeft;
1330 $this->margeRight = $this->defaultRight;
1331 $this->margeTop = $this->defaultTop;
1332 $this->margeBottom = $this->defaultBottom;
1333 $this->pdf->SetMargins($this->margeLeft, $this->margeTop, $this->margeRight);
1334 $this->pdf->SetAutoPageBreak(false, $this->margeBottom);
1335 $this->pdf->setXY($this->defaultLeft, $this->defaultTop);
1336
1337 $this->style->initStyle();
1338 $this->style->resetStyle();
1339 $this->style->value['width'] = $this->pdf->getW() - $this->defaultLeft - $this->defaultRight;
1340 $this->style->table = array();
1341
1342 $this->style->save();
1343 $this->style->analyse('page_header_sub', $param);
1344 $this->style->setPosition();
1345 $this->style->FontSet();
1346 $this->setNewPositionForNewLine();
1347 return true;
1348 }
1349
1350 function c_PAGE_HEADER_SUB($param)
1351 {
1352 if ($this->forOneLine) return false;
1353
1354 $this->style->load();
1355
1356 // retablissement de l'etat
1357 $this->style->value = $this->subSTATES['s'];
1358 $this->style->table = $this->subSTATES['t'];
1359 $this->pageMarges = $this->subSTATES['mp'];
1360 $this->margeLeft = $this->subSTATES['ml'];
1361 $this->margeRight = $this->subSTATES['mr'];
1362 $this->margeTop = $this->subSTATES['mt'];
1363 $this->margeBottom = $this->subSTATES['mb'];
1364 $this->pdf->SetMargins($this->margeLeft, $this->margeTop, $this->margeRight);
1365 $this->pdf->setbMargin($this->margeBottom);
1366 $this->pdf->SetAutoPageBreak(false, $this->margeBottom);
1367 $this->pdf->setXY($this->subSTATES['x'], $this->subSTATES['y']);
1368
1369 $this->style->FontSet();
1370 $this->maxH = 0;
1371
1372 return true;
1373 }
1374
1375 function o_PAGE_FOOTER_SUB($param)
1376 {
1377 if ($this->forOneLine) return false;
1378
1379 $this->subSTATES = array();
1380 $this->subSTATES['x'] = $this->pdf->getX();
1381 $this->subSTATES['y'] = $this->pdf->getY();
1382 $this->subSTATES['s'] = $this->style->value;
1383 $this->subSTATES['t'] = $this->style->table;
1384 $this->subSTATES['ml'] = $this->margeLeft;
1385 $this->subSTATES['mr'] = $this->margeRight;
1386 $this->subSTATES['mt'] = $this->margeTop;
1387 $this->subSTATES['mb'] = $this->margeBottom;
1388 $this->subSTATES['mp'] = $this->pageMarges;
1389
1390 // nouvel etat pour le footer
1391 $this->pageMarges = array();
1392 $this->margeLeft = $this->defaultLeft;
1393 $this->margeRight = $this->defaultRight;
1394 $this->margeTop = $this->defaultTop;
1395 $this->margeBottom = $this->defaultBottom;
1396 $this->pdf->SetMargins($this->margeLeft, $this->margeTop, $this->margeRight);
1397 $this->pdf->SetAutoPageBreak(false, $this->margeBottom);
1398 $this->pdf->setXY($this->defaultLeft, $this->defaultTop);
1399
1400
1401 $this->style->initStyle();
1402 $this->style->resetStyle();
1403 $this->style->value['width'] = $this->pdf->getW() - $this->defaultLeft - $this->defaultRight;
1404 $this->style->table = array();
1405
1406 // on en créé un sous HTML que l'on transforme en PDF
1407 // pour récupérer la hauteur
1408 // on extrait tout ce qui est contenu dans le FOOTER
1409 $sub = null;
1410 $this->CreateSubHTML($sub);
1411 $sub->parsing->code = $this->parsing->getLevel($this->parse_pos);
1412 $sub->MakeHTMLcode();
1413 $this->pdf->setY($this->pdf->getH() - $sub->maxY - $this->defaultBottom - 0.01);
1414 $this->destroySubHTML($sub);
1415
1416 $this->style->save();
1417 $this->style->analyse('page_footer_sub', $param);
1418 $this->style->setPosition();
1419 $this->style->FontSet();
1420 $this->setNewPositionForNewLine();
1421
1422 return true;
1423 }
1424
1425 function c_PAGE_FOOTER_SUB($param)
1426 {
1427 if ($this->forOneLine) return false;
1428
1429 $this->style->load();
1430
1431 $this->style->value = $this->subSTATES['s'];
1432 $this->style->table = $this->subSTATES['t'];
1433 $this->pageMarges = $this->subSTATES['mp'];
1434 $this->margeLeft = $this->subSTATES['ml'];
1435 $this->margeRight = $this->subSTATES['mr'];
1436 $this->margeTop = $this->subSTATES['mt'];
1437 $this->margeBottom = $this->subSTATES['mb'];
1438 $this->pdf->SetMargins($this->margeLeft, $this->margeTop, $this->margeRight);
1439 $this->pdf->SetAutoPageBreak(false, $this->margeBottom);
1440 $this->pdf->setXY($this->subSTATES['x'], $this->subSTATES['y']);
1441
1442 $this->style->FontSet();
1443 $this->maxH = 0;
1444
1445 return true;
1446 }
1447
1448 /**
1449 * balise : NOBREAK
1450 * mode : OUVERTURE
1451 *
1452 * @param array paramètres de l'élément de parsing
1453 * @return null
1454 */
1455 function o_NOBREAK($param)
1456 {
1457 if ($this->forOneLine) return false;
1458
1459 $this->maxH = 0;
1460
1461 // on en créé un sous HTML que l'on transforme en PDF
1462 // pour analyse les dimensions
1463 // et voir si ca rentre
1464 $sub = null;
1465 $this->CreateSubHTML($sub);
1466 $sub->parsing->code = $this->parsing->getLevel($this->parse_pos);
1467 $sub->MakeHTMLcode();
1468
1469 $y = $this->pdf->getY();
1470 if (
1471 $sub->maxY < ($this->pdf->getH() - $this->pdf->gettMargin()-$this->pdf->getbMargin()) &&
1472 $y + $sub->maxY>=($this->pdf->getH() - $this->pdf->getbMargin())
1473 )
1474 $this->setNewPage();
1475 $this->destroySubHTML($sub);
1476
1477 return true;
1478 }
1479
1480
1481 /**
1482 * balise : NOBREAK
1483 * mode : FERMETURE
1484 *
1485 * @param array paramètres de l'élément de parsing
1486 * @return null
1487 */
1488 function c_NOBREAK($param)
1489 {
1490 if ($this->forOneLine) return false;
1491
1492 $this->maxH = 0;
1493
1494 return true;
1495 }
1496
1497 /**
1498 * balise : DIV
1499 * mode : OUVERTURE
1500 *
1501 * @param array paramètres de l'élément de parsing
1502 * @return null
1503 */
1504 function o_DIV($param, $other = 'div')
1505 {
1506 if ($this->forOneLine) return false;
1507 if ($this->DEBUG_actif) $this->DEBUG_add(strtoupper($other), true);
1508
1509 $this->style->save();
1510 $this->style->analyse($other, $param);
1511 $this->style->FontSet();
1512
1513 // gestion specifique a la balise legend pour l'afficher au bon endroit
1514 if (in_array($other, array('fieldset', 'legend')))
1515 {
1516 if (isset($param['moveTop'])) $this->style->value['margin']['t'] += $param['moveTop'];
1517 if (isset($param['moveLeft'])) $this->style->value['margin']['l'] += $param['moveLeft'];
1518 if (isset($param['moveDown'])) $this->style->value['margin']['b'] += $param['moveDown'];
1519 }
1520
1521 $align_object = null;
1522 if ($this->style->value['margin-auto']) $align_object = 'center';
1523
1524 $marge = array();
1525 $marge['l'] = $this->style->value['border']['l']['width'] + $this->style->value['padding']['l']+0.03;
1526 $marge['r'] = $this->style->value['border']['r']['width'] + $this->style->value['padding']['r']+0.03;
1527 $marge['t'] = $this->style->value['border']['t']['width'] + $this->style->value['padding']['t']+0.03;
1528 $marge['b'] = $this->style->value['border']['b']['width'] + $this->style->value['padding']['b']+0.03;
1529
1530 // on extrait tout ce qui est contenu dans la DIV
1531 $level = $this->parsing->getLevel($this->parse_pos);
1532
1533 // on en créé un sous HTML que l'on transforme en PDF
1534 // pour analyse les dimensions
1535 $w = 0; $h = 0;
1536 if (count($level))
1537 {
1538 $sub = null;
1539 $this->CreateSubHTML($sub);
1540 $sub->parsing->code = $level;
1541 $sub->MakeHTMLcode();
1542 $w = $sub->maxX;
1543 $h = $sub->maxY;
1544 $this->destroySubHTML($sub);
1545 }
1546 $w_reel = $w;
1547 $h_reel = $h;
1548
1549 // if (($w==0 && $this->style->value['width']==0) || ($w>$this->style->value['width']) || $this->style->value['position']=='absolute')
1550 $w+= $marge['l']+$marge['r']+0.001;
1551
1552 $h+= $marge['t']+$marge['b']+0.001;
1553
1554 if ($this->style->value['overflow']=='hidden')
1555 {
1556 $over_w = max($w, $this->style->value['width']);
1557 $over_h = max($h, $this->style->value['height']);
1558 $overflow = true;
1559 $this->style->value['old_maxX'] = $this->maxX;
1560 $this->style->value['old_maxY'] = $this->maxY;
1561 $this->style->value['old_maxH'] = $this->maxH;
1562 $this->style->value['old_overflow'] = $this->isInOverflow;
1563 $this->isInOverflow = true;
1564 }
1565 else
1566 {
1567 $over_w = null;
1568 $over_h = null;
1569 $overflow = false;
1570 $this->style->value['width'] = max($w, $this->style->value['width']);
1571 $this->style->value['height'] = max($h, $this->style->value['height']);
1572 }
1573
1574 switch($this->style->value['rotate'])
1575 {
1576 case 90:
1577 $tmp = $over_h; $over_h = $over_w; $over_w = $tmp;
1578 $tmp = $h_reel; $h_reel = $w_reel; $w_reel = $tmp;
1579 unset($tmp);
1580 $w = $this->style->value['height'];
1581 $h = $this->style->value['width'];
1582 $t_x =-$h;
1583 $t_y = 0;
1584 break;
1585
1586 case 180:
1587 $w = $this->style->value['width'];
1588 $h = $this->style->value['height'];
1589 $t_x = -$w;
1590 $t_y = -$h;
1591 break;
1592
1593 case 270:
1594 $tmp = $over_h; $over_h = $over_w; $over_w = $tmp;
1595 $tmp = $h_reel; $h_reel = $w_reel; $w_reel = $tmp;
1596 unset($tmp);
1597 $w = $this->style->value['height'];
1598 $h = $this->style->value['width'];
1599 $t_x = 0;
1600 $t_y =-$w;
1601 break;
1602
1603 default:
1604 $w = $this->style->value['width'];
1605 $h = $this->style->value['height'];
1606 $t_x = 0;
1607 $t_y = 0;
1608 break;
1609 }
1610
1611 if (!$this->style->value['position'])
1612 {
1613 if (
1614 $w < ($this->pdf->getW() - $this->pdf->getlMargin()-$this->pdf->getrMargin()) &&
1615 $this->pdf->getX() + $w>=($this->pdf->getW() - $this->pdf->getrMargin())
1616 )
1617 $this->o_BR(array());
1618
1619 if (
1620 ($h < ($this->pdf->getH() - $this->pdf->gettMargin()-$this->pdf->getbMargin())) &&
1621 ($this->pdf->getY() + $h>=($this->pdf->getH() - $this->pdf->getbMargin())) &&
1622 !$this->isInOverflow
1623 )
1624 $this->setNewPage();
1625
1626 // en cas d'alignement => correction
1627 $old = $this->style->getOldValues();
1628 $parent_w = $old['width'] ? $old['width'] : $this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin();
1629
1630 if ($parent_w>$w)
1631 {
1632 if ($align_object=='center') $this->pdf->setX($this->pdf->getX() + ($parent_w-$w)*0.5);
1633 else if ($align_object=='right') $this->pdf->setX($this->pdf->getX() + $parent_w-$w);
1634 }
1635
1636 $this->style->setPosition();
1637 }
1638 else
1639 {
1640 // en cas d'alignement => correction
1641 $old = $this->style->getOldValues();
1642 $parent_w = $old['width'] ? $old['width'] : $this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin();
1643
1644 if ($parent_w>$w)
1645 {
1646 if ($align_object=='center') $this->pdf->setX($this->pdf->getX() + ($parent_w-$w)*0.5);
1647 else if ($align_object=='right') $this->pdf->setX($this->pdf->getX() + $parent_w-$w);
1648 }
1649
1650 $this->style->setPosition();
1651 $this->saveMax();
1652 $this->maxX = 0;
1653 $this->maxY = 0;
1654 $this->maxH = 0;
1655 $this->maxE = 0;
1656 }
1657
1658 if ($this->style->value['rotate'])
1659 {
1660 $this->pdf->startTransform();
1661 $this->pdf->setRotation($this->style->value['rotate']);
1662 $this->pdf->setTranslate($t_x, $t_y);
1663 }
1664
1665 // initialisation du style des bordures de la div
1666 $this->drawRectangle(
1667 $this->style->value['x'],
1668 $this->style->value['y'],
1669 $this->style->value['width'],
1670 $this->style->value['height'],
1671 $this->style->value['border'],
1672 $this->style->value['padding'],
1673 0,
1674 $this->style->value['background']
1675 );
1676
1677 $marge = array();
1678 $marge['l'] = $this->style->value['border']['l']['width'] + $this->style->value['padding']['l']+0.03;
1679 $marge['r'] = $this->style->value['border']['r']['width'] + $this->style->value['padding']['r']+0.03;
1680 $marge['t'] = $this->style->value['border']['t']['width'] + $this->style->value['padding']['t']+0.03;
1681 $marge['b'] = $this->style->value['border']['b']['width'] + $this->style->value['padding']['b']+0.03;
1682
1683 $this->style->value['width'] -= $marge['l']+$marge['r'];
1684 $this->style->value['height']-= $marge['t']+$marge['b'];
1685
1686 // positionnement en fonction des alignements
1687 $x_corr = 0;
1688 $y_corr = 0;
1689 if (!$this->sub_part && !$this->isSubPart)
1690 {
1691 switch($this->style->value['text-align'])
1692 {
1693 case 'right': $x_corr = ($this->style->value['width']-$w_reel); break;
1694 case 'center': $x_corr = ($this->style->value['width']-$w_reel)*0.5; break;
1695 }
1696 if ($x_corr>0) $x_corr=0;
1697 switch($this->style->value['vertical-align'])
1698 {
1699 case 'bottom': $y_corr = ($this->style->value['height']-$h_reel); break;
1700 case 'middle': $y_corr = ($this->style->value['height']-$h_reel)*0.5; break;
1701 }
1702 }
1703
1704 if ($overflow)
1705 {
1706 $over_w-= $marge['l']+$marge['r'];
1707 $over_h-= $marge['t']+$marge['b'];
1708 $this->pdf->clippingPathOpen(
1709 $this->style->value['x']+$marge['l'],
1710 $this->style->value['y']+$marge['t'],
1711 $this->style->value['width'],
1712 $this->style->value['height']
1713 );
1714
1715 $this->style->value['x']+= $x_corr;
1716 // limitation des marges aux dimensions du contenu
1717 $mL = $this->style->value['x']+$marge['l'];
1718 $mR = $this->pdf->getW() - $mL - $over_w;
1719 }
1720 else
1721 {
1722 // limitation des marges aux dimensions de la div
1723 $mL = $this->style->value['x']+$marge['l'];
1724 $mR = $this->pdf->getW() - $mL - $this->style->value['width'];
1725 }
1726
1727 $x = $this->style->value['x']+$marge['l'];
1728 $y = $this->style->value['y']+$marge['t']+$y_corr;
1729 $this->saveMargin($mL, 0, $mR);
1730 $this->pdf->setXY($x, $y);
1731
1732 $this->setNewPositionForNewLine();
1733
1734 return true;
1735 }
1736 function o_BLOCKQUOTE($param) { return $this->o_DIV($param, 'blockquote'); }
1737 function o_LEGEND($param) { return $this->o_DIV($param, 'legend'); }
1738
1739 /**
1740 * balise : FIELDSET
1741 * mode : OUVERTURE
1742 * ecrite par Pavel Kochman
1743 *
1744 * @param array paramètres de l'élément de parsing
1745 * @return null
1746 */
1747 function o_FIELDSET($param)
1748 {
1749
1750 $this->style->save();
1751 $this->style->analyse('fieldset', $param);
1752
1753 // get height of LEGEND element and make fieldset corrections
1754 for($temp_pos = $this->parse_pos + 1; $temp_pos<count($this->parsing->code); $temp_pos++)
1755 {
1756 $todo = $this->parsing->code[$temp_pos];
1757 if($todo['name'] == 'fieldset') break;
1758 if($todo['name'] == 'legend' && !$todo['close'])
1759 {
1760 $legend_open_pos = $temp_pos;
1761
1762 $sub = null;
1763 $this->CreateSubHTML($sub);
1764 $sub->parsing->code = $this->parsing->getLevel($temp_pos - 1);
1765
1766 // pour chaque element identifié par le parsing
1767 $res = null;
1768 for($sub->parse_pos = 0; $sub->parse_pos<count($sub->parsing->code); $sub->parse_pos++)
1769 {
1770 $todo = $sub->parsing->code[$sub->parse_pos];
1771 $sub->loadAction($todo);
1772
1773 if ($todo['name'] == 'legend' && $todo['close'])
1774 break;
1775 }
1776
1777 $legendH = $sub->maxY;
1778 $this->destroySubHTML($sub);
1779
1780 $move = $this->style->value['padding']['t'] + $this->style->value['border']['t']['width'] + 0.03;
1781
1782 $param['moveTop'] = $legendH / 2;
1783
1784 $this->parsing->code[$legend_open_pos]['param']['moveTop'] = - ($legendH / 2 + $move);
1785 $this->parsing->code[$legend_open_pos]['param']['moveLeft'] = 2 - $this->style->value['border']['l']['width'] - $this->style->value['padding']['l'];
1786 $this->parsing->code[$legend_open_pos]['param']['moveDown'] = $move;
1787 break;
1788 }
1789 }
1790 $this->style->load();
1791
1792 return $this->o_DIV($param, 'fieldset');
1793 }
1794
1795 /**
1796 * balise : DIV
1797 * mode : FERMETURE
1798 *
1799 * @param array paramètres de l'élément de parsing
1800 * @return null
1801 */
1802 function c_DIV($param, $other='div')
1803 {
1804 if ($this->forOneLine) return false;
1805
1806 if ($this->style->value['overflow']=='hidden')
1807 {
1808 $this->maxX = $this->style->value['old_maxX'];
1809 $this->maxY = $this->style->value['old_maxY'];
1810 $this->maxH = $this->style->value['old_maxH'];
1811 $this->isInOverflow = $this->style->value['old_overflow'];
1812 $this->pdf->clippingPathClose();
1813 }
1814
1815 if ($this->style->value['rotate'])
1816 $this->pdf->stopTransform();
1817
1818 $marge = array();
1819 $marge['l'] = $this->style->value['border']['l']['width'] + $this->style->value['padding']['l']+0.03;
1820 $marge['r'] = $this->style->value['border']['r']['width'] + $this->style->value['padding']['r']+0.03;
1821 $marge['t'] = $this->style->value['border']['t']['width'] + $this->style->value['padding']['t']+0.03;
1822 $marge['b'] = $this->style->value['border']['b']['width'] + $this->style->value['padding']['b']+0.03;
1823
1824 $x = $this->style->value['x'];
1825 $y = $this->style->value['y'];
1826 $w = $this->style->value['width']+$marge['l']+$marge['r']+$this->style->value['margin']['r'];
1827 $h = $this->style->value['height']+$marge['t']+$marge['b']+$this->style->value['margin']['b'];
1828
1829 switch($this->style->value['rotate'])
1830 {
1831 case 90:
1832 $t = $w; $w = $h; $h = $t;
1833 break;
1834
1835 case 270:
1836 $t = $w; $w = $h; $h = $t;
1837 break;
1838
1839 default:
1840 break;
1841 }
1842
1843
1844 if ($this->style->value['position']!='absolute')
1845 {
1846 // position
1847 $this->pdf->setXY($x+$w, $y);
1848
1849 // position MAX
1850 $this->maxX = max($this->maxX, $x+$w);
1851 $this->maxY = max($this->maxY, $y+$h);
1852 $this->maxH = max($this->maxH, $h);
1853 }
1854 else
1855 {
1856 // position
1857 $this->pdf->setXY($this->style->value['xc'], $this->style->value['yc']);
1858
1859 $this->loadMax();
1860 }
1861
1862 $block = ($this->style->value['display']!='inline' && $this->style->value['position']!='absolute');
1863
1864 $this->style->load();
1865 $this->style->FontSet();
1866 $this->loadMargin();
1867
1868 if ($block) $this->o_BR(array());
1869 if ($this->DEBUG_actif) $this->DEBUG_add(strtoupper($other), false);
1870
1871 return true;
1872 }
1873 function c_BLOCKQUOTE($param) { return $this->c_DIV($param, 'blockquote'); }
1874 function c_FIELDSET($param) { return $this->c_DIV($param, 'fieldset'); }
1875 function c_LEGEND($param) { return $this->c_DIV($param, 'legend'); }
1876
1877 /**
1878 * balise : BARCODE
1879 * mode : OUVERTURE
1880 *
1881 * @param array paramètres de l'élément de parsing
1882 * @return null
1883 */
1884 function o_BARCODE($param)
1885 {
1886 if (!isset($param['type'])) $param['type'] = '';
1887 if (!isset($param['value'])) $param['value'] = 0;
1888 if (!isset($param['label'])) $param['label'] = 'label';
1889
1890 if ($this->testIsDeprecated && (isset($param['bar_h']) || isset($param['bar_w'])))
1891 HTML2PDF::makeError(9, __FILE__, __LINE__, array('BARCODE', 'bar_h, bar_w'));
1892
1893 // les différents types de barcode
1894 $lst_barcode = array();
1895 $lst_barcode['EAN13'] = 'EAN13';
1896 $lst_barcode['UPCA'] = 'UPC_A';
1897 $lst_barcode['C39'] = 'CODE39';
1898
1899 // pour compatibilité < 3.29
1900 $lst_barcode['UPC_A'] = 'UPC_A';
1901 $lst_barcode['CODE39'] = 'CODE39';
1902
1903 $param['type'] = strtoupper($param['type']);
1904 if (!isset($lst_barcode[$param['type']])) $param['type']=='C39';
1905 $param['type'] = $lst_barcode[$param['type']];
1906
1907 if (!isset($param['style']['color'])) $param['style']['color'] = '#000000';
1908 $param['style']['background-color'] = $param['style']['color'];
1909
1910 $this->style->save();
1911 $this->style->analyse('barcode', $param);
1912 $this->style->setPosition();
1913 $this->style->FontSet();
1914
1915 $x = $this->pdf->getX();
1916 $y = $this->pdf->getY();
1917 $w = $this->style->value['width']; if (!$w) $w = $this->style->ConvertToMM('50mm');
1918 $h = $this->style->value['height']; if (!$h) $h = $this->style->ConvertToMM('10mm');
1919 $txt = ($param['label']!=='none');
1920 $infos = $this->pdf->{'BARCODE_'.$param['type']}($x, $y, $w, $h, $param['value'], $txt);
1921
1922 // position maximale globale
1923 $this->maxX = max($this->maxX, $x+$infos[0]);
1924 $this->maxY = max($this->maxY, $y+$infos[1]);
1925 $this->maxH = max($this->maxH, $infos[1]);
1926 $this->maxE++;
1927
1928 $this->pdf->setXY($x+$infos[0], $y);
1929
1930 $this->style->load();
1931 $this->style->FontSet();
1932
1933 return true;
1934 }
1935
1936 /**
1937 * balise : BARCODE
1938 * mode : FERMETURE
1939 *
1940 * @param array paramètres de l'élément de parsing
1941 * @return null
1942 */
1943 function c_BARCODE($param)
1944 {
1945 // completement inutile
1946
1947 return true;
1948 }
1949
1950
1951 /**
1952 * balise : QRCODE
1953 * mode : OUVERTURE
1954 *
1955 * @param array paramètres de l'élément de parsing
1956 * @return null
1957 */
1958 function o_QRCODE($param)
1959 {
1960 if ($this->testIsDeprecated && (isset($param['size']) || isset($param['noborder'])))
1961 HTML2PDF::makeError(9, __FILE__, __LINE__, array('QRCODE', 'size, noborder'));
1962
1963 $msg = '
1964 <h1>QRCODE Tag</h1>
1965 <pre>
1966 <b>ATTENTION :</b>
1967 Vous devez télécharger la librairie "QR-code generator >=0.99" (sous licence LGPL)
1968 a cette adresse : <a href="http://prgm.spipu.net/php_qrcode" target="_blank">http://prgm.spipu.net/php_qrcode</a>
1969 et mettre tout son contenu dans ce repertoire : '.str_replace('\\', '/', dirname(__FILE__)).'/qrcode
1970
1971 <b>WARNING:</b>
1972 You have to download the librairy "QR-code generator >=0.99" (under LGPL licence)
1973 at this url : <a href="http://prgm.spipu.net/php_qrcode" target="_blank">http://prgm.spipu.net/php_qrcode</a>
1974 and to put all his contents in this folder '.str_replace('\\', '/', dirname(__FILE__)).'/qrcode
1975 </pre>';
1976
1977 $file_class = dirname(__FILE__).'/qrcode/qrcode.class.php';
1978 if (!is_file($file_class)) { echo $msg; exit; }
1979 require_once($file_class);
1980 if (__CLASS_QRCODE__<'0.99') { echo $msg; exit; }
1981
1982 if ($this->DEBUG_actif) $this->DEBUG_add('QRCODE', true);
1983 if (!isset($param['value'])) $param['value'] = '';
1984 if (!isset($param['ec'])) $param['ec'] = 'H';
1985 if (!isset($param['style']['color'])) $param['style']['color'] = '#000000';
1986 if (!isset($param['style']['background-color'])) $param['style']['background-color'] = '#FFFFFF';
1987 if (isset($param['style']['border']))
1988 {
1989 $borders = $param['style']['border']!='none';
1990 unset($param['style']['border']);
1991 }
1992 else
1993 $borders = true;
1994
1995 if ($param['value']==='') return true;
1996 if (!in_array($param['ec'], array('L', 'M', 'Q', 'H'))) $param['ec'] = 'H';
1997
1998 $this->style->save();
1999 $this->style->analyse('qrcode', $param);
2000 $this->style->setPosition();
2001 $this->style->FontSet();
2002
2003 $x = $this->pdf->getX();
2004 $y = $this->pdf->getY();
2005 $w = $this->style->value['width'];
2006 $h = $this->style->value['height'];
2007 $size = max($w, $h); if (!$size) $size = $this->style->ConvertToMM('50mm');
2008
2009 $color = $this->style->value['color'];
2010 if (count($color)==4) $color = array(0, 0, 0);
2011 $color[0] = floor($color[0]*255.);
2012 $color[1] = floor($color[1]*255.);
2013 $color[2] = floor($color[2]*255.);
2014
2015 $background = $this->style->value['background']['color'];
2016 if (count($background)==4) $background = array(0, 0, 0);
2017 $background[0] = floor($background[0]*255.);
2018 $background[1] = floor($background[1]*255.);
2019 $background[2] = floor($background[2]*255.);
2020
2021 if (!$this->sub_part && !$this->isSubPart)
2022 {
2023 $qrcode = new QRcode($param['value'], $param['ec']);
2024 if (!$borders) $qrcode->disableBorder();
2025 $qrcode->displayFPDF($this->pdf, $x, $y, $size, $background, $color);
2026 unset($qrcode);
2027 }
2028
2029 // position maximale globale
2030 $this->maxX = max($this->maxX, $x+$size);
2031 $this->maxY = max($this->maxY, $y+$size);
2032 $this->maxH = max($this->maxH, $size);
2033
2034 $this->pdf->setX($x+$size);
2035
2036 $this->style->load();
2037 $this->style->FontSet();
2038
2039 return true;
2040 }
2041
2042 /**
2043 * balise : QRCODE
2044 * mode : FERMETURE
2045 *
2046 * @param array paramètres de l'élément de parsing
2047 * @return null
2048 */
2049 function c_QRCODE($param)
2050 {
2051 if ($this->DEBUG_actif) $this->DEBUG_add('QRCODE', false);
2052 // completement inutile
2053 return true;
2054 }
2055
2056 /**
2057 * balise : BOOKMARK
2058 * mode : OUVERTURE
2059 *
2060 * @param array paramètres de l'élément de parsing
2061 * @return null
2062 */
2063 function o_BOOKMARK($param)
2064 {
2065 $titre = isset($param['title']) ? trim($param['title']) : '';
2066 $level = isset($param['level']) ? floor($param['level']) : 0;
2067
2068 if ($level<0) $level = 0;
2069 if ($titre) $this->pdf->Bookmark($titre, $level, -1);
2070
2071 return true;
2072 }
2073
2074 /**
2075 * balise : BOOKMARK
2076 * mode : FERMETURE
2077 *
2078 * @param array paramètres de l'élément de parsing
2079 * @return null
2080 */
2081 function c_BOOKMARK($param)
2082 {
2083 // completement inutile
2084
2085 return true;
2086 }
2087
2088 function getElementY($h)
2089 {
2090 if ($this->sub_part || $this->isSubPart || !$this->currentH || $this->currentH<$h)
2091 return 0;
2092
2093 return ($this->currentH-$h)*0.8;
2094 }
2095
2096 /**
2097 * balise : WRITE
2098 * mode : OUVERTURE
2099 *
2100 * @param array paramètres de l'élément de parsing
2101 * @return null
2102 */
2103 function o_WRITE($param)
2104 {
2105 $fill = ($this->style->value['background']['color']!==null && $this->style->value['background']['image']===null);
2106 if (in_array($this->style->value['id_balise'], array('fieldset', 'legend', 'div', 'table', 'tr', 'td', 'th')))
2107 $fill = false;
2108
2109 // récupération du texte à écrire, et conversion
2110 $txt = $param['txt'];
2111
2112 if ($this->isAfterFloat)
2113 {
2114 $txt = ltrim($txt);
2115 $this->isAfterFloat = false;
2116 }
2117
2118 $txt = str_replace('[[page_cu]]', $this->page, $txt);
2119
2120 if ($this->style->value['text-transform']!='none')
2121 {
2122 if ($this->style->value['text-transform']=='capitalize')
2123 $txt = ucwords($txt);
2124 else if ($this->style->value['text-transform']=='uppercase')
2125 $txt = strtoupper($txt);
2126 else if ($this->style->value['text-transform']=='lowercase')
2127 $txt = strtolower($txt);
2128 }
2129
2130 // tailles du texte
2131 $h = 1.08*$this->style->value['font-size'];
2132 $dh = $h*$this->style->value['mini-decal'];
2133 $lh = $this->style->getLineHeight();
2134
2135 // identification de l'alignement
2136 $align = 'L';
2137 if ($this->style->value['text-align']=='li_right')
2138 {
2139 $w = $this->style->value['width'];
2140 $align = 'R';
2141 }
2142
2143 // pré calcul de la taille de chaque mot et de la phrase complete
2144 $w = 0;
2145 $words = explode(' ', $txt);
2146 foreach($words as $k => $word)
2147 {
2148 $words[$k] = array($word, $this->pdf->GetStringWidth($word));
2149 $w+= $words[$k][1];
2150 }
2151 $space = $this->pdf->GetStringWidth(' ');
2152 $w+= $space*(count($words)-1);
2153
2154 $curr_pos = 0; // position dans le texte
2155 $curr_max = strlen($txt); // taille maxi du texte
2156 $maxX = 0; // plus grande largeur du texte apres retour à la ligne
2157 $x = $this->pdf->getX(); // position du texte
2158 $y = $this->pdf->getY();
2159 $dy = $this->getElementY($lh);
2160
2161 list($left, $right) = $this->getMargins($y); // marges autorisees
2162 $nb = 0; // nbr de lignes découpées
2163
2164 // tant que ca ne rentre pas sur la ligne et qu'on a du texte => on découpe
2165 while($x+$w>$right && $x<$right && count($words))
2166 {
2167 // trouver une phrase qui rentre dans la largeur, en ajoutant les mots 1 à 1
2168 $i=0;
2169 $old = array('', 0);
2170 $str = $words[0];
2171 $add = false;
2172 while(($x+$str[1])<$right)
2173 {
2174 $i++;
2175 $add = true;
2176
2177 array_shift($words);
2178 $old = $str;
2179
2180 if (!count($words)) break;
2181 $str[0].= ' '.$words[0][0];
2182 $str[1]+= $space+$words[0][1];
2183 }
2184 $str = $old;
2185
2186 // si rien de rentre, et que le premier mot ne rentre de toute facon pas dans une ligne, on le force...
2187 if ($i==0 && (($left+$words[0][1])>=$right))
2188 {
2189 $str = $words[0];
2190 array_shift($words);
2191 $i++;
2192 $add = true;
2193 }
2194 $curr_pos+= ($curr_pos ? 1 : 0)+strlen($str[0]);
2195
2196 // ecriture du bout de phrase extrait et qui rentre
2197 $wc = ($align=='L' ? $str[1] : $this->style->value['width']);
2198 if ($right - $left<$wc) $wc = $right - $left;
2199 /*
2200 if ($this->pdf->ws)
2201 {
2202 $oldSpace = $this->pdf->CurrentFont['cw'][' '];
2203 $this->pdf->CurrentFont['cw'][' ']*=(1.+$this->pdf->ws);
2204 $wc = $str[1];
2205 $this->pdf->CurrentFont['cw'][' '] = $oldSpace;
2206 }
2207 */
2208 if (strlen($str[0]))
2209 {
2210 $this->pdf->setXY($this->pdf->getX(), $y+$dh+$dy);
2211 $this->pdf->Cell($wc, $h, $str[0], 0, 0, $align, $fill, $this->inLink);
2212 $this->pdf->setXY($this->pdf->getX(), $y);
2213 }
2214 $this->maxH = max($this->maxH, $lh);
2215
2216 // détermination de la largeur max
2217 $maxX = max($maxX, $this->pdf->getX());
2218
2219 // nouvelle position et nouvelle largeur pour la boucle
2220 $w-= $str[1];
2221 $y = $this->pdf->getY();
2222 $x = $this->pdf->getX();
2223 $dy = $this->getElementY($lh);
2224
2225 // si il reste du text à afficher
2226 if (count($words))
2227 {
2228 if ($add) $w-= $space;
2229 if ($this->forOneLine)
2230 {
2231 $this->maxE+= $i+1;
2232 $this->maxX = max($this->maxX, $maxX);
2233 return null;
2234 }
2235
2236 // retour à la ligne
2237 $this->o_BR(array('style' => ''), $curr_pos);
2238
2239 $y = $this->pdf->getY();
2240 $x = $this->pdf->getX();
2241 $dy = $this->getElementY($lh);
2242
2243 // si la prochaine ligne ne rentre pas dans la page => nouvelle page
2244 if ($y + $h>=$this->pdf->getH() - $this->pdf->getbMargin())
2245 {
2246 if (!$this->isInOverflow && !$this->isInFooter)
2247 {
2248 $this->setNewPage(null, '', null, $curr_pos);
2249 $y = $this->pdf->getY();
2250 $x = $this->pdf->getX();
2251 $dy = $this->getElementY($lh);
2252 }
2253 }
2254
2255 // ligne suplémentaire. au bout de 1000 : trop long => erreur
2256 $nb++;
2257 if ($nb>1000)
2258 {
2259 $txt = ''; foreach($words as $k => $word) $txt.= ($k ? ' ' : '').$word[0];
2260 HTML2PDF::makeError(2, __FILE__, __LINE__, array($txt, $right-$left, $w));
2261 }
2262
2263 list($left, $right) = $this->getMargins($y); // marges autorisees
2264 }
2265 }
2266
2267 // si il reste du text apres découpe, c'est qu'il rentre direct => on l'affiche
2268 if (count($words))
2269 {
2270 $txt = ''; foreach($words as $k => $word) $txt.= ($k ? ' ' : '').$word[0];
2271 /*
2272 if ($this->pdf->ws)
2273 {
2274 $oldSpace = $this->pdf->CurrentFont['cw'][' '];
2275 $this->pdf->CurrentFont['cw'][' ']*=(1.+$this->pdf->ws);
2276 $w = $this->pdf->GetStringWidth($txt);
2277 $this->pdf->CurrentFont['cw'][' '] = $oldSpace;
2278 }
2279 */
2280 $this->pdf->setXY($this->pdf->getX(), $y+$dh+$dy);
2281 $this->pdf->Cell(($align=='L' ? $w : $this->style->value['width']), $h, $txt, 0, 0, $align, $fill, $this->inLink);
2282 $this->pdf->setXY($this->pdf->getX(), $y);
2283 $this->maxH = max($this->maxH, $lh);
2284 $this->maxE+= count($words);
2285 }
2286
2287 // détermination des positions MAX
2288 $maxX = max($maxX, $this->pdf->getX());
2289 $maxY = $this->pdf->getY()+$h;
2290
2291 // position maximale globale
2292 $this->maxX = max($this->maxX, $maxX);
2293 $this->maxY = max($this->maxY, $maxY);
2294
2295 return true;
2296 }
2297
2298 /**
2299 * tracer une image
2300 *
2301 * @param string nom du fichier source
2302 * @return null
2303 */
2304 function Image($src, $sub_li=false)
2305 {
2306 // est-ce que c'est une image ?
2307 $infos=@GetImageSize($src);
2308
2309 if (count($infos)<2)
2310 {
2311 if ($this->testIsImage)
2312 {
2313 HTML2PDF::makeError(6, __FILE__, __LINE__, $src);
2314 return false;
2315 }
2316 $src = null;
2317 $infos = array(16, 16);
2318 }
2319
2320 // récupération des dimensions dans l'unité du PDF
2321 $wi = $infos[0]/$this->pdf->getK();
2322 $hi = $infos[1]/$this->pdf->getK();
2323
2324 // détermination des dimensions d'affichage en fonction du style
2325 if ($this->style->value['width'] && $this->style->value['height'])
2326 {
2327 $w = $this->style->value['width'];
2328 $h = $this->style->value['height'];
2329 }
2330 else if ($this->style->value['width'])
2331 {
2332 $w = $this->style->value['width'];
2333 $h = $hi*$w/$wi;
2334
2335 }
2336 else if ($this->style->value['height'])
2337 {
2338 $h = $this->style->value['height'];
2339 $w = $wi*$h/$hi;
2340 }
2341 else
2342 {
2343 $w = 72./96.*$wi;
2344 $h = 72./96.*$hi;
2345 }
2346
2347 // detection du float
2348 $float = $this->style->getFloat();
2349 if ($float && $this->maxH)
2350 if (!$this->o_BR(array()))
2351 return false;
2352
2353 // position d'affichage
2354 $x = $this->pdf->getX();
2355 $y = $this->pdf->getY();
2356
2357 // si l'image ne rentre pas dans la ligne => nouvelle ligne
2358 if (!$float && ($x + $w>$this->pdf->getW() - $this->pdf->getrMargin()) && $this->maxH)
2359 {
2360 if ($this->forOneLine) return null;
2361
2362 $hnl = max($this->maxH, $this->style->getLineHeight());
2363 $this->setNewLine($hnl);
2364 $x = $this->pdf->getX();
2365 $y = $this->pdf->getY();
2366 }
2367
2368 // si l'image ne rentre pas dans la page => nouvelle page
2369 if (
2370 ($y + $h>$this->pdf->getH() - $this->pdf->getbMargin()) &&
2371 !$this->isInOverflow
2372 )
2373 {
2374 $this->setNewPage();
2375 $x = $this->pdf->getX();
2376 $y = $this->pdf->getY();
2377 }
2378
2379 // correction pour l'affichage d'une puce image
2380 $hT = 0.80*$this->style->value['font-size'];
2381 if ($sub_li && $h<$hT)
2382 {
2383 $y+=($hT-$h);
2384 }
2385
2386 $yc = $y-$this->style->value['margin']['t'];
2387
2388 // détermination de la position réelle d'affichage en fonction du text-align du parent
2389 $old = $this->style->getOldValues();
2390
2391 if ( $old['width'])
2392 {
2393 $parent_w = $old['width'];
2394 $parent_x = $x;
2395 }
2396 else
2397 {
2398 $parent_w = $this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin();
2399 $parent_x = $this->pdf->getlMargin();
2400 }
2401
2402 if ($float)
2403 {
2404 list($lx, $rx) = $this->getMargins($yc);
2405 $parent_x = $lx;
2406 $parent_w = $rx-$lx;
2407 }
2408
2409 if ($parent_w>$w && $float!='left')
2410 {
2411 if ($float=='right' || $this->style->value['text-align']=='li_right') $x = $parent_x + $parent_w - $w-$this->style->value['margin']['r']-$this->style->value['margin']['l'];
2412 }
2413
2414 // affichage de l'image, et positionnement à la suite
2415 if (!$this->sub_part && !$this->isSubPart)
2416 {
2417 if ($src) $this->pdf->Image($src, $x, $y, $w, $h, '', $this->inLink);
2418 else
2419 {
2420 $this->pdf->setMyFillColor(array(0.94, 0.86, 0.86));
2421 $this->pdf->Rect($x, $y, $w, $h, 'F');
2422 }
2423 }
2424
2425 $x-= $this->style->value['margin']['l'];
2426 $y-= $this->style->value['margin']['t'];
2427 $w+= $this->style->value['margin']['l'] + $this->style->value['margin']['r'];
2428 $h+= $this->style->value['margin']['t'] + $this->style->value['margin']['b'];
2429
2430 if ($float=='left')
2431 {
2432 $this->maxX = max($this->maxX, $x+$w);
2433 $this->maxY = max($this->maxY, $y+$h);
2434
2435 $this->addMargins($float, $x, $y, $x+$w, $y+$h);
2436
2437 list($lx, $rx) = $this->getMargins($yc);
2438 $this->pdf->setXY($lx, $yc);
2439 }
2440 else if ($float=='right')
2441 {
2442 // $this->maxX = max($this->maxX, $x+$w);
2443 $this->maxY = max($this->maxY, $y+$h);
2444
2445 $this->addMargins($float, $x, $y, $x+$w, $y+$h);
2446
2447 list($lx, $rx) = $this->getMargins($yc);
2448 $this->pdf->setXY($lx, $yc);
2449 }
2450 else
2451 {
2452 $this->pdf->setX($x+$w);
2453 $this->maxX = max($this->maxX, $x+$w);
2454 $this->maxY = max($this->maxY, $y+$h);
2455 $this->maxH = max($this->maxH, $h);
2456 }
2457 return true;
2458 }
2459
2460 /**
2461 * Tracer un rectanble
2462 *
2463 * @param float position X
2464 * @param float position Y
2465 * @param float Largeur
2466 * @param float Hauteur
2467 * @param array Tableau de style de définition des borders
2468 * @param float padding - marge intérieur au rectangle => non utile mais on le passe en paramètre
2469 * @param float margin - marge exterieur au rectangle
2470 * @param array Tableau de style de définition du background
2471 * @return null
2472 */
2473 function drawRectangle($x, $y, $w, $h, $border, $padding, $margin, $background)
2474 {
2475 if ($this->sub_part || $this->isSubPart) return false;
2476 if ($h===null) return false;
2477
2478 $x+= $margin;
2479 $y+= $margin;
2480 $w-= $margin*2;
2481 $h-= $margin*2;
2482
2483 // récupération des radius
2484 $out_TL = $border['radius']['tl'];
2485 $out_TR = $border['radius']['tr'];
2486 $out_BR = $border['radius']['br'];
2487 $out_BL = $border['radius']['bl'];
2488
2489 // verification des coins en radius
2490 $out_TL = ($out_TL[0] && $out_TL[1]) ? $out_TL : null;
2491 $out_TR = ($out_TR[0] && $out_TR[1]) ? $out_TR : null;
2492 $out_BR = ($out_BR[0] && $out_BR[1]) ? $out_BR : null;
2493 $out_BL = ($out_BL[0] && $out_BL[1]) ? $out_BL : null;
2494
2495
2496 $in_TL = $out_TL;
2497 $in_TR = $out_TR;
2498 $in_BR = $out_BR;
2499 $in_BL = $out_BL;
2500
2501 if (is_array($in_TL)) { $in_TL[0]-= $border['l']['width']; $in_TL[1]-= $border['t']['width']; }
2502 if (is_array($in_TR)) { $in_TR[0]-= $border['r']['width']; $in_TR[1]-= $border['t']['width']; }
2503 if (is_array($in_BR)) { $in_BR[0]-= $border['r']['width']; $in_BR[1]-= $border['b']['width']; }
2504 if (is_array($in_BL)) { $in_BL[0]-= $border['l']['width']; $in_BL[1]-= $border['b']['width']; }
2505
2506 if ($in_TL[0]<=0 || $in_TL[1]<=0) $in_TL = null;
2507 if ($in_TR[0]<=0 || $in_TR[1]<=0) $in_TR = null;
2508 if ($in_BR[0]<=0 || $in_BR[1]<=0) $in_BR = null;
2509 if ($in_BL[0]<=0 || $in_BL[1]<=0) $in_BL = null;
2510
2511 // traitement de la couleur de fond
2512 $STYLE = '';
2513 if ($background['color'])
2514 {
2515 $this->pdf->setMyFillColor($background['color']);
2516 $STYLE.= 'F';
2517 }
2518
2519 if ($STYLE)
2520 {
2521 $this->pdf->clippingPathOpen($x, $y, $w, $h, $out_TL,$out_TR, $out_BL, $out_BR);
2522 $this->pdf->Rect($x, $y, $w, $h, $STYLE);
2523 $this->pdf->clippingPathClose();
2524 }
2525
2526 // traitement de l'image de fond
2527 if ($background['image'])
2528 {
2529 $i_name = $background['image'];
2530 $i_position = $background['position']!==null ? $background['position'] : array(0, 0);
2531 $i_repeat = $background['repeat']!==null ? $background['repeat'] : array(true, true);
2532
2533 // taile du fond (il faut retirer les borders
2534 $b_x = $x;
2535 $b_y = $y;
2536 $b_w = $w;
2537 $b_h = $h;
2538
2539 if ($border['b']['width']) { $b_h-= $border['b']['width']; }
2540 if ($border['l']['width']) { $b_w-= $border['l']['width']; $b_x+= $border['l']['width']; }
2541 if ($border['t']['width']) { $b_h-= $border['t']['width']; $b_y+= $border['t']['width']; }
2542 if ($border['r']['width']) { $b_w-= $border['r']['width']; }
2543
2544 // est-ce que c'est une image ?
2545 $i_infos=@GetImageSize($i_name);
2546
2547 if (count($i_infos)<2)
2548 {
2549 if ($this->testIsImage)
2550 {
2551 HTML2PDF::makeError(6, __FILE__, __LINE__, $i_name);
2552 return false;
2553 }
2554 }
2555 else
2556 {
2557 // récupération des dimensions dans l'unité du PDF
2558 $i_width = 72./96.*$i_infos[0]/$this->pdf->getK();
2559 $i_height = 72./96.*$i_infos[1]/$this->pdf->getK();
2560
2561 if ($i_repeat[0]) $i_position[0] = $b_x;
2562 else if(preg_match('/^([-]?[0-9\.]+)%/isU', $i_position[0], $match)) $i_position[0] = $b_x + $match[1]*($b_w-$i_width)/100;
2563 else $i_position[0] = $b_x+$i_position[0];
2564
2565 if ($i_repeat[1]) $i_position[1] = $b_y;
2566 else if(preg_match('/^([-]?[0-9\.]+)%/isU', $i_position[1], $match)) $i_position[1] = $b_y + $match[1]*($b_h-$i_height)/100;
2567 else $i_position[1] = $b_y+$i_position[1];
2568
2569 $i_x_min = $b_x;
2570 $i_x_max = $b_x+$b_w;
2571 $i_y_min = $b_y;
2572 $i_y_max = $b_y+$b_h;
2573
2574 if (!$i_repeat[0] && !$i_repeat[1])
2575 {
2576 $i_x_min = $i_position[0]; $i_x_max = $i_position[0]+$i_width;
2577 $i_y_min = $i_position[1]; $i_y_max = $i_position[1]+$i_height;
2578 }
2579 else if ($i_repeat[0] && !$i_repeat[1])
2580 {
2581 $i_y_min = $i_position[1]; $i_y_max = $i_position[1]+$i_height;
2582 }
2583 elseif (!$i_repeat[0] && $i_repeat[1])
2584 {
2585 $i_x_min = $i_position[0]; $i_x_max = $i_position[0]+$i_width;
2586 }
2587
2588 $this->pdf->clippingPathOpen($b_x, $b_y, $b_w, $b_h, $in_TL, $in_TR, $in_BL, $in_BR);
2589 for ($i_y=$i_y_min; $i_y<$i_y_max; $i_y+=$i_height)
2590 {
2591 for ($i_x=$i_x_min; $i_x<$i_x_max; $i_x+=$i_width)
2592 {
2593 $c_x = null;
2594 $c_y = null;
2595 $c_w = $i_width;
2596 $c_h = $i_height;
2597 if ($i_y_max-$i_y<$i_height)
2598 {
2599 $c_x = $i_x;
2600 $c_y = $i_y;
2601 $c_h = $i_y_max-$i_y;
2602 }
2603 if ($i_x_max-$i_x<$i_width)
2604 {
2605 $c_x = $i_x;
2606 $c_y = $i_y;
2607 $c_w = $i_x_max-$i_x;
2608 }
2609
2610 $this->pdf->Image($i_name, $i_x, $i_y, $i_width, $i_height, '', '');
2611 }
2612 }
2613 $this->pdf->clippingPathClose();
2614 }
2615 }
2616
2617 $x-= 0.01;
2618 $y-= 0.01;
2619 $w+= 0.02;
2620 $h+= 0.02;
2621 if ($border['l']['width']) $border['l']['width']+= 0.02;
2622 if ($border['t']['width']) $border['t']['width']+= 0.02;
2623 if ($border['r']['width']) $border['r']['width']+= 0.02;
2624 if ($border['b']['width']) $border['b']['width']+= 0.02;
2625
2626 $Bl = ($border['l']['width'] && $border['l']['color'][0]!==null);
2627 $Bt = ($border['t']['width'] && $border['t']['color'][0]!==null);
2628 $Br = ($border['r']['width'] && $border['r']['color'][0]!==null);
2629 $Bb = ($border['b']['width'] && $border['b']['color'][0]!==null);
2630
2631 if (is_array($out_BL) && ($Bb || $Bl))
2632 {
2633 if ($in_BL)
2634 {
2635 $courbe = array();
2636 $courbe[] = $x+$out_BL[0]; $courbe[] = $y+$h;
2637 $courbe[] = $x; $courbe[] = $y+$h-$out_BL[1];
2638 $courbe[] = $x+$out_BL[0]; $courbe[] = $y+$h-$border['b']['width'];
2639 $courbe[] = $x+$border['l']['width']; $courbe[] = $y+$h-$out_BL[1];
2640 $courbe[] = $x+$out_BL[0]; $courbe[] = $y+$h-$out_BL[1];
2641 }
2642 else
2643 {
2644 $courbe = array();
2645 $courbe[] = $x+$out_BL[0]; $courbe[] = $y+$h;
2646 $courbe[] = $x; $courbe[] = $y+$h-$out_BL[1];
2647 $courbe[] = $x+$border['l']['width']; $courbe[] = $y+$h-$border['b']['width'];
2648 $courbe[] = $x+$out_BL[0]; $courbe[] = $y+$h-$out_BL[1];
2649 }
2650 $this->drawCourbe($courbe, $border['l']['color']);
2651 }
2652
2653
2654 if (is_array($out_TL) && ($Bt || $Bl))
2655 {
2656 if ($in_TL)
2657 {
2658 $courbe = array();
2659 $courbe[] = $x; $courbe[] = $y+$out_TL[1];
2660 $courbe[] = $x+$out_TL[0]; $courbe[] = $y;
2661 $courbe[] = $x+$border['l']['width']; $courbe[] = $y+$out_TL[1];
2662 $courbe[] = $x+$out_TL[0]; $courbe[] = $y+$border['t']['width'];
2663 $courbe[] = $x+$out_TL[0]; $courbe[] = $y+$out_TL[1];
2664 }
2665 else
2666 {
2667 $courbe = array();
2668 $courbe[] = $x; $courbe[] = $y+$out_TL[1];
2669 $courbe[] = $x+$out_TL[0]; $courbe[] = $y;
2670 $courbe[] = $x+$border['l']['width']; $courbe[] = $y+$border['t']['width'];
2671 $courbe[] = $x+$out_TL[0]; $courbe[] = $y+$out_TL[1];
2672 }
2673 $this->drawCourbe($courbe, $border['t']['color']);
2674 }
2675
2676 if (is_array($out_TR) && ($Bt || $Br))
2677 {
2678 if ($in_TR)
2679 {
2680 $courbe = array();
2681 $courbe[] = $x+$w-$out_TR[0]; $courbe[] = $y;
2682 $courbe[] = $x+$w; $courbe[] = $y+$out_TR[1];
2683 $courbe[] = $x+$w-$out_TR[0]; $courbe[] = $y+$border['t']['width'];
2684 $courbe[] = $x+$w-$border['r']['width']; $courbe[] = $y+$out_TR[1];
2685 $courbe[] = $x+$w-$out_TR[0]; $courbe[] = $y+$out_TR[1];
2686 }
2687 else
2688 {
2689 $courbe = array();
2690 $courbe[] = $x+$w-$out_TR[0]; $courbe[] = $y;
2691 $courbe[] = $x+$w; $courbe[] = $y+$out_TR[1];
2692 $courbe[] = $x+$w-$border['r']['width']; $courbe[] = $y+$border['t']['width'];
2693 $courbe[] = $x+$w-$out_TR[0]; $courbe[] = $y+$out_TR[1];
2694 }
2695 $this->drawCourbe($courbe, $border['r']['color']);
2696 }
2697
2698 if (is_array($out_BR) && ($Bb || $Br))
2699 {
2700 if ($in_BR)
2701 {
2702 $courbe = array();
2703 $courbe[] = $x+$w; $courbe[] = $y+$h-$out_BR[1];
2704 $courbe[] = $x+$w-$out_BR[0]; $courbe[] = $y+$h;
2705 $courbe[] = $x+$w-$border['r']['width']; $courbe[] = $y+$h-$out_BR[1];
2706 $courbe[] = $x+$w-$out_BR[0]; $courbe[] = $y+$h-$border['b']['width'];
2707 $courbe[] = $x+$w-$out_BR[0]; $courbe[] = $y+$h-$out_BR[1];
2708 }
2709 else
2710 {
2711 $courbe = array();
2712 $courbe[] = $x+$w; $courbe[] = $y+$h-$out_BR[1];
2713 $courbe[] = $x+$w-$out_BR[0]; $courbe[] = $y+$h;
2714 $courbe[] = $x+$w-$border['r']['width']; $courbe[] = $y+$h-$border['b']['width'];
2715 $courbe[] = $x+$w-$out_BR[0]; $courbe[] = $y+$h-$out_BR[1];
2716 }
2717 $this->drawCourbe($courbe, $border['b']['color']);
2718 }
2719
2720 if ($Bl)
2721 {
2722 $pt = array();
2723 $pt[] = $x; $pt[] = $y+$h;
2724 $pt[] = $x; $pt[] = $y+$h-$border['b']['width'];
2725 $pt[] = $x; $pt[] = $y+$border['t']['width'];
2726 $pt[] = $x; $pt[] = $y;
2727 $pt[] = $x+$border['l']['width']; $pt[] = $y+$border['t']['width'];
2728 $pt[] = $x+$border['l']['width']; $pt[] = $y+$h-$border['b']['width'];
2729
2730 $bord = 3;
2731 if (is_array($out_BL))
2732 {
2733 $bord-=1;
2734 $pt[3] -= $out_BL[1] - $border['b']['width'];
2735 if ($in_BL) $pt[11]-= $in_BL[1];
2736 unset($pt[0]);unset($pt[1]);
2737 }
2738 if (is_array($out_TL))
2739 {
2740 $bord-=2;
2741 $pt[5] += $out_TL[1]-$border['t']['width'];
2742 if ($in_TL) $pt[9] += $in_TL[1];
2743 unset($pt[6]);unset($pt[7]);
2744 }
2745
2746 $pt = array_values($pt);
2747 $this->drawLine($pt, $border['l']['color'], $border['l']['type'], $border['l']['width'], $bord);
2748 }
2749
2750 if ($Bt)
2751 {
2752 $pt = array();
2753 $pt[] = $x; $pt[] = $y;
2754 $pt[] = $x+$border['l']['width']; $pt[] = $y;
2755 $pt[] = $x+$w-$border['r']['width']; $pt[] = $y;
2756 $pt[] = $x+$w; $pt[] = $y;
2757 $pt[] = $x+$w-$border['r']['width']; $pt[] = $y+$border['t']['width'];
2758 $pt[] = $x+$border['l']['width']; $pt[] = $y+$border['t']['width'];
2759
2760 $bord = 3;
2761 if (is_array($out_TL))
2762 {
2763 $bord-=1;
2764 $pt[2] += $out_TL[0] - $border['l']['width'];
2765 if ($in_TL) $pt[10]+= $in_TL[0];
2766 unset($pt[0]);unset($pt[1]);
2767 }
2768 if (is_array($out_TR))
2769 {
2770 $bord-=2;
2771 $pt[4] -= $out_TR[0] - $border['r']['width'];
2772 if ($in_TR) $pt[8] -= $in_TR[0];
2773 unset($pt[6]);unset($pt[7]);
2774 }
2775
2776 $pt = array_values($pt);
2777 $this->drawLine($pt, $border['t']['color'], $border['t']['type'], $border['t']['width'], $bord);
2778 }
2779
2780 if ($Br)
2781 {
2782 $pt = array();
2783 $pt[] = $x+$w; $pt[] = $y;
2784 $pt[] = $x+$w; $pt[] = $y+$border['t']['width'];
2785 $pt[] = $x+$w; $pt[] = $y+$h-$border['b']['width'];
2786 $pt[] = $x+$w; $pt[] = $y+$h;
2787 $pt[] = $x+$w-$border['r']['width']; $pt[] = $y+$h-$border['b']['width'];
2788 $pt[] = $x+$w-$border['r']['width']; $pt[] = $y+$border['t']['width'];
2789
2790 $bord = 3;
2791 if (is_array($out_TR))
2792 {
2793 $bord-=1;
2794 $pt[3] += $out_TR[1] - $border['t']['width'];
2795 if ($in_TR) $pt[11]+= $in_TR[1];
2796 unset($pt[0]);unset($pt[1]);
2797 }
2798 if (is_array($out_BR))
2799 {
2800 $bord-=2;
2801 $pt[5] -= $out_BR[1] - $border['b']['width'];
2802 if ($in_BR) $pt[9] -= $in_BR[1];
2803 unset($pt[6]);unset($pt[7]);
2804 }
2805
2806 $pt = array_values($pt);
2807 $this->drawLine($pt, $border['r']['color'], $border['r']['type'], $border['r']['width'], $bord);
2808 }
2809
2810 if ($Bb)
2811 {
2812 $pt = array();
2813 $pt[] = $x+$w; $pt[] = $y+$h;
2814 $pt[] = $x+$w-$border['r']['width']; $pt[] = $y+$h;
2815 $pt[] = $x+$border['l']['width']; $pt[] = $y+$h;
2816 $pt[] = $x; $pt[] = $y+$h;
2817 $pt[] = $x+$border['l']['width']; $pt[] = $y+$h-$border['b']['width'];
2818 $pt[] = $x+$w-$border['r']['width']; $pt[] = $y+$h-$border['b']['width'];
2819
2820 $bord = 3;
2821 if (is_array($out_BL))
2822 {
2823 $bord-=2;
2824 $pt[4] += $out_BL[0] - $border['l']['width'];
2825 if ($in_BL) $pt[8] += $in_BL[0];
2826 unset($pt[6]);unset($pt[7]);
2827 }
2828 if (is_array($out_BR))
2829 {
2830 $bord-=1;
2831 $pt[2] -= $out_BR[0] - $border['r']['width'];
2832 if ($in_BR) $pt[10]-= $in_BR[0];
2833 unset($pt[0]);unset($pt[1]);
2834
2835 }
2836
2837 $pt = array_values($pt);
2838 $this->drawLine($pt, $border['b']['color'], $border['b']['type'], $border['b']['width'], $bord);
2839 }
2840
2841 if ($background['color'])
2842 {
2843 $this->pdf->setMyFillColor($background['color']);
2844 }
2845 }
2846
2847 function drawCourbe($pt, $color)
2848 {
2849 $this->pdf->setMyFillColor($color);
2850
2851 if (count($pt)==10)
2852 $this->pdf->drawCourbe($pt[0], $pt[1], $pt[2], $pt[3], $pt[4], $pt[5], $pt[6], $pt[7], $pt[8], $pt[9]);
2853 else
2854 $this->pdf->drawCoin($pt[0], $pt[1], $pt[2], $pt[3], $pt[4], $pt[5], $pt[6], $pt[7]);
2855 }
2856
2857 /**
2858 * Tracer une ligne epaisse défini par ses points avec des extreminites en biseau
2859 *
2860 * @param array liste des points definissant le tour de la ligne
2861 * @param float couleur RVB
2862 * @param string type de ligne
2863 * @param float largeur de la ligne
2864 * @return null
2865 */
2866 function drawLine($pt, $color, $type, $width, $bord=3)
2867 {
2868 $this->pdf->setMyFillColor($color);
2869 if ($type=='dashed' || $type=='dotted')
2870 {
2871 if ($bord==1)
2872 {
2873 $tmp = array(); $tmp[]=$pt[0]; $tmp[]=$pt[1]; $tmp[]=$pt[2]; $tmp[]=$pt[3]; $tmp[]=$pt[8]; $tmp[]=$pt[9];
2874 $this->pdf->Polygon($tmp, 'F');
2875
2876 $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];
2877 $pt = $tmp;
2878 }
2879 else if ($bord==2)
2880 {
2881 $tmp = array(); $tmp[]=$pt[2]; $tmp[]=$pt[3]; $tmp[]=$pt[4]; $tmp[]=$pt[5]; $tmp[]=$pt[6]; $tmp[]=$pt[7];
2882 $this->pdf->Polygon($tmp, 'F');
2883
2884 $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];
2885 $pt = $tmp;
2886 }
2887 else if ($bord==3)
2888 {
2889 $tmp = array(); $tmp[]=$pt[0]; $tmp[]=$pt[1]; $tmp[]=$pt[2]; $tmp[]=$pt[3]; $tmp[]=$pt[10]; $tmp[]=$pt[11];
2890 $this->pdf->Polygon($tmp, 'F');
2891
2892 $tmp = array(); $tmp[]=$pt[4]; $tmp[]=$pt[5]; $tmp[]=$pt[6]; $tmp[]=$pt[7]; $tmp[]=$pt[8]; $tmp[]=$pt[9];
2893 $this->pdf->Polygon($tmp, 'F');
2894
2895 $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];
2896 $pt = $tmp;
2897 }
2898
2899 if ($pt[2]==$pt[0])
2900 {
2901 $l = abs(($pt[3]-$pt[1])*0.5);
2902 $px = 0;
2903 $py = $width;
2904 $x1 = $pt[0]; $y1 = ($pt[3]+$pt[1])*0.5;
2905 $x2 = $pt[6]; $y2 = ($pt[7]+$pt[5])*0.5;
2906 }
2907 else
2908 {
2909 $l = abs(($pt[2]-$pt[0])*0.5);
2910 $px = $width;
2911 $py = 0;
2912 $x1 = ($pt[2]+$pt[0])*0.5; $y1 = $pt[1];
2913 $x2 = ($pt[6]+$pt[4])*0.5; $y2 = $pt[7];
2914 }
2915 if ($type=='dashed')
2916 {
2917 $px = $px*3.;
2918 $py = $py*3.;
2919 }
2920 $mode = ($l/($px+$py)<.5);
2921
2922 for($i=0; $l-($px+$py)*($i-0.5)>0; $i++)
2923 {
2924 if (($i%2)==$mode)
2925 {
2926 $j = $i-0.5;
2927 $lx1 = $px*($j); if ($lx1<-$l) $lx1 =-$l;
2928 $ly1 = $py*($j); if ($ly1<-$l) $ly1 =-$l;
2929 $lx2 = $px*($j+1); if ($lx2>$l) $lx2 = $l;
2930 $ly2 = $py*($j+1); if ($ly2>$l) $ly2 = $l;
2931
2932 $tmp = array();
2933 $tmp[] = $x1+$lx1; $tmp[] = $y1+$ly1;
2934 $tmp[] = $x1+$lx2; $tmp[] = $y1+$ly2;
2935 $tmp[] = $x2+$lx2; $tmp[] = $y2+$ly2;
2936 $tmp[] = $x2+$lx1; $tmp[] = $y2+$ly1;
2937 $this->pdf->Polygon($tmp, 'F');
2938
2939 if ($j>0)
2940 {
2941 $tmp = array();
2942 $tmp[] = $x1-$lx1; $tmp[] = $y1-$ly1;
2943 $tmp[] = $x1-$lx2; $tmp[] = $y1-$ly2;
2944 $tmp[] = $x2-$lx2; $tmp[] = $y2-$ly2;
2945 $tmp[] = $x2-$lx1; $tmp[] = $y2-$ly1;
2946 $this->pdf->Polygon($tmp, 'F');
2947 }
2948 }
2949 }
2950 }
2951 else if ($type=='double')
2952 {
2953 $pt1 = $pt;
2954 $pt2 = $pt;
2955
2956 if (count($pt)==12)
2957 {
2958 $pt1[0] = ($pt[0]-$pt[10])*0.33 + $pt[10];
2959 $pt1[1] = ($pt[1]-$pt[11])*0.33 + $pt[11];
2960 $pt1[2] = ($pt[2]-$pt[10])*0.33 + $pt[10];
2961 $pt1[3] = ($pt[3]-$pt[11])*0.33 + $pt[11];
2962 $pt1[4] = ($pt[4]-$pt[8])*0.33 + $pt[8];
2963 $pt1[5] = ($pt[5]-$pt[9])*0.33 + $pt[9];
2964 $pt1[6] = ($pt[6]-$pt[8])*0.33 + $pt[8];
2965 $pt1[7] = ($pt[7]-$pt[9])*0.33 + $pt[9];
2966 $pt2[10]= ($pt[10]-$pt[0])*0.33 + $pt[0];
2967 $pt2[11]= ($pt[11]-$pt[1])*0.33 + $pt[1];
2968 $pt2[2] = ($pt[2] -$pt[0])*0.33 + $pt[0];
2969 $pt2[3] = ($pt[3] -$pt[1])*0.33 + $pt[1];
2970 $pt2[4] = ($pt[4] -$pt[6])*0.33 + $pt[6];
2971 $pt2[5] = ($pt[5] -$pt[7])*0.33 + $pt[7];
2972 $pt2[8] = ($pt[8] -$pt[6])*0.33 + $pt[6];
2973 $pt2[9] = ($pt[9] -$pt[7])*0.33 + $pt[7];
2974 }
2975 else
2976 {
2977 $pt1[0] = ($pt[0]-$pt[6])*0.33 + $pt[6];
2978 $pt1[1] = ($pt[1]-$pt[7])*0.33 + $pt[7];
2979 $pt1[2] = ($pt[2]-$pt[4])*0.33 + $pt[4];
2980 $pt1[3] = ($pt[3]-$pt[5])*0.33 + $pt[5];
2981 $pt2[6] = ($pt[6]-$pt[0])*0.33 + $pt[0];
2982 $pt2[7] = ($pt[7]-$pt[1])*0.33 + $pt[1];
2983 $pt2[4] = ($pt[4]-$pt[2])*0.33 + $pt[2];
2984 $pt2[5] = ($pt[5]-$pt[3])*0.33 + $pt[3];
2985 }
2986 $this->pdf->Polygon($pt1, 'F');
2987 $this->pdf->Polygon($pt2, 'F');
2988 }
2989 else if ($type=='solid')
2990 {
2991 $this->pdf->Polygon($pt, 'F');
2992 }
2993 }
2994
2995 /**
2996 * balise : BR
2997 * mode : OUVERTURE
2998 *
2999 * @param array paramètres de l'élément de parsing
3000 * @param integer position reelle courante si saut de ligne pendant l'ecriture d'un texte
3001 * @return null
3002 */
3003 function o_BR($param, $curr = null)
3004 {
3005 if ($this->forOneLine) return false;
3006
3007 $h = max($this->maxH, $this->style->getLineHeight());
3008
3009 // si la ligne est vide, la position maximale n'a pas été mise à jour => on la met à jour
3010 if ($this->maxH==0) $this->maxY = max($this->maxY, $this->pdf->getY()+$h);
3011
3012 $this->makeBR($h, $curr);
3013
3014 $this->maxH = 0;
3015
3016 return true;
3017 }
3018
3019 function makeBR($h, $curr = null)
3020 {
3021 // si le saut de ligne rentre => on le prend en compte, sinon nouvelle page
3022 if ($h)
3023 {
3024 if (($this->pdf->getY()+$h<$this->pdf->getH() - $this->pdf->getbMargin()) || $this->isInOverflow || $this->isInFooter)
3025 $this->setNewLine($h, $curr);
3026 else
3027 $this->setNewPage(null, '', null, $curr);
3028 }
3029 else
3030 {
3031 $this->setNewPositionForNewLine($curr);
3032 }
3033
3034 $this->maxH = 0;
3035 }
3036
3037 /**
3038 * balise : HR
3039 * mode : OUVERTURE
3040 *
3041 * @param array paramètres de l'élément de parsing
3042 * @return null
3043 */
3044 function o_HR($param)
3045 {
3046 if ($this->forOneLine) return false;
3047 $old_align = $this->style->value['text-align'];
3048 $this->style->value['text-align'] = 'left';
3049
3050 if ($this->maxH) $this->o_BR($param);
3051
3052 $f_size = $this->style->value['font-size'];
3053 $this->style->value['font-size']=$f_size*0.5; $this->o_BR($param);
3054 $this->style->value['font-size']=0;
3055
3056 $param['style']['width'] = '100%';
3057
3058 $this->style->save();
3059 $this->style->value['height']=$this->style->ConvertToMM('1mm');
3060
3061 $this->style->analyse('hr', $param);
3062 $this->style->setPosition();
3063 $this->style->FontSet();
3064
3065 $h = $this->style->value['height'];
3066 if ($h) $h-= $this->style->value['border']['t']['width']+$this->style->value['border']['b']['width'];
3067 if ($h<=0) $h = $this->style->value['border']['t']['width']+$this->style->value['border']['b']['width'];
3068
3069 $this->drawRectangle($this->pdf->getX(), $this->pdf->getY(), $this->style->value['width'], $h, $this->style->value['border'], 0, 0, $this->style->value['background']);
3070 $this->maxH = $h;
3071
3072 $this->style->load();
3073 $this->style->FontSet();
3074
3075 $this->o_BR($param);
3076
3077 $this->style->value['font-size']=$f_size*0.5; $this->o_BR($param);
3078 $this->style->value['font-size']=$f_size;
3079
3080 $this->style->value['text-align'] = $old_align;
3081 $this->setNewPositionForNewLine();
3082
3083 return true;
3084 }
3085
3086 /**
3087 * balise : B
3088 * mode : OUVERTURE
3089 *
3090 * @param array paramètres de l'élément de parsing
3091 * @return null
3092 */
3093 function o_B($param, $other = 'b')
3094 {
3095 $this->style->save();
3096 $this->style->value['font-bold'] = true;
3097 $this->style->analyse($other, $param);
3098 $this->style->setPosition();
3099 $this->style->FontSet();
3100
3101 return true;
3102 }
3103 function o_STRONG($param) { return $this->o_B($param, 'strong'); }
3104
3105 /**
3106 * balise : B
3107 * mode : FERMETURE
3108 *
3109 * @param array paramètres de l'élément de parsing
3110 * @return null
3111 */
3112 function c_B($param)
3113 {
3114 $this->style->load();
3115 $this->style->FontSet();
3116
3117 return true;
3118 }
3119 function c_STRONG($param) { return $this->c_B($param); }
3120
3121 /**
3122 * balise : I
3123 * mode : OUVERTURE
3124 *
3125 * @param array paramètres de l'élément de parsing
3126 * @return null
3127 */
3128 function o_I($param, $other = 'i')
3129 {
3130 $this->style->save();
3131 $this->style->value['font-italic'] = true;
3132 $this->style->analyse($other, $param);
3133 $this->style->setPosition();
3134 $this->style->FontSet();
3135
3136 return true;
3137 }
3138 function o_ADDRESS($param) { return $this->o_I($param, 'address'); }
3139 function o_CITE($param) { return $this->o_I($param, 'cite'); }
3140 function o_EM($param) { return $this->o_I($param, 'em'); }
3141 function o_SAMP($param) { return $this->o_I($param, 'samp'); }
3142
3143 /**
3144 * balise : I
3145 * mode : FERMETURE
3146 *
3147 * @param array paramètres de l'élément de parsing
3148 * @return null
3149 */
3150 function c_I($param)
3151 {
3152 $this->style->load();
3153 $this->style->FontSet();
3154
3155 return true;
3156 }
3157 function c_ADDRESS($param) { return $this->c_I($param); }
3158 function c_CITE($param) { return $this->c_I($param); }
3159 function c_EM($param) { return $this->c_I($param); }
3160 function c_SAMP($param) { return $this->c_I($param); }
3161
3162 /**
3163 * balise : S
3164 * mode : OUVERTURE
3165 *
3166 * @param array paramètres de l'élément de parsing
3167 * @return null
3168 */
3169 function o_S($param, $other = 's')
3170 {
3171 $this->style->save();
3172 $this->style->value['font-linethrough'] = true;
3173 $this->style->analyse($other, $param);
3174 $this->style->setPosition();
3175 $this->style->FontSet();
3176
3177 return true;
3178 }
3179 function o_DEL($param) { return $this->o_S($param, 'del'); }
3180
3181 /**
3182 * balise : S
3183 * mode : FERMETURE
3184 *
3185 * @param array paramètres de l'élément de parsing
3186 * @return null
3187 */
3188 function c_S($param)
3189 {
3190 $this->style->load();
3191 $this->style->FontSet();
3192
3193 return true;
3194 }
3195 function c_DEL($param) { return $this->c_S($param); }
3196
3197 /**
3198 * balise : U
3199 * mode : OUVERTURE
3200 *
3201 * @param array paramètres de l'élément de parsing
3202 * @return null
3203 */
3204 function o_U($param, $other='u')
3205 {
3206 $this->style->save();
3207 $this->style->value['font-underline'] = true;
3208 $this->style->analyse($other, $param);
3209 $this->style->setPosition();
3210 $this->style->FontSet();
3211
3212 return true;
3213 }
3214 function o_INS($param) { return $this->o_U($param, 'ins'); }
3215
3216 /**
3217 * balise : U
3218 * mode : FERMETURE
3219 *
3220 * @param array paramètres de l'élément de parsing
3221 * @return null
3222 */
3223 function c_U($param)
3224 {
3225 $this->style->load();
3226 $this->style->FontSet();
3227
3228 return true;
3229 }
3230 function c_INS($param) { return $this->c_U($param); }
3231
3232 /**
3233 * balise : A
3234 * mode : OUVERTURE
3235 *
3236 * @param array paramètres de l'élément de parsing
3237 * @return null
3238 */
3239 function o_A($param)
3240 {
3241 $this->inLink = str_replace('&amp;', '&', isset($param['href']) ? $param['href'] : '');
3242
3243 if (isset($param['name']))
3244 {
3245 $nom = $param['name'];
3246 if (!isset($this->lstAncre[$nom])) $this->lstAncre[$nom] = array($this->pdf->AddLink(), false);
3247
3248 if (!$this->lstAncre[$nom][1])
3249 {
3250 $this->lstAncre[$nom][1] = true;
3251 $this->pdf->SetLink($this->lstAncre[$nom][0], -1, -1);
3252 }
3253 }
3254
3255 if (preg_match('/^#([^#]+)$/isU', $this->inLink, $match))
3256 {
3257 $nom = $match[1];
3258 if (!isset($this->lstAncre[$nom])) $this->lstAncre[$nom] = array($this->pdf->AddLink(), false);
3259
3260 $this->inLink = $this->lstAncre[$nom][0];
3261 }
3262
3263 $this->style->save();
3264 $this->style->value['font-underline'] = true;
3265 $this->style->value['color'] = array(0.08, 0.08, 0.98);
3266 $this->style->analyse('a', $param);
3267 $this->style->setPosition();
3268 $this->style->FontSet();
3269
3270 return true;
3271 }
3272
3273 /**
3274 * balise : A
3275 * mode : FERMETURE
3276 *
3277 * @param array paramètres de l'élément de parsing
3278 * @return null
3279 */
3280 function c_A($param)
3281 {
3282 $this->inLink = '';
3283 $this->style->load();
3284 $this->style->FontSet();
3285
3286 return true;
3287 }
3288
3289 /**
3290 * balise : H1
3291 * mode : OUVERTURE
3292 *
3293 * @param array paramètres de l'élément de parsing
3294 * @return null
3295 */
3296 function o_H1($param, $other = 'h1')
3297 {
3298 if ($this->forOneLine) return false;
3299
3300 if ($this->maxH) $this->o_BR(array());
3301 $this->style->save();
3302 $this->style->value['font-bold'] = true;
3303
3304 $size = array('h1' => '28px', 'h2' => '24px', 'h3' => '20px', 'h4' => '16px', 'h5' => '12px', 'h6' => '9px');
3305 $this->style->value['margin']['l'] = 0;
3306 $this->style->value['margin']['r'] = 0;
3307 $this->style->value['margin']['t'] = $this->style->ConvertToMM('16px');
3308 $this->style->value['margin']['b'] = $this->style->ConvertToMM('16px');
3309 $this->style->value['font-size'] = $this->style->ConvertToMM($size[$other]);
3310
3311 $this->style->analyse($other, $param);
3312 $this->style->setPosition();
3313 $this->style->FontSet();
3314 $this->setNewPositionForNewLine();
3315
3316 return true;
3317 }
3318 function o_H2($param) { return $this->o_H1($param, 'h2'); }
3319 function o_H3($param) { return $this->o_H1($param, 'h3'); }
3320 function o_H4($param) { return $this->o_H1($param, 'h4'); }
3321 function o_H5($param) { return $this->o_H1($param, 'h5'); }
3322 function o_H6($param) { return $this->o_H1($param, 'h6'); }
3323
3324
3325 /**
3326 * balise : H1
3327 * mode : FERMETURE
3328 *
3329 * @param array paramètres de l'élément de parsing
3330 * @return null
3331 */
3332 function c_H1($param)
3333 {
3334 if ($this->forOneLine) return false;
3335
3336 // hauteur du H1
3337 $this->maxH+= $this->style->value['margin']['b'];
3338 $h = max($this->maxH, $this->style->getLineHeight());
3339
3340 $this->style->load();
3341 $this->style->FontSet();
3342
3343 // saut de ligne et initialisation de la hauteur
3344 $this->makeBR($h);
3345 $this->maxH = 0;
3346
3347 return true;
3348 }
3349 function c_H2($param) { return $this->c_H1($param); }
3350 function c_H3($param) { return $this->c_H1($param); }
3351 function c_H4($param) { return $this->c_H1($param); }
3352 function c_H5($param) { return $this->c_H1($param); }
3353 function c_H6($param) { return $this->c_H1($param); }
3354
3355 /**
3356 * balise : SPAN
3357 * mode : OUVERTURE
3358 *
3359 * @param array paramètres de l'élément de parsing
3360 * @return null
3361 */
3362 function o_SPAN($param, $other = 'span')
3363 {
3364 $this->style->save();
3365 $this->style->analyse($other, $param);
3366 $this->style->setPosition();
3367 $this->style->FontSet();
3368
3369 return true;
3370 }
3371 function o_FONT($param) { return $this->o_SPAN($param, 'font'); }
3372 function o_LABEL($param) { return $this->o_SPAN($param, 'label');}
3373
3374 /**
3375 * balise : SPAN
3376 * mode : FERMETURE
3377 *
3378 * @param array paramètres de l'élément de parsing
3379 * @return null
3380 */
3381 function c_SPAN($param)
3382 {
3383 $this->style->restorePosition();
3384 $this->style->load();
3385 $this->style->FontSet();
3386
3387 return true;
3388 }
3389 function c_FONT($param) { return $this->c_SPAN($param); }
3390 function c_LABEL($param) { return $this->c_SPAN($param); }
3391
3392
3393 /**
3394 * balise : P
3395 * mode : OUVERTURE
3396 *
3397 * @param array paramètres de l'élément de parsing
3398 * @return null
3399 */
3400 function o_P($param)
3401 {
3402 if ($this->forOneLine) return false;
3403
3404 if (!in_array($this->previousCall, array('c_P', 'c_UL')))
3405 {
3406 if ($this->maxH) $this->o_BR(array());
3407 }
3408
3409 $this->style->save();
3410 $this->style->analyse('p', $param);
3411 $this->style->setPosition();
3412 $this->style->FontSet();
3413 // annule les effets du setposition
3414 $this->pdf->setXY($this->pdf->getX()-$this->style->value['margin']['l'], $this->pdf->getY()-$this->style->value['margin']['t']);
3415
3416 list($mL, $mR) = $this->getMargins($this->pdf->getY());
3417 $mR = $this->pdf->getW()-$mR;
3418 $mL+= $this->style->value['margin']['l']+$this->style->value['padding']['l'];
3419 $mR+= $this->style->value['margin']['r']+$this->style->value['padding']['r'];
3420 $this->saveMargin($mL,0,$mR);
3421
3422 if ($this->style->value['text-indent']>0)
3423 {
3424 $y = $this->pdf->getY()+$this->style->value['margin']['t']+$this->style->value['padding']['t'];
3425 $this->pageMarges[floor($y*100)] = array($mL+$this->style->value['text-indent'], $this->pdf->getW()-$mR);
3426 $y+= $this->style->getLineHeight()*0.1;
3427 $this->pageMarges[floor($y*100)] = array($mL, $this->pdf->getW()-$mR);
3428 }
3429 $this->makeBR($this->style->value['margin']['t']+$this->style->value['padding']['t']);
3430 return true;
3431 }
3432
3433 /**
3434 * balise : P
3435 * mode : FERMETURE
3436 *
3437 * @param array paramètres de l'élément de parsing
3438 * @return null
3439 */
3440 function c_P($param)
3441 {
3442 if ($this->forOneLine) return false;
3443
3444 if ($this->maxH) $this->o_BR(array());
3445 $this->loadMargin();
3446 $h = $this->style->value['margin']['b']+$this->style->value['padding']['b'];
3447
3448 $this->style->load();
3449 $this->style->FontSet();
3450 $this->makeBR($h);
3451
3452 return true;
3453 }
3454
3455 /**
3456 * balise : PRE
3457 * mode : OUVERTURE
3458 *
3459 * @param array paramètres de l'élément de parsing
3460 * @return null
3461 */
3462 function o_PRE($param, $other = 'pre')
3463 {
3464 if ($other=='pre' && $this->maxH) $this->o_BR(array());
3465
3466 $this->style->save();
3467 $this->style->value['font-family'] = 'courier';
3468 $this->style->analyse($other, $param);
3469 $this->style->setPosition();
3470 $this->style->FontSet();
3471
3472 if ($other=='pre') return $this->o_DIV($param, $other);
3473
3474 return true;
3475 }
3476 function o_CODE($param) { return $this->o_PRE($param, 'code'); }
3477
3478 /**
3479 * balise : PRE
3480 * mode : FERMETURE
3481 *
3482 * @param array paramètres de l'élément de parsing
3483 * @return null
3484 */
3485 function c_PRE($param, $other = 'pre')
3486 {
3487 if ($other=='pre')
3488 {
3489 if ($this->forOneLine) return false;
3490
3491 $this->c_DIV($param);
3492 $this->o_BR(array());
3493 }
3494 $this->style->load();
3495 $this->style->FontSet();
3496
3497 return true;
3498 }
3499 function c_CODE($param) { return $this->c_PRE($param, 'code'); }
3500
3501 /**
3502 * balise : BIG
3503 * mode : OUVERTURE
3504 *
3505 * @param array paramètres de l'élément de parsing
3506 * @return null
3507 */
3508 function o_BIG($param)
3509 {
3510 $this->style->save();
3511 $this->style->value['mini-decal']-= $this->style->value['mini-size']*0.05;
3512 $this->style->value['mini-size'] *= 1.2;
3513 $this->style->analyse('big', $param);
3514 $this->style->setPosition();
3515 $this->style->FontSet();
3516 return true;
3517 }
3518
3519 /**
3520 * balise : BIG
3521 * mode : FERMETURE
3522 *
3523 * @param array paramètres de l'élément de parsing
3524 * @return null
3525 */
3526 function c_BIG($param)
3527 {
3528 $this->style->load();
3529 $this->style->FontSet();
3530
3531 return true;
3532 }
3533
3534 /**
3535 * balise : SMALL
3536 * mode : OUVERTURE
3537 *
3538 * @param array paramètres de l'élément de parsing
3539 * @return null
3540 */
3541 function o_SMALL($param)
3542 {
3543 $this->style->save();
3544 $this->style->value['mini-decal']+= $this->style->value['mini-size']*0.05;
3545 $this->style->value['mini-size'] *= 0.82;
3546 $this->style->analyse('small', $param);
3547 $this->style->setPosition();
3548 $this->style->FontSet();
3549 return true;
3550 }
3551
3552 /**
3553 * balise : SMALL
3554 * mode : FERMETURE
3555 *
3556 * @param array paramètres de l'élément de parsing
3557 * @return null
3558 */
3559 function c_SMALL($param)
3560 {
3561 $this->style->load();
3562 $this->style->FontSet();
3563
3564 return true;
3565 }
3566
3567
3568 /**
3569 * balise : SUP
3570 * mode : OUVERTURE
3571 *
3572 * @param array paramètres de l'élément de parsing
3573 * @return null
3574 */
3575 function o_SUP($param)
3576 {
3577 $this->style->save();
3578 $this->style->value['mini-decal']-= $this->style->value['mini-size']*0.15;
3579 $this->style->value['mini-size'] *= 0.75;
3580 $this->style->analyse('sup', $param);
3581 $this->style->setPosition();
3582 $this->style->FontSet();
3583
3584 return true;
3585 }
3586
3587 /**
3588 * balise : SUP
3589 * mode : FERMETURE
3590 *
3591 * @param array paramètres de l'élément de parsing
3592 * @return null
3593 */
3594 function c_SUP($param)
3595 {
3596 $this->style->load();
3597 $this->style->FontSet();
3598
3599 return true;
3600 }
3601
3602 /**
3603 * balise : SUB
3604 * mode : OUVERTURE
3605 *
3606 * @param array paramètres de l'élément de parsing
3607 * @return null
3608 */
3609 function o_SUB($param)
3610 {
3611 $this->style->save();
3612 $this->style->value['mini-decal']+= $this->style->value['mini-size']*0.15;
3613 $this->style->value['mini-size'] *= 0.75;
3614 $this->style->analyse('sub', $param);
3615 $this->style->setPosition();
3616 $this->style->FontSet();
3617 return true;
3618 }
3619
3620 /**
3621 * balise : SUB
3622 * mode : FERMETURE
3623 *
3624 * @param array paramètres de l'élément de parsing
3625 * @return null
3626 */
3627 function c_SUB($param)
3628 {
3629 $this->style->load();
3630 $this->style->FontSet();
3631
3632 return true;
3633 }
3634
3635 /**
3636 * balise : UL
3637 * mode : OUVERTURE
3638 *
3639 * @param array paramètres de l'élément de parsing
3640 * @return null
3641 */
3642 function o_UL($param, $other = 'ul')
3643 {
3644 if ($this->forOneLine) return false;
3645
3646 if (!in_array($this->previousCall, array('c_P', 'c_UL')))
3647 {
3648 if ($this->maxH) $this->o_BR(array());
3649 if (!count($this->defLIST)) $this->o_BR(array());
3650 }
3651
3652 if (!isset($param['style']['width'])) $param['allwidth'] = true;
3653 $param['cellspacing'] = 0;
3654
3655 // une liste est traitée comme un tableau
3656 $this->o_TABLE($param, $other);
3657
3658 // ajouter un niveau de liste
3659 $this->listeAddLevel($other, $this->style->value['list-style-type'], $this->style->value['list-style-image']);
3660
3661 return true;
3662 }
3663 function o_OL($param) { return $this->o_UL($param, 'ol'); }
3664
3665 /**
3666 * balise : UL
3667 * mode : FERMETURE
3668 *
3669 * @param array paramètres de l'élément de parsing
3670 * @return null
3671 */
3672 function c_UL($param)
3673 {
3674 if ($this->forOneLine) return false;
3675
3676 // fin du tableau
3677 $this->c_TABLE($param);
3678
3679 // enlever un niveau de liste
3680 $this->listeDelLevel();
3681
3682 if (!$this->sub_part)
3683 {
3684 if (!count($this->defLIST)) $this->o_BR(array());
3685 }
3686
3687 return true;
3688 }
3689 function c_OL($param) { return $this->c_UL($param); }
3690
3691 /**
3692 * balise : LI
3693 * mode : OUVERTURE
3694 *
3695 * @param array paramètres de l'élément de parsing
3696 * @return null
3697 */
3698 function o_LI($param)
3699 {
3700 if ($this->forOneLine) return false;
3701
3702 // ajouter une puce au niveau actuel
3703 $this->listeAddLi();
3704
3705 if (!isset($param['style']['width'])) $param['style']['width'] = '100%';
3706
3707 // preparation du style de la puce
3708 $paramPUCE = $param;
3709
3710 $inf = $this->listeGetLi();
3711 if ($inf[0])
3712 {
3713 $paramPUCE['style']['font-family'] = $inf[0];
3714 $paramPUCE['style']['text-align'] = 'li_right';
3715 $paramPUCE['style']['vertical-align'] = 'top';
3716 $paramPUCE['style']['width'] = $this->listeGetWidth();
3717 $paramPUCE['style']['padding-right'] = $this->listeGetPadding();
3718 $paramPUCE['txt'] = $inf[2];
3719 }
3720 else
3721 {
3722 $paramPUCE['style']['text-align'] = 'li_right';
3723 $paramPUCE['style']['vertical-align'] = 'top';
3724 $paramPUCE['style']['width'] = $this->listeGetWidth();
3725 $paramPUCE['style']['padding-right'] = $this->listeGetPadding();
3726 $paramPUCE['src'] = $inf[2];
3727 $paramPUCE['sub_li'] = true;
3728 }
3729
3730 // nouvelle ligne
3731 $this->o_TR($param, 'li');
3732
3733 $this->style->save();
3734
3735 if ($inf[1]) // small
3736 {
3737 $this->style->value['mini-decal']+= $this->style->value['mini-size']*0.045;
3738 $this->style->value['mini-size'] *= 0.75;
3739 }
3740
3741 // si on est dans un sub_html => preparation, sinon affichage classique
3742 if ($this->sub_part)
3743 {
3744 // TD pour la puce
3745 $tmp_pos = $this->temp_pos;
3746 $tmp_lst1 = $this->parsing->code[$tmp_pos+1];
3747 $tmp_lst2 = $this->parsing->code[$tmp_pos+2];
3748 $this->parsing->code[$tmp_pos+1] = array();
3749 $this->parsing->code[$tmp_pos+1]['name'] = (isset($paramPUCE['src'])) ? 'img' : 'write';
3750 $this->parsing->code[$tmp_pos+1]['param'] = $paramPUCE; unset($this->parsing->code[$tmp_pos+1]['param']['style']['width']);
3751 $this->parsing->code[$tmp_pos+1]['close'] = 0;
3752 $this->parsing->code[$tmp_pos+2] = array();
3753 $this->parsing->code[$tmp_pos+2]['name'] = 'li';
3754 $this->parsing->code[$tmp_pos+2]['param'] = $paramPUCE;
3755 $this->parsing->code[$tmp_pos+2]['close'] = 1;
3756 $this->o_TD($paramPUCE, 'li_sub');
3757 $this->c_TD($param);
3758 $this->temp_pos = $tmp_pos;
3759 $this->parsing->code[$tmp_pos+1] = $tmp_lst1;
3760 $this->parsing->code[$tmp_pos+2] = $tmp_lst2;
3761 }
3762 else
3763 {
3764 // TD pour la puce
3765 $this->o_TD($paramPUCE, 'li_sub');
3766 unset($paramPUCE['style']['width']);
3767 if (isset($paramPUCE['src'])) $this->o_IMG($paramPUCE);
3768 else $this->o_WRITE($paramPUCE);
3769 $this->c_TD($paramPUCE);
3770 }
3771 $this->style->load();
3772
3773
3774 // td pour le contenu
3775 $this->o_TD($param, 'li');
3776
3777 return true;
3778 }
3779
3780 /**
3781 * balise : LI
3782 * mode : FERMETURE
3783 *
3784 * @param array paramètres de l'élément de parsing
3785 * @return null
3786 */
3787 function c_LI($param)
3788 {
3789 if ($this->forOneLine) return false;
3790
3791 // fin du contenu
3792 $this->c_TD($param);
3793
3794 // fin de la ligne
3795 $this->c_TR($param);
3796
3797 return true;
3798 }
3799
3800 /**
3801 * balise : TBODY
3802 * mode : OUVERTURE
3803 *
3804 * @param array paramètres de l'élément de parsing
3805 * @return null
3806 */
3807 function o_TBODY($param)
3808 {
3809 if ($this->forOneLine) return false;
3810
3811 $this->style->save();
3812 $this->style->analyse('tbody', $param);
3813 $this->style->setPosition();
3814 $this->style->FontSet();
3815
3816 return true;
3817 }
3818
3819 /**
3820 * balise : TBODY
3821 * mode : FERMETURE
3822 *
3823 * @param array paramètres de l'élément de parsing
3824 * @return null
3825 */
3826 function c_TBODY($param)
3827 {
3828 if ($this->forOneLine) return false;
3829
3830 $this->style->load();
3831 $this->style->FontSet();
3832
3833 return true;
3834 }
3835
3836 /**
3837 * balise : THEAD
3838 * mode : OUVERTURE
3839 *
3840 * @param array paramètres de l'élément de parsing
3841 * @return null
3842 */
3843 function o_THEAD($param)
3844 {
3845 if ($this->forOneLine) return false;
3846
3847 global $HTML2PDF_TABLEAU;
3848
3849 $this->style->save();
3850 $this->style->analyse('thead', $param);
3851 $this->style->setPosition();
3852 $this->style->FontSet();
3853
3854 // si on est en mode sub_html : sauvegarde du numéro du TR
3855 if ($this->sub_part)
3856 {
3857 $HTML2PDF_TABLEAU[$param['num']]['thead']['tr'][0] = $HTML2PDF_TABLEAU[$param['num']]['tr_curr'];
3858 $HTML2PDF_TABLEAU[$param['num']]['thead']['code'] = array();
3859 for($pos=$this->temp_pos; $pos<count($this->parsing->code); $pos++)
3860 {
3861 $todo = $this->parsing->code[$pos];
3862 if (strtolower($todo['name'])=='thead') $todo['name'] = 'thead_sub';
3863 $HTML2PDF_TABLEAU[$param['num']]['thead']['code'][] = $todo;
3864 if (strtolower($todo['name'])=='thead_sub' && $todo['close']) break;
3865 }
3866 }
3867 else
3868 {
3869 $level = $this->parsing->getLevel($this->parse_pos);
3870 $this->parse_pos+= count($level);
3871 $HTML2PDF_TABLEAU[$param['num']]['tr_curr']+= count($HTML2PDF_TABLEAU[$param['num']]['thead']['tr']);
3872 }
3873
3874 return true;
3875 }
3876
3877 /**
3878 * balise : THEAD
3879 * mode : FERMETURE
3880 *
3881 * @param array paramètres de l'élément de parsing
3882 * @return null
3883 */
3884 function c_THEAD($param)
3885 {
3886 if ($this->forOneLine) return false;
3887
3888 $this->style->load();
3889 $this->style->FontSet();
3890
3891 // si on est en mode sub_html : sauvegarde du numéro du TR
3892 if ($this->sub_part)
3893 {
3894 global $HTML2PDF_TABLEAU;
3895 $min = $HTML2PDF_TABLEAU[$param['num']]['thead']['tr'][0];
3896 $max = $HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1;
3897 $HTML2PDF_TABLEAU[$param['num']]['thead']['tr'] = range($min, $max);
3898 }
3899
3900 return true;
3901 }
3902
3903 /**
3904 * balise : TFOOT
3905 * mode : OUVERTURE
3906 *
3907 * @param array paramètres de l'élément de parsing
3908 * @return null
3909 */
3910 function o_TFOOT($param)
3911 {
3912 if ($this->forOneLine) return false;
3913
3914 global $HTML2PDF_TABLEAU;
3915
3916 $this->style->save();
3917 $this->style->analyse('tfoot', $param);
3918 $this->style->setPosition();
3919 $this->style->FontSet();
3920
3921 // si on est en mode sub_html : sauvegarde du numéro du TR
3922 if ($this->sub_part)
3923 {
3924 $HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr'][0] = $HTML2PDF_TABLEAU[$param['num']]['tr_curr'];
3925 $HTML2PDF_TABLEAU[$param['num']]['tfoot']['code'] = array();
3926 for($pos=$this->temp_pos; $pos<count($this->parsing->code); $pos++)
3927 {
3928 $todo = $this->parsing->code[$pos];
3929 if (strtolower($todo['name'])=='tfoot') $todo['name'] = 'tfoot_sub';
3930 $HTML2PDF_TABLEAU[$param['num']]['tfoot']['code'][] = $todo;
3931 if (strtolower($todo['name'])=='tfoot_sub' && $todo['close']) break;
3932 }
3933 }
3934 else
3935 {
3936 $level = $this->parsing->getLevel($this->parse_pos);
3937 $this->parse_pos+= count($level);
3938 $HTML2PDF_TABLEAU[$param['num']]['tr_curr']+= count($HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr']);
3939 }
3940
3941 return true;
3942 }
3943
3944 /**
3945 * balise : TFOOT
3946 * mode : FERMETURE
3947 *
3948 * @param array paramètres de l'élément de parsing
3949 * @return null
3950 */
3951 function c_TFOOT($param)
3952 {
3953 if ($this->forOneLine) return false;
3954
3955 $this->style->load();
3956 $this->style->FontSet();
3957
3958 // si on est en mode sub_html : sauvegarde du numéro du TR
3959 if ($this->sub_part)
3960 {
3961 global $HTML2PDF_TABLEAU;
3962
3963 $min = $HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr'][0];
3964 $max = $HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1;
3965 $HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr'] = range($min, $max);
3966 }
3967
3968 return true;
3969 }
3970
3971 /**
3972 * balise : THEAD_SUB
3973 * mode : OUVERTURE
3974 *
3975 * @param array paramètres de l'élément de parsing
3976 * @return null
3977 */
3978 function o_THEAD_SUB($param)
3979 {
3980 if ($this->forOneLine) return false;
3981
3982 $this->style->save();
3983 $this->style->analyse('thead', $param);
3984 $this->style->setPosition();
3985 $this->style->FontSet();
3986
3987 return true;
3988 }
3989
3990 /**
3991 * balise : THEAD_SUB
3992 * mode : FERMETURE
3993 *
3994 * @param array paramètres de l'élément de parsing
3995 * @return null
3996 */
3997 function c_THEAD_SUB($param)
3998 {
3999 if ($this->forOneLine) return false;
4000
4001 $this->style->load();
4002 $this->style->FontSet();
4003
4004 return true;
4005 }
4006
4007 /**
4008 * balise : TFOOT_SUB
4009 * mode : OUVERTURE
4010 *
4011 * @param array paramètres de l'élément de parsing
4012 * @return null
4013 */
4014 function o_TFOOT_SUB($param)
4015 {
4016 if ($this->forOneLine) return false;
4017
4018 $this->style->save();
4019 $this->style->analyse('tfoot', $param);
4020 $this->style->setPosition();
4021 $this->style->FontSet();
4022
4023 return true;
4024 }
4025
4026 /**
4027 * balise : TFOOT_SUB
4028 * mode : FERMETURE
4029 *
4030 * @param array paramètres de l'élément de parsing
4031 * @return null
4032 */
4033 function c_TFOOT_SUB($param)
4034 {
4035 if ($this->forOneLine) return false;
4036
4037 $this->style->load();
4038 $this->style->FontSet();
4039
4040 return true;
4041 }
4042
4043 /**
4044 * balise : FORM
4045 * mode : OUVERTURE
4046 *
4047 * @param array paramètres de l'élément de parsing
4048 * @return null
4049 */
4050 function o_FORM($param)
4051 {
4052 $this->style->save();
4053 $this->style->analyse('form', $param);
4054 $this->style->setPosition();
4055 $this->style->FontSet();
4056
4057 $this->isInForm = isset($param['action']) ? $param['action'] : '';
4058
4059 return true;
4060 }
4061
4062 /**
4063 * balise : FORM
4064 * mode : FERMETURE
4065 *
4066 * @param array paramètres de l'élément de parsing
4067 * @return null
4068 */
4069 function c_FORM($param)
4070 {
4071 $this->isInForm = false;
4072 $this->style->load();
4073 $this->style->FontSet();
4074
4075 return true;
4076 }
4077
4078 /**
4079 * balise : TABLE
4080 * mode : OUVERTURE
4081 *
4082 * @param array paramètres de l'élément de parsing
4083 * @return null
4084 */
4085 function o_TABLE($param, $other = 'table')
4086 {
4087 if ($this->maxH)
4088 {
4089 if ($this->forOneLine) return false;
4090 $this->o_BR(array());
4091 }
4092
4093 if ($this->forOneLine)
4094 {
4095 $this->maxE++;
4096 $this->maxX = $this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin();
4097 return false;
4098 }
4099
4100 $this->maxH = 0;
4101 // utilisation du tableau des paramétres des tables
4102 global $HTML2PDF_TABLEAU;
4103
4104 $align_object = isset($param['align']) ? strtolower($param['align']) : 'left';
4105 if (isset($param['align'])) unset($param['align']);
4106 if (!in_array($align_object, array('left', 'center', 'right'))) $align_object = 'left';
4107
4108 // lecture et initialisation du style
4109 $this->style->save();
4110 $this->style->analyse($other, $param);
4111 $this->style->setPosition();
4112 $this->style->FontSet();
4113
4114 if ($this->style->value['margin-auto']) $align_object = 'center';
4115
4116 // est-on en collapse
4117 $collapse = false;
4118 if ($other=='table')
4119 $collapse = isset($this->style->value['border']['collapse']) ? $this->style->value['border']['collapse'] : false;
4120
4121 // si oui il faut adapté les borders
4122 if ($collapse)
4123 {
4124 $param['style']['border'] = 'none';
4125 $param['cellspacing'] = 0;
4126 $none = $this->style->readBorder('none');
4127 $this->style->value['border']['t'] = $none;
4128 $this->style->value['border']['r'] = $none;
4129 $this->style->value['border']['b'] = $none;
4130 $this->style->value['border']['l'] = $none;
4131 }
4132
4133 // si on est en mode sub_html : initialisation des dimensions et autres
4134 if ($this->sub_part)
4135 {
4136 if ($this->DEBUG_actif) $this->DEBUG_add('Table n°'.$param['num'], true);
4137 $HTML2PDF_TABLEAU[$param['num']] = array();
4138 $HTML2PDF_TABLEAU[$param['num']]['border'] = isset($param['border']) ? $this->style->readBorder($param['border']) : null; // border spécifique si border precisé en paramètre
4139 $HTML2PDF_TABLEAU[$param['num']]['cellpadding'] = $this->style->ConvertToMM(isset($param['cellpadding']) ? $param['cellpadding'] : '1px'); // cellpadding du tableau
4140 $HTML2PDF_TABLEAU[$param['num']]['cellspacing'] = $this->style->ConvertToMM(isset($param['cellspacing']) ? $param['cellspacing'] : '2px'); // cellspacing du tableau
4141 $HTML2PDF_TABLEAU[$param['num']]['cases'] = array(); // liste des propriétés des cases
4142 $HTML2PDF_TABLEAU[$param['num']]['corr'] = array(); // tableau de correlation pour les colspan et rowspan
4143 $HTML2PDF_TABLEAU[$param['num']]['corr_x'] = 0; // position dans le tableau de correlation
4144 $HTML2PDF_TABLEAU[$param['num']]['corr_y'] = 0; // position dans le tableau de correlation
4145 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = 0; // colonne courante
4146 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = 0; // ligne courante
4147 $HTML2PDF_TABLEAU[$param['num']]['curr_x'] = $this->pdf->getX(); // position courante X
4148 $HTML2PDF_TABLEAU[$param['num']]['curr_y'] = $this->pdf->getY(); // position courante Y
4149 $HTML2PDF_TABLEAU[$param['num']]['width'] = 0; // largeur globale
4150 $HTML2PDF_TABLEAU[$param['num']]['height'] = 0; // hauteur globale
4151 $HTML2PDF_TABLEAU[$param['num']]['align'] = $align_object;
4152 $HTML2PDF_TABLEAU[$param['num']]['marge'] = array();
4153 $HTML2PDF_TABLEAU[$param['num']]['marge']['t'] = $this->style->value['padding']['t']+$this->style->value['border']['t']['width']+$HTML2PDF_TABLEAU[$param['num']]['cellspacing']*0.5;
4154 $HTML2PDF_TABLEAU[$param['num']]['marge']['r'] = $this->style->value['padding']['r']+$this->style->value['border']['r']['width']+$HTML2PDF_TABLEAU[$param['num']]['cellspacing']*0.5;
4155 $HTML2PDF_TABLEAU[$param['num']]['marge']['b'] = $this->style->value['padding']['b']+$this->style->value['border']['b']['width']+$HTML2PDF_TABLEAU[$param['num']]['cellspacing']*0.5;
4156 $HTML2PDF_TABLEAU[$param['num']]['marge']['l'] = $this->style->value['padding']['l']+$this->style->value['border']['l']['width']+$HTML2PDF_TABLEAU[$param['num']]['cellspacing']*0.5;
4157 $HTML2PDF_TABLEAU[$param['num']]['page'] = 0; // nombre de pages
4158 $HTML2PDF_TABLEAU[$param['num']]['new_page'] = true; // nouvelle page pour le TR courant
4159 $HTML2PDF_TABLEAU[$param['num']]['style_value'] = null; // style du tableau
4160 $HTML2PDF_TABLEAU[$param['num']]['thead'] = array(); // infos sur le thead
4161 $HTML2PDF_TABLEAU[$param['num']]['tfoot'] = array(); // infos sur le tfoot
4162 $HTML2PDF_TABLEAU[$param['num']]['thead']['tr'] = array(); // tr du thead
4163 $HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr'] = array(); // tr du tfoot
4164 $HTML2PDF_TABLEAU[$param['num']]['thead']['height'] = 0; // hauteur du thead
4165 $HTML2PDF_TABLEAU[$param['num']]['tfoot']['height'] = 0; // hauteur du tfoot
4166 $HTML2PDF_TABLEAU[$param['num']]['thead']['code'] = array(); // contenu HTML du thead
4167 $HTML2PDF_TABLEAU[$param['num']]['tfoot']['code'] = array(); // contenu HTML du tfoot
4168 $HTML2PDF_TABLEAU[$param['num']]['cols'] = array(); // definition via les balises col
4169 $this->saveMargin($this->pdf->getlMargin(), $this->pdf->gettMargin(), $this->pdf->getrMargin());
4170
4171 // adaptation de la largeur en fonction des marges du tableau
4172 $this->style->value['width']-= $HTML2PDF_TABLEAU[$param['num']]['marge']['l'] + $HTML2PDF_TABLEAU[$param['num']]['marge']['r'];
4173 }
4174 else
4175 {
4176 // on repart à la premiere page du tableau et à la premiere case
4177 $HTML2PDF_TABLEAU[$param['num']]['page'] = 0;
4178 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = 0;
4179 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = 0;
4180 $HTML2PDF_TABLEAU[$param['num']]['td_x'] = $HTML2PDF_TABLEAU[$param['num']]['marge']['l']+$HTML2PDF_TABLEAU[$param['num']]['curr_x'];
4181 $HTML2PDF_TABLEAU[$param['num']]['td_y'] = $HTML2PDF_TABLEAU[$param['num']]['marge']['t']+$HTML2PDF_TABLEAU[$param['num']]['curr_y'];
4182
4183 // initialisation du style des bordures de la premiere partie de tableau
4184 $this->drawRectangle(
4185 $HTML2PDF_TABLEAU[$param['num']]['curr_x'],
4186 $HTML2PDF_TABLEAU[$param['num']]['curr_y'],
4187 $HTML2PDF_TABLEAU[$param['num']]['width'],
4188 isset($HTML2PDF_TABLEAU[$param['num']]['height'][0]) ? $HTML2PDF_TABLEAU[$param['num']]['height'][0] : null,
4189 $this->style->value['border'],
4190 $this->style->value['padding'],
4191 0,
4192 $this->style->value['background']
4193 );
4194
4195 $HTML2PDF_TABLEAU[$param['num']]['style_value'] = $this->style->value;
4196 }
4197
4198 return true;
4199 }
4200
4201 /**
4202 * balise : TABLE
4203 * mode : FERMETURE
4204 *
4205 * @param array paramètres de l'élément de parsing
4206 * @return null
4207 */
4208 function c_TABLE($param)
4209 {
4210 if ($this->forOneLine) return false;
4211
4212 $this->maxH = 0;
4213 global $HTML2PDF_TABLEAU;
4214
4215 // restauration du style
4216 $this->style->load();
4217 $this->style->FontSet();
4218
4219 // si on est en mode sub_html : initialisation des dimensions et autres
4220 if ($this->sub_part)
4221 {
4222 // ajustement de la taille des cases
4223 $this->calculTailleCases($HTML2PDF_TABLEAU[$param['num']]['cases'], $HTML2PDF_TABLEAU[$param['num']]['corr']);
4224
4225 // calcul de la hauteur du THEAD et du TFOOT
4226 $lst = array('thead', 'tfoot');
4227 foreach($lst as $mode)
4228 {
4229 $HTML2PDF_TABLEAU[$param['num']][$mode]['height'] = 0;
4230 foreach($HTML2PDF_TABLEAU[$param['num']][$mode]['tr'] as $tr)
4231 {
4232 // hauteur de la ligne tr
4233 $h = 0;
4234 for($i=0; $i<count($HTML2PDF_TABLEAU[$param['num']]['cases'][$tr]); $i++)
4235 if ($HTML2PDF_TABLEAU[$param['num']]['cases'][$tr][$i]['rowspan']==1)
4236 $h = max($h, $HTML2PDF_TABLEAU[$param['num']]['cases'][$tr][$i]['h']);
4237 $HTML2PDF_TABLEAU[$param['num']][$mode]['height']+= $h;
4238 }
4239 }
4240
4241 // calcul des dimensions du tableau - Largeur
4242 $HTML2PDF_TABLEAU[$param['num']]['width'] = $HTML2PDF_TABLEAU[$param['num']]['marge']['l'] + $HTML2PDF_TABLEAU[$param['num']]['marge']['r'];
4243 if (isset($HTML2PDF_TABLEAU[$param['num']]['cases'][0]))
4244 foreach($HTML2PDF_TABLEAU[$param['num']]['cases'][0] as $case)
4245 $HTML2PDF_TABLEAU[$param['num']]['width']+= $case['w'];
4246
4247 // positionnement du tableau horizontalement;
4248 $old = $this->style->getOldValues();
4249 $parent_w = $old['width'] ? $old['width'] : $this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin();
4250 $x = $HTML2PDF_TABLEAU[$param['num']]['curr_x'];
4251 $w = $HTML2PDF_TABLEAU[$param['num']]['width'];
4252 if ($parent_w>$w)
4253 {
4254 if ($HTML2PDF_TABLEAU[$param['num']]['align']=='center')
4255 $x = $x + ($parent_w-$w)*0.5;
4256 else if ($HTML2PDF_TABLEAU[$param['num']]['align']=='right')
4257 $x = $x + $parent_w-$w;
4258
4259 $HTML2PDF_TABLEAU[$param['num']]['curr_x'] = $x;
4260 }
4261
4262
4263 // calcul des dimensions du tableau - hauteur du tableau sur chaque page
4264 $HTML2PDF_TABLEAU[$param['num']]['height'] = array();
4265
4266 $h0 = $HTML2PDF_TABLEAU[$param['num']]['marge']['t'] + $HTML2PDF_TABLEAU[$param['num']]['marge']['b']; // minimum de hauteur à cause des marges
4267 $h0+= $HTML2PDF_TABLEAU[$param['num']]['thead']['height'] + $HTML2PDF_TABLEAU[$param['num']]['tfoot']['height']; // et du tfoot et thead
4268 $max = $this->pdf->getH() - $this->pdf->getbMargin(); // max de hauteur par page
4269 $y = $HTML2PDF_TABLEAU[$param['num']]['curr_y']; // position Y actuelle
4270 $height = $h0;
4271
4272 // on va lire les hauteurs de chaque ligne, une à une, et voir si ca rentre sur la page.
4273 for($k=0; $k<count($HTML2PDF_TABLEAU[$param['num']]['cases']); $k++)
4274 {
4275 // si c'est des lignes du thead ou du tfoot : on passe
4276 if (in_array($k, $HTML2PDF_TABLEAU[$param['num']]['thead']['tr'])) continue;
4277 if (in_array($k, $HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr'])) continue;
4278
4279 // hauteur de la ligne $k
4280 $th = 0;
4281 $h = 0;
4282 for($i=0; $i<count($HTML2PDF_TABLEAU[$param['num']]['cases'][$k]); $i++)
4283 {
4284 $h = max($h, $HTML2PDF_TABLEAU[$param['num']]['cases'][$k][$i]['h']);
4285
4286 if ($HTML2PDF_TABLEAU[$param['num']]['cases'][$k][$i]['rowspan']==1)
4287 $th = max($th, $HTML2PDF_TABLEAU[$param['num']]['cases'][$k][$i]['h']);
4288 }
4289
4290 // si la ligne ne rentre pas dans la page
4291 // => la hauteur sur cette page est trouvée, et on passe à la page d'apres
4292 if ($y+$h+$height>$max)
4293 {
4294 if ($height==$h0) $height = null;
4295 $HTML2PDF_TABLEAU[$param['num']]['height'][] = $height;
4296 $height = $h0;
4297 $y = $this->margeTop;
4298 }
4299 $height+= $th;
4300 }
4301 // rajout du reste de tableau (si il existe) à la derniere page
4302 if ($height!=$h0 || $k==0) $HTML2PDF_TABLEAU[$param['num']]['height'][] = $height;
4303 }
4304 else
4305 {
4306 if (count($HTML2PDF_TABLEAU[$param['num']]['tfoot']['code']))
4307 {
4308 $tmp_tr = $HTML2PDF_TABLEAU[$param['num']]['tr_curr'];
4309 $tmp_td = $HTML2PDF_TABLEAU[$param['num']]['td_curr'];
4310 $OLD_parse_pos = $this->parse_pos;
4311 $OLD_parse_code = $this->parsing->code;
4312
4313 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = $HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr'][0];
4314 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = 0;
4315 $this->parse_pos = 0;
4316 $this->parsing->code = $HTML2PDF_TABLEAU[$param['num']]['tfoot']['code'];
4317 $this->makeHTMLcode();
4318
4319 $this->parse_pos = $OLD_parse_pos;
4320 $this->parsing->code = $OLD_parse_code;
4321 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = $tmp_tr;
4322 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = $tmp_td;
4323 }
4324
4325 // determination des coordonnées de sortie du tableau
4326 $x = $HTML2PDF_TABLEAU[$param['num']]['curr_x'] + $HTML2PDF_TABLEAU[$param['num']]['width'];
4327 if (count($HTML2PDF_TABLEAU[$param['num']]['height'])>1)
4328 $y = $this->margeTop+$HTML2PDF_TABLEAU[$param['num']]['height'][count($HTML2PDF_TABLEAU[$param['num']]['height'])-1];
4329 else if (count($HTML2PDF_TABLEAU[$param['num']]['height'])==1)
4330 $y = $HTML2PDF_TABLEAU[$param['num']]['curr_y']+$HTML2PDF_TABLEAU[$param['num']]['height'][count($HTML2PDF_TABLEAU[$param['num']]['height'])-1];
4331 else
4332 $y = $HTML2PDF_TABLEAU[$param['num']]['curr_y'];
4333
4334 // taille du tableau
4335 $this->maxX = max($this->maxX, $x);
4336 $this->maxY = max($this->maxY, $y);
4337
4338
4339 // nouvelle position apres le tableau
4340 $this->pdf->setXY($this->pdf->getlMargin(), $y);
4341
4342 // restauration des marges
4343 $this->loadMargin();
4344
4345 if ($this->DEBUG_actif) $this->DEBUG_add('Table n°'.$param['num'], false);
4346 }
4347
4348 return true;
4349 }
4350
4351
4352 /**
4353 * balise : COL
4354 * mode : OUVERTURE (pas de fermeture)
4355 *
4356 * @param array paramètres de l'élément de parsing
4357 * @return null
4358 */
4359 function o_COL($param)
4360 {
4361 global $HTML2PDF_TABLEAU;
4362 $span = isset($param['span']) ? $param['span'] : 1;
4363 for($k=0; $k<$span; $k++)
4364 $HTML2PDF_TABLEAU[$param['num']]['cols'][] = $param;
4365 }
4366
4367 /**
4368 * balise : TR
4369 * mode : OUVERTURE
4370 *
4371 * @param array paramètres de l'élément de parsing
4372 * @return null
4373 */
4374 function o_TR($param, $other = 'tr')
4375 {
4376 if ($this->forOneLine) return false;
4377
4378 $this->maxH = 0;
4379 global $HTML2PDF_TABLEAU;
4380
4381 // analyse du style
4382 $this->style->save();
4383 $this->style->analyse($other, $param);
4384 $this->style->setPosition();
4385 $this->style->FontSet();
4386
4387 // positionnement dans le tableau
4388 $HTML2PDF_TABLEAU[$param['num']]['tr_curr']++;
4389 $HTML2PDF_TABLEAU[$param['num']]['td_curr']= 0;
4390
4391 // si on est pas dans un sub_html
4392 if (!$this->sub_part)
4393 {
4394 // Y courant apres la ligne
4395 $ty=null;
4396 for($ii=0; $ii<count($HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1]); $ii++)
4397 $ty = max($ty, $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$ii]['h']);
4398
4399 $hfoot = $HTML2PDF_TABLEAU[$param['num']]['tfoot']['height'];
4400
4401 // si la ligne ne rentre pas dans la page => nouvelle page
4402 if (!$this->isInTfoot && $HTML2PDF_TABLEAU[$param['num']]['td_y'] + $HTML2PDF_TABLEAU[$param['num']]['marge']['b'] + $ty +$hfoot> $this->pdf->getH() - $this->pdf->getbMargin())
4403 {
4404 if (count($HTML2PDF_TABLEAU[$param['num']]['tfoot']['code']))
4405 {
4406 $tmp_tr = $HTML2PDF_TABLEAU[$param['num']]['tr_curr'];
4407 $tmp_td = $HTML2PDF_TABLEAU[$param['num']]['td_curr'];
4408 $OLD_parse_pos = $this->parse_pos;
4409 $OLD_parse_code = $this->parsing->code;
4410
4411 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = $HTML2PDF_TABLEAU[$param['num']]['tfoot']['tr'][0];
4412 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = 0;
4413 $this->parse_pos = 0;
4414 $this->parsing->code = $HTML2PDF_TABLEAU[$param['num']]['tfoot']['code'];
4415 $this->isInTfoot = true;
4416 $this->makeHTMLcode();
4417 $this->isInTfoot = false;
4418
4419 $this->parse_pos = $OLD_parse_pos;
4420 $this->parsing->code = $OLD_parse_code;
4421 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = $tmp_tr;
4422 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = $tmp_td;
4423 }
4424
4425 $HTML2PDF_TABLEAU[$param['num']]['new_page'] = true;
4426 $this->setNewPage();
4427
4428 $HTML2PDF_TABLEAU[$param['num']]['page']++;
4429 $HTML2PDF_TABLEAU[$param['num']]['curr_y'] = $this->pdf->getY();
4430 $HTML2PDF_TABLEAU[$param['num']]['td_y'] = $HTML2PDF_TABLEAU[$param['num']]['curr_y']+$HTML2PDF_TABLEAU[$param['num']]['marge']['t'];
4431
4432 // si la hauteur de cette partie a bien été calculée, on trace le cadre
4433 if (isset($HTML2PDF_TABLEAU[$param['num']]['height'][$HTML2PDF_TABLEAU[$param['num']]['page']]))
4434 {
4435 $old = $this->style->value;
4436 $this->style->value = $HTML2PDF_TABLEAU[$param['num']]['style_value'];
4437
4438 // initialisation du style des bordures de la premiere partie de tableau
4439 $this->drawRectangle(
4440 $HTML2PDF_TABLEAU[$param['num']]['curr_x'],
4441 $HTML2PDF_TABLEAU[$param['num']]['curr_y'],
4442 $HTML2PDF_TABLEAU[$param['num']]['width'],
4443 $HTML2PDF_TABLEAU[$param['num']]['height'][$HTML2PDF_TABLEAU[$param['num']]['page']],
4444 $this->style->value['border'],
4445 $this->style->value['padding'],
4446 $HTML2PDF_TABLEAU[$param['num']]['cellspacing']*0.5,
4447 $this->style->value['background']
4448 );
4449
4450 $this->style->value = $old;
4451 }
4452 }
4453
4454 if ($HTML2PDF_TABLEAU[$param['num']]['new_page'] && count($HTML2PDF_TABLEAU[$param['num']]['thead']['code']))
4455 {
4456 $HTML2PDF_TABLEAU[$param['num']]['new_page'] = false;
4457 $tmp_tr = $HTML2PDF_TABLEAU[$param['num']]['tr_curr'];
4458 $tmp_td = $HTML2PDF_TABLEAU[$param['num']]['td_curr'];
4459 $OLD_parse_pos = $this->parse_pos;
4460 $OLD_parse_code = $this->parsing->code;
4461
4462 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = $HTML2PDF_TABLEAU[$param['num']]['thead']['tr'][0];
4463 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = 0;
4464 $this->parse_pos = 0;
4465 $this->parsing->code = $HTML2PDF_TABLEAU[$param['num']]['thead']['code'];
4466 $this->isInThead = true;
4467 $this->makeHTMLcode();
4468 $this->isInThead = false;
4469
4470 $this->parse_pos = $OLD_parse_pos;
4471 $this->parsing->code = $OLD_parse_code;
4472 $HTML2PDF_TABLEAU[$param['num']]['tr_curr'] = $tmp_tr;
4473 $HTML2PDF_TABLEAU[$param['num']]['td_curr'] = $tmp_td;
4474 $HTML2PDF_TABLEAU[$param['num']]['new_page'] = true;
4475 }
4476 }
4477 else
4478 {
4479 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1] = array();
4480 if (!isset($HTML2PDF_TABLEAU[$param['num']]['corr'][$HTML2PDF_TABLEAU[$param['num']]['corr_y']]))
4481 $HTML2PDF_TABLEAU[$param['num']]['corr'][$HTML2PDF_TABLEAU[$param['num']]['corr_y']] = array();
4482
4483 $HTML2PDF_TABLEAU[$param['num']]['corr_x']=0;
4484 while(isset($HTML2PDF_TABLEAU[$param['num']]['corr'][$HTML2PDF_TABLEAU[$param['num']]['corr_y']][$HTML2PDF_TABLEAU[$param['num']]['corr_x']]))
4485 $HTML2PDF_TABLEAU[$param['num']]['corr_x']++;
4486 }
4487
4488 return true;
4489 }
4490
4491 /**
4492 * balise : TR
4493 * mode : FERMETURE
4494 *
4495 * @param array paramètres de l'élément de parsing
4496 * @return null
4497 */
4498 function c_TR($param)
4499 {
4500 if ($this->forOneLine) return false;
4501
4502 $this->maxH = 0;
4503 global $HTML2PDF_TABLEAU;
4504
4505 // restauration du style
4506 $this->style->load();
4507 $this->style->FontSet();
4508
4509 // si on est pas dans un sub_html
4510 if (!$this->sub_part)
4511 {
4512 // Y courant apres la ligne
4513 $ty=null;
4514 for($ii=0; $ii<count($HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1]); $ii++)
4515 if ($HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$ii]['rowspan']==1)
4516 $ty = $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$ii]['h'];
4517
4518 // mise à jour des coordonnées courantes
4519 $HTML2PDF_TABLEAU[$param['num']]['td_x'] = $HTML2PDF_TABLEAU[$param['num']]['curr_x']+$HTML2PDF_TABLEAU[$param['num']]['marge']['l'];
4520 $HTML2PDF_TABLEAU[$param['num']]['td_y']+= $ty;
4521 $HTML2PDF_TABLEAU[$param['num']]['new_page'] = false;
4522 }
4523 else
4524 {
4525 $HTML2PDF_TABLEAU[$param['num']]['corr_y']++;
4526 }
4527
4528 return true;
4529 }
4530
4531 /**
4532 * balise : TD
4533 * mode : OUVERTURE
4534 *
4535 * @param array paramètres de l'élément de parsing
4536 * @return null
4537 */
4538 function o_TD($param, $other = 'td')
4539 {
4540 if ($this->forOneLine) return false;
4541
4542 $this->maxH = 0;
4543 global $HTML2PDF_TABLEAU;
4544
4545 $param['cellpadding'] = $HTML2PDF_TABLEAU[$param['num']]['cellpadding'].'mm';
4546 $param['cellspacing'] = $HTML2PDF_TABLEAU[$param['num']]['cellspacing'].'mm';
4547
4548 if ($other=='li')
4549 {
4550 $special_li = true;
4551 }
4552 else
4553 {
4554 $special_li = false;
4555 if ($other=='li_sub')
4556 {
4557 $param['style']['border'] = 'none';
4558 $param['style']['background-color'] = 'transparent';
4559 $param['style']['background-image'] = 'none';
4560 $param['style']['background-position'] = '';
4561 $param['style']['background-repeat'] = '';
4562 $other = 'li';
4563 }
4564 }
4565
4566 // est-on en collapse, et egalement y-a-t'il des definitions de colonne
4567 $x = $HTML2PDF_TABLEAU[$param['num']]['td_curr'];
4568 $y = $HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1;
4569 $colspan = isset($param['colspan']) ? $param['colspan'] : 1;
4570 $rowspan = isset($param['rowspan']) ? $param['rowspan'] : 1;
4571 $collapse = false;
4572 if (in_array($other, array('td', 'th')))
4573 {
4574 $num_col = isset($HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x]['Xr']) ? $HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x]['Xr'] : $HTML2PDF_TABLEAU[$param['num']]['corr_x'];
4575
4576 // si une definition de colonne est presente
4577 if (isset($HTML2PDF_TABLEAU[$param['num']]['cols'][$num_col]))
4578 {
4579 // on la recupere
4580 $col_param = $HTML2PDF_TABLEAU[$param['num']]['cols'][$num_col];
4581
4582 // pour les colspan, on recupere toutes les largeurs
4583 $col_param['style']['width'] = array();
4584 for($k=0; $k<$colspan; $k++)
4585 {
4586 if (isset($HTML2PDF_TABLEAU[$param['num']]['cols'][$num_col+$k]['style']['width']))
4587 $col_param['style']['width'][] = $HTML2PDF_TABLEAU[$param['num']]['cols'][$num_col+$k]['style']['width'];
4588 }
4589
4590 // on les somme
4591 $total = '';
4592 $last = $this->style->getLastWidth();
4593 if (count($col_param['style']['width']))
4594 {
4595 $total = $col_param['style']['width'][0]; unset($col_param['style']['width'][0]);
4596 foreach($col_param['style']['width'] as $width)
4597 {
4598 if (substr($total, -1)=='%' && substr($width, -1)=='%')
4599 $total = (str_replace('%', '', $total)+str_replace('%', '', $width)).'%';
4600 else
4601 $total = ($this->style->ConvertToMM($total, $last) + $this->style->ConvertToMM($width, $last)).'mm';
4602 }
4603 }
4604
4605 // et on recupere la largeur finale
4606 if ($total)
4607 $col_param['style']['width'] = $total;
4608 else
4609 unset($col_param['style']['width']);
4610
4611
4612 // on merge les 2 styles (col + td)
4613 $param['style'] = array_merge($col_param['style'], $param['style']);
4614
4615 // si une classe est définie, on la merge egalement
4616 if (isset($col_param['class']))
4617 $param['class'] = $col_param['class'].(isset($param['class']) ? ' '.$param['class'] : '');
4618 }
4619
4620 $collapse = isset($this->style->value['border']['collapse']) ? $this->style->value['border']['collapse'] : false;
4621 }
4622
4623
4624 // analyse du style
4625 $this->style->save();
4626 $heritage = null;
4627 if (in_array($other, array('td', 'th')))
4628 {
4629 $heritage = array();
4630
4631 $old = $this->style->getLastValue('background');
4632 if ($old && ($old['color'] || $old['image']))
4633 $heritage['background'] = $old;
4634
4635 if ($HTML2PDF_TABLEAU[$param['num']]['border'])
4636 {
4637 $heritage['border'] = array();
4638 $heritage['border']['l'] = $HTML2PDF_TABLEAU[$param['num']]['border'];
4639 $heritage['border']['t'] = $HTML2PDF_TABLEAU[$param['num']]['border'];
4640 $heritage['border']['r'] = $HTML2PDF_TABLEAU[$param['num']]['border'];
4641 $heritage['border']['b'] = $HTML2PDF_TABLEAU[$param['num']]['border'];
4642 }
4643 }
4644 $return = $this->style->analyse($other, $param, $heritage);
4645
4646 if ($special_li)
4647 {
4648 $this->style->value['width']-= $this->style->ConvertToMM($this->listeGetWidth());
4649 $this->style->value['width']-= $this->style->ConvertToMM($this->listeGetPadding());
4650 }
4651 $this->style->setPosition();
4652 $this->style->FontSet();
4653
4654 // si on est en collapse : modification du style
4655 if ($collapse)
4656 {
4657 if (!$this->sub_part)
4658 {
4659 if (
4660 ($HTML2PDF_TABLEAU[$param['num']]['tr_curr']>1 && !$HTML2PDF_TABLEAU[$param['num']]['new_page']) ||
4661 (!$this->isInThead && count($HTML2PDF_TABLEAU[$param['num']]['thead']['code']))
4662 )
4663 {
4664 $this->style->value['border']['t'] = $this->style->readBorder('none');
4665 }
4666 }
4667
4668 if ($HTML2PDF_TABLEAU[$param['num']]['td_curr']>0)
4669 {
4670 if (!$return) $this->style->value['width']+= $this->style->value['border']['l']['width'];
4671 $this->style->value['border']['l'] = $this->style->readBorder('none');
4672 }
4673 }
4674
4675 $marge = array();
4676 $marge['t'] = $this->style->value['padding']['t']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['t']['width'];
4677 $marge['r'] = $this->style->value['padding']['r']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['r']['width'];
4678 $marge['b'] = $this->style->value['padding']['b']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['b']['width'];
4679 $marge['l'] = $this->style->value['padding']['l']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['l']['width'];
4680
4681 // si on est dans un sub_html
4682 if ($this->sub_part)
4683 {
4684 // on se positionne dans le tableau
4685 $HTML2PDF_TABLEAU[$param['num']]['td_curr']++;
4686 $HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x] = array();
4687 $HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x]['w'] = 0;
4688 $HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x]['h'] = 0;
4689 $HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x]['dw'] = 0;
4690 $HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x]['colspan'] = $colspan;
4691 $HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x]['rowspan'] = $rowspan;
4692 $HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x]['Xr'] = $HTML2PDF_TABLEAU[$param['num']]['corr_x'];
4693 $HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x]['Yr'] = $HTML2PDF_TABLEAU[$param['num']]['corr_y'];
4694
4695 for($j=0; $j<$rowspan; $j++)
4696 {
4697 for($i=0; $i<$colspan; $i++)
4698 {
4699 $HTML2PDF_TABLEAU[$param['num']]['corr']
4700 [$HTML2PDF_TABLEAU[$param['num']]['corr_y']+$j]
4701 [$HTML2PDF_TABLEAU[$param['num']]['corr_x']+$i] = ($i+$j>0) ? '' : array($x,$y,$colspan,$rowspan);
4702 }
4703 }
4704 $HTML2PDF_TABLEAU[$param['num']]['corr_x']+= $colspan;
4705 while(isset($HTML2PDF_TABLEAU[$param['num']]['corr'][$HTML2PDF_TABLEAU[$param['num']]['corr_y']][$HTML2PDF_TABLEAU[$param['num']]['corr_x']]))
4706 $HTML2PDF_TABLEAU[$param['num']]['corr_x']++;
4707
4708 // on extrait tout ce qui est contenu dans le TD
4709 // on en créé un sous HTML que l'on transforme en PDF
4710 // pour analyse les dimensions
4711 // et les récupérer dans le tableau global.
4712 $level = $this->parsing->getLevel($this->temp_pos);
4713 $this->CreateSubHTML($this->sub_html);
4714 $this->sub_html->parsing->code = $level;
4715 $this->sub_html->MakeHTMLcode();
4716 $this->temp_pos+= count($level);
4717 }
4718 else
4719 {
4720 // on se positionne dans le tableau
4721 $HTML2PDF_TABLEAU[$param['num']]['td_curr']++;
4722 $HTML2PDF_TABLEAU[$param['num']]['td_x']+= $HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x]['dw'];
4723
4724 // initialisation du style des bordures de la premiere partie de tableau
4725 $this->drawRectangle(
4726 $HTML2PDF_TABLEAU[$param['num']]['td_x'],
4727 $HTML2PDF_TABLEAU[$param['num']]['td_y'],
4728 $HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x]['w'],
4729 $HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x]['h'],
4730 $this->style->value['border'],
4731 $this->style->value['padding'],
4732 $HTML2PDF_TABLEAU[$param['num']]['cellspacing']*0.5,
4733 $this->style->value['background']
4734 );
4735
4736
4737 $this->style->value['width'] = $HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x]['w'] - $marge['l'] - $marge['r'];
4738
4739 // limitation des marges aux dimensions de la case
4740 $mL = $HTML2PDF_TABLEAU[$param['num']]['td_x']+$marge['l'];
4741 $mR = $this->pdf->getW() - $mL - $this->style->value['width'];
4742 $this->saveMargin($mL, 0, $mR);
4743
4744 // positionnement en fonction
4745 $h_corr = $HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x]['h'];
4746 $h_reel = $HTML2PDF_TABLEAU[$param['num']]['cases'][$y][$x]['real_h'];
4747 switch($this->style->value['vertical-align'])
4748 {
4749 case 'bottom':
4750 $y_corr = $h_corr-$h_reel;
4751 break;
4752
4753 case 'middle':
4754 $y_corr = ($h_corr-$h_reel)*0.5;
4755 break;
4756
4757 case 'top':
4758 default:
4759 $y_corr = 0;
4760 break;
4761 }
4762
4763 $x = $HTML2PDF_TABLEAU[$param['num']]['td_x']+$marge['l'];
4764 $y = $HTML2PDF_TABLEAU[$param['num']]['td_y']+$marge['t']+$y_corr;
4765 $this->pdf->setXY($x, $y);
4766 $this->setNewPositionForNewLine();
4767 }
4768
4769 return true;
4770 }
4771
4772 /**
4773 * balise : TD
4774 * mode : FERMETURE
4775 *
4776 * @param array paramètres de l'élément de parsing
4777 * @return null
4778 */
4779 function c_TD($param)
4780 {
4781 if ($this->forOneLine) return false;
4782
4783 $this->maxH = 0;
4784 global $HTML2PDF_TABLEAU;
4785
4786 // récupération de la marge
4787 $marge = array();
4788 $marge['t'] = $this->style->value['padding']['t']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['t']['width'];
4789 $marge['r'] = $this->style->value['padding']['r']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['r']['width'];
4790 $marge['b'] = $this->style->value['padding']['b']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['b']['width'];
4791 $marge['l'] = $this->style->value['padding']['l']+0.5*$HTML2PDF_TABLEAU[$param['num']]['cellspacing']+$this->style->value['border']['l']['width'];
4792 $marge['t']+= 0.001;
4793 $marge['r']+= 0.001;
4794 $marge['b']+= 0.001;
4795 $marge['l']+= 0.001;
4796
4797 // si on est dans un sub_html
4798 if ($this->sub_part)
4799 {
4800 if ($this->testTDin1page && $this->sub_html->pdf->getPage()>1) HTML2PDF::makeError(7, __FILE__, __LINE__);
4801
4802 // dimentions de cette case
4803 $w0 = $this->sub_html->maxX + $marge['l'] + $marge['r'];
4804 $h0 = $this->sub_html->maxY + $marge['t'] + $marge['b'];
4805
4806 // dimensions imposées par le style
4807 $w2 = $this->style->value['width'] + $marge['l'] + $marge['r'];
4808 $h2 = $this->style->value['height'] + $marge['t'] + $marge['b'];
4809
4810 // dimension finale de la case = max des 2 ci-dessus
4811 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['w'] = max(array($w0, $w2));
4812 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['h'] = max(array($h0, $h2));
4813
4814 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['real_w'] = $w0;
4815 $HTML2PDF_TABLEAU[$param['num']]['cases'][$HTML2PDF_TABLEAU[$param['num']]['tr_curr']-1][$HTML2PDF_TABLEAU[$param['num']]['td_curr']-1]['real_h'] = $h0;
4816
4817 // suppresion du sous_html
4818 $this->destroySubHTML($this->sub_html);
4819 }
4820 else
4821 {
4822 $this->loadMargin();
4823 //positionnement
4824 $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'];
4825 }
4826
4827 // restauration du style
4828 $this->style->load();
4829 $this->style->FontSet();
4830
4831 return true;
4832 }
4833
4834 function calculTailleCases(&$cases, &$corr)
4835 {
4836 /* // construction d'un tableau de correlation
4837 $corr = array();
4838
4839 // on fait correspondre chaque case d'un tableau normé aux cases réelles, en prennant en compte les colspan et rowspan
4840 $Yr=0;
4841 for($y=0; $y<count($cases); $y++)
4842 {
4843 $Xr=0; while(isset($corr[$Yr][$Xr])) $Xr++;
4844
4845 for($x=0; $x<count($cases[$y]); $x++)
4846 {
4847 for($j=0; $j<$cases[$y][$x]['rowspan']; $j++)
4848 {
4849 for($i=0; $i<$cases[$y][$x]['colspan']; $i++)
4850 {
4851 $corr[$Yr+$j][$Xr+$i] = ($i+$j>0) ? '' : array($x, $y, $cases[$y][$x]['colspan'], $cases[$y][$x]['rowspan']);
4852 }
4853 }
4854 $Xr+= $cases[$y][$x]['colspan'];
4855 while(isset($corr[$Yr][$Xr])) $Xr++;
4856 }
4857 $Yr++;
4858 }
4859 */
4860 if (!isset($corr[0])) return true;
4861
4862 // on détermine, pour les cases sans colspan, la largeur maximale de chaque colone
4863 $sw = array();
4864 for($x=0; $x<count($corr[0]); $x++)
4865 {
4866 $m=0;
4867 for($y=0; $y<count($corr); $y++)
4868 if (isset($corr[$y][$x]) && is_array($corr[$y][$x]) && $corr[$y][$x][2]==1)
4869 $m = max($m, $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w']);
4870 $sw[$x] = $m;
4871 }
4872
4873 // on vérifie que cette taille est valide avec les colones en colspan
4874 for($x=0; $x<count($corr[0]); $x++)
4875 {
4876 for($y=0; $y<count($corr); $y++)
4877 {
4878 if (isset($corr[$y][$x]) && is_array($corr[$y][$x]) && $corr[$y][$x][2]>1)
4879 {
4880 // somme des colonnes correspondant au colspan
4881 $s = 0; for($i=0; $i<$corr[$y][$x][2]; $i++) $s+= $sw[$x+$i];
4882
4883 // si la somme est inférieure à la taille necessaire => règle de 3 pour adapter
4884 if ($s>0 && $s<$cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w'])
4885 for($i=0; $i<$corr[$y][$x][2]; $i++)
4886 $sw[$x+$i] = $sw[$x+$i]/$s*$cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w'];
4887 }
4888 }
4889 }
4890
4891 // on applique les nouvelles largeurs
4892 for($x=0; $x<count($corr[0]); $x++)
4893 {
4894 for($y=0; $y<count($corr); $y++)
4895 {
4896 if (isset($corr[$y][$x]) && is_array($corr[$y][$x]))
4897 {
4898 if ($corr[$y][$x][2]==1)
4899 {
4900 $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w'] = $sw[$x];
4901 }
4902 else
4903 {
4904 // somme des colonnes correspondant au colspan
4905 $s = 0; for($i=0; $i<$corr[$y][$x][2]; $i++) $s+= $sw[$x+$i];
4906 $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w'] = $s;
4907 }
4908 }
4909 }
4910 }
4911
4912 // on détermine, pour les cases sans rowspan, la hauteur maximale de chaque colone
4913 $sh = array();
4914 for($y=0; $y<count($corr); $y++)
4915 {
4916 $m=0;
4917 for($x=0; $x<count($corr[0]); $x++)
4918 if (isset($corr[$y][$x]) && is_array($corr[$y][$x]) && $corr[$y][$x][3]==1)
4919 $m = max($m, $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['h']);
4920 $sh[$y] = $m;
4921 }
4922
4923
4924 // on vérifie que cette taille est valide avec les lignes en rowspan
4925 for($y=0; $y<count($corr); $y++)
4926 {
4927 for($x=0; $x<count($corr[0]); $x++)
4928 {
4929 if (isset($corr[$y][$x]) && is_array($corr[$y][$x]) && $corr[$y][$x][3]>1)
4930 {
4931 // somme des colonnes correspondant au colspan
4932 $s = 0; for($i=0; $i<$corr[$y][$x][3]; $i++) $s+= $sh[$y+$i];
4933
4934 // si la somme est inférieure à la taille necessaire => règle de 3 pour adapter
4935 if ($s>0 && $s<$cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['h'])
4936 for($i=0; $i<$corr[$y][$x][3]; $i++)
4937 $sh[$y+$i] = $sh[$y+$i]/$s*$cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['h'];
4938 }
4939 }
4940 }
4941
4942
4943 // on applique les nouvelles hauteurs
4944 for($y=0; $y<count($corr); $y++)
4945 {
4946 for($x=0; $x<count($corr[0]); $x++)
4947 {
4948 if (isset($corr[$y][$x]) && is_array($corr[$y][$x]))
4949 {
4950 if ($corr[$y][$x][3]==1)
4951 {
4952 $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['h'] = $sh[$y];
4953 }
4954 else
4955 {
4956 // somme des lignes correspondant au rowspan
4957 $s = 0; for($i=0; $i<$corr[$y][$x][3]; $i++) $s+= $sh[$y+$i];
4958 $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['h'] = $s;
4959
4960 for($j=1; $j<$corr[$y][$x][3]; $j++)
4961 {
4962 $tx = $x+1;
4963 $ty = $y+$j;
4964 for(true; isset($corr[$ty][$tx]) && !is_array($corr[$ty][$tx]); $tx++);
4965 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'];
4966
4967 }
4968 }
4969 }
4970 }
4971 }
4972 }
4973
4974 /**
4975 * balise : TH
4976 * mode : OUVERTURE
4977 *
4978 * @param array paramètres de l'élément de parsing
4979 * @return null
4980 */
4981 function o_TH($param)
4982 {
4983 if ($this->forOneLine) return false;
4984
4985 $this->maxH = 0;
4986 // identique à TD mais en gras
4987 if (!isset($param['style']['font-weight'])) $param['style']['font-weight'] = 'bold';
4988 $this->o_TD($param, 'th');
4989
4990 return true;
4991 }
4992
4993 /**
4994 * balise : TH
4995 * mode : FERMETURE
4996 *
4997 * @param array paramètres de l'élément de parsing
4998 * @return null
4999 */
5000 function c_TH($param)
5001 {
5002 if ($this->forOneLine) return false;
5003
5004 $this->maxH = 0;
5005 // identique à TD
5006 $this->c_TD($param);
5007
5008 return true;
5009 }
5010
5011 /**
5012 * balise : IMG
5013 * mode : OUVERTURE
5014 *
5015 * @param array paramètres de l'élément de parsing
5016 * @return null
5017 */
5018 function o_IMG($param)
5019 {
5020 // analyse du style
5021 $src = str_replace('&amp;', '&', $param['src']);
5022
5023 $this->style->save();
5024 $this->style->value['width'] = 0;
5025 $this->style->value['height'] = 0;
5026 $this->style->value['border'] = array(
5027 'type' => 'none',
5028 'width' => 0,
5029 'color' => array(0, 0, 0),
5030 );
5031 $this->style->value['background'] = array(
5032 'color' => null,
5033 'image' => null,
5034 'position' => null,
5035 'repeat' => null
5036 );
5037 $this->style->analyse('img', $param);
5038 $this->style->setPosition();
5039 $this->style->FontSet();
5040
5041 // affichage de l'image
5042 $res = $this->Image($src, isset($param['sub_li']));
5043 if (!$res) return $res;
5044
5045 // restauration du style
5046 $this->style->load();
5047 $this->style->FontSet();
5048 $this->maxE++;
5049
5050 return true;
5051 }
5052
5053 /**
5054 * balise : SELECT
5055 * mode : OUVERTURE
5056 *
5057 * @param array paramètres de l'élément de parsing
5058 * @return null
5059 */
5060 function o_SELECT($param)
5061 {
5062 // preparation du champs
5063 if (!isset($param['name'])) $param['name'] = 'champs_pdf_'.(count($this->lstChamps)+1);
5064
5065 $param['name'] = strtolower($param['name']);
5066
5067 if (isset($this->lstChamps[$param['name']]))
5068 $this->lstChamps[$param['name']]++;
5069 else
5070 $this->lstChamps[$param['name']] = 1;
5071
5072 $this->style->save();
5073 $this->style->analyse('select', $param);
5074 $this->style->setPosition();
5075 $this->style->FontSet();
5076
5077 $this->lstSelect = array();
5078 $this->lstSelect['name'] = $param['name'];
5079 $this->lstSelect['multi'] = isset($param['multiple']) ? true : false;
5080 $this->lstSelect['size'] = isset($param['size']) ? $param['size'] : 1;
5081 $this->lstSelect['options'] = array();
5082
5083 if ($this->lstSelect['multi'] && $this->lstSelect['size']<3) $this->lstSelect['size'] = 3;
5084
5085 return true;
5086 }
5087
5088 /**
5089 * balise : OPTION
5090 * mode : OUVERTURE
5091 *
5092 * @param array paramètres de l'élément de parsing
5093 * @return null
5094 */
5095 function o_OPTION($param)
5096 {
5097 // on extrait tout ce qui est contenu dans l'option
5098 $level = $this->parsing->getLevel($this->parse_pos);
5099 $this->parse_pos+= count($level);
5100 $value = isset($param['value']) ? $param['value'] : 'auto_opt_'.(count($this->lstSelect)+1);
5101
5102 $this->lstSelect['options'][$value] = isset($level[0]['param']['txt']) ? $level[0]['param']['txt'] : '';
5103
5104 return true;
5105 }
5106
5107 /**
5108 * balise : OPTION
5109 * mode : FERMETURE
5110 *
5111 * @param array paramètres de l'élément de parsing
5112 * @return null
5113 */
5114 function c_OPTION($param) { return true; }
5115
5116 /**
5117 * balise : SELECT
5118 * mode : FERMETURE
5119 *
5120 * @param array paramètres de l'élément de parsing
5121 * @return null
5122 */
5123 function c_SELECT()
5124 {
5125 // position d'affichage
5126 $x = $this->pdf->getX();
5127 $y = $this->pdf->getY();
5128 $f = 1.08*$this->style->value['font-size'];
5129
5130 $w = $this->style->value['width']; if (!$w) $w = 50;
5131 $h = ($f*1.07*$this->lstSelect['size'] + 1);
5132 $prop = array();
5133 if ($this->lstSelect['multi']) $prop['multipleSelection'] = true;
5134 $this->pdf->form_Select($this->lstSelect['name'], $x, $y, $w, $h, $this->lstSelect['options'], $this->lstSelect['size']>1, $prop);
5135
5136 $this->maxX = max($this->maxX, $x+$w);
5137 $this->maxY = max($this->maxY, $y+$h);
5138 $this->maxH = max($this->maxH, $h);
5139 $this->pdf->setX($x+$w);
5140
5141 $this->style->load();
5142 $this->style->FontSet();
5143
5144 $this->lstSelect = array();
5145
5146 return true;
5147 }
5148
5149 /**
5150 * balise : TEXTAREA
5151 * mode : OUVERTURE
5152 *
5153 * @param array paramètres de l'élément de parsing
5154 * @return null
5155 */
5156 function o_TEXTAREA($param)
5157 {
5158 // preparation du champs
5159 if (!isset($param['name'])) $param['name'] = 'champs_pdf_'.(count($this->lstChamps)+1);
5160
5161 $param['name'] = strtolower($param['name']);
5162
5163 if (isset($this->lstChamps[$param['name']]))
5164 $this->lstChamps[$param['name']]++;
5165 else
5166 $this->lstChamps[$param['name']] = 1;
5167
5168 $this->style->save();
5169 $this->style->analyse('textarea', $param);
5170 $this->style->setPosition();
5171 $this->style->FontSet();
5172
5173 // position d'affichage
5174 $x = $this->pdf->getX();
5175 $y = $this->pdf->getY();
5176 $fx = 0.65*$this->style->value['font-size'];
5177 $fy = 1.08*$this->style->value['font-size'];
5178
5179 // on extrait tout ce qui est contenu dans le textarea
5180 $level = $this->parsing->getLevel($this->parse_pos);
5181 $this->parse_pos+= count($level);
5182
5183 $w = $fx*(isset($param['cols']) ? $param['cols'] : 22)+1;
5184 $h = $fy*1.07*(isset($param['rows']) ? $param['rows'] : 3)+3;
5185
5186 // if ($this->style->value['width']) $w = $this->style->value['width'];
5187 // if ($this->style->value['height']) $h = $this->style->value['height'];
5188
5189 $prop = array();
5190 $prop['multiline'] = true;
5191 $prop['value'] = isset($level[0]['param']['txt']) ? $level[0]['param']['txt'] : '';
5192
5193 $this->pdf->form_InputText($param['name'], $x, $y, $w, $h, $prop);
5194
5195 $this->maxX = max($this->maxX, $x+$w);
5196 $this->maxY = max($this->maxY, $y+$h);
5197 $this->maxH = max($this->maxH, $h);
5198 $this->pdf->setX($x+$w);
5199
5200 return true;
5201 }
5202
5203 /**
5204 * balise : TEXTAREA
5205 * mode : FERMETURE
5206 *
5207 * @param array paramètres de l'élément de parsing
5208 * @return null
5209 */
5210 function c_TEXTAREA()
5211 {
5212 $this->style->load();
5213 $this->style->FontSet();
5214
5215 return true;
5216 }
5217
5218 /**
5219 * balise : INPUT
5220 * mode : OUVERTURE
5221 *
5222 * @param array paramètres de l'élément de parsing
5223 * @return null
5224 */
5225 function o_INPUT($param)
5226 {
5227 // preparation du champs
5228 if (!isset($param['name'])) $param['name'] = 'champs_pdf_'.(count($this->lstChamps)+1);
5229 if (!isset($param['value'])) $param['value'] = '';
5230 if (!isset($param['type'])) $param['type'] = 'text';
5231
5232 $param['name'] = strtolower($param['name']);
5233 $param['type'] = strtolower($param['type']);
5234
5235 if (!in_array($param['type'], array('text', 'checkbox', 'radio', 'hidden', 'submit', 'reset', 'button'))) $param['type'] = 'text';
5236
5237 if (isset($this->lstChamps[$param['name']]))
5238 $this->lstChamps[$param['name']]++;
5239 else
5240 $this->lstChamps[$param['name']] = 1;
5241
5242 $this->style->save();
5243 $this->style->analyse('input', $param);
5244 $this->style->setPosition();
5245 $this->style->FontSet();
5246
5247 $name = $param['name'];
5248
5249 // position d'affichage
5250 $x = $this->pdf->getX();
5251 $y = $this->pdf->getY();
5252 $f = 1.08*$this->style->value['font-size'];
5253
5254 switch($param['type'])
5255 {
5256 case 'checkbox':
5257 $w = 3;
5258 $h = $w;
5259 if ($h<$f) $y+= ($f-$h)*0.5;
5260 $this->pdf->form_InputCheckBox($name, $x, $y, $w, isset($param['checked']));
5261 break;
5262
5263 case 'radio':
5264 $w = 3;
5265 $h = $w;
5266 if ($h<$f) $y+= ($f-$h)*0.5;
5267 $this->pdf->form_InputRadio($name, $x, $y, $w);
5268 break;
5269
5270 case 'hidden':
5271 $w = 0;
5272 $h = 0;
5273 $this->pdf->form_InputHidden($name, $param['value']);
5274 break;
5275
5276 case 'text':
5277 $w = $this->style->value['width']; if (!$w) $w = 40;
5278 $h = $f*1.3;
5279 $prop = array();
5280 $prop['value'] = $param['value'];
5281 $this->pdf->form_InputText($name, $x, $y, $w, $h, $prop);
5282 break;
5283
5284 case 'submit':
5285 $w = $this->style->value['width']; if (!$w) $w = 40;
5286 $h = $this->style->value['height']; if (!$h) $h = $f*1.3;
5287 $action = 'this.submitForm("'.$this->isInForm.'", false);';
5288 $this->pdf->form_InputButton($name, $x, $y, $w, $h, $param['value'], $action, array());
5289 break;
5290
5291 case 'reset':
5292 $w = $this->style->value['width']; if (!$w) $w = 40;
5293 $h = $this->style->value['height']; if (!$h) $h = $f*1.3;
5294 $action = 'this.resetForm();';
5295 $this->pdf->form_InputButton($name, $x, $y, $w, $h, $param['value'], $action, array());
5296 break;
5297
5298 case 'button':
5299 $w = $this->style->value['width']; if (!$w) $w = 40;
5300 $h = $this->style->value['height']; if (!$h) $h = $f*1.3;
5301 $action = isset($param['onclick']) ? $param['onclick'] : '';
5302 $this->pdf->form_InputButton($name, $x, $y, $w, $h, $param['value'], $action, array());
5303 break;
5304
5305 default:
5306 $w = 0;
5307 $h = 0;
5308 break;
5309 }
5310
5311 $this->maxX = max($this->maxX, $x+$w);
5312 $this->maxY = max($this->maxY, $y+$h);
5313 $this->maxH = max($this->maxH, $h);
5314 $this->pdf->setX($x+$w);
5315
5316 $this->style->load();
5317 $this->style->FontSet();
5318
5319 return true;
5320 }
5321
5322 /**
5323 * balise : DRAW
5324 * mode : OUVERTURE
5325 *
5326 * @param array paramètres de l'élément de parsing
5327 * @return null
5328 */
5329 function o_DRAW($param)
5330 {
5331 if ($this->forOneLine) return false;
5332 if ($this->DEBUG_actif) $this->DEBUG_add('DRAW', true);
5333
5334 $this->style->save();
5335 $this->style->analyse('draw', $param);
5336 $this->style->FontSet();
5337
5338 $align_object = null;
5339 if ($this->style->value['margin-auto']) $align_object = 'center';
5340
5341 $over_w = $this->style->value['width'];
5342 $over_h = $this->style->value['height'];
5343 $this->style->value['old_maxX'] = $this->maxX;
5344 $this->style->value['old_maxY'] = $this->maxY;
5345 $this->style->value['old_maxH'] = $this->maxH;
5346
5347 $w = $this->style->value['width'];
5348 $h = $this->style->value['height'];
5349
5350 if (!$this->style->value['position'])
5351 {
5352 if (
5353 $w < ($this->pdf->getW() - $this->pdf->getlMargin()-$this->pdf->getrMargin()) &&
5354 $this->pdf->getX() + $w>=($this->pdf->getW() - $this->pdf->getrMargin())
5355 )
5356 $this->o_BR(array());
5357
5358 if (
5359 ($h < ($this->pdf->getH() - $this->pdf->gettMargin()-$this->pdf->getbMargin())) &&
5360 ($this->pdf->getY() + $h>=($this->pdf->getH() - $this->pdf->getbMargin())) &&
5361 !$this->isInOverflow
5362 )
5363 $this->setNewPage();
5364
5365 // en cas d'alignement => correction
5366 $old = $this->style->getOldValues();
5367 $parent_w = $old['width'] ? $old['width'] : $this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin();
5368
5369 if ($parent_w>$w)
5370 {
5371 if ($align_object=='center') $this->pdf->setX($this->pdf->getX() + ($parent_w-$w)*0.5);
5372 else if ($align_object=='right') $this->pdf->setX($this->pdf->getX() + $parent_w-$w);
5373 }
5374
5375 $this->style->setPosition();
5376 }
5377 else
5378 {
5379 // en cas d'alignement => correction
5380 $old = $this->style->getOldValues();
5381 $parent_w = $old['width'] ? $old['width'] : $this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin();
5382
5383 if ($parent_w>$w)
5384 {
5385 if ($align_object=='center') $this->pdf->setX($this->pdf->getX() + ($parent_w-$w)*0.5);
5386 else if ($align_object=='right') $this->pdf->setX($this->pdf->getX() + $parent_w-$w);
5387 }
5388
5389 $this->style->setPosition();
5390 $this->saveMax();
5391 $this->maxX = 0;
5392 $this->maxY = 0;
5393 $this->maxH = 0;
5394 $this->maxE = 0;
5395 }
5396
5397 // initialisation du style des bordures de la div
5398 $this->drawRectangle(
5399 $this->style->value['x'],
5400 $this->style->value['y'],
5401 $this->style->value['width'],
5402 $this->style->value['height'],
5403 $this->style->value['border'],
5404 $this->style->value['padding'],
5405 0,
5406 $this->style->value['background']
5407 );
5408
5409 $marge = array();
5410 $marge['l'] = $this->style->value['border']['l']['width'];
5411 $marge['r'] = $this->style->value['border']['r']['width'];
5412 $marge['t'] = $this->style->value['border']['t']['width'];
5413 $marge['b'] = $this->style->value['border']['b']['width'];
5414
5415 $this->style->value['width'] -= $marge['l']+$marge['r'];
5416 $this->style->value['height']-= $marge['t']+$marge['b'];
5417
5418 $over_w-= $marge['l']+$marge['r'];
5419 $over_h-= $marge['t']+$marge['b'];
5420 $this->pdf->clippingPathOpen(
5421 $this->style->value['x']+$marge['l'],
5422 $this->style->value['y']+$marge['t'],
5423 $this->style->value['width'],
5424 $this->style->value['height']
5425 );
5426
5427 // limitation des marges aux dimensions du contenu
5428 $mL = $this->style->value['x']+$marge['l'];
5429 $mR = $this->pdf->getW() - $mL - $over_w;
5430
5431 $x = $this->style->value['x']+$marge['l'];
5432 $y = $this->style->value['y']+$marge['t'];
5433 $this->saveMargin($mL, 0, $mR);
5434 $this->pdf->setXY($x, $y);
5435
5436 $this->isInDraw = array(
5437 'x' => $x,
5438 'y' => $y,
5439 'w' => $over_w,
5440 'h' => $over_h,
5441 );
5442 $this->pdf->doTransform(array(1,0,0,1,$x,$y));
5443 return true;
5444 }
5445
5446 /**
5447 * balise : DRAW
5448 * mode : FERMETURE
5449 *
5450 * @param array paramètres de l'élément de parsing
5451 * @return null
5452 */
5453 function c_DRAW($param)
5454 {
5455 if ($this->forOneLine) return false;
5456
5457 $this->pdf->undoTransform();
5458 $this->pdf->clippingPathClose();
5459
5460 $this->maxX = $this->style->value['old_maxX'];
5461 $this->maxY = $this->style->value['old_maxY'];
5462 $this->maxH = $this->style->value['old_maxH'];
5463
5464 $marge = array();
5465 $marge['l'] = $this->style->value['border']['l']['width'];
5466 $marge['r'] = $this->style->value['border']['r']['width'];
5467 $marge['t'] = $this->style->value['border']['t']['width'];
5468 $marge['b'] = $this->style->value['border']['b']['width'];
5469
5470 $x = $this->style->value['x'];
5471 $y = $this->style->value['y'];
5472 $w = $this->style->value['width']+$marge['l']+$marge['r'];
5473 $h = $this->style->value['height']+$marge['t']+$marge['b'];
5474
5475 if ($this->style->value['position']!='absolute')
5476 {
5477 // position
5478 $this->pdf->setXY($x+$w, $y);
5479
5480 // position MAX
5481 $this->maxX = max($this->maxX, $x+$w);
5482 $this->maxY = max($this->maxY, $y+$h);
5483 $this->maxH = max($this->maxH, $h);
5484 }
5485 else
5486 {
5487 // position
5488 $this->pdf->setXY($this->style->value['xc'], $this->style->value['yc']);
5489
5490 $this->loadMax();
5491 }
5492
5493 $block = ($this->style->value['display']!='inline' && $this->style->value['position']!='absolute');
5494
5495 $this->style->load();
5496 $this->style->FontSet();
5497 $this->loadMargin();
5498
5499 if ($block) $this->o_BR(array());
5500 if ($this->DEBUG_actif) $this->DEBUG_add('DRAW', false);
5501
5502 $this->isInDraw = null;
5503
5504 return true;
5505 }
5506
5507 /**
5508 * balise : LINE
5509 * mode : OUVERTURE
5510 *
5511 * @param array paramètres de l'élément de parsing
5512 * @return null
5513 */
5514 function o_LINE($param)
5515 {
5516 if (!$this->isInDraw) HTML2PDF::makeError(8, __FILE__, __LINE__, 'LINE');
5517 $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);
5518 $this->style->save();
5519 $styles = $this->style->getSvgStyle('path', $param);
5520 $styles['fill'] = null;
5521 $style = $this->pdf->svgSetStyle($styles);
5522
5523 $x1 = isset($param['x1']) ? $this->style->ConvertToMM($param['x1'], $this->isInDraw['w']) : 0.;
5524 $y1 = isset($param['y1']) ? $this->style->ConvertToMM($param['y1'], $this->isInDraw['h']) : 0.;
5525 $x2 = isset($param['x2']) ? $this->style->ConvertToMM($param['x2'], $this->isInDraw['w']) : 0.;
5526 $y2 = isset($param['y2']) ? $this->style->ConvertToMM($param['y2'], $this->isInDraw['h']) : 0.;
5527 $this->pdf->svgLine($x1, $y1, $x2, $y2);
5528
5529 $this->pdf->undoTransform();
5530 $this->style->load();
5531 }
5532
5533 /**
5534 * balise : RECT
5535 * mode : OUVERTURE
5536 *
5537 * @param array paramètres de l'élément de parsing
5538 * @return null
5539 */
5540 function o_RECT($param)
5541 {
5542 if (!$this->isInDraw) HTML2PDF::makeError(8, __FILE__, __LINE__, 'RECT');
5543 $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);
5544 $this->style->save();
5545 $styles = $this->style->getSvgStyle('path', $param);
5546 $style = $this->pdf->svgSetStyle($styles);
5547
5548 $x = isset($param['x']) ? $this->style->ConvertToMM($param['x'], $this->isInDraw['w']) : 0.;
5549 $y = isset($param['y']) ? $this->style->ConvertToMM($param['y'], $this->isInDraw['h']) : 0.;
5550 $w = isset($param['w']) ? $this->style->ConvertToMM($param['w'], $this->isInDraw['w']) : 0.;
5551 $h = isset($param['h']) ? $this->style->ConvertToMM($param['h'], $this->isInDraw['h']) : 0.;
5552
5553 $this->pdf->svgRect($x, $y, $w, $h, $style);
5554
5555 $this->pdf->undoTransform();
5556 $this->style->load();
5557 }
5558
5559 /**
5560 * balise : CIRCLE
5561 * mode : OUVERTURE
5562 *
5563 * @param array paramètres de l'élément de parsing
5564 * @return null
5565 */
5566 function o_CIRCLE($param)
5567 {
5568 if (!$this->isInDraw) HTML2PDF::makeError(8, __FILE__, __LINE__, 'CIRCLE');
5569 $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);
5570 $this->style->save();
5571 $styles = $this->style->getSvgStyle('path', $param);
5572 $style = $this->pdf->svgSetStyle($styles);
5573
5574 $cx = isset($param['cx']) ? $this->style->ConvertToMM($param['cx'], $this->isInDraw['w']) : 0.;
5575 $cy = isset($param['cy']) ? $this->style->ConvertToMM($param['cy'], $this->isInDraw['h']) : 0.;
5576 $r = isset($param['r']) ? $this->style->ConvertToMM($param['r'], $this->isInDraw['w']) : 0.;
5577 $this->pdf->svgEllipse($cx, $cy, $r, $r, $style);
5578
5579 $this->pdf->undoTransform();
5580 $this->style->load();
5581 }
5582
5583 /**
5584 * balise : ELLIPSE
5585 * mode : OUVERTURE
5586 *
5587 * @param array paramètres de l'élément de parsing
5588 * @return null
5589 */
5590 function o_ELLIPSE($param)
5591 {
5592 if (!$this->isInDraw) HTML2PDF::makeError(8, __FILE__, __LINE__, 'ELLIPSE');
5593 $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);
5594 $this->style->save();
5595 $styles = $this->style->getSvgStyle('path', $param);
5596 $style = $this->pdf->svgSetStyle($styles);
5597
5598 $cx = isset($param['cx']) ? $this->style->ConvertToMM($param['cx'], $this->isInDraw['w']) : 0.;
5599 $cy = isset($param['cy']) ? $this->style->ConvertToMM($param['cy'], $this->isInDraw['h']) : 0.;
5600 $rx = isset($param['ry']) ? $this->style->ConvertToMM($param['rx'], $this->isInDraw['w']) : 0.;
5601 $ry = isset($param['rx']) ? $this->style->ConvertToMM($param['ry'], $this->isInDraw['h']) : 0.;
5602 $this->pdf->svgEllipse($cx, $cy, $rx, $ry, $style);
5603
5604 $this->pdf->undoTransform();
5605 $this->style->load();
5606 }
5607
5608
5609 /**
5610 * balise : POLYLINE
5611 * mode : OUVERTURE
5612 *
5613 * @param array paramètres de l'élément de parsing
5614 * @return null
5615 */
5616 function o_POLYLINE($param)
5617 {
5618 if (!$this->isInDraw) HTML2PDF::makeError(8, __FILE__, __LINE__, 'POLYGON');
5619 $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);
5620 $this->style->save();
5621 $styles = $this->style->getSvgStyle('path', $param);
5622 $style = $this->pdf->svgSetStyle($styles);
5623
5624 $path = isset($param['points']) ? $param['points'] : null;
5625 if ($path)
5626 {
5627 $path = str_replace(',', ' ', $path);
5628 $path = preg_replace('/[\s]+/', ' ', trim($path));
5629
5630 // decoupage et nettoyage
5631 $path = explode(' ', $path);
5632 foreach($path as $k => $v)
5633 {
5634 $path[$k] = trim($v);
5635 if ($path[$k]==='') unset($path[$k]);
5636 }
5637 $path = array_values($path);
5638
5639 $actions = array();
5640 for($k=0; $k<count($path); $k+=2)
5641 {
5642 $actions[] = array(($k ? 'L' : 'M') ,
5643 $this->style->ConvertToMM($path[$k+0], $this->isInDraw['w']),
5644 $this->style->ConvertToMM($path[$k+1], $this->isInDraw['h']));
5645 }
5646
5647 // on trace
5648 $this->pdf->svgPolygone($actions, $style);
5649 }
5650
5651 $this->pdf->undoTransform();
5652 $this->style->load();
5653 }
5654
5655 /**
5656 * balise : POLYGON
5657 * mode : OUVERTURE
5658 *
5659 * @param array paramètres de l'élément de parsing
5660 * @return null
5661 */
5662 function o_POLYGON($param)
5663 {
5664 if (!$this->isInDraw) HTML2PDF::makeError(8, __FILE__, __LINE__, 'POLYGON');
5665 $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);
5666 $this->style->save();
5667 $styles = $this->style->getSvgStyle('path', $param);
5668 $style = $this->pdf->svgSetStyle($styles);
5669
5670 $path = isset($param['points']) ? $param['points'] : null;
5671 if ($path)
5672 {
5673 $path = str_replace(',', ' ', $path);
5674 $path = preg_replace('/[\s]+/', ' ', trim($path));
5675
5676 // decoupage et nettoyage
5677 $path = explode(' ', $path);
5678 foreach($path as $k => $v)
5679 {
5680 $path[$k] = trim($v);
5681 if ($path[$k]==='') unset($path[$k]);
5682 }
5683 $path = array_values($path);
5684
5685 $actions = array();
5686 for($k=0; $k<count($path); $k+=2)
5687 {
5688 $actions[] = array(($k ? 'L' : 'M') ,
5689 $this->style->ConvertToMM($path[$k+0], $this->isInDraw['w']),
5690 $this->style->ConvertToMM($path[$k+1], $this->isInDraw['h']));
5691 }
5692 $actions[] = array('z');
5693 // on trace
5694 $this->pdf->svgPolygone($actions, $style);
5695 }
5696
5697 $this->pdf->undoTransform();
5698 $this->style->load();
5699 }
5700
5701 /**
5702 * balise : PATH
5703 * mode : OUVERTURE
5704 *
5705 * @param array paramètres de l'élément de parsing
5706 * @return null
5707 */
5708 function o_PATH($param)
5709 {
5710 if (!$this->isInDraw) HTML2PDF::makeError(8, __FILE__, __LINE__, 'PATH');
5711 $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);
5712 $this->style->save();
5713 $styles = $this->style->getSvgStyle('path', $param);
5714 $style = $this->pdf->svgSetStyle($styles);
5715
5716 $path = isset($param['d']) ? $param['d'] : null;
5717 if ($path)
5718 {
5719 // preparation
5720 $path = str_replace(',', ' ', $path);
5721 $path = preg_replace('/([a-zA-Z])([0-9\.\-])/', '$1 $2', $path);
5722 $path = preg_replace('/([0-9\.])([a-zA-Z])/', '$1 $2', $path);
5723 $path = preg_replace('/[\s]+/', ' ', trim($path));
5724 $path = preg_replace('/ ([a-z]{2})/', '$1', $path);
5725
5726 // decoupage et nettoyage
5727 $path = explode(' ', $path);
5728 foreach($path as $k => $v)
5729 {
5730 $path[$k] = trim($v);
5731 if ($path[$k]==='') unset($path[$k]);
5732 }
5733 $path = array_values($path);
5734
5735 // conversion des unites
5736 $actions = array();
5737 $action = array();
5738 for($k=0; $k<count($path); $k+=count($action))
5739 {
5740 $action = array();
5741 $action[] = $path[$k];
5742 switch($path[$k])
5743 {
5744 case 'C':
5745 case 'c':
5746 $action[] = $this->style->ConvertToMM($path[$k+1], $this->isInDraw['w']); // x1
5747 $action[] = $this->style->ConvertToMM($path[$k+2], $this->isInDraw['h']); // y1
5748 $action[] = $this->style->ConvertToMM($path[$k+3], $this->isInDraw['w']); // x2
5749 $action[] = $this->style->ConvertToMM($path[$k+4], $this->isInDraw['h']); // y2
5750 $action[] = $this->style->ConvertToMM($path[$k+5], $this->isInDraw['w']); // x
5751 $action[] = $this->style->ConvertToMM($path[$k+6], $this->isInDraw['h']); // y
5752 break;
5753
5754 case 'Q':
5755 case 'S':
5756 case 'q':
5757 case 's':
5758 $action[] = $this->style->ConvertToMM($path[$k+1], $this->isInDraw['w']); // x2
5759 $action[] = $this->style->ConvertToMM($path[$k+2], $this->isInDraw['h']); // y2
5760 $action[] = $this->style->ConvertToMM($path[$k+3], $this->isInDraw['w']); // x
5761 $action[] = $this->style->ConvertToMM($path[$k+4], $this->isInDraw['h']); // y
5762 break;
5763
5764 case 'A':
5765 case 'a':
5766 $action[] = $this->style->ConvertToMM($path[$k+1], $this->isInDraw['w']); // rx
5767 $action[] = $this->style->ConvertToMM($path[$k+2], $this->isInDraw['h']); // ry
5768 $action[] = 1.*$path[$k+3]; // angle de deviation de l'axe X
5769 $action[] = ($path[$k+4]=='1') ? 1 : 0; // large-arc-flag
5770 $action[] = ($path[$k+5]=='1') ? 1 : 0; // sweep-flag
5771 $action[] = $this->style->ConvertToMM($path[$k+6], $this->isInDraw['w']); // x
5772 $action[] = $this->style->ConvertToMM($path[$k+7], $this->isInDraw['h']); // y
5773 break;
5774
5775 case 'M':
5776 case 'L':
5777 case 'T':
5778 case 'm':
5779 case 'l':
5780 case 't':
5781 $action[] = $this->style->ConvertToMM($path[$k+1], $this->isInDraw['w']); // x
5782 $action[] = $this->style->ConvertToMM($path[$k+2], $this->isInDraw['h']); // y
5783 break;
5784
5785 case 'H':
5786 case 'h':
5787 $action[] = $this->style->ConvertToMM($path[$k+1], $this->isInDraw['w']); // x
5788 break;
5789
5790 case 'V':
5791 case 'v':
5792 $action[] = $this->style->ConvertToMM($path[$k+1], $this->isInDraw['h']); // y
5793 break;
5794
5795 case 'z':
5796 case 'Z':
5797 default:
5798 break;
5799 }
5800 $actions[] = $action;
5801 }
5802
5803 // on trace
5804 $this->pdf->svgPolygone($actions, $style);
5805 }
5806
5807 $this->pdf->undoTransform();
5808 $this->style->load();
5809 }
5810
5811 /**
5812 * balise : G
5813 * mode : OUVERTURE
5814 *
5815 * @param array paramètres de l'élément de parsing
5816 * @return null
5817 */
5818 function o_G($param)
5819 {
5820 if (!$this->isInDraw) HTML2PDF::makeError(8, __FILE__, __LINE__, 'LINE');
5821 $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);
5822 $this->style->save();
5823 $styles = $this->style->getSvgStyle('path', $param);
5824 $style = $this->pdf->svgSetStyle($styles);
5825 }
5826
5827 /**
5828 * balise : G
5829 * mode : FERMETURE
5830 *
5831 * @param array paramètres de l'élément de parsing
5832 * @return null
5833 */
5834 function c_G($param)
5835 {
5836 $this->pdf->undoTransform();
5837 $this->style->load();
5838 }
5839
5840 function _prepareTransform($transform)
5841 {
5842 if (!$transform) return null;
5843 $actions = array();
5844 if (!preg_match_all('/([a-z]+)\(([^\)]*)\)/isU', $transform, $match)) return null;
5845
5846 for($k=0; $k<count($match[0]); $k++)
5847 {
5848 $nom = strtolower($match[1][$k]);
5849 $val = explode(',', trim($match[2][$k]));
5850 foreach($val as $i => $j)
5851 $val[$i] = trim($j);
5852
5853 switch($nom)
5854 {
5855 case 'scale':
5856 if (!isset($val[0])) $val[0] = 1.; else $val[0] = 1.*$val[0];
5857 if (!isset($val[1])) $val[1] = $val[0]; else $val[1] = 1.*$val[1];
5858 $actions[] = array($val[0],0,0,$val[1],0,0);
5859 break;
5860
5861 case 'translate':
5862 if (!isset($val[0])) $val[0] = 0.; else $val[0] = $this->style->ConvertToMM($val[0], $this->isInDraw['w']);
5863 if (!isset($val[1])) $val[1] = 0.; else $val[1] = $this->style->ConvertToMM($val[1], $this->isInDraw['h']);
5864 $actions[] = array(1,0,0,1,$val[0],$val[1]);
5865 break;
5866
5867 case 'rotate':
5868 if (!isset($val[0])) $val[0] = 0.; else $val[0] = $val[0]*M_PI/180.;
5869 if (!isset($val[1])) $val[1] = 0.; else $val[1] = $this->style->ConvertToMM($val[1], $this->isInDraw['w']);
5870 if (!isset($val[2])) $val[2] = 0.; else $val[2] = $this->style->ConvertToMM($val[2], $this->isInDraw['h']);
5871 if ($val[1] || $val[2]) $actions[] = array(1,0,0,1,-$val[1],-$val[2]);
5872 $actions[] = array(cos($val[0]),sin($val[0]),-sin($val[0]),cos($val[0]),0,0);
5873 if ($val[1] || $val[2]) $actions[] = array(1,0,0,1,$val[1],$val[2]);
5874 break;
5875
5876 case 'skewx':
5877 if (!isset($val[0])) $val[0] = 0.; else $val[0] = $val[0]*M_PI/180.;
5878 $actions[] = array(1,0,tan($val[0]),1,0,0);
5879 break;
5880
5881 case 'skewy':
5882 if (!isset($val[0])) $val[0] = 0.; else $val[0] = $val[0]*M_PI/180.;
5883 $actions[] = array(1,tan($val[0]),0,1,0,0);
5884 break;
5885 case 'matrix':
5886 if (!isset($val[0])) $val[0] = 0.; else $val[0] = $val[0]*1.;
5887 if (!isset($val[1])) $val[1] = 0.; else $val[1] = $val[1]*1.;
5888 if (!isset($val[2])) $val[2] = 0.; else $val[2] = $val[2]*1.;
5889 if (!isset($val[3])) $val[3] = 0.; else $val[3] = $val[3]*1.;
5890 if (!isset($val[4])) $val[4] = 0.; else $val[4] = $this->style->ConvertToMM($val[4], $this->isInDraw['w']);
5891 if (!isset($val[5])) $val[5] = 0.; else $val[5] = $this->style->ConvertToMM($val[5], $this->isInDraw['h']);
5892 $actions[] =$val;
5893 break;
5894 }
5895 }
5896
5897 if (!$actions) return null;
5898 $m = $actions[0]; unset($actions[0]);
5899 foreach($actions as $n)
5900 {
5901 $m = array(
5902 $m[0]*$n[0]+$m[2]*$n[1],
5903 $m[1]*$n[0]+$m[3]*$n[1],
5904 $m[0]*$n[2]+$m[2]*$n[3],
5905 $m[1]*$n[2]+$m[3]*$n[3],
5906 $m[0]*$n[4]+$m[2]*$n[5]+$m[4],
5907 $m[1]*$n[4]+$m[3]*$n[5]+$m[5]
5908 );
5909 }
5910
5911 return $m;
5912 }
5913
5914 function _getDrawNumber(&$lst, $key, $n=1, $correct=false)
5915 {
5916 $res = array_fill(0, $n, 0);
5917 $tmp = isset($lst[$key]) ? $lst[$key] : null;
5918 if (!$tmp) return $res;
5919 $tmp = explode(' ', trim(preg_replace('/[\s]+/', ' ', $tmp)));
5920 foreach($tmp as $k => $v)
5921 {
5922 $v = trim($v);
5923 if (!$correct)
5924 {
5925 $res[$k] = $this->style->ConvertToMM($v);
5926 }
5927 else
5928 {
5929 $res[$k] = $this->style->ConvertToMM($v, ($k%2) ? $this->isInDraw['h'] : $this->isInDraw['w']);
5930 }
5931 }
5932 return $res;
5933 }
5934
5935 /**
5936 * permet d'afficher un index automatique utilisant les bookmark
5937 *
5938 * @param string titre du sommaire
5939 * @param int taille en mm de la fonte du titre du sommaire
5940 * @param int taille en mm de la fonte du texte du sommaire
5941 * @param boolean ajouter un bookmark spécifique pour l'index, juste avant le début de celui-ci
5942 * @param boolean afficher les numéros de page associés à chaque bookmark
5943 * @param int si présent : page où afficher le sommaire. sinon : nouvelle page
5944 * @param string nom de la fonte à utiliser
5945 * @return null
5946 */
5947 function createIndex($titre = 'Index', $size_title = 20, $size_bookmark = 15, $bookmark_title = true, $display_page = true, $on_page = null, $font_name = 'helvetica')
5948 {
5949 $old_page = $this->INDEX_NewPage($on_page);
5950 $this->pdf->createIndex($this, $titre, $size_title, $size_bookmark, $bookmark_title, $display_page, $on_page, $font_name);
5951 if ($old_page) $this->pdf->setPage($old_page);
5952 }
5953
5954 /**
5955 * nouvelle page pour l'index. ne pas utiliser directement. seul MyPDF doit l'utiliser !!!!
5956 *
5957 * @param int page courante
5958 * @return null
5959 */
5960 function INDEX_NewPage(&$page)
5961 {
5962 if ($page)
5963 {
5964 $old_page = $this->pdf->getPage();
5965 $this->pdf->setPage($page);
5966 $this->pdf->setXY($this->margeLeft, $this->margeTop);
5967 $this->maxH = 0;
5968 $page++;
5969 return $old_page;
5970 }
5971 else
5972 {
5973 $this->setNewPage();
5974 return null;
5975 }
5976 }
5977
5978 /**
5979 * chargement du fichier de langue
5980 *
5981 * @param string langue
5982 * @return null
5983 */
5984 function textLOAD($langue)
5985 {
5986 global $HTML2PDF_TEXTES;
5987 if (count($HTML2PDF_TEXTES)) return true;
5988
5989 if (!preg_match('/^([a-z0-9]+)$/isU', $langue))
5990 {
5991 echo 'ERROR : language code <b>'.$langue.'</b> incorrect.';
5992 exit;
5993 }
5994
5995 $file = dirname(__FILE__).'/langues/'.strtolower($langue).'.txt';
5996 if (!is_file($file))
5997 {
5998 echo 'ERROR : language code <b>'.$langue.'</b> unknown.<br>';
5999 echo 'You can create the translation file <b>'.$file.'</b> and send it to me in order to integrate it into a future version.';
6000 exit;
6001 }
6002
6003 $texte = array();
6004 $infos = file($file);
6005 foreach($infos as $val)
6006 {
6007 $val = trim($val);
6008 $val = explode("\t", $val);
6009 if (count($val)<2) continue;
6010
6011 $t_k = trim($val[0]); unset($val[0]);
6012 $t_v = trim(implode(' ', $val));
6013 if ($t_k && $t_v) $texte[$t_k] = $t_v;
6014 }
6015 $HTML2PDF_TEXTES = $texte;
6016
6017 return true;
6018 }
6019
6020 /**
6021 * recuperer un texte precis
6022 *
6023 * @param string code du texte
6024 * @return null
6025 */
6026 function textGET($key)
6027 {
6028 global $HTML2PDF_TEXTES;
6029 if (!isset($HTML2PDF_TEXTES[$key])) return '######';
6030
6031 return $HTML2PDF_TEXTES[$key];
6032 }
6033
6034 /**
6035 * generer une erreur HTML2PDF
6036 *
6037 * @param int numero de l'erreur
6038 * @param string nom du fichier ou c'est produit l'erreur
6039 * @param int numero de la ligne ou c'est produit l'erreur
6040 * @param mixed indications suplementaires sur l'erreur
6041 * @return string code HTML eventuel associé à l'erreur
6042 */
6043 function makeError($err, $file, $line, $other = null, $html = '')
6044 {
6045 $msg = '';
6046 switch($err)
6047 {
6048 case 1:
6049 $msg = (HTML2PDF::textGET('err01'));
6050 $msg = str_replace('[[OTHER]]', $other, $msg);
6051 break;
6052
6053 case 2:
6054 $msg = (HTML2PDF::textGET('err02'));
6055 $msg = str_replace('[[OTHER_0]]', $other[0], $msg);
6056 $msg = str_replace('[[OTHER_1]]', $other[1], $msg);
6057 $msg = str_replace('[[OTHER_2]]', $other[2], $msg);
6058 break;
6059
6060 case 3:
6061 $msg = (HTML2PDF::textGET('err03'));
6062 $msg = str_replace('[[OTHER]]', $other, $msg);
6063 break;
6064
6065 case 4:
6066 $msg = (HTML2PDF::textGET('err04'));
6067 $msg = str_replace('[[OTHER]]', print_r($other, true), $msg);
6068 break;
6069
6070 case 5:
6071 $msg = (HTML2PDF::textGET('err05'));
6072 $msg = str_replace('[[OTHER]]', print_r($other, true), $msg);
6073 break;
6074
6075 case 6:
6076 $msg = (HTML2PDF::textGET('err06'));
6077 $msg = str_replace('[[OTHER]]', $other, $msg);
6078 break;
6079
6080 case 7:
6081 $msg = (HTML2PDF::textGET('err07'));
6082 break;
6083
6084 case 8:
6085 $msg = (HTML2PDF::textGET('err08'));
6086 $msg = str_replace('[[OTHER]]', $other, $msg);
6087 break;
6088
6089 case 9:
6090 $msg = (HTML2PDF::textGET('err09'));
6091 $msg = str_replace('[[OTHER_0]]', $other[0], $msg);
6092 $msg = str_replace('[[OTHER_1]]', $other[1], $msg);
6093 break;
6094 }
6095 echo '<span style="color: #AA0000; font-weight: bold;">'.(HTML2PDF::textGET('txt01')).$err.'</span><br>';
6096 echo (HTML2PDF::textGET('txt02')).' '.$file.'<br>';
6097 echo (HTML2PDF::textGET('txt03')).' '.$line.'<br>';
6098 echo '<br>';
6099 echo $msg;
6100 echo '<br>';
6101 if ($html) echo '<br>HTML : ...'.htmlentities($html).'...';
6102 exit;
6103 }
6104 }
6105 }
Mirror of official OpenEMR Sourceforge repository