/include/html2pdf/html2pdf.class.php

https://bitbucket.org/sleininger/stock_online · PHP · 6125 lines · 4031 code · 857 blank · 1237 comment · 664 complexity · 2c96e3ec10ad42db995aacb6c834a163 MD5 · raw file

Large files are truncated click here to view the full file

    

  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.01

    10. 

  10.  */

    11. 

  11. 

    12. 

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

    13. 

  13. {

    14. 

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

    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. 	class HTML2PDF

    21. 

  21. 	{

    22. 

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

    23. 

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

    24. 

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

    25. 

  25. 

    26. 

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

    27. 

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

    28. 

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

    29. 

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

    30. 

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

    31. 

  31. 

    32. 

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

    33. 

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

    34. 

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

    35. 

  35. 		protected	$testIsDeprecated	= false;	// test si certaines fonctions sont deprecated

    36. 

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

    37. 

  37. 

    38. 

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

    39. 

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

    40. 

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

    41. 

  41. 

    42. 

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

    43. 

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

    44. 

  44. 

    45. 

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

    46. 

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

    47. 

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

    48. 

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

    49. 

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

    50. 

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

    51. 

  51. 

    52. 

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

    53. 

  53. 

    54. 

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

    55. 

  55. 		protected	$defaultTop			= 0;

    56. 

  56. 		protected	$defaultRight		= 0;

    57. 

  57. 		protected	$defaultBottom		= 0;

    58. 

  58. 

    59. 

  59. 		protected	$margeLeft			= 0;		//marges rיelles de la page

    60. 

  60. 		protected	$margeTop			= 0;

    61. 

  61. 		protected	$margeRight			= 0;

    62. 

  62. 		protected	$margeBottom		= 0;

    63. 

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

    64. 

  64. 

    65. 

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

    66. 

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

    67. 

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

    68. 

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

    69. 

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

    70. 

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

    71. 

  71. 

    72. 

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

    73. 

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

    74. 

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

    75. 

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

    76. 

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

    77. 

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

    78. 

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

    79. 

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

    80. 

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

    81. 

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

    82. 

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

    83. 

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

    84. 

  84. 

    85. 

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

    86. 

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

    87. 

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

    88. 

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

    89. 

  89. 		protected	$DEBUG_start_time	= 0;		//

    90. 

  90. 		protected	$DEBUG_last_time	= 0;		//

    91. 

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

    92. 

  92. 

    93. 

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

    94. 

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

    95. 

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

    96. 

  96. 

    97. 

  97. 		/**

    98. 

  98. 		 * Constructeur

    99. 

  99. 		 *

    100. 

  100. 		 * @param	string		sens portrait ou landscape

    101. 

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

    102. 

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

    103. 

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

    104. 

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

    105. 

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

    106. 

  106. 		 * @return	null

    107. 

  107. 		 */

    108. 

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

    109. 

  109. 		{

    110. 

  110. 			// sauvegarde des paramטtres

    111. 

  111. 			$this->page 		= 0;

    112. 

  112. 			$this->sens			= $sens;

    113. 

  113. 			$this->format		= $format;

    114. 

  114. 			$this->unicode		= $unicode;

    115. 

  115. 			$this->encoding		= $encoding;

    116. 

  116. 				

    117. 

  117. 			$this->firstPage	= true;

    118. 

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

    119. 

  119. 				

    120. 

  120. 			// chargement du fichier de langue

    121. 

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

    122. 

  122. 				

    123. 

  123. 			// crיation de l' objet PDF

    124. 

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

    125. 

  125. 

    126. 

  126. 			// initialisation des styles

    127. 

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

    128. 

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

    129. 

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

    130. 

  130. 				

    131. 

  131. 			// initialisations diverses

    132. 

  132. 			$this->setTestTdInOnePage(true);

    133. 

  133. 			$this->setTestIsImage(true);

    134. 

  134. 			$this->setTestIsDeprecated(true);

    135. 

  135. 			$this->setDefaultFont(null);

    136. 

  136. 				

    137. 

  137. 			// initialisation du parsing

    138. 

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

    139. 

  139. 			$this->sub_html = null;

    140. 

  140. 			$this->sub_part	= false;

    141. 

  141. 				

    142. 

  142. 			// initialisation des marges

    143. 

  143. 			if (!is_array($marges)) $marges = array($marges, $marges, $marges, $marges);

    144. 

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

    145. 

  145. 			$this->setMargins();

    146. 

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

    147. 

  147. 

    148. 

  148. 			// initialisation des champs de formulaire

    149. 

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

    150. 

  150. 		}

    151. 

  151. 

    152. 

  152. 		/**

    153. 

  153. 		 * Destructeur

    154. 

  154. 		 *

    155. 

  155. 		 * @return	null

    156. 

  156. 		 */

    157. 

  157. 		public function __destruct()

    158. 

  158. 		{

    159. 

  159. 				

    160. 

  160. 		}

    161. 

  161. 

    162. 

  162. 		/**

    163. 

  163. 		 * activer le debug mode

    164. 

  164. 		 *

    165. 

  165. 		 * @return	null

    166. 

  166. 		 */

    167. 

  167. 		public function setModeDebug()

    168. 

  168. 		{

    169. 

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

    170. 

  170. 				

    171. 

  171. 			$this->DEBUG_actif = true;

    172. 

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

    173. 

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

    174. 

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

    175. 

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

    176. 

  176. 				

    177. 

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

    178. 

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

    179. 

  179. 		}

    180. 

  180. 

    181. 

  181. 		/**

    182. 

  182. 		 * rajouter une ligne de debug

    183. 

  183. 		 *

    184. 

  184. 		 * @param	string	nom de l'etape

    185. 

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

    186. 

  186. 		 * @return	null

    187. 

  187. 		 */

    188. 

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

    189. 

  189. 		{

    190. 

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

    191. 

  191. 			if ($level===true) $this->DEBUG_level++;

    192. 

  192. 

    193. 

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

    194. 

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

    195. 

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

    196. 

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

    197. 

  197. 

    198. 

  198. 			$this->DEBUG_stepline(

    199. 

  199. 			$nom,

    200. 

  200. 			number_format(($time - $this->DEBUG_start_time)*1000, 1, '.', ' ').' ms',

    201. 

  201. 			number_format(($time - $this->DEBUG_last_time)*1000, 1, '.', ' ').' ms',

    202. 

  202. 			number_format($usage/1024, 1, '.', ' ').' Ko',

    203. 

  203. 			number_format($peak/1024, 1, '.', ' ').' Ko');

    204. 

  204. 

    205. 

  205. 			$this->DEBUG_last_time = $time;

    206. 

  206. 			if ($level===false) $this->DEBUG_level--;

    207. 

  207. 			return true;

    208. 

  208. 		}

    209. 

  209. 

    210. 

  210. 		/**

    211. 

  211. 		 * affiche une ligne de debug

    212. 

  212. 		 *

    213. 

  213. 		 * @param	string	nom de l'etape

    214. 

  214. 		 * @param	string	valeur 1

    215. 

  215. 		 * @param	string	valeur 2

    216. 

  216. 		 * @param	string	valeur 3

    217. 

  217. 		 * @param	string	valeur 4

    218. 

  218. 		 * @return	null

    219. 

  219. 		 */

    220. 

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

    221. 

  221. 		{

    222. 

  222. 			$txt = str_pad($nom, 30, ' ', STR_PAD_RIGHT).

    223. 

  223. 			str_pad($val1, 12, ' ', STR_PAD_LEFT).

    224. 

  224. 			str_pad($val2, 12, ' ', STR_PAD_LEFT).

    225. 

  225. 			str_pad($val3, 15, ' ', STR_PAD_LEFT).

    226. 

  226. 			str_pad($val4, 15, ' ', STR_PAD_LEFT);

    227. 

  227. 				

    228. 

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

    229. 

  229. 		}

    230. 

  230. 

    231. 

  231. 		/**

    232. 

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

    233. 

  233. 		 *

    234. 

  234. 		 * @param	boolean	nouvel etat

    235. 

  235. 		 * @return	boolean ancien etat

    236. 

  236. 		 */

    237. 

  237. 		public function setTestTdInOnePage($mode = true)

    238. 

  238. 		{

    239. 

  239. 			$old = $this->testTDin1page;

    240. 

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

    241. 

  241. 			return $old;

    242. 

  242. 		}

    243. 

  243. 

    244. 

  244. 		/**

    245. 

  245. 		 * activer ou desactiver le test sur la prיsence des images

    246. 

  246. 		 *

    247. 

  247. 		 * @param	boolean	nouvel etat

    248. 

  248. 		 * @return	boolean ancien etat

    249. 

  249. 		 */

    250. 

  250. 		public function setTestIsImage($mode = true)

    251. 

  251. 		{

    252. 

  252. 			$old = $this->testIsImage;

    253. 

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

    254. 

  254. 			return $old;

    255. 

  255. 		}

    256. 

  256. 

    257. 

  257. 		/**

    258. 

  258. 		 * activer ou desactiver le test sur les fonctions deprecated

    259. 

  259. 		 *

    260. 

  260. 		 * @param	boolean	nouvel etat

    261. 

  261. 		 * @return	boolean ancien etat

    262. 

  262. 		 */

    263. 

  263. 		public function setTestIsDeprecated($mode = true)

    264. 

  264. 		{

    265. 

  265. 			$old = $this->testIsDeprecated;

    266. 

  266. 			$this->testIsDeprecated = $mode ? true : false;

    267. 

  267. 			return $old;

    268. 

  268. 		}

    269. 

  269. 

    270. 

  270. 		/**

    271. 

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

    272. 

  272. 		 *

    273. 

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

    274. 

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

    275. 

  275. 		 */

    276. 

  276. 		public function setDefaultFont($default = null)

    277. 

  277. 		{

    278. 

  278. 			$old = $this->defaultFont;

    279. 

  279. 			$this->defaultFont = $default;

    280. 

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

    281. 

  281. 			return $old;

    282. 

  282. 		}

    283. 

  283. 			

    284. 

  284. 		/**

    285. 

  285. 		 * dיfinir les marges par dיfault

    286. 

  286. 		 *

    287. 

  287. 		 * @param	int		en mm, marge left

    288. 

  288. 		 * @param	int		en mm, marge top

    289. 

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

    290. 

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

    291. 

  291. 		 * @return	null

    292. 

  292. 		 */

    293. 

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

    294. 

  294. 		{

    295. 

  295. 			if ($right===null)	$right = $left;

    296. 

  296. 			if ($bottom===null)	$bottom = 8;

    297. 

  297. 				

    298. 

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

    299. 

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

    300. 

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

    301. 

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

    302. 

  302. 		}

    303. 

  303. 

    304. 

  304. 		/**

    305. 

  305. 		 * dיfinir les marges rיelles, fonctions de la balise page

    306. 

  306. 		 *

    307. 

  307. 		 * @return	null

    308. 

  308. 		 */

    309. 

  309. 		protected function setMargins()

    310. 

  310. 		{

    311. 

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

    312. 

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

    313. 

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

    314. 

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

    315. 

  315. 				

    316. 

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

    317. 

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

    318. 

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

    319. 

  319. 				

    320. 

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

    321. 

  321. 			$this->pageMarges[floor($this->margeTop*100)] = array($this->margeLeft, $this->pdf->getW()-$this->margeRight);

    322. 

  322. 		}

    323. 

  323. 

    324. 

  324. 		/**

    325. 

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

    326. 

  326. 		 *

    327. 

  327. 		 * @param	float	y

    328. 

  328. 		 * @return	array(float, float)

    329. 

  329. 		 */

    330. 

  330. 		protected function getMargins($y)

    331. 

  331. 		{

    332. 

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

    333. 

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

    334. 

  334. 				

    335. 

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

    336. 

  336. 			if ($m_y<=$y) $x = $m_x;

    337. 

  337. 				

    338. 

  338. 			return $x;

    339. 

  339. 		}

    340. 

  340. 

    341. 

  341. 		/**

    342. 

  342. 		 * ajouter une marge suite a un float

    343. 

  343. 		 *

    344. 

  344. 		 * @param	string	left ou right

    345. 

  345. 		 * @param	float	x1

    346. 

  346. 		 * @param	float	y1

    347. 

  347. 		 * @param	float	x2

    348. 

  348. 		 * @param	float	y2

    349. 

  349. 		 * @return	null

    350. 

  350. 		 */

    351. 

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

    352. 

  352. 		{

    353. 

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

    354. 

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

    355. 

  355. 			if ($float=='left') $old1[0] = $x2;

    356. 

  356. 			if ($float=='right') $old1[1] = $x1;

    357. 

  357. 				

    358. 

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

    359. 

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

    360. 

  360. 

    361. 

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

    362. 

  362. 			{

    363. 

  363. 				if ($m_y<$y1) continue;

    364. 

  364. 				if ($m_y>$y2) break;

    365. 

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

    366. 

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

    367. 

  367. 			}

    368. 

  368. 

    369. 

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

    370. 

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

    371. 

  371. 				

    372. 

  372. 			ksort($this->pageMarges);

    373. 

  373. 				

    374. 

  374. 			$this->isAfterFloat = true;

    375. 

  375. 		}

    376. 

  376. 

    377. 

  377. 		/**

    378. 

  378. 		 * dיfinir des nouvelles marges et sauvegarder les anciennes

    379. 

  379. 		 *

    380. 

  380. 		 * @param	float	marge left

    381. 

  381. 		 * @param	float	marge top

    382. 

  382. 		 * @param	float	marge right

    383. 

  383. 		 * @return	null

    384. 

  384. 		 */

    385. 

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

    386. 

  386. 		{

    387. 

  387. 			$this->marges[] = array('l' => $this->pdf->getlMargin(), 't' => $this->pdf->gettMargin(), 'r' => $this->pdf->getrMargin(), 'page' => $this->pageMarges);

    388. 

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

    389. 

  389. 

    390. 

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

    391. 

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

    392. 

  392. 		}

    393. 

  393. 

    394. 

  394. 		/**

    395. 

  395. 		 * rיcuperer les derniטres marches sauvיes

    396. 

  396. 		 *

    397. 

  397. 		 * @return	null

    398. 

  398. 		 */

    399. 

  399. 		protected function loadMargin()

    400. 

  400. 		{

    401. 

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

    402. 

  402. 			if ($old)

    403. 

  403. 			{

    404. 

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

    405. 

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

    406. 

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

    407. 

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

    408. 

  408. 			}

    409. 

  409. 			else

    410. 

  410. 			{

    411. 

  411. 				$ml = $this->margeLeft;

    412. 

  412. 				$mt = 0;

    413. 

  413. 				$mr = $this->margeRight;

    414. 

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

    415. 

  415. 			}

    416. 

  416. 				

    417. 

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

    418. 

  418. 			$this->pageMarges = $mP;

    419. 

  419. 		}

    420. 

  420. 

    421. 

  421. 		/**

    422. 

  422. 		 * permet d'ajouter une fonte.

    423. 

  423. 		 *

    424. 

  424. 		 * @param	string nom de la fonte

    425. 

  425. 		 * @param	string style de la fonte

    426. 

  426. 		 * @param	string fichier de la fonte

    427. 

  427. 		 * @return	null

    428. 

  428. 		 */

    429. 

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

    430. 

  430. 		{

    431. 

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

    432. 

  432. 		}

    433. 

  433. 

    434. 

  434. 		/**

    435. 

  435. 		 * sauvegarder l'יtat actuelle des maximums

    436. 

  436. 		 *

    437. 

  437. 		 * @return	null

    438. 

  438. 		 */

    439. 

  439. 		protected function saveMax()

    440. 

  440. 		{

    441. 

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

    442. 

  442. 		}

    443. 

  443. 

    444. 

  444. 		/**

    445. 

  445. 		 * charger le dernier יtat sauvי des maximums

    446. 

  446. 		 *

    447. 

  447. 		 * @return	null

    448. 

  448. 		 */

    449. 

  449. 		protected function loadMax()

    450. 

  450. 		{

    451. 

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

    452. 

  452. 

    453. 

  453. 			if ($old)

    454. 

  454. 			{

    455. 

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

    456. 

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

    457. 

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

    458. 

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

    459. 

  459. 			}

    460. 

  460. 			else

    461. 

  461. 			{

    462. 

  462. 				$this->maxX = 0;

    463. 

  463. 				$this->maxY = 0;

    464. 

  464. 				$this->maxH = 0;

    465. 

  465. 				$this->maxE = 0;

    466. 

  466. 			}

    467. 

  467. 		}

    468. 

  468. 

    469. 

  469. 		/**

    470. 

  470. 		 * afficher l'header contenu dans page_header

    471. 

  471. 		 *

    472. 

  472. 		 * @return	null

    473. 

  473. 		 */

    474. 

  474. 		protected function setPageHeader()

    475. 

  475. 		{

    476. 

  476. 			if (!count($this->subHEADER)) return false;

    477. 

  477. 

    478. 

  478. 			$OLD_parse_pos = $this->parse_pos;

    479. 

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

    480. 

  480. 				

    481. 

  481. 			$this->parse_pos = 0;

    482. 

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

    483. 

  483. 			$this->makeHTMLcode();

    484. 

  484. 				

    485. 

  485. 			$this->parse_pos = 	$OLD_parse_pos;

    486. 

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

    487. 

  487. 		}

    488. 

  488. 

    489. 

  489. 		/**

    490. 

  490. 		 * afficher le footer contenu dans page_footer

    491. 

  491. 		 *

    492. 

  492. 		 * @return	null

    493. 

  493. 		 */

    494. 

  494. 		protected function setPageFooter()

    495. 

  495. 		{

    496. 

  496. 			if (!count($this->subFOOTER)) return false;

    497. 

  497. 

    498. 

  498. 			$OLD_parse_pos = $this->parse_pos;

    499. 

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

    500. 

  500. 				

    501. 

  501. 			$this->parse_pos = 0;

    502. 

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

    503. 

  503. 			$this->isInFooter = true;

    504. 

  504. 			$this->makeHTMLcode();

    505. 

  505. 			$this->isInFooter = false;

    506. 

  506. 				

    507. 

  507. 			$this->parse_pos = 	$OLD_parse_pos;

    508. 

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

    509. 

  509. 		}

    510. 

  510. 

    511. 

  511. 		/**

    512. 

  512. 		 * saut de ligne avec une hauteur spיcifique

    513. 

  513. 		 *

    514. 

  514. 		 * @param	float	hauteur de la ligne

    515. 

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

    516. 

  516. 		 * @return	null

    517. 

  517. 		 */

    518. 

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

    519. 

  519. 		{

    520. 

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

    521. 

  521. 				

    522. 

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

    523. 

  523. 		}

    524. 

  524. 			

    525. 

  525. 		/**

    526. 

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

    527. 

  527. 		 *

    528. 

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

    529. 

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

    530. 

  530. 		 * @param	array	tableau des propriיtיs du fond de la page

    531. 

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

    532. 

  532. 		 * @return	null

    533. 

  533. 		 */

    534. 

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

    535. 

  535. 		{

    536. 

  536. 			$this->firstPage = false;

    537. 

  537. 

    538. 

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

    539. 

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

    540. 

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

    541. 

  541. 			$this->maxY = 0;

    542. 

  542. 			$this->maxX = 0;

    543. 

  543. 			$this->maxH = 0;

    544. 

  544. 				

    545. 

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

    546. 

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

    547. 

  547. 			$this->page++;

    548. 

  548. 				

    549. 

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

    550. 

  550. 			{

    551. 

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

    552. 

  552. 				{

    553. 

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

    554. 

  554. 					{

    555. 

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

    556. 

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

    557. 

  557. 					}

    558. 

  558. 

    559. 

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

    560. 

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

    561. 

  561. 				}

    562. 

  562. 

    563. 

  563. 				$this->setPageHeader();

    564. 

  564. 				$this->setPageFooter();

    565. 

  565. 			}

    566. 

  566. 				

    567. 

  567. 			$this->setMargins();

    568. 

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

    569. 

  569. 				

    570. 

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

    571. 

  571. 			$this->maxH = 0;

    572. 

  572. 		}

    573. 

  573. 

    574. 

  574. 		/**

    575. 

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

    576. 

  576. 		 *

    577. 

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

    578. 

  578. 		 * @return	null

    579. 

  579. 		 */

    580. 

  580. 		protected function setNewPositionForNewLine($curr = null)

    581. 

  581. 		{

    582. 

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

    583. 

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

    584. 

  584. 			$wMax = $rx-$lx;

    585. 

  585. 			$this->currentH = 0;

    586. 

  586. 				

    587. 

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

    588. 

  588. 			{

    589. 

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

    590. 

  590. 				return null;

    591. 

  591. 			}

    592. 

  592. 			/*

    593. 

  593. 			 if (

    594. 

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

    595. 

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

    596. 

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

    597. 

  597. 				)

    598. 

  598. 				{

    599. 

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

    600. 

  600. 				return null;

    601. 

  601. 				}

    602. 

  602. 				*/

    603. 

  603. 			$sub = null;

    604. 

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

    605. 

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

    606. 

  606. 			$sub->forOneLine = true;

    607. 

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

    608. 

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

    609. 

  609. 				

    610. 

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

    611. 

  611. 			{

    612. 

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

    613. 

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

    614. 

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

    615. 

  615. 			}

    616. 

  616. 			else

    617. 

  617. 			$sub->parse_pos++;

    618. 

  618. 

    619. 

  619. 			// pour chaque element identifiי par le parsing

    620. 

  620. 			$res = null;

    621. 

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

    622. 

  622. 			{

    623. 

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

    624. 

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

    625. 

  625. 				if (!$res) break;

    626. 

  626. 			}

    627. 

  627. 

    628. 

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

    629. 

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

    630. 

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

    631. 

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

    632. 

  632. 				

    633. 

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

    634. 

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

    635. 

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

    636. 

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

    637. 

  637. 			else

    638. 

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

    639. 

  639. 				

    640. 

  640. 			$this->currentH = $h;

    641. 

  641. 			/*

    642. 

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

    643. 

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

    644. 

  644. 				else

    645. 

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

    646. 

  646. 				*/

    647. 

  647. 		}

    648. 

  648. 

    649. 

  649. 		/**

    650. 

  650. 		 * rיcupיration du PDF

    651. 

  651. 		 *

    652. 

  652. 		 * @param	string	nom du fichier PDF

    653. 

  653. 		 * @param	boolean	destination

    654. 

  654. 		 * @return	string	contenu יventuel du pdf

    655. 

  655. 		 *

    656. 

  656. 		 *

    657. 

  657. 		 * Destination oש envoyer le document. Le paramטtre peut prendre les valeurs suivantes :

    658. 

  658. 		 * true	: equivalent א I

    659. 

  659. 		 * false	: equivalent א S

    660. 

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

    661. 

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

    662. 

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

    663. 

  663. 		 * S : renvoyer le document sous forme de chaמne. name est ignorי.

    664. 

  664. 		 */

    665. 

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

    666. 

  666. 		{

    667. 

  667. 			// nettoyage

    668. 

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

    669. 

  669. 

    670. 

  670. 			if ($this->DEBUG_actif)

    671. 

  671. 			{

    672. 

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

    673. 

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

    674. 

  674. 				exit;

    675. 

  675. 			}

    676. 

  676. 				

    677. 

  677. 			// interpretation des paramטtres

    678. 

  678. 			if ($dest===false)	$dest = 'I';

    679. 

  679. 			if ($dest===true)	$dest = 'S';

    680. 

  680. 			if ($dest==='')		$dest = 'I';

    681. 

  681. 			if ($name=='')		$name='document.pdf';

    682. 

  682. 				

    683. 

  683. 			// verification de la destination

    684. 

  684. 			$dest = strtoupper($dest);

    685. 

  685. 			if (!in_array($dest, array('I', 'D', 'F', 'S'))) $dest = 'I';

    686. 

  686. 

    687. 

  687. 			// verification du nom

    688. 

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

    689. 

  689. 			{

    690. 

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

    691. 

  691. 				exit;

    692. 

  692. 			}

    693. 

  693. 				

    694. 

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

    695. 

  695. 		}

    696. 

  696. 

    697. 

  697. 		/**

    698. 

  698. 		 * preparation de HTML2PDF::$SUBOBJ utilisי pour la crיation des sous HTML2PDF

    699. 

  699. 		 *

    700. 

  700. 		 * @return	null

    701. 

  701. 		 */

    702. 

  702. 		protected function prepareSubObj()

    703. 

  703. 		{

    704. 

  704. 			$pdf = null;

    705. 

  705. 				

    706. 

  706. 			HTML2PDF::$SUBOBJ = new HTML2PDF(

    707. 

  707. 			$this->sens,

    708. 

  708. 			$this->format,

    709. 

  709. 			$this->langue,

    710. 

  710. 			$this->unicode,

    711. 

  711. 			$this->encoding,

    712. 

  712. 			array($this->defaultLeft,$this->defaultTop,$this->defaultRight,$this->defaultBottom)

    713. 

  713. 			);

    714. 

  714. 

    715. 

  715. 			// initialisation

    716. 

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

    717. 

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

    718. 

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

    719. 

  719. 			HTML2PDF::$SUBOBJ->setTestIsDeprecated($this->testIsDeprecated);

    720. 

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

    721. 

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

    722. 

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

    723. 

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

    724. 

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

    725. 

  725. 		}

    726. 

  726. 			

    727. 

  727. 		/**

    728. 

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

    729. 

  729. 		 *

    730. 

  730. 		 * @return	null

    731. 

  731. 		 */

    732. 

  732. 		public function __clone()

    733. 

  733. 		{

    734. 

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

    735. 

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

    736. 

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

    737. 

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

    738. 

  738. 		}

    739. 

  739. 

    740. 

  740. 		/**

    741. 

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

    742. 

  742. 		 *

    743. 

  743. 		 * @param	HTML2PDF	futur sous HTML2PDF passי en rיfיrence pour crיation

    744. 

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

    745. 

  745. 		 * @return	null

    746. 

  746. 		 */

    747. 

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

    748. 

  748. 		{

    749. 

  749. 			if (!HTML2PDF::$SUBOBJ) $this->prepareSubObj();

    750. 

  750. 				

    751. 

  751. 			// calcul de la largueur

    752. 

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

    753. 

  753. 			{

    754. 

  754. 				$marge = $cellmargin*2;

    755. 

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

    756. 

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

    757. 

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

    758. 

  758. 			}

    759. 

  759. 			else

    760. 

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

    761. 

  761. 				

    762. 

  762. 			//clonage

    763. 

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

    764. 

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

    765. 

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

    766. 

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

    767. 

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

    768. 

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

    769. 

  769. 		}

    770. 

  770. 

    771. 

  771. 		/**

    772. 

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

    773. 

  773. 		 *

    774. 

  774. 		 * @return	null

    775. 

  775. 		 */

    776. 

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

    777. 

  777. 		{

    778. 

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

    779. 

  779. 			$this->defLIST = $defLIST;

    780. 

  780. 				

    781. 

  781. 			$this->page = $page;

    782. 

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

    783. 

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

    784. 

  784. 		}

    785. 

  785. 

    786. 

  786. 		public function setIsSubPart()

    787. 

  787. 		{

    788. 

  788. 			$this->isSubPart = true;

    789. 

  789. 		}

    790. 

  790. 

    791. 

  791. 		/**

    792. 

  792. 		 * destruction d'un sous HTML2PDF pour la gestion des tableaux imbriquיs

    793. 

  793. 		 *

    794. 

  794. 		 * @return	null

    795. 

  795. 		 */

    796. 

  796. 		protected function destroySubHTML(&$sub_html)

    797. 

  797. 		{

    798. 

  798. 			unset($sub_html);

    799. 

  799. 			$sub_html = null;

    800. 

  800. 		}

    801. 

  801. 

    802. 

  802. 		/**

    803. 

  803. 		 * Convertir un nombre arabe en nombre romain

    804. 

  804. 		 *

    805. 

  805. 		 * @param	integer	nombre א convertir

    806. 

  806. 		 * @return	string	nombre converti

    807. 

  807. 		 */

    808. 

  808. 		protected function listeArab2Rom($nb_ar)

    809. 

  809. 		{

    810. 

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

    811. 

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

    812. 

  812. 			$nb_ro	= '';

    813. 

  813. 

    814. 

  814. 			if ($nb_ar<1)		return $nb_ar;

    815. 

  815. 			if ($nb_ar>3999)	return $nb_ar;

    816. 

  816. 

    817. 

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

    818. 

  818. 			{

    819. 

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

    820. 

  820. 				if($chiffre>=1)

    821. 

  821. 				{

    822. 

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

    823. 

  823. 					if($chiffre<=3)

    824. 

  824. 					{

    825. 

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

    826. 

  826. 						{

    827. 

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

    828. 

  828. 						}

    829. 

  829. 					}

    830. 

  830. 					else if($chiffre==9)

    831. 

  831. 					{

    832. 

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

    833. 

  833. 					}

    834. 

  834. 					elseif($chiffre==4)

    835. 

  835. 					{

    836. 

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

    837. 

  837. 					}

    838. 

  838. 					else

    839. 

  839. 					{

    840. 

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

    841. 

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

    842. 

  842. 						{

    843. 

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

    844. 

  844. 						}

    845. 

  845. 					}

    846. 

  846. 				}

    847. 

  847. 			}

    848. 

  848. 			return $nb_ro;

    849. 

  849. 		}

    850. 

  850. 

    851. 

  851. 		/**

    852. 

  852. 		 * Ajouter un LI au niveau actuel

    853. 

  853. 		 *

    854. 

  854. 		 * @return	null

    855. 

  855. 		 */

    856. 

  856. 		protected function listeAddLi()

    857. 

  857. 		{

    858. 

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

    859. 

  859. 		}

    860. 

  860. 

    861. 

  861. 		protected function listeGetWidth() { return '7mm'; }

    862. 

  862. 		protected function listeGetPadding() { return '1mm'; }

    863. 

  863. 

    864. 

  864. 		/**

    865. 

  865. 		 * Recuperer le LI du niveau actuel

    866. 

  866. 		 *

    867. 

  867. 		 * @return	string	chaine א afficher

    868. 

  868. 		 */

    869. 

  869. 		protected function listeGetLi()

    870. 

  870. 		{

    871. 

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

    872. 

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

    873. 

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

    874. 

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

    875. 

  875. 				

    876. 

  876. 			if ($im) return array(false, false, $im);

    877. 

  877. 				

    878. 

  878. 			switch($st)

    879. 

  879. 			{

    880. 

  880. 				case 'none':

    881. 

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

    882. 

  882. 						

    883. 

  883. 				case 'upper-alpha':

    884. 

  884. 				case 'lower-alpha':

    885. 

  885. 					$str = '';

    886. 

  886. 					while($nb>26)

    887. 

  887. 					{

    888. 

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

    889. 

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

    890. 

  890. 					}

    891. 

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

    892. 

  892. 						

    893. 

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

    894. 

  894. 

    895. 

  895. 				case 'upper-roman':

    896. 

  896. 				case 'lower-roman':

    897. 

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

    898. 

  898. 						

    899. 

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

    900. 

  900. 						

    901. 

  901. 				case 'decimal':

    902. 

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

    903. 

  903. 

    904. 

  904. 				case 'square':

    905. 

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

    906. 

  906. 

    907. 

  907. 				case 'circle':

    908. 

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

    909. 

  909. 

    910. 

  910. 				case 'disc':

    911. 

  911. 				default:

    912. 

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

    913. 

  913. 			}

    914. 

  914. 		}

    915. 

  915. 

    916. 

  916. 		/**

    917. 

  917. 		 * Ajouter un niveau de liste

    918. 

  918. 		 *

    919. 

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

    920. 

  920. 		 * @param	string	style de la liste

    921. 

  921. 		 * @return	null

    922. 

  922. 		 */

    923. 

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

    924. 

  924. 		{

    925. 

  925. 			if ($img)

    926. 

  926. 			{

    927. 

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

    928. 

  928. 				$img = $match[1];

    929. 

  929. 				else

    930. 

  930. 				$img = null;

    931. 

  931. 			}

    932. 

  932. 			else

    933. 

  933. 			$img = null;

    934. 

  934. 				

    935. 

  935. 			if (!in_array($type, array('ul', 'ol'))) $type = 'ul';

    936. 

  936. 			if (!in_array($style, array('lower-alpha', 'upper-alpha', 'upper-roman', 'lower-roman', 'decimal', 'square', 'circle', 'disc', 'none'))) $style = '';

    937. 

  937. 				

    938. 

  938. 			if (!$style)

    939. 

  939. 			{

    940. 

  940. 				if ($type=='ul')	$style = 'disc';

    941. 

  941. 				else				$style = 'decimal';

    942. 

  942. 			}

    943. 

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

    944. 

  944. 		}

    945. 

  945. 

    946. 

  946. 		/**

    947. 

  947. 		 * Supprimer un niveau de liste

    948. 

  948. 		 *

    949. 

  949. 		 * @return	null

    950. 

  950. 		 */

    951. 

  951. 		protected function listeDelLevel()

    952. 

  952. 		{

    953. 

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

    954. 

  954. 			{

    955. 

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

    956. 

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

    957. 

  957. 			}

    958. 

  958. 		}

    959. 

  959. 

    960. 

  960. 		/**

    961. 

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

    962. 

  962. 		 *

    963. 

  963. 		 * @param	string	code HTML א convertir

    964. 

  964. 		 * @param	boolean	afficher en pdf (false) ou en html adaptי (true)

    965. 

  965. 		 * @return	null

    966. 

  966. 		 */

    967. 

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

    968. 

  968. 		{

    969. 

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

    970. 

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

    971. 

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

    972. 

  972. 

    973. 

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

    974. 

  974. 				

    975. 

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

    976. 

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

    977. 

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

    978. 

  978. 

    979. 

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

    980. 

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

    981. 

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

    982. 

  982. 				

    983. 

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

    984. 

  984. 			if ($vue)	$this->vueHTML($html);

    985. 

  985. 

    986. 

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

    987. 

  987. 			// parsing

    988. 

  988. 			$this->sub_pdf = false;

    989. 

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

    990. 

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

    991. 

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

    992. 

  992. 			$this->makeHTMLcode();

    993. 

  993. 		}

    994. 

  994. 			

    995. 

  995. 		/**

    996. 

  996. 		 * traitement du code d'une vrai page HTML pour l'adapter א HTML2PDF

    997. 

  997. 		 *

    998. 

  998. 		 * @param	string	code HTML א adapter

    999. 

  999. 		 * @return	string	code HTML adaptי

    1000. 

  1000. 		 */

    1001. 

  1001. 		public function getHtmlFromPage($html)

    1002. 

  1002. 		{

    1003. 

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

    1004. 

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

    1005. 

  1005. 				

    1006. 

  1006. 			// extraction du contenu

    1007. 

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

    1008. 

  1008. 			if (count($res)<2) return $html;

    1009. 

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

    1010. 

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

    1011. 

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

    1012. 

  1012. 

    1013. 

  1013. 			// extraction des balises link

    1014. 

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

    1015. 

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

    1016. 

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

    1017. 

  1017. 				

    1018. 

  1018. 			// extraction des balises style

    1019. 

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

    1020. 

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

    1021. 

  1021. 			$content = $src.$content;

    1022. 

  1022. 

    1023. 

  1023. 			return $content;

    1024. 

  1024. 		}

    1025. 

  1025. 

    1026. 

  1026. 		/**

    1027. 

  1027. 		 * execute les diffיrentes actions du code HTML

    1028. 

  1028. 		 *

    1029. 

  1029. 		 * @return	null

    1030. 

  1030. 		 */

    1031. 

  1031. 		protected function makeHTMLcode()

    1032. 

  1032. 		{

    1033. 

  1033. 			// pour chaque element identifiי par le parsing

    1034. 

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

    1035. 

  1035. 			{

    1036. 

  1036. 				// rיcupיration de l'יlיment

    1037. 

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

    1038. 

  1038. 

    1039. 

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

    1040. 

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

    1041. 

  1041. 				{

    1042. 

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

    1043. 

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

    1044. 

  1044. 

    1045. 

  1045. 					$this->sub_part = true;

    1046. 

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

    1047. 

  1047. 						

    1048. 

  1048. 					// pour tous les יlיments jusqu'א la fermeture de la table afin de prיparer les dimensions

    1049. 

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

    1050. 

  1050. 					{

    1051. 

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

    1052. 

  1052. 						$this->temp_pos++;

    1053. 

  1053. 					}

    1054. 

  1054. 					if (isset($this->parsing->code[$this->temp_pos])) 	$this->loadAction($this->parsing->code[$this->temp_pos]);

    1055. 

  1055. 					$this->sub_part = false;

    1056. 

  1056. 				}

    1057. 

  1057. 

    1058. 

  1058. 				// chargement de l'action correspondant א l'יlיment

    1059. 

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

    1060. 

  1060. 			}

    1061. 

  1061. 		}

    1062. 

  1062. 

    1063. 

  1063. 

    1064. 

  1064. 

    1065. 

  1065. 		/**

    1066. 

  1066. 		 * affichage en mode HTML du contenu

    1067. 

  1067. 		 *

    1068. 

  1068. 		 * @param	string	contenu

    1069. 

  1069. 		 * @return	null

    1070. 

  1070. 		 */

    1071. 

  1071. 		protected function vueHTML($content)

    1072. 

  1072. 		{

    1073. 

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

    1074. 

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

    1075. 

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

    1076. 

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

    1077. 

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

    1078. 

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

    1079. 

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

    1080. 

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

    1081. 

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

    1082. 

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

    1083. 

  1083. 				

    1084. 

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

    1085. 

  1085. <html>

    1086. 

  1086. 	<head>

    1087. 

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

    1088. 

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

    1089. 

  1089. 	</head>

    1090. 

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

    1091. 

  1091. '.$content.'

    1092. 

  1092. 	</body>

    1093. 

  1093. </html>';

    1094. 

  1094. 			exit;

    1095. 

  1095. 		}

    1096. 

  1096. 

    1097. 

  1097. 		/**

    1098. 

  1098. 		 * chargement de l'action correspondante א un element de parsing

    1099. 

  1099. 		 *

    1100. 

  1100. 		 * @param	array	יlיment de parsing

    1101. 

  1101. 		 * @return	null

    1102. 

  1102. 		 */

    1103. 

  1103. 		protected function loadAction($row)

    1104. 

  1104. 		{

    1105. 

  1105. 			// nom de l'action

    1106. 

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

    1107. 

  1107. 				

    1108. 

  1108. 			// parametres de l'action

    1109. 

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

    1110. 

  1110. 				

    1111. 

  1111. 			// si aucune page n'est crיי, on la crיי

    1112. 

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

    1113. 

  1113. 			{

    1114. 

  1114. 				$this->setNewPage();

    1115. 

  1115. 			}

    1116. 

  1116. 				

    1117. 

  1117. 			// lancement de l'action

    1118. 

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

    1119. 

  1119. 			{

    1120. 

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

    1121. 

  1121. 				$this->previousCall = $fnc;

    1122. 

  1122. 				return $res;

    1123. 

  1123. 			}

    1124. 

  1124. 			else

    1125. 

  1125. 			throw new HTML2PDF_exception(1, strtoupper($row['name']), $this->parsing->getHtmlErrorCode($row['html_pos']));

    1126. 

  1126. 		}

    1127. 

  1127. 

    1128. 

  1128. 		/**

    1129. 

  1129. 		 * balise	: PAGE

    1130. 

  1130. 		 * mode		: OUVERTURE

    1131. 

  1131. 		 *

    1132. 

  1132. 		 * @param	array	paramטtres de l'יlיment de parsing

    1133. 

  1133. 		 * @return	null

    1134. 

  1134. 		 */

    1135. 

  1135. 		protected function o_PAGE($param)

    1136. 

  1136. 		{

    1137. 

  1137. 			if ($this->forOneLine) return false;

    1138. 

  1138. 			if ($this->DEBUG_actif) $this->DEBUG_add('PAGE n°'.($this->page+1), true);

    1139. 

  1139. 

    1140. 

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

    1141. 

  1141. 				

    1142. 

  1142. 			$this->maxH = 0;

    1143. 

  1143. 			if ($newPageSet)

    1144. 

  1144. 			{

    1145. 

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

    1146. 

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

    1147. 

  1147. 

    1148. 

  1148. 				// identification de l'orientation demandיe

    1149. 

  1149. 				$orientation = '';

    1150. 

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

    1151. 

  1151. 				{

    1152. 

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

    1153. 

  1153. 					if ($param['orientation']=='p')			$orientation = 'P';

    1154. 

  1154. 					if ($param['orientation']=='portrait')	$orientation = 'P';

    1155. 

  1155. 

    1156. 

  1156. 					if ($param['orientation']=='l')			$orientation = 'L';

    1157. 

  1157. 					if ($param['orientation']=='paysage')	$orientation = 'L';

    1158. 

  1158. 					if ($param['orientation']=='landscape')	$orientation = 'L';

    1159. 

  1159. 				}

    1160. 

  1160. 

    1161. 

  1161. 				// identification de l'orientation demandיe

    1162. 

  1162. 				$format = null;

    1163. 

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

    1164. 

  1164. 				{

    1165. 

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

    1166. 

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

    1167. 

  1167. 					{

    1168. 

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

    1169. 

  1169. 					}

    1170. 

  1170. 				}

    1171. 

  1171. 					

    1172. 

  1172. 				// identification des propriיtיs du background

    1173. 

  1173. 				$background = array();

    1174. 

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

    1175. 

  1175. 				{

    1176. 

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

    1177. 

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

    1178. 

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

    1179. 

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

    1180. 

  1180. 						

    1181. 

  1181. 					// conversion du nom de l'image, en cas de paramטtres en _GET

    1182. 

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

    1183. 

  1183. 					// conversion des positions

    1184. 

  1184. 					if ($background['posX']=='left')	$background['posX'] = '0%';

    1185. 

  1185. 					if ($background['posX']=='center')	$background['posX'] = '50%';

    1186. 

  1186. 					if ($background['posX']=='right')	$background['posX'] = '100%';

    1187. 

  1187. 					if ($background['posY']=='top')		$background['posY'] = '0%';

    1188. 

  1188. 					if ($background['posY']=='middle')	$background['posY'] = '50%';

    1189. 

  1189. 					if ($background['posY']=='bottom')	$background['posY'] = '100%';

    1190. 

  1190. 

    1191. 

  1191. 

    1192. 

  1192. 					// si il y a une image de prיcisי

    1193. 

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

    1194. 

  1194. 					{

    1195. 

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

    1196. 

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

    1197. 

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

    1198. 

  1198. 						{

    1199. 

  1199. 							// taille de l'image, en fonction de la taille spיcifiיe.

    1200. 

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

    1201. 

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

    1202. 

  1202. 								

    1203. 

  1203. 							// rיcupיration des dimensions et positions de l'image

    1204. 

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

    1205. 

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

    1206. 

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

    1207. 

  1207. 						}

    1208. 

  1208. 						else

    1209. 

  1209. 						$background = array();

    1210. 

  1210. 					}

    1211. 

  1211. 					else

    1212. 

  1212. 					$background = array();

    1213. 

  1213. 				}

    1214. 

  1214. 

    1215. 

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

    1216. 

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

    1217. 

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

    1218. 

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

    1219. 

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

    1220. 

  1220. 

    1221. 

  1221. 				if (preg_match('/^([0-9]*)$/isU', $background['top']))		$background['top']		.= 'mm';

    1222. 

  1222. 				if (preg_match('/^([0-9]*)$/isU', $background['bottom']))	$background['bottom']	.= 'mm';

    1223. 

  1223. 				if (preg_match('/^([0-9]*)$/isU', $background['left']))		$background['left']		.= 'mm';

    1224. 

  1224. 				if (preg_match('/^([0-9]*)$/isU', $background['right']))	$background['right']	.= 'mm';

    1225. 

  1225. 

    1226. 

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

    1227. 

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

    1228. 

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

    1229. 

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

    1230. 

  1230. 

    1231. 

  1231. 				$res = false;

    1232. 

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

    1233. 

  1233. 				if (!$res) $background['color'] = null;

    1234. 

  1234. 

    1235. 

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

    1236. 

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

    1237. 

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

    1238. 

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

    1239. 

  1239. 

    1240. 

  1240. 				// nouvelle page

    1241. 

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

    1242. 

  1242. 

    1243. 

  1243. 				// footer automatique

    1244. 

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

    1245. 

  1245. 				{

    1246. 

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

    1247. 

  1247. 					foreach($lst as $key => $val) $lst[$key] = trim(strtolower($val));

    1248. 

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

    1249. 

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

    1250. 

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

    1251. 

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

    1252. 

  1252. 				}

    1253. 

  1253. 				else

    1254. 

  1254. 				{

    1255. 

  1255. 					$page	= null;

    1256. 

  1256. 					$date	= null;

    1257. 

  1257. 					$heure	= null;

    1258. 

  1258. 					$form	= null;

    1259. 

  1259. 				}

    1260. 

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

    1261. 

  1261. 			}

    1262. 

  1262. 			else

    1263. 

  1263. 			{

    1264. 

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

    1265. 

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

    1266. 

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

    1267. 

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

    1268. 

  1268. 

    1269. 

  1269. 				$this->setNewPage();

    1270. 

  1270. 			}

    1271. 

  1271. 				

    1272. 

  1272. 			return true;

    1273. 

  1273. 		}

    1274. 

  1274. 

    1275. 

  1275. 		/**

    1276. 

  1276. 		 * balise : PAGE

    1277. 

  1277. 		 * mode : FERMETURE

    1278. 

  1278. 		 *

    1279. 

  1279. 		 * @param	array	paramטtres de l'יlיment de parsing

    1280. 

  1280. 		 * @return	null

    1281. 

  1281. 		 */

    1282. 

  1282. 		protected function c_PAGE($param)

    1283. 

  1283. 		{

    1284. 

  1284. 			if ($this->forOneLine) return false;

    1285. 

  1285. 

    1286. 

  1286. 			$this->maxH = 0;

    1287. 

  1287. 

    1288. 

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

    1289. 

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

    1290. 

  1290. 				

    1291. 

  1291. 			if ($this->DEBUG_actif) $this->DEBUG_add('PAGE n°'.$this->page, false);

    1292. 

  1292. 				

    1293. 

  1293. 			return true;

    1294. 

  1294. 		}

    1295. 

  1295. 

    1296. 

  1296. 

    1297. 

  1297. 		protected function o_PAGE_HEADER($param)

    1298. 

  1298. 		{

    1299. 

  1299. 			if ($this->forOneLine) return false;

    1300. 

  1300. 

    1301. 

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

    1302. 

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

    1303. 

  1303. 			{

    1304. 

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

    1305. 

  1305. 				if ($todo['name']=='page_header') $todo['name']='page_header_sub';

    1306. 

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

    1307. 

  1307. 				if (strtolower($todo['name'])=='page_header_sub' && $todo['close']) break;

    1308. 

  1308. 			}

    1309. 

  1309. 

    1310. 

  1310. 			$this->setPageHeader();

    1311. 

  1311. 				

    1312. 

  1312. 			return true;

    1313. 

  1313. 		}

    1314. 

  1314. 

    1315. 

  1315. 		protected function o_PAGE_FOOTER($param)

    1316. 

  1316. 		{

    1317. 

  1317. 			if ($this->forOneLine) return false;

    1318. 

  1318. 

    1319. 

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

    1320. 

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

    1321. 

  1321. 			{

    1322. 

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

    1323. 

  1323. 				if ($todo['name']=='page_footer') $todo['name']='page_footer_sub';

    1324. 

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

    1325. 

  1325. 				if (strtolower($todo['name'])=='page_footer_sub' && $todo['close']) break;

    1326. 

  1326. 			}

    1327. 

  1327. 				

    1328. 

  1328. 			$this->setPageFooter();

    1329. 

  1329. 				

    1330. 

  1330. 			return true;

    1331. 

  1331. 		}

    1332. 

  1332. 

    1333. 

  1333. 		protected function o_PAGE_HEADER_SUB($param)

    1334. 

  1334. 		{

    1335. 

  1335. 			if ($this->forOneLine) return false;

    1336. 

  1336. 

    1337. 

  1337. 			// sauvegarde de l'יtat

    1338. 

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

    1339. 

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

    1340. 

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

    1341. 

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

    1342. 

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

    1343. 

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

    1344. 

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

    1345. 

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

    1346. 

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

    1347. 

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

    1348. 

  1348. 

    1349. 

  1349. 			// nouvel etat pour le footer

    1350. 

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

    1351. 

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

    1352. 

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

    1353. 

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

    1354. 

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

    1355. 

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

    1356. 

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

    1357. 

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

    1358. 

  1358. 				

    1359. 

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

    1360. 

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

    1361. 

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

    1362. 

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

    1363. 

  1363. 

    1364. 

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

    1365. 

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

    1366. 

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

    1367. 

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

    1368. 

  1368. 			$this->setNewPositionForNewLine();

    1369. 

  1369. 			return true;

    1370. 

  1370. 		}

    1371. 

  1371. 

    1372. 

  1372. 		protected function c_PAGE_HEADER_SUB($param)

    1373. 

  1373. 		{

    1374. 

  1374. 			if ($this->forOneLine) return false;

    1375. 

  1375. 

    1376. 

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

    1377. 

  1377. 

    1378. 

  1378. 			// retablissement de l'etat

    1379. 

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

    1380. 

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

    1381. 

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

    1382. 

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

    1383. 

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

    1384. 

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

    1385. 

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

    1386. 

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

    1387. 

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

    1388. 

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

    1389. 

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

    1390. 

  1390. 				

    1391. 

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

    1392. 

  1392. 			$this->maxH = 0;

    1393. 

  1393. 				

    1394. 

  1394. 			return true;

    1395. 

  1395. 		}

    1396. 

  1396. 

    1397. 

  1397. 		protected function o_PAGE_FOOTER_SUB($param)

    1398. 

  1398. 		{

    1399. 

  1399. 			if ($this->forOneLine) return false;

    1400. 

  1400. 

    1401. 

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

    1402. 

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

    1403. 

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

    1404. 

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

    1405. 

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

    1406. 

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

    1407. 

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

    1408. 

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

    1409. 

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

    1410. 

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

    1411. 

  1411. 

    1412. 

  1412. 			// nouvel etat pour le footer

    1413. 

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

    1414. 

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

    1415. 

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

    1416. 

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

    1417. 

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

    1418. 

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

    1419. 

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

    1420. 

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

    1421. 

  1421. 				

    1422. 

  1422. 

    1423. 

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

    1424. 

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

    1425. 

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

    1426. 

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

    1427. 

  1427. 

    1428. 

  1428. 			// on en crיי un sous HTML que l'on transforme en PDF

    1429. 

  1429. 			// pour rיcupיrer la hauteur

    1430. 

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

    1431. 

  1431. 			$sub = null;

    1432. 

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

    1433. 

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

    1434. 

  1434. 			$sub->MakeHTMLcode();

    1435. 

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

    1436. 

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

    1437. 

  1437. 				

    1438. 

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

    1439. 

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

    1440. 

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

    1441. 

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

    1442. 

  1442. 			$this->setNewPositionForNewLine();

    1443. 

  1443. 				

    1444. 

  1444. 			return true;

    1445. 

  1445. 		}

    1446. 

  1446. 

    1447. 

  1447. 		protected function c_PAGE_FOOTER_SUB($param)

    1448. 

  1448. 		{

    1449. 

  1449. 			if ($this->forOneLine) return false;

    1450. 

  1450. 

    1451. 

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

    1452. 

  1452. 

    1453. 

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

    1454. 

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

    1455. 

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

    1456. 

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

    1457. 

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

    1458. 

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

    1459. 

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

    1460. 

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

    1461. 

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

    1462. 

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

    1463. 

  1463. 

    1464. 

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

    1465. 

  1465. 			$this->maxH = 0;

    1466. 

  1466. 				

    1467. 

  1467. 			return true;

    1468. 

  1468. 		}

    1469. 

  1469. 

    1470. 

  1470. 		/**

    1471. 

  1471. 		 * balise : NOBREAK

    1472. 

  1472. 		 * mode : OUVERTURE

    1473. 

  1473. 		 *

    1474. 

  1474. 		 * @param	array	paramטtres de l'יlיment de parsing

    1475. 

  1475. 		 * @return	null

    1476. 

  1476. 		 */

    1477. 

  1477. 		protected function o_NOBREAK($param)

    1478. 

  1478. 		{

    1479. 

  1479. 			if ($this->forOneLine) return false;

    1480. 

  1480. 

    1481. 

  1481. 			$this->maxH = 0;

    1482. 

  1482. 

    1483. 

  1483. 			// on en crיי un sous HTML que l'on transforme en PDF

    1484. 

  1484. 			// pour analyse les dimensions

    1485. 

  1485. 			// et voir si ca rentre

    1486. 

  1486. 			$sub = null;

    1487. 

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

    1488. 

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

    1489. 

  1489. 			$sub->MakeHTMLcode();

    1490. 

  1490. 				

    1491. 

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

    1492. 

  1492. 			if (

    1493. 

  1493. 			$sub->maxY < ($this->pdf->getH() - $this->pdf->gettMargin()-$this->pdf->getbMargin()) &&

    1494. 

  1494. 			$y + $sub->maxY>=($this->pdf->getH() - $this->pdf->getbMargin())

    1495. 

  1495. 			)

    1496. 

  1496. 			$this->setNewPage();

    1497. 

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

    1498. 

  1498. 				

    1499. 

  1499. 			return true;

    1500. 

  1500. 		}

    1501. 

  1501. 

    1502. 

  1502. 

    1503. 

  1503. 		/**

    1504. 

  1504. 		 * balise : NOBREAK

    1505. 

  1505. 		 * mode : FERMETURE

    1506. 

  1506. 		 *

    1507. 

  1507. 		 * @param	array	paramטtres de l'יlיment de parsing

    1508. 

  1508. 		 * @return	null

    1509. 

  1509. 		 */

    1510. 

  1510. 		protected function c_NOBREAK($param)

    1511. 

  1511. 		{

    1512. 

  1512. 			if ($this->forOneLine) return false;

    1513. 

  1513. 

    1514. 

  1514. 			$this->maxH = 0;

    1515. 

  1515. 				

    1516. 

  1516. 			return true;

    1517. 

  1517. 		}

    1518. 

  1518. 

    1519. 

  1519. 		/**

    1520. 

  1520. 		 * balise : DIV

    1521. 

  1521. 		 * mode : OUVERTURE

    1522. 

  1522. 		 *

    1523. 

  1523. 		 * @param	array	paramטtres de l'יlיment de parsing

    1524. 

  1524. 		 * @return	null

    1525. 

  1525. 		 */

    1526. 

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

    1527. 

  1527. 		{

    1528. 

  1528. 			if ($this->forOneLine) return false;

    1529. 

  1529. 			if ($this->DEBUG_actif) $this->DEBUG_add(strtoupper($other), true);

    1530. 

  1530. 				

    1531. 

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

    1532. 

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

    1533. 

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

    1534. 

  1534. 				

    1535. 

  1535. 			// gestion specifique a la balise legend pour l'afficher au bon endroit

    1536. 

  1536. 			if (in_array($other, array('fieldset', 'legend')))

    1537. 

  1537. 			{

    1538. 

  1538. 				if (isset($param['moveTop']))	$this->style->value['margin']['t']	+= $param['moveTop'];

    1539. 

  1539. 				if (isset($param['moveLeft']))	$this->style->value['margin']['l']	+= $param['moveLeft'];

    1540. 

  1540. 				if (isset($param['moveDown']))	$this->style->value['margin']['b']	+= $param['moveDown'];

    1541. 

  1541. 			}

    1542. 

  1542. 				

    1543. 

  1543. 			$align_object = null;

    1544. 

  1544. 			if ($this->style->value['margin-auto']) $align_object = 'center';

    1545. 

  1545. 

    1546. 

  1546. 			$marge = array();

    1547. 

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

    1548. 

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

    1549. 

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

    1550. 

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

    1551. 

  1551. 				

    1552. 

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

    1553. 

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

    1554. 

  1554. 

    1555. 

  1555. 			// on en crיי un sous HTML que l'on transforme en PDF

    1556. 

  1556. 			// pour analyse les dimensions

    1557. 

  1557. 			$w = 0; $h = 0;

    1558. 

  1558. 			if (count($level))

    1559. 

  1559. 			{

    1560. 

  1560. 				$sub = null;

    1561. 

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

    1562. 

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

    1563. 

  1563. 				$sub->MakeHTMLcode();

    1564. 

  1564. 				$w = $sub->maxX;

    1565. 

  1565. 				$h = $sub->maxY;

    1566. 

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

    1567. 

  1567. 			}…
    1568.