PageRenderTime 49ms CodeModel.GetById 15ms RepoModel.GetById 0ms app.codeStats 1ms

/common/libraries/plugin/html2pdf/html2pdf.class.php

https://bitbucket.org/renaatdemuynck/chamilo
PHP | 6528 lines | 4448 code | 863 blank | 1217 comment | 748 complexity | 5f659e18d7f4af2877b8f9e0b0c52f61 MD5 | raw file
Possible License(s): BSD-3-Clause, LGPL-2.1, LGPL-3.0, GPL-3.0, MIT, GPL-2.0 
    

  1. <?php

    2. 

  2. /**

    3. 

  3.  * Logiciel : HTML2PDF

    4. 

  4.  *

    5. 

  5.  * Convertisseur HTML => PDF, utilise TCPDF

    6. 

  6.  * Distribu� sous la licence LGPL.

    7. 

  7.  *

    8. 

  8.  * @author		Laurent MINGUET <webmaster@html2pdf.fr>

    9. 

  9.  * @version		4.00

    10. 

  10.  */

    11. 

  11. 

    12. 

  12. if (! defined('__CLASS_HTML2PDF__'))

    13. 

  13. {

    14. 

  14.     define('__CLASS_HTML2PDF__', '4.00');

    15. 

  15.     

    16. 

  16.     require_once (dirname(__FILE__) . '/_mypdf/mypdf.class.php'); // classe mypdf

    17. 

  17.     require_once (dirname(__FILE__) . '/parsingHTML.class.php'); // classe de parsing HTML

    18. 

  18.     require_once (dirname(__FILE__) . '/styleHTML.class.php'); // classe de gestion des styles

    19. 

  19.     

    20. 

  20. 

    21. 

  21.     class HTML2PDF

    22. 

  22.     {

    23. 

  23.         public $pdf = null; // objet PDF

    24. 

  24.         public $style = null; // objet de style

    25. 

  25.         public $parsing = null; // objet de parsing

    26. 

  26.         

    27. 

  27. 

    28. 

  28.         protected $langue = 'fr'; // langue des messages

    29. 

  29.         protected $sens = 'P'; // sens d'affichage Portrait ou Landscape

    30. 

  30.         protected $format = 'A4'; // format de la page : A4, A3, ...

    31. 

  31.         protected $encoding = ''; // charset encoding

    32. 

  32.         protected $unicode = true; // means that the input text is unicode (default = true)

    33. 

  33.         

    34. 

  34. 

    35. 

  35.         protected $background = array(); // informations sur le background

    36. 

  36.         protected $testTDin1page = true; // activer le test de TD ne devant pas depasser une page

    37. 

  37.         protected $testIsImage = true; // test si les images existes ou non

    38. 

  38.         protected $isSubPart = false; // indique que le convertisseur courant est un sous html

    39. 

  39.         

    40. 

  40. 

    41. 

  41.         protected $parse_pos = 0; // position du parsing

    42. 

  42.         protected $temp_pos = 0; // position temporaire pour multi tableau

    43. 

  43.         protected $page = 0; // numero de la page courante

    44. 

  44.         

    45. 

  45. 

    46. 

  46.         protected $sub_html = null; // sous html

    47. 

  47.         protected $sub_part = false; // indicateur de sous html

    48. 

  48.         

    49. 

  49. 

    50. 

  50.         protected $maxX = 0; // zone maxi X

    51. 

  51.         protected $maxY = 0; // zone maxi Y

    52. 

  52.         protected $maxE = 0; // nomre d'elements dans la zone

    53. 

  53.         protected $maxH = 0; // plus grande hauteur dans la ligne, pour saut de ligne � corriger

    54. 

  54.         protected $maxSave = array(); // tableau de sauvegarde des maximaux

    55. 

  55.         protected $currentH = 0; // hauteur de la ligne courante

    56. 

  56.         

    57. 

  57. 

    58. 

  58.         protected $firstPage = true; // premier page

    59. 

  59.         

    60. 

  60. 

    61. 

  61.         protected $defaultLeft = 0; // marges par default de la page

    62. 

  62.         protected $defaultTop = 0;

    63. 

  63.         protected $defaultRight = 0;

    64. 

  64.         protected $defaultBottom = 0;

    65. 

  65.         

    66. 

  66.         protected $margeLeft = 0; //marges r�elles de la page

    67. 

  67.         protected $margeTop = 0;

    68. 

  68.         protected $margeRight = 0;

    69. 

  69.         protected $margeBottom = 0;

    70. 

  70.         protected $marges = array(); // tableau de sauvegarde des differents etats des marges de la page courante

    71. 

  71.         

    72. 

  72. 

    73. 

  73.         protected $inLink = ''; // indique si on est � l'interieur d'un lien

    74. 

  74.         protected $lstAncre = array(); // liste des ancres d�tect�es ou cr��es

    75. 

  75.         protected $subHEADER = array(); // tableau des sous commandes pour faire l'HEADER

    76. 

  76.         protected $subFOOTER = array(); // tableau des sous commandes pour faire le FOOTER

    77. 

  77.         protected $subSTATES = array(); // tableau de sauvegarde de certains param�tres

    78. 

  78.         protected $defLIST = array(); // tableau de sauvegarde de l'etat des UL et OL

    79. 

  79.         

    80. 

  80. 

    81. 

  81.         protected $lstChamps = array(); // liste des champs

    82. 

  82.         protected $lstSelect = array(); // options du select en cours

    83. 

  83.         protected $previousCall = null; // dernier appel

    84. 

  84.         protected $pageMarges = array(); // marges sp�cifiques dues aux floats

    85. 

  85.         protected $isInThead = false; // indique si on est dans un thead

    86. 

  86.         protected $isInTfoot = false; // indique si on est dans un tfoot

    87. 

  87.         protected $isInOverflow = false; // indique si on est dans une div overflow

    88. 

  88.         protected $isInFooter = false; // indique si on est dans un footer ou non

    89. 

  89.         protected $isInDraw = null; // indique si on est en mode dessin

    90. 

  90.         protected $isAfterFloat = false; // indique si on est apres un float

    91. 

  91.         protected $forOneLine = false; // indique si on est dans un sous HTML ne servant qu'a calculer la taille de la prochaine ligne

    92. 

  92.         protected $isInForm = false; // indique si on est dans un formulaire. Contient dans ce cas l� l'action de celui-ci

    93. 

  93.         

    94. 

  94. 

    95. 

  95.         protected $DEBUG_actif = false; // indique si on est en mode debug

    96. 

  96.         protected $DEBUG_ok_usage = false; // indique l'existance de la fonction memory_get_usage

    97. 

  97.         protected $DEBUG_ok_peak = false; // indique l'existance de la fonction memory_get_peak_usage

    98. 

  98.         protected $DEBUG_level = 0; // niveau du debug

    99. 

  99.         protected $DEBUG_start_time = 0; //

    100. 

  100.         protected $DEBUG_last_time = 0; //

    101. 

  101.         protected $defaultFont = null; // fonte par d�faut si la fonte demand�e n'existe pas

    102. 

  102.         

    103. 

  103. 

    104. 

  104.         protected static $SUBOBJ = null; // sous objet HTML2PDF pr�par� en cas de besoin

    105. 

  105.         protected static $TABLES = array(); // tableau global necessaire � la gestion des tables imbriqu�es

    106. 

  106.         protected static $TEXTES = array(); // tableau comprennant le fichier de langue

    107. 

  107. 

    108. 

  108.         

    109. 

  109.         /**

    110. 

  110.          * Constructeur

    111. 

  111.          *

    112. 

  112.          * @param	string		sens portrait ou landscape

    113. 

  113.          * @param	string		format A4, A5, ...

    114. 

  114.          * @param	string		langue : fr, en, it...

    115. 

  115.          * @param	boolean		$unicode TRUE means that the input text is unicode (default = true)

    116. 

  116.          * @param 	String		$encoding charset encoding; default is UTF-8

    117. 

  117.          * @param	array		marges par defaut, dans l'ordre (left, top, right, bottom)

    118. 

  118.          * @return	null

    119. 

  119.          */

    120. 

  120.         public function __construct($sens = 'P', $format = 'A4', $langue = 'fr', $unicode = true, $encoding = 'UTF-8', $marges = array(5, 5, 5, 8))

    121. 

  121.         {

    122. 

  122.             // sauvegarde des param�tres

    123. 

  123.             $this->page = 0;

    124. 

  124.             $this->sens = $sens;

    125. 

  125.             $this->format = $format;

    126. 

  126.             $this->unicode = $unicode;

    127. 

  127.             $this->encoding = $encoding;

    128. 

  128.             

    129. 

  129.             $this->firstPage = true;

    130. 

  130.             $this->langue = strtolower($langue);

    131. 

  131.             

    132. 

  132.             // chargement du fichier de langue

    133. 

  133.             HTML2PDF :: textLOAD($this->langue);

    134. 

  134.             

    135. 

  135.             // cr�ation de l' objet PDF

    136. 

  136.             $this->pdf = new MyPDF($sens, 'mm', $format, $unicode, $encoding);

    137. 

  137.             

    138. 

  138.             // initialisation des styles

    139. 

  139.             $this->style = new styleHTML($this->pdf);

    140. 

  140.             $this->style->FontSet();

    141. 

  141.             $this->defLIST = array();

    142. 

  142.             

    143. 

  143.             // initialisations diverses

    144. 

  144.             $this->setTestTdInOnePage(true);

    145. 

  145.             $this->setTestIsImage(true);

    146. 

  146.             $this->setDefaultFont(null);

    147. 

  147.             

    148. 

  148.             // initialisation du parsing

    149. 

  149.             $this->parsing = new parsingHTML($this->encoding);

    150. 

  150.             $this->sub_html = null;

    151. 

  151.             $this->sub_part = false;

    152. 

  152.             

    153. 

  153.             // initialisation des marges

    154. 

  154.             if (! is_array($marges))

    155. 

  155.                 $marges = array($marges, $marges, $marges, $marges);

    156. 

  156.             $this->setDefaultMargins($marges[0], $marges[1], $marges[2], $marges[3]);

    157. 

  157.             $this->setMargins();

    158. 

  158.             $this->marges = array();

    159. 

  159.             

    160. 

  160.             // initialisation des champs de formulaire

    161. 

  161.             $this->lstChamps = array();

    162. 

  162.         }

    163. 

  163. 

    164. 

  164.         /**

    165. 

  165.          * Destructeur

    166. 

  166.          *

    167. 

  167.          * @return	null

    168. 

  168.          */

    169. 

  169.         public function __destruct()

    170. 

  170.         {

    171. 

  171.         

    172. 

  172.         }

    173. 

  173. 

    174. 

  174.         /**

    175. 

  175.          * activer le debug mode

    176. 

  176.          *

    177. 

  177.          * @return	null

    178. 

  178.          */

    179. 

  179.         public function setModeDebug()

    180. 

  180.         {

    181. 

  181.             list($usec, $sec) = explode(' ', microtime());

    182. 

  182.             

    183. 

  183.             $this->DEBUG_actif = true;

    184. 

  184.             $this->DEBUG_ok_usage = function_exists('memory_get_usage');

    185. 

  185.             $this->DEBUG_ok_peak = function_exists('memory_get_peak_usage');

    186. 

  186.             $this->DEBUG_start_time = (float) $sec + (float) $usec;

    187. 

  187.             $this->DEBUG_last_time = (float) $sec + (float) $usec;

    188. 

  188.             

    189. 

  189.             $this->DEBUG_stepline('step', 'time', 'delta', 'memory', 'peak');

    190. 

  190.             $this->DEBUG_add('Init debug');

    191. 

  191.         }

    192. 

  192. 

    193. 

  193.         /**

    194. 

  194.          * rajouter une ligne de debug

    195. 

  195.          *

    196. 

  196.          * @param	string	nom de l'etape

    197. 

  197.          * @param	boolean true=monter d'un niveau, false=descendre d'un niveau, null : ne rien faire

    198. 

  198.          * @return	null

    199. 

  199.          */

    200. 

  200.         protected function DEBUG_add($nom, $level = null)

    201. 

  201.         {

    202. 

  202.             list($usec, $sec) = explode(' ', microtime());

    203. 

  203.             if ($level === true)

    204. 

  204.                 $this->DEBUG_level ++;

    205. 

  205.             

    206. 

  206.             $nom = str_repeat('  ', $this->DEBUG_level) . $nom . ($level === true ? ' Begin' : ($level === false ? ' End' : ''));

    207. 

  207.             $time = (float) $sec + (float) $usec;

    208. 

  208.             $usage = ($this->DEBUG_ok_usage ? memory_get_usage() : 0);

    209. 

  209.             $peak = ($this->DEBUG_ok_peak ? memory_get_peak_usage() : 0);

    210. 

  210.             

    211. 

  211.             $this->DEBUG_stepline($nom, number_format(($time - $this->DEBUG_start_time) * 1000, 1, '.', ' ') . ' ms', number_format(($time - $this->DEBUG_last_time) * 1000, 1, '.', ' ') . ' ms', number_format($usage / 1024, 1, '.', ' ') . ' Ko', number_format($peak / 1024, 1, '.', ' ') . ' Ko');

    212. 

  212.             

    213. 

  213.             $this->DEBUG_last_time = $time;

    214. 

  214.             if ($level === false)

    215. 

  215.                 $this->DEBUG_level --;

    216. 

  216.             return true;

    217. 

  217.         }

    218. 

  218. 

    219. 

  219.         /**

    220. 

  220.          * affiche une ligne de debug

    221. 

  221.          *

    222. 

  222.          * @param	string	nom de l'etape

    223. 

  223.          * @param	string	valeur 1

    224. 

  224.          * @param	string	valeur 2

    225. 

  225.          * @param	string	valeur 3

    226. 

  226.          * @param	string	valeur 4

    227. 

  227.          * @return	null

    228. 

  228.          */

    229. 

  229.         protected function DEBUG_stepline($nom, $val1, $val2, $val3, $val4)

    230. 

  230.         {

    231. 

  231.             $txt = str_pad($nom, 30, ' ', STR_PAD_RIGHT) . str_pad($val1, 12, ' ', STR_PAD_LEFT) . str_pad($val2, 12, ' ', STR_PAD_LEFT) . str_pad($val3, 15, ' ', STR_PAD_LEFT) . str_pad($val4, 15, ' ', STR_PAD_LEFT);

    232. 

  232.             

    233. 

  233.             echo '<pre style="padding:0; margin:0">' . $txt . '</pre>';

    234. 

  234.         }

    235. 

  235. 

    236. 

  236.         /**

    237. 

  237.          * activer ou desactiver le test de TD ne devant pas depasser une page

    238. 

  238.          *

    239. 

  239.          * @param	boolean	nouvel etat

    240. 

  240.          * @return	boolean ancien etat

    241. 

  241.          */

    242. 

  242.         public function setTestTdInOnePage($mode = true)

    243. 

  243.         {

    244. 

  244.             $old = $this->testTDin1page;

    245. 

  245.             $this->testTDin1page = $mode ? true : false;

    246. 

  246.             return $old;

    247. 

  247.         }

    248. 

  248. 

    249. 

  249.         /**

    250. 

  250.          * activer ou desactiver le test sur la pr�sence des images

    251. 

  251.          *

    252. 

  252.          * @param	boolean	nouvel etat

    253. 

  253.          * @return	boolean ancien etat

    254. 

  254.          */

    255. 

  255.         public function setTestIsImage($mode = true)

    256. 

  256.         {

    257. 

  257.             $old = $this->testIsImage;

    258. 

  258.             $this->testIsImage = $mode ? true : false;

    259. 

  259.             return $old;

    260. 

  260.         }

    261. 

  261. 

    262. 

  262.         /**

    263. 

  263.          * d�finit la fonte par d�faut si aucun fonte n'est sp�cifi�e, ou si la fonte demand�e n'existe pas

    264. 

  264.          *

    265. 

  265.          * @param	string	nom de la fonte par defaut. si null : Arial pour fonte non sp�cifi�e, et erreur pour fonte non existante

    266. 

  266.          * @return	string	nom de l'ancienne fonte par defaut

    267. 

  267.          */

    268. 

  268.         public function setDefaultFont($default = null)

    269. 

  269.         {

    270. 

  270.             $old = $this->defaultFont;

    271. 

  271.             $this->defaultFont = $default;

    272. 

  272.             $this->style->setDefaultFont($default);

    273. 

  273.             return $old;

    274. 

  274.         }

    275. 

  275. 

    276. 

  276.         /**

    277. 

  277.          * d�finir les marges par d�fault

    278. 

  278.          *

    279. 

  279.          * @param	int		en mm, marge left

    280. 

  280.          * @param	int		en mm, marge top

    281. 

  281.          * @param	int		en mm, marge right. si null, left=right

    282. 

  282.          * @param	int		en mm, marge bottom. si null, bottom=8

    283. 

  283.          * @return	null

    284. 

  284.          */

    285. 

  285.         protected function setDefaultMargins($left, $top, $right = null, $bottom = null)

    286. 

  286.         {

    287. 

  287.             if ($right === null)

    288. 

  288.                 $right = $left;

    289. 

  289.             if ($bottom === null)

    290. 

  290.                 $bottom = 8;

    291. 

  291.             

    292. 

  292.             $this->defaultLeft = $this->style->ConvertToMM($left . 'mm');

    293. 

  293.             $this->defaultTop = $this->style->ConvertToMM($top . 'mm');

    294. 

  294.             $this->defaultRight = $this->style->ConvertToMM($right . 'mm');

    295. 

  295.             $this->defaultBottom = $this->style->ConvertToMM($bottom . 'mm');

    296. 

  296.         }

    297. 

  297. 

    298. 

  298.         /**

    299. 

  299.          * d�finir les marges r�elles, fonctions de la balise page

    300. 

  300.          *

    301. 

  301.          * @return	null

    302. 

  302.          */

    303. 

  303.         protected function setMargins()

    304. 

  304.         {

    305. 

  305.             $this->margeLeft = $this->defaultLeft + (isset($this->background['left']) ? $this->background['left'] : 0);

    306. 

  306.             $this->margeRight = $this->defaultRight + (isset($this->background['right']) ? $this->background['right'] : 0);

    307. 

  307.             $this->margeTop = $this->defaultTop + (isset($this->background['top']) ? $this->background['top'] : 0);

    308. 

  308.             $this->margeBottom = $this->defaultBottom + (isset($this->background['bottom']) ? $this->background['bottom'] : 0);

    309. 

  309.             

    310. 

  310.             $this->pdf->SetMargins($this->margeLeft, $this->margeTop, $this->margeRight);

    311. 

  311.             $this->pdf->setcMargin(0);

    312. 

  312.             $this->pdf->SetAutoPageBreak(false, $this->margeBottom);

    313. 

  313.             

    314. 

  314.             $this->pageMarges = array();

    315. 

  315.             $this->pageMarges[floor($this->margeTop * 100)] = array($this->margeLeft, 

    316. 

  316.                     $this->pdf->getW() - $this->margeRight);

    317. 

  317.         }

    318. 

  318. 

    319. 

  319.         /**

    320. 

  320.          * recuperer les positions x minimales et maximales en fonction d'une hauteur

    321. 

  321.          *

    322. 

  322.          * @param	float	y

    323. 

  323.          * @return	array(float, float)

    324. 

  324.          */

    325. 

  325.         protected function getMargins($y)

    326. 

  326.         {

    327. 

  327.             $y = floor($y * 100);

    328. 

  328.             $x = array($this->pdf->getlMargin(), $this->pdf->getW() - $this->pdf->getrMargin());

    329. 

  329.             

    330. 

  330.             foreach ($this->pageMarges as $m_y => $m_x)

    331. 

  331.                 if ($m_y <= $y)

    332. 

  332.                     $x = $m_x;

    333. 

  333.             

    334. 

  334.             return $x;

    335. 

  335.         }

    336. 

  336. 

    337. 

  337.         /**

    338. 

  338.          * ajouter une marge suite a un float

    339. 

  339.          *

    340. 

  340.          * @param	string	left ou right

    341. 

  341.          * @param	float	x1

    342. 

  342.          * @param	float	y1

    343. 

  343.          * @param	float	x2

    344. 

  344.          * @param	float	y2

    345. 

  345.          * @return	null

    346. 

  346.          */

    347. 

  347.         protected function addMargins($float, $x1, $y1, $x2, $y2)

    348. 

  348.         {

    349. 

  349.             $old1 = $this->getMargins($y1);

    350. 

  350.             $old2 = $this->getMargins($y2);

    351. 

  351.             if ($float == 'left')

    352. 

  352.                 $old1[0] = $x2;

    353. 

  353.             if ($float == 'right')

    354. 

  354.                 $old1[1] = $x1;

    355. 

  355.             

    356. 

  356.             $y1 = floor($y1 * 100);

    357. 

  357.             $y2 = floor($y2 * 100);

    358. 

  358.             

    359. 

  359.             foreach ($this->pageMarges as $m_y => $m_x)

    360. 

  360.             {

    361. 

  361.                 if ($m_y < $y1)

    362. 

  362.                     continue;

    363. 

  363.                 if ($m_y > $y2)

    364. 

  364.                     break;

    365. 

  365.                 if ($float == 'left' && $this->pageMarges[$m_y][0] < $x2)

    366. 

  366.                     unset($this->pageMarges[$m_y]);

    367. 

  367.                 if ($float == 'right' && $this->pageMarges[$m_y][1] > $x1)

    368. 

  368.                     unset($this->pageMarges[$m_y]);

    369. 

  369.             }

    370. 

  370.             

    371. 

  371.             $this->pageMarges[$y1] = $old1;

    372. 

  372.             $this->pageMarges[$y2] = $old2;

    373. 

  373.             

    374. 

  374.             ksort($this->pageMarges);

    375. 

  375.             

    376. 

  376.             $this->isAfterFloat = true;

    377. 

  377.         }

    378. 

  378. 

    379. 

  379.         /**

    380. 

  380.          * d�finir des nouvelles marges et sauvegarder les anciennes

    381. 

  381.          *

    382. 

  382.          * @param	float	marge left

    383. 

  383.          * @param	float	marge top

    384. 

  384.          * @param	float	marge right

    385. 

  385.          * @return	null

    386. 

  386.          */

    387. 

  387.         protected function saveMargin($ml, $mt, $mr)

    388. 

  388.         {

    389. 

  389.             $this->marges[] = array('l' => $this->pdf->getlMargin(), 't' => $this->pdf->gettMargin(), 

    390. 

  390.                     'r' => $this->pdf->getrMargin(), 'page' => $this->pageMarges);

    391. 

  391.             $this->pdf->SetMargins($ml, $mt, $mr);

    392. 

  392.             

    393. 

  393.             $this->pageMarges = array();

    394. 

  394.             $this->pageMarges[floor($mt * 100)] = array($ml, $this->pdf->getW() - $mr);

    395. 

  395.         }

    396. 

  396. 

    397. 

  397.         /**

    398. 

  398.          * r�cuperer les derni�res marches sauv�es

    399. 

  399.          *

    400. 

  400.          * @return	null

    401. 

  401.          */

    402. 

  402.         protected function loadMargin()

    403. 

  403.         {

    404. 

  404.             $old = array_pop($this->marges);

    405. 

  405.             if ($old)

    406. 

  406.             {

    407. 

  407.                 $ml = $old['l'];

    408. 

  408.                 $mt = $old['t'];

    409. 

  409.                 $mr = $old['r'];

    410. 

  410.                 $mP = $old['page'];

    411. 

  411.             }

    412. 

  412.             else

    413. 

  413.             {

    414. 

  414.                 $ml = $this->margeLeft;

    415. 

  415.                 $mt = 0;

    416. 

  416.                 $mr = $this->margeRight;

    417. 

  417.                 $mP = array($mt => array($ml, $this->pdf->getW() - $mr));

    418. 

  418.             }

    419. 

  419.             

    420. 

  420.             $this->pdf->SetMargins($ml, $mt, $mr);

    421. 

  421.             $this->pageMarges = $mP;

    422. 

  422.         }

    423. 

  423. 

    424. 

  424.         /**

    425. 

  425.          * permet d'ajouter une fonte.

    426. 

  426.          *

    427. 

  427.          * @param	string nom de la fonte

    428. 

  428.          * @param	string style de la fonte

    429. 

  429.          * @param	string fichier de la fonte

    430. 

  430.          * @return	null

    431. 

  431.          */

    432. 

  432.         public function addFont($family, $style = '', $file = '')

    433. 

  433.         {

    434. 

  434.             $this->pdf->AddFont($family, $style, $file);

    435. 

  435.         }

    436. 

  436. 

    437. 

  437.         /**

    438. 

  438.          * sauvegarder l'�tat actuelle des maximums

    439. 

  439.          *

    440. 

  440.          * @return	null

    441. 

  441.          */

    442. 

  442.         protected function saveMax()

    443. 

  443.         {

    444. 

  444.             $this->maxSave[] = array($this->maxX, $this->maxY, $this->maxH, $this->maxE);

    445. 

  445.         }

    446. 

  446. 

    447. 

  447.         /**

    448. 

  448.          * charger le dernier �tat sauv� des maximums

    449. 

  449.          *

    450. 

  450.          * @return	null

    451. 

  451.          */

    452. 

  452.         protected function loadMax()

    453. 

  453.         {

    454. 

  454.             $old = array_pop($this->maxSave);

    455. 

  455.             

    456. 

  456.             if ($old)

    457. 

  457.             {

    458. 

  458.                 $this->maxX = $old[0];

    459. 

  459.                 $this->maxY = $old[1];

    460. 

  460.                 $this->maxH = $old[2];

    461. 

  461.                 $this->maxE = $old[3];

    462. 

  462.             }

    463. 

  463.             else

    464. 

  464.             {

    465. 

  465.                 $this->maxX = 0;

    466. 

  466.                 $this->maxY = 0;

    467. 

  467.                 $this->maxH = 0;

    468. 

  468.                 $this->maxE = 0;

    469. 

  469.             }

    470. 

  470.         }

    471. 

  471. 

    472. 

  472.         /**

    473. 

  473.          * afficher l'header contenu dans page_header

    474. 

  474.          *

    475. 

  475.          * @return	null

    476. 

  476.          */

    477. 

  477.         protected function setPageHeader()

    478. 

  478.         {

    479. 

  479.             if (! count($this->subHEADER))

    480. 

  480.                 return false;

    481. 

  481.             

    482. 

  482.             $OLD_parse_pos = $this->parse_pos;

    483. 

  483.             $OLD_parse_code = $this->parsing->code;

    484. 

  484.             

    485. 

  485.             $this->parse_pos = 0;

    486. 

  486.             $this->parsing->code = $this->subHEADER;

    487. 

  487.             $this->makeHTMLcode();

    488. 

  488.             

    489. 

  489.             $this->parse_pos = $OLD_parse_pos;

    490. 

  490.             $this->parsing->code = $OLD_parse_code;

    491. 

  491.         }

    492. 

  492. 

    493. 

  493.         /**

    494. 

  494.          * afficher le footer contenu dans page_footer

    495. 

  495.          *

    496. 

  496.          * @return	null

    497. 

  497.          */

    498. 

  498.         protected function setPageFooter()

    499. 

  499.         {

    500. 

  500.             if (! count($this->subFOOTER))

    501. 

  501.                 return false;

    502. 

  502.             

    503. 

  503.             $OLD_parse_pos = $this->parse_pos;

    504. 

  504.             $OLD_parse_code = $this->parsing->code;

    505. 

  505.             

    506. 

  506.             $this->parse_pos = 0;

    507. 

  507.             $this->parsing->code = $this->subFOOTER;

    508. 

  508.             $this->isInFooter = true;

    509. 

  509.             $this->makeHTMLcode();

    510. 

  510.             $this->isInFooter = false;

    511. 

  511.             

    512. 

  512.             $this->parse_pos = $OLD_parse_pos;

    513. 

  513.             $this->parsing->code = $OLD_parse_code;

    514. 

  514.         }

    515. 

  515. 

    516. 

  516.         /**

    517. 

  517.          * saut de ligne avec une hauteur sp�cifique

    518. 

  518.          *

    519. 

  519.          * @param	float	hauteur de la ligne

    520. 

  520.          * @param	integer	position reelle courante si saut de ligne pendant l'ecriture d'un texte

    521. 

  521.          * @return	null

    522. 

  522.          */

    523. 

  523.         protected function setNewLine($h, $curr = null)

    524. 

  524.         {

    525. 

  525.             $this->pdf->Ln($h);

    526. 

  526.             

    527. 

  527.             $this->setNewPositionForNewLine($curr);

    528. 

  528.         }

    529. 

  529. 

    530. 

  530.         /**

    531. 

  531.          * cr�ation d'une nouvelle page avec le format et l'orientation sp�cifies

    532. 

  532.          *

    533. 

  533.          * @param	mixed	format de la page : A5, A4, array(width, height)

    534. 

  534.          * @param	string	sens P=portrait ou L=landscape

    535. 

  535.          * @param	array	tableau des propri�t�s du fond de la page

    536. 

  536.          * @param	integer	position reelle courante si saut de ligne pendant l'ecriture d'un texte

    537. 

  537.          * @return	null

    538. 

  538.          */

    539. 

  539.         public function setNewPage($format = null, $orientation = '', $background = null, $curr = null)

    540. 

  540.         {

    541. 

  541.             $this->firstPage = false;

    542. 

  542.             

    543. 

  543.             $this->format = $format ? $format : $this->format;

    544. 

  544.             $this->sens = $orientation ? $orientation : $this->sens;

    545. 

  545.             $this->background = $background !== null ? $background : $this->background;

    546. 

  546.             $this->maxY = 0;

    547. 

  547.             $this->maxX = 0;

    548. 

  548.             $this->maxH = 0;

    549. 

  549.             

    550. 

  550.             $this->pdf->SetMargins($this->defaultLeft, $this->defaultTop, $this->defaultRight);

    551. 

  551.             $this->pdf->AddPage($this->sens, $this->format);

    552. 

  552.             $this->page ++;

    553. 

  553.             

    554. 

  554.             if (! $this->sub_part && ! $this->isSubPart)

    555. 

  555.             {

    556. 

  556.                 if (is_array($this->background))

    557. 

  557.                 {

    558. 

  558.                     if (isset($this->background['color']) && $this->background['color'])

    559. 

  559.                     {

    560. 

  560.                         $this->pdf->setFillColorArray($this->background['color']);

    561. 

  561.                         $this->pdf->Rect(0, 0, $this->pdf->getW(), $this->pdf->getH(), 'F');

    562. 

  562.                     }

    563. 

  563.                     

    564. 

  564.                     if (isset($this->background['img']) && $this->background['img'])

    565. 

  565.                         $this->pdf->Image($this->background['img'], $this->background['posX'], $this->background['posY'], $this->background['width']);

    566. 

  566.                 }

    567. 

  567.                 

    568. 

  568.                 $this->setPageHeader();

    569. 

  569.                 $this->setPageFooter();

    570. 

  570.             }

    571. 

  571.             

    572. 

  572.             $this->setMargins();

    573. 

  573.             $this->pdf->setY($this->margeTop);

    574. 

  574.             

    575. 

  575.             $this->setNewPositionForNewLine($curr);

    576. 

  576.             $this->maxH = 0;

    577. 

  577.         }

    578. 

  578. 

    579. 

  579.         /**

    580. 

  580.          * calcul de la position de debut de la prochaine ligne en fonction de l'alignement voulu

    581. 

  581.          *

    582. 

  582.          * @param	integer	position reelle courante si saut de ligne pendant l'ecriture d'un texte

    583. 

  583.          * @return	null

    584. 

  584.          */

    585. 

  585.         protected function setNewPositionForNewLine($curr = null)

    586. 

  586.         {

    587. 

  587.             list($lx, $rx) = $this->getMargins($this->pdf->getY());

    588. 

  588.             $this->pdf->setX($lx);

    589. 

  589.             $wMax = $rx - $lx;

    590. 

  590.             $this->currentH = 0;

    591. 

  591.             

    592. 

  592.             if ($this->sub_part || $this->isSubPart || $this->forOneLine)

    593. 

  593.             {

    594. 

  594.                 //				$this->pdf->setWordSpacing(0);

    595. 

  595.                 return null;

    596. 

  596.             }

    597. 

  597.             /*

    598. 

  598. 			if (

    599. 

  599. 				$this->style->value['text-align']!='right' &&

    600. 

  600. 				$this->style->value['text-align']!='center' &&

    601. 

  601. 				$this->style->value['text-align']!='justify'

    602. 

  602. 				)

    603. 

  603. 			{

    604. 

  604. //				$this->pdf->setWordSpacing(0);

    605. 

  605. 				return null;

    606. 

  606. 			}

    607. 

  607. */

    608. 

  608.             $sub = null;

    609. 

  609.             $this->createSubHTML($sub);

    610. 

  610.             $sub->saveMargin(0, 0, $sub->pdf->getW() - $wMax);

    611. 

  611.             $sub->forOneLine = true;

    612. 

  612.             $sub->parse_pos = $this->parse_pos;

    613. 

  613.             $sub->parsing->code = $this->parsing->code;

    614. 

  614.             

    615. 

  615.             if ($curr !== null && $sub->parsing->code[$this->parse_pos]['name'] == 'write')

    616. 

  616.             {

    617. 

  617.                 $txt = $sub->parsing->code[$this->parse_pos]['param']['txt'];

    618. 

  618.                 $txt = str_replace('[[page_cu]]', $sub->page, $txt);

    619. 

  619.                 $sub->parsing->code[$this->parse_pos]['param']['txt'] = substr($txt, $curr);

    620. 

  620.             }

    621. 

  621.             else

    622. 

  622.                 $sub->parse_pos ++;

    623. 

  623.             

    624. 

  624.      // pour chaque element identifi� par le parsing

    625. 

  625.             $res = null;

    626. 

  626.             for($sub->parse_pos; $sub->parse_pos < count($sub->parsing->code); $sub->parse_pos ++)

    627. 

  627.             {

    628. 

  628.                 $todo = $sub->parsing->code[$sub->parse_pos];

    629. 

  629.                 $res = $sub->loadAction($todo);

    630. 

  630.                 if (! $res)

    631. 

  631.                     break;

    632. 

  632.             }

    633. 

  633.             

    634. 

  634.             $w = $sub->maxX; // largeur maximale

    635. 

  635.             $h = $sub->maxH; // hauteur maximale

    636. 

  636.             $e = ($res === null ? $sub->maxE : 0); // nombre d'�l�ments maximal

    637. 

  637.             $this->destroySubHTML($sub);

    638. 

  638.             

    639. 

  639.             if ($this->style->value['text-align'] == 'center')

    640. 

  640.                 $this->pdf->setX(($rx + $this->pdf->getX() - $w) * 0.5 - 0.01);

    641. 

  641.             elseif ($this->style->value['text-align'] == 'right')

    642. 

  642.                 $this->pdf->setX($rx - $w - 0.01);

    643. 

  643.             else

    644. 

  644.                 $this->pdf->setX($lx);

    645. 

  645.             

    646. 

  646.             $this->currentH = $h;

    647. 

  647.             /*

    648. 

  648. 			if ($this->style->value['text-align']=='justify' &&  $e>1)

    649. 

  649. 				$this->pdf->setWordSpacing(($wMax-$w)/($e-1));

    650. 

  650. 			else

    651. 

  651. 				$this->pdf->setWordSpacing(0);

    652. 

  652. */

    653. 

  653.         }

    654. 

  654. 

    655. 

  655.         /**

    656. 

  656.          * r�cup�ration du PDF

    657. 

  657.          *

    658. 

  658.          * @param	string	nom du fichier PDF

    659. 

  659.          * @param	boolean	destination

    660. 

  660.          * @return	string	contenu �ventuel du pdf

    661. 

  661.          *

    662. 

  662.          *

    663. 

  663.          * Destination o� envoyer le document. Le param�tre peut prendre les valeurs suivantes :

    664. 

  664.          * true	: equivalent � I

    665. 

  665.          * false	: equivalent � S

    666. 

  666.          * 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.

    667. 

  667.          * D : envoyer au navigateur en for�ant le t�l�chargement, avec le nom indiqu� dans name.

    668. 

  668.          * F : sauver dans un fichier local, avec le nom indiqu� dans name (peut inclure un r�pertoire).

    669. 

  669.          * S : renvoyer le document sous forme de cha�ne. name est ignor�.

    670. 

  670.          */

    671. 

  671.         public function Output($name = '', $dest = false)

    672. 

  672.         {

    673. 

  673.             // nettoyage

    674. 

  674.             HTML2PDF :: $TABLES = array();

    675. 

  675.             

    676. 

  676.             if ($this->DEBUG_actif)

    677. 

  677.             {

    678. 

  678.                 $this->DEBUG_add('Before output');

    679. 

  679.                 $this->pdf->Close();

    680. 

  680.                 exit();

    681. 

  681.             }

    682. 

  682.             

    683. 

  683.             // interpretation des param�tres

    684. 

  684.             if ($dest === false)

    685. 

  685.                 $dest = 'I';

    686. 

  686.             if ($dest === true)

    687. 

  687.                 $dest = 'S';

    688. 

  688.             if ($dest === '')

    689. 

  689.                 $dest = 'I';

    690. 

  690.             if ($name == '')

    691. 

  691.                 $name = 'document.pdf';

    692. 

  692.             

    693. 

  693.      // verification de la destination

    694. 

  694.             $dest = strtoupper($dest);

    695. 

  695.             if (! in_array($dest, array('I', 'D', 'F', 'S')))

    696. 

  696.                 $dest = 'I';

    697. 

  697.             

    698. 

  698.      // verification du nom

    699. 

  699.             if (strtolower(substr($name, - 4)) != '.pdf')

    700. 

  700.             {

    701. 

  701.                 echo 'ERROR : The output document name "' . $name . '" is not a PDF name';

    702. 

  702.                 exit();

    703. 

  703.             }

    704. 

  704.             

    705. 

  705.             return $this->pdf->Output($name, $dest);

    706. 

  706.         }

    707. 

  707. 

    708. 

  708.         /**

    709. 

  709.          * preparation de HTML2PDF::$SUBOBJ utilis� pour la cr�ation des sous HTML2PDF

    710. 

  710.          *

    711. 

  711.          * @return	null

    712. 

  712.          */

    713. 

  713.         protected function prepareSubObj()

    714. 

  714.         {

    715. 

  715.             $pdf = null;

    716. 

  716.             

    717. 

  717.             HTML2PDF :: $SUBOBJ = new HTML2PDF($this->sens, $this->format, $this->langue, $this->unicode, $this->encoding, array(

    718. 

  718.                     $this->defaultLeft, $this->defaultTop, $this->defaultRight, $this->defaultBottom));

    719. 

  719.             

    720. 

  720.             // initialisation

    721. 

  721.             HTML2PDF :: $SUBOBJ->setIsSubPart();

    722. 

  722.             HTML2PDF :: $SUBOBJ->setTestTdInOnePage($this->testTDin1page);

    723. 

  723.             HTML2PDF :: $SUBOBJ->setTestIsImage($this->testIsImage);

    724. 

  724.             HTML2PDF :: $SUBOBJ->setDefaultFont($this->defaultFont);

    725. 

  725.             HTML2PDF :: $SUBOBJ->style->css = &$this->style->css;

    726. 

  726.             HTML2PDF :: $SUBOBJ->style->css_keys = &$this->style->css_keys;

    727. 

  727.             HTML2PDF :: $SUBOBJ->pdf->cloneFontFrom($this->pdf);

    728. 

  728.             HTML2PDF :: $SUBOBJ->style->setPdfParent($pdf);

    729. 

  729.         }

    730. 

  730. 

    731. 

  731.         /**

    732. 

  732.          * fonction de clonage pour la creation d'un sous HTML2PDF � partir de HTML2PDF::$SUBOBJ

    733. 

  733.          *

    734. 

  734.          * @return	null

    735. 

  735.          */

    736. 

  736.         public function __clone()

    737. 

  737.         {

    738. 

  738.             $this->pdf = clone $this->pdf;

    739. 

  739.             $this->parsing = clone $this->parsing;

    740. 

  740.             $this->style = clone $this->style;

    741. 

  741.             $this->style->setPdfParent($this->pdf);

    742. 

  742.         }

    743. 

  743. 

    744. 

  744.         /**

    745. 

  745.          * cr�ation d'un sous HTML2PDF pour la gestion des tableaux imbriqu�s

    746. 

  746.          *

    747. 

  747.          * @param	HTML2PDF	futur sous HTML2PDF pass� en r�f�rence pour cr�ation

    748. 

  748.          * @param	integer		marge eventuelle de l'objet si simulation d'un TD

    749. 

  749.          * @return	null

    750. 

  750.          */

    751. 

  751.         protected function createSubHTML(&$sub_html, $cellmargin = 0)

    752. 

  752.         {

    753. 

  753.             if (! HTML2PDF :: $SUBOBJ)

    754. 

  754.                 $this->prepareSubObj();

    755. 

  755.             

    756. 

  756.      // calcul de la largueur

    757. 

  757.             if ($this->style->value['width'])

    758. 

  758.             {

    759. 

  759.                 $marge = $cellmargin * 2;

    760. 

  760.                 $marge += $this->style->value['padding']['l'] + $this->style->value['padding']['r'];

    761. 

  761.                 $marge += $this->style->value['border']['l']['width'] + $this->style->value['border']['r']['width'];

    762. 

  762.                 $marge = $this->pdf->getW() - $this->style->value['width'] + $marge;

    763. 

  763.             }

    764. 

  764.             else

    765. 

  765.                 $marge = $this->margeLeft + $this->margeRight;

    766. 

  766.             

    767. 

  767.      //clonage

    768. 

  768.             $sub_html = clone HTML2PDF :: $SUBOBJ;

    769. 

  769.             $sub_html->style->table = $this->style->table;

    770. 

  770.             $sub_html->style->value = $this->style->value;

    771. 

  771.             $sub_html->style->setOnlyLeft();

    772. 

  772.             $sub_html->setNewPage($this->format, $this->sens);

    773. 

  773.             $sub_html->initSubHtml($marge, $this->page, $this->defLIST);

    774. 

  774.         }

    775. 

  775. 

    776. 

  776.         /**

    777. 

  777.          * initialise le sous HTML2PDF. Ne pas utiliser directement. seul la fonction createSubHTML doit l'utiliser

    778. 

  778.          *

    779. 

  779.          * @return	null

    780. 

  780.          */

    781. 

  781.         public function initSubHtml($marge, $page, $defLIST)

    782. 

  782.         {

    783. 

  783.             $this->saveMargin(0, 0, $marge);

    784. 

  784.             $this->defLIST = $defLIST;

    785. 

  785.             

    786. 

  786.             $this->page = $page;

    787. 

  787.             $this->pdf->setXY(0, 0);

    788. 

  788.             $this->style->FontSet();

    789. 

  789.         }

    790. 

  790. 

    791. 

  791.         public function setIsSubPart()

    792. 

  792.         {

    793. 

  793.             $this->isSubPart = true;

    794. 

  794.         }

    795. 

  795. 

    796. 

  796.         /**

    797. 

  797.          * destruction d'un sous HTML2PDF pour la gestion des tableaux imbriqu�s

    798. 

  798.          *

    799. 

  799.          * @return	null

    800. 

  800.          */

    801. 

  801.         protected function destroySubHTML(&$sub_html)

    802. 

  802.         {

    803. 

  803.             unset($sub_html);

    804. 

  804.             $sub_html = null;

    805. 

  805.         }

    806. 

  806. 

    807. 

  807.         /**

    808. 

  808.          * Convertir un nombre arabe en nombre romain

    809. 

  809.          *

    810. 

  810.          * @param	integer	nombre � convertir

    811. 

  811.          * @return	string	nombre converti

    812. 

  812.          */

    813. 

  813.         protected function listeArab2Rom($nb_ar)

    814. 

  814.         {

    815. 

  815.             $nb_b10 = array('I', 'X', 'C', 'M');

    816. 

  816.             $nb_b5 = array('V', 'L', 'D');

    817. 

  817.             $nb_ro = '';

    818. 

  818.             

    819. 

  819.             if ($nb_ar < 1)

    820. 

  820.                 return $nb_ar;

    821. 

  821.             if ($nb_ar > 3999)

    822. 

  822.                 return $nb_ar;

    823. 

  823.             

    824. 

  824.             for($i = 3; $i >= 0; $i --)

    825. 

  825.             {

    826. 

  826.                 $chiffre = floor($nb_ar / pow(10, $i));

    827. 

  827.                 if ($chiffre >= 1)

    828. 

  828.                 {

    829. 

  829.                     $nb_ar = $nb_ar - $chiffre * pow(10, $i);

    830. 

  830.                     if ($chiffre <= 3)

    831. 

  831.                     {

    832. 

  832.                         for($j = $chiffre; $j >= 1; $j --)

    833. 

  833.                         {

    834. 

  834.                             $nb_ro = $nb_ro . $nb_b10[$i];

    835. 

  835.                         }

    836. 

  836.                     }

    837. 

  837.                     else 

    838. 

  838.                         if ($chiffre == 9)

    839. 

  839.                         {

    840. 

  840.                             $nb_ro = $nb_ro . $nb_b10[$i] . $nb_b10[$i + 1];

    841. 

  841.                         }

    842. 

  842.                         elseif ($chiffre == 4)

    843. 

  843.                         {

    844. 

  844.                             $nb_ro = $nb_ro . $nb_b10[$i] . $nb_b5[$i];

    845. 

  845.                         }

    846. 

  846.                         else

    847. 

  847.                         {

    848. 

  848.                             $nb_ro = $nb_ro . $nb_b5[$i];

    849. 

  849.                             for($j = $chiffre - 5; $j >= 1; $j --)

    850. 

  850.                             {

    851. 

  851.                                 $nb_ro = $nb_ro . $nb_b10[$i];

    852. 

  852.                             }

    853. 

  853.                         }

    854. 

  854.                 }

    855. 

  855.             }

    856. 

  856.             return $nb_ro;

    857. 

  857.         }

    858. 

  858. 

    859. 

  859.         /**

    860. 

  860.          * Ajouter un LI au niveau actuel

    861. 

  861.          *

    862. 

  862.          * @return	null

    863. 

  863.          */

    864. 

  864.         protected function listeAddLi()

    865. 

  865.         {

    866. 

  866.             $this->defLIST[count($this->defLIST) - 1]['nb'] ++;

    867. 

  867.         }

    868. 

  868. 

    869. 

  869.         protected function listeGetWidth()

    870. 

  870.         {

    871. 

  871.             return '7mm';

    872. 

  872.         }

    873. 

  873. 

    874. 

  874.         protected function listeGetPadding()

    875. 

  875.         {

    876. 

  876.             return '1mm';

    877. 

  877.         }

    878. 

  878. 

    879. 

  879.         /**

    880. 

  880.          * Recuperer le LI du niveau actuel

    881. 

  881.          *

    882. 

  882.          * @return	string	chaine � afficher

    883. 

  883.          */

    884. 

  884.         protected function listeGetLi()

    885. 

  885.         {

    886. 

  886.             $im = $this->defLIST[count($this->defLIST) - 1]['img'];

    887. 

  887.             $st = $this->defLIST[count($this->defLIST) - 1]['style'];

    888. 

  888.             $nb = $this->defLIST[count($this->defLIST) - 1]['nb'];

    889. 

  889.             $up = (substr($st, 0, 6) == 'upper-');

    890. 

  890.             

    891. 

  891.             if ($im)

    892. 

  892.                 return array(false, false, $im);

    893. 

  893.             

    894. 

  894.             switch ($st)

    895. 

  895.             {

    896. 

  896.                 case 'none' :

    897. 

  897.                     return array('helvetica', true, ' ');

    898. 

  898.                 

    899. 

  899.                 case 'upper-alpha' :

    900. 

  900.                 case 'lower-alpha' :

    901. 

  901.                     $str = '';

    902. 

  902.                     while ($nb > 26)

    903. 

  903.                     {

    904. 

  904.                         $str = chr(96 + $nb % 26) . $str;

    905. 

  905.                         $nb = floor($nb / 26);

    906. 

  906.                     }

    907. 

  907.                     $str = chr(96 + $nb) . $str;

    908. 

  908.                     

    909. 

  909.                     return array('helvetica', false, ($up ? strtoupper($str) : $str) . '.');

    910. 

  910.                 

    911. 

  911.                 case 'upper-roman' :

    912. 

  912.                 case 'lower-roman' :

    913. 

  913.                     $str = $this->listeArab2Rom($nb);

    914. 

  914.                     

    915. 

  915.                     return array('helvetica', false, ($up ? strtoupper($str) : $str) . '.');

    916. 

  916.                 

    917. 

  917.                 case 'decimal' :

    918. 

  918.                     return array('helvetica', false, $nb . '.');

    919. 

  919.                 

    920. 

  920.                 case 'square' :

    921. 

  921.                     return array('zapfdingbats', true, chr(110));

    922. 

  922.                 

    923. 

  923.                 case 'circle' :

    924. 

  924.                     return array('zapfdingbats', true, chr(109));

    925. 

  925.                 

    926. 

  926.                 case 'disc' :

    927. 

  927.                 default :

    928. 

  928.                     return array('zapfdingbats', true, chr(108));

    929. 

  929.             }

    930. 

  930.         }

    931. 

  931. 

    932. 

  932.         /**

    933. 

  933.          * Ajouter un niveau de liste

    934. 

  934.          *

    935. 

  935.          * @param	string	type de liste : ul, ol

    936. 

  936.          * @param	string	style de la liste

    937. 

  937.          * @return	null

    938. 

  938.          */

    939. 

  939.         protected function listeAddLevel($type = 'ul', $style = '', $img = null)

    940. 

  940.         {

    941. 

  941.             if ($img)

    942. 

  942.             {

    943. 

  943.                 if (preg_match('/^url\(([^)]+)\)$/isU', trim($img), $match))

    944. 

  944.                     $img = $match[1];

    945. 

  945.                 else

    946. 

  946.                     $img = null;

    947. 

  947.             }

    948. 

  948.             else

    949. 

  949.                 $img = null;

    950. 

  950.             

    951. 

  951.             if (! in_array($type, array('ul', 'ol')))

    952. 

  952.                 $type = 'ul';

    953. 

  953.             if (! in_array($style, array('lower-alpha', 'upper-alpha', 'upper-roman', 'lower-roman', 'decimal', 

    954. 

  954.                     'square', 'circle', 'disc', 'none')))

    955. 

  955.                 $style = '';

    956. 

  956.             

    957. 

  957.             if (! $style)

    958. 

  958.             {

    959. 

  959.                 if ($type == 'ul')

    960. 

  960.                     $style = 'disc';

    961. 

  961.                 else

    962. 

  962.                     $style = 'decimal';

    963. 

  963.             }

    964. 

  964.             $this->defLIST[count($this->defLIST)] = array('style' => $style, 'nb' => 0, 'img' => $img);

    965. 

  965.         }

    966. 

  966. 

    967. 

  967.         /**

    968. 

  968.          * Supprimer un niveau de liste

    969. 

  969.          *

    970. 

  970.          * @return	null

    971. 

  971.          */

    972. 

  972.         protected function listeDelLevel()

    973. 

  973.         {

    974. 

  974.             if (count($this->defLIST))

    975. 

  975.             {

    976. 

  976.                 unset($this->defLIST[count($this->defLIST) - 1]);

    977. 

  977.                 $this->defLIST = array_values($this->defLIST);

    978. 

  978.             }

    979. 

  979.         }

    980. 

  980. 

    981. 

  981.         /**

    982. 

  982.          * traitement d'un code HTML fait pour HTML2PDF

    983. 

  983.          *

    984. 

  984.          * @param	string	code HTML � convertir

    985. 

  985.          * @param	boolean	afficher en pdf (false) ou en html adapt� (true)

    986. 

  986.          * @return	null

    987. 

  987.          */

    988. 

  988.         public function writeHTML($html, $vue = false)

    989. 

  989.         {

    990. 

  990.             // si c'est une vrai page HTML, une conversion s'impose

    991. 

  991.             if (preg_match('/<body/isU', $html))

    992. 

  992.                 $html = $this->getHtmlFromPage($html);

    993. 

  993.             

    994. 

  994.             $html = str_replace('[[page_nb]]', '{nb}', $html);

    995. 

  995.             

    996. 

  996.             $html = str_replace('[[date_y]]', date('Y'), $html);

    997. 

  997.             $html = str_replace('[[date_m]]', date('m'), $html);

    998. 

  998.             $html = str_replace('[[date_d]]', date('d'), $html);

    999. 

  999.             

    1000. 

  1000.             $html = str_replace('[[date_h]]', date('H'), $html);

    1001. 

  1001.             $html = str_replace('[[date_i]]', date('i'), $html);

    1002. 

  1002.             $html = str_replace('[[date_s]]', date('s'), $html);

    1003. 

  1003.             

    1004. 

  1004.             // si on veut voir le r�sultat en HTML => on appelle la fonction

    1005. 

  1005.             if ($vue)

    1006. 

  1006.                 $this->vueHTML($html);

    1007. 

  1007.             

    1008. 

  1008.      // sinon, traitement pour conversion en PDF :

    1009. 

  1009.             // parsing

    1010. 

  1010.             $this->sub_pdf = false;

    1011. 

  1011.             $this->style->readStyle($html);

    1012. 

  1012.             $this->parsing->setHTML($html);

    1013. 

  1013.             $this->parsing->parse();

    1014. 

  1014.             $this->makeHTMLcode();

    1015. 

  1015.         }

    1016. 

  1016. 

    1017. 

  1017.         /**

    1018. 

  1018.          * traitement du code d'une vrai page HTML pour l'adapter � HTML2PDF

    1019. 

  1019.          *

    1020. 

  1020.          * @param	string	code HTML � adapter

    1021. 

  1021.          * @return	string	code HTML adapt�

    1022. 

  1022.          */

    1023. 

  1023.         public function getHtmlFromPage($html)

    1024. 

  1024.         {

    1025. 

  1025.             $html = str_replace('<BODY', '<body', $html);

    1026. 

  1026.             $html = str_replace('</BODY', '</body', $html);

    1027. 

  1027.             

    1028. 

  1028.             // extraction du contenu

    1029. 

  1029.             $res = explode('<body', $html);

    1030. 

  1030.             if (count($res) < 2)

    1031. 

  1031.                 return $html;

    1032. 

  1032.             $content = '<page' . $res[1];

    1033. 

  1033.             $content = explode('</body', $content);

    1034. 

  1034.             $content = $content[0] . '</page>';

    1035. 

  1035.             

    1036. 

  1036.             // extraction des balises link

    1037. 

  1037.             preg_match_all('/<link([^>]*)>/isU', $html, $match);

    1038. 

  1038.             foreach ($match[0] as $src)

    1039. 

  1039.                 $content = $src . '</link>' . $content;

    1040. 

  1040.             

    1041. 

  1041.      // extraction des balises style

    1042. 

  1042.             preg_match_all('/<style[^>]*>(.*)<\/style[^>]*>/isU', $html, $match);

    1043. 

  1043.             foreach ($match[0] as $src)

    1044. 

  1044.                 $content = $src . $content;

    1045. 

  1045.             

    1046. 

  1046.             return $content;

    1047. 

  1047.         }

    1048. 

  1048. 

    1049. 

  1049.         /**

    1050. 

  1050.          * execute les diff�rentes actions du code HTML

    1051. 

  1051.          *

    1052. 

  1052.          * @return	null

    1053. 

  1053.          */

    1054. 

  1054.         protected function makeHTMLcode()

    1055. 

  1055.         {

    1056. 

  1056.             // pour chaque element identifi� par le parsing

    1057. 

  1057.             for($this->parse_pos = 0; $this->parse_pos < count($this->parsing->code); $this->parse_pos ++)

    1058. 

  1058.             {

    1059. 

  1059.                 // r�cup�ration de l'�l�ment

    1060. 

  1060.                 $todo = $this->parsing->code[$this->parse_pos];

    1061. 

  1061.                 

    1062. 

  1062.                 // si c'est une ouverture de tableau

    1063. 

  1063.                 if (in_array($todo['name'], array('table', 'ul', 'ol')) && ! $todo['close'])

    1064. 

  1064.                 {

    1065. 

  1065.                     // on va cr�er un sous HTML, et on va travailler sur une position temporaire

    1066. 

  1066.                     $tag_open = $todo['name'];

    1067. 

  1067.                     

    1068. 

  1068.                     $this->sub_part = true;

    1069. 

  1069.                     $this->temp_pos = $this->parse_pos;

    1070. 

  1070.                     

    1071. 

  1071.                     // pour tous les �l�ments jusqu'� la fermeture de la table afin de pr�parer les dimensions

    1072. 

  1072.                     while (isset($this->parsing->code[$this->temp_pos]) && ! ($this->parsing->code[$this->temp_pos]['name'] == $tag_open && $this->parsing->code[$this->temp_pos]['close']))

    1073. 

  1073.                     {

    1074. 

  1074.                         $this->loadAction($this->parsing->code[$this->temp_pos]);

    1075. 

  1075.                         $this->temp_pos ++;

    1076. 

  1076.                     }

    1077. 

  1077.                     if (isset($this->parsing->code[$this->temp_pos]))

    1078. 

  1078.                         $this->loadAction($this->parsing->code[$this->temp_pos]);

    1079. 

  1079.                     $this->sub_part = false;

    1080. 

  1080.                 }

    1081. 

  1081.                 

    1082. 

  1082.                 // chargement de l'action correspondant � l'�l�ment

    1083. 

  1083.                 $this->loadAction($todo);

    1084. 

  1084.             }

    1085. 

  1085.         }

    1086. 

  1086. 

    1087. 

  1087.         /**

    1088. 

  1088.          * affichage en mode HTML du contenu

    1089. 

  1089.          *

    1090. 

  1090.          * @param	string	contenu

    1091. 

  1091.          * @return	null

    1092. 

  1092.          */

    1093. 

  1093.         protected function vueHTML($content)

    1094. 

  1094.         {

    1095. 

  1095.             $content = preg_replace('/<page_header([^>]*)>/isU', '<hr>' . HTML2PDF :: textGET('vue01') . ' : $1<hr><div$1>', $content);

    1096. 

  1096.             $content = preg_replace('/<page_footer([^>]*)>/isU', '<hr>' . HTML2PDF :: textGET('vue02') . ' : $1<hr><div$1>', $content);

    1097. 

  1097.             $content = preg_replace('/<page([^>]*)>/isU', '<hr>' . HTML2PDF :: textGET('vue03') . ' : $1<hr><div$1>', $content);

    1098. 

  1098.             $content = preg_replace('/<\/page([^>]*)>/isU', '</div><hr>', $content);

    1099. 

  1099.             $content = preg_replace('/<bookmark([^>]*)>/isU', '<hr>bookmark : $1<hr>', $content);

    1100. 

  1100.             $content = preg_replace('/<\/bookmark([^>]*)>/isU', '', $content);

    1101. 

  1101.             $content = preg_replace('/<barcode([^>]*)>/isU', '<hr>barcode : $1<hr>', $content);

    1102. 

  1102.             $content = preg_replace('/<\/barcode([^>]*)>/isU', '', $content);

    1103. 

  1103.             $content = preg_replace('/<qrcode([^>]*)>/isU', '<hr>qrcode : $1<hr>', $content);

    1104. 

  1104.             $content = preg_replace('/<\/qrcode([^>]*)>/isU', '', $content);

    1105. 

  1105.             

    1106. 

  1106.             echo '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

    1107. 

  1107. <html>

    1108. 

  1108. 	<head>

    1109. 

  1109. 		<title>' . HTML2PDF :: textGET('vue04') . ' HTML</title>

    1110. 

  1110. 		<meta http-equiv="Content-Type" content="text/html; charset=' . $this->encoding . '" >

    1111. 

  1111. 	</head>

    1112. 

  1112. 	<body style="padding: 10px; font-size: 10pt;font-family:	Verdana;">

    1113. 

  1113. ' . $content . '

    1114. 

  1114. 	</body>

    1115. 

  1115. </html>';

    1116. 

  1116.             exit();

    1117. 

  1117.         }

    1118. 

  1118. 

    1119. 

  1119.         /**

    1120. 

  1120.          * chargement de l'action correspondante � un element de parsing

    1121. 

  1121.          *

    1122. 

  1122.          * @param	array	�l�ment de parsing

    1123. 

  1123.          * @return	null

    1124. 

  1124.          */

    1125. 

  1125.         protected function loadAction($row)

    1126. 

  1126.         {

    1127. 

  1127.             // nom de l'action

    1128. 

  1128.             $fnc = ($row['close'] ? 'c_' : 'o_') . strtoupper($row['name']);

    1129. 

  1129.             

    1130. 

  1130.             // parametres de l'action

    1131. 

  1131.             $param = $row['param'];

    1132. 

  1132.             

    1133. 

  1133.             // si aucune page n'est cr��, on la cr��

    1134. 

  1134.             if ($fnc != 'o_PAGE' && $this->firstPage)

    1135. 

  1135.             {

    1136. 

  1136.                 $this->setNewPage();

    1137. 

  1137.             }

    1138. 

  1138.             

    1139. 

  1139.             // lancement de l'action

    1140. 

  1140.             if (is_callable(array(&$this, $fnc)))

    1141. 

  1141.             {

    1142. 

  1142.                 $res = $this->{$fnc}($param);

    1143. 

  1143.                 $this->previousCall = $fnc;

    1144. 

  1144.                 return $res;

    1145. 

  1145.             }

    1146. 

  1146.             else

    1147. 

  1147.             {

    1148. 

  1148.                 HTML2PDF :: makeError(1, __FILE__, __LINE__, strtoupper($row['name']), $this->parsing->getHtmlErrorCode($row['html_pos']));

    1149. 

  1149.                 return false;

    1150. 

  1150.             }

    1151. 

  1151.         }

    1152. 

  1152. 

    1153. 

  1153.         /**

    1154. 

  1154.          * balise	: PAGE

    1155. 

  1155.          * mode		: OUVERTURE

    1156. 

  1156.          *

    1157. 

  1157.          * @param	array	param�tres de l'�l�ment de parsing

    1158. 

  1158.          * @return	null

    1159. 

  1159.          */

    1160. 

  1160.         protected function o_PAGE($param)

    1161. 

  1161.         {

    1162. 

  1162.             if ($this->forOneLine)

    1163. 

  1163.                 return false;

    1164. 

  1164.             if ($this->DEBUG_actif)

    1165. 

  1165.                 $this->DEBUG_add('PAGE n�' . ($this->page + 1), true);

    1166. 

  1166.             

    1167. 

  1167.             $newPageSet = (! isset($param['pageset']) || $param['pageset'] != 'old');

    1168. 

  1168.             

    1169. 

  1169.             $this->maxH = 0;

    1170. 

  1170.             if ($newPageSet)

    1171. 

  1171.             {

    1172. 

  1172.                 $this->subHEADER = array();

    1173. 

  1173.                 $this->subFOOTER = array();

    1174. 

  1174.                 

    1175. 

  1175.                 // identification de l'orientation demand�e

    1176. 

  1176.                 $orientation = '';

    1177. 

  1177.                 if (isset($param['orientation']))

    1178. 

  1178.                 {

    1179. 

  1179.                     $param['orientation'] = strtolower($param['orientation']);

    1180. 

  1180.                     if ($param['orientation'] == 'p')

    1181. 

  1181.                         $orientation = 'P';

    1182. 

  1182.                     if ($param['orientation'] == 'portrait')

    1183. 

  1183.                         $orientation = 'P';

    1184. 

  1184.                     

    1185. 

  1185.                     if ($param['orientation'] == 'l')

    1186. 

  1186.                         $orientation = 'L';

    1187. 

  1187.                     if ($param['orientation'] == 'paysage')

    1188. 

  1188.                         $orientation = 'L';

    1189. 

  1189.                     if ($param['orientation'] == 'landscape')

    1190. 

  1190.                         $orientation = 'L';

    1191. 

  1191.                 }

    1192. 

  1192.                 

    1193. 

  1193.                 // identification de l'orientation demand�e

    1194. 

  1194.                 $format = null;

    1195. 

  1195.                 if (isset($param['format']))

    1196. 

  1196.                 {

    1197. 

  1197.                     $format = strtolower($param['format']);

    1198. 

  1198.                     if (preg_match('/^([0-9]+)x([0-9]+)$/isU', $format, $match))

    1199. 

  1199.                     {

    1200. 

  1200.                         $format = array(intval($match[1]), intval($match[2]));

    1201. 

  1201.                     }

    1202. 

  1202.                 }

    1203. 

  1203.                 

    1204. 

  1204.                 // identification des propri�t�s du background

    1205. 

  1205.                 $background = array();

    1206. 

  1206.                 if (isset($param['backimg']))

    1207. 

  1207.                 {

    1208. 

  1208.                     $background['img'] = isset($param['backimg']) ? $param['backimg'] : ''; // nom de l'image

    1209. 

  1209.                     $background['posX'] = isset($param['backimgx']) ? $param['backimgx'] : 'center'; // position horizontale de l'image

    1210. 

  1210.                     $background['posY'] = isset($param['backimgy']) ? $param['backimgy'] : 'middle'; // position verticale de l'image

    1211. 

  1211.                     $background['width'] = isset($param['backimgw']) ? $param['backimgw'] : '100%'; // taille de l'image (100% = largueur de la feuille)

    1212. 

  1212.                     

    1213. 

  1213. 

    1214. 

  1214.                     // conversion du nom de l'image, en cas de param�tres en _GET

    1215. 

  1215.                     $background['img'] = str_replace('&amp;', '&', $background['img']);

    1216. 

  1216.                     // conversion des positions

    1217. 

  1217.                     if ($background['posX'] == 'left')

    1218. 

  1218.                         $background['posX'] = '0%';

    1219. 

  1219.                     if ($background['posX'] == 'center')

    1220. 

  1220.                         $background['posX'] = '50%';

    1221. 

  1221.                     if ($background['posX'] == 'right')

    1222. 

  1222.                         $background['posX'] = '100%';

    1223. 

  1223.                     if ($background['posY'] == 'top')

    1224. 

  1224.                         $background['posY'] = '0%';

    1225. 

  1225.                     if ($background['posY'] == 'middle')

    1226. 

  1226.                         $background['posY'] = '50%';

    1227. 

  1227.                     if ($background['posY'] == 'bottom')

    1228. 

  1228.                         $background['posY'] = '100%';

    1229. 

  1229.                     

    1230. 

  1230.      // si il y a une image de pr�cis�

    1231. 

  1231.                     if ($background['img'])

    1232. 

  1232.                     {

    1233. 

  1233.                         // est-ce que c'est une image ?

    1234. 

  1234.                         $infos = @GetImageSize($background['img']);

    1235. 

  1235.                         if (count($infos) > 1)

    1236. 

  1236.                         {

    1237. 

  1237.                             // taille de l'image, en fonction de la taille sp�cifi�e.

    1238. 

  1238.                             $Wi = $this->style->ConvertToMM($background['width'], $this->pdf->getW());

    1239. 

  1239.                             $Hi = $Wi * $infos[1] / $infos[0];

    1240. 

  1240.                             

    1241. 

  1241.                             // r�cup�ration des dimensions et positions de l'image

    1242. 

  1242.                             $background['width'] = $Wi;

    1243. 

  1243.                             $background['posX'] = $this->style->ConvertToMM($background['posX'], $this->pdf->getW() - $Wi);

    1244. 

  1244.                             $background['posY'] = $this->style->ConvertToMM($background['posY'], $this->pdf->getH() - $Hi);

    1245. 

  1245.                         }

    1246. 

  1246.                         else

    1247. 

  1247.                             $background = array();

    1248. 

  1248.                     }

    1249. 

  1249.                     else

    1250. 

  1250.                         $background = array();

    1251. 

  1251.                 }

    1252. 

  1252.                 

    1253. 

  1253.                 // marges TOP et BOTTOM pour le texte.

    1254. 

  1254.                 $background['top'] = isset($param['backtop']) ? $param['backtop'] : '0';

    1255. 

  1255.                 $background['bottom'] = isset($param['backbottom']) ? $param['backbottom'] : '0';

    1256. 

  1256.                 $background['left'] = isset($param['backleft']) ? $param['backleft'] : '0';

    1257. 

  1257.                 $background['right'] = isset($param['backright']) ? $param['backright'] : '0';

    1258. 

  1258.                 

    1259. 

  1259.                 if (preg_match('/^([0-9]*)$/isU', $background['top']))

    1260. 

  1260.                     $background['top'] .= 'mm';

    1261. 

  1261.                 if (preg_match('/^([0-9]*)$/isU', $background['bottom']))

    1262. 

  1262.                     $background['bottom'] .= 'mm';

    1263. 

  1263.                 if (preg_match('/^([0-9]*)$/isU', $background['left']))

    1264. 

  1264.                     $background['left'] .= 'mm';

    1265. 

  1265.                 if (preg_match('/^([0-9]*)$/isU', $background['right']))

    1266. 

  1266.                     $background['right'] .= 'mm';

    1267. 

  1267.                 

    1268. 

  1268.                 $background['top'] = $this->style->ConvertToMM($background['top'], $this->pdf->getH());

    1269. 

  1269.                 $background['bottom'] = $this->style->ConvertToMM($background['bottom'], $this->pdf->getH());

    1270. 

  1270.                 $background['left'] = $this->style->ConvertToMM($background['left'], $this->pdf->getW());

    1271. 

  1271.                 $background['right'] = $this->style->ConvertToMM($background['right'], $this->pdf->getW());

    1272. 

  1272.                 

    1273. 

  1273.                 $res = false;

    1274. 

  1274.                 $background['color'] = isset($param['backcolor']) ? $this->style->ConvertToColor($param['backcolor'], $res) : null;

    1275. 

  1275.                 if (! $res)

    1276. 

  1276.                     $background['color'] = null;

    1277. 

  1277.                 

    1278. 

  1278.                 $this->style->save();

    1279. 

  1279.                 $this->style->analyse('PAGE', $param);

    1280. 

  1280.                 $this->style->setPosition();

    1281. 

  1281.                 $this->style->FontSet();

    1282. 

  1282.                 

    1283. 

  1283.                 // nouvelle page

    1284. 

  1284.                 $this->setNewPage($format, $orientation, $background);

    1285. 

  1285.                 

    1286. 

  1286.                 // footer automatique

    1287. 

  1287.                 if (isset($param['footer']))

    1288. 

  1288.                 {

    1289. 

  1289.                     $lst = explode(';', $param['footer']);

    1290. 

  1290.                     foreach ($lst as $key => $val)

    1291. 

  1291.                         $lst[$key] = trim(strtolower($val));

    1292. 

  1292.                     $page = in_array('page', $lst);

    1293. 

  1293.                     $date = in_array('date', $lst);

    1294. 

  1294.                     $heure = in_array('heure', $lst);

    1295. 

  1295.                     $form = in_array('form', $lst);

    1296. 

  1296.                 }

    1297. 

  1297.                 else

    1298. 

  1298.                 {

    1299. 

  1299.                     $page = null;

    1300. 

  1300.                     $date = null;

    1301. 

  1301.                     $heure = null;

    1302. 

  1302.                     $form = null;

    1303. 

  1303.                 }

    1304. 

  1304.                 $this->pdf->SetMyFooter($page, $date, $heure, $form);

    1305. 

  1305.             }

    1306. 

  1306.             else

    1307. 

  1307.             {

    1308. 

  1308.                 $this->style->save();

    1309. 

  1309.                 $this->style->analyse('PAGE', $param);

    1310. 

  1310.                 $this->style->setPosition();

    1311. 

  1311.                 $this->style->FontSet();

    1312. 

  1312.                 

    1313. 

  1313.                 $this->setNewPage();

    1314. 

  1314.             }

    1315. 

  1315.             

    1316. 

  1316.             return true;

    1317. 

  1317.         }

    1318. 

  1318. 

    1319. 

  1319.         /**

    1320. 

  1320.          * balise : PAGE

    1321. 

  1321.          * mode : FERMETURE

    1322. 

  1322.          *

    1323. 

  1323.          * @param	array	param�tres de l'�l�ment de parsing

    1324. 

  1324.          * @return	null

    1325. 

  1325.          */

    1326. 

  1326.         protected function c_PAGE($param)

    1327. 

  1327.         {

    1328. 

  1328.             if ($this->forOneLine)

    1329. 

  1329.                 return false;

    1330. 

  1330.             

    1331. 

  1331.             $this->maxH = 0;

    1332. 

  1332.             

    1333. 

  1333.             $this->style->load();

    1334. 

  1334.             $this->style->FontSet();

    1335. 

  1335.             

    1336. 

  1336.             if ($this->DEBUG_actif)

    1337. 

  1337.                 $this->DEBUG_add('PAGE n�' . $this->page, false);

    1338. 

  1338.             

    1339. 

  1339.             return true;

    1340. 

  1340.         }

    1341. 

  1341. 

    1342. 

  1342.         protected function o_PAGE_HEADER($param)

    1343. 

  1343.         {

    1344. 

  1344.             if ($this->forOneLine)

    1345. 

  1345.                 return false;

    1346. 

  1346.             

    1347. 

  1347.             $this->subHEADER = array();

    1348. 

  1348.             for($this->parse_pos; $this->parse_pos < count($this->parsing->code); $this->parse_pos ++)

    1349. 

  1349.             {

    1350. 

  1350.                 $todo = $this->parsing->code[$this->parse_pos];

    1351. 

  1351.                 if ($todo['name'] == 'page_header')

    1352. 

  1352.                     $todo['name'] = 'page_header_sub';

    1353. 

  1353.                 $this->subHEADER[] = $todo;

    1354. 

  1354.                 if (strtolower($todo['name']) == 'page_header_sub' && $todo['close'])

    1355. 

  1355.                     break;

    1356. 

  1356.             }

    1357. 

  1357.             

    1358. 

  1358.             $this->setPageHeader();

    1359. 

  1359.             

    1360. 

  1360.             return true;

    1361. 

  1361.         }

    1362. 

  1362. 

    1363. 

  1363.         protected function o_PAGE_FOOTER($param)

    1364. 

  1364.         {

    1365. 

  1365.             if ($this->forOneLine)

    1366. 

  1366.                 return false;

    1367. 

  1367.             

    1368. 

  1368.             $this->subFOOTER = array();

    1369. 

  1369.             for($this->parse_pos; $this->parse_pos < count($this->parsing->code); $this->parse_pos ++)

    1370. 

  1370.             {

    1371. 

  1371.                 $todo = $this->parsing->code[$this->parse_pos];

    1372. 

  1372.                 if ($todo['name'] == 'page_footer')

    1373. 

  1373.                     $todo['name'] = 'page_footer_sub';

    1374. 

  1374.                 $this->subFOOTER[] = $todo;

    1375. 

  1375.                 if (strtolower($todo['name']) == 'page_footer_sub' && $todo['close'])

    1376. 

  1376.                     break;

    1377. 

  1377.             }

    1378. 

  1378.             

    1379. 

  1379.             $this->setPageFooter();

    1380. 

  1380.             

    1381. 

  1381.             return true;

    1382. 

  1382.         }

    1383. 

  1383. 

    1384. 

  1384.         protected function o_PAGE_HEADER_SUB($param)

    1385. 

  1385.         {

    1386. 

  1386.             if ($this->forOneLine)

    1387. 

  1387.                 return false;

    1388. 

  1388.             

    1389. 

  1389.      // sauvegarde de l'�tat

    1390. 

  1390.             $this->subSTATES = array();

    1391. 

  1391.             $this->subSTATES['x'] = $this->pdf->getX();

    1392. 

  1392.             $this->subSTATES['y'] = $this->pdf->getY();

    1393. 

  1393.             $this->subSTATES['s'] = $this->style->value;

    1394. 

  1394.             $this->subSTATES['t'] = $this->style->table;

    1395. 

  1395.             $this->subSTATES['ml'] = $this->margeLeft;

    1396. 

  1396.             $this->subSTATES['mr'] = $this->margeRight;

    1397. 

  1397.             $this->subSTATES['mt'] = $this->margeTop;

    1398. 

  1398.             $this->subSTATES['mb'] = $this->margeBottom;

    1399. 

  1399.             $this->subSTATES['mp'] = $this->pageMarges;

    1400. 

  1400.             

    1401. 

  1401.             // nouvel etat pour le footer

    1402. 

  1402.             $this->pageMarges = array();

    1403. 

  1403.             $this->margeLeft = $this->defaultLeft;

    1404. 

  1404.             $this->margeRight = $this->defaultRight;

    1405. 

  1405.             $this->margeTop = $this->defaultTop;

    1406. 

  1406.             $this->margeBottom = $this->defaultBottom;

    1407. 

  1407.             $this->pdf->SetMargins($this->margeLeft, $this->margeTop, $this->margeRight);

    1408. 

  1408.             $this->pdf->SetAutoPageBreak(false, $this->margeBottom);

    1409. 

  1409.             $this->pdf->setXY($this->defaultLeft, $this->defaultTop);

    1410. 

  1410.             

    1411. 

  1411.             $this->style->initStyle();

    1412. 

  1412.             $this->style->resetStyle();

    1413. 

  1413.             $this->style->value['width'] = $this->pdf->getW() - $this->defaultLeft - $this->defaultRight;

    1414. 

  1414.             $this->style->table = array();

    1415. 

  1415.             

    1416. 

  1416.             $this->style->save();

    1417. 

  1417.             $this->style->analyse('page_header_sub', $param);

    1418. 

  1418.             $this->style->setPosition();

    1419. 

  1419.             $this->style->FontSet();

    1420. 

  1420.             $this->setNewPositionForNewLine();

    1421. 

  1421.             return true;

    1422. 

  1422.         }

    1423. 

  1423. 

    1424. 

  1424.         protected function c_PAGE_HEADER_SUB($param)

    1425. 

  1425.         {

    1426. 

  1426.             if ($this->forOneLine)

    1427. 

  1427.                 return false;

    1428. 

  1428.             

    1429. 

  1429.             $this->style->load();

    1430. 

  1430.             

    1431. 

  1431.             // retablissement de l'etat

    1432. 

  1432.             $this->style->value = $this->subSTATES['s'];

    1433. 

  1433.             $this->style->table = $this->subSTATES['t'];

    1434. 

  1434.             $this->pageMarges = $this->subSTATES['mp'];

    1435. 

  1435.             $this->margeLeft = $this->subSTATES['ml'];

    1436. 

  1436.             $this->margeRight = $this->subSTATES['mr'];

    1437. 

  1437.             $this->margeTop = $this->subSTATES['mt'];

    1438. 

  1438.             $this->margeBottom = $this->subSTATES['mb'];

    1439. 

  1439.             $this->pdf->SetMargins($this->margeLeft, $this->margeTop, $this->margeRight);

    1440. 

  1440.             $this->pdf->setbMargin($this->margeBottom);

    1441. 

  1441.             $this->pdf->SetAutoPageBreak(false, $this->margeBottom);

    1442. 

  1442.             $this->pdf->setXY($this->subSTATES['x'], $this->subSTATES['y']);

    1443. 

  1443.             

    1444. 

  1444.             $this->style->FontSet();

    1445. 

  1445.             $this->maxH = 0;

    1446. 

  1446.             

    1447. 

  1447.             return true;

    1448. 

  1448.         }

    1449. 

  1449. 

    1450. 

  1450.         protected function o_PAGE_FOOTER_SUB($param)

    1451. 

  1451.         {

    1452. 

  1452.             if ($this->forOneLine)

    1453. 

  1453.                 return false;

    1454. 

  1454.             

    1455. 

  1455.             $this->subSTATES = array();

    1456. 

  1456.             $this->subSTATES['x'] = $this->pdf->getX();

    1457. 

  1457.             $this->subSTATES['y'] = $this->pdf->getY();

    1458. 

  1458.             $this->subSTATES['s'] = $this->style->value;

    1459. 

  1459.             $this->subSTATES['t'] = $this->style->table;

    1460. 

  1460.             $this->subSTATES['ml'] = $this->margeLeft;

    1461. 

  1461.             $this->subSTATES['mr'] = $this->margeRight;

    1462. 

  1462.             $this->subSTATES['mt'] = $this->margeTop;

    1463. 

  1463.             $this->subSTATES['mb'] = $this->margeBottom;

    1464. 

  1464.             $this->subSTATES['mp'] = $this->pageMarges;

    1465. 

  1465.             

    1466. 

  1466.             // nouvel etat pour le footer

    1467. 

  1467.             $this->pageMarges = array();

    1468. 

  1468.             $this->margeLeft = $this->defaultLeft;

    1469. 

  1469.             $this->margeRight = $this->defaultRight;

    1470. 

  1470.             $this->margeTop = $this->defaultTop;

    1471. 

  1471.             $this->margeBottom = $this->defaultBottom;

    1472. 

  1472.             $this->pdf->SetMargins($this->margeLeft, $this->margeTop, $this->margeRight);

    1473. 

  1473.             $this->pdf->SetAutoPageBreak(false, $this->margeBottom);

    1474. 

  1474.             $this->pdf->setXY($this->defaultLeft, $this->defaultTop);

    1475. 

  1475.             

    1476. 

  1476.             $this->style->initStyle();

    1477. 

  1477.             $this->style->resetStyle();

    1478. 

  1478.             $this->style->value['width'] = $this->pdf->getW() - $this->defaultLeft - $this->defaultRight;

    1479. 

  1479.             $this->style->table = array();

    1480. 

  1480.             

    1481. 

  1481.             // on en cr�� un sous HTML que l'on transforme en PDF

    1482. 

  1482.             // pour r�cup�rer la hauteur

    1483. 

  1483.             // on extrait tout ce qui est contenu dans le FOOTER

    1484. 

  1484.             $sub = null;

    1485. 

  1485.             $this->CreateSubHTML($sub);

    1486. 

  1486.             $sub->parsing->code = $this->parsing->getLevel($this->parse_pos);

    1487. 

  1487.             $sub->MakeHTMLcode();

    1488. 

  1488.             $this->pdf->setY($this->pdf->getH() - $sub->maxY - $this->defaultBottom - 0.01);

    1489. 

  1489.             $this->destroySubHTML($sub);

    1490. 

  1490.             

    1491. 

  1491.             $this->style->save();

    1492. 

  1492.             $this->style->analyse('page_footer_sub', $param);

    1493. 

  1493.             $this->style->setPosition();

    1494. 

  1494.             $this->style->FontSet();

    1495. 

  1495.             $this->setNewPositionForNewLine();

    1496. 

  1496.             

    1497. 

  1497.             return true;

    1498. 

  1498.         }

    1499. 

  1499. 

    1500. 

  1500.         protected function c_PAGE_FOOTER_SUB($param)

    1501. 

  1501.         {

    1502. 

  1502.             if ($this->forOneLine)

    1503. 

  1503.                 return false;

    1504. 

  1504.             

    1505. 

  1505.             $this->style->load();

    1506. 

  1506.             

    1507. 

  1507.             $this->style->value = $this->subSTATES['s'];

    1508. 

  1508.             $this->style->table = $this->subSTATES['t'];

    1509. 

  1509.             $this->pageMarges = $this->subSTATES['mp'];

    1510. 

  1510.             $this->margeLeft = $this->subSTATES['ml'];

    1511. 

  1511.             $this->margeRight = $this->subSTATES['mr'];

    1512. 

  1512.             $this->margeTop = $this->subSTATES['mt'];

    1513. 

  1513.             $this->margeBottom = $this->subSTATES['mb'];

    1514. 

  1514.             $this->pdf->SetMargins($this->margeLeft, $this->margeTop, $this->margeRight);

    1515. 

  1515.             $this->pdf->SetAutoPageBreak(false, $this->margeBottom);

    1516. 

  1516.             $this->pdf->setXY($this->subSTATES['x'], $this->subSTATES['y']);

    1517. 

  1517.             

    1518. 

  1518.             $this->style->FontSet();

    1519. 

  1519.             $this->maxH = 0;

    1520. 

  1520.             

    1521. 

  1521.             return true;

    1522. 

  1522.         }

    1523. 

  1523. 

    1524. 

  1524.         /**

    1525. 

  1525.          * balise : NOBREAK

    1526. 

  1526.          * mode : OUVERTURE

    1527. 

  1527.          *

    1528. 

  1528.          * @param	array	param�tres de l'�l�ment de parsing

    1529. 

  1529.          * @return	null

    1530. 

  1530.          */

    1531. 

  1531.         protected function o_NOBREAK($param)

    1532. 

  1532.         {

    1533. 

  1533.             if ($this->forOneLine)

    1534. 

  1534.                 return false;

    1535. 

  1535.             

    1536. 

  1536.             $this->maxH = 0;

    1537. 

  1537.             

    1538. 

  1538.             // on en cr�� un sous HTML que l'on transforme en PDF

    1539. 

  1539.             // pour analyse les dimensions

    1540. 

  1540.             // et voir si ca rentre

    1541. 

  1541.             $sub = null;

    1542. 

  1542.             $this->CreateSubHTML($sub);

    1543. 

  1543.             $sub->parsing->code = $this->parsing->getLevel($this->parse_pos);

    1544. 

  1544.             $sub->MakeHTMLcode();

    1545. 

  1545.             

    1546. 

  1546.             $y = $this->pdf->getY();

    1547. 

  1547.             if ($sub->maxY < ($this->pdf->getH() - $this->pdf->gettMargin() - $this->pdf->getbMargin()) && $y + $sub->maxY >= ($this->pdf->getH() - $this->pdf->getbMargin()))

    1548. 

  1548.                 $this->setNewPage();

    1549. 

  1549.             $this->destroySubHTML($sub);

    1550. 

  1550.             

    1551. 

  1551.             return true;

    1552. 

  1552.         }

    1553. 

  1553. 

    1554. 

  1554.         /**

    1555. 

  1555.          * balise : NOBREAK

    1556. 

  1556.          * mode : FERMETURE

    1557. 

  1557.          *

    1558. 

  1558.          * @param	array	param�tres de l'�l�ment de parsing

    1559. 

  1559.          * @return	null

    1560. 

  1560.          */

    1561. 

  1561.         protected function c_NOBREAK($param)

    1562. 

  1562.         {

    1563. 

  1563.             if ($this->forOneLine)

    1564. 

  1564.                 return false;

    1565. 

  1565.             

    1566. 

  1566.             $this->maxH = 0;

    1567. 

  1567.             

    1568. 

  1568.             return true;

    1569. 

  1569.         }

    1570. 

  1570. 

    1571. 

  1571.         /**

    1572. 

  1572.          * balise : DIV

    1573. 

  1573.          * mode : OUVERTURE

    1574. 

  1574.          *

    1575. 

  1575.          * @param	array	param�tres de l'�l�ment de parsing

    1576. 

  1576.          * @return	null

    1577. 

  1577.          */

    1578. 

  1578.         protected function o_DIV($param, $other = 'div')

    1579. 

  1579.         {

    1580. 

  1580.             if ($this->forOneLine)

    1581. 

  1581.                 return false;

    1582. 

  1582.             if ($this->DEBUG_actif)

    1583. 

  1583.                 $this->DEBUG_add('DIV', true);

    1584. 

  1584.             

    1585. 

  1585.             $this->style->save();

    1586. 

  1586.             $this->style->analyse($other, $param);

    1587. 

  1587.             $this->style->FontSet();

    1588. 

  1588.             

    1589. 

  1589.             $align_object = null;

    1590. 

  1590.             if ($this->style->value['margin-auto'])

    1591. 

  1591.                 $align_object = 'center';

    1592. 

  1592.             

    1593. 

  1593.             $marge = array();

    1594. 

  1594.             $marge['l'] = $this->style->value['border']['l']['width'] + $this->style->value['padding']['l'] + 0.03;

    1595. 

  1595.             $marge['r'] = $this->style->value['border']['r']['width'] + $this->style->value['padding']['r'] + 0.03;

    1596. 

  1596.             $marge['t'] = $this->style->value['border']['t']['width'] + $this->style->value['padding']['t'] + 0.03;

    1597. 

  1597.             $marge['b'] = $this->style->value['border']['b']['width'] + $this->style->value['padding']['b'] + 0.03;

    1598. 

  1598.             

    1599. 

  1599.             // on extrait tout ce qui est contenu dans la DIV

    1600. 

  1600.             $level = $this->parsing->getLevel($this->parse_pos);

    1601. 

  1601.             

    1602. 

  1602.             // on en cr�� un sous HTML que l'on transforme en PDF

    1603. 

  1603.             // pour analyse les dimensions

    1604. 

  1604.             $w = 0;

    1605. 

  1605.             $h = 0;

    1606. 

  1606.             if (count($level))

    1607. 

  1607.             {

    1608. 

  1608.                 $sub = null;

    1609. 

  1609.                 $this->CreateSubHTML($sub);

    1610. 

  1610.                 $sub->parsing->code = $level;

    1611. 

  1611.                 $sub->MakeHTMLcode();

    1612. 

  1612.                 $w = $sub->maxX;

    1613. 

  1613.                 $h = $sub->maxY;

    1614. 

  1614.                 $this->destroySubHTML($sub);

    1615. 

  1615.             }

    1616. 

  1616.             $w_reel = $w;

    1617. 

  1617.             $h_reel = $h;

    1618. 

  1618.             

    1619. 

  1619.             //			if (($w==0 && $this->style->value['width']==0) || ($w>$this->style->value['width']) || $this->style->value['position']=='absolute')

    1620. 

  1620.             $w += $marge['l'] + $marge['r'] + 0.001;

    1621. 

  1621.             

    1622. 

  1622.             $h += $marge['t'] + $marge['b'] + 0.001;

    1623. 

  1623.             

    1624. 

  1624.             if ($this->style->value['overflow'] == 'hidden')

    1625. 

  1625.             {

    1626. 

  1626.                 $over_w = max($w, $this->style->value['width']);

    1627. 

  1627.                 $over_h = max($h, $this->style->value['height']);

    1628. 

  1628.                 $overflow = true;

    1629. 

  1629.                 $this->style->value['old_maxX'] = $this->maxX;

    1630. 

  1630.                 $this->style->value['old_maxY'] = $this->maxY;

    1631. 

  1631.                 $this->style->value['old_maxH'] = $this->maxH;

    1632. 

  1632.                 $this->style->value['old_overflow'] = $this->isInOverflow;

    1633. 

  1633.                 $this->isInOverflow = true;

    1634. 

  1634.             }

    1635. 

  1635.             else

    1636. 

  1636.             {

    1637. 

  1637.                 $over_w = null;

    1638. 

  1638.                 $over_h = null;

    1639. 

  1639.                 $overflow = false;

    1640. 

  1640.                 $this->style->value['width'] = max($w, $this->style->value['width']);

    1641. 

  1641.                 $this->style->value['height'] = max($h, $this->style->value['height']);

    1642. 

  1642.             }

    1643. 

  1643.             

    1644. 

  1644.             switch ($this->style->value['rotate'])

    1645. 

  1645.             {

    1646. 

  1646.                 case 90 :

    1647. 

  1647.                     $tmp = $over_h;

    1648. 

  1648.                     $over_h = $over_w;

    1649. 

  1649.                     $over_w = $tmp;

    1650. 

  1650.                     $tmp = $h_reel;

    1651. 

  1651.                     $h_reel = $w_reel;

    1652. 

  1652.                     $w_reel = $tmp;

    1653. 

  1653.                     unset($tmp);

    1654. 

  1654.                     $w = $this->style->value['height'];

    1655. 

  1655.                     $h = $this->style->value['width'];

    1656. 

  1656.                     $t_x = - $h;

    1657. 

  1657.                     $t_y = 0;

    1658. 

  1658.                     break;

    1659. 

  1659.                 

    1660. 

  1660.                 case 180 :

    1661. 

  1661.                     $w = $this->style->value['width'];

    1662. 

  1662.                     $h = $this->style->value['height'];

    1663. 

  1663.                     $t_x = - $w;

    1664. 

  1664.                     $t_y = - $h;

    1665. 

  1665.                     break;

    1666. 

  1666.                 

    1667. 

  1667.                 case 270 :

    1668. 

  1668.                     $tmp = $over_h;

    1669. 

  1669.                     $over_h = $over_w;

    1670. 

  1670.                     $over_w = $tmp;

    1671. 

  1671.                     $tmp = $h_reel;

    1672. 

  1672.                     $h_reel = $w_reel;

    1673. 

  1673.                     $w_reel = $tmp;

    1674. 

  1674.                     unset($tmp);

    1675. 

  1675.                     $w = $this->style->value['height'];

    1676. 

  1676.                     $h = $this->style->value['width'];

    1677. 

  1677.                     $t_x = 0;

    1678. 

  1678.                     $t_y = - $w;

    1679. 

  1679.                     break;

    1680. 

  1680.                 

    1681. 

  1681.                 default :

    1682. 

  1682.                     $w = $this->style->value['width'];

    1683. 

  1683.                     $h = $this->style->value['height'];

    1684. 

  1684.                     $t_x = 0;

    1685. 

  1685.                     $t_y = 0;

    1686. 

  1686.                     break;

    1687. 

  1687.             }

    1688. 

  1688.             

    1689. 

  1689.             if (! $this->style->value['position'])

    1690. 

  1690.             {

    1691. 

  1691.                 if ($w < ($this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin()) && $this->pdf->getX() + $w >= ($this->pdf->getW() - $this->pdf->getrMargin()))

    1692. 

  1692.                     $this->o_BR(array());

    1693. 

  1693.                 

    1694. 

  1694.                 if (($h < ($this->pdf->getH() - $this->pdf->gettMargin() - $this->pdf->getbMargin())) && ($this->pdf->getY() + $h >= ($this->pdf->getH() - $this->pdf->getbMargin())) && ! $this->isInOverflow)

    1695. 

  1695.                     $this->setNewPage();

    1696. 

  1696.                 

    1697. 

  1697.      // en cas d'alignement => correction

    1698. 

  1698.                 $old = $this->style->getOldValues();

    1699. 

  1699.                 $parent_w = $old['width'] ? $old['width'] : $this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin();

    1700. 

  1700.                 

    1701. 

  1701.                 if ($parent_w > $w)

    1702. 

  1702.                 {

    1703. 

  1703.                     if ($align_object == 'center')

    1704. 

  1704.                         $this->pdf->setX($this->pdf->getX() + ($parent_w - $w) * 0.5);

    1705. 

  1705.                     else 

    1706. 

  1706.                         if ($align_object == 'right')

    1707. 

  1707.                             $this->pdf->setX($this->pdf->getX() + $parent_w - $w);

    1708. 

  1708.                 }

    1709. 

  1709.                 

    1710. 

  1710.                 $this->style->setPosition();

    1711. 

  1711.             }

    1712. 

  1712.             else

    1713. 

  1713.             {

    1714. 

  1714.                 // en cas d'alignement => correction

    1715. 

  1715.                 $old = $this->style->getOldValues();

    1716. 

  1716.                 $parent_w = $old['width'] ? $old['width'] : $this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin();

    1717. 

  1717.                 

    1718. 

  1718.                 if ($parent_w > $w)

    1719. 

  1719.                 {

    1720. 

  1720.                     if ($align_object == 'center')

    1721. 

  1721.                         $this->pdf->setX($this->pdf->getX() + ($parent_w - $w) * 0.5);

    1722. 

  1722.                     else 

    1723. 

  1723.                         if ($align_object == 'right')

    1724. 

  1724.                             $this->pdf->setX($this->pdf->getX() + $parent_w - $w);

    1725. 

  1725.                 }

    1726. 

  1726.                 

    1727. 

  1727.                 $this->style->setPosition();

    1728. 

  1728.                 $this->saveMax();

    1729. 

  1729.                 $this->saveX = 0;

    1730. 

  1730.                 $this->saveY = 0;

    1731. 

  1731.                 $this->saveH = 0;

    1732. 

  1732.             }

    1733. 

  1733.             

    1734. 

  1734.             if ($this->style->value['rotate'])

    1735. 

  1735.             {

    1736. 

  1736.                 $this->pdf->startTransform();

    1737. 

  1737.                 $this->pdf->setRotation($this->style->value['rotate']);

    1738. 

  1738.                 $this->pdf->setTranslate($t_x, $t_y);

    1739. 

  1739.             }

    1740. 

  1740.             

    1741. 

  1741.             // initialisation du style des bordures de la div

    1742. 

  1742.             $this->drawRectangle($this->style->value['x'], $this->style->value['y'], $this->style->value['width'], $this->style->value['height'], $this->style->value['border'], $this->style->value['padding'], 0, $this->style->value['background']);

    1743. 

  1743.             

    1744. 

  1744.             $marge = array();

    1745. 

  1745.             $marge['l'] = $this->style->value['border']['l']['width'] + $this->style->value['padding']['l'] + 0.03;

    1746. 

  1746.             $marge['r'] = $this->style->value['border']['r']['width'] + $this->style->value['padding']['r'] + 0.03;

    1747. 

  1747.             $marge['t'] = $this->style->value['border']['t']['width'] + $this->style->value['padding']['t'] + 0.03;

    1748. 

  1748.             $marge['b'] = $this->style->value['border']['b']['width'] + $this->style->value['padding']['b'] + 0.03;

    1749. 

  1749.             

    1750. 

  1750.             $this->style->value['width'] -= $marge['l'] + $marge['r'];

    1751. 

  1751.             $this->style->value['height'] -= $marge['t'] + $marge['b'];

    1752. 

  1752.             

    1753. 

  1753.             // positionnement en fonction des alignements

    1754. 

  1754.             $x_corr = 0;

    1755. 

  1755.             $y_corr = 0;

    1756. 

  1756.             if (! $this->sub_part && ! $this->isSubPart)

    1757. 

  1757.             {

    1758. 

  1758.                 switch ($this->style->value['text-align'])

    1759. 

  1759.                 {

    1760. 

  1760.                     case 'right' :

    1761. 

  1761.                         $x_corr = ($this->style->value['width'] - $w_reel);

    1762. 

  1762.                         break;

    1763. 

  1763.                     case 'center' :

    1764. 

  1764.                         $x_corr = ($this->style->value['width'] - $w_reel) * 0.5;

    1765. 

  1765.                         break;

    1766. 

  1766.                 }

    1767. 

  1767.                 if ($x_corr > 0)

    1768. 

  1768.                     $x_corr = 0;

    1769. 

  1769.                 switch ($this->style->value['vertical-align'])

    1770. 

  1770.                 {

    1771. 

  1771.                     case 'bottom' :

    1772. 

  1772.                         $y_corr = ($this->style->value['height'] - $h_reel);

    1773. 

  1773.                         break;

    1774. 

  1774.                     case 'middle' :

    1775. 

  1775.                         $y_corr = ($this->style->value['height'] - $h_reel) * 0.5;

    1776. 

  1776.                         break;

    1777. 

  1777.                 }

    1778. 

  1778.             }

    1779. 

  1779.             

    1780. 

  1780.             if ($overflow)

    1781. 

  1781.             {

    1782. 

  1782.                 $over_w -= $marge['l'] + $marge['r'];

    1783. 

  1783.                 $over_h -= $marge['t'] + $marge['b'];

    1784. 

  1784.                 $this->pdf->clippingPathOpen($this->style->value['x'] + $marge['l'], $this->style->value['y'] + $marge['t'], $this->style->value['width'], $this->style->value['height']);

    1785. 

  1785.                 

    1786. 

  1786.                 $this->style->value['x'] += $x_corr;

    1787. 

  1787.                 // limitation des marges aux dimensions du contenu

    1788. 

  1788.                 $mL = $this->style->value['x'] + $marge['l'];

    1789. 

  1789.                 $mR = $this->pdf->getW() - $mL - $over_w;

    1790. 

  1790.             }

    1791. 

  1791.             else

    1792. 

  1792.             {

    1793. 

  1793.                 // limitation des marges aux dimensions de la div

    1794. 

  1794.                 $mL = $this->style->value['x'] + $marge['l'];

    1795. 

  1795.                 $mR = $this->pdf->getW() - $mL - $this->style->value['width'];

    1796. 

  1796.             }

    1797. 

  1797.             

    1798. 

  1798.             $x = $this->style->value['x'] + $marge['l'];

    1799. 

  1799.             $y = $this->style->value['y'] + $marge['t'] + $y_corr;

    1800. 

  1800.             $this->saveMargin($mL, 0, $mR);

    1801. 

  1801.             $this->pdf->setXY($x, $y);

    1802. 

  1802.             

    1803. 

  1803.             $this->setNewPositionForNewLine();

    1804. 

  1804.             

    1805. 

  1805.             return true;

    1806. 

  1806.         }

    1807. 

  1807. 

    1808. 

  1808.         protected function o_BLOCKQUOTE($param)

    1809. 

  1809.         {

    1810. 

  1810.             return $this->o_DIV($param, 'blockquote');

    1811. 

  1811.         }

    1812. 

  1812. 

    1813. 

  1813.         /**

    1814. 

  1814.          * balise : DIV

    1815. 

  1815.          * mode : FERMETURE

    1816. 

  1816.          *

    1817. 

  1817.          * @param	array	param�tres de l'�l�ment de parsing

    1818. 

  1818.          * @return	null

    1819. 

  1819.          */

    1820. 

  1820.         protected function c_DIV($param)

    1821. 

  1821.         {

    1822. 

  1822.             if ($this->forOneLine)

    1823. 

  1823.                 return false;

    1824. 

  1824.             

    1825. 

  1825.             if ($this->style->value['overflow'] == 'hidden')

    1826. 

  1826.             {

    1827. 

  1827.                 $this->maxX = $this->style->value['old_maxX'];

    1828. 

  1828.                 $this->maxY = $this->style->value['old_maxY'];

    1829. 

  1829.                 $this->maxH = $this->style->value['old_maxH'];

    1830. 

  1830.                 $this->isInOverflow = $this->style->value['old_overflow'];

    1831. 

  1831.                 $this->pdf->clippingPathClose();

    1832. 

  1832.             }

    1833. 

  1833.             

    1834. 

  1834.             if ($this->style->value['rotate'])

    1835. 

  1835.                 $this->pdf->stopTransform();

    1836. 

  1836.             

    1837. 

  1837.             $marge = array();

    1838. 

  1838.             $marge['l'] = $this->style->value['border']['l']['width'] + $this->style->value['padding']['l'] + 0.03;

    1839. 

  1839.             $marge['r'] = $this->style->value['border']['r']['width'] + $this->style->value['padding']['r'] + 0.03;

    1840. 

  1840.             $marge['t'] = $this->style->value['border']['t']['width'] + $this->style->value['padding']['t'] + 0.03;

    1841. 

  1841.             $marge['b'] = $this->style->value['border']['b']['width'] + $this->style->value['padding']['b'] + 0.03;

    1842. 

  1842.             

    1843. 

  1843.             $x = $this->style->value['x'];

    1844. 

  1844.             $y = $this->style->value['y'];

    1845. 

  1845.             $w = $this->style->value['width'] + $marge['l'] + $marge['r'] + $this->style->value['margin']['r'];

    1846. 

  1846.             $h = $this->style->value['height'] + $marge['t'] + $marge['b'] + $this->style->value['margin']['b'];

    1847. 

  1847.             switch ($this->style->value['rotate'])

    1848. 

  1848.             {

    1849. 

  1849.                 case 90 :

    1850. 

  1850.                     $t = $w;

    1851. 

  1851.                     $w = $h;

    1852. 

  1852.                     $h = $t;

    1853. 

  1853.                     break;

    1854. 

  1854.                 

    1855. 

  1855.                 case 270 :

    1856. 

  1856.                     $t = $w;

    1857. 

  1857.                     $w = $h;

    1858. 

  1858.                     $h = $t;

    1859. 

  1859.                     break;

    1860. 

  1860.                 

    1861. 

  1861.                 default :

    1862. 

  1862.                     break;

    1863. 

  1863.             }

    1864. 

  1864.             

    1865. 

  1865.             if ($this->style->value['position'] != 'absolute')

    1866. 

  1866.             {

    1867. 

  1867.                 // position

    1868. 

  1868.                 $this->pdf->setXY($x + $w, $y);

    1869. 

  1869.                 

    1870. 

  1870.                 // position MAX

    1871. 

  1871.                 $this->maxX = max($this->maxX, $x + $w);

    1872. 

  1872.                 $this->maxY = max($this->maxY, $y + $h);

    1873. 

  1873.                 $this->maxH = max($this->maxH, $h);

    1874. 

  1874.             }

    1875. 

  1875.             else

    1876. 

  1876.             {

    1877. 

  1877.                 // position

    1878. 

  1878.                 $this->pdf->setXY($this->style->value['xc'], $this->style->value['yc']);

    1879. 

  1879.                 

    1880. 

  1880.                 $this->loadMax();

    1881. 

  1881.             }

    1882. 

  1882.             

    1883. 

  1883.             $block = ($this->style->value['display'] != 'inline' && $this->style->value['position'] != 'absolute');

    1884. 

  1884.             

    1885. 

  1885.             $this->style->load();

    1886. 

  1886.             $this->style->FontSet();

    1887. 

  1887.             $this->loadMargin();

    1888. 

  1888.             

    1889. 

  1889.             if ($block)

    1890. 

  1890.                 $this->o_BR(array());

    1891. 

  1891.             if ($this->DEBUG_actif)

    1892. 

  1892.                 $this->DEBUG_add('DIV', false);

    1893. 

  1893.             

    1894. 

  1894.             return true;

    1895. 

  1895.         }

    1896. 

  1896. 

    1897. 

  1897.         protected function c_BLOCKQUOTE($param)

    1898. 

  1898.         {

    1899. 

  1899.             return $this->c_DIV($param);

    1900. 

  1900.         }

    1901. 

  1901. 

    1902. 

  1902.         /**

    1903. 

  1903.          * balise : BARCODE

    1904. 

  1904.          * mode : OUVERTURE

    1905. 

  1905.          *

    1906. 

  1906.          * @param	array	param�tres de l'�l�ment de parsing

    1907. 

  1907.          * @return	null

    1908. 

  1908.          */

    1909. 

  1909.         protected function o_BARCODE($param)

    1910. 

  1910.         {

    1911. 

  1911.             // pour compatibilit� < 3.29

    1912. 

  1912.             $lst_barcode = array();

    1913. 

  1913.             $lst_barcode['UPC_A'] = 'UPCA';

    1914. 

  1914.             $lst_barcode['CODE39'] = 'C39';

    1915. 

  1915.             

    1916. 

  1916.             if (! isset($param['type']))

    1917. 

  1917.                 $param['type'] = 'C39';

    1918. 

  1918.             if (! isset($param['value']))

    1919. 

  1919.                 $param['value'] = 0;

    1920. 

  1920.             if (! isset($param['label']))

    1921. 

  1921.                 $param['label'] = 'label';

    1922. 

  1922.             

    1923. 

  1923.             if (! isset($param['style']['color']))

    1924. 

  1924.                 $param['style']['color'] = '#000000';

    1925. 

  1925.             

    1926. 

  1926.             $param['type'] = strtoupper($param['type']);

    1927. 

  1927.             if (isset($lst_barcode[$param['type']]))

    1928. 

  1928.                 $param['type'] = $lst_barcode[$param['type']];

    1929. 

  1929.             

    1930. 

  1930.             $this->style->save();

    1931. 

  1931.             $this->style->analyse('barcode', $param);

    1932. 

  1932.             $this->style->setPosition();

    1933. 

  1933.             $this->style->FontSet();

    1934. 

  1934.             

    1935. 

  1935.             $x = $this->pdf->getX();

    1936. 

  1936.             $y = $this->pdf->getY();

    1937. 

  1937.             $w = $this->style->value['width'];

    1938. 

  1938.             if (! $w)

    1939. 

  1939.                 $w = $this->style->ConvertToMM('30mm');

    1940. 

  1940.             $h = $this->style->value['height'];

    1941. 

  1941.             if (! $h)

    1942. 

  1942.                 $h = $this->style->ConvertToMM('10mm');

    1943. 

  1943.             $txt = ($param['label'] !== 'none' ? $this->style->value['font-size'] : false);

    1944. 

  1944.             $c = $this->style->value['color'];

    1945. 

  1945.             $infos = $this->pdf->myBarcode($param['value'], $param['type'], $x, $y, $w, $h, $txt, $c);

    1946. 

  1946.             

    1947. 

  1947.             // position maximale globale

    1948. 

  1948.             $this->maxX = max($this->maxX, $x + $infos[0]);

    1949. 

  1949.             $this->maxY = max($this->maxY, $y + $infos[1]);

    1950. 

  1950.             $this->maxH = max($this->maxH, $infos[1]);

    1951. 

  1951.             $this->maxE ++;

    1952. 

  1952.             

    1953. 

  1953.             $this->pdf->setXY($x + $infos[0], $y);

    1954. 

  1954.             

    1955. 

  1955.             $this->style->load();

    1956. 

  1956.             $this->style->FontSet();

    1957. 

  1957.             

    1958. 

  1958.             return true;

    1959. 

  1959.         }

    1960. 

  1960. 

    1961. 

  1961.         /**

    1962. 

  1962.          * balise : BARCODE

    1963. 

  1963.          * mode : FERMETURE

    1964. 

  1964.          *

    1965. 

  1965.          * @param	array	param�tres de l'�l�ment de parsing

    1966. 

  1966.          * @return	null

    1967. 

  1967.          */

    1968. 

  1968.         protected function c_BARCODE($param)

    1969. 

  1969.         {

    1970. 

  1970.             // completement inutile

    1971. 

  1971.             

    1972. 

  1972. 

    1973. 

  1973.             return true;

    1974. 

  1974.         }

    1975. 

  1975. 

    1976. 

  1976.         /**

    1977. 

  1977.          * balise : QRCODE

    1978. 

  1978.          * mode : OUVERTURE

    1979. 

  1979.          *

    1980. 

  1980.          * @param	array	param�tres de l'�l�ment de parsing

    1981. 

  1981.          * @return	null

    1982. 

  1982.          */

    1983. 

  1983.         protected function o_QRCODE($param)

    1984. 

  1984.         {

    1985. 

  1985.             if ($this->DEBUG_actif)

    1986. 

  1986.                 $this->DEBUG_add('QRCODE', true);

    1987. 

  1987.             if (! isset($param['value']))

    1988. 

  1988.                 $param['value'] = '';

    1989. 

  1989.             if (! isset($param['ec']))

    1990. 

  1990.                 $param['ec'] = 'H';

    1991. 

  1991.             if (! isset($param['size']))

    1992. 

  1992.                 $param['size'] = '0.6mm';

    1993. 

  1993.             if (! isset($param['style']['color']))

    1994. 

  1994.                 $param['style']['color'] = '#000000';

    1995. 

  1995.             if (! isset($param['style']['background-color']))

    1996. 

  1996.                 $param['style']['background-color'] = '#FFFFFF';

    1997. 

  1997.             

    1998. 

  1998.             if ($param['value'] === '')

    1999. 

  1999.                 return true;

    2000. 

  2000.             

    2001. 

  2001.             $noborder = isset($param['noborder']);

    2002. 

  2002.             

    2003. 

  2003.             $this->style->save();

    2004. 

  2004.             $this->style->analyse('qrcode', $param);

    2005. 

  2005.             $this->style->setPosition();

    2006. 

  2006.             $this->style->FontSet();

    2007. 

  2007.             

    2008. 

  2008.             $x = $this->pdf->getX();

    2009. 

  2009.             $y = $this->pdf->getY();

    2010. 

  2010.             $s = $this->style->ConvertToMM($param['size']);

    2011. 

  2011.             $ec = $param['ec'];

    2012. 

  2012.             if (! in_array($ec, array('L', 'M', 'Q', 'H')))

    2013. 

  2013.                 $ec = 'H';

    2014. 

  2014.             

    2015. 

  2015.             require_once (dirname(__FILE__) . '/qrcode/qrcode.class.php');

    2016. 

  2016.             $qrcode = new QRcode($param['value'], $ec);

    2017. 

  2017.             if ($noborder)

    2018. 

  2018.                 $qrcode->disableBorder();

    2019. 

  2019.             if (! $this->sub_part && ! $this->isSubPart)

    2020. 

  2020.                 $qrcode->displayTCPDF($this->pdf, $x, $y, $s, $this->style->value['background']['color'], $this->style->value['color']);

    2021. 

  2021.             $size = $s * $qrcode->getQrSize();

    2022. 

  2022.             unset($qrcode);

    2023. 

  2023.             

    2024. 

  2024.             // position maximale globale

    2025. 

  2025.             $this->maxX = max($this->maxX, $x + $size);

    2026. 

  2026.             $this->maxY = max($this->maxY, $y + $size);

    2027. 

  2027.             $this->maxH = max($this->maxH, $size);

    2028. 

  2028.             

    2029. 

  2029.             $this->pdf->setX($x + $size);

    2030. 

  2030.             

    2031. 

  2031.             $this->style->load();

    2032. 

  2032.             $this->style->FontSet();

    2033. 

  2033.             

    2034. 

  2034.             return true;

    2035. 

  2035.         }

    2036. 

  2036. 

    2037. 

  2037.         /**

    2038. 

  2038.          * balise : QRCODE

    2039. 

  2039.          * mode : FERMETURE

    2040. 

  2040.          *

    2041. 

  2041.          * @param	array	param�tres de l'�l�ment de parsing

    2042. 

  2042.          * @return	null

    2043. 

  2043.          */

    2044. 

  2044.         protected function c_QRCODE($param)

    2045. 

  2045.         {

    2046. 

  2046.             if ($this->DEBUG_actif)

    2047. 

  2047.                 $this->DEBUG_add('QRCODE', false);

    2048. 

  2048.             

    2049. 

  2049.      // completement inutile

    2050. 

  2050.             return true;

    2051. 

  2051.         }

    2052. 

  2052. 

    2053. 

  2053.         /**

    2054. 

  2054.          * balise : BOOKMARK

    2055. 

  2055.          * mode : OUVERTURE

    2056. 

  2056.          *

    2057. 

  2057.          * @param	array	param�tres de l'�l�ment de parsing

    2058. 

  2058.          * @return	null

    2059. 

  2059.          */

    2060. 

  2060.         protected function o_BOOKMARK($param)

    2061. 

  2061.         {

    2062. 

  2062.             $titre = isset($param['title']) ? trim($param['title']) : '';

    2063. 

  2063.             $level = isset($param['level']) ? floor($param['level']) : 0;

    2064. 

  2064.             

    2065. 

  2065.             if ($level < 0)

    2066. 

  2066.                 $level = 0;

    2067. 

  2067.             if ($titre)

    2068. 

  2068.                 $this->pdf->Bookmark($titre, $level, - 1);

    2069. 

  2069.             

    2070. 

  2070.             return true;

    2071. 

  2071.         }

    2072. 

  2072. 

    2073. 

  2073.         /**

    2074. 

  2074.          * balise : BOOKMARK

    2075. 

  2075.          * mode : FERMETURE

    2076. 

  2076.          *

    2077. 

  2077.          * @param	array	param�tres de l'�l�ment de parsing

    2078. 

  2078.          * @return	null

    2079. 

  2079.          */

    2080. 

  2080.         protected function c_BOOKMARK($param)

    2081. 

  2081.         {

    2082. 

  2082.             // completement inutile

    2083. 

  2083.             

    2084. 

  2084. 

    2085. 

  2085.             return true;

    2086. 

  2086.         }

    2087. 

  2087. 

    2088. 

  2088.         function getElementY($h)

    2089. 

  2089.         {

    2090. 

  2090.             if ($this->sub_part || $this->isSubPart || ! $this->currentH || $this->currentH < $h)

    2091. 

  2091.                 return 0;

    2092. 

  2092.             

    2093. 

  2093.             return ($this->currentH - $h) * 0.8;

    2094. 

  2094.         }

    2095. 

  2095. 

    2096. 

  2096.         /**

    2097. 

  2097.          * balise : WRITE

    2098. 

  2098.          * mode : OUVERTURE

    2099. 

  2099.          *

    2100. 

  2100.          * @param	array	param�tres de l'�l�ment de parsing

    2101. 

  2101.          * @return	null

    2102. 

  2102.          */

    2103. 

  2103.         protected function o_WRITE($param)

    2104. 

  2104.         {

    2105. 

  2105.             $fill = ($this->style->value['background']['color'] !== null && $this->style->value['background']['image'] === null);

    2106. 

  2106.             if (in_array($this->style->value['id_balise'], array('div', 'table', 'tr', 'td', 'th')))

    2107. 

  2107.                 $fill = false;

    2108. 

  2108.             

    2109. 

  2109.      // r�cup�ration du texte � �crire, et conversion

    2110. 

  2110.             $txt = $param['txt'];

    2111. 

  2111.             

    2112. 

  2112.             if ($this->isAfterFloat)

    2113. 

  2113.             {

    2114. 

  2114.                 $txt = ltrim($txt);

    2115. 

  2115.                 $this->isAfterFloat = false;

    2116. 

  2116.             }

    2117. 

  2117.             

    2118. 

  2118.             $txt = str_replace('[[page_cu]]', $this->page, $txt);

    2119. 

  2119.             

    2120. 

  2120.             if ($this->style->value['text-transform'] != 'none')

    2121. 

  2121.             {

    2122. 

  2122.                 if ($this->style->value['text-transform'] == 'capitalize')

    2123. 

  2123.                     $txt = ucwords($txt);

    2124. 

  2124.                 else 

    2125. 

  2125.                     if ($this->style->value['text-transform'] == 'uppercase')

    2126. 

  2126.                         $txt = strtoupper($txt);

    2127. 

  2127.                     else 

    2128. 

  2128.                         if ($this->style->value['text-transform'] == 'lowercase')

    2129. 

  2129.                             $txt = strtolower($txt);

    2130. 

  2130.             }

    2131. 

  2131.             

    2132. 

  2132.             // tailles du texte

    2133. 

  2133.             $h = 1.08 * $this->style->value['font-size'];

    2134. 

  2134.             $dh = $h * $this->style->value['mini-decal'];

    2135. 

  2135.             $lh = $this->style->getLineHeight();

    2136. 

  2136.             

    2137. 

  2137.             // identification de l'alignement

    2138. 

  2138.             $align = 'L';

    2139. 

  2139.             if ($this->style->value['text-align'] == 'li_right')

    2140. 

  2140.             {

    2141. 

  2141.                 $w = $this->style->value['width'];

    2142. 

  2142.                 $align = 'R';

    2143. 

  2143.             }

    2144. 

  2144.             

    2145. 

  2145.             // pr� calcul de la taille de chaque mot et de la phrase complete

    2146. 

  2146.             $w = 0;

    2147. 

  2147.             $words = explode(' ', $txt);

    2148. 

  2148.             foreach ($words as $k => $word)

    2149. 

  2149.             {

    2150. 

  2150.                 $words[$k] = array($word, $this->pdf->GetStringWidth($word));

    2151. 

  2151.                 $w += $words[$k][1];

    2152. 

  2152.             }

    2153. 

  2153.             $space = $this->pdf->GetStringWidth(' ');

    2154. 

  2154.             $w += $space * (count($words) - 1);

    2155. 

  2155.             

    2156. 

  2156.             $curr_pos = 0; // position dans le texte

    2157. 

  2157.             $curr_max = strlen($txt); // taille maxi du texte

    2158. 

  2158.             $maxX = 0; // plus grande largeur du texte apres retour � la ligne

    2159. 

  2159.             $x = $this->pdf->getX(); // position du texte

    2160. 

  2160.             $y = $this->pdf->getY();

    2161. 

  2161.             $dy = $this->getElementY($lh);

    2162. 

  2162.             

    2163. 

  2163.             list($left, $right) = $this->getMargins($y); // marges autorisees

    2164. 

  2164.             $nb = 0; // nbr de lignes d�coup�es

    2165. 

  2165.             

    2166. 

  2166. 

    2167. 

  2167.             // tant que ca ne rentre pas sur la ligne et qu'on a du texte => on d�coupe

    2168. 

  2168.             while ($x + $w > $right && $x < $right && count($words))

    2169. 

  2169.             {

    2170. 

  2170.                 // trouver une phrase qui rentre dans la largeur, en ajoutant les mots 1 � 1

    2171. 

  2171.                 $i = 0;

    2172. 

  2172.                 $old = array('', 0);

    2173. 

  2173.                 $str = $words[0];

    2174. 

  2174.                 while (($x + $str[1]) < $right)

    2175. 

  2175.                 {

    2176. 

  2176.                     $i ++;

    2177. 

  2177.                     

    2178. 

  2178.                     array_shift($words);

    2179. 

  2179.                     $old = $str;

    2180. 

  2180.                     

    2181. 

  2181.                     if (! count($words))

    2182. 

  2182.                         break;

    2183. 

  2183.                     $str[0] .= ' ' . $words[0][0];

    2184. 

  2184.                     $str[1] += $space + $words[0][1];

    2185. 

  2185.                 }

    2186. 

  2186.                 $str = $old;

    2187. 

  2187.                 

    2188. 

  2188.                 // si rien de rentre, et que le premier mot ne rentre de toute facon pas dans une ligne, on le force...

    2189. 

  2189.                 if ($i == 0 && (($left + $str[1]) >= $right))

    2190. 

  2190.                 {

    2191. 

  2191.                     $str = $words[0];

    2192. 

  2192.                     array_shift($words);

    2193. 

  2193.                 }

    2194. 

  2194.                 $curr_pos += ($curr_pos ? 1 : 0) + strlen($str[0]);

    2195. 

  2195.                 

    2196. 

  2196.                 // ecriture du bout de phrase extrait et qui rentre

    2197. 

  2197.                 $wc = ($align == 'L' ? $str[1] : $this->style->value['width']);

    2198. 

  2198.                 if ($right - $left < $wc)

    2199. 

  2199.                     $wc = $right - $left;

    2200. 

  2200.                     /*

    2201. 

  2201. 				if ($this->pdf->ws)

    2202. 

  2202. 				{

    2203. 

  2203. 					$oldSpace = $this->pdf->CurrentFont['cw'][' '];

    2204. 

  2204. 					$this->pdf->CurrentFont['cw'][' ']*=(1.+$this->pdf->ws);

    2205. 

  2205. 					$wc = $str[1];

    2206. 

  2206. 					$this->pdf->CurrentFont['cw'][' '] = $oldSpace;

    2207. 

  2207. 				}

    2208. 

  2208. */

    2209. 

  2209.                 if (strlen($str[0]))

    2210. 

  2210.                 {

    2211. 

  2211.                     $this->pdf->setXY($this->pdf->getX(), $y + $dh + $dy);

    2212. 

  2212.                     $this->pdf->Cell($wc, $h, $str[0], 0, 0, $align, $fill, $this->inLink);

    2213. 

  2213.                     $this->pdf->setXY($this->pdf->getX(), $y);

    2214. 

  2214.                 }

    2215. 

  2215.                 $this->maxH = max($this->maxH, $lh);

    2216. 

  2216.                 

    2217. 

  2217.                 // d�termination de la largeur max

    2218. 

  2218.                 $maxX = max($maxX, $this->pdf->getX());

    2219. 

  2219.                 

    2220. 

  2220.                 // nouvelle position et nouvelle largeur pour la boucle

    2221. 

  2221.                 $w -= $str[1];

    2222. 

  2222.                 $y = $this->pdf->getY();

    2223. 

  2223.                 $x = $this->pdf->getX();

    2224. 

  2224.                 $dy = $this->getElementY($lh);

    2225. 

  2225.                 

    2226. 

  2226.                 // si il reste du text � afficher

    2227. 

  2227.                 if (count($words))

    2228. 

  2228.                 {

    2229. 

  2229.                     $w -= $space;

    2230. 

  2230.                     if ($this->forOneLine)

    2231. 

  2231.                     {

    2232. 

  2232.                         $this->maxE += $i + 1;

    2233. 

  2233.                         $this->maxX = max($this->maxX, $maxX);

    2234. 

  2234.                         return null;

    2235. 

  2235.                     }

    2236. 

  2236.                     

    2237. 

  2237.                     // retour � la ligne

    2238. 

  2238.                     $this->o_BR(array('style' => ''), $curr_pos);

    2239. 

  2239.                     

    2240. 

  2240.                     $y = $this->pdf->getY();

    2241. 

  2241.                     $x = $this->pdf->getX();

    2242. 

  2242.                     $dy = $this->getElementY($lh);

    2243. 

  2243.                     

    2244. 

  2244.                     // si la prochaine ligne ne rentre pas dans la page => nouvelle page

    2245. 

  2245.                     if ($y + $h > $this->pdf->getH() - $this->pdf->getbMargin())

    2246. 

  2246.                         if (! $this->isInOverflow)

    2247. 

  2247.                             $this->setNewPage(null, '', null, $curr_pos);

    2248. 

  2248.                     

    2249. 

  2249.      // ligne supl�mentaire. au bout de 1000 : trop long => erreur

    2250. 

  2250.                     $nb ++;

    2251. 

  2251.                     if ($nb > 1000)

    2252. 

  2252.                     {

    2253. 

  2253.                         $txt = '';

    2254. 

  2254.                         foreach ($words as $k => $word)

    2255. 

  2255.                             $txt .= ($k ? ' ' : '') . $word[0];

    2256. 

  2256.                         HTML2PDF :: makeError(2, __FILE__, __LINE__, array($txt, $right - $left, $w));

    2257. 

  2257.                     }

    2258. 

  2258.                     

    2259. 

  2259.                     list($left, $right) = $this->getMargins($y); // marges autorisees

    2260. 

  2260.                 }

    2261. 

  2261.             }

    2262. 

  2262.             

    2263. 

  2263.             // si il reste du text apres d�coupe, c'est qu'il rentre direct => on l'affiche

    2264. 

  2264.             if (count($words))

    2265. 

  2265.             {

    2266. 

  2266.                 $txt = '';

    2267. 

  2267.                 foreach ($words as $k => $word)

    2268. 

  2268.                     $txt .= ($k ? ' ' : '') . $word[0];

    2269. 

  2269.                     /*

    2270. 

  2270. 				if ($this->pdf->ws)

    2271. 

  2271. 				{

    2272. 

  2272. 					$oldSpace = $this->pdf->CurrentFont['cw'][' '];

    2273. 

  2273. 					$this->pdf->CurrentFont['cw'][' ']*=(1.+$this->pdf->ws);

    2274. 

  2274. 					$w = $this->pdf->GetStringWidth($txt);

    2275. 

  2275. 					$this->pdf->CurrentFont['cw'][' '] = $oldSpace;

    2276. 

  2276. 				}

    2277. 

  2277. */

    2278. 

  2278.                 $this->pdf->setXY($this->pdf->getX(), $y + $dh + $dy);

    2279. 

  2279.                 $this->pdf->Cell(($align == 'L' ? $w : $this->style->value['width']), $h, $txt, 0, 0, $align, $fill, $this->inLink);

    2280. 

  2280.                 $this->pdf->setXY($this->pdf->getX(), $y);

    2281. 

  2281.                 $this->maxH = max($this->maxH, $lh);

    2282. 

  2282.                 $this->maxE += count($words);

    2283. 

  2283.             }

    2284. 

  2284.             

    2285. 

  2285.             // d�termination des positions MAX

    2286. 

  2286.             $maxX = max($maxX, $this->pdf->getX());

    2287. 

  2287.             $maxY = $this->pdf->getY() + $h;

    2288. 

  2288.             

    2289. 

  2289.             // position maximale globale

    2290. 

  2290.             $this->maxX = max($this->maxX, $maxX);

    2291. 

  2291.             $this->maxY = max($this->maxY, $maxY);

    2292. 

  2292.             

    2293. 

  2293.             return true;

    2294. 

  2294.         }

    2295. 

  2295. 

    2296. 

  2296.         /**

    2297. 

  2297.          * tracer une image

    2298. 

  2298.          *

    2299. 

  2299.          * @param	string	nom du fichier source

    2300. 

  2300.          * @return	null

    2301. 

  2301.          */

    2302. 

  2302.         protected function Image($src, $sub_li = false)

    2303. 

  2303.         {

    2304. 

  2304.             // est-ce que c'est une image ?

    2305. 

  2305.             $infos = @GetImageSize($src);

    2306. 

  2306.             

    2307. 

  2307.             if (count($infos) < 2)

    2308. 

  2308.             {

    2309. 

  2309.                 if ($this->testIsImage)

    2310. 

  2310.                 {

    2311. 

  2311.                     HTML2PDF :: makeError(6, __FILE__, __LINE__, $src);

    2312. 

  2312.                     return false;

    2313. 

  2313.                 }

    2314. 

  2314.                 $src = null;

    2315. 

  2315.                 $infos = array(16, 16);

    2316. 

  2316.             }

    2317. 

  2317.             

    2318. 

  2318.             // r�cup�ration des dimensions dans l'unit� du PDF

    2319. 

  2319.             $wi = $infos[0] / $this->pdf->getK();

    2320. 

  2320.             $hi = $infos[1] / $this->pdf->getK();

    2321. 

  2321.             

    2322. 

  2322.             // d�termination des dimensions d'affichage en fonction du style

    2323. 

  2323.             if ($this->style->value['width'] && $this->style->value['height'])

    2324. 

  2324.             {

    2325. 

  2325.                 $w = $this->style->value['width'];

    2326. 

  2326.                 $h = $this->style->value['height'];

    2327. 

  2327.             }

    2328. 

  2328.             else 

    2329. 

  2329.                 if ($this->style->value['width'])

    2330. 

  2330.                 {

    2331. 

  2331.                     $w = $this->style->value['width'];

    2332. 

  2332.                     $h = $hi * $w / $wi;

    2333. 

  2333.                 

    2334. 

  2334.                 }

    2335. 

  2335.                 else 

    2336. 

  2336.                     if ($this->style->value['height'])

    2337. 

  2337.                     {

    2338. 

  2338.                         $h = $this->style->value['height'];

    2339. 

  2339.                         $w = $wi * $h / $hi;

    2340. 

  2340.                     }

    2341. 

  2341.                     else

    2342. 

  2342.                     {

    2343. 

  2343.                         $w = 72. / 96. * $wi;

    2344. 

  2344.                         $h = 72. / 96. * $hi;

    2345. 

  2345.                     }

    2346. 

  2346.             

    2347. 

  2347.             // detection du float

    2348. 

  2348.             $float = $this->style->getFloat();

    2349. 

  2349.             if ($float && $this->maxH)

    2350. 

  2350.                 if (! $this->o_BR(array()))

    2351. 

  2351.                     return false;

    2352. 

  2352.             

    2353. 

  2353.      // position d'affichage

    2354. 

  2354.             $x = $this->pdf->getX();

    2355. 

  2355.             $y = $this->pdf->getY();

    2356. 

  2356.             

    2357. 

  2357.             // si l'image ne rentre pas dans la ligne => nouvelle ligne

    2358. 

  2358.             if (! $float && ($x + $w > $this->pdf->getW() - $this->pdf->getrMargin()) && $this->maxH)

    2359. 

  2359.             {

    2360. 

  2360.                 if ($this->forOneLine)

    2361. 

  2361.                     return null;

    2362. 

  2362.                 

    2363. 

  2363.                 $hnl = $this->style->getLineHeight();

    2364. 

  2364.                 $hnl = max($this->maxH, $hnl);

    2365. 

  2365.                 $this->setNewLine($hnl);

    2366. 

  2366.                 $x = $this->pdf->getX();

    2367. 

  2367.                 $y = $this->pdf->getY();

    2368. 

  2368.             }

    2369. 

  2369.             

    2370. 

  2370.             // si l'image ne rentre pas dans la page => nouvelle page

    2371. 

  2371.             if (($y + $h > $this->pdf->getH() - $this->pdf->getbMargin()) && ! $this->isInOverflow)

    2372. 

  2372.             {

    2373. 

  2373.                 $this->setNewPage();

    2374. 

  2374.                 $x = $this->pdf->getX();

    2375. 

  2375.                 $y = $this->pdf->getY();

    2376. 

  2376.             }

    2377. 

  2377.             

    2378. 

  2378.             // correction pour l'affichage d'une puce image

    2379. 

  2379.             $hT = 0.80 * $this->style->value['font-size'];

    2380. 

  2380.             if ($sub_li && $h < $hT)

    2381. 

  2381.             {

    2382. 

  2382.                 $y += ($hT - $h);

    2383. 

  2383.             }

    2384. 

  2384.             

    2385. 

  2385.             $yc = $y - $this->style->value['margin']['t'];

    2386. 

  2386.             

    2387. 

  2387.             // d�termination de la position r�elle d'affichage en fonction du text-align du parent

    2388. 

  2388.             $old = $this->style->getOldValues();

    2389. 

  2389.             

    2390. 

  2390.             if ($old['width'])

    2391. 

  2391.             {

    2392. 

  2392.                 $parent_w = $old['width'];

    2393. 

  2393.                 $parent_x = $x;

    2394. 

  2394.             }

    2395. 

  2395.             else

    2396. 

  2396.             {

    2397. 

  2397.                 $parent_w = $this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin();

    2398. 

  2398.                 $parent_x = $this->pdf->getlMargin();

    2399. 

  2399.             }

    2400. 

  2400.             

    2401. 

  2401.             if ($float)

    2402. 

  2402.             {

    2403. 

  2403.                 list($lx, $rx) = $this->getMargins($yc);

    2404. 

  2404.                 $parent_x = $lx;

    2405. 

  2405.                 $parent_w = $rx - $lx;

    2406. 

  2406.             }

    2407. 

  2407.             

    2408. 

  2408.             if ($parent_w > $w && $float != 'left')

    2409. 

  2409.             {

    2410. 

  2410.                 if ($float == 'right' || $this->style->value['text-align'] == 'li_right')

    2411. 

  2411.                     $x = $parent_x + $parent_w - $w - $this->style->value['margin']['r'] - $this->style->value['margin']['l'];

    2412. 

  2412.             }

    2413. 

  2413.             

    2414. 

  2414.             // affichage de l'image, et positionnement � la suite

    2415. 

  2415.             if (! $this->sub_part && ! $this->isSubPart)

    2416. 

  2416.             {

    2417. 

  2417.                 if ($src)

    2418. 

  2418.                     $this->pdf->Image($src, $x, $y, $w, $h, '', $this->inLink);

    2419. 

  2419.                 else

    2420. 

  2420.                 {

    2421. 

  2421.                     $this->pdf->setFillColorArray(array(240, 220, 220));

    2422. 

  2422.                     $this->pdf->Rect($x, $y, $w, $h, 'F');

    2423. 

  2423.                 }

    2424. 

  2424.             }

    2425. 

  2425.             

    2426. 

  2426.             $x -= $this->style->value['margin']['l'];

    2427. 

  2427.             $y -= $this->style->value['margin']['t'];

    2428. 

  2428.             $w += $this->style->value['margin']['l'] + $this->style->value['margin']['r'];

    2429. 

  2429.             $h += $this->style->value['margin']['t'] + $this->style->value['margin']['b'];

    2430. 

  2430.             

    2431. 

  2431.             if ($float == 'left')

    2432. 

  2432.             {

    2433. 

  2433.                 $this->maxX = max($this->maxX, $x + $w);

    2434. 

  2434.                 $this->maxY = max($this->maxY, $y + $h);

    2435. 

  2435.                 

    2436. 

  2436.                 $this->addMargins($float, $x, $y, $x + $w, $y + $h);

    2437. 

  2437.                 

    2438. 

  2438.                 list($lx, $rx) = $this->getMargins($yc);

    2439. 

  2439.                 $this->pdf->setXY($lx, $yc);

    2440. 

  2440.             }

    2441. 

  2441.             else 

    2442. 

  2442.                 if ($float == 'right')

    2443. 

  2443.                 {

    2444. 

  2444.                     //				$this->maxX = max($this->maxX, $x+$w);

    2445. 

  2445.                     $this->maxY = max($this->maxY, $y + $h);

    2446. 

  2446.                     

    2447. 

  2447.                     $this->addMargins($float, $x, $y, $x + $w, $y + $h);

    2448. 

  2448.                     

    2449. 

  2449.                     list($lx, $rx) = $this->getMargins($yc);

    2450. 

  2450.                     $this->pdf->setXY($lx, $yc);

    2451. 

  2451.                 }

    2452. 

  2452.                 else

    2453. 

  2453.                 {

    2454. 

  2454.                     $this->pdf->setX($x + $w);

    2455. 

  2455.                     $this->maxX = max($this->maxX, $x + $w);

    2456. 

  2456.                     $this->maxY = max($this->maxY, $y + $h);

    2457. 

  2457.                     $this->maxH = max($this->maxH, $h);

    2458. 

  2458.                 }

    2459. 

  2459.             return true;

    2460. 

  2460.         }

    2461. 

  2461. 

    2462. 

  2462.         /**

    2463. 

  2463.          * Tracer un rectanble

    2464. 

  2464.          *

    2465. 

  2465.          * @param	float	position X

    2466. 

  2466.          * @param	float	position Y

    2467. 

  2467.          * @param	float	Largeur

    2468. 

  2468.          * @param	float	Hauteur

    2469. 

  2469.          * @param	array	Tableau de style de d�finition des borders

    2470. 

  2470.          * @param	float	padding - marge int�rieur au rectangle => non utile mais on le passe en param�tre

    2471. 

  2471.          * @param	float	margin - marge exterieur au rectangle

    2472. 

  2472.          * @param	array	Tableau de style de d�finition du background

    2473. 

  2473.          * @return	null

    2474. 

  2474.          */

    2475. 

  2475.         protected function drawRectangle($x, $y, $w, $h, $border, $padding, $margin, $background)

    2476. 

  2476.         {

    2477. 

  2477.             if ($this->sub_part || $this->isSubPart)

    2478. 

  2478.                 return false;

    2479. 

  2479.             if ($h === null)

    2480. 

  2480.                 return false;

    2481. 

  2481.             

    2482. 

  2482.             $x += $margin;

    2483. 

  2483.             $y += $margin;

    2484. 

  2484.             $w -= $margin * 2;

    2485. 

  2485.             $h -= $margin * 2;

    2486. 

  2486.             

    2487. 

  2487.             // r�cup�ration des radius

    2488. 

  2488.             $out_TL = $border['radius']['tl'];

    2489. 

  2489.             $out_TR = $border['radius']['tr'];

    2490. 

  2490.             $out_BR = $border['radius']['br'];

    2491. 

  2491.             $out_BL = $border['radius']['bl'];

    2492. 

  2492.             

    2493. 

  2493.             // verification des coins en radius

    2494. 

  2494.             $out_TL = ($out_TL[0] && $out_TL[1]) ? $out_TL : null;

    2495. 

  2495.             $out_TR = ($out_TR[0] && $out_TR[1]) ? $out_TR : null;

    2496. 

  2496.             $out_BR = ($out_BR[0] && $out_BR[1]) ? $out_BR : null;

    2497. 

  2497.             $out_BL = ($out_BL[0] && $out_BL[1]) ? $out_BL : null;

    2498. 

  2498.             

    2499. 

  2499.             $in_TL = $out_TL;

    2500. 

  2500.             $in_TR = $out_TR;

    2501. 

  2501.             $in_BR = $out_BR;

    2502. 

  2502.             $in_BL = $out_BL;

    2503. 

  2503.             

    2504. 

  2504.             if (is_array($in_TL))

    2505. 

  2505.             {

    2506. 

  2506.                 $in_TL[0] -= $border['l']['width'];

    2507. 

  2507.                 $in_TL[1] -= $border['t']['width'];

    2508. 

  2508.             }

    2509. 

  2509.             if (is_array($in_TR))

    2510. 

  2510.             {

    2511. 

  2511.                 $in_TR[0] -= $border['r']['width'];

    2512. 

  2512.                 $in_TR[1] -= $border['t']['width'];

    2513. 

  2513.             }

    2514. 

  2514.             if (is_array($in_BR))

    2515. 

  2515.             {

    2516. 

  2516.                 $in_BR[0] -= $border['r']['width'];

    2517. 

  2517.                 $in_BR[1] -= $border['b']['width'];

    2518. 

  2518.             }

    2519. 

  2519.             if (is_array($in_BL))

    2520. 

  2520.             {

    2521. 

  2521.                 $in_BL[0] -= $border['l']['width'];

    2522. 

  2522.                 $in_BL[1] -= $border['b']['width'];

    2523. 

  2523.             }

    2524. 

  2524.             

    2525. 

  2525.             if ($in_TL[0] <= 0 || $in_TL[1] <= 0)

    2526. 

  2526.                 $in_TL = null;

    2527. 

  2527.             if ($in_TR[0] <= 0 || $in_TR[1] <= 0)

    2528. 

  2528.                 $in_TR = null;

    2529. 

  2529.             if ($in_BR[0] <= 0 || $in_BR[1] <= 0)

    2530. 

  2530.                 $in_BR = null;

    2531. 

  2531.             if ($in_BL[0] <= 0 || $in_BL[1] <= 0)

    2532. 

  2532.                 $in_BL = null;

    2533. 

  2533.             

    2534. 

  2534.      // traitement de la couleur de fond

    2535. 

  2535.             $STYLE = '';

    2536. 

  2536.             if ($background['color'])

    2537. 

  2537.             {

    2538. 

  2538.                 $this->pdf->setFillColorArray($background['color']);

    2539. 

  2539.                 $STYLE .= 'F';

    2540. 

  2540.             }

    2541. 

  2541.             

    2542. 

  2542.             if ($STYLE)

    2543. 

  2543.             {

    2544. 

  2544.                 $this->pdf->clippingPathOpen($x, $y, $w, $h, $out_TL, $out_TR, $out_BL, $out_BR);

    2545. 

  2545.                 $this->pdf->Rect($x, $y, $w, $h, $STYLE);

    2546. 

  2546.                 $this->pdf->clippingPathClose();

    2547. 

  2547.             }

    2548. 

  2548.             

    2549. 

  2549.             // traitement de l'image de fond

    2550. 

  2550.             if ($background['image'])

    2551. 

  2551.             {

    2552. 

  2552.                 $i_name = $background['image'];

    2553. 

  2553.                 $i_position = $background['position'] !== null ? $background['position'] : array(0, 0);

    2554. 

  2554.                 $i_repeat = $background['repeat'] !== null ? $background['repeat'] : array(true, true);

    2555. 

  2555.                 

    2556. 

  2556.                 // taile du fond (il faut retirer les borders

    2557. 

  2557.                 $b_x = $x;

    2558. 

  2558.                 $b_y = $y;

    2559. 

  2559.                 $b_w = $w;

    2560. 

  2560.                 $b_h = $h;

    2561. 

  2561.                 

    2562. 

  2562.                 if ($border['b']['width'])

    2563. 

  2563.                 {

    2564. 

  2564.                     $b_h -= $border['b']['width'];

    2565. 

  2565.                 }

    2566. 

  2566.                 if ($border['l']['width'])

    2567. 

  2567.                 {

    2568. 

  2568.                     $b_w -= $border['l']['width'];

    2569. 

  2569.                     $b_x += $border['l']['width'];

    2570. 

  2570.                 }

    2571. 

  2571.                 if ($border['t']['width'])

    2572. 

  2572.                 {

    2573. 

  2573.                     $b_h -= $border['t']['width'];

    2574. 

  2574.                     $b_y += $border['t']['width'];

    2575. 

  2575.                 }

    2576. 

  2576.                 if ($border['r']['width'])

    2577. 

  2577.                 {

    2578. 

  2578.                     $b_w -= $border['r']['width'];

    2579. 

  2579.                 }

    2580. 

  2580.                 

    2581. 

  2581.                 // est-ce que c'est une image ?

    2582. 

  2582.                 $i_infos = @GetImageSize($i_name);

    2583. 

  2583.                 

    2584. 

  2584.                 if (count($i_infos) < 2)

    2585. 

  2585.                 {

    2586. 

  2586.                     if ($this->testIsImage)

    2587. 

  2587.                     {

    2588. 

  2588.                         HTML2PDF :: makeError(6, __FILE__, __LINE__, $i_name);

    2589. 

  2589.                         return false;

    2590. 

  2590.                     }

    2591. 

  2591.                 }

    2592. 

  2592.                 else

    2593. 

  2593.                 {

    2594. 

  2594.                     // r�cup�ration des dimensions dans l'unit� du PDF

    2595. 

  2595.                     $i_width = 72. / 96. * $i_infos[0] / $this->pdf->getK();

    2596. 

  2596.                     $i_height = 72. / 96. * $i_infos[1] / $this->pdf->getK();

    2597. 

  2597.                     

    2598. 

  2598.                     if ($i_repeat[0])

    2599. 

  2599.                         $i_position[0] = $b_x;

    2600. 

  2600.                     else 

    2601. 

  2601.                         if (preg_match('/^([-]?[0-9\.]+)%/isU', $i_position[0], $match))

    2602. 

  2602.                             $i_position[0] = $b_x + $match[1] * ($b_w - $i_width) / 100;

    2603. 

  2603.                         else

    2604. 

  2604.                             $i_position[0] = $b_x + $i_position[0];

    2605. 

  2605.                     

    2606. 

  2606.                     if ($i_repeat[1])

    2607. 

  2607.                         $i_position[1] = $b_y;

    2608. 

  2608.                     else 

    2609. 

  2609.                         if (preg_match('/^([-]?[0-9\.]+)%/isU', $i_position[1], $match))

    2610. 

  2610.                             $i_position[1] = $b_y + $match[1] * ($b_h - $i_height) / 100;

    2611. 

  2611.                         else

    2612. 

  2612.                             $i_position[1] = $b_y + $i_position[1];

    2613. 

  2613.                     

    2614. 

  2614.                     $i_x_min = $b_x;

    2615. 

  2615.                     $i_x_max = $b_x + $b_w;

    2616. 

  2616.                     $i_y_min = $b_y;

    2617. 

  2617.                     $i_y_max = $b_y + $b_h;

    2618. 

  2618.                     

    2619. 

  2619.                     if (! $i_repeat[0] && ! $i_repeat[1])

    2620. 

  2620.                     {

    2621. 

  2621.                         $i_x_min = $i_position[0];

    2622. 

  2622.                         $i_x_max = $i_position[0] + $i_width;

    2623. 

  2623.                         $i_y_min = $i_position[1];

    2624. 

  2624.                         $i_y_max = $i_position[1] + $i_height;

    2625. 

  2625.                     }

    2626. 

  2626.                     else 

    2627. 

  2627.                         if ($i_repeat[0] && ! $i_repeat[1])

    2628. 

  2628.                         {

    2629. 

  2629.                             $i_y_min = $i_position[1];

    2630. 

  2630.                             $i_y_max = $i_position[1] + $i_height;

    2631. 

  2631.                         }

    2632. 

  2632.                         elseif (! $i_repeat[0] && $i_repeat[1])

    2633. 

  2633.                         {

    2634. 

  2634.                             $i_x_min = $i_position[0];

    2635. 

  2635.                             $i_x_max = $i_position[0] + $i_width;

    2636. 

  2636.                         }

    2637. 

  2637.                     

    2638. 

  2638.                     $this->pdf->clippingPathOpen($b_x, $b_y, $b_w, $b_h, $in_TL, $in_TR, $in_BL, $in_BR);

    2639. 

  2639.                     for($i_y = $i_y_min; $i_y < $i_y_max; $i_y += $i_height)

    2640. 

  2640.                     {

    2641. 

  2641.                         for($i_x = $i_x_min; $i_x < $i_x_max; $i_x += $i_width)

    2642. 

  2642.                         {

    2643. 

  2643.                             $c_x = null;

    2644. 

  2644.                             $c_y = null;

    2645. 

  2645.                             $c_w = $i_width;

    2646. 

  2646.                             $c_h = $i_height;

    2647. 

  2647.                             if ($i_y_max - $i_y < $i_height)

    2648. 

  2648.                             {

    2649. 

  2649.                                 $c_x = $i_x;

    2650. 

  2650.                                 $c_y = $i_y;

    2651. 

  2651.                                 $c_h = $i_y_max - $i_y;

    2652. 

  2652.                             }

    2653. 

  2653.                             if ($i_x_max - $i_x < $i_width)

    2654. 

  2654.                             {

    2655. 

  2655.                                 $c_x = $i_x;

    2656. 

  2656.                                 $c_y = $i_y;

    2657. 

  2657.                                 $c_w = $i_x_max - $i_x;

    2658. 

  2658.                             }

    2659. 

  2659.                             

    2660. 

  2660.                             $this->pdf->Image($i_name, $i_x, $i_y, $i_width, $i_height, '', '');

    2661. 

  2661.                         }

    2662. 

  2662.                     }

    2663. 

  2663.                     $this->pdf->clippingPathClose();

    2664. 

  2664.                 }

    2665. 

  2665.             }

    2666. 

  2666.             

    2667. 

  2667.             $x -= 0.01;

    2668. 

  2668.             $y -= 0.01;

    2669. 

  2669.             $w += 0.02;

    2670. 

  2670.             $h += 0.02;

    2671. 

  2671.             if ($border['l']['width'])

    2672. 

  2672.                 $border['l']['width'] += 0.02;

    2673. 

  2673.             if ($border['t']['width'])

    2674. 

  2674.                 $border['t']['width'] += 0.02;

    2675. 

  2675.             if ($border['r']['width'])

    2676. 

  2676.                 $border['r']['width'] += 0.02;

    2677. 

  2677.             if ($border['b']['width'])

    2678. 

  2678.                 $border['b']['width'] += 0.02;

    2679. 

  2679.             

    2680. 

  2680.             $Bl = ($border['l']['width'] && $border['l']['color'][0] !== null);

    2681. 

  2681.             $Bt = ($border['t']['width'] && $border['t']['color'][0] !== null);

    2682. 

  2682.             $Br = ($border['r']['width'] && $border['r']['color'][0] !== null);

    2683. 

  2683.             $Bb = ($border['b']['width'] && $border['b']['color'][0] !== null);

    2684. 

  2684.             

    2685. 

  2685.             if (is_array($out_BL) && ($Bb || $Bl))

    2686. 

  2686.             {

    2687. 

  2687.                 if ($in_BL)

    2688. 

  2688.                 {

    2689. 

  2689.                     $courbe = array();

    2690. 

  2690.                     $courbe[] = $x + $out_BL[0];

    2691. 

  2691.                     $courbe[] = $y + $h;

    2692. 

  2692.                     $courbe[] = $x;

    2693. 

  2693.                     $courbe[] = $y + $h - $out_BL[1];

    2694. 

  2694.                     $courbe[] = $x + $out_BL[0];

    2695. 

  2695.                     $courbe[] = $y + $h - $border['b']['width'];

    2696. 

  2696.                     $courbe[] = $x + $border['l']['width'];

    2697. 

  2697.                     $courbe[] = $y + $h - $out_BL[1];

    2698. 

  2698.                     $courbe[] = $x + $out_BL[0];

    2699. 

  2699.                     $courbe[] = $y + $h - $out_BL[1];

    2700. 

  2700.                 }

    2701. 

  2701.                 else

    2702. 

  2702.                 {

    2703. 

  2703.                     $courbe = array();

    2704. 

  2704.                     $courbe[] = $x + $out_BL[0];

    2705. 

  2705.                     $courbe[] = $y + $h;

    2706. 

  2706.                     $courbe[] = $x;

    2707. 

  2707.                     $courbe[] = $y + $h - $out_BL[1];

    2708. 

  2708.                     $courbe[] = $x + $border['l']['width'];

    2709. 

  2709.                     $courbe[] = $y + $h - $border['b']['width'];

    2710. 

  2710.                     $courbe[] = $x + $out_BL[0];

    2711. 

  2711.                     $courbe[] = $y + $h - $out_BL[1];

    2712. 

  2712.                 }

    2713. 

  2713.                 $this->drawCourbe($courbe, $border['l']['color']);

    2714. 

  2714.             }

    2715. 

  2715.             

    2716. 

  2716.             if (is_array($out_TL) && ($Bt || $Bl))

    2717. 

  2717.             {

    2718. 

  2718.                 if ($in_TL)

    2719. 

  2719.                 {

    2720. 

  2720.                     $courbe = array();

    2721. 

  2721.                     $courbe[] = $x;

    2722. 

  2722.                     $courbe[] = $y + $out_TL[1];

    2723. 

  2723.                     $courbe[] = $x + $out_TL[0];

    2724. 

  2724.                     $courbe[] = $y;

    2725. 

  2725.                     $courbe[] = $x + $border['l']['width'];

    2726. 

  2726.                     $courbe[] = $y + $out_TL[1];

    2727. 

  2727.                     $courbe[] = $x + $out_TL[0];

    2728. 

  2728.                     $courbe[] = $y + $border['t']['width'];

    2729. 

  2729.                     $courbe[] = $x + $out_TL[0];

    2730. 

  2730.                     $courbe[] = $y + $out_TL[1];

    2731. 

  2731.                 }

    2732. 

  2732.                 else

    2733. 

  2733.                 {

    2734. 

  2734.                     $courbe = array();

    2735. 

  2735.                     $courbe[] = $x;

    2736. 

  2736.                     $courbe[] = $y + $out_TL[1];

    2737. 

  2737.                     $courbe[] = $x + $out_TL[0];

    2738. 

  2738.                     $courbe[] = $y;

    2739. 

  2739.                     $courbe[] = $x + $border['l']['width'];

    2740. 

  2740.                     $courbe[] = $y + $border['t']['width'];

    2741. 

  2741.                     $courbe[] = $x + $out_TL[0];

    2742. 

  2742.                     $courbe[] = $y + $out_TL[1];

    2743. 

  2743.                 }

    2744. 

  2744.                 $this->drawCourbe($courbe, $border['t']['color']);

    2745. 

  2745.             }

    2746. 

  2746.             

    2747. 

  2747.             if (is_array($out_TR) && ($Bt || $Br))

    2748. 

  2748.             {

    2749. 

  2749.                 if ($in_TR)

    2750. 

  2750.                 {

    2751. 

  2751.                     $courbe = array();

    2752. 

  2752.                     $courbe[] = $x + $w - $out_TR[0];

    2753. 

  2753.                     $courbe[] = $y;

    2754. 

  2754.                     $courbe[] = $x + $w;

    2755. 

  2755.                     $courbe[] = $y + $out_TR[1];

    2756. 

  2756.                     $courbe[] = $x + $w - $out_TR[0];

    2757. 

  2757.                     $courbe[] = $y + $border['t']['width'];

    2758. 

  2758.                     $courbe[] = $x + $w - $border['r']['width'];

    2759. 

  2759.                     $courbe[] = $y + $out_TR[1];

    2760. 

  2760.                     $courbe[] = $x + $w - $out_TR[0];

    2761. 

  2761.                     $courbe[] = $y + $out_TR[1];

    2762. 

  2762.                 }

    2763. 

  2763.                 else

    2764. 

  2764.                 {

    2765. 

  2765.                     $courbe = array();

    2766. 

  2766.                     $courbe[] = $x + $w - $out_TR[0];

    2767. 

  2767.                     $courbe[] = $y;

    2768. 

  2768.                     $courbe[] = $x + $w;

    2769. 

  2769.                     $courbe[] = $y + $out_TR[1];

    2770. 

  2770.                     $courbe[] = $x + $w - $border['r']['width'];

    2771. 

  2771.                     $courbe[] = $y + $border['t']['width'];

    2772. 

  2772.                     $courbe[] = $x + $w - $out_TR[0];

    2773. 

  2773.                     $courbe[] = $y + $out_TR[1];

    2774. 

  2774.                 }

    2775. 

  2775.                 $this->drawCourbe($courbe, $border['r']['color']);

    2776. 

  2776.             }

    2777. 

  2777.             

    2778. 

  2778.             if (is_array($out_BR) && ($Bb || $Br))

    2779. 

  2779.             {

    2780. 

  2780.                 if ($in_BR)

    2781. 

  2781.                 {

    2782. 

  2782.                     $courbe = array();

    2783. 

  2783.                     $courbe[] = $x + $w;

    2784. 

  2784.                     $courbe[] = $y + $h - $out_BR[1];

    2785. 

  2785.                     $courbe[] = $x + $w - $out_BR[0];

    2786. 

  2786.                     $courbe[] = $y + $h;

    2787. 

  2787.                     $courbe[] = $x + $w - $border['r']['width'];

    2788. 

  2788.                     $courbe[] = $y + $h - $out_BR[1];

    2789. 

  2789.                     $courbe[] = $x + $w - $out_BR[0];

    2790. 

  2790.                     $courbe[] = $y + $h - $border['b']['width'];

    2791. 

  2791.                     $courbe[] = $x + $w - $out_BR[0];

    2792. 

  2792.                     $courbe[] = $y + $h - $out_BR[1];

    2793. 

  2793.                 }

    2794. 

  2794.                 else

    2795. 

  2795.                 {

    2796. 

  2796.                     $courbe = array();

    2797. 

  2797.                     $courbe[] = $x + $w;

    2798. 

  2798.                     $courbe[] = $y + $h - $out_BR[1];

    2799. 

  2799.                     $courbe[] = $x + $w - $out_BR[0];

    2800. 

  2800.                     $courbe[] = $y + $h;

    2801. 

  2801.                     $courbe[] = $x + $w - $border['r']['width'];

    2802. 

  2802.                     $courbe[] = $y + $h - $border['b']['width'];

    2803. 

  2803.                     $courbe[] = $x + $w - $out_BR[0];

    2804. 

  2804.                     $courbe[] = $y + $h - $out_BR[1];

    2805. 

  2805.                 }

    2806. 

  2806.                 $this->drawCourbe($courbe, $border['b']['color']);

    2807. 

  2807.             }

    2808. 

  2808.             

    2809. 

  2809.             if ($Bl)

    2810. 

  2810.             {

    2811. 

  2811.                 $pt = array();

    2812. 

  2812.                 $pt[] = $x;

    2813. 

  2813.                 $pt[] = $y + $h;

    2814. 

  2814.                 $pt[] = $x;

    2815. 

  2815.                 $pt[] = $y + $h - $border['b']['width'];

    2816. 

  2816.                 $pt[] = $x;

    2817. 

  2817.                 $pt[] = $y + $border['t']['width'];

    2818. 

  2818.                 $pt[] = $x;

    2819. 

  2819.                 $pt[] = $y;

    2820. 

  2820.                 $pt[] = $x + $border['l']['width'];

    2821. 

  2821.                 $pt[] = $y + $border['t']['width'];

    2822. 

  2822.                 $pt[] = $x + $border['l']['width'];

    2823. 

  2823.                 $pt[] = $y + $h - $border['b']['width'];

    2824. 

  2824.                 

    2825. 

  2825.                 $bord = 3;

    2826. 

  2826.                 if (is_array($out_BL))

    2827. 

  2827.                 {

    2828. 

  2828.                     $bord -= 1;

    2829. 

  2829.                     $pt[3] -= $out_BL[1] - $border['b']['width'];

    2830. 

  2830.                     if ($in_BL)

    2831. 

  2831.                         $pt[11] -= $in_BL[1];

    2832. 

  2832.                     unset($pt[0]);

    2833. 

  2833.                     unset($pt[1]);

    2834. 

  2834.                 }

    2835. 

  2835.                 if (is_array($out_TL))

    2836. 

  2836.                 {

    2837. 

  2837.                     $bord -= 2;

    2838. 

  2838.                     $pt[5] += $out_TL[1] - $border['t']['width'];

    2839. 

  2839.                     if ($in_TL)

    2840. 

  2840.                         $pt[9] += $in_TL[1];

    2841. 

  2841.                     unset($pt[6]);

    2842. 

  2842.                     unset($pt[7]);

    2843. 

  2843.                 }

    2844. 

  2844.                 

    2845. 

  2845.                 $pt = array_values($pt);

    2846. 

  2846.                 $this->drawLine($pt, $border['l']['color'], $border['l']['type'], $border['l']['width'], $bord);

    2847. 

  2847.             }

    2848. 

  2848.             

    2849. 

  2849.             if ($Bt)

    2850. 

  2850.             {

    2851. 

  2851.                 $pt = array();

    2852. 

  2852.                 $pt[] = $x;

    2853. 

  2853.                 $pt[] = $y;

    2854. 

  2854.                 $pt[] = $x + $border['l']['width'];

    2855. 

  2855.                 $pt[] = $y;

    2856. 

  2856.                 $pt[] = $x + $w - $border['r']['width'];

    2857. 

  2857.                 $pt[] = $y;

    2858. 

  2858.                 $pt[] = $x + $w;

    2859. 

  2859.                 $pt[] = $y;

    2860. 

  2860.                 $pt[] = $x + $w - $border['r']['width'];

    2861. 

  2861.                 $pt[] = $y + $border['t']['width'];

    2862. 

  2862.                 $pt[] = $x + $border['l']['width'];

    2863. 

  2863.                 $pt[] = $y + $border['t']['width'];

    2864. 

  2864.                 

    2865. 

  2865.                 $bord = 3;

    2866. 

  2866.                 if (is_array($out_TL))

    2867. 

  2867.                 {

    2868. 

  2868.                     $bord -= 1;

    2869. 

  2869.                     $pt[2] += $out_TL[0] - $border['l']['width'];

    2870. 

  2870.                     if ($in_TL)

    2871. 

  2871.                         $pt[10] += $in_TL[0];

    2872. 

  2872.                     unset($pt[0]);

    2873. 

  2873.                     unset($pt[1]);

    2874. 

  2874.                 }

    2875. 

  2875.                 if (is_array($out_TR))

    2876. 

  2876.                 {

    2877. 

  2877.                     $bord -= 2;

    2878. 

  2878.                     $pt[4] -= $out_TR[0] - $border['r']['width'];

    2879. 

  2879.                     if ($in_TR)

    2880. 

  2880.                         $pt[8] -= $in_TR[0];

    2881. 

  2881.                     unset($pt[6]);

    2882. 

  2882.                     unset($pt[7]);

    2883. 

  2883.                 }

    2884. 

  2884.                 

    2885. 

  2885.                 $pt = array_values($pt);

    2886. 

  2886.                 $this->drawLine($pt, $border['t']['color'], $border['t']['type'], $border['t']['width'], $bord);

    2887. 

  2887.             }

    2888. 

  2888.             

    2889. 

  2889.             if ($Br)

    2890. 

  2890.             {

    2891. 

  2891.                 $pt = array();

    2892. 

  2892.                 $pt[] = $x + $w;

    2893. 

  2893.                 $pt[] = $y;

    2894. 

  2894.                 $pt[] = $x + $w;

    2895. 

  2895.                 $pt[] = $y + $border['t']['width'];

    2896. 

  2896.                 $pt[] = $x + $w;

    2897. 

  2897.                 $pt[] = $y + $h - $border['b']['width'];

    2898. 

  2898.                 $pt[] = $x + $w;

    2899. 

  2899.                 $pt[] = $y + $h;

    2900. 

  2900.                 $pt[] = $x + $w - $border['r']['width'];

    2901. 

  2901.                 $pt[] = $y + $h - $border['b']['width'];

    2902. 

  2902.                 $pt[] = $x + $w - $border['r']['width'];

    2903. 

  2903.                 $pt[] = $y + $border['t']['width'];

    2904. 

  2904.                 

    2905. 

  2905.                 $bord = 3;

    2906. 

  2906.                 if (is_array($out_TR))

    2907. 

  2907.                 {

    2908. 

  2908.                     $bord -= 1;

    2909. 

  2909.                     $pt[3] += $out_TR[1] - $border['t']['width'];

    2910. 

  2910.                     if ($in_TR)

    2911. 

  2911.                         $pt[11] += $in_TR[1];

    2912. 

  2912.                     unset($pt[0]);

    2913. 

  2913.                     unset($pt[1]);

    2914. 

  2914.                 }

    2915. 

  2915.                 if (is_array($out_BR))

    2916. 

  2916.                 {

    2917. 

  2917.                     $bord -= 2;

    2918. 

  2918.                     $pt[5] -= $out_BR[1] - $border['b']['width'];

    2919. 

  2919.                     if ($in_BR)

    2920. 

  2920.                         $pt[9] -= $in_BR[1];

    2921. 

  2921.                     unset($pt[6]);

    2922. 

  2922.                     unset($pt[7]);

    2923. 

  2923.                 }

    2924. 

  2924.                 

    2925. 

  2925.                 $pt = array_values($pt);

    2926. 

  2926.                 $this->drawLine($pt, $border['r']['color'], $border['r']['type'], $border['r']['width'], $bord);

    2927. 

  2927.             }

    2928. 

  2928.             

    2929. 

  2929.             if ($Bb)

    2930. 

  2930.             {

    2931. 

  2931.                 $pt = array();

    2932. 

  2932.                 $pt[] = $x + $w;

    2933. 

  2933.                 $pt[] = $y + $h;

    2934. 

  2934.                 $pt[] = $x + $w - $border['r']['width'];

    2935. 

  2935.                 $pt[] = $y + $h;

    2936. 

  2936.                 $pt[] = $x + $border['l']['width'];

    2937. 

  2937.                 $pt[] = $y + $h;

    2938. 

  2938.                 $pt[] = $x;

    2939. 

  2939.                 $pt[] = $y + $h;

    2940. 

  2940.                 $pt[] = $x + $border['l']['width'];

    2941. 

  2941.                 $pt[] = $y + $h - $border['b']['width'];

    2942. 

  2942.                 $pt[] = $x + $w - $border['r']['width'];

    2943. 

  2943.                 $pt[] = $y + $h - $border['b']['width'];

    2944. 

  2944.                 

    2945. 

  2945.                 $bord = 3;

    2946. 

  2946.                 if (is_array($out_BL))

    2947. 

  2947.                 {

    2948. 

  2948.                     $bord -= 2;

    2949. 

  2949.                     $pt[4] += $out_BL[0] - $border['l']['width'];

    2950. 

  2950.                     if ($in_BL)

    2951. 

  2951.                         $pt[8] += $in_BL[0];

    2952. 

  2952.                     unset($pt[6]);

    2953. 

  2953.                     unset($pt[7]);

    2954. 

  2954.                 }

    2955. 

  2955.                 if (is_array($out_BR))

    2956. 

  2956.                 {

    2957. 

  2957.                     $bord -= 1;

    2958. 

  2958.                     $pt[2] -= $out_BR[0] - $border['r']['width'];

    2959. 

  2959.                     if ($in_BR)

    2960. 

  2960.                         $pt[10] -= $in_BR[0];

    2961. 

  2961.                     unset($pt[0]);

    2962. 

  2962.                     unset($pt[1]);

    2963. 

  2963.                 

    2964. 

  2964.                 }

    2965. 

  2965.                 

    2966. 

  2966.                 $pt = array_values($pt);

    2967. 

  2967.                 $this->drawLine($pt, $border['b']['color'], $border['b']['type'], $border['b']['width'], $bord);

    2968. 

  2968.             }

    2969. 

  2969.             

    2970. 

  2970.             if ($background['color'])

    2971. 

  2971.             {

    2972. 

  2972.                 $this->pdf->setFillColorArray($background['color']);

    2973. 

  2973.             }

    2974. 

  2974.         }

    2975. 

  2975. 

    2976. 

  2976.         protected function drawCourbe($pt, $color)

    2977. 

  2977.         {

    2978. 

  2978.             $this->pdf->setFillColorArray($color);

    2979. 

  2979.             

    2980. 

  2980.             if (count($pt) == 10)

    2981. 

  2981.                 $this->pdf->drawCourbe($pt[0], $pt[1], $pt[2], $pt[3], $pt[4], $pt[5], $pt[6], $pt[7], $pt[8], $pt[9]);

    2982. 

  2982.             else

    2983. 

  2983.                 $this->pdf->drawCoin($pt[0], $pt[1], $pt[2], $pt[3], $pt[4], $pt[5], $pt[6], $pt[7]);

    2984. 

  2984.         }

    2985. 

  2985. 

    2986. 

  2986.         /**

    2987. 

  2987.          * Tracer une ligne epaisse d�fini par ses points avec des extreminites en biseau

    2988. 

  2988.          *

    2989. 

  2989.          * @param	array	liste des points definissant le tour de la ligne

    2990. 

  2990.          * @param	float	couleur RVB

    2991. 

  2991.          * @param	string	type de ligne

    2992. 

  2992.          * @param	float	largeur de la ligne

    2993. 

  2993.          * @return	null

    2994. 

  2994.          */

    2995. 

  2995.         protected function drawLine($pt, $color, $type, $width, $bord = 3)

    2996. 

  2996.         {

    2997. 

  2997.             $this->pdf->setFillColorArray($color);

    2998. 

  2998.             if ($type == 'dashed' || $type == 'dotted')

    2999. 

  2999.             {

    3000. 

  3000.                 if ($bord == 1)

    3001. 

  3001.                 {

    3002. 

  3002.                     $tmp = array();

    3003. 

  3003.                     $tmp[] = $pt[0];

    3004. 

  3004.                     $tmp[] = $pt[1];

    3005. 

  3005.                     $tmp[] = $pt[2];

    3006. 

  3006.                     $tmp[] = $pt[3];

    3007. 

  3007.                     $tmp[] = $pt[8];

    3008. 

  3008.                     $tmp[] = $pt[9];

    3009. 

  3009.                     $this->pdf->Polygon($tmp, 'F');

    3010. 

  3010.                     

    3011. 

  3011.                     $tmp = array();

    3012. 

  3012.                     $tmp[] = $pt[2];

    3013. 

  3013.                     $tmp[] = $pt[3];

    3014. 

  3014.                     $tmp[] = $pt[4];

    3015. 

  3015.                     $tmp[] = $pt[5];

    3016. 

  3016.                     $tmp[] = $pt[6];

    3017. 

  3017.                     $tmp[] = $pt[7];

    3018. 

  3018.                     $tmp[] = $pt[8];

    3019. 

  3019.                     $tmp[] = $pt[9];

    3020. 

  3020.                     $pt = $tmp;

    3021. 

  3021.                 }

    3022. 

  3022.                 else 

    3023. 

  3023.                     if ($bord == 2)

    3024. 

  3024.                     {

    3025. 

  3025.                         $tmp = array();

    3026. 

  3026.                         $tmp[] = $pt[2];

    3027. 

  3027.                         $tmp[] = $pt[3];

    3028. 

  3028.                         $tmp[] = $pt[4];

    3029. 

  3029.                         $tmp[] = $pt[5];

    3030. 

  3030.                         $tmp[] = $pt[6];

    3031. 

  3031.                         $tmp[] = $pt[7];

    3032. 

  3032.                         $this->pdf->Polygon($tmp, 'F');

    3033. 

  3033.                         

    3034. 

  3034.                         $tmp = array();

    3035. 

  3035.                         $tmp[] = $pt[0];

    3036. 

  3036.                         $tmp[] = $pt[1];

    3037. 

  3037.                         $tmp[] = $pt[2];

    3038. 

  3038.                         $tmp[] = $pt[3];

    3039. 

  3039.                         $tmp[] = $pt[6];

    3040. 

  3040.                         $tmp[] = $pt[7];

    3041. 

  3041.                         $tmp[] = $pt[8];

    3042. 

  3042.                         $tmp[] = $pt[9];

    3043. 

  3043.                         $pt = $tmp;

    3044. 

  3044.                     }

    3045. 

  3045.                     else 

    3046. 

  3046.                         if ($bord == 3)

    3047. 

  3047.                         {

    3048. 

  3048.                             $tmp = array();

    3049. 

  3049.                             $tmp[] = $pt[0];

    3050. 

  3050.                             $tmp[] = $pt[1];

    3051. 

  3051.                             $tmp[] = $pt[2];

    3052. 

  3052.                             $tmp[] = $pt[3];

    3053. 

  3053.                             $tmp[] = $pt[10];

    3054. 

  3054.                             $tmp[] = $pt[11];

    3055. 

  3055.                             $this->pdf->Polygon($tmp, 'F');

    3056. 

  3056.                             

    3057. 

  3057.                             $tmp = array();

    3058. 

  3058.                             $tmp[] = $pt[4];

    3059. 

  3059.                             $tmp[] = $pt[5];

    3060. 

  3060.                             $tmp[] = $pt[6];

    3061. 

  3061.                             $tmp[] = $pt[7];

    3062. 

  3062.                             $tmp[] = $pt[8];

    3063. 

  3063.                             $tmp[] = $pt[9];

    3064. 

  3064.                             $this->pdf->Polygon($tmp, 'F');

    3065. 

  3065.                             

    3066. 

  3066.                             $tmp = array();

    3067. 

  3067.                             $tmp[] = $pt[2];

    3068. 

  3068.                             $tmp[] = $pt[3];

    3069. 

  3069.                             $tmp[] = $pt[4];

    3070. 

  3070.                             $tmp[] = $pt[5];

    3071. 

  3071.                             $tmp[] = $pt[8];

    3072. 

  3072.                             $tmp[] = $pt[9];

    3073. 

  3073.                             $tmp[] = $pt[10];

    3074. 

  3074.                             $tmp[] = $pt[11];

    3075. 

  3075.                             $pt = $tmp;

    3076. 

  3076.                         }

    3077. 

  3077.                 

    3078. 

  3078.                 if ($pt[2] == $pt[0])

    3079. 

  3079.                 {

    3080. 

  3080.                     $l = abs(($pt[3] - $pt[1]) * 0.5);

    3081. 

  3081.                     $px = 0;

    3082. 

  3082.                     $py = $width;

    3083. 

  3083.                     $x1 = $pt[0];

    3084. 

  3084.                     $y1 = ($pt[3] + $pt[1]) * 0.5;

    3085. 

  3085.                     $x2 = $pt[6];

    3086. 

  3086.                     $y2 = ($pt[7] + $pt[5]) * 0.5;

    3087. 

  3087.                 }

    3088. 

  3088.                 else

    3089. 

  3089.                 {

    3090. 

  3090.                     $l = abs(($pt[2] - $pt[0]) * 0.5);

    3091. 

  3091.                     $px = $width;

    3092. 

  3092.                     $py = 0;

    3093. 

  3093.                     $x1 = ($pt[2] + $pt[0]) * 0.5;

    3094. 

  3094.                     $y1 = $pt[1];

    3095. 

  3095.                     $x2 = ($pt[6] + $pt[4]) * 0.5;

    3096. 

  3096.                     $y2 = $pt[7];

    3097. 

  3097.                 }

    3098. 

  3098.                 if ($type == 'dashed')

    3099. 

  3099.                 {

    3100. 

  3100.                     $px = $px * 3.;

    3101. 

  3101.                     $py = $py * 3.;

    3102. 

  3102.                 }

    3103. 

  3103.                 $mode = ($l / ($px + $py) < .5);

    3104. 

  3104.                 

    3105. 

  3105.                 for($i = 0; $l - ($px + $py) * ($i - 0.5) > 0; $i ++)

    3106. 

  3106.                 {

    3107. 

  3107.                     if (($i % 2) == $mode)

    3108. 

  3108.                     {

    3109. 

  3109.                         $j = $i - 0.5;

    3110. 

  3110.                         $lx1 = $px * ($j);

    3111. 

  3111.                         if ($lx1 < - $l)

    3112. 

  3112.                             $lx1 = - $l;

    3113. 

  3113.                         $ly1 = $py * ($j);

    3114. 

  3114.                         if ($ly1 < - $l)

    3115. 

  3115.                             $ly1 = - $l;

    3116. 

  3116.                         $lx2 = $px * ($j + 1);

    3117. 

  3117.                         if ($lx2 > $l)

    3118. 

  3118.                             $lx2 = $l;

    3119. 

  3119.                         $ly2 = $py * ($j + 1);

    3120. 

  3120.                         if ($ly2 > $l)

    3121. 

  3121.                             $ly2 = $l;

    3122. 

  3122.                         

    3123. 

  3123.                         $tmp = array();

    3124. 

  3124.                         $tmp[] = $x1 + $lx1;

    3125. 

  3125.                         $tmp[] = $y1 + $ly1;

    3126. 

  3126.                         $tmp[] = $x1 + $lx2;

    3127. 

  3127.                         $tmp[] = $y1 + $ly2;

    3128. 

  3128.                         $tmp[] = $x2 + $lx2;

    3129. 

  3129.                         $tmp[] = $y2 + $ly2;

    3130. 

  3130.                         $tmp[] = $x2 + $lx1;

    3131. 

  3131.                         $tmp[] = $y2 + $ly1;

    3132. 

  3132.                         $this->pdf->Polygon($tmp, 'F');

    3133. 

  3133.                         

    3134. 

  3134.                         if ($j > 0)

    3135. 

  3135.                         {

    3136. 

  3136.                             $tmp = array();

    3137. 

  3137.                             $tmp[] = $x1 - $lx1;

    3138. 

  3138.                             $tmp[] = $y1 - $ly1;

    3139. 

  3139.                             $tmp[] = $x1 - $lx2;

    3140. 

  3140.                             $tmp[] = $y1 - $ly2;

    3141. 

  3141.                             $tmp[] = $x2 - $lx2;

    3142. 

  3142.                             $tmp[] = $y2 - $ly2;

    3143. 

  3143.                             $tmp[] = $x2 - $lx1;

    3144. 

  3144.                             $tmp[] = $y2 - $ly1;

    3145. 

  3145.                             $this->pdf->Polygon($tmp, 'F');

    3146. 

  3146.                         }

    3147. 

  3147.                     }

    3148. 

  3148.                 }

    3149. 

  3149.             }

    3150. 

  3150.             else 

    3151. 

  3151.                 if ($type == 'double')

    3152. 

  3152.                 {

    3153. 

  3153.                     $pt1 = $pt;

    3154. 

  3154.                     $pt2 = $pt;

    3155. 

  3155.                     

    3156. 

  3156.                     if (count($pt) == 12)

    3157. 

  3157.                     {

    3158. 

  3158.                         $pt1[0] = ($pt[0] - $pt[10]) * 0.33 + $pt[10];

    3159. 

  3159.                         $pt1[1] = ($pt[1] - $pt[11]) * 0.33 + $pt[11];

    3160. 

  3160.                         $pt1[2] = ($pt[2] - $pt[10]) * 0.33 + $pt[10];

    3161. 

  3161.                         $pt1[3] = ($pt[3] - $pt[11]) * 0.33 + $pt[11];

    3162. 

  3162.                         $pt1[4] = ($pt[4] - $pt[8]) * 0.33 + $pt[8];

    3163. 

  3163.                         $pt1[5] = ($pt[5] - $pt[9]) * 0.33 + $pt[9];

    3164. 

  3164.                         $pt1[6] = ($pt[6] - $pt[8]) * 0.33 + $pt[8];

    3165. 

  3165.                         $pt1[7] = ($pt[7] - $pt[9]) * 0.33 + $pt[9];

    3166. 

  3166.                         $pt2[10] = ($pt[10] - $pt[0]) * 0.33 + $pt[0];

    3167. 

  3167.                         $pt2[11] = ($pt[11] - $pt[1]) * 0.33 + $pt[1];

    3168. 

  3168.                         $pt2[2] = ($pt[2] - $pt[0]) * 0.33 + $pt[0];

    3169. 

  3169.                         $pt2[3] = ($pt[3] - $pt[1]) * 0.33 + $pt[1];

    3170. 

  3170.                         $pt2[4] = ($pt[4] - $pt[6]) * 0.33 + $pt[6];

    3171. 

  3171.                         $pt2[5] = ($pt[5] - $pt[7]) * 0.33 + $pt[7];

    3172. 

  3172.                         $pt2[8] = ($pt[8] - $pt[6]) * 0.33 + $pt[6];

    3173. 

  3173.                         $pt2[9] = ($pt[9] - $pt[7]) * 0.33 + $pt[7];

    3174. 

  3174.                     }

    3175. 

  3175.                     else

    3176. 

  3176.                     {

    3177. 

  3177.                         $pt1[0] = ($pt[0] - $pt[6]) * 0.33 + $pt[6];

    3178. 

  3178.                         $pt1[1] = ($pt[1] - $pt[7]) * 0.33 + $pt[7];

    3179. 

  3179.                         $pt1[2] = ($pt[2] - $pt[4]) * 0.33 + $pt[4];

    3180. 

  3180.                         $pt1[3] = ($pt[3] - $pt[5]) * 0.33 + $pt[5];

    3181. 

  3181.                         $pt2[6] = ($pt[6] - $pt[0]) * 0.33 + $pt[0];

    3182. 

  3182.                         $pt2[7] = ($pt[7] - $pt[1]) * 0.33 + $pt[1];

    3183. 

  3183.                         $pt2[4] = ($pt[4] - $pt[2]) * 0.33 + $pt[2];

    3184. 

  3184.                         $pt2[5] = ($pt[5] - $pt[3]) * 0.33 + $pt[3];

    3185. 

  3185.                     }

    3186. 

  3186.                     $this->pdf->Polygon($pt1, 'F');

    3187. 

  3187.                     $this->pdf->Polygon($pt2, 'F');

    3188. 

  3188.                 }

    3189. 

  3189.                 else 

    3190. 

  3190.                     if ($type == 'solid')

    3191. 

  3191.                     {

    3192. 

  3192.                         $this->pdf->Polygon($pt, 'F');

    3193. 

  3193.                     }

    3194. 

  3194.         }

    3195. 

  3195. 

    3196. 

  3196.         /**

    3197. 

  3197.          * balise : BR

    3198. 

  3198.          * mode : OUVERTURE

    3199. 

  3199.          *

    3200. 

  3200.          * @param	array	param�tres de l'�l�ment de parsing

    3201. 

  3201.          * @param	integer	position reelle courante si saut de ligne pendant l'ecriture d'un texte

    3202. 

  3202.          * @return	null

    3203. 

  3203.          */

    3204. 

  3204.         protected function o_BR($param, $curr = null)

    3205. 

  3205.         {

    3206. 

  3206.             if ($this->forOneLine)

    3207. 

  3207.                 return false;

    3208. 

  3208.             

    3209. 

  3209.             $h = max($this->maxH, $this->style->getLineHeight());

    3210. 

  3210.             

    3211. 

  3211.             // si la ligne est vide, la position maximale n'a pas �t� mise � jour => on la met � jour

    3212. 

  3212.             if ($this->maxH == 0)

    3213. 

  3213.                 $this->maxY = max($this->maxY, $this->pdf->getY() + $h);

    3214. 

  3214.             

    3215. 

  3215.             $this->makeBR($h, $curr);

    3216. 

  3216.             

    3217. 

  3217.             $this->maxH = 0;

    3218. 

  3218.             

    3219. 

  3219.             return true;

    3220. 

  3220.         }

    3221. 

  3221. 

    3222. 

  3222.         protected function makeBR($h, $curr = null)

    3223. 

  3223.         {

    3224. 

  3224.             // si le saut de ligne rentre => on le prend en compte, sinon nouvelle page

    3225. 

  3225.             if ($h)

    3226. 

  3226.             {

    3227. 

  3227.                 if (($this->pdf->getY() + $h < $this->pdf->getH() - $this->pdf->getbMargin()) || $this->isInOverflow || $this->isInFooter)

    3228. 

  3228.                     $this->setNewLine($h, $curr);

    3229. 

  3229.                 else

    3230. 

  3230.                     $this->setNewPage(null, '', null, $curr);

    3231. 

  3231.             }

    3232. 

  3232.             else

    3233. 

  3233.             {

    3234. 

  3234.                 $this->setNewPositionForNewLine($curr);

    3235. 

  3235.             }

    3236. 

  3236.             

    3237. 

  3237.             $this->maxH = 0;

    3238. 

  3238.         }

    3239. 

  3239. 

    3240. 

  3240.         /**

    3241. 

  3241.          * balise : HR

    3242. 

  3242.          * mode : OUVERTURE

    3243. 

  3243.          *

    3244. 

  3244.          * @param	array	param�tres de l'�l�ment de parsing

    3245. 

  3245.          * @return	null

    3246. 

  3246.          */

    3247. 

  3247.         protected function o_HR($param)

    3248. 

  3248.         {

    3249. 

  3249.             if ($this->forOneLine)

    3250. 

  3250.                 return false;

    3251. 

  3251.             $old_align = $this->style->value['text-align'];

    3252. 

  3252.             $this->style->value['text-align'] = 'left';

    3253. 

  3253.             

    3254. 

  3254.             if ($this->maxH)

    3255. 

  3255.                 $this->o_BR($param);

    3256. 

  3256.             

    3257. 

  3257.             $f_size = $this->style->value['font-size'];

    3258. 

  3258.             $this->style->value['font-size'] = $f_size * 0.5;

    3259. 

  3259.             $this->o_BR($param);

    3260. 

  3260.             $this->style->value['font-size'] = 0;

    3261. 

  3261.             

    3262. 

  3262.             $param['style']['width'] = '100%';

    3263. 

  3263.             

    3264. 

  3264.             $this->style->save();

    3265. 

  3265.             $this->style->value['height'] = $this->style->ConvertToMM('1mm');

    3266. 

  3266.             

    3267. 

  3267.             $this->style->analyse('hr', $param);

    3268. 

  3268.             $this->style->setPosition();

    3269. 

  3269.             $this->style->FontSet();

    3270. 

  3270.             

    3271. 

  3271.             $h = $this->style->value['height'];

    3272. 

  3272.             if ($h)

    3273. 

  3273.                 $h -= $this->style->value['border']['t']['width'] + $this->style->value['border']['b']['width'];

    3274. 

  3274.             if ($h <= 0)

    3275. 

  3275.                 $h = $this->style->value['border']['t']['width'] + $this->style->value['border']['b']['width'];

    3276. 

  3276.             

    3277. 

  3277.             $this->drawRectangle($this->pdf->getX(), $this->pdf->getY(), $this->style->value['width'], $h, $this->style->value['border'], 0, 0, $this->style->value['background']);

    3278. 

  3278.             $this->maxH = $h;

    3279. 

  3279.             

    3280. 

  3280.             $this->style->load();

    3281. 

  3281.             $this->style->FontSet();

    3282. 

  3282.             

    3283. 

  3283.             $this->o_BR($param);

    3284. 

  3284.             

    3285. 

  3285.             $this->style->value['font-size'] = $f_size * 0.5;

    3286. 

  3286.             $this->o_BR($param);

    3287. 

  3287.             $this->style->value['font-size'] = $f_size;

    3288. 

  3288.             

    3289. 

  3289.             $this->style->value['text-align'] = $old_align;

    3290. 

  3290.             $this->setNewPositionForNewLine();

    3291. 

  3291.             

    3292. 

  3292.             return true;

    3293. 

  3293.         }

    3294. 

  3294. 

    3295. 

  3295.         /**

    3296. 

  3296.          * balise : B

    3297. 

  3297.          * mode : OUVERTURE

    3298. 

  3298.          *

    3299. 

  3299.          * @param	array	param�tres de l'�l�ment de parsing

    3300. 

  3300.          * @return	null

    3301. 

  3301.          */

    3302. 

  3302.         protected function o_B($param, $other = 'b')

    3303. 

  3303.         {

    3304. 

  3304.             $this->style->save();

    3305. 

  3305.             $this->style->value['font-bold'] = true;

    3306. 

  3306.             $this->style->analyse($other, $param);

    3307. 

  3307.             $this->style->setPosition();

    3308. 

  3308.             $this->style->FontSet();

    3309. 

  3309.             

    3310. 

  3310.             return true;

    3311. 

  3311.         }

    3312. 

  3312. 

    3313. 

  3313.         protected function o_STRONG($param)

    3314. 

  3314.         {

    3315. 

  3315.             return $this->o_B($param, 'strong');

    3316. 

  3316.         }

    3317. 

  3317. 

    3318. 

  3318.         /**

    3319. 

  3319.          * balise : B

    3320. 

  3320.          * mode : FERMETURE

    3321. 

  3321.          *

    3322. 

  3322.          * @param	array	param�tres de l'�l�ment de parsing

    3323. 

  3323.          * @return	null

    3324. 

  3324.          */

    3325. 

  3325.         protected function c_B($param)

    3326. 

  3326.         {

    3327. 

  3327.             $this->style->load();

    3328. 

  3328.             $this->style->FontSet();

    3329. 

  3329.             

    3330. 

  3330.             return true;

    3331. 

  3331.         }

    3332. 

  3332. 

    3333. 

  3333.         protected function c_STRONG($param)

    3334. 

  3334.         {

    3335. 

  3335.             return $this->c_B($param);

    3336. 

  3336.         }

    3337. 

  3337. 

    3338. 

  3338.         /**

    3339. 

  3339.          * balise : I

    3340. 

  3340.          * mode : OUVERTURE

    3341. 

  3341.          *

    3342. 

  3342.          * @param	array	param�tres de l'�l�ment de parsing

    3343. 

  3343.          * @return	null

    3344. 

  3344.          */

    3345. 

  3345.         protected function o_I($param, $other = 'i')

    3346. 

  3346.         {

    3347. 

  3347.             $this->style->save();

    3348. 

  3348.             $this->style->value['font-italic'] = true;

    3349. 

  3349.             $this->style->analyse($other, $param);

    3350. 

  3350.             $this->style->setPosition();

    3351. 

  3351.             $this->style->FontSet();

    3352. 

  3352.             

    3353. 

  3353.             return true;

    3354. 

  3354.         }

    3355. 

  3355. 

    3356. 

  3356.         protected function o_ADDRESS($param)

    3357. 

  3357.         {

    3358. 

  3358.             return $this->o_I($param, 'address');

    3359. 

  3359.         }

    3360. 

  3360. 

    3361. 

  3361.         protected function o_CITE($param)

    3362. 

  3362.         {

    3363. 

  3363.             return $this->o_I($param, 'cite');

    3364. 

  3364.         }

    3365. 

  3365. 

    3366. 

  3366.         protected function o_EM($param)

    3367. 

  3367.         {

    3368. 

  3368.             return $this->o_I($param, 'em');

    3369. 

  3369.         }

    3370. 

  3370. 

    3371. 

  3371.         protected function o_SAMP($param)

    3372. 

  3372.         {

    3373. 

  3373.             return $this->o_I($param, 'samp');

    3374. 

  3374.         }

    3375. 

  3375. 

    3376. 

  3376.         /**

    3377. 

  3377.          * balise : I

    3378. 

  3378.          * mode : FERMETURE

    3379. 

  3379.          *

    3380. 

  3380.          * @param	array	param�tres de l'�l�ment de parsing

    3381. 

  3381.          * @return	null

    3382. 

  3382.          */

    3383. 

  3383.         protected function c_I($param)

    3384. 

  3384.         {

    3385. 

  3385.             $this->style->load();

    3386. 

  3386.             $this->style->FontSet();

    3387. 

  3387.             

    3388. 

  3388.             return true;

    3389. 

  3389.         }

    3390. 

  3390. 

    3391. 

  3391.         protected function c_ADDRESS($param)

    3392. 

  3392.         {

    3393. 

  3393.             return $this->c_I($param);

    3394. 

  3394.         }

    3395. 

  3395. 

    3396. 

  3396.         protected function c_CITE($param)

    3397. 

  3397.         {

    3398. 

  3398.             return $this->c_I($param);

    3399. 

  3399.         }

    3400. 

  3400. 

    3401. 

  3401.         protected function c_EM($param)

    3402. 

  3402.         {

    3403. 

  3403.             return $this->c_I($param);

    3404. 

  3404.         }

    3405. 

  3405. 

    3406. 

  3406.         protected function c_SAMP($param)

    3407. 

  3407.         {

    3408. 

  3408.             return $this->c_I($param);

    3409. 

  3409.         }

    3410. 

  3410. 

    3411. 

  3411.         /**

    3412. 

  3412.          * balise : S

    3413. 

  3413.          * mode : OUVERTURE

    3414. 

  3414.          *

    3415. 

  3415.          * @param	array	param�tres de l'�l�ment de parsing

    3416. 

  3416.          * @return	null

    3417. 

  3417.          */

    3418. 

  3418.         protected function o_S($param, $other = 's')

    3419. 

  3419.         {

    3420. 

  3420.             $this->style->save();

    3421. 

  3421.             $this->style->value['font-linethrough'] = true;

    3422. 

  3422.             $this->style->analyse($other, $param);

    3423. 

  3423.             $this->style->setPosition();

    3424. 

  3424.             $this->style->FontSet();

    3425. 

  3425.             

    3426. 

  3426.             return true;

    3427. 

  3427.         }

    3428. 

  3428. 

    3429. 

  3429.         protected function o_DEL($param)

    3430. 

  3430.         {

    3431. 

  3431.             return $this->o_S($param, 'del');

    3432. 

  3432.         }

    3433. 

  3433. 

    3434. 

  3434.         /**

    3435. 

  3435.          * balise : S

    3436. 

  3436.          * mode : FERMETURE

    3437. 

  3437.          *

    3438. 

  3438.          * @param	array	param�tres de l'�l�ment de parsing

    3439. 

  3439.          * @return	null

    3440. 

  3440.          */

    3441. 

  3441.         protected function c_S($param)

    3442. 

  3442.         {

    3443. 

  3443.             $this->style->load();

    3444. 

  3444.             $this->style->FontSet();

    3445. 

  3445.             

    3446. 

  3446.             return true;

    3447. 

  3447.         }

    3448. 

  3448. 

    3449. 

  3449.         protected function c_DEL($param)

    3450. 

  3450.         {

    3451. 

  3451.             return $this->c_S($param);

    3452. 

  3452.         }

    3453. 

  3453. 

    3454. 

  3454.         /**

    3455. 

  3455.          * balise : U

    3456. 

  3456.          * mode : OUVERTURE

    3457. 

  3457.          *

    3458. 

  3458.          * @param	array	param�tres de l'�l�ment de parsing

    3459. 

  3459.          * @return	null

    3460. 

  3460.          */

    3461. 

  3461.         protected function o_U($param, $other = 'u')

    3462. 

  3462.         {

    3463. 

  3463.             $this->style->save();

    3464. 

  3464.             $this->style->value['font-underline'] = true;

    3465. 

  3465.             $this->style->analyse($other, $param);

    3466. 

  3466.             $this->style->setPosition();

    3467. 

  3467.             $this->style->FontSet();

    3468. 

  3468.             

    3469. 

  3469.             return true;

    3470. 

  3470.         }

    3471. 

  3471. 

    3472. 

  3472.         protected function o_INS($param)

    3473. 

  3473.         {

    3474. 

  3474.             return $this->o_U($param, 'ins');

    3475. 

  3475.         }

    3476. 

  3476. 

    3477. 

  3477.         /**

    3478. 

  3478.          * balise : U

    3479. 

  3479.          * mode : FERMETURE

    3480. 

  3480.          *

    3481. 

  3481.          * @param	array	param�tres de l'�l�ment de parsing

    3482. 

  3482.          * @return	null

    3483. 

  3483.          */

    3484. 

  3484.         protected function c_U($param)

    3485. 

  3485.         {

    3486. 

  3486.             $this->style->load();

    3487. 

  3487.             $this->style->FontSet();

    3488. 

  3488.             

    3489. 

  3489.             return true;

    3490. 

  3490.         }

    3491. 

  3491. 

    3492. 

  3492.         protected function c_INS($param)

    3493. 

  3493.         {

    3494. 

  3494.             return $this->c_U($param);

    3495. 

  3495.         }

    3496. 

  3496. 

    3497. 

  3497.         /**

    3498. 

  3498.          * balise : A

    3499. 

  3499.          * mode : OUVERTURE

    3500. 

  3500.          *

    3501. 

  3501.          * @param	array	param�tres de l'�l�ment de parsing

    3502. 

  3502.          * @return	null

    3503. 

  3503.          */

    3504. 

  3504.         protected function o_A($param)

    3505. 

  3505.         {

    3506. 

  3506.             $this->inLink = str_replace('&amp;', '&', isset($param['href']) ? $param['href'] : '');

    3507. 

  3507.             

    3508. 

  3508.             if (isset($param['name']))

    3509. 

  3509.             {

    3510. 

  3510.                 $nom = $param['name'];

    3511. 

  3511.                 if (! isset($this->lstAncre[$nom]))

    3512. 

  3512.                     $this->lstAncre[$nom] = array($this->pdf->AddLink(), false);

    3513. 

  3513.                 

    3514. 

  3514.                 if (! $this->lstAncre[$nom][1])

    3515. 

  3515.                 {

    3516. 

  3516.                     $this->lstAncre[$nom][1] = true;

    3517. 

  3517.                     $this->pdf->SetLink($this->lstAncre[$nom][0], - 1, - 1);

    3518. 

  3518.                 }

    3519. 

  3519.             }

    3520. 

  3520.             

    3521. 

  3521.             if (preg_match('/^#([^#]+)$/isU', $this->inLink, $match))

    3522. 

  3522.             {

    3523. 

  3523.                 $nom = $match[1];

    3524. 

  3524.                 if (! isset($this->lstAncre[$nom]))

    3525. 

  3525.                     $this->lstAncre[$nom] = array($this->pdf->AddLink(), false);

    3526. 

  3526.                 

    3527. 

  3527.                 $this->inLink = $this->lstAncre[$nom][0];

    3528. 

  3528.             }

    3529. 

  3529.             

    3530. 

  3530.             $this->style->save();

    3531. 

  3531.             $this->style->value['font-underline'] = true;

    3532. 

  3532.             $this->style->value['color'] = array(20, 20, 250);

    3533. 

  3533.             $this->style->analyse('a', $param);

    3534. 

  3534.             $this->style->setPosition();

    3535. 

  3535.             $this->style->FontSet();

    3536. 

  3536.             

    3537. 

  3537.             return true;

    3538. 

  3538.         }

    3539. 

  3539. 

    3540. 

  3540.         /**

    3541. 

  3541.          * balise : A

    3542. 

  3542.          * mode : FERMETURE

    3543. 

  3543.          *

    3544. 

  3544.          * @param	array	param�tres de l'�l�ment de parsing

    3545. 

  3545.          * @return	null

    3546. 

  3546.          */

    3547. 

  3547.         protected function c_A($param)

    3548. 

  3548.         {

    3549. 

  3549.             $this->inLink = '';

    3550. 

  3550.             $this->style->load();

    3551. 

  3551.             $this->style->FontSet();

    3552. 

  3552.             

    3553. 

  3553.             return true;

    3554. 

  3554.         }

    3555. 

  3555. 

    3556. 

  3556.         /**

    3557. 

  3557.          * balise : H1

    3558. 

  3558.          * mode : OUVERTURE

    3559. 

  3559.          *

    3560. 

  3560.          * @param	array	param�tres de l'�l�ment de parsing

    3561. 

  3561.          * @return	null

    3562. 

  3562.          */

    3563. 

  3563.         protected function o_H1($param, $other = 'h1')

    3564. 

  3564.         {

    3565. 

  3565.             if ($this->forOneLine)

    3566. 

  3566.                 return false;

    3567. 

  3567.             

    3568. 

  3568.             if ($this->maxH)

    3569. 

  3569.                 $this->o_BR(array());

    3570. 

  3570.             $this->style->save();

    3571. 

  3571.             $this->style->value['font-bold'] = true;

    3572. 

  3572.             

    3573. 

  3573.             $size = array('h1' => '28px', 'h2' => '24px', 'h3' => '20px', 'h4' => '16px', 'h5' => '12px', 'h6' => '9px');

    3574. 

  3574.             $this->style->value['margin']['l'] = 0;

    3575. 

  3575.             $this->style->value['margin']['r'] = 0;

    3576. 

  3576.             $this->style->value['margin']['t'] = $this->style->ConvertToMM('16px');

    3577. 

  3577.             $this->style->value['margin']['b'] = $this->style->ConvertToMM('16px');

    3578. 

  3578.             $this->style->value['font-size'] = $this->style->ConvertToMM($size[$other]);

    3579. 

  3579.             

    3580. 

  3580.             $this->style->analyse($other, $param);

    3581. 

  3581.             $this->style->setPosition();

    3582. 

  3582.             $this->style->FontSet();

    3583. 

  3583.             $this->setNewPositionForNewLine();

    3584. 

  3584.             

    3585. 

  3585.             return true;

    3586. 

  3586.         }

    3587. 

  3587. 

    3588. 

  3588.         protected function o_H2($param)

    3589. 

  3589.         {

    3590. 

  3590.             return $this->o_H1($param, 'h2');

    3591. 

  3591.         }

    3592. 

  3592. 

    3593. 

  3593.         protected function o_H3($param)

    3594. 

  3594.         {

    3595. 

  3595.             return $this->o_H1($param, 'h3');

    3596. 

  3596.         }

    3597. 

  3597. 

    3598. 

  3598.         protected function o_H4($param)

    3599. 

  3599.         {

    3600. 

  3600.             return $this->o_H1($param, 'h4');

    3601. 

  3601.         }

    3602. 

  3602. 

    3603. 

  3603.         protected function o_H5($param)

    3604. 

  3604.         {

    3605. 

  3605.             return $this->o_H1($param, 'h5');

    3606. 

  3606.         }

    3607. 

  3607. 

    3608. 

  3608.         protected function o_H6($param)

    3609. 

  3609.         {

    3610. 

  3610.             return $this->o_H1($param, 'h6');

    3611. 

  3611.         }

    3612. 

  3612. 

    3613. 

  3613.         /**

    3614. 

  3614.          * balise : H1

    3615. 

  3615.          * mode : FERMETURE

    3616. 

  3616.          *

    3617. 

  3617.          * @param	array	param�tres de l'�l�ment de parsing

    3618. 

  3618.          * @return	null

    3619. 

  3619.          */

    3620. 

  3620.         protected function c_H1($param)

    3621. 

  3621.         {

    3622. 

  3622.             if ($this->forOneLine)

    3623. 

  3623.                 return false;

    3624. 

  3624.             $this->maxH += $this->style->value['margin']['b'];

    3625. 

  3625.             $this->o_BR(array());

    3626. 

  3626.             $this->style->load();

    3627. 

  3627.             $this->style->FontSet();

    3628. 

  3628.             

    3629. 

  3629.             return true;

    3630. 

  3630.         }

    3631. 

  3631. 

    3632. 

  3632.         protected function c_H2($param)

    3633. 

  3633.         {

    3634. 

  3634.             return $this->c_H1($param);

    3635. 

  3635.         }

    3636. 

  3636. 

    3637. 

  3637.         protected function c_H3($param)

    3638. 

  3638.         {

    3639. 

  3639.             return $this->c_H1($param);

    3640. 

  3640.         }

    3641. 

  3641. 

    3642. 

  3642.         protected function c_H4($param)

    3643. 

  3643.         {

    3644. 

  3644.             return $this->c_H1($param);

    3645. 

  3645.         }

    3646. 

  3646. 

    3647. 

  3647.         protected function c_H5($param)

    3648. 

  3648.         {

    3649. 

  3649.             return $this->c_H1($param);

    3650. 

  3650.         }

    3651. 

  3651. 

    3652. 

  3652.         protected function c_H6($param)

    3653. 

  3653.         {

    3654. 

  3654.             return $this->c_H1($param);

    3655. 

  3655.         }

    3656. 

  3656. 

    3657. 

  3657.         /**

    3658. 

  3658.          * balise : SPAN

    3659. 

  3659.          * mode : OUVERTURE

    3660. 

  3660.          *

    3661. 

  3661.          * @param	array	param�tres de l'�l�ment de parsing

    3662. 

  3662.          * @return	null

    3663. 

  3663.          */

    3664. 

  3664.         protected function o_SPAN($param, $other = 'span')

    3665. 

  3665.         {

    3666. 

  3666.             $this->style->save();

    3667. 

  3667.             $this->style->analyse($other, $param);

    3668. 

  3668.             $this->style->setPosition();

    3669. 

  3669.             $this->style->FontSet();

    3670. 

  3670.             

    3671. 

  3671.             return true;

    3672. 

  3672.         }

    3673. 

  3673. 

    3674. 

  3674.         protected function o_FONT($param)

    3675. 

  3675.         {

    3676. 

  3676.             return $this->o_SPAN($param, 'font');

    3677. 

  3677.         }

    3678. 

  3678. 

    3679. 

  3679.         protected function o_LABEL($param)

    3680. 

  3680.         {

    3681. 

  3681.             return $this->o_SPAN($param, 'label');

    3682. 

  3682.         }

    3683. 

  3683. 

    3684. 

  3684.         /**

    3685. 

  3685.          * balise : SPAN

    3686. 

  3686.          * mode : FERMETURE

    3687. 

  3687.          *

    3688. 

  3688.          * @param	array	param�tres de l'�l�ment de parsing

    3689. 

  3689.          * @return	null

    3690. 

  3690.          */

    3691. 

  3691.         protected function c_SPAN($param)

    3692. 

  3692.         {

    3693. 

  3693.             $this->style->restorePosition();

    3694. 

  3694.             $this->style->load();

    3695. 

  3695.             $this->style->FontSet();

    3696. 

  3696.             

    3697. 

  3697.             return true;

    3698. 

  3698.         }

    3699. 

  3699. 

    3700. 

  3700.         protected function c_FONT($param)

    3701. 

  3701.         {

    3702. 

  3702.             return $this->c_SPAN($param);

    3703. 

  3703.         }

    3704. 

  3704. 

    3705. 

  3705.         protected function c_LABEL($param)

    3706. 

  3706.         {

    3707. 

  3707.             return $this->c_SPAN($param);

    3708. 

  3708.         }

    3709. 

  3709. 

    3710. 

  3710.         /**

    3711. 

  3711.          * balise : P

    3712. 

  3712.          * mode : OUVERTURE

    3713. 

  3713.          *

    3714. 

  3714.          * @param	array	param�tres de l'�l�ment de parsing

    3715. 

  3715.          * @return	null

    3716. 

  3716.          */

    3717. 

  3717.         protected function o_P($param)

    3718. 

  3718.         {

    3719. 

  3719.             if ($this->forOneLine)

    3720. 

  3720.                 return false;

    3721. 

  3721.             

    3722. 

  3722.             if (! in_array($this->previousCall, array('c_P', 'c_UL')))

    3723. 

  3723.             {

    3724. 

  3724.                 if ($this->maxH)

    3725. 

  3725.                     $this->o_BR(array());

    3726. 

  3726.             }

    3727. 

  3727.             

    3728. 

  3728.             $this->style->save();

    3729. 

  3729.             $this->style->analyse('p', $param);

    3730. 

  3730.             $this->style->setPosition();

    3731. 

  3731.             $this->style->FontSet();

    3732. 

  3732.             // annule les effets du setposition

    3733. 

  3733.             $this->pdf->setXY($this->pdf->getX() - $this->style->value['margin']['l'], $this->pdf->getY() - $this->style->value['margin']['t']);

    3734. 

  3734.             

    3735. 

  3735.             list($mL, $mR) = $this->getMargins($this->pdf->getY());

    3736. 

  3736.             $mR = $this->pdf->getW() - $mR;

    3737. 

  3737.             $mL += $this->style->value['margin']['l'] + $this->style->value['padding']['l'];

    3738. 

  3738.             $mR += $this->style->value['margin']['r'] + $this->style->value['padding']['r'];

    3739. 

  3739.             $this->saveMargin($mL, 0, $mR);

    3740. 

  3740.             

    3741. 

  3741.             if ($this->style->value['text-indent'] > 0)

    3742. 

  3742.             {

    3743. 

  3743.                 $y = $this->pdf->getY() + $this->style->value['margin']['t'] + $this->style->value['padding']['t'];

    3744. 

  3744.                 $this->pageMarges[floor($y * 100)] = array($mL + $this->style->value['text-indent'], 

    3745. 

  3745.                         $this->pdf->getW() - $mR);

    3746. 

  3746.                 $y += $this->style->getLineHeight() * 0.1;

    3747. 

  3747.                 $this->pageMarges[floor($y * 100)] = array($mL, $this->pdf->getW() - $mR);

    3748. 

  3748.             }

    3749. 

  3749.             $this->makeBR($this->style->value['margin']['t'] + $this->style->value['padding']['t']);

    3750. 

  3750.             return true;

    3751. 

  3751.         }

    3752. 

  3752. 

    3753. 

  3753.         /**

    3754. 

  3754.          * balise : P

    3755. 

  3755.          * mode : FERMETURE

    3756. 

  3756.          *

    3757. 

  3757.          * @param	array	param�tres de l'�l�ment de parsing

    3758. 

  3758.          * @return	null

    3759. 

  3759.          */

    3760. 

  3760.         protected function c_P($param)

    3761. 

  3761.         {

    3762. 

  3762.             if ($this->forOneLine)

    3763. 

  3763.                 return false;

    3764. 

  3764.             

    3765. 

  3765.             if ($this->maxH)

    3766. 

  3766.                 $this->o_BR(array());

    3767. 

  3767.             $this->loadMargin();

    3768. 

  3768.             $h = $this->style->value['margin']['b'] + $this->style->value['padding']['b'];

    3769. 

  3769.             

    3770. 

  3770.             $this->style->load();

    3771. 

  3771.             $this->style->FontSet();

    3772. 

  3772.             $this->makeBR($h);

    3773. 

  3773.             

    3774. 

  3774.             return true;

    3775. 

  3775.         }

    3776. 

  3776. 

    3777. 

  3777.         /**

    3778. 

  3778.          * balise : PRE

    3779. 

  3779.          * mode : OUVERTURE

    3780. 

  3780.          *

    3781. 

  3781.          * @param	array	param�tres de l'�l�ment de parsing

    3782. 

  3782.          * @return	null

    3783. 

  3783.          */

    3784. 

  3784.         protected function o_PRE($param, $other = 'pre')

    3785. 

  3785.         {

    3786. 

  3786.             if ($other == 'pre' && $this->maxH)

    3787. 

  3787.                 $this->o_BR(array());

    3788. 

  3788.             

    3789. 

  3789.             $this->style->save();

    3790. 

  3790.             $this->style->value['font-family'] = 'courier';

    3791. 

  3791.             $this->style->analyse($other, $param);

    3792. 

  3792.             $this->style->setPosition();

    3793. 

  3793.             $this->style->FontSet();

    3794. 

  3794.             

    3795. 

  3795.             if ($other == 'pre')

    3796. 

  3796.                 return $this->o_DIV($param, $other);

    3797. 

  3797.             

    3798. 

  3798.             return true;

    3799. 

  3799.         }

    3800. 

  3800. 

    3801. 

  3801.         protected function o_CODE($param)

    3802. 

  3802.         {

    3803. 

  3803.             return $this->o_PRE($param, 'code');

    3804. 

  3804.         }

    3805. 

  3805. 

    3806. 

  3806.         /**

    3807. 

  3807.          * balise : PRE

    3808. 

  3808.          * mode : FERMETURE

    3809. 

  3809.          *

    3810. 

  3810.          * @param	array	param�tres de l'�l�ment de parsing

    3811. 

  3811.          * @return	null

    3812. 

  3812.          */

    3813. 

  3813.         protected function c_PRE($param, $other = 'pre')

    3814. 

  3814.         {

    3815. 

  3815.             if ($other == 'pre')

    3816. 

  3816.             {

    3817. 

  3817.                 if ($this->forOneLine)

    3818. 

  3818.                     return false;

    3819. 

  3819.                 

    3820. 

  3820.                 $this->c_DIV($param);

    3821. 

  3821.                 $this->o_BR(array());

    3822. 

  3822.             }

    3823. 

  3823.             $this->style->load();

    3824. 

  3824.             $this->style->FontSet();

    3825. 

  3825.             

    3826. 

  3826.             return true;

    3827. 

  3827.         }

    3828. 

  3828. 

    3829. 

  3829.         protected function c_CODE($param)

    3830. 

  3830.         {

    3831. 

  3831.             return $this->c_PRE($param, 'code');

    3832. 

  3832.         }

    3833. 

  3833. 

    3834. 

  3834.         /**

    3835. 

  3835.          * balise : BIG

    3836. 

  3836.          * mode : OUVERTURE

    3837. 

  3837.          *

    3838. 

  3838.          * @param	array	param�tres de l'�l�ment de parsing

    3839. 

  3839.          * @return	null

    3840. 

  3840.          */

    3841. 

  3841.         protected function o_BIG($param)

    3842. 

  3842.         {

    3843. 

  3843.             $this->style->save();

    3844. 

  3844.             $this->style->value['mini-decal'] -= $this->style->value['mini-size'] * 0.10;

    3845. 

  3845.             $this->style->value['mini-size'] *= 1.2;

    3846. 

  3846.             $this->style->analyse('big', $param);

    3847. 

  3847.             $this->style->setPosition();

    3848. 

  3848.             $this->style->FontSet();

    3849. 

  3849.             return true;

    3850. 

  3850.         }

    3851. 

  3851. 

    3852. 

  3852.         /**

    3853. 

  3853.          * balise : BIG

    3854. 

  3854.          * mode : FERMETURE

    3855. 

  3855.          *

    3856. 

  3856.          * @param	array	param�tres de l'�l�ment de parsing

    3857. 

  3857.          * @return	null

    3858. 

  3858.          */

    3859. 

  3859.         protected function c_BIG($param)

    3860. 

  3860.         {

    3861. 

  3861.             $this->style->load();

    3862. 

  3862.             $this->style->FontSet();

    3863. 

  3863.             

    3864. 

  3864.             return true;

    3865. 

  3865.         }

    3866. 

  3866. 

    3867. 

  3867.         /**

    3868. 

  3868.          * balise : SMALL

    3869. 

  3869.          * mode : OUVERTURE

    3870. 

  3870.          *

    3871. 

  3871.          * @param	array	param�tres de l'�l�ment de parsing

    3872. 

  3872.          * @return	null

    3873. 

  3873.          */

    3874. 

  3874.         protected function o_SMALL($param)

    3875. 

  3875.         {

    3876. 

  3876.             $this->style->save();

    3877. 

  3877.             $this->style->value['mini-decal'] += $this->style->value['mini-size'] * 0.05;

    3878. 

  3878.             $this->style->value['mini-size'] *= 0.82;

    3879. 

  3879.             $this->style->analyse('small', $param);

    3880. 

  3880.             $this->style->setPosition();

    3881. 

  3881.             $this->style->FontSet();

    3882. 

  3882.             return true;

    3883. 

  3883.         }

    3884. 

  3884. 

    3885. 

  3885.         /**

    3886. 

  3886.          * balise : SMALL

    3887. 

  3887.          * mode : FERMETURE

    3888. 

  3888.          *

    3889. 

  3889.          * @param	array	param�tres de l'�l�ment de parsing

    3890. 

  3890.          * @return	null

    3891. 

  3891.          */

    3892. 

  3892.         protected function c_SMALL($param)

    3893. 

  3893.         {

    3894. 

  3894.             $this->style->load();

    3895. 

  3895.             $this->style->FontSet();

    3896. 

  3896.             

    3897. 

  3897.             return true;

    3898. 

  3898.         }

    3899. 

  3899. 

    3900. 

  3900.         /**

    3901. 

  3901.          * balise : SUP

    3902. 

  3902.          * mode : OUVERTURE

    3903. 

  3903.          *

    3904. 

  3904.          * @param	array	param�tres de l'�l�ment de parsing

    3905. 

  3905.          * @return	null

    3906. 

  3906.          */

    3907. 

  3907.         protected function o_SUP($param)

    3908. 

  3908.         {

    3909. 

  3909.             $this->style->save();

    3910. 

  3910.             $this->style->value['mini-decal'] -= $this->style->value['mini-size'] * 0.15;

    3911. 

  3911.             $this->style->value['mini-size'] *= 0.75;

    3912. 

  3912.             $this->style->analyse('sup', $param);

    3913. 

  3913.             $this->style->setPosition();

    3914. 

  3914.             $this->style->FontSet();

    3915. 

  3915.             

    3916. 

  3916.             return true;

    3917. 

  3917.         }

    3918. 

  3918. 

    3919. 

  3919.         /**

    3920. 

  3920.          * balise : SUP

    3921. 

  3921.          * mode : FERMETURE

    3922. 

  3922.          *

    3923. 

  3923.          * @param	array	param�tres de l'�l�ment de parsing

    3924. 

  3924.          * @return	null

    3925. 

  3925.          */

    3926. 

  3926.         protected function c_SUP($param)

    3927. 

  3927.         {

    3928. 

  3928.             $this->style->load();

    3929. 

  3929.             $this->style->FontSet();

    3930. 

  3930.             

    3931. 

  3931.             return true;

    3932. 

  3932.         }

    3933. 

  3933. 

    3934. 

  3934.         /**

    3935. 

  3935.          * balise : SUB

    3936. 

  3936.          * mode : OUVERTURE

    3937. 

  3937.          *

    3938. 

  3938.          * @param	array	param�tres de l'�l�ment de parsing

    3939. 

  3939.          * @return	null

    3940. 

  3940.          */

    3941. 

  3941.         protected function o_SUB($param)

    3942. 

  3942.         {

    3943. 

  3943.             $this->style->save();

    3944. 

  3944.             $this->style->value['mini-decal'] += $this->style->value['mini-size'] * 0.15;

    3945. 

  3945.             $this->style->value['mini-size'] *= 0.75;

    3946. 

  3946.             $this->style->analyse('sub', $param);

    3947. 

  3947.             $this->style->setPosition();

    3948. 

  3948.             $this->style->FontSet();

    3949. 

  3949.             $this->inSub = 1;

    3950. 

  3950.             

    3951. 

  3951.             return true;

    3952. 

  3952.         }

    3953. 

  3953. 

    3954. 

  3954.         /**

    3955. 

  3955.          * balise : SUB

    3956. 

  3956.          * mode : FERMETURE

    3957. 

  3957.          *

    3958. 

  3958.          * @param	array	param�tres de l'�l�ment de parsing

    3959. 

  3959.          * @return	null

    3960. 

  3960.          */

    3961. 

  3961.         protected function c_SUB($param)

    3962. 

  3962.         {

    3963. 

  3963.             $this->style->load();

    3964. 

  3964.             $this->style->FontSet();

    3965. 

  3965.             

    3966. 

  3966.             return true;

    3967. 

  3967.         }

    3968. 

  3968. 

    3969. 

  3969.         /**

    3970. 

  3970.          * balise : UL

    3971. 

  3971.          * mode : OUVERTURE

    3972. 

  3972.          *

    3973. 

  3973.          * @param	array	param�tres de l'�l�ment de parsing

    3974. 

  3974.          * @return	null

    3975. 

  3975.          */

    3976. 

  3976.         protected function o_UL($param, $other = 'ul')

    3977. 

  3977.         {

    3978. 

  3978.             if ($this->forOneLine)

    3979. 

  3979.                 return false;

    3980. 

  3980.             

    3981. 

  3981.             if (! in_array($this->previousCall, array('c_P', 'c_UL')))

    3982. 

  3982.             {

    3983. 

  3983.                 if ($this->maxH)

    3984. 

  3984.                     $this->o_BR(array());

    3985. 

  3985.                 if (! count($this->defLIST))

    3986. 

  3986.                     $this->o_BR(array());

    3987. 

  3987.             }

    3988. 

  3988.             

    3989. 

  3989.             if (! isset($param['style']['width']))

    3990. 

  3990.                 $param['allwidth'] = true;

    3991. 

  3991.             $param['cellspacing'] = 0;

    3992. 

  3992.             

    3993. 

  3993.             // une liste est trait�e comme un tableau

    3994. 

  3994.             $this->o_TABLE($param, $other);

    3995. 

  3995.             

    3996. 

  3996.             // ajouter un niveau de liste

    3997. 

  3997.             $this->listeAddLevel($other, $this->style->value['list-style-type'], $this->style->value['list-style-image']);

    3998. 

  3998.             

    3999. 

  3999.             return true;

    4000. 

  4000.         }

    4001. 

  4001. 

    4002. 

  4002.         protected function o_OL($param)

    4003. 

  4003.         {

    4004. 

  4004.             return $this->o_UL($param, 'ol');

    4005. 

  4005.         }

    4006. 

  4006. 

    4007. 

  4007.         /**

    4008. 

  4008.          * balise : UL

    4009. 

  4009.          * mode : FERMETURE

    4010. 

  4010.          *

    4011. 

  4011.          * @param	array	param�tres de l'�l�ment de parsing

    4012. 

  4012.          * @return	null

    4013. 

  4013.          */

    4014. 

  4014.         protected function c_UL($param)

    4015. 

  4015.         {

    4016. 

  4016.             if ($this->forOneLine)

    4017. 

  4017.                 return false;

    4018. 

  4018.             

    4019. 

  4019.      // fin du tableau

    4020. 

  4020.             $this->c_TABLE($param);

    4021. 

  4021.             

    4022. 

  4022.             // enlever un niveau de liste

    4023. 

  4023.             $this->listeDelLevel();

    4024. 

  4024.             

    4025. 

  4025.             if (! $this->sub_part)

    4026. 

  4026.             {

    4027. 

  4027.                 if (! count($this->defLIST))

    4028. 

  4028.                     $this->o_BR(array());

    4029. 

  4029.             }

    4030. 

  4030.             

    4031. 

  4031.             return true;

    4032. 

  4032.         }

    4033. 

  4033. 

    4034. 

  4034.         protected function c_OL($param)

    4035. 

  4035.         {

    4036. 

  4036.             return $this->c_UL($param);

    4037. 

  4037.         }

    4038. 

  4038. 

    4039. 

  4039.         /**

    4040. 

  4040.          * balise : LI

    4041. 

  4041.          * mode : OUVERTURE

    4042. 

  4042.          *

    4043. 

  4043.          * @param	array	param�tres de l'�l�ment de parsing

    4044. 

  4044.          * @return	null

    4045. 

  4045.          */

    4046. 

  4046.         protected function o_LI($param)

    4047. 

  4047.         {

    4048. 

  4048.             if ($this->forOneLine)

    4049. 

  4049.                 return false;

    4050. 

  4050.             

    4051. 

  4051.      // ajouter une puce au niveau actuel

    4052. 

  4052.             $this->listeAddLi();

    4053. 

  4053.             

    4054. 

  4054.             if (! isset($param['style']['width']))

    4055. 

  4055.                 $param['style']['width'] = '100%';

    4056. 

  4056.             

    4057. 

  4057.      // preparation du style de la puce

    4058. 

  4058.             $paramPUCE = $param;

    4059. 

  4059.             

    4060. 

  4060.             $inf = $this->listeGetLi();

    4061. 

  4061.             if ($inf[0])

    4062. 

  4062.             {

    4063. 

  4063.                 $paramPUCE['style']['font-family'] = $inf[0];

    4064. 

  4064.                 $paramPUCE['style']['text-align'] = 'li_right';

    4065. 

  4065.                 $paramPUCE['style']['vertical-align'] = 'top';

    4066. 

  4066.                 $paramPUCE['style']['width'] = $this->listeGetWidth();

    4067. 

  4067.                 $paramPUCE['style']['padding-right'] = $this->listeGetPadding();

    4068. 

  4068.                 $paramPUCE['txt'] = $inf[2];

    4069. 

  4069.             }

    4070. 

  4070.             else

    4071. 

  4071.             {

    4072. 

  4072.                 $paramPUCE['style']['text-align'] = 'li_right';

    4073. 

  4073.                 $paramPUCE['style']['vertical-align'] = 'top';

    4074. 

  4074.                 $paramPUCE['style']['width'] = $this->listeGetWidth();

    4075. 

  4075.                 $paramPUCE['style']['padding-right'] = $this->listeGetPadding();

    4076. 

  4076.                 $paramPUCE['src'] = $inf[2];

    4077. 

  4077.                 $paramPUCE['sub_li'] = true;

    4078. 

  4078.             }

    4079. 

  4079.             

    4080. 

  4080.             // nouvelle ligne

    4081. 

  4081.             $this->o_TR($param, 'li');

    4082. 

  4082.             

    4083. 

  4083.             $this->style->save();

    4084. 

  4084.             

    4085. 

  4085.             if ($inf[1]) // small

    4086. 

  4086.             {

    4087. 

  4087.                 $this->style->value['mini-decal'] += $this->style->value['mini-size'] * 0.045;

    4088. 

  4088.                 $this->style->value['mini-size'] *= 0.75;

    4089. 

  4089.             }

    4090. 

  4090.             

    4091. 

  4091.             // si on est dans un sub_html => preparation, sinon affichage classique

    4092. 

  4092.             if ($this->sub_part)

    4093. 

  4093.             {

    4094. 

  4094.                 // TD pour la puce

    4095. 

  4095.                 $tmp_pos = $this->temp_pos;

    4096. 

  4096.                 $tmp_lst1 = $this->parsing->code[$tmp_pos + 1];

    4097. 

  4097.                 $tmp_lst2 = $this->parsing->code[$tmp_pos + 2];

    4098. 

  4098.                 $this->parsing->code[$tmp_pos + 1] = array();

    4099. 

  4099.                 $this->parsing->code[$tmp_pos + 1]['name'] = (isset($paramPUCE['src'])) ? 'img' : 'write';

    4100. 

  4100.                 $this->parsing->code[$tmp_pos + 1]['param'] = $paramPUCE;

    4101. 

  4101.                 unset($this->parsing->code[$tmp_pos + 1]['param']['style']['width']);

    4102. 

  4102.                 $this->parsing->code[$tmp_pos + 1]['close'] = 0;

    4103. 

  4103.                 $this->parsing->code[$tmp_pos + 2] = array();

    4104. 

  4104.                 $this->parsing->code[$tmp_pos + 2]['name'] = 'li';

    4105. 

  4105.                 $this->parsing->code[$tmp_pos + 2]['param'] = $paramPUCE;

    4106. 

  4106.                 $this->parsing->code[$tmp_pos + 2]['close'] = 1;

    4107. 

  4107.                 $this->o_TD($paramPUCE, 'li_sub');

    4108. 

  4108.                 $this->c_TD($param);

    4109. 

  4109.                 $this->temp_pos = $tmp_pos;

    4110. 

  4110.                 $this->parsing->code[$tmp_pos + 1] = $tmp_lst1;

    4111. 

  4111.                 $this->parsing->code[$tmp_pos + 2] = $tmp_lst2;

    4112. 

  4112.             }

    4113. 

  4113.             else

    4114. 

  4114.             {

    4115. 

  4115.                 // TD pour la puce

    4116. 

  4116.                 $this->o_TD($paramPUCE, 'li_sub');

    4117. 

  4117.                 unset($paramPUCE['style']['width']);

    4118. 

  4118.                 if (isset($paramPUCE['src']))

    4119. 

  4119.                     $this->o_IMG($paramPUCE);

    4120. 

  4120.                 else

    4121. 

  4121.                     $this->o_WRITE($paramPUCE);

    4122. 

  4122.                 $this->c_TD($paramPUCE);

    4123. 

  4123.             }

    4124. 

  4124.             $this->style->load();

    4125. 

  4125.             

    4126. 

  4126.             // td pour le contenu

    4127. 

  4127.             $this->o_TD($param, 'li');

    4128. 

  4128.             

    4129. 

  4129.             return true;

    4130. 

  4130.         }

    4131. 

  4131. 

    4132. 

  4132.         /**

    4133. 

  4133.          * balise : LI

    4134. 

  4134.          * mode : FERMETURE

    4135. 

  4135.          *

    4136. 

  4136.          * @param	array	param�tres de l'�l�ment de parsing

    4137. 

  4137.          * @return	null

    4138. 

  4138.          */

    4139. 

  4139.         protected function c_LI($param)

    4140. 

  4140.         {

    4141. 

  4141.             if ($this->forOneLine)

    4142. 

  4142.                 return false;

    4143. 

  4143.             

    4144. 

  4144.      // fin du contenu

    4145. 

  4145.             $this->c_TD($param);

    4146. 

  4146.             

    4147. 

  4147.             // fin de la ligne

    4148. 

  4148.             $this->c_TR($param);

    4149. 

  4149.             

    4150. 

  4150.             return true;

    4151. 

  4151.         }

    4152. 

  4152. 

    4153. 

  4153.         /**

    4154. 

  4154.          * balise : TBODY

    4155. 

  4155.          * mode : OUVERTURE

    4156. 

  4156.          *

    4157. 

  4157.          * @param	array	param�tres de l'�l�ment de parsing

    4158. 

  4158.          * @return	null

    4159. 

  4159.          */

    4160. 

  4160.         protected function o_TBODY($param)

    4161. 

  4161.         {

    4162. 

  4162.             if ($this->forOneLine)

    4163. 

  4163.                 return false;

    4164. 

  4164.             

    4165. 

  4165.             $this->style->save();

    4166. 

  4166.             $this->style->analyse('tbody', $param);

    4167. 

  4167.             $this->style->setPosition();

    4168. 

  4168.             $this->style->FontSet();

    4169. 

  4169.             

    4170. 

  4170.             return true;

    4171. 

  4171.         }

    4172. 

  4172. 

    4173. 

  4173.         /**

    4174. 

  4174.          * balise : TBODY

    4175. 

  4175.          * mode : FERMETURE

    4176. 

  4176.          *

    4177. 

  4177.          * @param	array	param�tres de l'�l�ment de parsing

    4178. 

  4178.          * @return	null

    4179. 

  4179.          */

    4180. 

  4180.         protected function c_TBODY($param)

    4181. 

  4181.         {

    4182. 

  4182.             if ($this->forOneLine)

    4183. 

  4183.                 return false;

    4184. 

  4184.             

    4185. 

  4185.             $this->style->load();

    4186. 

  4186.             $this->style->FontSet();

    4187. 

  4187.             

    4188. 

  4188.             return true;

    4189. 

  4189.         }

    4190. 

  4190. 

    4191. 

  4191.         /**

    4192. 

  4192.          * balise : THEAD

    4193. 

  4193.          * mode : OUVERTURE

    4194. 

  4194.          *

    4195. 

  4195.          * @param	array	param�tres de l'�l�ment de parsing

    4196. 

  4196.          * @return	null

    4197. 

  4197.          */

    4198. 

  4198.         protected function o_THEAD($param)

    4199. 

  4199.         {

    4200. 

  4200.             if ($this->forOneLine)

    4201. 

  4201.                 return false;

    4202. 

  4202.             

    4203. 

  4203.             $this->style->save();

    4204. 

  4204.             $this->style->analyse('thead', $param);

    4205. 

  4205.             $this->style->setPosition();

    4206. 

  4206.             $this->style->FontSet();

    4207. 

  4207.             

    4208. 

  4208.             // si on est en mode sub_html : sauvegarde du num�ro du TR

    4209. 

  4209.             if ($this->sub_part)

    4210. 

  4210.             {

    4211. 

  4211.                 HTML2PDF :: $TABLES[$param['num']]['thead']['tr'][0] = HTML2PDF :: $TABLES[$param['num']]['tr_curr'];

    4212. 

  4212.                 HTML2PDF :: $TABLES[$param['num']]['thead']['code'] = array();

    4213. 

  4213.                 for($pos = $this->temp_pos; $pos < count($this->parsing->code); $pos ++)

    4214. 

  4214.                 {

    4215. 

  4215.                     $todo = $this->parsing->code[$pos];

    4216. 

  4216.                     if (strtolower($todo['name']) == 'thead')

    4217. 

  4217.                         $todo['name'] = 'thead_sub';

    4218. 

  4218.                     HTML2PDF :: $TABLES[$param['num']]['thead']['code'][] = $todo;

    4219. 

  4219.                     if (strtolower($todo['name']) == 'thead_sub' && $todo['close'])

    4220. 

  4220.                         break;

    4221. 

  4221.                 }

    4222. 

  4222.             }

    4223. 

  4223.             else

    4224. 

  4224.             {

    4225. 

  4225.                 $level = $this->parsing->getLevel($this->parse_pos);

    4226. 

  4226.                 $this->parse_pos += count($level);

    4227. 

  4227.                 HTML2PDF :: $TABLES[$param['num']]['tr_curr'] += count(HTML2PDF :: $TABLES[$param['num']]['thead']['tr']);

    4228. 

  4228.             }

    4229. 

  4229.             

    4230. 

  4230.             return true;

    4231. 

  4231.         }

    4232. 

  4232. 

    4233. 

  4233.         /**

    4234. 

  4234.          * balise : THEAD

    4235. 

  4235.          * mode : FERMETURE

    4236. 

  4236.          *

    4237. 

  4237.          * @param	array	param�tres de l'�l�ment de parsing

    4238. 

  4238.          * @return	null

    4239. 

  4239.          */

    4240. 

  4240.         protected function c_THEAD($param)

    4241. 

  4241.         {

    4242. 

  4242.             if ($this->forOneLine)

    4243. 

  4243.                 return false;

    4244. 

  4244.             

    4245. 

  4245.             $this->style->load();

    4246. 

  4246.             $this->style->FontSet();

    4247. 

  4247.             

    4248. 

  4248.             // si on est en mode sub_html : sauvegarde du num�ro du TR

    4249. 

  4249.             if ($this->sub_part)

    4250. 

  4250.             {

    4251. 

  4251.                 $min = HTML2PDF :: $TABLES[$param['num']]['thead']['tr'][0];

    4252. 

  4252.                 $max = HTML2PDF :: $TABLES[$param['num']]['tr_curr'] - 1;

    4253. 

  4253.                 HTML2PDF :: $TABLES[$param['num']]['thead']['tr'] = range($min, $max);

    4254. 

  4254.             }

    4255. 

  4255.             

    4256. 

  4256.             return true;

    4257. 

  4257.         }

    4258. 

  4258. 

    4259. 

  4259.         /**

    4260. 

  4260.          * balise : TFOOT

    4261. 

  4261.          * mode : OUVERTURE

    4262. 

  4262.          *

    4263. 

  4263.          * @param	array	param�tres de l'�l�ment de parsing

    4264. 

  4264.          * @return	null

    4265. 

  4265.          */

    4266. 

  4266.         protected function o_TFOOT($param)

    4267. 

  4267.         {

    4268. 

  4268.             if ($this->forOneLine)

    4269. 

  4269.                 return false;

    4270. 

  4270.             

    4271. 

  4271.             $this->style->save();

    4272. 

  4272.             $this->style->analyse('tfoot', $param);

    4273. 

  4273.             $this->style->setPosition();

    4274. 

  4274.             $this->style->FontSet();

    4275. 

  4275.             

    4276. 

  4276.             // si on est en mode sub_html : sauvegarde du num�ro du TR

    4277. 

  4277.             if ($this->sub_part)

    4278. 

  4278.             {

    4279. 

  4279.                 HTML2PDF :: $TABLES[$param['num']]['tfoot']['tr'][0] = HTML2PDF :: $TABLES[$param['num']]['tr_curr'];

    4280. 

  4280.                 HTML2PDF :: $TABLES[$param['num']]['tfoot']['code'] = array();

    4281. 

  4281.                 for($pos = $this->temp_pos; $pos < count($this->parsing->code); $pos ++)

    4282. 

  4282.                 {

    4283. 

  4283.                     $todo = $this->parsing->code[$pos];

    4284. 

  4284.                     if (strtolower($todo['name']) == 'tfoot')

    4285. 

  4285.                         $todo['name'] = 'tfoot_sub';

    4286. 

  4286.                     HTML2PDF :: $TABLES[$param['num']]['tfoot']['code'][] = $todo;

    4287. 

  4287.                     if (strtolower($todo['name']) == 'tfoot_sub' && $todo['close'])

    4288. 

  4288.                         break;

    4289. 

  4289.                 }

    4290. 

  4290.             }

    4291. 

  4291.             else

    4292. 

  4292.             {

    4293. 

  4293.                 $level = $this->parsing->getLevel($this->parse_pos);

    4294. 

  4294.                 $this->parse_pos += count($level);

    4295. 

  4295.                 HTML2PDF :: $TABLES[$param['num']]['tr_curr'] += count(HTML2PDF :: $TABLES[$param['num']]['tfoot']['tr']);

    4296. 

  4296.             }

    4297. 

  4297.             

    4298. 

  4298.             return true;

    4299. 

  4299.         }

    4300. 

  4300. 

    4301. 

  4301.         /**

    4302. 

  4302.          * balise : TFOOT

    4303. 

  4303.          * mode : FERMETURE

    4304. 

  4304.          *

    4305. 

  4305.          * @param	array	param�tres de l'�l�ment de parsing

    4306. 

  4306.          * @return	null

    4307. 

  4307.          */

    4308. 

  4308.         protected function c_TFOOT($param)

    4309. 

  4309.         {

    4310. 

  4310.             if ($this->forOneLine)

    4311. 

  4311.                 return false;

    4312. 

  4312.             

    4313. 

  4313.             $this->style->load();

    4314. 

  4314.             $this->style->FontSet();

    4315. 

  4315.             

    4316. 

  4316.             // si on est en mode sub_html : sauvegarde du num�ro du TR

    4317. 

  4317.             if ($this->sub_part)

    4318. 

  4318.             {

    4319. 

  4319.                 $min = HTML2PDF :: $TABLES[$param['num']]['tfoot']['tr'][0];

    4320. 

  4320.                 $max = HTML2PDF :: $TABLES[$param['num']]['tr_curr'] - 1;

    4321. 

  4321.                 HTML2PDF :: $TABLES[$param['num']]['tfoot']['tr'] = range($min, $max);

    4322. 

  4322.             }

    4323. 

  4323.             

    4324. 

  4324.             return true;

    4325. 

  4325.         }

    4326. 

  4326. 

    4327. 

  4327.         /**

    4328. 

  4328.          * balise : THEAD_SUB

    4329. 

  4329.          * mode : OUVERTURE

    4330. 

  4330.          *

    4331. 

  4331.          * @param	array	param�tres de l'�l�ment de parsing

    4332. 

  4332.          * @return	null

    4333. 

  4333.          */

    4334. 

  4334.         protected function o_THEAD_SUB($param)

    4335. 

  4335.         {

    4336. 

  4336.             if ($this->forOneLine)

    4337. 

  4337.                 return false;

    4338. 

  4338.             

    4339. 

  4339.             $this->style->save();

    4340. 

  4340.             $this->style->analyse('thead', $param);

    4341. 

  4341.             $this->style->setPosition();

    4342. 

  4342.             $this->style->FontSet();

    4343. 

  4343.             

    4344. 

  4344.             return true;

    4345. 

  4345.         }

    4346. 

  4346. 

    4347. 

  4347.         /**

    4348. 

  4348.          * balise : THEAD_SUB

    4349. 

  4349.          * mode : FERMETURE

    4350. 

  4350.          *

    4351. 

  4351.          * @param	array	param�tres de l'�l�ment de parsing

    4352. 

  4352.          * @return	null

    4353. 

  4353.          */

    4354. 

  4354.         protected function c_THEAD_SUB($param)

    4355. 

  4355.         {

    4356. 

  4356.             if ($this->forOneLine)

    4357. 

  4357.                 return false;

    4358. 

  4358.             

    4359. 

  4359.             $this->style->load();

    4360. 

  4360.             $this->style->FontSet();

    4361. 

  4361.             

    4362. 

  4362.             return true;

    4363. 

  4363.         }

    4364. 

  4364. 

    4365. 

  4365.         /**

    4366. 

  4366.          * balise : TFOOT_SUB

    4367. 

  4367.          * mode : OUVERTURE

    4368. 

  4368.          *

    4369. 

  4369.          * @param	array	param�tres de l'�l�ment de parsing

    4370. 

  4370.          * @return	null

    4371. 

  4371.          */

    4372. 

  4372.         protected function o_TFOOT_SUB($param)

    4373. 

  4373.         {

    4374. 

  4374.             if ($this->forOneLine)

    4375. 

  4375.                 return false;

    4376. 

  4376.             

    4377. 

  4377.             $this->style->save();

    4378. 

  4378.             $this->style->analyse('tfoot', $param);

    4379. 

  4379.             $this->style->setPosition();

    4380. 

  4380.             $this->style->FontSet();

    4381. 

  4381.             

    4382. 

  4382.             return true;

    4383. 

  4383.         }

    4384. 

  4384. 

    4385. 

  4385.         /**

    4386. 

  4386.          * balise : TFOOT_SUB

    4387. 

  4387.          * mode : FERMETURE

    4388. 

  4388.          *

    4389. 

  4389.          * @param	array	param�tres de l'�l�ment de parsing

    4390. 

  4390.          * @return	null

    4391. 

  4391.          */

    4392. 

  4392.         protected function c_TFOOT_SUB($param)

    4393. 

  4393.         {

    4394. 

  4394.             if ($this->forOneLine)

    4395. 

  4395.                 return false;

    4396. 

  4396.             

    4397. 

  4397.             $this->style->load();

    4398. 

  4398.             $this->style->FontSet();

    4399. 

  4399.             

    4400. 

  4400.             return true;

    4401. 

  4401.         }

    4402. 

  4402. 

    4403. 

  4403.         /**

    4404. 

  4404.          * balise : FORM

    4405. 

  4405.          * mode : OUVERTURE

    4406. 

  4406.          *

    4407. 

  4407.          * @param	array	param�tres de l'�l�ment de parsing

    4408. 

  4408.          * @return	null

    4409. 

  4409.          */

    4410. 

  4410.         protected function o_FORM($param)

    4411. 

  4411.         {

    4412. 

  4412.             $this->style->save();

    4413. 

  4413.             $this->style->analyse('form', $param);

    4414. 

  4414.             $this->style->setPosition();

    4415. 

  4415.             $this->style->FontSet();

    4416. 

  4416.             

    4417. 

  4417.             $this->pdf->setFormDefaultProp(array('lineWidth' => 1, 'borderStyle' => 'solid', 

    4418. 

  4418.                     'fillColor' => array(220, 220, 255), 'strokeColor' => array(128, 128, 200)));

    4419. 

  4419.             

    4420. 

  4420.             $this->isInForm = isset($param['action']) ? $param['action'] : '';

    4421. 

  4421.             

    4422. 

  4422.             return true;

    4423. 

  4423.         }

    4424. 

  4424. 

    4425. 

  4425.         /**

    4426. 

  4426.          * balise : FORM

    4427. 

  4427.          * mode : FERMETURE

    4428. 

  4428.          *

    4429. 

  4429.          * @param	array	param�tres de l'�l�ment de parsing

    4430. 

  4430.          * @return	null

    4431. 

  4431.          */

    4432. 

  4432.         protected function c_FORM($param)

    4433. 

  4433.         {

    4434. 

  4434.             $this->isInForm = false;

    4435. 

  4435.             $this->style->load();

    4436. 

  4436.             $this->style->FontSet();

    4437. 

  4437.             

    4438. 

  4438.             return true;

    4439. 

  4439.         }

    4440. 

  4440. 

    4441. 

  4441.         /**

    4442. 

  4442.          * balise : TABLE

    4443. 

  4443.          * mode : OUVERTURE

    4444. 

  4444.          *

    4445. 

  4445.          * @param	array	param�tres de l'�l�ment de parsing

    4446. 

  4446.          * @return	null

    4447. 

  4447.          */

    4448. 

  4448.         protected function o_TABLE($param, $other = 'table')

    4449. 

  4449.         {

    4450. 

  4450.             if ($this->maxH)

    4451. 

  4451.             {

    4452. 

  4452.                 if ($this->forOneLine)

    4453. 

  4453.                     return false;

    4454. 

  4454.                 $this->o_BR(array());

    4455. 

  4455.             }

    4456. 

  4456.             

    4457. 

  4457.             if ($this->forOneLine)

    4458. 

  4458.             {

    4459. 

  4459.                 $this->maxE ++;

    4460. 

  4460.                 $this->maxX = $this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin();

    4461. 

  4461.                 return false;

    4462. 

  4462.             }

    4463. 

  4463.             

    4464. 

  4464.             $this->maxH = 0;

    4465. 

  4465.             

    4466. 

  4466.             $align_object = isset($param['align']) ? strtolower($param['align']) : 'left';

    4467. 

  4467.             if (isset($param['align']))

    4468. 

  4468.                 unset($param['align']);

    4469. 

  4469.             if (! in_array($align_object, array('left', 'center', 'right')))

    4470. 

  4470.                 $align_object = 'left';

    4471. 

  4471.             

    4472. 

  4472.      // lecture et initialisation du style

    4473. 

  4473.             $this->style->save();

    4474. 

  4474.             $this->style->analyse($other, $param);

    4475. 

  4475.             $this->style->setPosition();

    4476. 

  4476.             $this->style->FontSet();

    4477. 

  4477.             

    4478. 

  4478.             if ($this->style->value['margin-auto'])

    4479. 

  4479.                 $align_object = 'center';

    4480. 

  4480.             

    4481. 

  4481.      // est-on en collapse

    4482. 

  4482.             $collapse = false;

    4483. 

  4483.             if ($other == 'table')

    4484. 

  4484.                 $collapse = isset($this->style->value['border']['collapse']) ? $this->style->value['border']['collapse'] : false;

    4485. 

  4485.             

    4486. 

  4486.      // si oui il faut adapt� les borders

    4487. 

  4487.             if ($collapse)

    4488. 

  4488.             {

    4489. 

  4489.                 $param['style']['border'] = 'none';

    4490. 

  4490.                 $param['cellspacing'] = 0;

    4491. 

  4491.                 $none = $this->style->readBorder('none');

    4492. 

  4492.                 $this->style->value['border']['t'] = $none;

    4493. 

  4493.                 $this->style->value['border']['r'] = $none;

    4494. 

  4494.                 $this->style->value['border']['b'] = $none;

    4495. 

  4495.                 $this->style->value['border']['l'] = $none;

    4496. 

  4496.             }

    4497. 

  4497.             

    4498. 

  4498.             // si on est en mode sub_html : initialisation des dimensions et autres

    4499. 

  4499.             if ($this->sub_part)

    4500. 

  4500.             {

    4501. 

  4501.                 if ($this->DEBUG_actif)

    4502. 

  4502.                     $this->DEBUG_add('Table n�' . $param['num'], true);

    4503. 

  4503.                 HTML2PDF :: $TABLES[$param['num']] = array();

    4504. 

  4504.                 HTML2PDF :: $TABLES[$param['num']]['border'] = isset($param['border']) ? $this->style->readBorder($param['border']) : null; // border sp�cifique si border precis� en param�tre

    4505. 

  4505.                 HTML2PDF :: $TABLES[$param['num']]['cellpadding'] = $this->style->ConvertToMM(isset($param['cellpadding']) ? $param['cellpadding'] : '1px'); // cellpadding du tableau

    4506. 

  4506.                 HTML2PDF :: $TABLES[$param['num']]['cellspacing'] = $this->style->ConvertToMM(isset($param['cellspacing']) ? $param['cellspacing'] : '2px'); // cellspacing du tableau

    4507. 

  4507.                 HTML2PDF :: $TABLES[$param['num']]['cases'] = array(); // liste des propri�t�s des cases

    4508. 

  4508.                 HTML2PDF :: $TABLES[$param['num']]['corr'] = array(); // tableau de correlation pour les colspan et rowspan

    4509. 

  4509.                 HTML2PDF :: $TABLES[$param['num']]['corr_x'] = 0; // position dans le tableau de correlation

    4510. 

  4510.                 HTML2PDF :: $TABLES[$param['num']]['corr_y'] = 0; // position dans le tableau de correlation

    4511. 

  4511.                 HTML2PDF :: $TABLES[$param['num']]['td_curr'] = 0; // colonne courante

    4512. 

  4512.                 HTML2PDF :: $TABLES[$param['num']]['tr_curr'] = 0; // ligne courante

    4513. 

  4513.                 HTML2PDF :: $TABLES[$param['num']]['curr_x'] = $this->pdf->getX(); // position courante X

    4514. 

  4514.                 HTML2PDF :: $TABLES[$param['num']]['curr_y'] = $this->pdf->getY(); // position courante Y

    4515. 

  4515.                 HTML2PDF :: $TABLES[$param['num']]['width'] = 0; // largeur globale

    4516. 

  4516.                 HTML2PDF :: $TABLES[$param['num']]['height'] = 0; // hauteur globale

    4517. 

  4517.                 HTML2PDF :: $TABLES[$param['num']]['align'] = $align_object;

    4518. 

  4518.                 HTML2PDF :: $TABLES[$param['num']]['marge'] = array();

    4519. 

  4519.                 HTML2PDF :: $TABLES[$param['num']]['marge']['t'] = $this->style->value['padding']['t'] + $this->style->value['border']['t']['width'] + HTML2PDF :: $TABLES[$param['num']]['cellspacing'] * 0.5;

    4520. 

  4520.                 HTML2PDF :: $TABLES[$param['num']]['marge']['r'] = $this->style->value['padding']['r'] + $this->style->value['border']['r']['width'] + HTML2PDF :: $TABLES[$param['num']]['cellspacing'] * 0.5;

    4521. 

  4521.                 HTML2PDF :: $TABLES[$param['num']]['marge']['b'] = $this->style->value['padding']['b'] + $this->style->value['border']['b']['width'] + HTML2PDF :: $TABLES[$param['num']]['cellspacing'] * 0.5;

    4522. 

  4522.                 HTML2PDF :: $TABLES[$param['num']]['marge']['l'] = $this->style->value['padding']['l'] + $this->style->value['border']['l']['width'] + HTML2PDF :: $TABLES[$param['num']]['cellspacing'] * 0.5;

    4523. 

  4523.                 HTML2PDF :: $TABLES[$param['num']]['page'] = 0; // nombre de pages

    4524. 

  4524.                 HTML2PDF :: $TABLES[$param['num']]['new_page'] = true; // nouvelle page pour le TR courant

    4525. 

  4525.                 HTML2PDF :: $TABLES[$param['num']]['style_value'] = null; // style du tableau

    4526. 

  4526.                 HTML2PDF :: $TABLES[$param['num']]['thead'] = array(); // infos sur le thead

    4527. 

  4527.                 HTML2PDF :: $TABLES[$param['num']]['tfoot'] = array(); // infos sur le tfoot

    4528. 

  4528.                 HTML2PDF :: $TABLES[$param['num']]['thead']['tr'] = array(); // tr du thead

    4529. 

  4529.                 HTML2PDF :: $TABLES[$param['num']]['tfoot']['tr'] = array(); // tr du tfoot

    4530. 

  4530.                 HTML2PDF :: $TABLES[$param['num']]['thead']['height'] = 0; // hauteur du thead

    4531. 

  4531.                 HTML2PDF :: $TABLES[$param['num']]['tfoot']['height'] = 0; // hauteur du tfoot

    4532. 

  4532.                 HTML2PDF :: $TABLES[$param['num']]['thead']['code'] = array(); // contenu HTML du thead

    4533. 

  4533.                 HTML2PDF :: $TABLES[$param['num']]['tfoot']['code'] = array(); // contenu HTML du tfoot

    4534. 

  4534.                 HTML2PDF :: $TABLES[$param['num']]['cols'] = array(); // definition via les balises col

    4535. 

  4535.                 $this->saveMargin($this->pdf->getlMargin(), $this->pdf->gettMargin(), $this->pdf->getrMargin());

    4536. 

  4536.                 

    4537. 

  4537.                 // adaptation de la largeur en fonction des marges du tableau

    4538. 

  4538.                 $this->style->value['width'] -= HTML2PDF :: $TABLES[$param['num']]['marge']['l'] + HTML2PDF :: $TABLES[$param['num']]['marge']['r'];

    4539. 

  4539.             }

    4540. 

  4540.             else

    4541. 

  4541.             {

    4542. 

  4542.                 // on repart � la premiere page du tableau et � la premiere case

    4543. 

  4543.                 HTML2PDF :: $TABLES[$param['num']]['page'] = 0;

    4544. 

  4544.                 HTML2PDF :: $TABLES[$param['num']]['td_curr'] = 0;

    4545. 

  4545.                 HTML2PDF :: $TABLES[$param['num']]['tr_curr'] = 0;

    4546. 

  4546.                 HTML2PDF :: $TABLES[$param['num']]['td_x'] = HTML2PDF :: $TABLES[$param['num']]['marge']['l'] + HTML2PDF :: $TABLES[$param['num']]['curr_x'];

    4547. 

  4547.                 HTML2PDF :: $TABLES[$param['num']]['td_y'] = HTML2PDF :: $TABLES[$param['num']]['marge']['t'] + HTML2PDF :: $TABLES[$param['num']]['curr_y'];

    4548. 

  4548.                 

    4549. 

  4549.                 // initialisation du style des bordures de la premiere partie de tableau

    4550. 

  4550.                 $this->drawRectangle(HTML2PDF :: $TABLES[$param['num']]['curr_x'], HTML2PDF :: $TABLES[$param['num']]['curr_y'], HTML2PDF :: $TABLES[$param['num']]['width'], isset(HTML2PDF :: $TABLES[$param['num']]['height'][0]) ? HTML2PDF :: $TABLES[$param['num']]['height'][0] : null, $this->style->value['border'], $this->style->value['padding'], 0, $this->style->value['background']);

    4551. 

  4551.                 

    4552. 

  4552.                 HTML2PDF :: $TABLES[$param['num']]['style_value'] = $this->style->value;

    4553. 

  4553.             }

    4554. 

  4554.             

    4555. 

  4555.             return true;

    4556. 

  4556.         }

    4557. 

  4557. 

    4558. 

  4558.         /**

    4559. 

  4559.          * balise : TABLE

    4560. 

  4560.          * mode : FERMETURE

    4561. 

  4561.          *

    4562. 

  4562.          * @param	array	param�tres de l'�l�ment de parsing

    4563. 

  4563.          * @return	null

    4564. 

  4564.          */

    4565. 

  4565.         protected function c_TABLE($param)

    4566. 

  4566.         {

    4567. 

  4567.             if ($this->forOneLine)

    4568. 

  4568.                 return false;

    4569. 

  4569.             

    4570. 

  4570.             $this->maxH = 0;

    4571. 

  4571.             

    4572. 

  4572.             // restauration du style

    4573. 

  4573.             $this->style->load();

    4574. 

  4574.             $this->style->FontSet();

    4575. 

  4575.             

    4576. 

  4576.             // si on est en mode sub_html : initialisation des dimensions et autres

    4577. 

  4577.             if ($this->sub_part)

    4578. 

  4578.             {

    4579. 

  4579.                 // ajustement de la taille des cases

    4580. 

  4580.                 $this->calculTailleCases(HTML2PDF :: $TABLES[$param['num']]['cases'], HTML2PDF :: $TABLES[$param['num']]['corr']);

    4581. 

  4581.                 

    4582. 

  4582.                 // calcul de la hauteur du THEAD et du TFOOT

    4583. 

  4583.                 $lst = array('thead', 'tfoot');

    4584. 

  4584.                 foreach ($lst as $mode)

    4585. 

  4585.                 {

    4586. 

  4586.                     HTML2PDF :: $TABLES[$param['num']][$mode]['height'] = 0;

    4587. 

  4587.                     foreach (HTML2PDF :: $TABLES[$param['num']][$mode]['tr'] as $tr)

    4588. 

  4588.                     {

    4589. 

  4589.                         // hauteur de la ligne tr

    4590. 

  4590.                         $h = 0;

    4591. 

  4591.                         for($i = 0; $i < count(HTML2PDF :: $TABLES[$param['num']]['cases'][$tr]); $i ++)

    4592. 

  4592.                             if (HTML2PDF :: $TABLES[$param['num']]['cases'][$tr][$i]['rowspan'] == 1)

    4593. 

  4593.                                 $h = max($h, HTML2PDF :: $TABLES[$param['num']]['cases'][$tr][$i]['h']);

    4594. 

  4594.                         HTML2PDF :: $TABLES[$param['num']][$mode]['height'] += $h;

    4595. 

  4595.                     }

    4596. 

  4596.                 }

    4597. 

  4597.                 

    4598. 

  4598.                 // calcul des dimensions du tableau - Largeur

    4599. 

  4599.                 HTML2PDF :: $TABLES[$param['num']]['width'] = HTML2PDF :: $TABLES[$param['num']]['marge']['l'] + HTML2PDF :: $TABLES[$param['num']]['marge']['r'];

    4600. 

  4600.                 if (isset(HTML2PDF :: $TABLES[$param['num']]['cases'][0]))

    4601. 

  4601.                     foreach (HTML2PDF :: $TABLES[$param['num']]['cases'][0] as $case)

    4602. 

  4602.                         HTML2PDF :: $TABLES[$param['num']]['width'] += $case['w'];

    4603. 

  4603.                 

    4604. 

  4604.      // positionnement du tableau horizontalement;

    4605. 

  4605.                 $old = $this->style->getOldValues();

    4606. 

  4606.                 $parent_w = $old['width'] ? $old['width'] : $this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin();

    4607. 

  4607.                 $x = HTML2PDF :: $TABLES[$param['num']]['curr_x'];

    4608. 

  4608.                 $w = HTML2PDF :: $TABLES[$param['num']]['width'];

    4609. 

  4609.                 if ($parent_w > $w)

    4610. 

  4610.                 {

    4611. 

  4611.                     if (HTML2PDF :: $TABLES[$param['num']]['align'] == 'center')

    4612. 

  4612.                         $x = $x + ($parent_w - $w) * 0.5;

    4613. 

  4613.                     else 

    4614. 

  4614.                         if (HTML2PDF :: $TABLES[$param['num']]['align'] == 'right')

    4615. 

  4615.                             $x = $x + $parent_w - $w;

    4616. 

  4616.                     

    4617. 

  4617.                     HTML2PDF :: $TABLES[$param['num']]['curr_x'] = $x;

    4618. 

  4618.                 }

    4619. 

  4619.                 

    4620. 

  4620.                 // calcul des dimensions du tableau - hauteur du tableau sur chaque page

    4621. 

  4621.                 HTML2PDF :: $TABLES[$param['num']]['height'] = array();

    4622. 

  4622.                 

    4623. 

  4623.                 $h0 = HTML2PDF :: $TABLES[$param['num']]['marge']['t'] + HTML2PDF :: $TABLES[$param['num']]['marge']['b']; // minimum de hauteur � cause des marges

    4624. 

  4624.                 $h0 += HTML2PDF :: $TABLES[$param['num']]['thead']['height'] + HTML2PDF :: $TABLES[$param['num']]['tfoot']['height']; // et du tfoot et thead

    4625. 

  4625.                 $max = $this->pdf->getH() - $this->pdf->getbMargin(); // max de hauteur par page

    4626. 

  4626.                 $y = HTML2PDF :: $TABLES[$param['num']]['curr_y']; // position Y actuelle

    4627. 

  4627.                 $height = $h0;

    4628. 

  4628.                 

    4629. 

  4629.                 // on va lire les hauteurs de chaque ligne, une � une, et voir si ca rentre sur la page.

    4630. 

  4630.                 for($k = 0; $k < count(HTML2PDF :: $TABLES[$param['num']]['cases']); $k ++)

    4631. 

  4631.                 {

    4632. 

  4632.                     // si c'est des lignes du thead ou du tfoot : on passe

    4633. 

  4633.                     if (in_array($k, HTML2PDF :: $TABLES[$param['num']]['thead']['tr']))

    4634. 

  4634.                         continue;

    4635. 

  4635.                     if (in_array($k, HTML2PDF :: $TABLES[$param['num']]['tfoot']['tr']))

    4636. 

  4636.                         continue;

    4637. 

  4637.                     

    4638. 

  4638.      // hauteur de la ligne $k

    4639. 

  4639.                     $th = 0;

    4640. 

  4640.                     $h = 0;

    4641. 

  4641.                     for($i = 0; $i < count(HTML2PDF :: $TABLES[$param['num']]['cases'][$k]); $i ++)

    4642. 

  4642.                     {

    4643. 

  4643.                         $h = max($h, HTML2PDF :: $TABLES[$param['num']]['cases'][$k][$i]['h']);

    4644. 

  4644.                         

    4645. 

  4645.                         if (HTML2PDF :: $TABLES[$param['num']]['cases'][$k][$i]['rowspan'] == 1)

    4646. 

  4646.                             $th = max($th, HTML2PDF :: $TABLES[$param['num']]['cases'][$k][$i]['h']);

    4647. 

  4647.                     }

    4648. 

  4648.                     

    4649. 

  4649.                     // si la ligne ne rentre pas dans la page

    4650. 

  4650.                     // => la hauteur sur cette page est trouv�e, et on passe � la page d'apres

    4651. 

  4651.                     if ($y + $h + $height > $max)

    4652. 

  4652.                     {

    4653. 

  4653.                         if ($height == $h0)

    4654. 

  4654.                             $height = null;

    4655. 

  4655.                         HTML2PDF :: $TABLES[$param['num']]['height'][] = $height;

    4656. 

  4656.                         $height = $h0;

    4657. 

  4657.                         $y = $this->margeTop;

    4658. 

  4658.                     }

    4659. 

  4659.                     $height += $th;

    4660. 

  4660.                 }

    4661. 

  4661.                 // rajout du reste de tableau (si il existe) � la derniere page

    4662. 

  4662.                 if ($height != $h0 || $k == 0)

    4663. 

  4663.                     HTML2PDF :: $TABLES[$param['num']]['height'][] = $height;

    4664. 

  4664.             }

    4665. 

  4665.             else

    4666. 

  4666.             {

    4667. 

  4667.                 if (count(HTML2PDF :: $TABLES[$param['num']]['tfoot']['code']))

    4668. 

  4668.                 {

    4669. 

  4669.                     $tmp_tr = HTML2PDF :: $TABLES[$param['num']]['tr_curr'];

    4670. 

  4670.                     $tmp_td = HTML2PDF :: $TABLES[$param['num']]['td_curr'];

    4671. 

  4671.                     $OLD_parse_pos = $this->parse_pos;

    4672. 

  4672.                     $OLD_parse_code = $this->parsing->code;

    4673. 

  4673.                     

    4674. 

  4674.                     HTML2PDF :: $TABLES[$param['num']]['tr_curr'] = HTML2PDF :: $TABLES[$param['num']]['tfoot']['tr'][0];

    4675. 

  4675.                     HTML2PDF :: $TABLES[$param['num']]['td_curr'] = 0;

    4676. 

  4676.                     $this->parse_pos = 0;

    4677. 

  4677.                     $this->parsing->code = HTML2PDF :: $TABLES[$param['num']]['tfoot']['code'];

    4678. 

  4678.                     $this->makeHTMLcode();

    4679. 

  4679.                     

    4680. 

  4680.                     $this->parse_pos = $OLD_parse_pos;

    4681. 

  4681.                     $this->parsing->code = $OLD_parse_code;

    4682. 

  4682.                     HTML2PDF :: $TABLES[$param['num']]['tr_curr'] = $tmp_tr;

    4683. 

  4683.                     HTML2PDF :: $TABLES[$param['num']]['td_curr'] = $tmp_td;

    4684. 

  4684.                 }

    4685. 

  4685.                 

    4686. 

  4686.                 // determination des coordonn�es de sortie du tableau

    4687. 

  4687.                 $x = HTML2PDF :: $TABLES[$param['num']]['curr_x'] + HTML2PDF :: $TABLES[$param['num']]['width'];

    4688. 

  4688.                 if (count(HTML2PDF :: $TABLES[$param['num']]['height']) > 1)

    4689. 

  4689.                     $y = $this->margeTop + HTML2PDF :: $TABLES[$param['num']]['height'][count(HTML2PDF :: $TABLES[$param['num']]['height']) - 1];

    4690. 

  4690.                 else 

    4691. 

  4691.                     if (count(HTML2PDF :: $TABLES[$param['num']]['height']) == 1)

    4692. 

  4692.                         $y = HTML2PDF :: $TABLES[$param['num']]['curr_y'] + HTML2PDF :: $TABLES[$param['num']]['height'][count(HTML2PDF :: $TABLES[$param['num']]['height']) - 1];

    4693. 

  4693.                     else

    4694. 

  4694.                         $y = HTML2PDF :: $TABLES[$param['num']]['curr_y'];

    4695. 

  4695.                 

    4696. 

  4696.      // taille du tableau

    4697. 

  4697.                 $this->maxX = max($this->maxX, $x);

    4698. 

  4698.                 $this->maxY = max($this->maxY, $y);

    4699. 

  4699.                 

    4700. 

  4700.                 // nouvelle position apres le tableau

    4701. 

  4701.                 $this->pdf->setXY($this->pdf->getlMargin(), $y);

    4702. 

  4702.                 

    4703. 

  4703.                 // restauration des marges

    4704. 

  4704.                 $this->loadMargin();

    4705. 

  4705.                 

    4706. 

  4706.                 if ($this->DEBUG_actif)

    4707. 

  4707.                     $this->DEBUG_add('Table n�' . $param['num'], false);

    4708. 

  4708.             }

    4709. 

  4709.             

    4710. 

  4710.             return true;

    4711. 

  4711.         }

    4712. 

  4712. 

    4713. 

  4713.         /**

    4714. 

  4714.          * balise : COL

    4715. 

  4715.          * mode : OUVERTURE (pas de fermeture)

    4716. 

  4716.          *

    4717. 

  4717.          * @param	array	param�tres de l'�l�ment de parsing

    4718. 

  4718.          * @return	null

    4719. 

  4719.          */

    4720. 

  4720.         protected function o_COL($param)

    4721. 

  4721.         {

    4722. 

  4722.             $span = isset($param['span']) ? $param['span'] : 1;

    4723. 

  4723.             for($k = 0; $k < $span; $k ++)

    4724. 

  4724.                 HTML2PDF :: $TABLES[$param['num']]['cols'][] = $param;

    4725. 

  4725.         }

    4726. 

  4726. 

    4727. 

  4727.         /**

    4728. 

  4728.          * balise : TR

    4729. 

  4729.          * mode : OUVERTURE

    4730. 

  4730.          *

    4731. 

  4731.          * @param	array	param�tres de l'�l�ment de parsing

    4732. 

  4732.          * @return	null

    4733. 

  4733.          */

    4734. 

  4734.         protected function o_TR($param, $other = 'tr')

    4735. 

  4735.         {

    4736. 

  4736.             if ($this->forOneLine)

    4737. 

  4737.                 return false;

    4738. 

  4738.             

    4739. 

  4739.             $this->maxH = 0;

    4740. 

  4740.             

    4741. 

  4741.             // analyse du style

    4742. 

  4742.             $this->style->save();

    4743. 

  4743.             $this->style->analyse($other, $param);

    4744. 

  4744.             $this->style->setPosition();

    4745. 

  4745.             $this->style->FontSet();

    4746. 

  4746.             

    4747. 

  4747.             // positionnement dans le tableau

    4748. 

  4748.             HTML2PDF :: $TABLES[$param['num']]['tr_curr'] ++;

    4749. 

  4749.             HTML2PDF :: $TABLES[$param['num']]['td_curr'] = 0;

    4750. 

  4750.             

    4751. 

  4751.             // si on est pas dans un sub_html

    4752. 

  4752.             if (! $this->sub_part)

    4753. 

  4753.             {

    4754. 

  4754.                 // Y courant apres la ligne

    4755. 

  4755.                 $ty = null;

    4756. 

  4756.                 for($ii = 0; $ii < count(HTML2PDF :: $TABLES[$param['num']]['cases'][HTML2PDF :: $TABLES[$param['num']]['tr_curr'] - 1]); $ii ++)

    4757. 

  4757.                     $ty = max($ty, HTML2PDF :: $TABLES[$param['num']]['cases'][HTML2PDF :: $TABLES[$param['num']]['tr_curr'] - 1][$ii]['h']);

    4758. 

  4758.                 

    4759. 

  4759.                 $hfoot = HTML2PDF :: $TABLES[$param['num']]['tfoot']['height'];

    4760. 

  4760.                 

    4761. 

  4761.                 // si la ligne ne rentre pas dans la page => nouvelle page

    4762. 

  4762.                 if (! $this->isInTfoot && HTML2PDF :: $TABLES[$param['num']]['td_y'] + HTML2PDF :: $TABLES[$param['num']]['marge']['b'] + $ty + $hfoot > $this->pdf->getH() - $this->pdf->getbMargin())

    4763. 

  4763.                 {

    4764. 

  4764.                     if (count(HTML2PDF :: $TABLES[$param['num']]['tfoot']['code']))

    4765. 

  4765.                     {

    4766. 

  4766.                         $tmp_tr = HTML2PDF :: $TABLES[$param['num']]['tr_curr'];

    4767. 

  4767.                         $tmp_td = HTML2PDF :: $TABLES[$param['num']]['td_curr'];

    4768. 

  4768.                         $OLD_parse_pos = $this->parse_pos;

    4769. 

  4769.                         $OLD_parse_code = $this->parsing->code;

    4770. 

  4770.                         

    4771. 

  4771.                         HTML2PDF :: $TABLES[$param['num']]['tr_curr'] = HTML2PDF :: $TABLES[$param['num']]['tfoot']['tr'][0];

    4772. 

  4772.                         HTML2PDF :: $TABLES[$param['num']]['td_curr'] = 0;

    4773. 

  4773.                         $this->parse_pos = 0;

    4774. 

  4774.                         $this->parsing->code = HTML2PDF :: $TABLES[$param['num']]['tfoot']['code'];

    4775. 

  4775.                         $this->isInTfoot = true;

    4776. 

  4776.                         $this->makeHTMLcode();

    4777. 

  4777.                         $this->isInTfoot = false;

    4778. 

  4778.                         

    4779. 

  4779.                         $this->parse_pos = $OLD_parse_pos;

    4780. 

  4780.                         $this->parsing->code = $OLD_parse_code;

    4781. 

  4781.                         HTML2PDF :: $TABLES[$param['num']]['tr_curr'] = $tmp_tr;

    4782. 

  4782.                         HTML2PDF :: $TABLES[$param['num']]['td_curr'] = $tmp_td;

    4783. 

  4783.                     }

    4784. 

  4784.                     

    4785. 

  4785.                     HTML2PDF :: $TABLES[$param['num']]['new_page'] = true;

    4786. 

  4786.                     $this->setNewPage();

    4787. 

  4787.                     

    4788. 

  4788.                     HTML2PDF :: $TABLES[$param['num']]['page'] ++;

    4789. 

  4789.                     HTML2PDF :: $TABLES[$param['num']]['curr_y'] = $this->pdf->getY();

    4790. 

  4790.                     HTML2PDF :: $TABLES[$param['num']]['td_y'] = HTML2PDF :: $TABLES[$param['num']]['curr_y'] + HTML2PDF :: $TABLES[$param['num']]['marge']['t'];

    4791. 

  4791.                     

    4792. 

  4792.                     // si la hauteur de cette partie a bien �t� calcul�e, on trace le cadre

    4793. 

  4793.                     if (isset(HTML2PDF :: $TABLES[$param['num']]['height'][HTML2PDF :: $TABLES[$param['num']]['page']]))

    4794. 

  4794.                     {

    4795. 

  4795.                         $old = $this->style->value;

    4796. 

  4796.                         $this->style->value = HTML2PDF :: $TABLES[$param['num']]['style_value'];

    4797. 

  4797.                         

    4798. 

  4798.                         // initialisation du style des bordures de la premiere partie de tableau

    4799. 

  4799.                         $this->drawRectangle(HTML2PDF :: $TABLES[$param['num']]['curr_x'], HTML2PDF :: $TABLES[$param['num']]['curr_y'], HTML2PDF :: $TABLES[$param['num']]['width'], HTML2PDF :: $TABLES[$param['num']]['height'][HTML2PDF :: $TABLES[$param['num']]['page']], $this->style->value['border'], $this->style->value['padding'], HTML2PDF :: $TABLES[$param['num']]['cellspacing'] * 0.5, $this->style->value['background']);

    4800. 

  4800.                         

    4801. 

  4801.                         $this->style->value = $old;

    4802. 

  4802.                     }

    4803. 

  4803.                 }

    4804. 

  4804.                 

    4805. 

  4805.                 if (HTML2PDF :: $TABLES[$param['num']]['new_page'] && count(HTML2PDF :: $TABLES[$param['num']]['thead']['code']))

    4806. 

  4806.                 {

    4807. 

  4807.                     HTML2PDF :: $TABLES[$param['num']]['new_page'] = false;

    4808. 

  4808.                     $tmp_tr = HTML2PDF :: $TABLES[$param['num']]['tr_curr'];

    4809. 

  4809.                     $tmp_td = HTML2PDF :: $TABLES[$param['num']]['td_curr'];

    4810. 

  4810.                     $OLD_parse_pos = $this->parse_pos;

    4811. 

  4811.                     $OLD_parse_code = $this->parsing->code;

    4812. 

  4812.                     

    4813. 

  4813.                     HTML2PDF :: $TABLES[$param['num']]['tr_curr'] = HTML2PDF :: $TABLES[$param['num']]['thead']['tr'][0];

    4814. 

  4814.                     HTML2PDF :: $TABLES[$param['num']]['td_curr'] = 0;

    4815. 

  4815.                     $this->parse_pos = 0;

    4816. 

  4816.                     $this->parsing->code = HTML2PDF :: $TABLES[$param['num']]['thead']['code'];

    4817. 

  4817.                     $this->isInThead = true;

    4818. 

  4818.                     $this->makeHTMLcode();

    4819. 

  4819.                     $this->isInThead = false;

    4820. 

  4820.                     

    4821. 

  4821.                     $this->parse_pos = $OLD_parse_pos;

    4822. 

  4822.                     $this->parsing->code = $OLD_parse_code;

    4823. 

  4823.                     HTML2PDF :: $TABLES[$param['num']]['tr_curr'] = $tmp_tr;

    4824. 

  4824.                     HTML2PDF :: $TABLES[$param['num']]['td_curr'] = $tmp_td;

    4825. 

  4825.                     HTML2PDF :: $TABLES[$param['num']]['new_page'] = true;

    4826. 

  4826.                 }

    4827. 

  4827.             }

    4828. 

  4828.             else

    4829. 

  4829.             {

    4830. 

  4830.                 HTML2PDF :: $TABLES[$param['num']]['cases'][HTML2PDF :: $TABLES[$param['num']]['tr_curr'] - 1] = array();

    4831. 

  4831.                 if (! isset(HTML2PDF :: $TABLES[$param['num']]['corr'][HTML2PDF :: $TABLES[$param['num']]['corr_y']]))

    4832. 

  4832.                     HTML2PDF :: $TABLES[$param['num']]['corr'][HTML2PDF :: $TABLES[$param['num']]['corr_y']] = array();

    4833. 

  4833.                 

    4834. 

  4834.                 HTML2PDF :: $TABLES[$param['num']]['corr_x'] = 0;

    4835. 

  4835.                 while (isset(HTML2PDF :: $TABLES[$param['num']]['corr'][HTML2PDF :: $TABLES[$param['num']]['corr_y']][HTML2PDF :: $TABLES[$param['num']]['corr_x']]))

    4836. 

  4836.                     HTML2PDF :: $TABLES[$param['num']]['corr_x'] ++;

    4837. 

  4837.             }

    4838. 

  4838.             

    4839. 

  4839.             return true;

    4840. 

  4840.         }

    4841. 

  4841. 

    4842. 

  4842.         /**

    4843. 

  4843.          * balise : TR

    4844. 

  4844.          * mode : FERMETURE

    4845. 

  4845.          *

    4846. 

  4846.          * @param	array	param�tres de l'�l�ment de parsing

    4847. 

  4847.          * @return	null

    4848. 

  4848.          */

    4849. 

  4849.         protected function c_TR($param)

    4850. 

  4850.         {

    4851. 

  4851.             if ($this->forOneLine)

    4852. 

  4852.                 return false;

    4853. 

  4853.             

    4854. 

  4854.             $this->maxH = 0;

    4855. 

  4855.             

    4856. 

  4856.             // restauration du style

    4857. 

  4857.             $this->style->load();

    4858. 

  4858.             $this->style->FontSet();

    4859. 

  4859.             

    4860. 

  4860.             // si on est pas dans un sub_html

    4861. 

  4861.             if (! $this->sub_part)

    4862. 

  4862.             {

    4863. 

  4863.                 // Y courant apres la ligne

    4864. 

  4864.                 $ty = null;

    4865. 

  4865.                 for($ii = 0; $ii < count(HTML2PDF :: $TABLES[$param['num']]['cases'][HTML2PDF :: $TABLES[$param['num']]['tr_curr'] - 1]); $ii ++)

    4866. 

  4866.                     if (HTML2PDF :: $TABLES[$param['num']]['cases'][HTML2PDF :: $TABLES[$param['num']]['tr_curr'] - 1][$ii]['rowspan'] == 1)

    4867. 

  4867.                         $ty = HTML2PDF :: $TABLES[$param['num']]['cases'][HTML2PDF :: $TABLES[$param['num']]['tr_curr'] - 1][$ii]['h'];

    4868. 

  4868.                 

    4869. 

  4869.      // mise � jour des coordonn�es courantes

    4870. 

  4870.                 HTML2PDF :: $TABLES[$param['num']]['td_x'] = HTML2PDF :: $TABLES[$param['num']]['curr_x'] + HTML2PDF :: $TABLES[$param['num']]['marge']['l'];

    4871. 

  4871.                 HTML2PDF :: $TABLES[$param['num']]['td_y'] += $ty;

    4872. 

  4872.                 HTML2PDF :: $TABLES[$param['num']]['new_page'] = false;

    4873. 

  4873.             }

    4874. 

  4874.             else

    4875. 

  4875.             {

    4876. 

  4876.                 HTML2PDF :: $TABLES[$param['num']]['corr_y'] ++;

    4877. 

  4877.             }

    4878. 

  4878.             

    4879. 

  4879.             return true;

    4880. 

  4880.         }

    4881. 

  4881. 

    4882. 

  4882.         /**

    4883. 

  4883.          * balise : TD

    4884. 

  4884.          * mode : OUVERTURE

    4885. 

  4885.          *

    4886. 

  4886.          * @param	array	param�tres de l'�l�ment de parsing

    4887. 

  4887.          * @return	null

    4888. 

  4888.          */

    4889. 

  4889.         protected function o_TD($param, $other = 'td')

    4890. 

  4890.         {

    4891. 

  4891.             if ($this->forOneLine)

    4892. 

  4892.                 return false;

    4893. 

  4893.             

    4894. 

  4894.             $this->maxH = 0;

    4895. 

  4895.             

    4896. 

  4896.             $param['cellpadding'] = HTML2PDF :: $TABLES[$param['num']]['cellpadding'] . 'mm';

    4897. 

  4897.             $param['cellspacing'] = HTML2PDF :: $TABLES[$param['num']]['cellspacing'] . 'mm';

    4898. 

  4898.             

    4899. 

  4899.             if ($other == 'li')

    4900. 

  4900.             {

    4901. 

  4901.                 $special_li = true;

    4902. 

  4902.             }

    4903. 

  4903.             else

    4904. 

  4904.             {

    4905. 

  4905.                 $special_li = false;

    4906. 

  4906.                 if ($other == 'li_sub')

    4907. 

  4907.                 {

    4908. 

  4908.                     $param['style']['border'] = 'none';

    4909. 

  4909.                     $param['style']['background-color'] = 'transparent';

    4910. 

  4910.                     $param['style']['background-image'] = 'none';

    4911. 

  4911.                     $param['style']['background-position'] = '';

    4912. 

  4912.                     $param['style']['background-repeat'] = '';

    4913. 

  4913.                     $other = 'li';

    4914. 

  4914.                 }

    4915. 

  4915.             }

    4916. 

  4916.             

    4917. 

  4917.             // est-on en collapse, et egalement y-a-t'il des definitions de colonne

    4918. 

  4918.             $x = HTML2PDF :: $TABLES[$param['num']]['td_curr'];

    4919. 

  4919.             $y = HTML2PDF :: $TABLES[$param['num']]['tr_curr'] - 1;

    4920. 

  4920.             $colspan = isset($param['colspan']) ? $param['colspan'] : 1;

    4921. 

  4921.             $rowspan = isset($param['rowspan']) ? $param['rowspan'] : 1;

    4922. 

  4922.             $collapse = false;

    4923. 

  4923.             if (in_array($other, array('td', 'th')))

    4924. 

  4924.             {

    4925. 

  4925.                 $num_col = isset(HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x]['Xr']) ? HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x]['Xr'] : HTML2PDF :: $TABLES[$param['num']]['corr_x'];

    4926. 

  4926.                 

    4927. 

  4927.                 // si une definition de colonne est presente

    4928. 

  4928.                 if (isset(HTML2PDF :: $TABLES[$param['num']]['cols'][$num_col]))

    4929. 

  4929.                 {

    4930. 

  4930.                     // on la recupere

    4931. 

  4931.                     $col_param = HTML2PDF :: $TABLES[$param['num']]['cols'][$num_col];

    4932. 

  4932.                     

    4933. 

  4933.                     // pour les colspan, on recupere toutes les largeurs

    4934. 

  4934.                     $col_param['style']['width'] = array();

    4935. 

  4935.                     for($k = 0; $k < $colspan; $k ++)

    4936. 

  4936.                     {

    4937. 

  4937.                         if (isset(HTML2PDF :: $TABLES[$param['num']]['cols'][$num_col + $k]['style']['width']))

    4938. 

  4938.                             $col_param['style']['width'][] = HTML2PDF :: $TABLES[$param['num']]['cols'][$num_col + $k]['style']['width'];

    4939. 

  4939.                     }

    4940. 

  4940.                     

    4941. 

  4941.                     // on les somme

    4942. 

  4942.                     $total = '';

    4943. 

  4943.                     $last = $this->style->getLastWidth();

    4944. 

  4944.                     if (count($col_param['style']['width']))

    4945. 

  4945.                     {

    4946. 

  4946.                         $total = $col_param['style']['width'][0];

    4947. 

  4947.                         unset($col_param['style']['width'][0]);

    4948. 

  4948.                         foreach ($col_param['style']['width'] as $width)

    4949. 

  4949.                         {

    4950. 

  4950.                             if (substr($total, - 1) == '%' && substr($width, - 1) == '%')

    4951. 

  4951.                                 $total = (str_replace('%', '', $total) + str_replace('%', '', $width)) . '%';

    4952. 

  4952.                             else

    4953. 

  4953.                                 $total = ($this->style->ConvertToMM($total, $last) + $this->style->ConvertToMM($width, $last)) . 'mm';

    4954. 

  4954.                         }

    4955. 

  4955.                     }

    4956. 

  4956.                     

    4957. 

  4957.                     // et on recupere la largeur finale

    4958. 

  4958.                     if ($total)

    4959. 

  4959.                         $col_param['style']['width'] = $total;

    4960. 

  4960.                     else

    4961. 

  4961.                         unset($col_param['style']['width']);

    4962. 

  4962.                     

    4963. 

  4963.      // on merge les 2 styles (col + td)

    4964. 

  4964.                     $param['style'] = array_merge($col_param['style'], $param['style']);

    4965. 

  4965.                     

    4966. 

  4966.                     // si une classe est d�finie, on la merge egalement

    4967. 

  4967.                     if (isset($col_param['class']))

    4968. 

  4968.                         $param['class'] = $col_param['class'] . (isset($param['class']) ? ' ' . $param['class'] : '');

    4969. 

  4969.                 }

    4970. 

  4970.                 

    4971. 

  4971.                 $collapse = isset($this->style->value['border']['collapse']) ? $this->style->value['border']['collapse'] : false;

    4972. 

  4972.             }

    4973. 

  4973.             

    4974. 

  4974.             // analyse du style

    4975. 

  4975.             $this->style->save();

    4976. 

  4976.             $heritage = null;

    4977. 

  4977.             if (in_array($other, array('td', 'th')))

    4978. 

  4978.             {

    4979. 

  4979.                 $heritage = array();

    4980. 

  4980.                 

    4981. 

  4981.                 $old = $this->style->getLastValue('background');

    4982. 

  4982.                 if ($old && ($old['color'] || $old['image']))

    4983. 

  4983.                     $heritage['background'] = $old;

    4984. 

  4984.                 

    4985. 

  4985.                 if (HTML2PDF :: $TABLES[$param['num']]['border'])

    4986. 

  4986.                 {

    4987. 

  4987.                     $heritage['border'] = array();

    4988. 

  4988.                     $heritage['border']['l'] = HTML2PDF :: $TABLES[$param['num']]['border'];

    4989. 

  4989.                     $heritage['border']['t'] = HTML2PDF :: $TABLES[$param['num']]['border'];

    4990. 

  4990.                     $heritage['border']['r'] = HTML2PDF :: $TABLES[$param['num']]['border'];

    4991. 

  4991.                     $heritage['border']['b'] = HTML2PDF :: $TABLES[$param['num']]['border'];

    4992. 

  4992.                 }

    4993. 

  4993.             }

    4994. 

  4994.             $this->style->analyse($other, $param, $heritage);

    4995. 

  4995.             

    4996. 

  4996.             if ($special_li)

    4997. 

  4997.             {

    4998. 

  4998.                 $this->style->value['width'] -= $this->style->ConvertToMM($this->listeGetWidth());

    4999. 

  4999.                 $this->style->value['width'] -= $this->style->ConvertToMM($this->listeGetPadding());

    5000. 

  5000.             }

    5001. 

  5001.             $this->style->setPosition();

    5002. 

  5002.             $this->style->FontSet();

    5003. 

  5003.             

    5004. 

  5004.             // si on est en collapse : modification du style

    5005. 

  5005.             if ($collapse)

    5006. 

  5006.             {

    5007. 

  5007.                 if (! $this->sub_part)

    5008. 

  5008.                 {

    5009. 

  5009.                     if ((HTML2PDF :: $TABLES[$param['num']]['tr_curr'] > 1 && ! HTML2PDF :: $TABLES[$param['num']]['new_page']) || (! $this->isInThead && count(HTML2PDF :: $TABLES[$param['num']]['thead']['code'])))

    5010. 

  5010.                         $this->style->value['border']['t'] = $this->style->readBorder('none');

    5011. 

  5011.                 }

    5012. 

  5012.                 

    5013. 

  5013.                 if (HTML2PDF :: $TABLES[$param['num']]['td_curr'] > 0)

    5014. 

  5014.                     $this->style->value['border']['l'] = $this->style->readBorder('none');

    5015. 

  5015.             }

    5016. 

  5016.             

    5017. 

  5017.             $marge = array();

    5018. 

  5018.             $marge['t'] = $this->style->value['padding']['t'] + 0.5 * HTML2PDF :: $TABLES[$param['num']]['cellspacing'] + $this->style->value['border']['t']['width'];

    5019. 

  5019.             $marge['r'] = $this->style->value['padding']['r'] + 0.5 * HTML2PDF :: $TABLES[$param['num']]['cellspacing'] + $this->style->value['border']['r']['width'];

    5020. 

  5020.             $marge['b'] = $this->style->value['padding']['b'] + 0.5 * HTML2PDF :: $TABLES[$param['num']]['cellspacing'] + $this->style->value['border']['b']['width'];

    5021. 

  5021.             $marge['l'] = $this->style->value['padding']['l'] + 0.5 * HTML2PDF :: $TABLES[$param['num']]['cellspacing'] + $this->style->value['border']['l']['width'];

    5022. 

  5022.             

    5023. 

  5023.             // si on est dans un sub_html

    5024. 

  5024.             if ($this->sub_part)

    5025. 

  5025.             {

    5026. 

  5026.                 // on se positionne dans le tableau

    5027. 

  5027.                 HTML2PDF :: $TABLES[$param['num']]['td_curr'] ++;

    5028. 

  5028.                 HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x] = array();

    5029. 

  5029.                 HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x]['w'] = 0;

    5030. 

  5030.                 HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x]['h'] = 0;

    5031. 

  5031.                 HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x]['dw'] = 0;

    5032. 

  5032.                 HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x]['colspan'] = $colspan;

    5033. 

  5033.                 HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x]['rowspan'] = $rowspan;

    5034. 

  5034.                 HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x]['Xr'] = HTML2PDF :: $TABLES[$param['num']]['corr_x'];

    5035. 

  5035.                 HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x]['Yr'] = HTML2PDF :: $TABLES[$param['num']]['corr_y'];

    5036. 

  5036.                 

    5037. 

  5037.                 for($j = 0; $j < $rowspan; $j ++)

    5038. 

  5038.                 {

    5039. 

  5039.                     for($i = 0; $i < $colspan; $i ++)

    5040. 

  5040.                     {

    5041. 

  5041.                         HTML2PDF :: $TABLES[$param['num']]['corr'][HTML2PDF :: $TABLES[$param['num']]['corr_y'] + $j][HTML2PDF :: $TABLES[$param['num']]['corr_x'] + $i] = ($i + $j > 0) ? '' : array(

    5042. 

  5042.                                 $x, $y, $colspan, $rowspan);

    5043. 

  5043.                     }

    5044. 

  5044.                 }

    5045. 

  5045.                 HTML2PDF :: $TABLES[$param['num']]['corr_x'] += $colspan;

    5046. 

  5046.                 while (isset(HTML2PDF :: $TABLES[$param['num']]['corr'][HTML2PDF :: $TABLES[$param['num']]['corr_y']][HTML2PDF :: $TABLES[$param['num']]['corr_x']]))

    5047. 

  5047.                     HTML2PDF :: $TABLES[$param['num']]['corr_x'] ++;

    5048. 

  5048.                 

    5049. 

  5049.      // on extrait tout ce qui est contenu dans le TD

    5050. 

  5050.                 // on en cr�� un sous HTML que l'on transforme en PDF

    5051. 

  5051.                 // pour analyse les dimensions

    5052. 

  5052.                 // et les r�cup�rer dans le tableau global.

    5053. 

  5053.                 $level = $this->parsing->getLevel($this->temp_pos);

    5054. 

  5054.                 $this->CreateSubHTML($this->sub_html);

    5055. 

  5055.                 $this->sub_html->parsing->code = $level;

    5056. 

  5056.                 $this->sub_html->MakeHTMLcode();

    5057. 

  5057.                 $this->temp_pos += count($level);

    5058. 

  5058.             }

    5059. 

  5059.             else

    5060. 

  5060.             {

    5061. 

  5061.                 // on se positionne dans le tableau

    5062. 

  5062.                 HTML2PDF :: $TABLES[$param['num']]['td_curr'] ++;

    5063. 

  5063.                 HTML2PDF :: $TABLES[$param['num']]['td_x'] += HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x]['dw'];

    5064. 

  5064.                 

    5065. 

  5065.                 // initialisation du style des bordures de la premiere partie de tableau

    5066. 

  5066.                 $this->drawRectangle(HTML2PDF :: $TABLES[$param['num']]['td_x'], HTML2PDF :: $TABLES[$param['num']]['td_y'], HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x]['w'], HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x]['h'], $this->style->value['border'], $this->style->value['padding'], HTML2PDF :: $TABLES[$param['num']]['cellspacing'] * 0.5, $this->style->value['background']);

    5067. 

  5067.                 

    5068. 

  5068.                 $this->style->value['width'] = HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x]['w'] - $marge['l'] - $marge['r'];

    5069. 

  5069.                 

    5070. 

  5070.                 // limitation des marges aux dimensions de la case

    5071. 

  5071.                 $mL = HTML2PDF :: $TABLES[$param['num']]['td_x'] + $marge['l'];

    5072. 

  5072.                 $mR = $this->pdf->getW() - $mL - $this->style->value['width'];

    5073. 

  5073.                 $this->saveMargin($mL, 0, $mR);

    5074. 

  5074.                 

    5075. 

  5075.                 // positionnement en fonction

    5076. 

  5076.                 $h_corr = HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x]['h'];

    5077. 

  5077.                 $h_reel = HTML2PDF :: $TABLES[$param['num']]['cases'][$y][$x]['real_h'];

    5078. 

  5078.                 switch ($this->style->value['vertical-align'])

    5079. 

  5079.                 {

    5080. 

  5080.                     case 'bottom' :

    5081. 

  5081.                         $y_corr = $h_corr - $h_reel;

    5082. 

  5082.                         break;

    5083. 

  5083.                     

    5084. 

  5084.                     case 'middle' :

    5085. 

  5085.                         $y_corr = ($h_corr - $h_reel) * 0.5;

    5086. 

  5086.                         break;

    5087. 

  5087.                     

    5088. 

  5088.                     case 'top' :

    5089. 

  5089.                     default :

    5090. 

  5090.                         $y_corr = 0;

    5091. 

  5091.                         break;

    5092. 

  5092.                 }

    5093. 

  5093.                 

    5094. 

  5094.                 $x = HTML2PDF :: $TABLES[$param['num']]['td_x'] + $marge['l'];

    5095. 

  5095.                 $y = HTML2PDF :: $TABLES[$param['num']]['td_y'] + $marge['t'] + $y_corr;

    5096. 

  5096.                 $this->pdf->setXY($x, $y);

    5097. 

  5097.                 $this->setNewPositionForNewLine();

    5098. 

  5098.             }

    5099. 

  5099.             

    5100. 

  5100.             return true;

    5101. 

  5101.         }

    5102. 

  5102. 

    5103. 

  5103.         /**

    5104. 

  5104.          * balise : TD

    5105. 

  5105.          * mode : FERMETURE

    5106. 

  5106.          *

    5107. 

  5107.          * @param	array	param�tres de l'�l�ment de parsing

    5108. 

  5108.          * @return	null

    5109. 

  5109.          */

    5110. 

  5110.         protected function c_TD($param)

    5111. 

  5111.         {

    5112. 

  5112.             if ($this->forOneLine)

    5113. 

  5113.                 return false;

    5114. 

  5114.             

    5115. 

  5115.             $this->maxH = 0;

    5116. 

  5116.             

    5117. 

  5117.             // r�cup�ration de la marge

    5118. 

  5118.             $marge = array();

    5119. 

  5119.             $marge['t'] = $this->style->value['padding']['t'] + 0.5 * HTML2PDF :: $TABLES[$param['num']]['cellspacing'] + $this->style->value['border']['t']['width'];

    5120. 

  5120.             $marge['r'] = $this->style->value['padding']['r'] + 0.5 * HTML2PDF :: $TABLES[$param['num']]['cellspacing'] + $this->style->value['border']['r']['width'];

    5121. 

  5121.             $marge['b'] = $this->style->value['padding']['b'] + 0.5 * HTML2PDF :: $TABLES[$param['num']]['cellspacing'] + $this->style->value['border']['b']['width'];

    5122. 

  5122.             $marge['l'] = $this->style->value['padding']['l'] + 0.5 * HTML2PDF :: $TABLES[$param['num']]['cellspacing'] + $this->style->value['border']['l']['width'];

    5123. 

  5123.             $marge['t'] += 0.01;

    5124. 

  5124.             $marge['r'] += 0.01;

    5125. 

  5125.             $marge['b'] += 0.01;

    5126. 

  5126.             $marge['l'] += 0.01;

    5127. 

  5127.             

    5128. 

  5128.             // si on est dans un sub_html

    5129. 

  5129.             if ($this->sub_part)

    5130. 

  5130.             {

    5131. 

  5131.                 if ($this->testTDin1page && $this->sub_html->pdf->getPage() > 1)

    5132. 

  5132.                     HTML2PDF :: makeError(7, __FILE__, __LINE__);

    5133. 

  5133.                 

    5134. 

  5134.      // dimentions de cette case

    5135. 

  5135.                 $w0 = $this->sub_html->maxX + $marge['l'] + $marge['r'];

    5136. 

  5136.                 $h0 = $this->sub_html->maxY + $marge['t'] + $marge['b'];

    5137. 

  5137.                 

    5138. 

  5138.                 // dimensions impos�es par le style

    5139. 

  5139.                 $w2 = $this->style->value['width'] + $marge['l'] + $marge['r'];

    5140. 

  5140.                 $h2 = $this->style->value['height'] + $marge['t'] + $marge['b'];

    5141. 

  5141.                 

    5142. 

  5142.                 // dimension finale de la case = max des 2 ci-dessus

    5143. 

  5143.                 HTML2PDF :: $TABLES[$param['num']]['cases'][HTML2PDF :: $TABLES[$param['num']]['tr_curr'] - 1][HTML2PDF :: $TABLES[$param['num']]['td_curr'] - 1]['w'] = max(array(

    5144. 

  5144.                         $w0, $w2));

    5145. 

  5145.                 HTML2PDF :: $TABLES[$param['num']]['cases'][HTML2PDF :: $TABLES[$param['num']]['tr_curr'] - 1][HTML2PDF :: $TABLES[$param['num']]['td_curr'] - 1]['h'] = max(array(

    5146. 

  5146.                         $h0, $h2));

    5147. 

  5147.                 

    5148. 

  5148.                 HTML2PDF :: $TABLES[$param['num']]['cases'][HTML2PDF :: $TABLES[$param['num']]['tr_curr'] - 1][HTML2PDF :: $TABLES[$param['num']]['td_curr'] - 1]['real_w'] = $w0;

    5149. 

  5149.                 HTML2PDF :: $TABLES[$param['num']]['cases'][HTML2PDF :: $TABLES[$param['num']]['tr_curr'] - 1][HTML2PDF :: $TABLES[$param['num']]['td_curr'] - 1]['real_h'] = $h0;

    5150. 

  5150.                 

    5151. 

  5151.                 // suppresion du sous_html

    5152. 

  5152.                 $this->destroySubHTML($this->sub_html);

    5153. 

  5153.             }

    5154. 

  5154.             else

    5155. 

  5155.             {

    5156. 

  5156.                 $this->loadMargin();

    5157. 

  5157.                 //positionnement

    5158. 

  5158.                 HTML2PDF :: $TABLES[$param['num']]['td_x'] += HTML2PDF :: $TABLES[$param['num']]['cases'][HTML2PDF :: $TABLES[$param['num']]['tr_curr'] - 1][HTML2PDF :: $TABLES[$param['num']]['td_curr'] - 1]['w'];

    5159. 

  5159.             }

    5160. 

  5160.             

    5161. 

  5161.             // restauration du style

    5162. 

  5162.             $this->style->load();

    5163. 

  5163.             $this->style->FontSet();

    5164. 

  5164.             

    5165. 

  5165.             return true;

    5166. 

  5166.         }

    5167. 

  5167. 

    5168. 

  5168.         protected function calculTailleCases(&$cases, &$corr)

    5169. 

  5169.         {

    5170. 

  5170.             /*			// construction d'un tableau de correlation

    5171. 

  5171. 			$corr = array();

    5172. 

  5172. 

    5173. 

  5173. 			// on fait correspondre chaque case d'un tableau norm� aux cases r�elles, en prennant en compte les colspan et rowspan

    5174. 

  5174. 			$Yr=0;

    5175. 

  5175. 			for($y=0; $y<count($cases); $y++)

    5176. 

  5176. 			{

    5177. 

  5177. 				$Xr=0; 	while(isset($corr[$Yr][$Xr])) $Xr++;

    5178. 

  5178. 

    5179. 

  5179. 				for($x=0; $x<count($cases[$y]); $x++)

    5180. 

  5180. 				{

    5181. 

  5181. 					for($j=0; $j<$cases[$y][$x]['rowspan']; $j++)

    5182. 

  5182. 					{

    5183. 

  5183. 						for($i=0; $i<$cases[$y][$x]['colspan']; $i++)

    5184. 

  5184. 						{

    5185. 

  5185. 							$corr[$Yr+$j][$Xr+$i] = ($i+$j>0) ? '' : array($x, $y, $cases[$y][$x]['colspan'], $cases[$y][$x]['rowspan']);

    5186. 

  5186. 						}

    5187. 

  5187. 					}

    5188. 

  5188. 					$Xr+= $cases[$y][$x]['colspan'];

    5189. 

  5189. 					while(isset($corr[$Yr][$Xr])) $Xr++;

    5190. 

  5190. 				}

    5191. 

  5191. 				$Yr++;

    5192. 

  5192. 			}

    5193. 

  5193. */

    5194. 

  5194.             if (! isset($corr[0]))

    5195. 

  5195.                 return true;

    5196. 

  5196.             

    5197. 

  5197.      // on d�termine, pour les cases sans colspan, la largeur maximale de chaque colone

    5198. 

  5198.             $sw = array();

    5199. 

  5199.             for($x = 0; $x < count($corr[0]); $x ++)

    5200. 

  5200.             {

    5201. 

  5201.                 $m = 0;

    5202. 

  5202.                 for($y = 0; $y < count($corr); $y ++)

    5203. 

  5203.                     if (isset($corr[$y][$x]) && is_array($corr[$y][$x]) && $corr[$y][$x][2] == 1)

    5204. 

  5204.                         $m = max($m, $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w']);

    5205. 

  5205.                 $sw[$x] = $m;

    5206. 

  5206.             }

    5207. 

  5207.             

    5208. 

  5208.             // on v�rifie que cette taille est valide avec les colones en colspan

    5209. 

  5209.             for($x = 0; $x < count($corr[0]); $x ++)

    5210. 

  5210.             {

    5211. 

  5211.                 for($y = 0; $y < count($corr); $y ++)

    5212. 

  5212.                 {

    5213. 

  5213.                     if (isset($corr[$y][$x]) && is_array($corr[$y][$x]) && $corr[$y][$x][2] > 1)

    5214. 

  5214.                     {

    5215. 

  5215.                         // somme des colonnes correspondant au colspan

    5216. 

  5216.                         $s = 0;

    5217. 

  5217.                         for($i = 0; $i < $corr[$y][$x][2]; $i ++)

    5218. 

  5218.                             $s += $sw[$x + $i];

    5219. 

  5219.                         

    5220. 

  5220.      // si la somme est inf�rieure � la taille necessaire => r�gle de 3 pour adapter

    5221. 

  5221.                         if ($s > 0 && $s < $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w'])

    5222. 

  5222.                             for($i = 0; $i < $corr[$y][$x][2]; $i ++)

    5223. 

  5223.                                 $sw[$x + $i] = $sw[$x + $i] / $s * $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w'];

    5224. 

  5224.                     }

    5225. 

  5225.                 }

    5226. 

  5226.             }

    5227. 

  5227.             

    5228. 

  5228.             // on applique les nouvelles largeurs

    5229. 

  5229.             for($x = 0; $x < count($corr[0]); $x ++)

    5230. 

  5230.             {

    5231. 

  5231.                 for($y = 0; $y < count($corr); $y ++)

    5232. 

  5232.                 {

    5233. 

  5233.                     if (isset($corr[$y][$x]) && is_array($corr[$y][$x]))

    5234. 

  5234.                     {

    5235. 

  5235.                         if ($corr[$y][$x][2] == 1)

    5236. 

  5236.                         {

    5237. 

  5237.                             $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w'] = $sw[$x];

    5238. 

  5238.                         }

    5239. 

  5239.                         else

    5240. 

  5240.                         {

    5241. 

  5241.                             // somme des colonnes correspondant au colspan

    5242. 

  5242.                             $s = 0;

    5243. 

  5243.                             for($i = 0; $i < $corr[$y][$x][2]; $i ++)

    5244. 

  5244.                                 $s += $sw[$x + $i];

    5245. 

  5245.                             $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w'] = $s;

    5246. 

  5246.                         }

    5247. 

  5247.                     }

    5248. 

  5248.                 }

    5249. 

  5249.             }

    5250. 

  5250.             

    5251. 

  5251.             // on d�termine, pour les cases sans rowspan, la hauteur maximale de chaque colone

    5252. 

  5252.             $sh = array();

    5253. 

  5253.             for($y = 0; $y < count($corr); $y ++)

    5254. 

  5254.             {

    5255. 

  5255.                 $m = 0;

    5256. 

  5256.                 for($x = 0; $x < count($corr[0]); $x ++)

    5257. 

  5257.                     if (isset($corr[$y][$x]) && is_array($corr[$y][$x]) && $corr[$y][$x][3] == 1)

    5258. 

  5258.                         $m = max($m, $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['h']);

    5259. 

  5259.                 $sh[$y] = $m;

    5260. 

  5260.             }

    5261. 

  5261.             

    5262. 

  5262.             // on v�rifie que cette taille est valide avec les lignes en rowspan

    5263. 

  5263.             for($y = 0; $y < count($corr); $y ++)

    5264. 

  5264.             {

    5265. 

  5265.                 for($x = 0; $x < count($corr[0]); $x ++)

    5266. 

  5266.                 {

    5267. 

  5267.                     if (isset($corr[$y][$x]) && is_array($corr[$y][$x]) && $corr[$y][$x][3] > 1)

    5268. 

  5268.                     {

    5269. 

  5269.                         // somme des colonnes correspondant au colspan

    5270. 

  5270.                         $s = 0;

    5271. 

  5271.                         for($i = 0; $i < $corr[$y][$x][3]; $i ++)

    5272. 

  5272.                             $s += $sh[$y + $i];

    5273. 

  5273.                         

    5274. 

  5274.      // si la somme est inf�rieure � la taille necessaire => r�gle de 3 pour adapter

    5275. 

  5275.                         if ($s > 0 && $s < $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['h'])

    5276. 

  5276.                             for($i = 0; $i < $corr[$y][$x][3]; $i ++)

    5277. 

  5277.                                 $sh[$y + $i] = $sh[$y + $i] / $s * $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['h'];

    5278. 

  5278.                     }

    5279. 

  5279.                 }

    5280. 

  5280.             }

    5281. 

  5281.             

    5282. 

  5282.             // on applique les nouvelles hauteurs

    5283. 

  5283.             for($y = 0; $y < count($corr); $y ++)

    5284. 

  5284.             {

    5285. 

  5285.                 for($x = 0; $x < count($corr[0]); $x ++)

    5286. 

  5286.                 {

    5287. 

  5287.                     if (isset($corr[$y][$x]) && is_array($corr[$y][$x]))

    5288. 

  5288.                     {

    5289. 

  5289.                         if ($corr[$y][$x][3] == 1)

    5290. 

  5290.                         {

    5291. 

  5291.                             $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['h'] = $sh[$y];

    5292. 

  5292.                         }

    5293. 

  5293.                         else

    5294. 

  5294.                         {

    5295. 

  5295.                             // somme des lignes correspondant au rowspan

    5296. 

  5296.                             $s = 0;

    5297. 

  5297.                             for($i = 0; $i < $corr[$y][$x][3]; $i ++)

    5298. 

  5298.                                 $s += $sh[$y + $i];

    5299. 

  5299.                             $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['h'] = $s;

    5300. 

  5300.                             

    5301. 

  5301.                             for($j = 1; $j < $corr[$y][$x][3]; $j ++)

    5302. 

  5302.                             {

    5303. 

  5303.                                 $tx = $x + 1;

    5304. 

  5304.                                 $ty = $y + $j;

    5305. 

  5305.                                 for(true; isset($corr[$ty][$tx]) && ! is_array($corr[$ty][$tx]); $tx ++);

    5306. 

  5306.                                 if (isset($corr[$ty][$tx]))

    5307. 

  5307.                                     $cases[$corr[$ty][$tx][1]][$corr[$ty][$tx][0]]['dw'] += $cases[$corr[$y][$x][1]][$corr[$y][$x][0]]['w'];

    5308. 

  5308.                             

    5309. 

  5309.                             }

    5310. 

  5310.                         }

    5311. 

  5311.                     }

    5312. 

  5312.                 }

    5313. 

  5313.             }

    5314. 

  5314.         }

    5315. 

  5315. 

    5316. 

  5316.         /**

    5317. 

  5317.          * balise : TH

    5318. 

  5318.          * mode : OUVERTURE

    5319. 

  5319.          *

    5320. 

  5320.          * @param	array	param�tres de l'�l�ment de parsing

    5321. 

  5321.          * @return	null

    5322. 

  5322.          */

    5323. 

  5323.         protected function o_TH($param)

    5324. 

  5324.         {

    5325. 

  5325.             if ($this->forOneLine)

    5326. 

  5326.                 return false;

    5327. 

  5327.             

    5328. 

  5328.             $this->maxH = 0;

    5329. 

  5329.             // identique � TD mais en gras

    5330. 

  5330.             if (! isset($param['style']['font-weight']))

    5331. 

  5331.                 $param['style']['font-weight'] = 'bold';

    5332. 

  5332.             $this->o_TD($param, 'th');

    5333. 

  5333.             

    5334. 

  5334.             return true;

    5335. 

  5335.         }

    5336. 

  5336. 

    5337. 

  5337.         /**

    5338. 

  5338.          * balise : TH

    5339. 

  5339.          * mode : FERMETURE

    5340. 

  5340.          *

    5341. 

  5341.          * @param	array	param�tres de l'�l�ment de parsing

    5342. 

  5342.          * @return	null

    5343. 

  5343.          */

    5344. 

  5344.         protected function c_TH($param)

    5345. 

  5345.         {

    5346. 

  5346.             if ($this->forOneLine)

    5347. 

  5347.                 return false;

    5348. 

  5348.             

    5349. 

  5349.             $this->maxH = 0;

    5350. 

  5350.             // identique � TD

    5351. 

  5351.             $this->c_TD($param);

    5352. 

  5352.             

    5353. 

  5353.             return true;

    5354. 

  5354.         }

    5355. 

  5355. 

    5356. 

  5356.         /**

    5357. 

  5357.          * balise : IMG

    5358. 

  5358.          * mode : OUVERTURE

    5359. 

  5359.          *

    5360. 

  5360.          * @param	array	param�tres de l'�l�ment de parsing

    5361. 

  5361.          * @return	null

    5362. 

  5362.          */

    5363. 

  5363.         protected function o_IMG($param)

    5364. 

  5364.         {

    5365. 

  5365.             // analyse du style

    5366. 

  5366.             $src = str_replace('&amp;', '&', $param['src']);

    5367. 

  5367.             

    5368. 

  5368.             $this->style->save();

    5369. 

  5369.             $this->style->value['width'] = 0;

    5370. 

  5370.             $this->style->value['height'] = 0;

    5371. 

  5371.             $this->style->value['border'] = array('type' => 'none', 'width' => 0, 'color' => array(0, 0, 0));

    5372. 

  5372.             $this->style->value['background'] = array('color' => null, 'image' => null, 'position' => null, 

    5373. 

  5373.                     'repeat' => null);

    5374. 

  5374.             $this->style->analyse('img', $param);

    5375. 

  5375.             $this->style->setPosition();

    5376. 

  5376.             $this->style->FontSet();

    5377. 

  5377.             

    5378. 

  5378.             // affichage de l'image

    5379. 

  5379.             $res = $this->Image($src, isset($param['sub_li']));

    5380. 

  5380.             if (! $res)

    5381. 

  5381.                 return $res;

    5382. 

  5382.             

    5383. 

  5383.      // restauration du style

    5384. 

  5384.             $this->style->load();

    5385. 

  5385.             $this->style->FontSet();

    5386. 

  5386.             $this->maxE ++;

    5387. 

  5387.             

    5388. 

  5388.             return true;

    5389. 

  5389.         }

    5390. 

  5390. 

    5391. 

  5391.         /**

    5392. 

  5392.          * balise : SELECT

    5393. 

  5393.          * mode : OUVERTURE

    5394. 

  5394.          *

    5395. 

  5395.          * @param	array	param�tres de l'�l�ment de parsing

    5396. 

  5396.          * @return	null

    5397. 

  5397.          */

    5398. 

  5398.         protected function o_SELECT($param)

    5399. 

  5399.         {

    5400. 

  5400.             // preparation du champs

    5401. 

  5401.             if (! isset($param['name']))

    5402. 

  5402.                 $param['name'] = 'champs_pdf_' . (count($this->lstChamps) + 1);

    5403. 

  5403.             

    5404. 

  5404.             $param['name'] = strtolower($param['name']);

    5405. 

  5405.             

    5406. 

  5406.             if (isset($this->lstChamps[$param['name']]))

    5407. 

  5407.                 $this->lstChamps[$param['name']] ++;

    5408. 

  5408.             else

    5409. 

  5409.                 $this->lstChamps[$param['name']] = 1;

    5410. 

  5410.             

    5411. 

  5411.             $this->style->save();

    5412. 

  5412.             $this->style->analyse('select', $param);

    5413. 

  5413.             $this->style->setPosition();

    5414. 

  5414.             $this->style->FontSet();

    5415. 

  5415.             

    5416. 

  5416.             $this->lstSelect = array();

    5417. 

  5417.             $this->lstSelect['name'] = $param['name'];

    5418. 

  5418.             $this->lstSelect['multi'] = isset($param['multiple']) ? true : false;

    5419. 

  5419.             $this->lstSelect['size'] = isset($param['size']) ? $param['size'] : 1;

    5420. 

  5420.             $this->lstSelect['options'] = array();

    5421. 

  5421.             

    5422. 

  5422.             if ($this->lstSelect['multi'] && $this->lstSelect['size'] < 3)

    5423. 

  5423.                 $this->lstSelect['size'] = 3;

    5424. 

  5424.             

    5425. 

  5425.             return true;

    5426. 

  5426.         }

    5427. 

  5427. 

    5428. 

  5428.         /**

    5429. 

  5429.          * balise : OPTION

    5430. 

  5430.          * mode : OUVERTURE

    5431. 

  5431.          *

    5432. 

  5432.          * @param	array	param�tres de l'�l�ment de parsing

    5433. 

  5433.          * @return	null

    5434. 

  5434.          */

    5435. 

  5435.         protected function o_OPTION($param)

    5436. 

  5436.         {

    5437. 

  5437.             // on extrait tout ce qui est contenu dans l'option

    5438. 

  5438.             $level = $this->parsing->getLevel($this->parse_pos);

    5439. 

  5439.             $this->parse_pos += count($level);

    5440. 

  5440.             $value = isset($param['value']) ? $param['value'] : 'auto_opt_' . (count($this->lstSelect) + 1);

    5441. 

  5441.             

    5442. 

  5442.             $this->lstSelect['options'][$value] = isset($level[0]['param']['txt']) ? $level[0]['param']['txt'] : '';

    5443. 

  5443.             

    5444. 

  5444.             return true;

    5445. 

  5445.         }

    5446. 

  5446. 

    5447. 

  5447.         /**

    5448. 

  5448.          * balise : OPTION

    5449. 

  5449.          * mode : FERMETURE

    5450. 

  5450.          *

    5451. 

  5451.          * @param	array	param�tres de l'�l�ment de parsing

    5452. 

  5452.          * @return	null

    5453. 

  5453.          */

    5454. 

  5454.         protected function c_OPTION($param)

    5455. 

  5455.         {

    5456. 

  5456.             return true;

    5457. 

  5457.         }

    5458. 

  5458. 

    5459. 

  5459.         /**

    5460. 

  5460.          * balise : SELECT

    5461. 

  5461.          * mode : FERMETURE

    5462. 

  5462.          *

    5463. 

  5463.          * @param	array	param�tres de l'�l�ment de parsing

    5464. 

  5464.          * @return	null

    5465. 

  5465.          */

    5466. 

  5466.         protected function c_SELECT()

    5467. 

  5467.         {

    5468. 

  5468.             // position d'affichage

    5469. 

  5469.             $x = $this->pdf->getX();

    5470. 

  5470.             $y = $this->pdf->getY();

    5471. 

  5471.             $f = 1.08 * $this->style->value['font-size'];

    5472. 

  5472.             

    5473. 

  5473.             $w = $this->style->value['width'];

    5474. 

  5474.             if (! $w)

    5475. 

  5475.                 $w = 50;

    5476. 

  5476.             $h = ($f * 1.07 * $this->lstSelect['size'] + 1);

    5477. 

  5477.             $opts = array();

    5478. 

  5478.             if ($this->lstSelect['multi'])

    5479. 

  5479.                 $opts['multipleSelection'] = 'true';

    5480. 

  5480.             

    5481. 

  5481.             if ($this->lstSelect['size'] > 1)

    5482. 

  5482.                 $this->pdf->ListBox($this->lstSelect['name'], $w, $h, $this->lstSelect['options'], $opts);

    5483. 

  5483.             else

    5484. 

  5484.                 $this->pdf->ComboBox($this->lstSelect['name'], $w, $h, $this->lstSelect['options']);

    5485. 

  5485.             

    5486. 

  5486.             $this->maxX = max($this->maxX, $x + $w);

    5487. 

  5487.             $this->maxY = max($this->maxY, $y + $h);

    5488. 

  5488.             $this->maxH = max($this->maxH, $h);

    5489. 

  5489.             $this->pdf->setX($x + $w);

    5490. 

  5490.             

    5491. 

  5491.             $this->style->load();

    5492. 

  5492.             $this->style->FontSet();

    5493. 

  5493.             

    5494. 

  5494.             $this->lstSelect = array();

    5495. 

  5495.             

    5496. 

  5496.             return true;

    5497. 

  5497.         }

    5498. 

  5498. 

    5499. 

  5499.         /**

    5500. 

  5500.          * balise : TEXTAREA

    5501. 

  5501.          * mode : OUVERTURE

    5502. 

  5502.          *

    5503. 

  5503.          * @param	array	param�tres de l'�l�ment de parsing

    5504. 

  5504.          * @return	null

    5505. 

  5505.          */

    5506. 

  5506.         protected function o_TEXTAREA($param)

    5507. 

  5507.         {

    5508. 

  5508.             // preparation du champs

    5509. 

  5509.             if (! isset($param['name']))

    5510. 

  5510.                 $param['name'] = 'champs_pdf_' . (count($this->lstChamps) + 1);

    5511. 

  5511.             

    5512. 

  5512.             $param['name'] = strtolower($param['name']);

    5513. 

  5513.             

    5514. 

  5514.             if (isset($this->lstChamps[$param['name']]))

    5515. 

  5515.                 $this->lstChamps[$param['name']] ++;

    5516. 

  5516.             else

    5517. 

  5517.                 $this->lstChamps[$param['name']] = 1;

    5518. 

  5518.             

    5519. 

  5519.             $this->style->save();

    5520. 

  5520.             $this->style->analyse('textarea', $param);

    5521. 

  5521.             $this->style->setPosition();

    5522. 

  5522.             $this->style->FontSet();

    5523. 

  5523.             

    5524. 

  5524.             // position d'affichage

    5525. 

  5525.             $x = $this->pdf->getX();

    5526. 

  5526.             $y = $this->pdf->getY();

    5527. 

  5527.             $fx = 0.65 * $this->style->value['font-size'];

    5528. 

  5528.             $fy = 1.08 * $this->style->value['font-size'];

    5529. 

  5529.             

    5530. 

  5530.             // on extrait tout ce qui est contenu dans le textarea

    5531. 

  5531.             $level = $this->parsing->getLevel($this->parse_pos);

    5532. 

  5532.             $this->parse_pos += count($level);

    5533. 

  5533.             

    5534. 

  5534.             $w = $fx * (isset($param['cols']) ? $param['cols'] : 22) + 1;

    5535. 

  5535.             $h = $fy * 1.07 * (isset($param['rows']) ? $param['rows'] : 3) + 3;

    5536. 

  5536.             

    5537. 

  5537.             //			if ($this->style->value['width']) $w = $this->style->value['width'];

    5538. 

  5538.             //			if ($this->style->value['height']) $h = $this->style->value['height'];

    5539. 

  5539.             

    5540. 

  5540. 

    5541. 

  5541.             $prop = array();

    5542. 

  5542.             $prop['multiline'] = true;

    5543. 

  5543.             $prop['value'] = isset($level[0]['param']['txt']) ? $level[0]['param']['txt'] : '';

    5544. 

  5544.             

    5545. 

  5545.             $this->pdf->TextField($param['name'], $w, $h, $prop, array(), $x, $y);

    5546. 

  5546.             

    5547. 

  5547.             $this->maxX = max($this->maxX, $x + $w);

    5548. 

  5548.             $this->maxY = max($this->maxY, $y + $h);

    5549. 

  5549.             $this->maxH = max($this->maxH, $h);

    5550. 

  5550.             $this->pdf->setX($x + $w);

    5551. 

  5551.             

    5552. 

  5552.             return true;

    5553. 

  5553.         }

    5554. 

  5554. 

    5555. 

  5555.         /**

    5556. 

  5556.          * balise : TEXTAREA

    5557. 

  5557.          * mode : FERMETURE

    5558. 

  5558.          *

    5559. 

  5559.          * @param	array	param�tres de l'�l�ment de parsing

    5560. 

  5560.          * @return	null

    5561. 

  5561.          */

    5562. 

  5562.         protected function c_TEXTAREA()

    5563. 

  5563.         {

    5564. 

  5564.             $this->style->load();

    5565. 

  5565.             $this->style->FontSet();

    5566. 

  5566.             

    5567. 

  5567.             return true;

    5568. 

  5568.         }

    5569. 

  5569. 

    5570. 

  5570.         /**

    5571. 

  5571.          * balise : INPUT

    5572. 

  5572.          * mode : OUVERTURE

    5573. 

  5573.          *

    5574. 

  5574.          * @param	array	param�tres de l'�l�ment de parsing

    5575. 

  5575.          * @return	null

    5576. 

  5576.          */

    5577. 

  5577.         protected function o_INPUT($param)

    5578. 

  5578.         {

    5579. 

  5579.             // preparation du champs

    5580. 

  5580.             if (! isset($param['name']))

    5581. 

  5581.                 $param['name'] = 'champs_pdf_' . (count($this->lstChamps) + 1);

    5582. 

  5582.             if (! isset($param['value']))

    5583. 

  5583.                 $param['value'] = '';

    5584. 

  5584.             if (! isset($param['type']))

    5585. 

  5585.                 $param['type'] = 'text';

    5586. 

  5586.             

    5587. 

  5587.             $param['name'] = strtolower($param['name']);

    5588. 

  5588.             $param['type'] = strtolower($param['type']);

    5589. 

  5589.             

    5590. 

  5590.             if (! in_array($param['type'], array('text', 'checkbox', 'radio', 'hidden', 'submit', 'reset', 'button')))

    5591. 

  5591.                 $param['type'] = 'text';

    5592. 

  5592.             

    5593. 

  5593.             if (isset($this->lstChamps[$param['name']]))

    5594. 

  5594.                 $this->lstChamps[$param['name']] ++;

    5595. 

  5595.             else

    5596. 

  5596.                 $this->lstChamps[$param['name']] = 1;

    5597. 

  5597.             

    5598. 

  5598.             $this->style->save();

    5599. 

  5599.             $this->style->analyse('input', $param);

    5600. 

  5600.             $this->style->setPosition();

    5601. 

  5601.             $this->style->FontSet();

    5602. 

  5602.             

    5603. 

  5603.             $name = $param['name'];

    5604. 

  5604.             

    5605. 

  5605.             // position d'affichage

    5606. 

  5606.             $x = $this->pdf->getX();

    5607. 

  5607.             $y = $this->pdf->getY();

    5608. 

  5608.             $f = 1.08 * $this->style->value['font-size'];

    5609. 

  5609.             

    5610. 

  5610.             switch ($param['type'])

    5611. 

  5611.             {

    5612. 

  5612.                 case 'checkbox' :

    5613. 

  5613.                     $w = 3;

    5614. 

  5614.                     $h = $w;

    5615. 

  5615.                     if ($h < $f)

    5616. 

  5616.                         $y += ($f - $h) * 0.5;

    5617. 

  5617.                     $this->pdf->CheckBox($name, $w, isset($param['checked']), array(), array(), ($param['value'] ? $param['value'] : 'Yes'), $x, $y);

    5618. 

  5618.                     break;

    5619. 

  5619.                 

    5620. 

  5620.                 case 'radio' :

    5621. 

  5621.                     $w = 3;

    5622. 

  5622.                     $h = $w;

    5623. 

  5623.                     if ($h < $f)

    5624. 

  5624.                         $y += ($f - $h) * 0.5;

    5625. 

  5625.                     $this->pdf->RadioButton($name, $w, array(), array(), ($param['value'] ? $param['value'] : 'On'), isset($param['selected']), $x, $y);

    5626. 

  5626.                     break;

    5627. 

  5627.                 

    5628. 

  5628.                 case 'hidden' :

    5629. 

  5629.                     $w = 0;

    5630. 

  5630.                     $h = 0;

    5631. 

  5631.                     $prop = array();

    5632. 

  5632.                     $prop['value'] = $param['value'];

    5633. 

  5633.                     $this->pdf->TextField($name, $w, $h, $prop, array(), $x, $y);

    5634. 

  5634.                     break;

    5635. 

  5635.                 

    5636. 

  5636.                 case 'text' :

    5637. 

  5637.                     $w = $this->style->value['width'];

    5638. 

  5638.                     if (! $w)

    5639. 

  5639.                         $w = 40;

    5640. 

  5640.                     $h = $f * 1.3;

    5641. 

  5641.                     $prop = array();

    5642. 

  5642.                     $prop['value'] = $param['value'];

    5643. 

  5643.                     $this->pdf->TextField($name, $w, $h, $prop, array(), $x, $y);

    5644. 

  5644.                     break;

    5645. 

  5645.                 

    5646. 

  5646.                 case 'submit' :

    5647. 

  5647.                     $w = $this->style->value['width'];

    5648. 

  5648.                     if (! $w)

    5649. 

  5649.                         $w = 40;

    5650. 

  5650.                     $h = $this->style->value['height'];

    5651. 

  5651.                     if (! $h)

    5652. 

  5652.                         $h = $f * 1.3;

    5653. 

  5653.                     $action = array('S' => 'SubmitForm', 'F' => $this->isInForm, 'Flags' => array('ExportFormat'));

    5654. 

  5654.                     $this->pdf->Button($name, $w, $h, $param['value'], $action, array(), array(), $x, $y);

    5655. 

  5655.                     break;

    5656. 

  5656.                 

    5657. 

  5657.                 case 'reset' :

    5658. 

  5658.                     $w = $this->style->value['width'];

    5659. 

  5659.                     if (! $w)

    5660. 

  5660.                         $w = 40;

    5661. 

  5661.                     $h = $this->style->value['height'];

    5662. 

  5662.                     if (! $h)

    5663. 

  5663.                         $h = $f * 1.3;

    5664. 

  5664.                     $action = array('S' => 'ResetForm');

    5665. 

  5665.                     $this->pdf->Button($name, $w, $h, $param['value'], $action, array(), array(), $x, $y);

    5666. 

  5666.                     break;

    5667. 

  5667.                 

    5668. 

  5668.                 case 'button' :

    5669. 

  5669.                     $w = $this->style->value['width'];

    5670. 

  5670.                     if (! $w)

    5671. 

  5671.                         $w = 40;

    5672. 

  5672.                     $h = $this->style->value['height'];

    5673. 

  5673.                     if (! $h)

    5674. 

  5674.                         $h = $f * 1.3;

    5675. 

  5675.                     $action = isset($param['onclick']) ? $param['onclick'] : '';

    5676. 

  5676.                     $this->pdf->Button($name, $w, $h, $param['value'], $action, array(), array(), $x, $y);

    5677. 

  5677.                     break;

    5678. 

  5678.                 

    5679. 

  5679.                 default :

    5680. 

  5680.                     $w = 0;

    5681. 

  5681.                     $h = 0;

    5682. 

  5682.                     break;

    5683. 

  5683.             }

    5684. 

  5684.             

    5685. 

  5685.             $this->maxX = max($this->maxX, $x + $w);

    5686. 

  5686.             $this->maxY = max($this->maxY, $y + $h);

    5687. 

  5687.             $this->maxH = max($this->maxH, $h);

    5688. 

  5688.             $this->pdf->setX($x + $w);

    5689. 

  5689.             

    5690. 

  5690.             $this->style->load();

    5691. 

  5691.             $this->style->FontSet();

    5692. 

  5692.             

    5693. 

  5693.             return true;

    5694. 

  5694.         }

    5695. 

  5695. 

    5696. 

  5696.         /**

    5697. 

  5697.          * balise : DRAW

    5698. 

  5698.          * mode : OUVERTURE

    5699. 

  5699.          *

    5700. 

  5700.          * @param	array	param�tres de l'�l�ment de parsing

    5701. 

  5701.          * @return	null

    5702. 

  5702.          */

    5703. 

  5703.         protected function o_DRAW($param)

    5704. 

  5704.         {

    5705. 

  5705.             if ($this->forOneLine)

    5706. 

  5706.                 return false;

    5707. 

  5707.             if ($this->DEBUG_actif)

    5708. 

  5708.                 $this->DEBUG_add('DRAW', true);

    5709. 

  5709.             

    5710. 

  5710.             $this->style->save();

    5711. 

  5711.             $this->style->analyse('draw', $param);

    5712. 

  5712.             $this->style->FontSet();

    5713. 

  5713.             

    5714. 

  5714.             $align_object = null;

    5715. 

  5715.             if ($this->style->value['margin-auto'])

    5716. 

  5716.                 $align_object = 'center';

    5717. 

  5717.             

    5718. 

  5718.             $marge = array();

    5719. 

  5719.             $marge['l'] = $this->style->value['border']['l']['width'] + 0.03;

    5720. 

  5720.             $marge['r'] = $this->style->value['border']['r']['width'] + 0.03;

    5721. 

  5721.             $marge['t'] = $this->style->value['border']['t']['width'] + 0.03;

    5722. 

  5722.             $marge['b'] = $this->style->value['border']['b']['width'] + 0.03;

    5723. 

  5723.             

    5724. 

  5724.             $over_w = $this->style->value['width'];

    5725. 

  5725.             $over_h = $this->style->value['height'];

    5726. 

  5726.             $this->style->value['old_maxX'] = $this->maxX;

    5727. 

  5727.             $this->style->value['old_maxY'] = $this->maxY;

    5728. 

  5728.             $this->style->value['old_maxH'] = $this->maxH;

    5729. 

  5729.             

    5730. 

  5730.             $w = $this->style->value['width'];

    5731. 

  5731.             $h = $this->style->value['height'];

    5732. 

  5732.             

    5733. 

  5733.             if (! $this->style->value['position'])

    5734. 

  5734.             {

    5735. 

  5735.                 if ($w < ($this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin()) && $this->pdf->getX() + $w >= ($this->pdf->getW() - $this->pdf->getrMargin()))

    5736. 

  5736.                     $this->o_BR(array());

    5737. 

  5737.                 

    5738. 

  5738.                 if (($h < ($this->pdf->getH() - $this->pdf->gettMargin() - $this->pdf->getbMargin())) && ($this->pdf->getY() + $h >= ($this->pdf->getH() - $this->pdf->getbMargin())) && ! $this->isInOverflow)

    5739. 

  5739.                     $this->setNewPage();

    5740. 

  5740.                 

    5741. 

  5741.      // en cas d'alignement => correction

    5742. 

  5742.                 $old = $this->style->getOldValues();

    5743. 

  5743.                 $parent_w = $old['width'] ? $old['width'] : $this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin();

    5744. 

  5744.                 

    5745. 

  5745.                 if ($parent_w > $w)

    5746. 

  5746.                 {

    5747. 

  5747.                     if ($align_object == 'center')

    5748. 

  5748.                         $this->pdf->setX($this->pdf->getX() + ($parent_w - $w) * 0.5);

    5749. 

  5749.                     else 

    5750. 

  5750.                         if ($align_object == 'right')

    5751. 

  5751.                             $this->pdf->setX($this->pdf->getX() + $parent_w - $w);

    5752. 

  5752.                 }

    5753. 

  5753.                 

    5754. 

  5754.                 $this->style->setPosition();

    5755. 

  5755.             }

    5756. 

  5756.             else

    5757. 

  5757.             {

    5758. 

  5758.                 // en cas d'alignement => correction

    5759. 

  5759.                 $old = $this->style->getOldValues();

    5760. 

  5760.                 $parent_w = $old['width'] ? $old['width'] : $this->pdf->getW() - $this->pdf->getlMargin() - $this->pdf->getrMargin();

    5761. 

  5761.                 

    5762. 

  5762.                 if ($parent_w > $w)

    5763. 

  5763.                 {

    5764. 

  5764.                     if ($align_object == 'center')

    5765. 

  5765.                         $this->pdf->setX($this->pdf->getX() + ($parent_w - $w) * 0.5);

    5766. 

  5766.                     else 

    5767. 

  5767.                         if ($align_object == 'right')

    5768. 

  5768.                             $this->pdf->setX($this->pdf->getX() + $parent_w - $w);

    5769. 

  5769.                 }

    5770. 

  5770.                 

    5771. 

  5771.                 $this->style->setPosition();

    5772. 

  5772.                 $this->saveMax();

    5773. 

  5773.                 $this->saveX = 0;

    5774. 

  5774.                 $this->saveY = 0;

    5775. 

  5775.                 $this->saveH = 0;

    5776. 

  5776.             }

    5777. 

  5777.             

    5778. 

  5778.             // initialisation du style des bordures de la div

    5779. 

  5779.             $this->drawRectangle($this->style->value['x'], $this->style->value['y'], $this->style->value['width'], $this->style->value['height'], $this->style->value['border'], $this->style->value['padding'], 0, $this->style->value['background']);

    5780. 

  5780.             

    5781. 

  5781.             $m = 0.03;

    5782. 

  5782.             

    5783. 

  5783.             $marge = array();

    5784. 

  5784.             $marge['l'] = $this->style->value['border']['l']['width'] + 0.03;

    5785. 

  5785.             $marge['r'] = $this->style->value['border']['r']['width'] + 0.03;

    5786. 

  5786.             $marge['t'] = $this->style->value['border']['t']['width'] + 0.03;

    5787. 

  5787.             $marge['b'] = $this->style->value['border']['b']['width'] + 0.03;

    5788. 

  5788.             

    5789. 

  5789.             $this->style->value['width'] -= $marge['l'] + $marge['r'];

    5790. 

  5790.             $this->style->value['height'] -= $marge['t'] + $marge['b'];

    5791. 

  5791.             

    5792. 

  5792.             $over_w -= $marge['l'] + $marge['r'];

    5793. 

  5793.             $over_h -= $marge['t'] + $marge['b'];

    5794. 

  5794.             $this->pdf->clippingPathOpen($this->style->value['x'] + $marge['l'], $this->style->value['y'] + $marge['t'], $this->style->value['width'], $this->style->value['height']);

    5795. 

  5795.             

    5796. 

  5796.             // limitation des marges aux dimensions du contenu

    5797. 

  5797.             $mL = $this->style->value['x'] + $marge['l'];

    5798. 

  5798.             $mR = $this->pdf->getW() - $mL - $over_w;

    5799. 

  5799.             

    5800. 

  5800.             $x = $this->style->value['x'] + $marge['l'];

    5801. 

  5801.             $y = $this->style->value['y'] + $marge['t'];

    5802. 

  5802.             $this->saveMargin($mL, 0, $mR);

    5803. 

  5803.             $this->pdf->setXY($x, $y);

    5804. 

  5804.             

    5805. 

  5805.             $this->isInDraw = array('x' => $x, 'y' => $y, 'w' => $over_w, 'h' => $over_h);

    5806. 

  5806.             $this->pdf->doTransform(array(1, 0, 0, 1, $x, $y));

    5807. 

  5807.             $this->pdf->SetAlpha(1.);

    5808. 

  5808.             return true;

    5809. 

  5809.         }

    5810. 

  5810. 

    5811. 

  5811.         /**

    5812. 

  5812.          * balise : DRAW

    5813. 

  5813.          * mode : FERMETURE

    5814. 

  5814.          *

    5815. 

  5815.          * @param	array	param�tres de l'�l�ment de parsing

    5816. 

  5816.          * @return	null

    5817. 

  5817.          */

    5818. 

  5818.         protected function c_DRAW($param)

    5819. 

  5819.         {

    5820. 

  5820.             if ($this->forOneLine)

    5821. 

  5821.                 return false;

    5822. 

  5822.             

    5823. 

  5823.             $this->pdf->SetAlpha(1.);

    5824. 

  5824.             $this->pdf->undoTransform();

    5825. 

  5825.             $this->pdf->clippingPathClose();

    5826. 

  5826.             

    5827. 

  5827.             $this->maxX = $this->style->value['old_maxX'];

    5828. 

  5828.             $this->maxY = $this->style->value['old_maxY'];

    5829. 

  5829.             $this->maxH = $this->style->value['old_maxH'];

    5830. 

  5830.             

    5831. 

  5831.             $marge = array();

    5832. 

  5832.             $marge['l'] = $this->style->value['border']['l']['width'] + 0.03;

    5833. 

  5833.             $marge['r'] = $this->style->value['border']['r']['width'] + 0.03;

    5834. 

  5834.             $marge['t'] = $this->style->value['border']['t']['width'] + 0.03;

    5835. 

  5835.             $marge['b'] = $this->style->value['border']['b']['width'] + 0.03;

    5836. 

  5836.             

    5837. 

  5837.             $x = $this->style->value['x'];

    5838. 

  5838.             $y = $this->style->value['y'];

    5839. 

  5839.             $w = $this->style->value['width'] + $marge['l'] + $marge['r'];

    5840. 

  5840.             $h = $this->style->value['height'] + $marge['t'] + $marge['b'];

    5841. 

  5841.             

    5842. 

  5842.             if ($this->style->value['position'] != 'absolute')

    5843. 

  5843.             {

    5844. 

  5844.                 // position

    5845. 

  5845.                 $this->pdf->setXY($x + $w, $y);

    5846. 

  5846.                 

    5847. 

  5847.                 // position MAX

    5848. 

  5848.                 $this->maxX = max($this->maxX, $x + $w);

    5849. 

  5849.                 $this->maxY = max($this->maxY, $y + $h);

    5850. 

  5850.                 $this->maxH = max($this->maxH, $h);

    5851. 

  5851.             }

    5852. 

  5852.             else

    5853. 

  5853.             {

    5854. 

  5854.                 // position

    5855. 

  5855.                 $this->pdf->setXY($this->style->value['xc'], $this->style->value['yc']);

    5856. 

  5856.                 

    5857. 

  5857.                 $this->loadMax();

    5858. 

  5858.             }

    5859. 

  5859.             

    5860. 

  5860.             $block = ($this->style->value['display'] != 'inline' && $this->style->value['position'] != 'absolute');

    5861. 

  5861.             

    5862. 

  5862.             $this->style->load();

    5863. 

  5863.             $this->style->FontSet();

    5864. 

  5864.             $this->loadMargin();

    5865. 

  5865.             

    5866. 

  5866.             if ($block)

    5867. 

  5867.                 $this->o_BR(array());

    5868. 

  5868.             if ($this->DEBUG_actif)

    5869. 

  5869.                 $this->DEBUG_add('DRAW', false);

    5870. 

  5870.             

    5871. 

  5871.             $this->isInDraw = null;

    5872. 

  5872.             

    5873. 

  5873.             return true;

    5874. 

  5874.         }

    5875. 

  5875. 

    5876. 

  5876.         /**

    5877. 

  5877.          * balise : LINE

    5878. 

  5878.          * mode : OUVERTURE

    5879. 

  5879.          *

    5880. 

  5880.          * @param	array	param�tres de l'�l�ment de parsing

    5881. 

  5881.          * @return	null

    5882. 

  5882.          */

    5883. 

  5883.         protected function o_LINE($param)

    5884. 

  5884.         {

    5885. 

  5885.             if (! $this->isInDraw)

    5886. 

  5886.                 HTML2PDF :: makeError(8, __FILE__, __LINE__, 'LINE');

    5887. 

  5887.             $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);

    5888. 

  5888.             $this->style->save();

    5889. 

  5889.             $styles = $this->style->getSvgStyle('path', $param);

    5890. 

  5890.             $styles['fill'] = null;

    5891. 

  5891.             $style = $this->pdf->svgSetStyle($styles);

    5892. 

  5892.             

    5893. 

  5893.             $x1 = isset($param['x1']) ? $this->style->ConvertToMM($param['x1'], $this->isInDraw['w']) : 0.;

    5894. 

  5894.             $y1 = isset($param['y1']) ? $this->style->ConvertToMM($param['y1'], $this->isInDraw['h']) : 0.;

    5895. 

  5895.             $x2 = isset($param['x2']) ? $this->style->ConvertToMM($param['x2'], $this->isInDraw['w']) : 0.;

    5896. 

  5896.             $y2 = isset($param['y2']) ? $this->style->ConvertToMM($param['y2'], $this->isInDraw['h']) : 0.;

    5897. 

  5897.             $this->pdf->svgLine($x1, $y1, $x2, $y2);

    5898. 

  5898.             

    5899. 

  5899.             $this->pdf->undoTransform();

    5900. 

  5900.             $this->style->load();

    5901. 

  5901.         }

    5902. 

  5902. 

    5903. 

  5903.         /**

    5904. 

  5904.          * balise : RECT

    5905. 

  5905.          * mode : OUVERTURE

    5906. 

  5906.          *

    5907. 

  5907.          * @param	array	param�tres de l'�l�ment de parsing

    5908. 

  5908.          * @return	null

    5909. 

  5909.          */

    5910. 

  5910.         protected function o_RECT($param)

    5911. 

  5911.         {

    5912. 

  5912.             if (! $this->isInDraw)

    5913. 

  5913.                 HTML2PDF :: makeError(8, __FILE__, __LINE__, 'RECT');

    5914. 

  5914.             $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);

    5915. 

  5915.             $this->style->save();

    5916. 

  5916.             $styles = $this->style->getSvgStyle('path', $param);

    5917. 

  5917.             $style = $this->pdf->svgSetStyle($styles);

    5918. 

  5918.             

    5919. 

  5919.             $x = isset($param['x']) ? $this->style->ConvertToMM($param['x'], $this->isInDraw['w']) : 0.;

    5920. 

  5920.             $y = isset($param['y']) ? $this->style->ConvertToMM($param['y'], $this->isInDraw['h']) : 0.;

    5921. 

  5921.             $w = isset($param['w']) ? $this->style->ConvertToMM($param['w'], $this->isInDraw['w']) : 0.;

    5922. 

  5922.             $h = isset($param['h']) ? $this->style->ConvertToMM($param['h'], $this->isInDraw['h']) : 0.;

    5923. 

  5923.             

    5924. 

  5924.             $this->pdf->svgRect($x, $y, $w, $h, $style);

    5925. 

  5925.             

    5926. 

  5926.             $this->pdf->undoTransform();

    5927. 

  5927.             $this->style->load();

    5928. 

  5928.         }

    5929. 

  5929. 

    5930. 

  5930.         /**

    5931. 

  5931.          * balise : CIRCLE

    5932. 

  5932.          * mode : OUVERTURE

    5933. 

  5933.          *

    5934. 

  5934.          * @param	array	param�tres de l'�l�ment de parsing

    5935. 

  5935.          * @return	null

    5936. 

  5936.          */

    5937. 

  5937.         protected function o_CIRCLE($param)

    5938. 

  5938.         {

    5939. 

  5939.             if (! $this->isInDraw)

    5940. 

  5940.                 HTML2PDF :: makeError(8, __FILE__, __LINE__, 'CIRCLE');

    5941. 

  5941.             $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);

    5942. 

  5942.             $this->style->save();

    5943. 

  5943.             $styles = $this->style->getSvgStyle('path', $param);

    5944. 

  5944.             $style = $this->pdf->svgSetStyle($styles);

    5945. 

  5945.             

    5946. 

  5946.             $cx = isset($param['cx']) ? $this->style->ConvertToMM($param['cx'], $this->isInDraw['w']) : 0.;

    5947. 

  5947.             $cy = isset($param['cy']) ? $this->style->ConvertToMM($param['cy'], $this->isInDraw['h']) : 0.;

    5948. 

  5948.             $r = isset($param['r']) ? $this->style->ConvertToMM($param['r'], $this->isInDraw['w']) : 0.;

    5949. 

  5949.             $this->pdf->svgEllipse($cx, $cy, $r, $r, $style);

    5950. 

  5950.             

    5951. 

  5951.             $this->pdf->undoTransform();

    5952. 

  5952.             $this->style->load();

    5953. 

  5953.         }

    5954. 

  5954. 

    5955. 

  5955.         /**

    5956. 

  5956.          * balise : ELLIPSE

    5957. 

  5957.          * mode : OUVERTURE

    5958. 

  5958.          *

    5959. 

  5959.          * @param	array	param�tres de l'�l�ment de parsing

    5960. 

  5960.          * @return	null

    5961. 

  5961.          */

    5962. 

  5962.         protected function o_ELLIPSE($param)

    5963. 

  5963.         {

    5964. 

  5964.             if (! $this->isInDraw)

    5965. 

  5965.                 HTML2PDF :: makeError(8, __FILE__, __LINE__, 'ELLIPSE');

    5966. 

  5966.             $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);

    5967. 

  5967.             $this->style->save();

    5968. 

  5968.             $styles = $this->style->getSvgStyle('path', $param);

    5969. 

  5969.             $style = $this->pdf->svgSetStyle($styles);

    5970. 

  5970.             

    5971. 

  5971.             $cx = isset($param['cx']) ? $this->style->ConvertToMM($param['cx'], $this->isInDraw['w']) : 0.;

    5972. 

  5972.             $cy = isset($param['cy']) ? $this->style->ConvertToMM($param['cy'], $this->isInDraw['h']) : 0.;

    5973. 

  5973.             $rx = isset($param['ry']) ? $this->style->ConvertToMM($param['rx'], $this->isInDraw['w']) : 0.;

    5974. 

  5974.             $ry = isset($param['rx']) ? $this->style->ConvertToMM($param['ry'], $this->isInDraw['h']) : 0.;

    5975. 

  5975.             $this->pdf->svgEllipse($cx, $cy, $rx, $ry, $style);

    5976. 

  5976.             

    5977. 

  5977.             $this->pdf->undoTransform();

    5978. 

  5978.             $this->style->load();

    5979. 

  5979.         }

    5980. 

  5980. 

    5981. 

  5981.         /**

    5982. 

  5982.          * balise : POLYLINE

    5983. 

  5983.          * mode : OUVERTURE

    5984. 

  5984.          *

    5985. 

  5985.          * @param	array	param�tres de l'�l�ment de parsing

    5986. 

  5986.          * @return	null

    5987. 

  5987.          */

    5988. 

  5988.         protected function o_POLYLINE($param)

    5989. 

  5989.         {

    5990. 

  5990.             if (! $this->isInDraw)

    5991. 

  5991.                 HTML2PDF :: makeError(8, __FILE__, __LINE__, 'POLYGON');

    5992. 

  5992.             $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);

    5993. 

  5993.             $this->style->save();

    5994. 

  5994.             $styles = $this->style->getSvgStyle('path', $param);

    5995. 

  5995.             $style = $this->pdf->svgSetStyle($styles);

    5996. 

  5996.             

    5997. 

  5997.             $path = isset($param['points']) ? $param['points'] : null;

    5998. 

  5998.             if ($path)

    5999. 

  5999.             {

    6000. 

  6000.                 $path = str_replace(',', ' ', $path);

    6001. 

  6001.                 $path = preg_replace('/[\s]+/', ' ', trim($path));

    6002. 

  6002.                 

    6003. 

  6003.                 // decoupage et nettoyage

    6004. 

  6004.                 $path = explode(' ', $path);

    6005. 

  6005.                 foreach ($path as $k => $v)

    6006. 

  6006.                 {

    6007. 

  6007.                     $path[$k] = trim($v);

    6008. 

  6008.                     if ($path[$k] === '')

    6009. 

  6009.                         unset($path[$k]);

    6010. 

  6010.                 }

    6011. 

  6011.                 $path = array_values($path);

    6012. 

  6012.                 

    6013. 

  6013.                 $actions = array();

    6014. 

  6014.                 for($k = 0; $k < count($path); $k += 2)

    6015. 

  6015.                 {

    6016. 

  6016.                     $actions[] = array(($k ? 'L' : 'M'), $this->style->ConvertToMM($path[$k + 0], $this->isInDraw['w']), 

    6017. 

  6017.                             $this->style->ConvertToMM($path[$k + 1], $this->isInDraw['h']));

    6018. 

  6018.                 }

    6019. 

  6019.                 

    6020. 

  6020.                 // on trace

    6021. 

  6021.                 $this->pdf->svgPolygone($actions, $style);

    6022. 

  6022.             }

    6023. 

  6023.             

    6024. 

  6024.             $this->pdf->undoTransform();

    6025. 

  6025.             $this->style->load();

    6026. 

  6026.         }

    6027. 

  6027. 

    6028. 

  6028.         /**

    6029. 

  6029.          * balise : POLYGON

    6030. 

  6030.          * mode : OUVERTURE

    6031. 

  6031.          *

    6032. 

  6032.          * @param	array	param�tres de l'�l�ment de parsing

    6033. 

  6033.          * @return	null

    6034. 

  6034.          */

    6035. 

  6035.         protected function o_POLYGON($param)

    6036. 

  6036.         {

    6037. 

  6037.             if (! $this->isInDraw)

    6038. 

  6038.                 HTML2PDF :: makeError(8, __FILE__, __LINE__, 'POLYGON');

    6039. 

  6039.             $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);

    6040. 

  6040.             $this->style->save();

    6041. 

  6041.             $styles = $this->style->getSvgStyle('path', $param);

    6042. 

  6042.             $style = $this->pdf->svgSetStyle($styles);

    6043. 

  6043.             

    6044. 

  6044.             $path = isset($param['points']) ? $param['points'] : null;

    6045. 

  6045.             if ($path)

    6046. 

  6046.             {

    6047. 

  6047.                 $path = str_replace(',', ' ', $path);

    6048. 

  6048.                 $path = preg_replace('/[\s]+/', ' ', trim($path));

    6049. 

  6049.                 

    6050. 

  6050.                 // decoupage et nettoyage

    6051. 

  6051.                 $path = explode(' ', $path);

    6052. 

  6052.                 foreach ($path as $k => $v)

    6053. 

  6053.                 {

    6054. 

  6054.                     $path[$k] = trim($v);

    6055. 

  6055.                     if ($path[$k] === '')

    6056. 

  6056.                         unset($path[$k]);

    6057. 

  6057.                 }

    6058. 

  6058.                 $path = array_values($path);

    6059. 

  6059.                 

    6060. 

  6060.                 $actions = array();

    6061. 

  6061.                 for($k = 0; $k < count($path); $k += 2)

    6062. 

  6062.                 {

    6063. 

  6063.                     $actions[] = array(($k ? 'L' : 'M'), $this->style->ConvertToMM($path[$k + 0], $this->isInDraw['w']), 

    6064. 

  6064.                             $this->style->ConvertToMM($path[$k + 1], $this->isInDraw['h']));

    6065. 

  6065.                 }

    6066. 

  6066.                 $actions[] = array('z');

    6067. 

  6067.                 // on trace

    6068. 

  6068.                 $this->pdf->svgPolygone($actions, $style);

    6069. 

  6069.             }

    6070. 

  6070.             

    6071. 

  6071.             $this->pdf->undoTransform();

    6072. 

  6072.             $this->style->load();

    6073. 

  6073.         }

    6074. 

  6074. 

    6075. 

  6075.         /**

    6076. 

  6076.          * balise : PATH

    6077. 

  6077.          * mode : OUVERTURE

    6078. 

  6078.          *

    6079. 

  6079.          * @param	array	param�tres de l'�l�ment de parsing

    6080. 

  6080.          * @return	null

    6081. 

  6081.          */

    6082. 

  6082.         protected function o_PATH($param)

    6083. 

  6083.         {

    6084. 

  6084.             if (! $this->isInDraw)

    6085. 

  6085.                 HTML2PDF :: makeError(8, __FILE__, __LINE__, 'PATH');

    6086. 

  6086.             $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);

    6087. 

  6087.             $this->style->save();

    6088. 

  6088.             $styles = $this->style->getSvgStyle('path', $param);

    6089. 

  6089.             $style = $this->pdf->svgSetStyle($styles);

    6090. 

  6090.             

    6091. 

  6091.             $path = isset($param['d']) ? $param['d'] : null;

    6092. 

  6092.             if ($path)

    6093. 

  6093.             {

    6094. 

  6094.                 // preparation

    6095. 

  6095.                 $path = str_replace(',', ' ', $path);

    6096. 

  6096.                 $path = preg_replace('/([a-zA-Z])([0-9\.\-])/', '$1 $2', $path);

    6097. 

  6097.                 $path = preg_replace('/([0-9\.])([a-zA-Z])/', '$1 $2', $path);

    6098. 

  6098.                 $path = preg_replace('/[\s]+/', ' ', trim($path));

    6099. 

  6099.                 $path = preg_replace('/ ([a-z]{2})/', '$1', $path);

    6100. 

  6100.                 

    6101. 

  6101.                 // decoupage et nettoyage

    6102. 

  6102.                 $path = explode(' ', $path);

    6103. 

  6103.                 foreach ($path as $k => $v)

    6104. 

  6104.                 {

    6105. 

  6105.                     $path[$k] = trim($v);

    6106. 

  6106.                     if ($path[$k] === '')

    6107. 

  6107.                         unset($path[$k]);

    6108. 

  6108.                 }

    6109. 

  6109.                 $path = array_values($path);

    6110. 

  6110.                 

    6111. 

  6111.                 // conversion des unites

    6112. 

  6112.                 $actions = array();

    6113. 

  6113.                 $action = array();

    6114. 

  6114.                 for($k = 0; $k < count($path); $k += count($action))

    6115. 

  6115.                 {

    6116. 

  6116.                     $action = array();

    6117. 

  6117.                     $action[] = $path[$k];

    6118. 

  6118.                     switch ($path[$k])

    6119. 

  6119.                     {

    6120. 

  6120.                         case 'C' :

    6121. 

  6121.                         case 'c' :

    6122. 

  6122.                             $action[] = $this->style->ConvertToMM($path[$k + 1], $this->isInDraw['w']); // x1

    6123. 

  6123.                             $action[] = $this->style->ConvertToMM($path[$k + 2], $this->isInDraw['h']); // y1

    6124. 

  6124.                             $action[] = $this->style->ConvertToMM($path[$k + 3], $this->isInDraw['w']); // x2

    6125. 

  6125.                             $action[] = $this->style->ConvertToMM($path[$k + 4], $this->isInDraw['h']); // y2

    6126. 

  6126.                             $action[] = $this->style->ConvertToMM($path[$k + 5], $this->isInDraw['w']); // x

    6127. 

  6127.                             $action[] = $this->style->ConvertToMM($path[$k + 6], $this->isInDraw['h']); // y

    6128. 

  6128.                             break;

    6129. 

  6129.                         

    6130. 

  6130.                         case 'Q' :

    6131. 

  6131.                         case 'S' :

    6132. 

  6132.                         case 'q' :

    6133. 

  6133.                         case 's' :

    6134. 

  6134.                             $action[] = $this->style->ConvertToMM($path[$k + 1], $this->isInDraw['w']); // x2

    6135. 

  6135.                             $action[] = $this->style->ConvertToMM($path[$k + 2], $this->isInDraw['h']); // y2

    6136. 

  6136.                             $action[] = $this->style->ConvertToMM($path[$k + 3], $this->isInDraw['w']); // x

    6137. 

  6137.                             $action[] = $this->style->ConvertToMM($path[$k + 4], $this->isInDraw['h']); // y

    6138. 

  6138.                             break;

    6139. 

  6139.                         

    6140. 

  6140.                         case 'A' :

    6141. 

  6141.                         case 'a' :

    6142. 

  6142.                             $action[] = $this->style->ConvertToMM($path[$k + 1], $this->isInDraw['w']); // rx

    6143. 

  6143.                             $action[] = $this->style->ConvertToMM($path[$k + 2], $this->isInDraw['h']); // ry

    6144. 

  6144.                             $action[] = 1. * $path[$k + 3]; // angle de deviation de l'axe X

    6145. 

  6145.                             $action[] = ($path[$k + 4] == '1') ? 1 : 0; // large-arc-flag

    6146. 

  6146.                             $action[] = ($path[$k + 5] == '1') ? 1 : 0; // sweep-flag

    6147. 

  6147.                             $action[] = $this->style->ConvertToMM($path[$k + 6], $this->isInDraw['w']); // x

    6148. 

  6148.                             $action[] = $this->style->ConvertToMM($path[$k + 7], $this->isInDraw['h']); // y

    6149. 

  6149.                             break;

    6150. 

  6150.                         

    6151. 

  6151.                         case 'M' :

    6152. 

  6152.                         case 'L' :

    6153. 

  6153.                         case 'T' :

    6154. 

  6154.                         case 'm' :

    6155. 

  6155.                         case 'l' :

    6156. 

  6156.                         case 't' :

    6157. 

  6157.                             $action[] = $this->style->ConvertToMM($path[$k + 1], $this->isInDraw['w']); // x

    6158. 

  6158.                             $action[] = $this->style->ConvertToMM($path[$k + 2], $this->isInDraw['h']); // y

    6159. 

  6159.                             break;

    6160. 

  6160.                         

    6161. 

  6161.                         case 'H' :

    6162. 

  6162.                         case 'h' :

    6163. 

  6163.                             $action[] = $this->style->ConvertToMM($path[$k + 1], $this->isInDraw['w']); // x

    6164. 

  6164.                             break;

    6165. 

  6165.                         

    6166. 

  6166.                         case 'V' :

    6167. 

  6167.                         case 'v' :

    6168. 

  6168.                             $action[] = $this->style->ConvertToMM($path[$k + 1], $this->isInDraw['h']); // y

    6169. 

  6169.                             break;

    6170. 

  6170.                         

    6171. 

  6171.                         case 'z' :

    6172. 

  6172.                         case 'Z' :

    6173. 

  6173.                         default :

    6174. 

  6174.                             break;

    6175. 

  6175.                     }

    6176. 

  6176.                     $actions[] = $action;

    6177. 

  6177.                 }

    6178. 

  6178.                 

    6179. 

  6179.                 // on trace

    6180. 

  6180.                 $this->pdf->svgPolygone($actions, $style);

    6181. 

  6181.             }

    6182. 

  6182.             

    6183. 

  6183.             $this->pdf->undoTransform();

    6184. 

  6184.             $this->style->load();

    6185. 

  6185.         }

    6186. 

  6186. 

    6187. 

  6187.         /**

    6188. 

  6188.          * balise : G

    6189. 

  6189.          * mode : OUVERTURE

    6190. 

  6190.          *

    6191. 

  6191.          * @param	array	param�tres de l'�l�ment de parsing

    6192. 

  6192.          * @return	null

    6193. 

  6193.          */

    6194. 

  6194.         protected function o_G($param)

    6195. 

  6195.         {

    6196. 

  6196.             if (! $this->isInDraw)

    6197. 

  6197.                 HTML2PDF :: makeError(8, __FILE__, __LINE__, 'LINE');

    6198. 

  6198.             $this->pdf->doTransform(isset($param['transform']) ? $this->_prepareTransform($param['transform']) : null);

    6199. 

  6199.             $this->style->save();

    6200. 

  6200.             $styles = $this->style->getSvgStyle('path', $param);

    6201. 

  6201.             $style = $this->pdf->svgSetStyle($styles);

    6202. 

  6202.         }

    6203. 

  6203. 

    6204. 

  6204.         /**

    6205. 

  6205.          * balise : G

    6206. 

  6206.          * mode : FERMETURE

    6207. 

  6207.          *

    6208. 

  6208.          * @param	array	param�tres de l'�l�ment de parsing

    6209. 

  6209.          * @return	null

    6210. 

  6210.          */

    6211. 

  6211.         protected function c_G($param)

    6212. 

  6212.         {

    6213. 

  6213.             $this->pdf->undoTransform();

    6214. 

  6214.             $this->style->load();

    6215. 

  6215.         }

    6216. 

  6216. 

    6217. 

  6217.         protected function _prepareTransform($transform)

    6218. 

  6218.         {

    6219. 

  6219.             if (! $transform)

    6220. 

  6220.                 return null;

    6221. 

  6221.             $actions = array();

    6222. 

  6222.             if (! preg_match_all('/([a-z]+)\(([^\)]*)\)/isU', $transform, $match))

    6223. 

  6223.                 return null;

    6224. 

  6224.             

    6225. 

  6225.             for($k = 0; $k < count($match[0]); $k ++)

    6226. 

  6226.             {

    6227. 

  6227.                 $nom = strtolower($match[1][$k]);

    6228. 

  6228.                 $val = explode(',', trim($match[2][$k]));

    6229. 

  6229.                 foreach ($val as $i => $j)

    6230. 

  6230.                     $val[$i] = trim($j);

    6231. 

  6231.                 

    6232. 

  6232.                 switch ($nom)

    6233. 

  6233.                 {

    6234. 

  6234.                     case 'scale' :

    6235. 

  6235.                         if (! isset($val[0]))

    6236. 

  6236.                             $val[0] = 1.;

    6237. 

  6237.                         else

    6238. 

  6238.                             $val[0] = 1. * $val[0];

    6239. 

  6239.                         if (! isset($val[1]))

    6240. 

  6240.                             $val[1] = $val[0];

    6241. 

  6241.                         else

    6242. 

  6242.                             $val[1] = 1. * $val[1];

    6243. 

  6243.                         $actions[] = array($val[0], 0, 0, $val[1], 0, 0);

    6244. 

  6244.                         break;

    6245. 

  6245.                     

    6246. 

  6246.                     case 'translate' :

    6247. 

  6247.                         if (! isset($val[0]))

    6248. 

  6248.                             $val[0] = 0.;

    6249. 

  6249.                         else

    6250. 

  6250.                             $val[0] = $this->style->ConvertToMM($val[0], $this->isInDraw['w']);

    6251. 

  6251.                         if (! isset($val[1]))

    6252. 

  6252.                             $val[1] = 0.;

    6253. 

  6253.                         else

    6254. 

  6254.                             $val[1] = $this->style->ConvertToMM($val[1], $this->isInDraw['h']);

    6255. 

  6255.                         $actions[] = array(1, 0, 0, 1, $val[0], $val[1]);

    6256. 

  6256.                         break;

    6257. 

  6257.                     

    6258. 

  6258.                     case 'rotate' :

    6259. 

  6259.                         if (! isset($val[0]))

    6260. 

  6260.                             $val[0] = 0.;

    6261. 

  6261.                         else

    6262. 

  6262.                             $val[0] = $val[0] * M_PI / 180.;

    6263. 

  6263.                         if (! isset($val[1]))

    6264. 

  6264.                             $val[1] = 0.;

    6265. 

  6265.                         else

    6266. 

  6266.                             $val[1] = $this->style->ConvertToMM($val[1], $this->isInDraw['w']);

    6267. 

  6267.                         if (! isset($val[2]))

    6268. 

  6268.                             $val[2] = 0.;

    6269. 

  6269.                         else

    6270. 

  6270.                             $val[2] = $this->style->ConvertToMM($val[2], $this->isInDraw['h']);

    6271. 

  6271.                         if ($val[1] || $val[2])

    6272. 

  6272.                             $actions[] = array(1, 0, 0, 1, - $val[1], - $val[2]);

    6273. 

  6273.                         $actions[] = array(cos($val[0]), sin($val[0]), - sin($val[0]), cos($val[0]), 0, 0);

    6274. 

  6274.                         if ($val[1] || $val[2])

    6275. 

  6275.                             $actions[] = array(1, 0, 0, 1, $val[1], $val[2]);

    6276. 

  6276.                         break;

    6277. 

  6277.                     

    6278. 

  6278.                     case 'skewx' :

    6279. 

  6279.                         if (! isset($val[0]))

    6280. 

  6280.                             $val[0] = 0.;

    6281. 

  6281.                         else

    6282. 

  6282.                             $val[0] = $val[0] * M_PI / 180.;

    6283. 

  6283.                         $actions[] = array(1, 0, tan($val[0]), 1, 0, 0);

    6284. 

  6284.                         break;

    6285. 

  6285.                     

    6286. 

  6286.                     case 'skewy' :

    6287. 

  6287.                         if (! isset($val[0]))

    6288. 

  6288.                             $val[0] = 0.;

    6289. 

  6289.                         else

    6290. 

  6290.                             $val[0] = $val[0] * M_PI / 180.;

    6291. 

  6291.                         $actions[] = array(1, tan($val[0]), 0, 1, 0, 0);

    6292. 

  6292.                         break;

    6293. 

  6293.                     case 'matrix' :

    6294. 

  6294.                         if (! isset($val[0]))

    6295. 

  6295.                             $val[0] = 0.;

    6296. 

  6296.                         else

    6297. 

  6297.                             $val[0] = $val[0] * 1.;

    6298. 

  6298.                         if (! isset($val[1]))

    6299. 

  6299.                             $val[1] = 0.;

    6300. 

  6300.                         else

    6301. 

  6301.                             $val[1] = $val[1] * 1.;

    6302. 

  6302.                         if (! isset($val[2]))

    6303. 

  6303.                             $val[2] = 0.;

    6304. 

  6304.                         else

    6305. 

  6305.                             $val[2] = $val[2] * 1.;

    6306. 

  6306.                         if (! isset($val[3]))

    6307. 

  6307.                             $val[3] = 0.;

    6308. 

  6308.                         else

    6309. 

  6309.                             $val[3] = $val[3] * 1.;

    6310. 

  6310.                         if (! isset($val[4]))

    6311. 

  6311.                             $val[4] = 0.;

    6312. 

  6312.                         else

    6313. 

  6313.                             $val[4] = $this->style->ConvertToMM($val[4], $this->isInDraw['w']);

    6314. 

  6314.                         if (! isset($val[5]))

    6315. 

  6315.                             $val[5] = 0.;

    6316. 

  6316.                         else

    6317. 

  6317.                             $val[5] = $this->style->ConvertToMM($val[5], $this->isInDraw['h']);

    6318. 

  6318.                         $actions[] = $val;

    6319. 

  6319.                         break;

    6320. 

  6320.                 }

    6321. 

  6321.             }

    6322. 

  6322.             

    6323. 

  6323.             if (! $actions)

    6324. 

  6324.                 return null;

    6325. 

  6325.             $m = $actions[0];

    6326. 

  6326.             unset($actions[0]);

    6327. 

  6327.             foreach ($actions as $n)

    6328. 

  6328.             {

    6329. 

  6329.                 $m = array($m[0] * $n[0] + $m[2] * $n[1], $m[1] * $n[0] + $m[3] * $n[1], $m[0] * $n[2] + $m[2] * $n[3], 

    6330. 

  6330.                         $m[1] * $n[2] + $m[3] * $n[3], $m[0] * $n[4] + $m[2] * $n[5] + $m[4], 

    6331. 

  6331.                         $m[1] * $n[4] + $m[3] * $n[5] + $m[5]);

    6332. 

  6332.             }

    6333. 

  6333.             

    6334. 

  6334.             return $m;

    6335. 

  6335.         }

    6336. 

  6336. 

    6337. 

  6337.         protected function _getDrawNumber(&$lst, $key, $n = 1, $correct = false)

    6338. 

  6338.         {

    6339. 

  6339.             $res = array_fill(0, $n, 0);

    6340. 

  6340.             $tmp = isset($lst[$key]) ? $lst[$key] : null;

    6341. 

  6341.             if (! $tmp)

    6342. 

  6342.                 return $res;

    6343. 

  6343.             $tmp = explode(' ', trim(preg_replace('/[\s]+/', ' ', $tmp)));

    6344. 

  6344.             foreach ($tmp as $k => $v)

    6345. 

  6345.             {

    6346. 

  6346.                 $v = trim($v);

    6347. 

  6347.                 if (! $correct)

    6348. 

  6348.                 {

    6349. 

  6349.                     $res[$k] = $this->style->ConvertToMM($v);

    6350. 

  6350.                 }

    6351. 

  6351.                 else

    6352. 

  6352.                 {

    6353. 

  6353.                     $res[$k] = $this->style->ConvertToMM($v, ($k % 2) ? $this->isInDraw['h'] : $this->isInDraw['w']);

    6354. 

  6354.                 }

    6355. 

  6355.             }

    6356. 

  6356.             return $res;

    6357. 

  6357.         }

    6358. 

  6358. 

    6359. 

  6359.         /**

    6360. 

  6360.          * permet d'afficher un index automatique utilisant les bookmark

    6361. 

  6361.          *

    6362. 

  6362.          * @param	string	titre du sommaire

    6363. 

  6363.          * @param	int		taille en mm de la fonte du titre du sommaire

    6364. 

  6364.          * @param	int		taille en mm de la fonte du texte du sommaire

    6365. 

  6365.          * @param	boolean	ajouter un bookmark sp�cifique  pour l'index, juste avant le d�but de celui-ci

    6366. 

  6366.          * @param	boolean	afficher les num�ros de page associ�s � chaque bookmark

    6367. 

  6367.          * @param	int		si pr�sent : page o� afficher le sommaire. sinon : nouvelle page

    6368. 

  6368.          * @param	string	nom de la fonte � utiliser

    6369. 

  6369.          * @return	null

    6370. 

  6370.          */

    6371. 

  6371.         public function createIndex($titre = 'Index', $size_title = 20, $size_bookmark = 15, $bookmark_title = true, $display_page = true, $on_page = null, $font_name = 'helvetica')

    6372. 

  6372.         {

    6373. 

  6373.             $old_page = $this->INDEX_NewPage($on_page);

    6374. 

  6374.             $this->pdf->createIndex($this, $titre, $size_title, $size_bookmark, $bookmark_title, $display_page, $on_page, $font_name);

    6375. 

  6375.             if ($old_page)

    6376. 

  6376.                 $this->pdf->setPage($old_page);

    6377. 

  6377.         }

    6378. 

  6378. 

    6379. 

  6379.         /**

    6380. 

  6380.          * nouvelle page pour l'index. ne pas utiliser directement. seul MyPDF doit l'utiliser !!!!

    6381. 

  6381.          *

    6382. 

  6382.          * @param	int		page courante

    6383. 

  6383.          * @return	null

    6384. 

  6384.          */

    6385. 

  6385.         public function INDEX_NewPage(&$page)

    6386. 

  6386.         {

    6387. 

  6387.             if ($page)

    6388. 

  6388.             {

    6389. 

  6389.                 $old_page = $this->pdf->getPage();

    6390. 

  6390.                 $this->pdf->setPage($page);

    6391. 

  6391.                 $this->pdf->setXY($this->margeLeft, $this->margeTop);

    6392. 

  6392.                 $this->maxH = 0;

    6393. 

  6393.                 $page ++;

    6394. 

  6394.                 return $old_page;

    6395. 

  6395.             }

    6396. 

  6396.             else

    6397. 

  6397.             {

    6398. 

  6398.                 $this->setNewPage();

    6399. 

  6399.                 return null;

    6400. 

  6400.             }

    6401. 

  6401.         }

    6402. 

  6402. 

    6403. 

  6403.         /**

    6404. 

  6404.          * chargement du fichier de langue

    6405. 

  6405.          *

    6406. 

  6406.          * @param	string langue

    6407. 

  6407.          * @return	null

    6408. 

  6408.          */

    6409. 

  6409.         static protected function textLOAD($langue)

    6410. 

  6410.         {

    6411. 

  6411.             if (count(HTML2PDF :: $TEXTES))

    6412. 

  6412.                 return true;

    6413. 

  6413.             

    6414. 

  6414.             if (! preg_match('/^([a-z0-9]+)$/isU', $langue))

    6415. 

  6415.             {

    6416. 

  6416.                 echo 'ERROR : language code <b>' . $langue . '</b> incorrect.';

    6417. 

  6417.                 exit();

    6418. 

  6418.             }

    6419. 

  6419.             

    6420. 

  6420.             $file = dirname(__FILE__) . '/langues/' . strtolower($langue) . '.txt';

    6421. 

  6421.             if (! is_file($file))

    6422. 

  6422.             {

    6423. 

  6423.                 echo 'ERROR : language code <b>' . $langue . '</b> unknown.<br>';

    6424. 

  6424.                 echo 'You can create the translation file <b>' . $file . '</b> and send it to me in order to integrate it into a future version.';

    6425. 

  6425.                 exit();

    6426. 

  6426.             }

    6427. 

  6427.             

    6428. 

  6428.             $texte = array();

    6429. 

  6429.             $infos = file($file);

    6430. 

  6430.             foreach ($infos as $val)

    6431. 

  6431.             {

    6432. 

  6432.                 $val = trim($val);

    6433. 

  6433.                 $val = explode("\t", $val);

    6434. 

  6434.                 if (count($val) < 2)

    6435. 

  6435.                     continue;

    6436. 

  6436.                 

    6437. 

  6437.                 $t_k = trim($val[0]);

    6438. 

  6438.                 unset($val[0]);

    6439. 

  6439.                 $t_v = trim(implode(' ', $val));

    6440. 

  6440.                 if ($t_k && $t_v)

    6441. 

  6441.                     $texte[$t_k] = $t_v;

    6442. 

  6442.             }

    6443. 

  6443.             HTML2PDF :: $TEXTES = $texte;

    6444. 

  6444.             

    6445. 

  6445.             return true;

    6446. 

  6446.         }

    6447. 

  6447. 

    6448. 

  6448.         /**

    6449. 

  6449.          * recuperer un texte precis

    6450. 

  6450.          *

    6451. 

  6451.          * @param	string code du texte

    6452. 

  6452.          * @return	null

    6453. 

  6453.          */

    6454. 

  6454.         static public function textGET($key)

    6455. 

  6455.         {

    6456. 

  6456.             if (! isset(HTML2PDF :: $TEXTES[$key]))

    6457. 

  6457.                 return '######';

    6458. 

  6458.             

    6459. 

  6459.             return HTML2PDF :: $TEXTES[$key];

    6460. 

  6460.         }

    6461. 

  6461. 

    6462. 

  6462.         /**

    6463. 

  6463.          * generer une erreur HTML2PDF

    6464. 

  6464.          *

    6465. 

  6465.          * @param	int		numero de l'erreur

    6466. 

  6466.          * @param	string	nom du fichier ou c'est produit l'erreur

    6467. 

  6467.          * @param	int		numero de la ligne ou c'est produit l'erreur

    6468. 

  6468.          * @param	mixed	indications suplementaires sur l'erreur

    6469. 

  6469.          * @return	string	code HTML eventuel associ� � l'erreur

    6470. 

  6470.          */

    6471. 

  6471.         static public function makeError($err, $file, $line, $other = null, $html = '')

    6472. 

  6472.         {

    6473. 

  6473.             $msg = '';

    6474. 

  6474.             switch ($err)

    6475. 

  6475.             {

    6476. 

  6476.                 case 1 :

    6477. 

  6477.                     $msg = (HTML2PDF :: textGET('err01'));

    6478. 

  6478.                     $msg = str_replace('[[OTHER]]', $other, $msg);

    6479. 

  6479.                     break;

    6480. 

  6480.                 

    6481. 

  6481.                 case 2 :

    6482. 

  6482.                     $msg = (HTML2PDF :: textGET('err02'));

    6483. 

  6483.                     $msg = str_replace('[[OTHER_0]]', $other[0], $msg);

    6484. 

  6484.                     $msg = str_replace('[[OTHER_1]]', $other[1], $msg);

    6485. 

  6485.                     $msg = str_replace('[[OTHER_2]]', $other[2], $msg);

    6486. 

  6486.                     break;

    6487. 

  6487.                 

    6488. 

  6488.                 case 3 :

    6489. 

  6489.                     $msg = (HTML2PDF :: textGET('err03'));

    6490. 

  6490.                     $msg = str_replace('[[OTHER]]', $other, $msg);

    6491. 

  6491.                     break;

    6492. 

  6492.                 

    6493. 

  6493.                 case 4 :

    6494. 

  6494.                     $msg = (HTML2PDF :: textGET('err04'));

    6495. 

  6495.                     $msg = str_replace('[[OTHER]]', print_r($other, true), $msg);

    6496. 

  6496.                     break;

    6497. 

  6497.                 

    6498. 

  6498.                 case 5 :

    6499. 

  6499.                     $msg = (HTML2PDF :: textGET('err05'));

    6500. 

  6500.                     $msg = str_replace('[[OTHER]]', print_r($other, true), $msg);

    6501. 

  6501.                     break;

    6502. 

  6502.                 

    6503. 

  6503.                 case 6 :

    6504. 

  6504.                     $msg = (HTML2PDF :: textGET('err06'));

    6505. 

  6505.                     $msg = str_replace('[[OTHER]]', $other, $msg);

    6506. 

  6506.                     break;

    6507. 

  6507.                 

    6508. 

  6508.                 case 7 :

    6509. 

  6509.                     $msg = (HTML2PDF :: textGET('err07'));

    6510. 

  6510.                     break;

    6511. 

  6511.                 

    6512. 

  6512.                 case 8 :

    6513. 

  6513.                     $msg = (HTML2PDF :: textGET('err08'));

    6514. 

  6514.                     $msg = str_replace('[[OTHER]]', $other, $msg);

    6515. 

  6515.                     break;

    6516. 

  6516.             }

    6517. 

  6517.             echo '<span style="color: #AA0000; font-weight: bold;">' . (HTML2PDF :: textGET('txt01')) . $err . '</span><br>';

    6518. 

  6518.             echo (HTML2PDF :: textGET('txt02')) . ' ' . $file . '<br>';

    6519. 

  6519.             echo (HTML2PDF :: textGET('txt03')) . ' ' . $line . '<br>';

    6520. 

  6520.             echo '<br>';

    6521. 

  6521.             echo $msg;

    6522. 

  6522.             echo '<br>';

    6523. 

  6523.             if ($html)

    6524. 

  6524.                 echo '<br>HTML : ...' . htmlentities($html) . '...';

    6525. 

  6525.             exit();

    6526. 

  6526.         }

    6527. 

  6527.     }

    6528. 

  6528. }

    6529. 

  6529.